/** ----------------------------------------------------------------------
 *
 * 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.
 *
 *
 ----------------------------------------------------------------------*/

#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 <pthread.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>

#include "android_logmsg.h"
#include "halcore.h"
#include "halcore_private.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_D("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_V("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");
      break;
    }

    if (event_table[0].revents & POLLIN) {
      STLOG_HAL_V("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];
            bytesRead = 0;
            if (remaining != 0) {
              // 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  (%s) \n", strerror(errno));
    (void)pthread_mutex_unlock(&i2ctransport_mtx);
    return false;
  }

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

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

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

  if (!*pHandle) {
    STLOG_HAL_E("failed to create NFC HAL Core \n");
    (void)pthread_mutex_unlock(&i2ctransport_mtx);
    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) {
    (void)pthread_mutex_unlock(&i2ctransport_mtx);
    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);
}

/**
 * Terminates the I2C layer.
 */
void I2cResetPulse() {
  ALOGD("%s: enter\n", __func__);

  (void)pthread_mutex_lock(&i2ctransport_mtx);

  i2cResetPulse(fidI2c);
  (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;
  int halfsecs = 0;

redo:
  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++;
    }
  }
  /* If we're here, we failed to write to NFCC. Retry after 500ms because some
  CPUs have shown such long unavailability sometimes */
  if (halfsecs < 10) {
    usleep(500000);
    halfsecs++;
    goto redo;
  }
  /* The CLF did not recover, give up */
  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 */