/*
* Copyright (C) 2010-2014 NXP Semiconductors
*
* 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.
*/
/*
* TML Implementation.
*/
#include <phTmlNfc.h>
#include <phOsalNfc_Timer.h>
#include <phNxpLog.h>
#include <phDal4Nfc_messageQueueLib.h>
#include <phTmlNfc_i2c.h>
#include <phNxpNciHal_utils.h>
/*
* Duration of Timer to wait after sending an Nci packet
*/
#define PHTMLNFC_MAXTIME_RETRANSMIT (200U)
#define MAX_WRITE_RETRY_COUNT 0x03
/* Retry Count = Standby Recovery time of NFCC / Retransmission time + 1 */
static uint8_t bCurrentRetryCount = (2000 / PHTMLNFC_MAXTIME_RETRANSMIT) + 1;
/* Value to reset variables of TML */
#define PH_TMLNFC_RESET_VALUE (0x00)
/* Indicates a Initial or offset value */
#define PH_TMLNFC_VALUE_ONE (0x01)
/* Initialize Context structure pointer used to access context structure */
phTmlNfc_Context_t *gpphTmlNfc_Context = NULL;
phTmlNfc_i2cfragmentation_t fragmentation_enabled = I2C_FRAGMENATATION_DISABLED;
/* Local Function prototypes */
static NFCSTATUS phTmlNfc_StartThread(void);
static void phTmlNfc_CleanUp(void);
static void phTmlNfc_ReadDeferredCb(void *pParams);
static void phTmlNfc_WriteDeferredCb(void *pParams);
static void phTmlNfc_TmlThread(void *pParam);
static void phTmlNfc_TmlWriterThread(void *pParam);
static void phTmlNfc_ReTxTimerCb(uint32_t dwTimerId, void *pContext);
static NFCSTATUS phTmlNfc_InitiateTimer(void);
/* Function definitions */
/*******************************************************************************
**
** Function phTmlNfc_Init
**
** Description Provides initialization of TML layer and hardware interface
** Configures given hardware interface and sends handle to the caller
**
** Parameters pConfig - TML configuration details as provided by the upper layer
**
** Returns NFC status:
** NFCSTATUS_SUCCESS - initialization successful
** NFCSTATUS_INVALID_PARAMETER - at least one parameter is invalid
** NFCSTATUS_FAILED - initialization failed
** (for example, unable to open hardware interface)
** NFCSTATUS_INVALID_DEVICE - device has not been opened or has been disconnected
**
*******************************************************************************/
NFCSTATUS phTmlNfc_Init(pphTmlNfc_Config_t pConfig)
{
NFCSTATUS wInitStatus = NFCSTATUS_SUCCESS;
/* Check if TML layer is already Initialized */
if (NULL != gpphTmlNfc_Context)
{
/* TML initialization is already completed */
wInitStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_ALREADY_INITIALISED);
}
/* Validate Input parameters */
else if ((NULL == pConfig) ||
(PH_TMLNFC_RESET_VALUE == pConfig->dwGetMsgThreadId))
{
/*Parameters passed to TML init are wrong */
wInitStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_INVALID_PARAMETER);
}
else
{
/* Allocate memory for TML context */
gpphTmlNfc_Context = malloc(sizeof(phTmlNfc_Context_t));
if (NULL == gpphTmlNfc_Context)
{
wInitStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_FAILED);
}
else
{
/* Initialise all the internal TML variables */
memset(gpphTmlNfc_Context, PH_TMLNFC_RESET_VALUE, sizeof(phTmlNfc_Context_t));
/* Make sure that the thread runs once it is created */
gpphTmlNfc_Context->bThreadDone = 1;
/* Open the device file to which data is read/written */
wInitStatus = phTmlNfc_i2c_open_and_configure(pConfig, &(gpphTmlNfc_Context->pDevHandle));
if (NFCSTATUS_SUCCESS != wInitStatus)
{
wInitStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_INVALID_DEVICE);
gpphTmlNfc_Context->pDevHandle = NULL;
}
else
{
gpphTmlNfc_Context->tReadInfo.bEnable = 0;
gpphTmlNfc_Context->tWriteInfo.bEnable = 0;
gpphTmlNfc_Context->tReadInfo.bThreadBusy = FALSE;
gpphTmlNfc_Context->tWriteInfo.bThreadBusy = FALSE;
if(0 != sem_init(&gpphTmlNfc_Context->rxSemaphore, 0, 0))
{
wInitStatus = NFCSTATUS_FAILED;
}
else if(0 != sem_init(&gpphTmlNfc_Context->txSemaphore, 0, 0))
{
wInitStatus = NFCSTATUS_FAILED;
}
else if(0 != sem_init(&gpphTmlNfc_Context->postMsgSemaphore, 0, 0))
{
wInitStatus = NFCSTATUS_FAILED;
}
else
{
sem_post(&gpphTmlNfc_Context->postMsgSemaphore);
/* Start TML thread (to handle write and read operations) */
if (NFCSTATUS_SUCCESS != phTmlNfc_StartThread())
{
wInitStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_FAILED);
}
else
{
/* Create Timer used for Retransmission of NCI packets */
gpphTmlNfc_Context->dwTimerId = phOsalNfc_Timer_Create();
if (PH_OSALNFC_TIMER_ID_INVALID != gpphTmlNfc_Context->dwTimerId)
{
/* Store the Thread Identifier to which Message is to be posted */
gpphTmlNfc_Context->dwCallbackThreadId = pConfig->dwGetMsgThreadId;
/* Enable retransmission of Nci packet & set retry count to default */
gpphTmlNfc_Context->eConfig = phTmlNfc_e_DisableRetrans;
/** Retry Count = Standby Recovery time of NFCC / Retransmission time + 1 */
gpphTmlNfc_Context->bRetryCount = (2000 / PHTMLNFC_MAXTIME_RETRANSMIT) + 1;
gpphTmlNfc_Context->bWriteCbInvoked = FALSE;
}
else
{
wInitStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_FAILED);
}
}
}
}
}
}
/* Clean up all the TML resources if any error */
if (NFCSTATUS_SUCCESS != wInitStatus)
{
/* Clear all handles and memory locations initialized during init */
phTmlNfc_CleanUp();
}
return wInitStatus;
}
/*******************************************************************************
**
** Function phTmlNfc_ConfigNciPktReTx
**
** Description Provides Enable/Disable Retransmission of NCI packets
** Needed in case of Timeout between Transmission and Reception of NCI packets
** Retransmission can be enabled only if standby mode is enabled
**
** Parameters eConfig - values from phTmlNfc_ConfigRetrans_t
** bRetryCount - Number of times Nci packets shall be retransmitted (default = 3)
**
** Returns None
**
*******************************************************************************/
void phTmlNfc_ConfigNciPktReTx(phTmlNfc_ConfigRetrans_t eConfiguration, uint8_t bRetryCounter)
{
/* Enable/Disable Retransmission */
gpphTmlNfc_Context->eConfig = eConfiguration;
if (phTmlNfc_e_EnableRetrans == eConfiguration)
{
/* Check whether Retry counter passed is valid */
if (0 != bRetryCounter)
{
gpphTmlNfc_Context->bRetryCount = bRetryCounter;
}
/* Set retry counter to its default value */
else
{
/** Retry Count = Standby Recovery time of NFCC / Retransmission time + 1 */
gpphTmlNfc_Context->bRetryCount = (2000 / PHTMLNFC_MAXTIME_RETRANSMIT) + 1;
}
}
return;
}
/*******************************************************************************
**
** Function phTmlNfc_StartThread
**
** Description Initializes comport, reader and writer threads
**
** Parameters None
**
** Returns NFC status:
** NFCSTATUS_SUCCESS - threads initialized successfully
** NFCSTATUS_FAILED - initialization failed due to system error
**
*******************************************************************************/
static NFCSTATUS phTmlNfc_StartThread(void)
{
NFCSTATUS wStartStatus = NFCSTATUS_SUCCESS;
void *h_threadsEvent = 0x00;
uint32_t dwEvent;
int pthread_create_status = 0;
/* Create Reader and Writer threads */
pthread_create_status = pthread_create(&gpphTmlNfc_Context->readerThread,NULL,(void *)&phTmlNfc_TmlThread,
(void *)h_threadsEvent);
if(0 != pthread_create_status)
{
wStartStatus = NFCSTATUS_FAILED;
}
else
{
/*Start Writer Thread*/
pthread_create_status = pthread_create(&gpphTmlNfc_Context->writerThread,NULL,(void *)&phTmlNfc_TmlWriterThread,
(void *)h_threadsEvent);
if(0 != pthread_create_status)
{
wStartStatus = NFCSTATUS_FAILED;
}
}
return wStartStatus;
}
/*******************************************************************************
**
** Function phTmlNfc_ReTxTimerCb
**
** Description This is the timer callback function after timer expiration.
**
** Parameters dwThreadId - id of the thread posting message
** pContext - context provided by upper layer
**
** Returns None
**
*******************************************************************************/
static void phTmlNfc_ReTxTimerCb(uint32_t dwTimerId, void *pContext)
{
if ((gpphTmlNfc_Context->dwTimerId == dwTimerId) &&
(NULL == pContext))
{
/* If Retry Count has reached its limit,Retransmit Nci
packet */
if (0 == bCurrentRetryCount)
{
/* Since the count has reached its limit,return from timer callback
Upper layer Timeout would have happened */
}
else
{
bCurrentRetryCount--;
gpphTmlNfc_Context->tWriteInfo.bThreadBusy = TRUE;
gpphTmlNfc_Context->tWriteInfo.bEnable = 1;
}
sem_post(&gpphTmlNfc_Context->txSemaphore);
}
return;
}
/*******************************************************************************
**
** Function phTmlNfc_InitiateTimer
**
** Description Start a timer for Tx and Rx thread.
**
** Parameters void
**
** Returns NFC status
**
*******************************************************************************/
static NFCSTATUS phTmlNfc_InitiateTimer(void)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
/* Start Timer once Nci packet is sent */
wStatus = phOsalNfc_Timer_Start(gpphTmlNfc_Context->dwTimerId,
(uint32_t) PHTMLNFC_MAXTIME_RETRANSMIT,
phTmlNfc_ReTxTimerCb, NULL);
return wStatus;
}
/*******************************************************************************
**
** Function phTmlNfc_TmlThread
**
** Description Read the data from the lower layer driver
**
** Parameters pParam - parameters for Writer thread function
**
** Returns None
**
*******************************************************************************/
static void phTmlNfc_TmlThread(void *pParam)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
int32_t dwNoBytesWrRd = PH_TMLNFC_RESET_VALUE;
uint8_t temp[260];
/* Transaction info buffer to be passed to Callback Thread */
static phTmlNfc_TransactInfo_t tTransactionInfo;
/* Structure containing Tml callback function and parameters to be invoked
by the callback thread */
static phLibNfc_DeferredCall_t tDeferredInfo;
/* Initialize Message structure to post message onto Callback Thread */
static phLibNfc_Message_t tMsg;
UNUSED(pParam);
NXPLOG_TML_D("PN54X - Tml Reader Thread Started................\n");
/* Writer thread loop shall be running till shutdown is invoked */
while (gpphTmlNfc_Context->bThreadDone)
{
/* If Tml write is requested */
/* Set the variable to success initially */
wStatus = NFCSTATUS_SUCCESS;
sem_wait(&gpphTmlNfc_Context->rxSemaphore);
/* If Tml read is requested */
if (1 == gpphTmlNfc_Context->tReadInfo.bEnable)
{
NXPLOG_TML_D("PN54X - Read requested.....\n");
/* Set the variable to success initially */
wStatus = NFCSTATUS_SUCCESS;
/* Variable to fetch the actual number of bytes read */
dwNoBytesWrRd = PH_TMLNFC_RESET_VALUE;
/* Read the data from the file onto the buffer */
if (NULL != gpphTmlNfc_Context->pDevHandle)
{
NXPLOG_TML_D("PN54X - Invoking I2C Read.....\n");
dwNoBytesWrRd = phTmlNfc_i2c_read(gpphTmlNfc_Context->pDevHandle, temp, 260);
if (-1 == dwNoBytesWrRd)
{
NXPLOG_TML_E("PN54X - Error in I2C Read.....\n");
sem_post(&gpphTmlNfc_Context->rxSemaphore);
}
else if (dwNoBytesWrRd > 260)
{
NXPLOG_TML_E ("Numer of bytes read exceeds the limit 260.....\n");
sem_post (&gpphTmlNfc_Context->rxSemaphore);
}
else
{
memcpy(gpphTmlNfc_Context->tReadInfo.pBuffer, temp, dwNoBytesWrRd);
NXPLOG_TML_D("PN54X - I2C Read successful.....\n");
/* This has to be reset only after a successful read */
gpphTmlNfc_Context->tReadInfo.bEnable = 0;
if ((phTmlNfc_e_EnableRetrans == gpphTmlNfc_Context->eConfig) &&
(0x00 != (gpphTmlNfc_Context->tReadInfo.pBuffer[0] & 0xE0)))
{
NXPLOG_TML_D("PN54X - Retransmission timer stopped.....\n");
/* Stop Timer to prevent Retransmission */
uint32_t timerStatus = phOsalNfc_Timer_Stop(gpphTmlNfc_Context->dwTimerId);
if (NFCSTATUS_SUCCESS != timerStatus)
{
NXPLOG_TML_E("PN54X - timer stopped returned failure.....\n");
}
else
{
gpphTmlNfc_Context->bWriteCbInvoked = FALSE;
}
}
if (gpphTmlNfc_Context->tWriteInfo.bThreadBusy)
{
NXPLOG_TML_D ("Delay Read if write thread is busy");
usleep (2000); /*2ms delay to give prio to write complete */
}
/* Update the actual number of bytes read including header */
gpphTmlNfc_Context->tReadInfo.wLength = (uint16_t) (dwNoBytesWrRd);
phNxpNciHal_print_packet("RECV", gpphTmlNfc_Context->tReadInfo.pBuffer,
gpphTmlNfc_Context->tReadInfo.wLength);
dwNoBytesWrRd = PH_TMLNFC_RESET_VALUE;
/* Fill the Transaction info structure to be passed to Callback Function */
tTransactionInfo.wStatus = wStatus;
tTransactionInfo.pBuff = gpphTmlNfc_Context->tReadInfo.pBuffer;
/* Actual number of bytes read is filled in the structure */
tTransactionInfo.wLength = gpphTmlNfc_Context->tReadInfo.wLength;
/* Read operation completed successfully. Post a Message onto Callback Thread*/
/* Prepare the message to be posted on User thread */
tDeferredInfo.pCallback = &phTmlNfc_ReadDeferredCb;
tDeferredInfo.pParameter = &tTransactionInfo;
tMsg.eMsgType = PH_LIBNFC_DEFERREDCALL_MSG;
tMsg.pMsgData = &tDeferredInfo;
tMsg.Size = sizeof(tDeferredInfo);
NXPLOG_TML_D("PN54X - Posting read message.....\n");
phTmlNfc_DeferredCall(gpphTmlNfc_Context->dwCallbackThreadId, &tMsg);
}
}
else
{
NXPLOG_TML_D ("PN54X -gpphTmlNfc_Context->pDevHandle is NULL");
}
}
else
{
NXPLOG_TML_D("PN54X - read request NOT enabled");
usleep(10*1000);
}
}/* End of While loop */
return;
}
/*******************************************************************************
**
** Function phTmlNfc_TmlWriterThread
**
** Description Writes the requested data onto the lower layer driver
**
** Parameters pParam - context provided by upper layer
**
** Returns None
**
*******************************************************************************/
static void phTmlNfc_TmlWriterThread(void *pParam)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
int32_t dwNoBytesWrRd = PH_TMLNFC_RESET_VALUE;
/* Transaction info buffer to be passed to Callback Thread */
static phTmlNfc_TransactInfo_t tTransactionInfo;
/* Structure containing Tml callback function and parameters to be invoked
by the callback thread */
static phLibNfc_DeferredCall_t tDeferredInfo;
/* Initialize Message structure to post message onto Callback Thread */
static phLibNfc_Message_t tMsg;
/* In case of I2C Write Retry */
static uint16_t retry_cnt;
UNUSED(pParam);
NXPLOG_TML_D("PN54X - Tml Writer Thread Started................\n");
/* Writer thread loop shall be running till shutdown is invoked */
while (gpphTmlNfc_Context->bThreadDone)
{
NXPLOG_TML_D("PN54X - Tml Writer Thread Running................\n");
sem_wait(&gpphTmlNfc_Context->txSemaphore);
/* If Tml write is requested */
if (1 == gpphTmlNfc_Context->tWriteInfo.bEnable)
{
NXPLOG_TML_D("PN54X - Write requested.....\n");
/* Set the variable to success initially */
wStatus = NFCSTATUS_SUCCESS;
if (NULL != gpphTmlNfc_Context->pDevHandle)
{
retry:
gpphTmlNfc_Context->tWriteInfo.bEnable = 0;
/* Variable to fetch the actual number of bytes written */
dwNoBytesWrRd = PH_TMLNFC_RESET_VALUE;
/* Write the data in the buffer onto the file */
NXPLOG_TML_D("PN54X - Invoking I2C Write.....\n");
dwNoBytesWrRd = phTmlNfc_i2c_write(gpphTmlNfc_Context->pDevHandle,
gpphTmlNfc_Context->tWriteInfo.pBuffer,
gpphTmlNfc_Context->tWriteInfo.wLength
);
/* Try I2C Write Five Times, if it fails : Raju */
if (-1 == dwNoBytesWrRd)
{
if (getDownloadFlag() == TRUE)
{
if (retry_cnt++ < MAX_WRITE_RETRY_COUNT)
{
NXPLOG_NCIHAL_E(
"PN54X - Error in I2C Write - Retry 0x%x", retry_cnt);
goto retry;
}
}
NXPLOG_TML_E("PN54X - Error in I2C Write.....\n");
wStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_FAILED);
}
else
{
phNxpNciHal_print_packet("SEND", gpphTmlNfc_Context->tWriteInfo.pBuffer,
gpphTmlNfc_Context->tWriteInfo.wLength);
}
retry_cnt = 0;
if (NFCSTATUS_SUCCESS == wStatus)
{
NXPLOG_TML_D("PN54X - I2C Write successful.....\n");
dwNoBytesWrRd = PH_TMLNFC_VALUE_ONE;
}
/* Fill the Transaction info structure to be passed to Callback Function */
tTransactionInfo.wStatus = wStatus;
tTransactionInfo.pBuff = gpphTmlNfc_Context->tWriteInfo.pBuffer;
/* Actual number of bytes written is filled in the structure */
tTransactionInfo.wLength = (uint16_t) dwNoBytesWrRd;
/* Prepare the message to be posted on the User thread */
tDeferredInfo.pCallback = &phTmlNfc_WriteDeferredCb;
tDeferredInfo.pParameter = &tTransactionInfo;
/* Write operation completed successfully. Post a Message onto Callback Thread*/
tMsg.eMsgType = PH_LIBNFC_DEFERREDCALL_MSG;
tMsg.pMsgData = &tDeferredInfo;
tMsg.Size = sizeof(tDeferredInfo);
/* Check whether Retransmission needs to be started,
* If yes, Post message only if
* case 1. Message is not posted &&
* case 11. Write status is success ||
* case 12. Last retry of write is also failure
*/
if ((phTmlNfc_e_EnableRetrans == gpphTmlNfc_Context->eConfig) &&
(0x00 != (gpphTmlNfc_Context->tWriteInfo.pBuffer[0] & 0xE0)))
{
if (FALSE == gpphTmlNfc_Context->bWriteCbInvoked)
{
if ((NFCSTATUS_SUCCESS == wStatus) ||
(bCurrentRetryCount == 0))
{
NXPLOG_TML_D("PN54X - Posting Write message.....\n");
phTmlNfc_DeferredCall(gpphTmlNfc_Context->dwCallbackThreadId,
&tMsg);
gpphTmlNfc_Context->bWriteCbInvoked = TRUE;
}
}
}
else
{
NXPLOG_TML_D("PN54X - Posting Fresh Write message.....\n");
phTmlNfc_DeferredCall(gpphTmlNfc_Context->dwCallbackThreadId, &tMsg);
}
}
else
{
NXPLOG_TML_D ("PN54X - gpphTmlNfc_Context->pDevHandle is NULL");
}
/* If Data packet is sent, then NO retransmission */
if ((phTmlNfc_e_EnableRetrans == gpphTmlNfc_Context->eConfig) &&
(0x00 != (gpphTmlNfc_Context->tWriteInfo.pBuffer[0] & 0xE0)))
{
NXPLOG_TML_D("PN54X - Starting timer for Retransmission case");
wStatus = phTmlNfc_InitiateTimer();
if (NFCSTATUS_SUCCESS != wStatus)
{
/* Reset Variables used for Retransmission */
NXPLOG_TML_D("PN54X - Retransmission timer initiate failed");
gpphTmlNfc_Context->tWriteInfo.bEnable = 0;
bCurrentRetryCount = 0;
}
}
}
else
{
NXPLOG_TML_D("PN54X - Write request NOT enabled");
usleep(10000);
}
}/* End of While loop */
return;
}
/*******************************************************************************
**
** Function phTmlNfc_CleanUp
**
** Description Clears all handles opened during TML initialization
**
** Parameters None
**
** Returns None
**
*******************************************************************************/
static void phTmlNfc_CleanUp(void)
{
NFCSTATUS wRetval = NFCSTATUS_SUCCESS;
if (NULL != gpphTmlNfc_Context->pDevHandle)
{
(void) phTmlNfc_i2c_reset(gpphTmlNfc_Context->pDevHandle, 0);
gpphTmlNfc_Context->bThreadDone = 0;
}
sem_destroy(&gpphTmlNfc_Context->rxSemaphore);
sem_destroy(&gpphTmlNfc_Context->txSemaphore);
sem_destroy(&gpphTmlNfc_Context->postMsgSemaphore);
phTmlNfc_i2c_close(gpphTmlNfc_Context->pDevHandle);
gpphTmlNfc_Context->pDevHandle = NULL;
/* Clear memory allocated for storing Context variables */
free((void *) gpphTmlNfc_Context);
/* Set the pointer to NULL to indicate De-Initialization */
gpphTmlNfc_Context = NULL;
return;
}
/*******************************************************************************
**
** Function phTmlNfc_Shutdown
**
** Description Uninitializes TML layer and hardware interface
**
** Parameters None
**
** Returns NFC status:
** NFCSTATUS_SUCCESS - TML configuration released successfully
** NFCSTATUS_INVALID_PARAMETER - at least one parameter is invalid
** NFCSTATUS_FAILED - un-initialization failed (example: unable to close interface)
**
*******************************************************************************/
NFCSTATUS phTmlNfc_Shutdown(void)
{
NFCSTATUS wShutdownStatus = NFCSTATUS_SUCCESS;
/* Check whether TML is Initialized */
if (NULL != gpphTmlNfc_Context)
{
/* Reset thread variable to terminate the thread */
gpphTmlNfc_Context->bThreadDone = 0;
usleep(1000);
/* Clear All the resources allocated during initialization */
sem_post(&gpphTmlNfc_Context->rxSemaphore);
usleep(1000);
sem_post(&gpphTmlNfc_Context->txSemaphore);
usleep(1000);
sem_post(&gpphTmlNfc_Context->postMsgSemaphore);
usleep(1000);
sem_post(&gpphTmlNfc_Context->postMsgSemaphore);
usleep(1000);
if (0 != pthread_join(gpphTmlNfc_Context->readerThread, (void**)NULL))
{
NXPLOG_TML_E ("Fail to kill reader thread!");
}
if (0 != pthread_join(gpphTmlNfc_Context->writerThread, (void**)NULL))
{
NXPLOG_TML_E ("Fail to kill writer thread!");
}
NXPLOG_TML_D ("bThreadDone == 0");
phTmlNfc_CleanUp();
}
else
{
wShutdownStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_NOT_INITIALISED);
}
return wShutdownStatus;
}
/*******************************************************************************
**
** Function phTmlNfc_Write
**
** Description Asynchronously writes given data block to hardware interface/driver
** Enables writer thread if there are no write requests pending
** Returns successfully once writer thread completes write operation
** Notifies upper layer using callback mechanism
** NOTE:
** * it is important to post a message with id PH_TMLNFC_WRITE_MESSAGE
** to IntegrationThread after data has been written to PN54X
** * if CRC needs to be computed, then input buffer should be capable to store
** two more bytes apart from length of packet
**
** Parameters pBuffer - data to be sent
** wLength - length of data buffer
** pTmlWriteComplete - pointer to the function to be invoked upon completion
** pContext - context provided by upper layer
**
** Returns NFC status:
** NFCSTATUS_PENDING - command is yet to be processed
** NFCSTATUS_INVALID_PARAMETER - at least one parameter is invalid
** NFCSTATUS_BUSY - write request is already in progress
**
*******************************************************************************/
NFCSTATUS phTmlNfc_Write(uint8_t *pBuffer, uint16_t wLength, pphTmlNfc_TransactCompletionCb_t pTmlWriteComplete, void *pContext)
{
NFCSTATUS wWriteStatus;
/* Check whether TML is Initialized */
if (NULL != gpphTmlNfc_Context)
{
if ((NULL != gpphTmlNfc_Context->pDevHandle) && (NULL != pBuffer) &&
(PH_TMLNFC_RESET_VALUE != wLength) && (NULL != pTmlWriteComplete))
{
if (!gpphTmlNfc_Context->tWriteInfo.bThreadBusy)
{
/* Setting the flag marks beginning of a Write Operation */
gpphTmlNfc_Context->tWriteInfo.bThreadBusy = TRUE;
/* Copy the buffer, length and Callback function,
This shall be utilized while invoking the Callback function in thread */
gpphTmlNfc_Context->tWriteInfo.pBuffer = pBuffer;
gpphTmlNfc_Context->tWriteInfo.wLength = wLength;
gpphTmlNfc_Context->tWriteInfo.pThread_Callback = pTmlWriteComplete;
gpphTmlNfc_Context->tWriteInfo.pContext = pContext;
wWriteStatus = NFCSTATUS_PENDING;
//FIXME: If retry is going on. Stop the retry thread/timer
if (phTmlNfc_e_EnableRetrans == gpphTmlNfc_Context->eConfig)
{
/* Set retry count to default value */
//FIXME: If the timer expired there, and meanwhile we have created
// a new request. The expired timer will think that retry is still
// ongoing.
bCurrentRetryCount = gpphTmlNfc_Context->bRetryCount;
gpphTmlNfc_Context->bWriteCbInvoked = FALSE;
}
/* Set event to invoke Writer Thread */
gpphTmlNfc_Context->tWriteInfo.bEnable = 1;
sem_post(&gpphTmlNfc_Context->txSemaphore);
}
else
{
wWriteStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_BUSY);
}
}
else
{
wWriteStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_INVALID_PARAMETER);
}
}
else
{
wWriteStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_NOT_INITIALISED);
}
return wWriteStatus;
}
/*******************************************************************************
**
** Function phTmlNfc_Read
**
** Description Asynchronously reads data from the driver
** Number of bytes to be read and buffer are passed by upper layer
** Enables reader thread if there are no read requests pending
** Returns successfully once read operation is completed
** Notifies upper layer using callback mechanism
**
** Parameters pBuffer - location to send read data to the upper layer via callback
** wLength - length of read data buffer passed by upper layer
** pTmlReadComplete - pointer to the function to be invoked upon completion of read operation
** pContext - context provided by upper layer
**
** Returns NFC status:
** NFCSTATUS_PENDING - command is yet to be processed
** NFCSTATUS_INVALID_PARAMETER - at least one parameter is invalid
** NFCSTATUS_BUSY - read request is already in progress
**
*******************************************************************************/
NFCSTATUS phTmlNfc_Read(uint8_t *pBuffer, uint16_t wLength, pphTmlNfc_TransactCompletionCb_t pTmlReadComplete, void *pContext)
{
NFCSTATUS wReadStatus;
/* Check whether TML is Initialized */
if (NULL != gpphTmlNfc_Context)
{
if ((gpphTmlNfc_Context->pDevHandle != NULL) && (NULL != pBuffer) &&
(PH_TMLNFC_RESET_VALUE != wLength) && (NULL != pTmlReadComplete))
{
if (!gpphTmlNfc_Context->tReadInfo.bThreadBusy)
{
/* Setting the flag marks beginning of a Read Operation */
gpphTmlNfc_Context->tReadInfo.bThreadBusy = TRUE;
/* Copy the buffer, length and Callback function,
This shall be utilized while invoking the Callback function in thread */
gpphTmlNfc_Context->tReadInfo.pBuffer = pBuffer;
gpphTmlNfc_Context->tReadInfo.wLength = wLength;
gpphTmlNfc_Context->tReadInfo.pThread_Callback = pTmlReadComplete;
gpphTmlNfc_Context->tReadInfo.pContext = pContext;
wReadStatus = NFCSTATUS_PENDING;
/* Set event to invoke Reader Thread */
gpphTmlNfc_Context->tReadInfo.bEnable = 1;
sem_post(&gpphTmlNfc_Context->rxSemaphore);
}
else
{
wReadStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_BUSY);
}
}
else
{
wReadStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_INVALID_PARAMETER);
}
}
else
{
wReadStatus = PHNFCSTVAL(CID_NFC_TML, NFCSTATUS_NOT_INITIALISED);
}
return wReadStatus;
}
/*******************************************************************************
**
** Function phTmlNfc_ReadAbort
**
** Description Aborts pending read request (if any)
**
** Parameters None
**
** Returns NFC status:
** NFCSTATUS_SUCCESS - ongoing read operation aborted
** NFCSTATUS_INVALID_PARAMETER - at least one parameter is invalid
** NFCSTATUS_NOT_INITIALIZED - TML layer is not initialized
** NFCSTATUS_BOARD_COMMUNICATION_ERROR - unable to cancel read operation
**
*******************************************************************************/
NFCSTATUS phTmlNfc_ReadAbort(void)
{
NFCSTATUS wStatus = NFCSTATUS_INVALID_PARAMETER;
gpphTmlNfc_Context->tReadInfo.bEnable = 0;
/*Reset the flag to accept another Read Request */
gpphTmlNfc_Context->tReadInfo.bThreadBusy=FALSE;
wStatus = NFCSTATUS_SUCCESS;
return wStatus;
}
/*******************************************************************************
**
** Function phTmlNfc_WriteAbort
**
** Description Aborts pending write request (if any)
**
** Parameters None
**
** Returns NFC status:
** NFCSTATUS_SUCCESS - ongoing write operation aborted
** NFCSTATUS_INVALID_PARAMETER - at least one parameter is invalid
** NFCSTATUS_NOT_INITIALIZED - TML layer is not initialized
** NFCSTATUS_BOARD_COMMUNICATION_ERROR - unable to cancel write operation
**
*******************************************************************************/
NFCSTATUS phTmlNfc_WriteAbort(void)
{
NFCSTATUS wStatus = NFCSTATUS_INVALID_PARAMETER;
gpphTmlNfc_Context->tWriteInfo.bEnable = 0;
/* Stop if any retransmission is in progress */
bCurrentRetryCount = 0;
/* Reset the flag to accept another Write Request */
gpphTmlNfc_Context->tWriteInfo.bThreadBusy=FALSE;
wStatus = NFCSTATUS_SUCCESS;
return wStatus;
}
/*******************************************************************************
**
** Function phTmlNfc_IoCtl
**
** Description Resets device when insisted by upper layer
** Number of bytes to be read and buffer are passed by upper layer
** Enables reader thread if there are no read requests pending
** Returns successfully once read operation is completed
** Notifies upper layer using callback mechanism
**
** Parameters eControlCode - control code for a specific operation
**
** Returns NFC status:
** NFCSTATUS_SUCCESS - ioctl command completed successfully
** NFCSTATUS_FAILED - ioctl command request failed
**
*******************************************************************************/
NFCSTATUS phTmlNfc_IoCtl(phTmlNfc_ControlCode_t eControlCode)
{
NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
if (NULL == gpphTmlNfc_Context)
{
wStatus = NFCSTATUS_FAILED;
}
else
{
switch (eControlCode)
{
case phTmlNfc_e_ResetDevice:
{
/*Reset PN54X*/
phTmlNfc_i2c_reset(gpphTmlNfc_Context->pDevHandle, 1);
usleep(100 * 1000);
phTmlNfc_i2c_reset(gpphTmlNfc_Context->pDevHandle, 0);
usleep(100 * 1000);
phTmlNfc_i2c_reset(gpphTmlNfc_Context->pDevHandle, 1);
break;
}
case phTmlNfc_e_EnableNormalMode:
{
/*Reset PN54X*/
phTmlNfc_i2c_reset(gpphTmlNfc_Context->pDevHandle, 0);
usleep(10 * 1000);
phTmlNfc_i2c_reset(gpphTmlNfc_Context->pDevHandle, 1);
usleep(100 * 1000);
break;
}
case phTmlNfc_e_EnableDownloadMode:
{
phTmlNfc_ConfigNciPktReTx(phTmlNfc_e_DisableRetrans, 0);
(void)phTmlNfc_i2c_reset(gpphTmlNfc_Context->pDevHandle,2);
usleep(100 * 1000);
break;
}
default:
{
wStatus = NFCSTATUS_INVALID_PARAMETER;
break;
}
}
}
return wStatus;
}
/*******************************************************************************
**
** Function phTmlNfc_DeferredCall
**
** Description Posts message on upper layer thread
** upon successful read or write operation
**
** Parameters dwThreadId - id of the thread posting message
** ptWorkerMsg - message to be posted
**
** Returns None
**
*******************************************************************************/
void phTmlNfc_DeferredCall(uintptr_t dwThreadId, phLibNfc_Message_t *ptWorkerMsg)
{
intptr_t bPostStatus;
UNUSED(dwThreadId);
/* Post message on the user thread to invoke the callback function */
sem_wait(&gpphTmlNfc_Context->postMsgSemaphore);
bPostStatus = phDal4Nfc_msgsnd(gpphTmlNfc_Context->dwCallbackThreadId,
ptWorkerMsg,
0
);
sem_post(&gpphTmlNfc_Context->postMsgSemaphore);
}
/*******************************************************************************
**
** Function phTmlNfc_ReadDeferredCb
**
** Description Read thread call back function
**
** Parameters pParams - context provided by upper layer
**
** Returns None
**
*******************************************************************************/
static void phTmlNfc_ReadDeferredCb(void *pParams)
{
/* Transaction info buffer to be passed to Callback Function */
phTmlNfc_TransactInfo_t *pTransactionInfo = (phTmlNfc_TransactInfo_t *) pParams;
/* Reset the flag to accept another Read Request */
gpphTmlNfc_Context->tReadInfo.bThreadBusy = FALSE;
gpphTmlNfc_Context->tReadInfo.pThread_Callback(gpphTmlNfc_Context->tReadInfo.pContext,
pTransactionInfo);
return;
}
/*******************************************************************************
**
** Function phTmlNfc_WriteDeferredCb
**
** Description Write thread call back function
**
** Parameters pParams - context provided by upper layer
**
** Returns None
**
*******************************************************************************/
static void phTmlNfc_WriteDeferredCb(void *pParams)
{
/* Transaction info buffer to be passed to Callback Function */
phTmlNfc_TransactInfo_t *pTransactionInfo = (phTmlNfc_TransactInfo_t *) pParams;
/* Reset the flag to accept another Write Request */
gpphTmlNfc_Context->tWriteInfo.bThreadBusy = FALSE;
gpphTmlNfc_Context->tWriteInfo.pThread_Callback(gpphTmlNfc_Context->tWriteInfo.pContext,
pTransactionInfo);
return;
}
void phTmlNfc_set_fragmentation_enabled(phTmlNfc_i2cfragmentation_t result)
{
fragmentation_enabled = result;
}
phTmlNfc_i2cfragmentation_t phTmlNfc_get_fragmentation_enabled()
{
return fragmentation_enabled;
}