/*
 *
 * Copyright 2017-2020 NXP
 * SPDX-License-Identifier: Apache-2.0
 */

/**
 * @par Description
 * MCIMX6UL-EVK / MCIMX8M-EVK board specific & Generic i2c code
 * @par History
 *
 **/
#include "i2c_a7.h"
#include <stdio.h>
#include <string.h>

#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <linux/i2c-dev.h>
#include <linux/i2c.h>
#include <linux/version.h>
#include <errno.h>
#include <time.h>

// #define NX_LOG_ENABLE_SMCOM_DEBUG 1

#include "nxLog_smCom.h"

static char* default_axSmDevice_name = "/dev/i2c-0";
static int default_axSmDevice_addr = 0x49;      // 7-bit address

#define DEV_NAME_BUFFER_SIZE 64

/**
* Opens the communication channel to I2C device
*/
i2c_error_t axI2CInit(void **conn_ctx, const char *pDevName)
{
    unsigned long funcs;
    int axSmDevice = 0;
    char *pdev_name = NULL;
    char *pdev_addr_str = NULL;
    U32 dev_addr = 0x00;
    char temp[DEV_NAME_BUFFER_SIZE] = { 0, };

    if (pDevName != NULL && (strcasecmp("none", pDevName) != 0) ) {
        if ((strlen(pDevName) + 1) < DEV_NAME_BUFFER_SIZE) {
            memcpy(temp, pDevName, strlen(pDevName));
            temp[strlen(pDevName)] = '\0';
        }
        else {
            LOG_E("Connection string passed as argument is too long (%d).", strlen(pDevName));
            LOG_I("Pass i2c device address in the format <i2c_port>:<i2c_addr(optional. Default 0x48)>.");
            LOG_I("Example ./example /dev/i2c-1:0x48 OR ./example /dev/i2c-1");
        }

        pdev_name = strtok(temp, ":");
        if (pdev_name == NULL) {
            perror("Invalid connection string");
            LOG_I("Pass i2c device address in the format <i2c_port>:<i2c_addr(optional. Default 0x48)>.");
            LOG_I("Example ./example /dev/i2c-1:0x48 OR ./example /dev/i2c-1");
            return I2C_FAILED;
        }

        pdev_addr_str = strtok(NULL, ":");
        if (pdev_addr_str != NULL) {
            dev_addr = strtol(pdev_addr_str, NULL, 0);
        }
        else {
            dev_addr = default_axSmDevice_addr;
        }
    }
    else {
        pdev_name = default_axSmDevice_name;
        dev_addr = default_axSmDevice_addr;
    }

    LOG_D("I2CInit: opening %s\n", pdev_name);

    if ((axSmDevice = open(pdev_name, O_RDWR)) < 0)
    {
        LOG_E("opening failed...");
        perror("Failed to open the i2c bus");
        LOG_I("Pass i2c device address in the format <i2c_port>:<i2c_addr(optional. Default 0x48)>.");
        LOG_I("Example ./example /dev/i2c-1:0x48 OR ./example /dev/i2c-1");
        return I2C_FAILED;
    }

    if (ioctl(axSmDevice, I2C_SLAVE, dev_addr) < 0)
    {
        LOG_E("I2C driver failed setting address\n");
    }

    // clear PEC flag
    if (ioctl(axSmDevice, I2C_PEC, 0) < 0)
    {
        LOG_E("I2C driver: PEC flag clear failed\n");
    }
    else
    {
        LOG_D("I2C driver: PEC flag cleared\n");
    }

    // Query functional capacity of I2C driver
    if (ioctl(axSmDevice, I2C_FUNCS, &funcs) < 0)
    {
        LOG_E("Cannot get i2c adapter functionality\n");
        close(axSmDevice);
        return I2C_FAILED;
    }
    else
    {
        if (funcs & I2C_FUNC_I2C)
        {
            LOG_D("I2C driver supports plain i2c-level commands.\n");
#if defined(SCI2C) //if SCI2C is enabled
            if ( (funcs & I2C_FUNC_SMBUS_READ_BLOCK_DATA) == I2C_FUNC_SMBUS_READ_BLOCK_DATA )
            {
                LOG_D("I2C driver supports Read Block.\n");
            }
            else
            {
                LOG_E("I2C driver does not support Read Block!\n");
                close(axSmDevice);
                return I2C_FAILED;
            }
#endif
        }
        else
        {
            LOG_E("I2C driver CANNOT support plain i2c-level commands!\n");
            close(axSmDevice);
            return I2C_FAILED;
        }
    }

    *conn_ctx = malloc(sizeof(int));
    *(int*)(*conn_ctx) = axSmDevice;
    return I2C_OK;
}

/**
* Closes the communication channel to I2C device
*/
void axI2CTerm(void* conn_ctx, int mode)
{
    AX_UNUSED_ARG(mode);
    // printf("axI2CTerm (enter) i2c device =  %d\n", *(int*)(conn_ctx));
    if (conn_ctx != NULL) {
        if (close(*(int*)(conn_ctx)) != 0) {
            LOG_E("Failed to close i2c device %d.\n", *(int*)(conn_ctx));
        }
        else {
            LOG_D("Close i2c device %d.\n", *(int*)(conn_ctx));
        }
        free(conn_ctx);
    }
    // printf("axI2CTerm (exit)\n");
    return;
}

#if defined(SCI2C)
/**
 * Write a single byte to the slave device.
 * In the context of the SCI2C protocol, this command is only invoked
 * to trigger a wake-up of the attached secure module. As such this
 * wakeup command 'wakes' the device, but does not receive a valid response.
 * \note \par bus is currently not used to distinguish between I2C masters.
*/
i2c_error_t axI2CWriteByte(void* conn_ctx, unsigned char bus, unsigned char addr, unsigned char * pTx)
{
    int nrWritten = -1;
    i2c_error_t rv;
    int axSmDevice = *(int*)conn_ctx;

    if (bus != I2C_BUS_0)
    {
        LOG_E("axI2CWriteByte on wrong bus %x (addr %x)\n", bus, addr);
    }

    nrWritten = write(axSmDevice, pTx, 1);
    if (nrWritten < 0)
    {
        // I2C_LOG_PRINTF("Failed writing data (nrWritten=%d).\n", nrWritten);
        rv = I2C_FAILED;
    }
    else
    {
        if (nrWritten == 1)
        {
            rv = I2C_OK;
        }
        else
        {
            rv = I2C_FAILED;
        }
    }

    return rv;
}
#endif // defined(SCI2C)

#if defined(SCI2C) || defined(T1oI2C)
i2c_error_t axI2CWrite(void* conn_ctx, unsigned char bus, unsigned char addr, unsigned char * pTx, unsigned short txLen)
{
    int nrWritten = -1;
    i2c_error_t rv;
    int axSmDevice = *(int*)conn_ctx;
#ifdef LOG_I2C
    int i = 0;
#endif

    if (bus != I2C_BUS_0)
    {
        LOG_E("axI2CWrite on wrong bus %x (addr %x)\n", bus, addr);
    }
    LOG_MAU8_D("TX (axI2CWrite) > ",pTx,txLen);
    nrWritten = write(axSmDevice, pTx, txLen);
    if (nrWritten < 0)
    {
       LOG_E("Failed writing data (nrWritten=%d).\n", nrWritten);
       rv = I2C_FAILED;
    }
    else
    {
        if (nrWritten == txLen) // okay
        {
            rv = I2C_OK;
        }
        else
        {
            rv = I2C_FAILED;
        }
    }
    LOG_D("Done with rv = %02x ", rv);

    return rv;
}
#endif // defined(SCI2C) || defined(T1oI2C)

#if defined(SCI2C)
i2c_error_t axI2CWriteRead(void* conn_ctx, unsigned char bus, unsigned char addr, unsigned char * pTx,
      unsigned short txLen, unsigned char * pRx, unsigned short * pRxLen)
{
    struct i2c_rdwr_ioctl_data packets;
    struct i2c_msg messages[2];
    int r = 0;
    int i = 0;
    int axSmDevice = *(int*)conn_ctx;

    if (bus != I2C_BUS_0) // change if bus 0 is not the correct bus
    {
        LOG_E("axI2CWriteRead on wrong bus %x (addr %x)\n", bus, addr);
    }

    messages[0].addr  = default_axSmDevice_addr;
    messages[0].flags = 0;
    messages[0].len   = txLen;
    messages[0].buf   = pTx;

    // NOTE:
    // By setting the 'I2C_M_RECV_LEN' bit in 'messages[1].flags' one ensures
    // the I2C Block Read feature is used.
    messages[1].addr  = default_axSmDevice_addr;
    messages[1].flags = I2C_M_RD | I2C_M_RECV_LEN;
    messages[1].len   = 256;
    messages[1].buf   = pRx;
    messages[1].buf[0] = 1;

    // NOTE:
    // By passing the two message structures via the packets structure as
    // a parameter to the ioctl call one ensures a Repeated Start is triggered.
    packets.msgs      = messages;
    packets.nmsgs     = 2;

    LOG_MAU8_D("TX (axI2CWriteRead ) > ",&packets.msgs[0].buf[i], txLen);

    // Send the request to the kernel and get the result back
    r = ioctl(axSmDevice, I2C_RDWR, &packets);

    // NOTE:
    // The ioctl return value in case of a NACK on the write address is '-1'
    // This impacts the error handling routine of the caller.
    // If possible distinguish between a general I2C error and a NACK on address
    // The way to do this is platform specific (depends on I2C bus driver).
    if (r < 0)
    {
        // LOG_E("axI2CWriteRead: ioctl cmd I2C_RDWR fails with value %d (errno: 0x%08X)\n", r, errno);
        // perror("Errorstring: ");
#ifdef PLATFORM_IMX
    #if LINUX_VERSION_CODE >= KERNEL_VERSION(4,4,0)
        #define E_NACK_I2C_IMX ENXIO
        // #warning "ENXIO"
    #else
        #define E_NACK_I2C_IMX EIO
        // #warning "EIO"
    #endif // LINUX_VERSION_CODE
        // In case of IMX, errno == E_NACK_I2C_IMX is not exclusively bound to NACK on address,
        // it can also signal a NACK on a data byte
        if (errno == E_NACK_I2C_IMX) {
            // I2C_LOG_PRINTF("axI2CWriteRead: ioctl signal NACK (errno = %d)\n", errno);
            return I2C_NACK_ON_ADDRESS;
        }
        else {
            // printf("axI2CWriteRead: ioctl error (errno = %d)\n", errno);
            return I2C_FAILED;
        }
#else
        // I2C_LOG_PRINTF("axI2CWriteRead: ioctl cmd I2C_RDWR fails with value %d (errno: 0x%08X)\n", r, errno);
        return I2C_FAILED;
#endif // PLATFORM_IMX
    }
    else
    {
        int rlen = packets.msgs[1].buf[0]+1;

        //I2C_LOG_PRINTF("packets.msgs[1].len is %d \n", packets.msgs[1].len);
        LOG_MAU8_D("RX (axI2CWriteRead) < ",&packets.msgs[1].buf[i], rlen);
        for (i = 0; i < rlen; i++)
        {
            pRx[i] = packets.msgs[1].buf[i];
        }
        *pRxLen = rlen;
    }

    return I2C_OK;
}
#endif // defined(SCI2C)

#ifdef T1oI2C
i2c_error_t axI2CRead(void* conn_ctx, unsigned char bus, unsigned char addr, unsigned char * pRx, unsigned short rxLen)
{
    int nrRead = -1;
    i2c_error_t rv;
    int axSmDevice = *(int*)conn_ctx;

    if (bus != I2C_BUS_0)
    {
        LOG_E("axI2CRead on wrong bus %x (addr %x)\n", bus, addr);
    }

   nrRead = read(axSmDevice, pRx, rxLen);
   if (nrRead < 0)
   {
      //LOG_E("Failed Read data (nrRead=%d).\n", nrRead);
      rv = I2C_FAILED;
   }
   else
   {
        if (nrRead == rxLen) // okay
        {
            rv = I2C_OK;
        }
        else
        {
            rv = I2C_FAILED;
        }
   }
    LOG_D("Done with rv = %02x ", rv);
    LOG_MAU8_D("TX (axI2CRead): ",pRx,rxLen);
    return rv;
}
#endif // T1oI2C