| /** ---------------------------------------------------------------------- |
| * |
| * 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" |
| #include "hal_config.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 ST21NFC_CLK_ENABLE _IOR(ST21NFC_MAGIC, 0x11, unsigned int) |
| #define ST21NFC_CLK_DISABLE _IOR(ST21NFC_MAGIC, 0x12, unsigned int) |
| #define ST21NFC_CLK_STATE _IOR(ST21NFC_MAGIC, 0x13, unsigned int) |
| |
| #define LINUX_DBGBUFFER_SIZE 300 |
| |
| static int fidI2c = 0; |
| static int cmdPipe[2] = {0, 0}; |
| static int notifyResetRequest = 0; |
| |
| static struct pollfd event_table[3]; |
| static pthread_t threadHandle = (pthread_t)NULL; |
| pthread_mutex_t i2ctransport_mtx = PTHREAD_MUTEX_INITIALIZER; |
| |
| unsigned long hal_ctrl_clk = 0; |
| |
| /************************************************************************************************** |
| * |
| * 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; |
| int eventNum = (notifyResetRequest < 0) ? 2 : 3; |
| bool reseting = 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; |
| |
| event_table[2].fd = notifyResetRequest; |
| event_table[2].events = POLLPRI; |
| event_table[2].revents = 0; |
| |
| STLOG_HAL_V("echo thread go to sleep...\n"); |
| |
| int poll_status = poll(event_table, eventNum, -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]; |
| int count = 0; |
| |
| 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, up to 2 times then allow writes */ |
| } while ((i2cGetGPIOState(fidI2c) == 1) && (count++ < 2)); |
| } |
| |
| 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; |
| } |
| } |
| |
| if (event_table[2].revents & POLLPRI && eventNum > 2) { |
| STLOG_HAL_W("thread received reset request command.. \n"); |
| char reset[10]; |
| int byte; |
| reset[9] = '\0'; |
| lseek(notifyResetRequest, 0, SEEK_SET); |
| byte = read(notifyResetRequest, &reset, sizeof(reset)); |
| if (byte < 10) { |
| reset[byte] = '\0'; |
| } |
| if (byte > 0 && reset[0] =='1' && reseting == false) { |
| STLOG_HAL_E("trigger NFCC reset.. \n"); |
| reseting = true; |
| i2cResetPulse(fidI2c); |
| } |
| } |
| } while (!closeThread); |
| |
| close(fidI2c); |
| close(cmdPipe[0]); |
| close(cmdPipe[1]); |
| close(notifyResetRequest); |
| |
| 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; |
| char nfc_dev_node[64]; |
| char nfc_reset_req_node[128]; |
| |
| /*Read device node path*/ |
| if (!GetStrValue(NAME_ST_NFC_DEV_NODE, (char *)nfc_dev_node, |
| sizeof(nfc_dev_node))) { |
| STLOG_HAL_D("Open /dev/st21nfc\n"); |
| strcpy(nfc_dev_node, "/dev/st21nfc"); |
| } |
| /*Read nfcc reset request sysfs*/ |
| if (GetStrValue(NAME_ST_NFC_RESET_REQ_SYSFS, (char *)nfc_reset_req_node, |
| sizeof(nfc_reset_req_node))) { |
| STLOG_HAL_D("Open %s\n", nfc_reset_req_node); |
| notifyResetRequest = open(nfc_reset_req_node, O_RDONLY); |
| if (notifyResetRequest < 0) { |
| STLOG_HAL_E("unable to open %s (%s) \n", nfc_reset_req_node, strerror(errno)); |
| } |
| } |
| |
| (void)pthread_mutex_lock(&i2ctransport_mtx); |
| |
| fidI2c = open(nfc_dev_node, O_RDWR); |
| if (fidI2c < 0) { |
| STLOG_HAL_W("unable to open %s (%s) \n", nfc_dev_node, strerror(errno)); |
| (void)pthread_mutex_unlock(&i2ctransport_mtx); |
| return false; |
| } |
| |
| GetNumValue(NAME_STNFC_CONTROL_CLK, &hal_ctrl_clk, sizeof(hal_ctrl_clk)); |
| |
| if (hal_ctrl_clk) { |
| if (ioctl(fidI2c, ST21NFC_CLK_DISABLE, NULL) < 0) { |
| char msg[LINUX_DBGBUFFER_SIZE]; |
| strerror_r(errno, msg, LINUX_DBGBUFFER_SIZE); |
| STLOG_HAL_E("ST21NFC_CLK_DISABLE failed errno %d(%s)", errno, msg); |
| } |
| } |
| 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; |
| int clk_state = -1; |
| char msg[LINUX_DBGBUFFER_SIZE]; |
| |
| if (hal_ctrl_clk && length >= 4 && pvBuffer[0] == 0x20 && |
| pvBuffer[1] == 0x09) { |
| if (0 > (clk_state = ioctl(fid, ST21NFC_CLK_STATE, NULL))) { |
| strerror_r(errno, msg, LINUX_DBGBUFFER_SIZE); |
| STLOG_HAL_E("ST21NFC_CLK_STATE failed errno %d(%s)", errno, msg); |
| clk_state = -1; |
| } |
| STLOG_HAL_D("ST21NFC_CLK_STATE = %d", clk_state); |
| if (clk_state == 1 && (pvBuffer[3] == 0x01 || pvBuffer[3] == 0x03)) { |
| // screen off cases |
| if (ioctl(fid, ST21NFC_CLK_DISABLE, NULL) < 0) { |
| strerror_r(errno, msg, LINUX_DBGBUFFER_SIZE); |
| STLOG_HAL_E("ST21NFC_CLK_DISABLE failed errno %d(%s)", errno, msg); |
| } else if (0 > (clk_state = ioctl(fid, ST21NFC_CLK_STATE, NULL))) { |
| strerror_r(errno, msg, LINUX_DBGBUFFER_SIZE); |
| STLOG_HAL_E("ST21NFC_CLK_STATE failed errno %d(%s)", errno, msg); |
| clk_state = -1; |
| } |
| if (clk_state != 0) { |
| STLOG_HAL_E("CLK_DISABLE STATE ERROR clk_state = %d", clk_state); |
| } |
| } else if (clk_state == 0 && (pvBuffer[3] == 0x02 || pvBuffer[3] == 0x00)) { |
| // screen on cases |
| if (ioctl(fid, ST21NFC_CLK_ENABLE, NULL) < 0) { |
| strerror_r(errno, msg, LINUX_DBGBUFFER_SIZE); |
| STLOG_HAL_E("ST21NFC_CLK_ENABLE failed errno %d(%s)", errno, msg); |
| } else if (0 > (clk_state = ioctl(fid, ST21NFC_CLK_STATE, NULL))) { |
| strerror_r(errno, msg, LINUX_DBGBUFFER_SIZE); |
| STLOG_HAL_E("ST21NFC_CLK_STATE failed errno %d(%s)", errno, msg); |
| clk_state = -1; |
| } |
| if (clk_state != 1) { |
| STLOG_HAL_E("CLK_ENABLE STATE ERROR clk_state = %d", clk_state); |
| } |
| } |
| } |
| |
| redo: |
| while (retries < 3) { |
| result = write(fid, pvBuffer, length); |
| |
| if (result < 0) { |
| |
| 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 */ |
