| /* |
| * Copyright 2012-2014,2018-2020 NXP |
| * |
| * 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 <phEseTypes.h> |
| #include <phNxpEseProto7816_3.h> |
| #include <phNxpEsePal_i2c.h> |
| #include "sm_types.h" |
| #include "sm_timer.h" |
| |
| #ifdef FLOW_VERBOSE |
| #define NX_LOG_ENABLE_SMCOM_DEBUG 1 |
| #endif |
| |
| #include "nxLog_smCom.h" |
| #include "nxEnsure.h" |
| |
| #if defined(USE_RTOS) && USE_RTOS == 1 |
| #include "FreeRTOSConfig.h" |
| #include "FreeRTOS.h" |
| #endif |
| |
| #define RECIEVE_PACKET_SOF 0xA5 |
| #define CHAINED_PACKET_WITHSEQN 0x60 |
| #define CHAINED_PACKET_WITHOUTSEQN 0x20 |
| static int phNxpEse_readPacket(void* conn_ctx, void *pDevHandle, uint8_t * pBuffer, int nNbBytesToRead); |
| static int poll_sof_chained_delay = 0; |
| |
| /*********************** Global Variables *************************************/ |
| |
| /* ESE Context structure */ |
| phNxpEse_Context_t gnxpese_ctxt; |
| |
| /****************************************************************************** |
| * Function phNxpEse_init |
| * |
| * Description This function is called by smCom during the |
| * initialization of the ESE. It initializes protocol stack instance variable |
| * |
| * param[in] connection context |
| * param[in] phNxpEse_initParams: ESE communication mode |
| * param[out] phNxpEse_data: ATR Response from ESE |
| * |
| * Returns This function return ESESTATUS_SUCCES (0) in case of success |
| * In case of failure returns other failure value. |
| * |
| ******************************************************************************/ |
| ESESTATUS phNxpEse_init(void *conn_ctx, phNxpEse_initParams initParams, phNxpEse_data *AtrRsp) |
| { |
| ESESTATUS wConfigStatus = ESESTATUS_SUCCESS; |
| phNxpEse_Context_t* nxpese_ctxt = (conn_ctx == NULL) ? &gnxpese_ctxt : (phNxpEse_Context_t*)conn_ctx; |
| bool_t status = FALSE; |
| phNxpEseProto7816InitParam_t protoInitParam; |
| phNxpEse_memset(&protoInitParam, 0x00, sizeof(phNxpEseProto7816InitParam_t)); |
| protoInitParam.rnack_retry_limit = MAX_RNACK_RETRY_LIMIT; |
| protoInitParam.wtx_counter_limit = PH_PROTO_WTX_DEFAULT_COUNT; |
| |
| if (ESE_MODE_NORMAL == initParams.initMode) /* TZ/Normal wired mode should come here*/ |
| { |
| protoInitParam.interfaceReset = TRUE; |
| } |
| else |
| { |
| protoInitParam.interfaceReset = FALSE; |
| /*RFU*/ |
| } |
| |
| /* T=1 Protocol layer open */ |
| status = phNxpEseProto7816_Open((void*)nxpese_ctxt, protoInitParam , AtrRsp); |
| if(FALSE == status) |
| { |
| wConfigStatus = ESESTATUS_FAILED; |
| LOG_E("phNxpEseProto7816_Open failed "); |
| } |
| return wConfigStatus; |
| } |
| |
| /****************************************************************************** |
| * Function phNxpEse_open |
| * |
| * Description This function is called by smCom during the |
| * initialization of the ESE. It opens the physical connection |
| * with ESE and initializes the protocol stack |
| * |
| * param[in] Pointer to connection context |
| * param[in] phNxpEse_initParams: ESE communication mode |
| * |
| * Returns This function return ESESTATUS_SUCCES (0) in case of success |
| * In case of failure returns other failure value. |
| * |
| ******************************************************************************/ |
| ESESTATUS phNxpEse_open(void **conn_ctx, phNxpEse_initParams initParams, const char *pConnString) |
| { |
| phPalEse_Config_t tPalConfig; |
| phNxpEse_Context_t *pnxpese_ctxt = NULL; |
| ESESTATUS wConfigStatus = ESESTATUS_SUCCESS; |
| |
| if (conn_ctx == NULL) { |
| pnxpese_ctxt = &gnxpese_ctxt; |
| } |
| else { |
| pnxpese_ctxt = (phNxpEse_Context_t*)phNxpEse_memalloc(sizeof(phNxpEse_Context_t)); |
| phNxpEse_memset(pnxpese_ctxt, 0, sizeof(phNxpEse_Context_t)); |
| *conn_ctx = pnxpese_ctxt; |
| } |
| |
| /*When I2C channel is already opened return status as FAILED*/ |
| if(pnxpese_ctxt->EseLibStatus != ESE_STATUS_CLOSE) |
| { |
| LOG_E(" Session already opened"); |
| return ESESTATUS_BUSY; |
| } |
| |
| phNxpEse_memset(pnxpese_ctxt, 0x00, sizeof(phNxpEse_Context_t)); |
| phNxpEse_memset(&tPalConfig, 0x00, sizeof(tPalConfig)); |
| |
| tPalConfig.pDevName = (int8_t *)pConnString; //"/dev/p73"; /*RFU*/ |
| /* Initialize PAL layer */ |
| wConfigStatus = phPalEse_i2c_open_and_configure(&tPalConfig); |
| if (wConfigStatus != ESESTATUS_SUCCESS) |
| { |
| LOG_E("phPalEse_Init Failed"); |
| goto clean_and_return; |
| } |
| /* Copying device handle to ESE Lib context*/ |
| pnxpese_ctxt->pDevHandle = tPalConfig.pDevHandle; |
| /* STATUS_OPEN */ |
| pnxpese_ctxt->EseLibStatus = ESE_STATUS_OPEN; |
| phNxpEse_memcpy(&pnxpese_ctxt->initParams, &initParams, sizeof(phNxpEse_initParams)); |
| return wConfigStatus; |
| |
| clean_and_return: |
| if (NULL != pnxpese_ctxt->pDevHandle) |
| { |
| phPalEse_i2c_close(pnxpese_ctxt->pDevHandle); |
| phNxpEse_memset (pnxpese_ctxt, 0x00, sizeof (phNxpEse_Context_t)); |
| } |
| pnxpese_ctxt->EseLibStatus = ESE_STATUS_CLOSE; |
| return ESESTATUS_FAILED; |
| } |
| |
| /****************************************************************************** |
| * Function phNxpEse_Transceive |
| * |
| * Description This function validate ESE state & C-APDU data before sending |
| * it to 7816 protocol |
| * |
| * param[in] connection context |
| * param[in] phNxpEse_data: Command to ESE C-APDU |
| * param[out] phNxpEse_data: Response from ESE R-APDU |
| * |
| * Returns On Success ESESTATUS_SUCCESS else proper error code |
| * |
| ******************************************************************************/ |
| ESESTATUS phNxpEse_Transceive(void* conn_ctx, phNxpEse_data *pCmd, phNxpEse_data *pRsp) |
| { |
| ESESTATUS status = ESESTATUS_FAILED; |
| bool_t bStatus = FALSE; |
| phNxpEse_Context_t* nxpese_ctxt = (conn_ctx == NULL) ? &gnxpese_ctxt : (phNxpEse_Context_t*)conn_ctx; |
| |
| if((NULL == pCmd) || (NULL == pRsp)) |
| return ESESTATUS_INVALID_PARAMETER; |
| |
| if ((pCmd->len == 0) || pCmd->p_data == NULL ) |
| { |
| LOG_E(" phNxpEse_Transceive - Invalid Parameter no data"); |
| return ESESTATUS_INVALID_PARAMETER; |
| } |
| else if ((ESE_STATUS_CLOSE == nxpese_ctxt->EseLibStatus)) |
| { |
| LOG_E(" %s ESE Not Initialized ", __FUNCTION__); |
| return ESESTATUS_NOT_INITIALISED; |
| } |
| else if ((ESE_STATUS_BUSY == nxpese_ctxt->EseLibStatus)) |
| { |
| LOG_E(" %s ESE - BUSY ", __FUNCTION__); |
| return ESESTATUS_BUSY; |
| } |
| else |
| { |
| nxpese_ctxt->EseLibStatus = ESE_STATUS_BUSY; |
| bStatus = phNxpEseProto7816_Transceive((void*)nxpese_ctxt, pCmd, pRsp); |
| if(TRUE == bStatus) |
| { |
| status = ESESTATUS_SUCCESS; |
| } |
| else |
| { |
| status = ESESTATUS_FAILED; |
| } |
| |
| if (ESESTATUS_SUCCESS != status) |
| { |
| LOG_E(" %s phNxpEseProto7816_Transceive- Failed ", __FUNCTION__); |
| } |
| if (nxpese_ctxt->EseLibStatus != ESE_STATUS_CLOSE) { |
| nxpese_ctxt->EseLibStatus = ESE_STATUS_IDLE; |
| } |
| |
| LOG_D(" %s Exit status 0x%x ", __FUNCTION__, status); |
| return status; |
| } |
| } |
| |
| /****************************************************************************** |
| * Function phNxpEse_reset |
| * |
| * Description This function reset the ESE interface and free all |
| * |
| * param[in] connection context |
| * |
| * Returns It returns ESESTATUS_SUCCESS (0) if the operation is successful else |
| * ESESTATUS_FAILED(1) |
| ******************************************************************************/ |
| ESESTATUS phNxpEse_reset(void* conn_ctx) |
| { |
| ESESTATUS status = ESESTATUS_FAILED; |
| phNxpEse_Context_t* nxpese_ctxt = (conn_ctx == NULL) ? &gnxpese_ctxt : (phNxpEse_Context_t*)conn_ctx; |
| //bool_t bStatus = phNxpEseProto7816_IntfReset(&AtrRsp); |
| status = phNxpEse_chipReset((void*)nxpese_ctxt); |
| if (status != ESESTATUS_SUCCESS) |
| { |
| LOG_E("phNxpEse_reset Failed"); |
| } |
| return status; |
| } |
| |
| /****************************************************************************** |
| * Function phNxpEse_EndOfApdu |
| * |
| * Description This function is used to send S-frame to indicate END_OF_APDU |
| * |
| * param[in] connection context |
| * |
| * Returns It returns ESESTATUS_SUCCESS (0) if the operation is successful else |
| * ESESTATUS_FAILED(1) |
| * |
| ******************************************************************************/ |
| ESESTATUS phNxpEse_EndOfApdu(void* conn_ctx) |
| { |
| ESESTATUS status = ESESTATUS_SUCCESS; |
| phNxpEse_Context_t* nxpese_ctxt = (conn_ctx == NULL) ? &gnxpese_ctxt : (phNxpEse_Context_t*)conn_ctx; |
| bool_t bStatus = phNxpEseProto7816_Close((void*)nxpese_ctxt); |
| if(!bStatus) |
| status = ESESTATUS_FAILED; |
| return status; |
| } |
| |
| |
| /****************************************************************************** |
| * Function phNxpEse_chipReset |
| * |
| * Description This function is used to reset the ESE. |
| * |
| * param[in] connection context |
| * |
| * Returns On Success ESESTATUS_SUCCESS (0) else ESESTATUS_FAILED (1). |
| * |
| ******************************************************************************/ |
| ESESTATUS phNxpEse_chipReset(void* conn_ctx) |
| { |
| ESESTATUS status = ESESTATUS_SUCCESS; |
| bool_t bStatus = FALSE; |
| phNxpEse_Context_t* nxpese_ctxt = (conn_ctx == NULL) ? &gnxpese_ctxt : (phNxpEse_Context_t*)conn_ctx; |
| bStatus = phNxpEseProto7816_Reset(); |
| if(!bStatus) |
| { |
| status = ESESTATUS_FAILED; |
| LOG_E("phNxpEseProto7816_Reset Failed"); |
| } |
| #if defined(T1oI2C_UM11225) |
| bStatus = phNxpEseProto7816_ChipReset((void*)nxpese_ctxt); |
| #elif defined(T1oI2C_GP1_0) |
| bStatus = phNxpEseProto7816_ColdReset((void*)nxpese_ctxt); |
| #endif |
| if (bStatus != TRUE) |
| { |
| LOG_E("phNxpEse_chipReset Failed"); |
| } |
| return status; |
| } |
| |
| /****************************************************************************** |
| * Function phNxpEse_deInit |
| * |
| * Description This function de-initializes all the ESE protocol params |
| * |
| * param[in] connection context |
| * |
| * Returns On Success ESESTATUS_SUCCESS (0) else ESESTATUS_FAILED (1). |
| * |
| ******************************************************************************/ |
| ESESTATUS phNxpEse_deInit(void* conn_ctx) |
| { |
| ESESTATUS status = ESESTATUS_SUCCESS; |
| //bool_t bStatus = FALSE; |
| phNxpEse_Context_t* nxpese_ctxt = (conn_ctx == NULL) ? &gnxpese_ctxt : (phNxpEse_Context_t*)conn_ctx; |
| /*bStatus = phNxpEseProto7816_ResetProtoParams(); |
| if(!bStatus) |
| { |
| status = ESESTATUS_FAILED; |
| }*/ |
| phPalEse_i2c_close(nxpese_ctxt->pDevHandle); |
| phNxpEse_memset (nxpese_ctxt, 0x00, sizeof (*nxpese_ctxt)); |
| //status= phNxpEse_close(); |
| return status; |
| } |
| |
| /****************************************************************************** |
| * Function phNxpEse_close |
| * |
| * Description This function close the ESE interface and free all |
| * resources. |
| * |
| * param[in] connection context |
| * |
| * Returns On Success ESESTATUS_SUCCESS else proper error code. |
| * |
| ******************************************************************************/ |
| ESESTATUS phNxpEse_close(void* conn_ctx) |
| { |
| ESESTATUS status = ESESTATUS_SUCCESS; |
| phNxpEse_Context_t* nxpese_ctxt = (conn_ctx == NULL) ? &gnxpese_ctxt : (phNxpEse_Context_t*)conn_ctx; |
| |
| if ((ESE_STATUS_CLOSE == nxpese_ctxt->EseLibStatus)) |
| { |
| LOG_E(" %s ESE Not Initialized previously ", __FUNCTION__); |
| return ESESTATUS_NOT_INITIALISED; |
| } |
| |
| phPalEse_i2c_close(nxpese_ctxt->pDevHandle); |
| phNxpEse_memset (nxpese_ctxt, 0x00, sizeof (*nxpese_ctxt)); |
| LOG_D("phNxpEse_close - ESE Context deinit completed"); |
| /* Return success always */ |
| if(conn_ctx != NULL){ |
| /*free the memory allocated during phNxpEse_open*/ |
| phNxpEse_free(conn_ctx); |
| } |
| return status; |
| } |
| |
| /****************************************************************************** |
| * Function phNxpEse_clearReadBuffer |
| * |
| * Description This function read out complete data from SE FIFO read buffer |
| * interface (e.g. I2C) using the driver interface. |
| * Just to make sure that if host is unable to read complete data |
| * during previous transaction |
| * |
| * param[in] void*: connection context |
| * |
| * Returns void |
| * |
| ******************************************************************************/ |
| void phNxpEse_clearReadBuffer(void* conn_ctx) |
| { |
| int ret = -1; |
| uint8_t readBuf[MAX_DATA_LEN]; |
| phNxpEse_Context_t* nxpese_ctxt = (conn_ctx == NULL) ? &gnxpese_ctxt : (phNxpEse_Context_t*)conn_ctx; |
| |
| LOG_D("%s Enter ..", __FUNCTION__); |
| |
| ret = phPalEse_i2c_read(nxpese_ctxt->pDevHandle, readBuf, MAX_DATA_LEN); |
| if(ret < 0) |
| { |
| /* Do nothing as nothing to read*/ |
| } |
| else |
| { |
| LOG_W("Previous transaction buffer is now cleard"); |
| LOG_MAU8_D("RAW Rx<",readBuf,ret ); |
| } |
| return; |
| } |
| |
| |
| /****************************************************************************** |
| * Function phNxpEse_read |
| * |
| * Description This function read the data from ESE through physical |
| * interface (e.g. I2C) using the driver interface. |
| * |
| * param[in] void*: connection context |
| * param[out] uint32_t: number of bytes read |
| * param[out] uint8_t : Read data from ESE |
| * |
| * Returns It returns ESESTATUS_SUCCESS (0) if read successful else |
| * ESESTATUS_FAILED(1) |
| * |
| ******************************************************************************/ |
| ESESTATUS phNxpEse_read(void* conn_ctx, uint32_t *data_len, uint8_t **pp_data) |
| { |
| ESESTATUS status = ESESTATUS_FAILED; |
| int ret = -1; |
| phNxpEse_Context_t* nxpese_ctxt = (conn_ctx == NULL) ? &gnxpese_ctxt : (phNxpEse_Context_t*)conn_ctx; |
| |
| LOG_D("%s Enter ..", __FUNCTION__); |
| |
| ENSURE_OR_GO_EXIT(data_len != NULL); |
| ENSURE_OR_GO_EXIT(pp_data != NULL); |
| |
| ret = phNxpEse_readPacket((void*)nxpese_ctxt, nxpese_ctxt->pDevHandle, nxpese_ctxt->p_read_buff, MAX_DATA_LEN); |
| if(ret < 0) |
| { |
| LOG_E("PAL Read status error status = %x", status); |
| status = ESESTATUS_FAILED; |
| } |
| else |
| { |
| LOG_MAU8_D("RAW Rx<",nxpese_ctxt->p_read_buff,ret ); |
| *data_len = ret; |
| *pp_data = nxpese_ctxt->p_read_buff; |
| status = ESESTATUS_SUCCESS; |
| } |
| exit: |
| return status; |
| } |
| |
| /****************************************************************************** |
| * Function phNxpEse_readPacket |
| * |
| * Description This function Reads requested number of bytes from |
| * ESE device into given buffer. |
| * |
| * param[in] void*: connection context |
| * param[in] void: ESE Context |
| * param[in] uint8_t: pointer to read buffer |
| * param[in] int : MAX bytes to read |
| * |
| * Returns ret - number of successfully read bytes |
| * -1 - read operation failure |
| * |
| ******************************************************************************/ |
| static int phNxpEse_readPacket(void* conn_ctx, void *pDevHandle, uint8_t * pBuffer, int nNbBytesToRead) |
| { |
| int ret = -1; |
| int sof_counter = 0;/* one read may take 1 ms*/ |
| int total_count = 0 ,numBytesToRead=0, headerIndex=0; |
| phNxpEse_Context_t* nxpese_ctxt = (conn_ctx == NULL) ? &gnxpese_ctxt : (phNxpEse_Context_t*)conn_ctx; |
| |
| ENSURE_OR_GO_EXIT(pBuffer != NULL); |
| memset(pBuffer,0,nNbBytesToRead); |
| do |
| { |
| sof_counter++; |
| ret = -1; |
| sm_sleep(ESE_POLL_DELAY_MS); /* 1ms delay to give ESE polling delay */ |
| ret = phPalEse_i2c_read(pDevHandle, pBuffer, 2); /*read NAD PCB byte first*/ |
| if (ret < 0) |
| { |
| /*Polling for read on i2c, hence Debug log*/ |
| LOG_D("_i2c_read() [HDR]errno : %x ret : %X", errno, ret); |
| } |
| if(pBuffer[0] == RECIEVE_PACKET_SOF) |
| { |
| /* Read the HEADR of Two bytes*/ |
| LOG_D("%s Read HDR", __FUNCTION__); |
| pBuffer[0] = RECIEVE_PACKET_SOF; |
| #if defined(T1oI2C_UM11225) |
| numBytesToRead = 1; |
| #elif defined(T1oI2C_GP1_0) |
| numBytesToRead = 2; |
| #endif |
| headerIndex = 1; |
| break; |
| } |
| if(pBuffer[1] == RECIEVE_PACKET_SOF) |
| { |
| /* Read the HEADR of Two bytes*/ |
| LOG_D("%s Read HDR", __FUNCTION__); |
| pBuffer[0] = RECIEVE_PACKET_SOF; |
| #if defined(T1oI2C_UM11225) |
| numBytesToRead = 2; |
| #elif defined(T1oI2C_GP1_0) |
| numBytesToRead = 3; |
| #endif |
| headerIndex = 0; |
| break; |
| } |
| /*if host writes invalid frame and host and SE are out of sync*/ |
| if((pBuffer[0] == 0x00)&&((pBuffer[1] == 0x82)||(pBuffer[1] == 0x92))) |
| { |
| LOG_W("%s Recieved NAD byte 0x%x ",__FUNCTION__,pBuffer[0]); |
| LOG_W("%s NAD error, clearing the read buffer ", __FUNCTION__); |
| /*retry to get all data*/ |
| #if defined(T1oI2C_UM11225) |
| numBytesToRead = 1; |
| #elif defined(T1oI2C_GP1_0) |
| numBytesToRead = 2; |
| #endif |
| headerIndex = 1; |
| ret = phPalEse_i2c_read(pDevHandle, &pBuffer[1+headerIndex], numBytesToRead); |
| #if defined(T1oI2C_UM11225) |
| total_count = 3; |
| nNbBytesToRead = pBuffer[2]; |
| #elif defined(T1oI2C_GP1_0) |
| total_count = 4; |
| nNbBytesToRead = (pBuffer[2] << 8 & 0xFF) | (pBuffer[3] & 0xFF) ; |
| #endif |
| /* Read the Complete data + two byte CRC*/ |
| ret = phPalEse_i2c_read(pDevHandle, &pBuffer[PH_PROTO_7816_HEADER_LEN], (nNbBytesToRead+PH_PROTO_7816_CRC_LEN)); |
| if (ret < 0) |
| { |
| LOG_D("_i2c_read() [HDR]errno : %x ret : %X", errno, ret); |
| ret = -1; |
| } |
| else |
| { |
| ret = (total_count + (nNbBytesToRead + PH_PROTO_7816_CRC_LEN)); |
| } |
| break; |
| } |
| /*If it is Chained packet wait for 1 ms*/ |
| if(poll_sof_chained_delay == 1) |
| { |
| LOG_D("%s Chained Pkt, delay read %dms",__FUNCTION__,ESE_POLL_DELAY_MS * CHAINED_PKT_SCALER); |
| sm_sleep(ESE_POLL_DELAY_MS); |
| } |
| else |
| { |
| LOG_D("%s Normal Pkt, delay read %dms",__FUNCTION__,ESE_POLL_DELAY_MS * NAD_POLLING_SCALER); |
| sm_sleep(ESE_POLL_DELAY_MS); |
| } |
| } while ((sof_counter < ESE_NAD_POLLING_MAX) && (nxpese_ctxt->EseLibStatus!= ESE_STATUS_CLOSE)); |
| if((pBuffer[0] == RECIEVE_PACKET_SOF) && (ret > 0)) |
| { |
| LOG_D("%s SOF FOUND", __FUNCTION__); |
| /* Read the HEADR of one/Two bytes based on how two bytes read A5 PCB or 00 A5*/ |
| ret = phPalEse_i2c_read(pDevHandle, &pBuffer[1+headerIndex], numBytesToRead); |
| if (ret < 0) |
| { |
| LOG_D("_i2c_read() [HDR]errno : %x ret : %X", errno, ret); |
| } |
| if((pBuffer[1] == CHAINED_PACKET_WITHOUTSEQN) || (pBuffer[1] == CHAINED_PACKET_WITHSEQN)) |
| { |
| poll_sof_chained_delay = 1; |
| LOG_D("poll_sof_chained_delay value is %d ", poll_sof_chained_delay); |
| } |
| else |
| { |
| poll_sof_chained_delay = 0; |
| LOG_D("poll_sof_chained_delay value is %d ", poll_sof_chained_delay); |
| } |
| #if defined(T1oI2C_UM11225) |
| total_count = 3; |
| nNbBytesToRead = pBuffer[2]; |
| #elif defined(T1oI2C_GP1_0) |
| total_count = 4; |
| nNbBytesToRead = (pBuffer[2] << 8 & 0xFF) | (pBuffer[3] & 0xFF) ; |
| #endif |
| /* Read the Complete data + two byte CRC*/ |
| ret = phPalEse_i2c_read(pDevHandle, &pBuffer[PH_PROTO_7816_HEADER_LEN], (nNbBytesToRead+PH_PROTO_7816_CRC_LEN)); |
| if (ret < 0) |
| { |
| LOG_D("_i2c_read() [HDR]errno : %x ret : %X", errno, ret); |
| ret = -1; |
| } |
| else |
| { |
| ret = (total_count + (nNbBytesToRead+PH_PROTO_7816_CRC_LEN)); |
| } |
| } |
| else |
| { |
| ret=-1; |
| } |
| exit: |
| return ret; |
| } |
| /****************************************************************************** |
| * Function phNxpEse_WriteFrame |
| * |
| * Description This function writes the data to ESE. |
| * It waits till write callback provide the result of write |
| * process. |
| * |
| * param[in] void*: connection context |
| * param[in] uint32_t: number of bytes to be written |
| * param[in] uint8_t : data buffer |
| * |
| * Returns It returns ESESTATUS_SUCCESS (0) if write successful else |
| * ESESTATUS_FAILED(1) |
| * |
| ******************************************************************************/ |
| ESESTATUS phNxpEse_WriteFrame(void* conn_ctx, uint32_t data_len, const uint8_t *p_data) |
| { |
| ESESTATUS status = ESESTATUS_INVALID_PARAMETER; |
| int32_t dwNoBytesWrRd = 0; |
| phNxpEse_Context_t* nxpese_ctxt = (conn_ctx == NULL) ? &gnxpese_ctxt : (phNxpEse_Context_t*)conn_ctx; |
| |
| /* Create local copy of cmd_data */ |
| LOG_D("%s Enter ..", __FUNCTION__); |
| phNxpEse_memcpy(nxpese_ctxt->p_cmd_data, p_data, data_len); |
| nxpese_ctxt->cmd_len = data_len; |
| if(nxpese_ctxt->EseLibStatus != ESE_STATUS_CLOSE) |
| { |
| dwNoBytesWrRd = phPalEse_i2c_write(nxpese_ctxt->pDevHandle, |
| nxpese_ctxt->p_cmd_data, |
| nxpese_ctxt->cmd_len |
| ); |
| if (-1 == dwNoBytesWrRd) |
| { |
| LOG_E(" - Error in I2C Write....."); |
| status = ESESTATUS_FAILED; |
| } |
| else if (-2 == dwNoBytesWrRd) |
| { |
| status = ESESTATUS_INVALID_STATE; |
| } |
| else |
| { |
| status = ESESTATUS_SUCCESS; |
| LOG_MAU8_D("RAW Tx>",nxpese_ctxt->p_cmd_data, nxpese_ctxt->cmd_len ); |
| } |
| } |
| else |
| status = ESESTATUS_INVALID_STATE; |
| return status; |
| } |
| |
| /****************************************************************************** |
| * Function phNxpEse_setIfsc |
| * |
| * Description This function sets the IFSC size to 240/254 support JCOP OS Update. |
| * |
| * param[in] uint16_t IFSC_Size |
| * |
| * Returns Always return ESESTATUS_SUCCESS (0). |
| * |
| ******************************************************************************/ |
| ESESTATUS phNxpEse_setIfsc(uint16_t IFSC_Size) |
| { |
| /*SET the IFSC size to 240 bytes*/ |
| phNxpEseProto7816_SetIfscSize(IFSC_Size); |
| return ESESTATUS_SUCCESS; |
| } |
| |
| /****************************************************************************** |
| * Function phNxpEse_memset |
| * |
| * Description This function updates destination buffer with val |
| * data in len size |
| * |
| * param[in] buff - Array to be udpated |
| * param[in] val - value to be updated |
| * param[in] len - length of array to be updated |
| * |
| * Returns Always return ESESTATUS_SUCCESS (0). |
| * |
| ******************************************************************************/ |
| void* phNxpEse_memset(void *buff, int val, size_t len) |
| { |
| return memset(buff, val, len); |
| } |
| |
| /****************************************************************************** |
| * Function phNxpEse_memcpy |
| * |
| * Description This function copies source buffer to destination buffer |
| * data in len size |
| * |
| * param[in] dest - Destination array to be updated |
| * param[in] src - Source array to be updated |
| * param[in] len - length of array to be updated |
| * |
| * Returns Return pointer to allocated memory location. |
| * |
| ******************************************************************************/ |
| void* phNxpEse_memcpy(void *dest, const void *src, size_t len) |
| { |
| return memcpy(dest, src, len); |
| } |
| |
| /****************************************************************************** |
| * Function phNxpEse_Memalloc |
| * |
| * Description This function allocation memory |
| * |
| * param[in] uint32_t size |
| * |
| * Returns Return pointer to allocated memory or NULL. |
| * |
| ******************************************************************************/ |
| void *phNxpEse_memalloc(uint32_t size) |
| { |
| #if defined(USE_RTOS) && USE_RTOS == 1 |
| return pvPortMalloc(size); |
| #else |
| return malloc(size); |
| #endif |
| } |
| |
| |
| /****************************************************************************** |
| * Function phNxpEse_free |
| * |
| * Description This function de-allocation memory |
| * |
| * param[in] ptr - Address pointer to previous allocation |
| * |
| * Returns void. |
| * |
| ******************************************************************************/ |
| void phNxpEse_free(void* ptr) |
| { |
| ENSURE_OR_GO_EXIT(ptr != NULL); |
| #if defined(USE_RTOS) && USE_RTOS == 1 |
| vPortFree(ptr); |
| #else |
| free(ptr); |
| #endif |
| exit: |
| return; |
| } |
| |
| #if defined(T1oI2C_UM11225) |
| /****************************************************************************** |
| * Function phNxpEse_getAtr |
| * |
| * Description This function get ATR from ESE. |
| * |
| * param[out] phNxpEse_data: Response from ESE |
| * |
| * Returns On Success ESESTATUS_SUCCESS else ESESTATUS_FAILED. |
| * |
| ******************************************************************************/ |
| ESESTATUS phNxpEse_getAtr(void* conn_ctx, phNxpEse_data *pRsp) |
| { |
| bool_t status = FALSE; |
| status =phNxpEseProto7816_GetAtr(conn_ctx, pRsp); |
| if (status == FALSE) |
| { |
| LOG_E("%s Get ATR Failed ", __FUNCTION__); |
| return ESESTATUS_FAILED; |
| } |
| return ESESTATUS_SUCCESS; |
| } |
| #endif |
| |
| #if defined(T1oI2C_GP1_0) |
| /****************************************************************************** |
| * Function phNxpEse_getCip |
| * |
| * Description This function get CIP from ESE. |
| * |
| * param[out] phNxpEse_data: Response from ESE |
| * |
| * Returns On Success ESESTATUS_SUCCESS else ESESTATUS_FAILED. |
| * |
| ******************************************************************************/ |
| ESESTATUS phNxpEse_getCip(void* conn_ctx, phNxpEse_data *pRsp) |
| { |
| bool_t status = FALSE; |
| status =phNxpEseProto7816_GetCip(conn_ctx, pRsp); |
| if (status == FALSE) |
| { |
| LOG_E("%s Get CIP Failed ", __FUNCTION__); |
| return ESESTATUS_FAILED; |
| } |
| return ESESTATUS_SUCCESS; |
| } |
| #endif |
