/** ----------------------------------------------------------------------
 *
 * Copyright (C) 2013 ST Microelectronics S.A.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *
 ----------------------------------------------------------------------*/
#define _GNU_SOURCE
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <linux/input.h> /* not required for all builds */
#include <poll.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <pthread.h>

#include "halcore.h"
#include "halcore_private.h"
#include "android_logmsg.h"

#define ST21NFC_MAGIC 0xEA

#define ST21NFC_GET_WAKEUP _IOR(ST21NFC_MAGIC, 0x01, unsigned int)
#define ST21NFC_PULSE_RESET _IOR(ST21NFC_MAGIC, 0x02, unsigned int)
#define ST21NFC_SET_POLARITY_RISING _IOR(ST21NFC_MAGIC, 0x03, unsigned int)
#define ST21NFC_SET_POLARITY_FALLING _IOR(ST21NFC_MAGIC, 0x04, unsigned int)
#define ST21NFC_SET_POLARITY_HIGH _IOR(ST21NFC_MAGIC, 0x05, unsigned int)
#define ST21NFC_SET_POLARITY_LOW _IOR(ST21NFC_MAGIC, 0x06, unsigned int)

#define LINUX_DBGBUFFER_SIZE 300

static int fidI2c = 0;
static int cmdPipe[2] = {0, 0};

static struct pollfd event_table[2];
static pthread_t threadHandle = (pthread_t)NULL;
pthread_mutex_t i2ctransport_mtx = PTHREAD_MUTEX_INITIALIZER;

/**************************************************************************************************
 *
 *                                      Private API Declaration
 *
 **************************************************************************************************/

static int i2cSetPolarity(int fid, bool low, bool edge);
static int i2cResetPulse(int fid);
static int i2cRead(int fid, uint8_t* pvBuffer, int length);
static int i2cGetGPIOState(int fid);
static int i2cWrite(int fd, const uint8_t* pvBuffer, int length);

/**************************************************************************************************
 *
 *                                      Public API Entry-Points
 *
 **************************************************************************************************/

/**
 * Worker thread for I2C data processing.
 * On exit of this thread, destroy the HAL thread instance.
 * @param arg  Handle of the HAL layer
 */
static void* I2cWorkerThread(void* arg)
{
    bool closeThread = false;
    HALHANDLE hHAL = (HALHANDLE)arg;
    STLOG_HAL_V("echo thread started...\n");
    bool readOk= false;

    do {
        event_table[0].fd = fidI2c;
        event_table[0].events = POLLIN;
        event_table[0].revents = 0;

        event_table[1].fd = cmdPipe[0];
        event_table[1].events = POLLIN;
        event_table[1].revents = 0;

        STLOG_HAL_D("echo thread go to sleep...\n");

        int poll_status = poll(event_table, 2, -1);

        if (-1 == poll_status) {
            STLOG_HAL_E("error in poll call\n");
            return false;
        }

        if (event_table[0].revents & POLLIN) {
            STLOG_HAL_D("echo thread wakeup from chip...\n");

            uint8_t buffer[300];

            do {
                // load first four bytes:
                int bytesRead = i2cRead(fidI2c, buffer, 3);

                if (bytesRead == 3) {
                    if ((buffer[0] != 0x7E) && (buffer[1] != 0x7E)) {
                        readOk = true;
                    } else {
                        if (buffer[1] != 0x7E) {
                            STLOG_HAL_W("Idle data: 2nd byte is 0x%02x\n, reading next 2 bytes",
                                  buffer[1]);
                            buffer[0] = buffer[1];
                            buffer[1] = buffer[2];
                            bytesRead = i2cRead(fidI2c, buffer + 2, 1);
                            if (bytesRead == 1) {
                                readOk = true;
                            }
                        } else if (buffer[2] != 0x7E) {
                            STLOG_HAL_W("Idle data: 3rd byte is 0x%02x\n, reading next  byte",
                                  buffer[2]);
                            buffer[0] = buffer[2];
                            bytesRead = i2cRead(fidI2c, buffer + 1, 2);
                            if (bytesRead == 2) {
                                readOk = true;
                            }
                        } else {
                            STLOG_HAL_W("received idle data\n");
                        }
                    }

                    if (readOk == true) {
                        int remaining = buffer[2];

                        // read and pass to HALCore
                        bytesRead = i2cRead(fidI2c, buffer + 3, remaining);
                        if (bytesRead == remaining) {
                            DispHal("RX DATA", buffer, 3 + bytesRead);
                            HalSendUpstream(hHAL, buffer, 3 + bytesRead);
                        } else {
                            readOk = false;
                            STLOG_HAL_E("! didn't read expected bytes from i2c\n");
                        }
                    }

                } else {
                    STLOG_HAL_E("! didn't read 3 requested bytes from i2c\n");
                }

                readOk = false;
                memset(buffer, 0xca, sizeof(buffer));

                /* read while we have data available */
            } while (i2cGetGPIOState(fidI2c) == 1);
        }

        if (event_table[1].revents & POLLIN) {
            STLOG_HAL_V("thread received command.. \n");

            char cmd = 0;
            read(cmdPipe[0], &cmd, 1);

            switch (cmd) {
                case 'X':
                    STLOG_HAL_D("received close command\n");
                    closeThread = true;
                    break;

                case 'W': {
                    size_t length;
                    uint8_t buffer[MAX_BUFFER_SIZE];
                    STLOG_HAL_V("received write command\n");
                    read(cmdPipe[0], &length, sizeof(length));
                    if (length <= MAX_BUFFER_SIZE)
                      {
                        read(cmdPipe[0], buffer, length);
                        i2cWrite(fidI2c, buffer, length);
                      }
                    else {
                        STLOG_HAL_E("! received bigger data than expected!! Data not transmitted to NFCC \n");
                        size_t bytes_read = 1;
                        // Read all the data to empty but do not use it as not expected
                        while((bytes_read > 0) && (length > 0))
                          {
                            bytes_read = read(cmdPipe[0],buffer,MAX_BUFFER_SIZE);
                            length = length - bytes_read;
                          }
                    }
                }
                break;
            }
        }

    } while (!closeThread);

    close(fidI2c);
    close(cmdPipe[0]);
    close(cmdPipe[1]);

    HalDestroy(hHAL);
    STLOG_HAL_D("thread exit\n");
    return 0;
}

/**
 * Put command into queue for worker thread to process it.
 * @param x Command 'X' to close I2C layer or 'W' to write data down to I2C
 * layer followed by data frame
 * @param len Size of command or data
 * @return
 */
int I2cWriteCmd(const uint8_t* x, size_t len)
{
    return write(cmdPipe[1], x, len);
}

/**
 * Initialize the I2C layer.
 * @param dev NFC NCI device context, NFC callbacks for control/data, HAL handle
 * @param callb HAL Core callback upon reception on I2C
 * @param pHandle HAL context handle
 */
bool I2cOpenLayer(void* dev, HAL_CALLBACK callb, HALHANDLE* pHandle)
{
    uint32_t NoDbgFlag = HAL_FLAG_DEBUG;

      (void) pthread_mutex_lock(&i2ctransport_mtx);
    fidI2c = open("/dev/st21nfc", O_RDWR);
    if (fidI2c < 0) {
        STLOG_HAL_W("unable to open /dev/st21nfc\n");
        return false;
    }

    i2cSetPolarity(fidI2c, false, true);
    i2cResetPulse(fidI2c);

    if ((pipe(cmdPipe) == -1)) {
        STLOG_HAL_W("unable to open cmdpipe\n");
        return false;
    }

    *pHandle = HalCreate(dev, callb, NoDbgFlag);

    if (!*pHandle) {
        STLOG_HAL_E("failed to create NFC HAL Core \n");
        return false;
    }

      (void) pthread_mutex_unlock(&i2ctransport_mtx);

    return (pthread_create(&threadHandle, NULL, I2cWorkerThread, *pHandle) == 0);
}

/**
 * Terminates the I2C layer.
 */
void I2cCloseLayer()
{
    uint8_t cmd = 'X';
    int ret;
    ALOGD("%s: enter\n", __func__);

    (void)pthread_mutex_lock(&i2ctransport_mtx);

    if (threadHandle == (pthread_t)NULL)
        return;

    I2cWriteCmd(&cmd, sizeof(cmd));
    /* wait for terminate */
    ret = pthread_join(threadHandle,(void**)NULL);
    if (ret != 0) {
        ALOGE("%s: failed to wait for thread (%d)", __func__, ret);
    }
    threadHandle = (pthread_t)NULL;
    (void)pthread_mutex_unlock(&i2ctransport_mtx);
}
/**************************************************************************************************
 *
 *                                      Private API Definition
 *
 **************************************************************************************************/
/**
 * Call the st21nfc driver to adjust wake-up polarity.
 * @param fid File descriptor for NFC device
 * @param low Polarity (HIGH or LOW)
 * @param edge Polarity (RISING or FALLING)
 * @return Result of IOCTL system call (0 if ok)
 */
static int i2cSetPolarity(int fid, bool low, bool edge)
{
    int result;
    unsigned int io_code;

    if (low) {
        if (edge) {
            io_code = ST21NFC_SET_POLARITY_FALLING;
        } else {
            io_code = ST21NFC_SET_POLARITY_LOW;
        }

    } else {
        if (edge) {
            io_code = ST21NFC_SET_POLARITY_RISING;
        } else {
            io_code = ST21NFC_SET_POLARITY_HIGH;
        }
    }

    if (-1 == (result = ioctl(fid, io_code, NULL))) {
        result = -1;
    }

    return result;
} /* i2cSetPolarity*/

/**
 * Call the st21nfc driver to generate a 30ms pulse on RESET line.
 * @param fid File descriptor for NFC device
 * @return Result of IOCTL system call (0 if ok)
 */
static int i2cResetPulse(int fid)
{
    int result;

    if (-1 == (result = ioctl(fid, ST21NFC_PULSE_RESET, NULL))) {
        result = -1;
    }
    STLOG_HAL_D("! i2cResetPulse!!, result = %d", result);
    return result;
} /* i2cResetPulse*/

/**
 * Write data to st21nfc, on failure do max 3 retries.
 * @param fid File descriptor for NFC device
 * @param pvBuffer Data to write
 * @param length Data size
 * @return 0 if bytes written, -1 if error
 */
static int i2cWrite(int fid, const uint8_t* pvBuffer, int length)
{
    int retries = 0;
    int result = 0;

    while (retries < 3) {
        result = write(fid, pvBuffer, length);

        if (result < 0) {
            char msg[LINUX_DBGBUFFER_SIZE];

            strerror_r(errno, msg, LINUX_DBGBUFFER_SIZE);
            STLOG_HAL_W("! i2cWrite!!, errno is '%s'", msg);
            usleep(4000);
            retries++;
        } else if (result > 0) {
            result = 0;
            return result;
        } else {
            STLOG_HAL_W("write on i2c failed, retrying\n");
            usleep(4000);
            retries++;
        }
    }

    return -1;
} /* i2cWrite */

/**
 * Read data from st21nfc, on failure do max 3 retries.
 *
 * @param fid File descriptor for NFC device
 * @param pvBuffer Buffer where to copy read data
 * @param length Data size to read
 * @return Length of read data, -1 if error
 */
static int i2cRead(int fid, uint8_t* pvBuffer, int length)
{
    int retries = 0;
    int result = -1;

    while ((retries < 3) && (result < 0)) {
        result = read(fid, pvBuffer, length);

        if (result == -1) {
            int e = errno;
            if (e == EAGAIN) {
                /* File is nonblocking, and no data is available.
                 * This is not an error condition!
                 */
                result = 0;
                STLOG_HAL_D("## i2cRead - got EAGAIN. No data available. return 0 bytes");
            } else {
                /* unexpected result */
                char msg[LINUX_DBGBUFFER_SIZE];
                strerror_r(e, msg, LINUX_DBGBUFFER_SIZE);
                STLOG_HAL_W("## i2cRead returns %d errno %d (%s)", result, e, msg);
            }
        }

        if (result < 0) {
            if (retries < 3) {
                /* delays are different and increasing for the three retries. */
                static const uint8_t delayTab[] = {2, 3, 5};
                int delay = delayTab[retries];

                retries++;
                STLOG_HAL_W("## i2cRead retry %d/3 in %d milliseconds.", retries, delay);
                usleep(delay * 1000);
                continue;
            }
        }
    }
    return result;
} /* i2cRead */

/**
 * Get the activation status of wake-up pin from st21nfc.
 *  The decision 'active' depends on selected polarity.
 *  The decision is handled inside the driver(st21nfc).
 * @param fid File descriptor for NFC device
 * @return
 *  Result < 0:     Error condition
 *  Result > 0:     Pin active
 *  Result = 0:     Pin not active
 */
static int i2cGetGPIOState(int fid)
{
    int result;

    if (-1 == (result = ioctl(fid, ST21NFC_GET_WAKEUP, NULL))) {
        result = -1;
    }

    return result;
} /* i2cGetGPIOState */