// SPDX-License-Identifier: GPL-2.0
#define USE_HW_I2C
#ifdef USE_HW_I2C
#include "ddk750_chip.h"
#include "ddk750_reg.h"
#include "ddk750_hwi2c.h"
#include "ddk750_power.h"

#define MAX_HWI2C_FIFO                  16
#define HWI2C_WAIT_TIMEOUT              0xF0000

int sm750_hw_i2c_init(unsigned char bus_speed_mode)
{
        unsigned int value;

        /* Enable GPIO 30 & 31 as IIC clock & data */
        value = peek32(GPIO_MUX);

        value |= (GPIO_MUX_30 | GPIO_MUX_31);
        poke32(GPIO_MUX, value);

        /*
         * Enable Hardware I2C power.
         * TODO: Check if we need to enable GPIO power?
         */
        sm750_enable_i2c(1);

        /* Enable the I2C Controller and set the bus speed mode */
        value = peek32(I2C_CTRL) & ~(I2C_CTRL_MODE | I2C_CTRL_EN);
        if (bus_speed_mode)
                value |= I2C_CTRL_MODE;
        value |= I2C_CTRL_EN;
        poke32(I2C_CTRL, value);

        return 0;
}

void sm750_hw_i2c_close(void)
{
        unsigned int value;

        /* Disable I2C controller */
        value = peek32(I2C_CTRL) & ~I2C_CTRL_EN;
        poke32(I2C_CTRL, value);

        /* Disable I2C Power */
        sm750_enable_i2c(0);

        /* Set GPIO 30 & 31 back as GPIO pins */
        value = peek32(GPIO_MUX);
        value &= ~GPIO_MUX_30;
        value &= ~GPIO_MUX_31;
        poke32(GPIO_MUX, value);
}

static long hw_i2c_wait_tx_done(void)
{
        unsigned int timeout;

        /* Wait until the transfer is completed. */
        timeout = HWI2C_WAIT_TIMEOUT;
        while (!(peek32(I2C_STATUS) & I2C_STATUS_TX) && (timeout != 0))
                timeout--;

        if (timeout == 0)
                return -1;

        return 0;
}

/*
 *  This function writes data to the i2c slave device registers.
 *
 *  Parameters:
 *      addr            - i2c Slave device address
 *      length          - Total number of bytes to be written to the device
 *      buf             - The buffer that contains the data to be written to the
 *                     i2c device.
 *
 *  Return Value:
 *      Total number of bytes those are actually written.
 */
static unsigned int hw_i2c_write_data(unsigned char addr,
                                      unsigned int length,
                                      unsigned char *buf)
{
        unsigned char count, i;
        unsigned int total_bytes = 0;

        /* Set the Device Address */
        poke32(I2C_SLAVE_ADDRESS, addr & ~0x01);

        /*
         * Write data.
         * Note:
         *      Only 16 byte can be accessed per i2c start instruction.
         */
        do {
                /*
                 * Reset I2C by writing 0 to I2C_RESET register to
                 * clear the previous status.
                 */
                poke32(I2C_RESET, 0);

                /* Set the number of bytes to be written */
                if (length < MAX_HWI2C_FIFO)
                        count = length - 1;
                else
                        count = MAX_HWI2C_FIFO - 1;
                poke32(I2C_BYTE_COUNT, count);

                /* Move the data to the I2C data register */
                for (i = 0; i <= count; i++)
                        poke32(I2C_DATA0 + i, *buf++);

                /* Start the I2C */
                poke32(I2C_CTRL, peek32(I2C_CTRL) | I2C_CTRL_CTRL);

                /* Wait until the transfer is completed. */
                if (hw_i2c_wait_tx_done() != 0)
                        break;

                /* Subtract length */
                length -= (count + 1);

                /* Total byte written */
                total_bytes += (count + 1);

        } while (length > 0);

        return total_bytes;
}

/*
 *  This function reads data from the slave device and stores them
 *  in the given buffer
 *
 *  Parameters:
 *      addr            - i2c Slave device address
 *      length          - Total number of bytes to be read
 *      buf             - Pointer to a buffer to be filled with the data read
 *                     from the slave device. It has to be the same size as the
 *                     length to make sure that it can keep all the data read.
 *
 *  Return Value:
 *      Total number of actual bytes read from the slave device
 */
static unsigned int hw_i2c_read_data(unsigned char addr,
                                     unsigned int length,
                                     unsigned char *buf)
{
        unsigned char count, i;
        unsigned int total_bytes = 0;

        /* Set the Device Address */
        poke32(I2C_SLAVE_ADDRESS, addr | 0x01);

        /*
         * Read data and save them to the buffer.
         * Note:
         *      Only 16 byte can be accessed per i2c start instruction.
         */
        do {
                /*
                 * Reset I2C by writing 0 to I2C_RESET register to
                 * clear all the status.
                 */
                poke32(I2C_RESET, 0);

                /* Set the number of bytes to be read */
                if (length <= MAX_HWI2C_FIFO)
                        count = length - 1;
                else
                        count = MAX_HWI2C_FIFO - 1;
                poke32(I2C_BYTE_COUNT, count);

                /* Start the I2C */
                poke32(I2C_CTRL, peek32(I2C_CTRL) | I2C_CTRL_CTRL);

                /* Wait until transaction done. */
                if (hw_i2c_wait_tx_done() != 0)
                        break;

                /* Save the data to the given buffer */
                for (i = 0; i <= count; i++)
                        *buf++ = peek32(I2C_DATA0 + i);

                /* Subtract length by 16 */
                length -= (count + 1);

                /* Number of bytes read. */
                total_bytes += (count + 1);

        } while (length > 0);

        return total_bytes;
}

/*
 *  This function reads the slave device's register
 *
 *  Parameters:
 *      deviceAddress   - i2c Slave device address which register
 *                        to be read from
 *      registerIndex   - Slave device's register to be read
 *
 *  Return Value:
 *      Register value
 */
unsigned char sm750_hw_i2c_read_reg(unsigned char addr, unsigned char reg)
{
        unsigned char value = 0xFF;

        if (hw_i2c_write_data(addr, 1, &reg) == 1)
                hw_i2c_read_data(addr, 1, &value);

        return value;
}

/*
 *  This function writes a value to the slave device's register
 *
 *  Parameters:
 *      deviceAddress   - i2c Slave device address which register
 *                        to be written
 *      registerIndex   - Slave device's register to be written
 *      data            - Data to be written to the register
 *
 *  Result:
 *          0   - Success
 *         -1   - Fail
 */
int sm750_hw_i2c_write_reg(unsigned char addr,
                           unsigned char reg,
                           unsigned char data)
{
        unsigned char value[2];

        value[0] = reg;
        value[1] = data;
        if (hw_i2c_write_data(addr, 2, value) == 2)
                return 0;

        return -1;
}

#endif