diff options
Diffstat (limited to 'pn54x/self-test')
| -rw-r--r-- | pn54x/self-test/phNxpNciHal_SelfTest.c | 1847 |
1 files changed, 1847 insertions, 0 deletions
diff --git a/pn54x/self-test/phNxpNciHal_SelfTest.c b/pn54x/self-test/phNxpNciHal_SelfTest.c new file mode 100644 index 0000000..37d6a3e --- /dev/null +++ b/pn54x/self-test/phNxpNciHal_SelfTest.c @@ -0,0 +1,1847 @@ +/* + * Copyright (C) 2012-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. + */ + +#ifdef NXP_HW_SELF_TEST + +#include <phNxpConfig.h> +#include <phNxpLog.h> +#include <phNxpNciHal_SelfTest.h> +#include <phOsalNfc_Timer.h> +#include <pthread.h> + +/* Timeout value to wait for response from PN54X */ +#define HAL_WRITE_RSP_TIMEOUT (2000) +#define HAL_WRITE_MAX_RETRY (10) + +/******************* Structures and definitions *******************************/ + +typedef uint8_t (*st_validator_t)(nci_data_t* exp, + phTmlNfc_TransactInfo_t* act); + +phAntenna_St_Resp_t phAntenna_resp; + +typedef struct nci_test_data { + nci_data_t cmd; + nci_data_t exp_rsp; + nci_data_t exp_ntf; + st_validator_t rsp_validator; + st_validator_t ntf_validator; + +} nci_test_data_t; + +/******************* Global variables *****************************************/ + +static int thread_running = 0; +static uint32_t timeoutTimerId = 0; +static int hal_write_timer_fired = 0; + +/* TML Context */ +extern phTmlNfc_Context_t* gpphTmlNfc_Context; + +/* Global HAL Ref */ +extern phNxpNciHal_Control_t nxpncihal_ctrl; + +/* Driver parameters */ +phLibNfc_sConfig_t gDrvCfg; + +NFCSTATUS gtxldo_status = NFCSTATUS_FAILED; +NFCSTATUS gagc_value_status = NFCSTATUS_FAILED; +NFCSTATUS gagc_nfcld_status = NFCSTATUS_FAILED; +NFCSTATUS gagc_differential_status = NFCSTATUS_FAILED; + +static uint8_t st_validator_testEquals(nci_data_t* exp, + phTmlNfc_TransactInfo_t* act); +static uint8_t st_validator_null(nci_data_t* exp, phTmlNfc_TransactInfo_t* act); +static uint8_t st_validator_testSWP1_vltg(nci_data_t* exp, + phTmlNfc_TransactInfo_t* act); +static uint8_t st_validator_testAntenna_Txldo(nci_data_t* exp, + phTmlNfc_TransactInfo_t* act); +static uint8_t st_validator_testAntenna_AgcVal(nci_data_t* exp, + phTmlNfc_TransactInfo_t* act); +static uint8_t st_validator_testAntenna_AgcVal_FixedNfcLd( + nci_data_t* exp, phTmlNfc_TransactInfo_t* act); +static uint8_t st_validator_testAntenna_AgcVal_Differential( + nci_data_t* exp, phTmlNfc_TransactInfo_t* act); + +#if (NFC_NXP_CHIP_TYPE != PN547C2) +NFCSTATUS phNxpNciHal_getPrbsCmd(phNxpNfc_PrbsType_t prbs_type, + phNxpNfc_PrbsHwType_t hw_prbs_type, + uint8_t tech, uint8_t bitrate, + uint8_t* prbs_cmd, uint8_t prbs_cmd_len); +#else +NFCSTATUS phNxpNciHal_getPrbsCmd(uint8_t tech, uint8_t bitrate, + uint8_t* prbs_cmd, uint8_t prbs_cmd_len); +#endif +/* Test data to validate SWP line 2*/ +static nci_test_data_t swp2_test_data[] = { + {{ + 0x04, {0x20, 0x00, 0x01, 0x00} /* cmd */ + }, + { +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x06, {0x40, 0x00, 0x03, 0x00, 0x11, 0x00} /* exp_rsp */ +#else + 0x06, {0x40, 0x00, 0x03, 0x00, 0x10, 0x00} /* exp_rsp */ +#endif + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, + {{ +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x05, {0x20, 0x01, 0x02, 0x00, 0x00} /* cmd */ +#else + 0x03, {0x20, 0x01, 0x00} +#endif + }, + { +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x4, {0x40, 0x01, 0x19, 0x00} /* exp_rsp */ +#else + 0x4, {0x40, 0x01, 0x17, 0x00} +#endif + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, + {{ + 0x03, {0x2F, 0x02, 0x00} /* cmd */ + }, + { + 0x04, {0x4F, 0x02, 0x05, 0x00} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, + {{ + 0x04, {0x2F, 0x3E, 0x01, 0x01} /* cmd */ + }, + { + 0x04, {0x4F, 0x3E, 0x01, 0x00} /* exp_rsp */ + }, + { + 0x04, {0x6F, 0x3E, 0x02, 0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_testEquals}, + +}; + +/* Test data to validate SWP line 1*/ +static nci_test_data_t swp1_test_data[] = { + + {{ + 0x04, {0x20, 0x00, 0x01, 0x00} /* cmd */ + }, + { +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x06, {0x40, 0x00, 0x03, 0x00, 0x11, 0x00} /* exp_rsp */ +#else + 0x06, {0x40, 0x00, 0x03, 0x00, 0x10, 0x00} /* exp_rsp */ +#endif + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, + {{ +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x05, {0x20, 0x01, 0x02, 0x00, 0x00} /* cmd */ +#else + 0x03, {0x20, 0x01, 0x00} +#endif + }, + { +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x4, {0x40, 0x01, 0x19, 0x00} /* exp_rsp */ +#else + 0x4, {0x40, 0x01, 0x17, 0x00} +#endif + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, + {{ + 0x03, {0x2F, 0x02, 0x00} /* cmd */ + }, + { + 0x04, {0x4F, 0x02, 0x05, 0x00} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, + {{ + 0x04, {0x2F, 0x3E, 0x01, 0x00} /* cmd */ + }, + { + 0x04, {0x4F, 0x3E, 0x01, 0x00} /* exp_rsp */ + }, + { + 0x04, {0x6F, 0x3E, 0x02, 0x00} /* ext_ntf */ + }, + + st_validator_testEquals, /* validator */ + st_validator_testSWP1_vltg}, +}; + +static nci_test_data_t prbs_test_data[] = { + {{ + 0x04, {0x20, 0x00, 0x01, 0x00} /* cmd */ + }, + { +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x06, {0x40, 0x00, 0x03, 0x00, 0x11, 0x00} /* exp_rsp */ +#else + 0x06, {0x40, 0x00, 0x03, 0x00, 0x10, 0x00} /* exp_rsp */ +#endif + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, + {{ +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x05, {0x20, 0x01, 0x02, 0x00, 0x00} /* cmd */ +#else + 0x03, {0x20, 0x01, 0x00} /* cmd */ +#endif + }, + { +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x4, {0x40, 0x01, 0x19, 0x00} /* exp_rsp */ +#else + 0x4, {0x40, 0x01, 0x17, 0x00} /* exp_rsp */ +#endif + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null +#if (NFC_NXP_CHIP_TYPE != PN547C2) + }, + {{ + 0x04, {0x2F, 0x00, 0x01, 0x00} /* cmd */ + }, + { + 0x04, {0x4F, 0x00, 0x01, 0x00} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null +#endif + }}; + +/* for rf field test, first requires to disable the standby mode */ +static nci_test_data_t rf_field_on_test_data[] = { + {{ + 0x04, {0x20, 0x00, 0x01, 0x00} /* cmd */ + }, + { +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x06, {0x40, 0x00, 0x03, 0x00, 0x11, 0x00} /* exp_rsp */ +#else + 0x06, {0x40, 0x00, 0x03, 0x00, 0x10, 0x00} /* exp_rsp */ +#endif + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, + {{ +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x05, {0x20, 0x01, 0x02, 0x00, 0x00} /* cmd */ +#else + 0x03, {0x20, 0x01, 0x00} /* cmd */ +#endif + }, + { +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x4, {0x40, 0x01, 0x19, 0x00} /* exp_rsp */ +#else + 0x4, {0x40, 0x01, 0x17, 0x00} /* exp_rsp */ +#endif + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, +#if (NFC_NXP_CHIP_TYPE != PN547C2) + {{ + 0x03, {0x2F, 0x02, 0x00} /* cmd */ + }, + { + 0x04, {0x4F, 0x02, 0x05, 0x00} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, + {{ + 0x04, {0x2F, 0x00, 0x01, 0x00} /* cmd */ + }, + { + 0x04, {0x4F, 0x00, 0x01, 0x00} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, +#endif + {{ +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x05, {0x2F, 0x3D, 0x02, 0x20, 0x01} /* cmd */ +#else + 0x08, {0x2F, 0x3D, 0x05, 0x20, 0x01, 0x00, 0x00, 0x00} /* cmd */ +#endif + }, + { + 0x04, {0x4F, 0x3D, 0x05, 0x00} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null +#if (NFC_NXP_CHIP_TYPE != PN547C2) + }, + {{ + 0x04, {0x2F, 0x00, 0x01, 0x01} /* cmd */ + }, + { + 0x04, {0x4F, 0x00, 0x01, 0x00} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null +#endif + }}; + +static nci_test_data_t rf_field_off_test_data[] = { + {{ + 0x04, {0x20, 0x00, 0x01, 0x00} /* cmd */ + }, + { +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x06, {0x40, 0x00, 0x03, 0x00, 0x11, 0x00} /* exp_rsp */ +#else + 0x06, {0x40, 0x00, 0x03, 0x00, 0x10, 0x00} /* exp_rsp */ +#endif + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, + {{ +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x05, {0x20, 0x01, 0x02, 0x00, 0x00} /* cmd */ +#else + 0x03, {0x20, 0x01, 0x00} /* cmd */ +#endif + }, + { +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x4, {0x40, 0x01, 0x19, 0x00} /* exp_rsp */ +#else + 0x4, {0x40, 0x01, 0x17, 0x00} /* exp_rsp */ +#endif + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, +#if (NFC_NXP_CHIP_TYPE != PN547C2) + {{ + 0x03, {0x2F, 0x02, 0x00} /* cmd */ + }, + { + 0x04, {0x4F, 0x02, 0x05, 0x00} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, + {{ + 0x04, {0x2F, 0x00, 0x01, 0x00} /* cmd */ + }, + { + 0x04, {0x4F, 0x00, 0x01, 0x00} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, +#endif + {{ +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x05, {0x2F, 0x3D, 0x02, 0x20, 0x00} /* cmd */ +#else + 0x08, {0x2F, 0x3D, 0x05, 0x20, 0x00, 0x00, 0x00, 0x00} /* cmd */ +#endif + }, + { + 0x04, {0x4F, 0x3D, 0x05, 0x00} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null +#if (NFC_NXP_CHIP_TYPE != PN547C2) + }, + {{ + 0x04, {0x2F, 0x00, 0x01, 0x01} /* cmd */ + }, + { + 0x04, {0x4F, 0x00, 0x01, 0x00} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null +#endif + }}; + +/* Download pin test data 1 */ +static nci_test_data_t download_pin_test_data1[] = { + {{ + 0x04, {0x20, 0x00, 0x01, 0x00} /* cmd */ + }, + { +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x06, {0x40, 0x00, 0x03, 0x00, 0x11, 0x00} /* exp_rsp */ +#else + 0x06, {0x40, 0x00, 0x03, 0x00, 0x10, 0x00} /* exp_rsp */ +#endif + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, +}; + +/* Download pin test data 2 */ +static nci_test_data_t download_pin_test_data2[] = { + {{ + 0x08, {0x00, 0x04, 0xD0, 0x11, 0x00, 0x00, 0x5B, 0x46} /* cmd */ + }, + { + 0x08, {0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x87, 0x16} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, +}; +/* Antenna self test data*/ +static nci_test_data_t antenna_self_test_data[] = { + {{ + 0x04, {0x20, 0x00, 0x01, 0x00} /* cmd */ + }, + { +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x06, {0x40, 0x00, 0x03, 0x00, 0x11, 0x00} /* exp_rsp */ +#else + 0x06, {0x40, 0x00, 0x03, 0x00, 0x10, 0x00} /* exp_rsp */ +#endif + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, + {{ +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x05, {0x20, 0x01, 0x02, 0x00, 0x00} /* cmd */ +#else + 0x03, {0x20, 0x01, 0x00} /* cmd */ +#endif + }, + { +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x4, {0x40, 0x01, 0x19, 0x00} /* exp_rsp */ +#else + 0x4, {0x40, 0x01, 0x17, 0x00} /* exp_rsp */ +#endif + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, + {{ + 0x03, {0x2F, 0x02, 0x00} /* cmd */ + }, + { + 0x04, {0x4F, 0x02, 0x05, 0x00} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, +#if (NFC_NXP_CHIP_TYPE != PN547C2) + {{ + 0x04, {0x2F, 0x00, 0x01, 0x00} /* cmd */ + }, + { + 0x04, {0x4F, 0x00, 0x01, 0x00} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null}, +#endif + {{ + 0x05, + {0x2F, 0x3D, 0x02, 0x01, 0x80} /* TxLDO cureent measurement cmd */ + }, + { + 0x03, {0x4F, 0x3D, 05} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testAntenna_Txldo, + st_validator_null}, + {{ +#if (NFC_NXP_CHIP_TYPE != PN547C2) + 0x07, + {0x2F, 0x3D, 0x04, 0x02, 0xC8, 0x60, 0x03} /* AGC measurement cmd */ +#else + 0x07, + {0x2F, 0x3D, 0x04, 0x02, 0xCD, 0x60, 0x03} /* AGC measurement cmd */ +#endif + }, + { + 0x03, {0x4F, 0x3D, 05} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testAntenna_AgcVal, + st_validator_null}, + {{ + 0x07, + {0x2F, 0x3D, 0x04, 0x04, 0x20, 0x08, + 0x20} /* AGC with NFCLD measurement cmd */ + }, + { + 0x03, {0x4F, 0x3D, 05} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testAntenna_AgcVal_FixedNfcLd, + st_validator_null}, + {{ + 0x07, + {0x2F, 0x3D, 0x04, 0x08, 0x8C, 0x60, + 0x03} /* AGC with NFCLD measurement cmd */ + }, + { + 0x03, {0x4F, 0x3D, 05} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testAntenna_AgcVal_Differential, + st_validator_null +#if (NFC_NXP_CHIP_TYPE != PN547C2) + }, + {{ + 0x04, {0x2F, 0x00, 0x01, 0x01} /* cmd */ + }, + { + 0x04, {0x4F, 0x00, 0x01, 0x00} /* exp_rsp */ + }, + { + 0x00, {0x00} /* ext_ntf */ + }, + st_validator_testEquals, /* validator */ + st_validator_null +#endif + }}; + +/************** Self test functions ***************************************/ + +static uint8_t st_validator_testEquals(nci_data_t* exp, + phTmlNfc_TransactInfo_t* act); +static void hal_write_cb(void* pContext, phTmlNfc_TransactInfo_t* pInfo); +static void hal_write_rsp_timeout_cb(uint32_t TimerId, void* pContext); +static void hal_read_cb(void* pContext, phTmlNfc_TransactInfo_t* pInfo); + +/******************************************************************************* +** +** Function st_validator_null +** +** Description Null Validator +** +** Returns One +** +*******************************************************************************/ +static uint8_t st_validator_null(nci_data_t* exp, + phTmlNfc_TransactInfo_t* act) { + UNUSED(exp); + UNUSED(act); + return 1; +} + +/******************************************************************************* +** +** Function st_validator_testSWP1_vltg +** +** Description Validator function to validate swp1 connection. +** +** Returns One if successful otherwise Zero. +** +*******************************************************************************/ +static uint8_t st_validator_testSWP1_vltg(nci_data_t* exp, + phTmlNfc_TransactInfo_t* act) { + uint8_t result = 0; + + if (NULL == exp || NULL == act) { + return result; + } + + if ((act->wLength == 0x05) && + (memcmp(exp->p_data, act->pBuff, exp->len) == 0)) { + if (act->pBuff[4] == 0x01 || act->pBuff[4] == 0x02) { + result = 1; + } + } + + return result; +} + +/******************************************************************************* +** +** Function st_validator_testAntenna_Txldo +** +** Description Validator function to validate Antenna TxLDO current +** measurement. +** +** Returns One if successful otherwise Zero. +** +*******************************************************************************/ +static uint8_t st_validator_testAntenna_Txldo(nci_data_t* exp, + phTmlNfc_TransactInfo_t* act) { + uint8_t result = 0; + uint8_t mesuredrange = 0; + long measured_val = 0; + int tolerance = 0; + + if (NULL == exp || NULL == act) { + return result; + } + + NXPLOG_NCIHAL_D("st_validator_testAntenna_Txldo = 0x%x", act->pBuff[3]); + if (0x05 == act->pBuff[2]) { + if (NFCSTATUS_SUCCESS == act->pBuff[3]) { + result = 1; + NXPLOG_NCIHAL_D("Antenna: TxLDO current measured raw value in mA : 0x%x", + act->pBuff[4]); + if (0x00 == act->pBuff[5]) { + NXPLOG_NCIHAL_D("Measured range : 0x00 = 50 - 100 mA"); + measured_val = ((0.40 * act->pBuff[4]) + 50); + NXPLOG_NCIHAL_D("TxLDO current absolute value in mA = %ld", + measured_val); + } else { + NXPLOG_NCIHAL_D("Measured range : 0x01 = 20 - 70 mA"); + measured_val = ((0.40 * act->pBuff[4]) + 20); + NXPLOG_NCIHAL_D("TxLDO current absolute value in mA = %ld", + measured_val); + } + + tolerance = (phAntenna_resp.wTxdoMeasuredRangeMax * + phAntenna_resp.wTxdoMeasuredTolerance) / + 100; + if ((measured_val <= phAntenna_resp.wTxdoMeasuredRangeMax + tolerance)) { + tolerance = (phAntenna_resp.wTxdoMeasuredRangeMin * + phAntenna_resp.wTxdoMeasuredTolerance) / + 100; + if ((measured_val >= + phAntenna_resp.wTxdoMeasuredRangeMin - tolerance)) { + gtxldo_status = NFCSTATUS_SUCCESS; + NXPLOG_NCIHAL_E("Test Antenna Response for TxLDO measurement PASS"); + } else { + gtxldo_status = NFCSTATUS_FAILED; + NXPLOG_NCIHAL_E("Test Antenna Response for TxLDO measurement FAIL"); + } + } else { + gtxldo_status = NFCSTATUS_FAILED; + NXPLOG_NCIHAL_E("Test Antenna Response for TxLDO measurement FAIL"); + } + } else { + gtxldo_status = NFCSTATUS_FAILED; + NXPLOG_NCIHAL_E( + "Test Antenna Response for TxLDO measurement failed: Invalid status"); + } + + } else { + gtxldo_status = NFCSTATUS_FAILED; + NXPLOG_NCIHAL_E( + "Test Antenna Response for TxLDO measurement failed: Invalid payload " + "length"); + } + + return result; +} + +/******************************************************************************* +** +** Function st_validator_testAntenna_AgcVal +** +** Description Validator function reads AGC value of antenna and print the +** info +** +** Returns One if successful otherwise Zero. +** +*******************************************************************************/ +static uint8_t st_validator_testAntenna_AgcVal(nci_data_t* exp, + phTmlNfc_TransactInfo_t* act) { + uint8_t result = 0; + int agc_tolerance = 0; + long agc_val = 0; + + if (NULL == exp || NULL == act) { + return result; + } + + if (0x05 == act->pBuff[2]) { + if (NFCSTATUS_SUCCESS == act->pBuff[3]) { + result = 1; + agc_tolerance = + (phAntenna_resp.wAgcValue * phAntenna_resp.wAgcValueTolerance) / 100; + agc_val = ((act->pBuff[5] << 8) | (act->pBuff[4])); + NXPLOG_NCIHAL_D("AGC value : %ld", agc_val); + if (((phAntenna_resp.wAgcValue - agc_tolerance) <= agc_val) && + (agc_val <= (phAntenna_resp.wAgcValue + agc_tolerance))) { + gagc_value_status = NFCSTATUS_SUCCESS; + NXPLOG_NCIHAL_E("Test Antenna Response for AGC Values PASS"); + } else { + gagc_value_status = NFCSTATUS_FAILED; + NXPLOG_NCIHAL_E("Test Antenna Response for AGC Values FAIL"); + } + } else { + gagc_value_status = NFCSTATUS_FAILED; + NXPLOG_NCIHAL_E("Test Antenna Response for AGC Values FAIL"); + } + } else { + gagc_value_status = NFCSTATUS_FAILED; + NXPLOG_NCIHAL_E( + "Test Antenna Response for AGC value failed: Invalid payload length"); + } + + return result; +} +/******************************************************************************* +** +** Function st_validator_testAntenna_AgcVal_FixedNfcLd +** +** Description Validator function reads and print AGC value of +** antenna with fixed NFCLD +** +** Returns One if successful otherwise Zero. +** +*******************************************************************************/ +static uint8_t st_validator_testAntenna_AgcVal_FixedNfcLd( + nci_data_t* exp, phTmlNfc_TransactInfo_t* act) { + uint8_t result = 0; + int agc_nfcld_tolerance = 0; + long agc_nfcld = 0; + + if (NULL == exp || NULL == act) { + return result; + } + + if (0x05 == act->pBuff[2]) { + if (NFCSTATUS_SUCCESS == act->pBuff[3]) { + result = 1; + agc_nfcld_tolerance = (phAntenna_resp.wAgcValuewithfixedNFCLD * + phAntenna_resp.wAgcValuewithfixedNFCLDTolerance) / + 100; + agc_nfcld = ((act->pBuff[5] << 8) | (act->pBuff[4])); + NXPLOG_NCIHAL_D("AGC value with Fixed Nfcld : %ld", agc_nfcld); + + if (((phAntenna_resp.wAgcValuewithfixedNFCLD - agc_nfcld_tolerance) <= + agc_nfcld) && + (agc_nfcld <= + (phAntenna_resp.wAgcValuewithfixedNFCLD + agc_nfcld_tolerance))) { + gagc_nfcld_status = NFCSTATUS_SUCCESS; + NXPLOG_NCIHAL_E( + "Test Antenna Response for AGC value with fixed NFCLD PASS"); + } else { + gagc_nfcld_status = NFCSTATUS_FAILED; + NXPLOG_NCIHAL_E( + "Test Antenna Response for AGC value with fixed NFCLD FAIL"); + } + } else { + gagc_nfcld_status = NFCSTATUS_FAILED; + NXPLOG_NCIHAL_E( + "Test Antenna Response for AGC value with fixed NFCLD failed: " + "Invalid status"); + } + } else { + gagc_nfcld_status = NFCSTATUS_FAILED; + NXPLOG_NCIHAL_E( + "Test Antenna Response for AGC value with fixed NFCLD failed: Invalid " + "payload length"); + } + + return result; +} + +/******************************************************************************* +** +** Function st_validator_testAntenna_AgcVal_Differential +** +** Description Reads the AGC value with open/short RM from buffer and print +** +** Returns One if successful otherwise Zero. +** +*******************************************************************************/ +static uint8_t st_validator_testAntenna_AgcVal_Differential( + nci_data_t* exp, phTmlNfc_TransactInfo_t* act) { + uint8_t result = 0; + int agc_toleranceopne1 = 0; + int agc_toleranceopne2 = 0; + long agc_differentialOpne1 = 0; + long agc_differentialOpne2 = 0; + + if (NULL == exp || NULL == act) { + return result; + } + + if (0x05 == act->pBuff[2]) { + if (NFCSTATUS_SUCCESS == act->pBuff[3]) { + result = 1; + agc_toleranceopne1 = (phAntenna_resp.wAgcDifferentialWithOpen1 * + phAntenna_resp.wAgcDifferentialWithOpenTolerance1) / + 100; + agc_toleranceopne2 = (phAntenna_resp.wAgcDifferentialWithOpen2 * + phAntenna_resp.wAgcDifferentialWithOpenTolerance2) / + 100; + agc_differentialOpne1 = ((act->pBuff[5] << 8) | (act->pBuff[4])); + agc_differentialOpne2 = ((act->pBuff[7] << 8) | (act->pBuff[6])); + NXPLOG_NCIHAL_D("AGC value differential Opne 1 : %ld", + agc_differentialOpne1); + NXPLOG_NCIHAL_D("AGC value differentialOpne 2 : %ld", + agc_differentialOpne2); + + if (((agc_differentialOpne1 >= + phAntenna_resp.wAgcDifferentialWithOpen1 - agc_toleranceopne1) && + (agc_differentialOpne1 <= + phAntenna_resp.wAgcDifferentialWithOpen1 + agc_toleranceopne1)) && + ((agc_differentialOpne2 >= + phAntenna_resp.wAgcDifferentialWithOpen2 - agc_toleranceopne2) && + (agc_differentialOpne2 <= + phAntenna_resp.wAgcDifferentialWithOpen2 + agc_toleranceopne2))) { + gagc_differential_status = NFCSTATUS_SUCCESS; + NXPLOG_NCIHAL_E("Test Antenna Response for AGC Differential Open PASS"); + } else { + gagc_differential_status = NFCSTATUS_FAILED; + NXPLOG_NCIHAL_E( + "Test Antenna Response for AGC Differential Open FAIL"); + } + } else { + NXPLOG_NCIHAL_E( + "Test Antenna Response for AGC Differential failed: Invalid status"); + gagc_differential_status = NFCSTATUS_FAILED; + } + + } else { + NXPLOG_NCIHAL_E( + "Test Antenna Response for AGC Differential failed: Invalid payload " + "length"); + gagc_differential_status = NFCSTATUS_FAILED; + } + + return result; +} +/******************************************************************************* +** +** Function st_validator_testEquals +** +** Description Validator function to validate for equality between actual +** and expected values. +** +** Returns One if successful otherwise Zero. +** +*******************************************************************************/ +static uint8_t st_validator_testEquals(nci_data_t* exp, + phTmlNfc_TransactInfo_t* act) { + uint8_t result = 0; + + if (NULL == exp || NULL == act) { + return result; + } + if (exp->len <= act->wLength && + (memcmp(exp->p_data, act->pBuff, exp->len) == 0)) { + result = 1; + } + + return result; +} + +/******************************************************************************* +** +** Function hal_write_rsp_timeout_cb +** +** Description Callback function for hal write response timer. +** +** Returns None +** +*******************************************************************************/ +static void hal_write_rsp_timeout_cb(uint32_t timerId, void* pContext) { + UNUSED(timerId); + NXPLOG_NCIHAL_E("hal_write_rsp_timeout_cb - write timeout!!!"); + hal_write_timer_fired = 1; + hal_read_cb(pContext, NULL); +} + +/******************************************************************************* +** +** Function hal_write_cb +** +** Description Callback function for hal write. +** +** Returns None +** +*******************************************************************************/ +static void hal_write_cb(void* pContext, phTmlNfc_TransactInfo_t* pInfo) { + phNxpNciHal_Sem_t* p_cb_data = (phNxpNciHal_Sem_t*)pContext; + + if (pInfo->wStatus == NFCSTATUS_SUCCESS) { + NXPLOG_NCIHAL_D("write successful status = 0x%x", pInfo->wStatus); + } else { + NXPLOG_NCIHAL_E("write error status = 0x%x", pInfo->wStatus); + } + + p_cb_data->status = pInfo->wStatus; + SEM_POST(p_cb_data); + + return; +} + +/******************************************************************************* +** +** Function hal_read_cb +** +** Description Callback function for hal read. +** +** Returns None +** +*******************************************************************************/ +static void hal_read_cb(void* pContext, phTmlNfc_TransactInfo_t* pInfo) { + phNxpNciHal_Sem_t* p_cb_data = (phNxpNciHal_Sem_t*)pContext; + NFCSTATUS status; + if (hal_write_timer_fired == 1) { + NXPLOG_NCIHAL_D("hal_read_cb - response timeout occurred"); + + hal_write_timer_fired = 0; + p_cb_data->status = NFCSTATUS_RESPONSE_TIMEOUT; + status = phTmlNfc_ReadAbort(); + } else { + NFCSTATUS status = phOsalNfc_Timer_Stop(timeoutTimerId); + + if (NFCSTATUS_SUCCESS == status) { + NXPLOG_NCIHAL_D("Response timer stopped"); + } else { + NXPLOG_NCIHAL_E("Response timer stop ERROR!!!"); + p_cb_data->status = NFCSTATUS_FAILED; + } + if (pInfo == NULL) { + NXPLOG_NCIHAL_E("Empty TransactInfo"); + p_cb_data->status = NFCSTATUS_FAILED; + } else { + if (pInfo->wStatus == NFCSTATUS_SUCCESS) { + NXPLOG_NCIHAL_D("hal_read_cb successful status = 0x%x", pInfo->wStatus); + p_cb_data->status = NFCSTATUS_SUCCESS; + } else { + NXPLOG_NCIHAL_E("hal_read_cb error status = 0x%x", pInfo->wStatus); + p_cb_data->status = NFCSTATUS_FAILED; + } + + p_cb_data->status = pInfo->wStatus; + nci_test_data_t* test_data = (nci_test_data_t*)p_cb_data->pContext; + + if (test_data->exp_rsp.len == 0) { + /* Compare the actual notification with expected notification.*/ + if (test_data->ntf_validator(&(test_data->exp_ntf), pInfo) == 1) { + p_cb_data->status = NFCSTATUS_SUCCESS; + } else { + p_cb_data->status = NFCSTATUS_FAILED; + } + } + + /* Compare the actual response with expected response.*/ + else if (test_data->rsp_validator(&(test_data->exp_rsp), pInfo) == 1) { + p_cb_data->status = NFCSTATUS_SUCCESS; + } else { + p_cb_data->status = NFCSTATUS_FAILED; + } + + test_data->exp_rsp.len = 0; + } + } + + SEM_POST(p_cb_data); + + return; +} + +/******************************************************************************* +** +** Function phNxpNciHal_test_rx_thread +** +** Description Thread to fetch and process messages from message queue. +** +** Returns NULL +** +*******************************************************************************/ +static void* phNxpNciHal_test_rx_thread(void* arg) { + phLibNfc_Message_t msg; + UNUSED(arg); + NXPLOG_NCIHAL_D("Self test thread started"); + + thread_running = 1; + + while (thread_running == 1) { + /* Fetch next message from the NFC stack message queue */ + if (phDal4Nfc_msgrcv(gDrvCfg.nClientId, &msg, 0, 0) == -1) { + NXPLOG_NCIHAL_E("Received bad message"); + continue; + } + + if (thread_running == 0) { + break; + } + + switch (msg.eMsgType) { + case PH_LIBNFC_DEFERREDCALL_MSG: { + phLibNfc_DeferredCall_t* deferCall = + (phLibNfc_DeferredCall_t*)(msg.pMsgData); + + REENTRANCE_LOCK(); + deferCall->pCallback(deferCall->pParameter); + REENTRANCE_UNLOCK(); + + break; + } + } + } + + NXPLOG_NCIHAL_D("Self test thread stopped"); + + return NULL; +} + +/******************************************************************************* +** +** Function phNxpNciHal_readLocked +** +** Description Reads response and notification from NFCC and waits for +** read completion, for a definitive timeout value. +** +** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED, +** NFCSTATUS_RESPONSE_TIMEOUT in case of timeout. +** +*******************************************************************************/ +static NFCSTATUS phNxpNciHal_readLocked(nci_test_data_t* pData) { + NFCSTATUS status = NFCSTATUS_SUCCESS; + phNxpNciHal_Sem_t cb_data; + uint16_t read_len = 16; + /* RX Buffer */ + uint32_t rx_data[NCI_MAX_DATA_LEN]; + + /* Create the local semaphore */ + if (phNxpNciHal_init_cb_data(&cb_data, pData) != NFCSTATUS_SUCCESS) { + NXPLOG_NCIHAL_D("phTmlNfc_Read Create cb data failed"); + status = NFCSTATUS_FAILED; + goto clean_and_return; + } + + /* call read pending */ + status = + phTmlNfc_Read((uint8_t*)rx_data, (uint16_t)read_len, + (pphTmlNfc_TransactCompletionCb_t)&hal_read_cb, &cb_data); + + if (status != NFCSTATUS_PENDING) { + NXPLOG_NCIHAL_E("TML Read status error status = %x", status); + status = NFCSTATUS_FAILED; + goto clean_and_return; + } + + status = phOsalNfc_Timer_Start(timeoutTimerId, HAL_WRITE_RSP_TIMEOUT, + &hal_write_rsp_timeout_cb, &cb_data); + + if (NFCSTATUS_SUCCESS == status) { + NXPLOG_NCIHAL_D("Response timer started"); + } else { + NXPLOG_NCIHAL_E("Response timer not started"); + status = NFCSTATUS_FAILED; + goto clean_and_return; + } + + /* Wait for callback response */ + if (SEM_WAIT(cb_data)) { + NXPLOG_NCIHAL_E("phTmlNfc_Read semaphore error"); + status = NFCSTATUS_FAILED; + goto clean_and_return; + } + + if (cb_data.status == NFCSTATUS_RESPONSE_TIMEOUT) { + NXPLOG_NCIHAL_E("Response timeout!!!"); + status = NFCSTATUS_RESPONSE_TIMEOUT; + goto clean_and_return; + } + + if (cb_data.status != NFCSTATUS_SUCCESS) { + NXPLOG_NCIHAL_E("phTmlNfc_Read failed "); + status = NFCSTATUS_FAILED; + goto clean_and_return; + } + +clean_and_return: + phNxpNciHal_cleanup_cb_data(&cb_data); + + return status; +} + +/******************************************************************************* +** +** Function phNxpNciHal_writeLocked +** +** Description Send command to NFCC and waits for cmd write completion, for +** a definitive timeout value. +** +** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED, +** NFCSTATUS_RESPONSE_TIMEOUT in case of timeout. +** +*******************************************************************************/ +static NFCSTATUS phNxpNciHal_writeLocked(nci_test_data_t* pData) { + NFCSTATUS status = NFCSTATUS_SUCCESS; + + phNxpNciHal_Sem_t cb_data; + int retryCnt = 0; + + /* Create the local semaphore */ + if (phNxpNciHal_init_cb_data(&cb_data, NULL) != NFCSTATUS_SUCCESS) { + NXPLOG_NCIHAL_D("phTmlNfc_Write Create cb data failed"); + goto clean_and_return; + } + +retry: + status = + phTmlNfc_Write(pData->cmd.p_data, pData->cmd.len, + (pphTmlNfc_TransactCompletionCb_t)&hal_write_cb, &cb_data); + + if (status != NFCSTATUS_PENDING) { + NXPLOG_NCIHAL_E("phTmlNfc_Write status error"); + goto clean_and_return; + } + + /* Wait for callback response */ + if (SEM_WAIT(cb_data)) { + NXPLOG_NCIHAL_E("write_unlocked semaphore error"); + status = NFCSTATUS_FAILED; + goto clean_and_return; + } + + if (cb_data.status != NFCSTATUS_SUCCESS && retryCnt < HAL_WRITE_MAX_RETRY) { + retryCnt++; + NXPLOG_NCIHAL_E( + "write_unlocked failed - PN54X Maybe in Standby Mode - Retry %d", + retryCnt); + goto retry; + } + + status = cb_data.status; + +clean_and_return: + phNxpNciHal_cleanup_cb_data(&cb_data); + + return status; +} + +/******************************************************************************* +** +** Function phNxpNciHal_performTest +** +** Description Performs a single cycle of command,response and +** notification. +** +** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED, +** +*******************************************************************************/ +NFCSTATUS phNxpNciHal_performTest(nci_test_data_t* pData) { + NFCSTATUS status = NFCSTATUS_SUCCESS; + + if (NULL == pData) { + return NFCSTATUS_FAILED; + } + + CONCURRENCY_LOCK(); + + status = phNxpNciHal_writeLocked(pData); + + if (status == NFCSTATUS_RESPONSE_TIMEOUT) { + goto clean_and_return; + } + if (status != NFCSTATUS_SUCCESS) { + goto clean_and_return; + } + + status = phNxpNciHal_readLocked(pData); + + if (status != NFCSTATUS_SUCCESS) { + goto clean_and_return; + } + + if (0 != pData->exp_ntf.len) { + status = phNxpNciHal_readLocked(pData); + + if (status != NFCSTATUS_SUCCESS) { + goto clean_and_return; + } + } + +clean_and_return: + CONCURRENCY_UNLOCK(); + return status; +} + +/******************************************************************************* + ** + ** Function phNxpNciHal_TestMode_open + ** + ** Description It opens the physical connection with NFCC (PN54X) and + ** creates required client thread for operation. + ** + ** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED. + ** + ******************************************************************************/ +NFCSTATUS phNxpNciHal_TestMode_open(void) { + /* Thread */ + pthread_t test_rx_thread; + + phOsalNfc_Config_t tOsalConfig; + phTmlNfc_Config_t tTmlConfig; + char* nfc_dev_node = NULL; + const uint16_t max_len = 260; + NFCSTATUS status = NFCSTATUS_SUCCESS; + uint16_t read_len = 255; + int8_t ret_val = 0x00; + /* initialize trace level */ + phNxpLog_InitializeLogLevel(); + + if (phNxpNciHal_init_monitor() == NULL) { + NXPLOG_NCIHAL_E("Init monitor failed"); + return NFCSTATUS_FAILED; + } + + CONCURRENCY_LOCK(); + + memset(&tOsalConfig, 0x00, sizeof(tOsalConfig)); + memset(&tTmlConfig, 0x00, sizeof(tTmlConfig)); + + /* Read the nfc device node name */ + nfc_dev_node = (char*)malloc(max_len * sizeof(char)); + if (nfc_dev_node == NULL) { + NXPLOG_NCIHAL_E("malloc of nfc_dev_node failed "); + goto clean_and_return; + } else if (!GetNxpStrValue(NAME_NXP_NFC_DEV_NODE, nfc_dev_node, + sizeof(nfc_dev_node))) { + NXPLOG_NCIHAL_E( + "Invalid nfc device node name keeping the default device node " + "/dev/pn54x"); + strcpy(nfc_dev_node, "/dev/pn54x"); + } + + gDrvCfg.nClientId = phDal4Nfc_msgget(0, 0600); + gDrvCfg.nLinkType = ENUM_LINK_TYPE_I2C; /* For PN54X */ + tTmlConfig.pDevName = (int8_t*)nfc_dev_node; + tOsalConfig.dwCallbackThreadId = (uintptr_t)gDrvCfg.nClientId; + tOsalConfig.pLogFile = NULL; + tTmlConfig.dwGetMsgThreadId = (uintptr_t)gDrvCfg.nClientId; + nxpncihal_ctrl.gDrvCfg.nClientId = (uintptr_t)gDrvCfg.nClientId; + + /* Initialize TML layer */ + status = phTmlNfc_Init(&tTmlConfig); + if (status != NFCSTATUS_SUCCESS) { + NXPLOG_NCIHAL_E("phTmlNfc_Init Failed"); + goto clean_and_return; + } else { + if (nfc_dev_node != NULL) { + free(nfc_dev_node); + nfc_dev_node = NULL; + } + } + + pthread_attr_t attr; + pthread_attr_init(&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + ret_val = + pthread_create(&test_rx_thread, &attr, phNxpNciHal_test_rx_thread, NULL); + pthread_attr_destroy(&attr); + if (ret_val != 0) { + NXPLOG_NCIHAL_E("pthread_create failed"); + phTmlNfc_Shutdown(); + goto clean_and_return; + } + + timeoutTimerId = phOsalNfc_Timer_Create(); + + if (timeoutTimerId == 0xFFFF) { + NXPLOG_NCIHAL_E("phOsalNfc_Timer_Create failed"); + } else { + NXPLOG_NCIHAL_D("phOsalNfc_Timer_Create SUCCESS"); + } + CONCURRENCY_UNLOCK(); + + return NFCSTATUS_SUCCESS; + +clean_and_return: + CONCURRENCY_UNLOCK(); + if (nfc_dev_node != NULL) { + free(nfc_dev_node); + nfc_dev_node = NULL; + } + phNxpNciHal_cleanup_monitor(); + return NFCSTATUS_FAILED; +} + +/******************************************************************************* + ** + ** Function phNxpNciHal_TestMode_close + ** + ** Description This function close the NFCC interface and free all + ** resources. + ** + ** Returns None. + ** + ******************************************************************************/ + +void phNxpNciHal_TestMode_close() { + NFCSTATUS status = NFCSTATUS_SUCCESS; + + CONCURRENCY_LOCK(); + + if (NULL != gpphTmlNfc_Context->pDevHandle) { + /* Abort any pending read and write */ + status = phTmlNfc_ReadAbort(); + status = phTmlNfc_WriteAbort(); + + phOsalNfc_Timer_Cleanup(); + + status = phTmlNfc_Shutdown(); + + NXPLOG_NCIHAL_D("phNxpNciHal_close return status = %d", status); + + thread_running = 0; + + phDal4Nfc_msgrelease(gDrvCfg.nClientId); + + status = phOsalNfc_Timer_Delete(timeoutTimerId); + } + + CONCURRENCY_UNLOCK(); + + phNxpNciHal_cleanup_monitor(); + + /* Return success always */ + return; +} + +/******************************************************************************* + ** + ** Function phNxpNciHal_SwpTest + ** + ** Description Test function to validate the SWP line. SWP line number is + ** is sent as parameter to the API. + ** + ** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED. + ** + ******************************************************************************/ + +NFCSTATUS phNxpNciHal_SwpTest(uint8_t swp_line) { + NFCSTATUS status = NFCSTATUS_SUCCESS; + int len = 0; + int cnt = 0; + + NXPLOG_NCIHAL_D("phNxpNciHal_SwpTest - start\n"); + + if (swp_line == 0x01) { + len = (sizeof(swp1_test_data) / sizeof(swp1_test_data[0])); + + for (cnt = 0; cnt < len; cnt++) { + status = phNxpNciHal_performTest(&(swp1_test_data[cnt])); + if (status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED) { + break; + } + } + } else if (swp_line == 0x02) { + len = (sizeof(swp2_test_data) / sizeof(swp2_test_data[0])); + + for (cnt = 0; cnt < len; cnt++) { + status = phNxpNciHal_performTest(&(swp2_test_data[cnt])); + if (status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED) { + break; + } + } + } else { + status = NFCSTATUS_FAILED; + } + + if (status == NFCSTATUS_SUCCESS) { + NXPLOG_NCIHAL_D("phNxpNciHal_SwpTest - SUCCESSS\n"); + } else { + NXPLOG_NCIHAL_D("phNxpNciHal_SwpTest - FAILED\n"); + } + + NXPLOG_NCIHAL_D("phNxpNciHal_SwpTest - end\n"); + + return status; +} + +/******************************************************************************* + ** + ** Function phNxpNciHal_PrbsTestStart + ** + ** Description Test function start RF generation for RF technology and bit + ** rate. RF technology and bit rate are sent as parameter to + ** the API. + ** + ** Returns NFCSTATUS_SUCCESS if RF generation successful, + ** otherwise NFCSTATUS_FAILED. + ** + ******************************************************************************/ + +#if (NFC_NXP_CHIP_TYPE != PN547C2) +NFCSTATUS phNxpNciHal_PrbsTestStart(phNxpNfc_PrbsType_t prbs_type, + phNxpNfc_PrbsHwType_t hw_prbs_type, + phNxpNfc_Tech_t tech, + phNxpNfc_Bitrate_t bitrate) +#else +NFCSTATUS phNxpNciHal_PrbsTestStart(phNxpNfc_Tech_t tech, + phNxpNfc_Bitrate_t bitrate) +#endif +{ + NFCSTATUS status = NFCSTATUS_FAILED; + + nci_test_data_t prbs_cmd_data; + +#if (NFC_NXP_CHIP_TYPE != PN547C2) + uint8_t rsp_cmd_info[] = {0x4F, 0x30, 0x01, 0x00}; + prbs_cmd_data.cmd.len = 0x09; +#else + uint8_t rsp_cmd_info[] = {0x4F, 0x30, 0x01, 0x00}; + prbs_cmd_data.cmd.len = 0x07; +#endif + + memcpy(prbs_cmd_data.exp_rsp.p_data, &rsp_cmd_info[0], sizeof(rsp_cmd_info)); + prbs_cmd_data.exp_rsp.len = sizeof(rsp_cmd_info); + + // prbs_cmd_data.exp_rsp.len = 0x00; + prbs_cmd_data.exp_ntf.len = 0x00; + prbs_cmd_data.rsp_validator = st_validator_testEquals; + prbs_cmd_data.ntf_validator = st_validator_null; + + uint8_t len = 0; + uint8_t cnt = 0; + +// [NCI] -> [0x2F 0x30 0x04 0x00 0x00 0x01 0xFF] + +#if (NFC_NXP_CHIP_TYPE != PN547C2) + status = + phNxpNciHal_getPrbsCmd(prbs_type, hw_prbs_type, tech, bitrate, + prbs_cmd_data.cmd.p_data, prbs_cmd_data.cmd.len); +#else + status = phNxpNciHal_getPrbsCmd(tech, bitrate, prbs_cmd_data.cmd.p_data, + prbs_cmd_data.cmd.len); +#endif + + if (status == NFCSTATUS_FAILED) { + // Invalid Param. + NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStart - INVALID_PARAM\n"); + + goto clean_and_return; + } + + len = (sizeof(prbs_test_data) / sizeof(prbs_test_data[0])); + + for (cnt = 0; cnt < len; cnt++) { + status = phNxpNciHal_performTest(&(prbs_test_data[cnt])); + if (status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED) { + break; + } + } + + /* Ignoring status, as there will be no response - Applicable till FW version + * 8.1.1*/ + status = phNxpNciHal_performTest(&prbs_cmd_data); +clean_and_return: + + if (status == NFCSTATUS_SUCCESS) { + NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStart - SUCCESSS\n"); + } else { + NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStart - FAILED\n"); + } + + NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStart - end\n"); + + return status; +} + +/******************************************************************************* + ** + ** Function phNxpNciHal_PrbsTestStop + ** + ** Description Test function stop RF generation for RF technology started + ** by phNxpNciHal_PrbsTestStart. + ** + ** Returns NFCSTATUS_SUCCESS if operation successful, + ** otherwise NFCSTATUS_FAILED. + ** + ******************************************************************************/ + +NFCSTATUS phNxpNciHal_PrbsTestStop() { + NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStop - Start\n"); + + NFCSTATUS status = NFCSTATUS_SUCCESS; + + status = phTmlNfc_IoCtl(phTmlNfc_e_ResetDevice); + + if (NFCSTATUS_SUCCESS == status) { + NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStop - SUCCESS\n"); + } else { + NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStop - FAILED\n"); + } + NXPLOG_NCIHAL_D("phNxpNciHal_PrbsTestStop - end\n"); + + return status; +} + +/******************************************************************************* +** +** Function phNxpNciHal_getPrbsCmd +** +** Description Test function frames the PRBS command. +** +** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED. +** +*******************************************************************************/ +#if (NFC_NXP_CHIP_TYPE != PN547C2) +NFCSTATUS phNxpNciHal_getPrbsCmd(phNxpNfc_PrbsType_t prbs_type, + phNxpNfc_PrbsHwType_t hw_prbs_type, + uint8_t tech, uint8_t bitrate, + uint8_t* prbs_cmd, uint8_t prbs_cmd_len) +#else +NFCSTATUS phNxpNciHal_getPrbsCmd(uint8_t tech, uint8_t bitrate, + uint8_t* prbs_cmd, uint8_t prbs_cmd_len) +#endif +{ + NFCSTATUS status = NFCSTATUS_SUCCESS; + int position_tech_param = 0; + int position_bit_param = 0; + + NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - tech 0x%x bitrate = 0x%x", tech, + bitrate); + if (NULL == prbs_cmd || +#if (NFC_NXP_CHIP_TYPE != PN547C2) + prbs_cmd_len != 0x09) +#else + prbs_cmd_len != 0x07) +#endif + { + return status; + } + + prbs_cmd[0] = 0x2F; + prbs_cmd[1] = 0x30; +#if (NFC_NXP_CHIP_TYPE != PN547C2) + prbs_cmd[2] = 0x06; + prbs_cmd[3] = (uint8_t)prbs_type; + // 0xFF Error value used for validation. + prbs_cmd[4] = (uint8_t)hw_prbs_type; + prbs_cmd[5] = 0xFF; // TECH + prbs_cmd[6] = 0xFF; // BITRATE + prbs_cmd[7] = 0x01; + prbs_cmd[8] = 0xFF; + position_tech_param = 5; + position_bit_param = 6; +#else + prbs_cmd[2] = 0x04; + // 0xFF Error value used for validation. + prbs_cmd[3] = 0xFF; // TECH + // 0xFF Error value used for validation. + prbs_cmd[4] = 0xFF; // BITRATE + prbs_cmd[5] = 0x01; + prbs_cmd[6] = 0xFF; + position_tech_param = 3; + position_bit_param = 4; +#endif + + switch (tech) { + case NFC_RF_TECHNOLOGY_A: + NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_RF_TECHNOLOGY_A"); + prbs_cmd[position_tech_param] = 0x00; + break; + case NFC_RF_TECHNOLOGY_B: + NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_RF_TECHNOLOGY_B"); + prbs_cmd[position_tech_param] = 0x01; + break; + case NFC_RF_TECHNOLOGY_F: + NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_RF_TECHNOLOGY_F"); + prbs_cmd[position_tech_param] = 0x02; + break; + default: + break; + } + + switch (bitrate) { + case NFC_BIT_RATE_106: + NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_106"); + if (prbs_cmd[position_tech_param] != 0x02) { + prbs_cmd[position_bit_param] = 0x00; + } + break; + case NFC_BIT_RATE_212: + NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_212"); + prbs_cmd[position_bit_param] = 0x01; + break; + case NFC_BIT_RATE_424: + NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_424"); + prbs_cmd[position_bit_param] = 0x02; + break; + case NFC_BIT_RATE_848: + NXPLOG_NCIHAL_D("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_848"); + if (prbs_cmd[position_tech_param] != 0x02) { + prbs_cmd[position_bit_param] = 0x03; + } + break; + default: + break; + } + + if (prbs_cmd[position_tech_param] == 0xFF || + prbs_cmd[position_bit_param] == 0xFF) { + // Invalid Param. + status = NFCSTATUS_FAILED; + } + + return status; +} + +/******************************************************************************* +** +** Function phNxpNciHal_RfFieldTest +** +** Description Test function performs RF filed test. +** +** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED. +** +*******************************************************************************/ +NFCSTATUS phNxpNciHal_RfFieldTest(uint8_t on) { + NFCSTATUS status = NFCSTATUS_SUCCESS; + int len = 0; + int cnt = 0; + + NXPLOG_NCIHAL_D("phNxpNciHal_RfFieldTest - start %x\n", on); + + if (on == 0x01) { + len = (sizeof(rf_field_on_test_data) / sizeof(rf_field_on_test_data[0])); + + for (cnt = 0; cnt < len; cnt++) { + status = phNxpNciHal_performTest(&(rf_field_on_test_data[cnt])); + if (status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED) { + break; + } + } + } else if (on == 0x00) { + len = (sizeof(rf_field_off_test_data) / sizeof(rf_field_off_test_data[0])); + + for (cnt = 0; cnt < len; cnt++) { + status = phNxpNciHal_performTest(&(rf_field_off_test_data[cnt])); + if (status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED) { + break; + } + } + } else { + status = NFCSTATUS_FAILED; + } + + if (status == NFCSTATUS_SUCCESS) { + NXPLOG_NCIHAL_D("phNxpNciHal_RfFieldTest - SUCCESSS\n"); + } else { + NXPLOG_NCIHAL_D("phNxpNciHal_RfFieldTest - FAILED\n"); + } + + NXPLOG_NCIHAL_D("phNxpNciHal_RfFieldTest - end\n"); + + return status; +} + +/******************************************************************************* + ** + ** Function phNxpNciHal_AntennaTest + ** + ** Description + ** + ** Returns + ** + ******************************************************************************/ +NFCSTATUS phNxpNciHal_AntennaTest() { + NFCSTATUS status = NFCSTATUS_FAILED; + + return status; +} + +/******************************************************************************* +** +** Function phNxpNciHal_DownloadPinTest +** +** Description Test function to validate the FW download pin connection. +** +** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED. +** +*******************************************************************************/ +NFCSTATUS phNxpNciHal_DownloadPinTest(void) { + NFCSTATUS status = NFCSTATUS_FAILED; + int len = 0; + int cnt = 0; + + NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - start\n"); + + len = (sizeof(download_pin_test_data1) / sizeof(download_pin_test_data1[0])); + + for (cnt = 0; cnt < len; cnt++) { + status = phNxpNciHal_performTest(&(download_pin_test_data1[cnt])); + if (status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED) { + break; + } + } + + if (status != NFCSTATUS_SUCCESS) { + NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - FAILED\n"); + return status; + } + + status = NFCSTATUS_FAILED; + status = phTmlNfc_IoCtl(phTmlNfc_e_EnableDownloadMode); + if (NFCSTATUS_SUCCESS != status) { + NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - FAILED\n"); + return status; + } + + status = NFCSTATUS_FAILED; + len = (sizeof(download_pin_test_data2) / sizeof(download_pin_test_data2[0])); + + for (cnt = 0; cnt < len; cnt++) { + status = phNxpNciHal_performTest(&(download_pin_test_data2[cnt])); + if (status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED) { + break; + } + } + + if (status == NFCSTATUS_SUCCESS) { + NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - SUCCESSS\n"); + } else { + NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - FAILED\n"); + } + + NXPLOG_NCIHAL_D("phNxpNciHal_DownloadPinTest - end\n"); + + return status; +} +/******************************************************************************* +** +** Function phNxpNciHal_AntennaSelfTest +** +** Description Test function to validate the Antenna's discrete +** components connection. +** +** Returns NFCSTATUS_SUCCESS if successful,otherwise NFCSTATUS_FAILED. +** +*******************************************************************************/ +NFCSTATUS phNxpNciHal_AntennaSelfTest(phAntenna_St_Resp_t* phAntenna_St_Resp) { + NFCSTATUS status = NFCSTATUS_FAILED; + NFCSTATUS antenna_st_status = NFCSTATUS_FAILED; + int len = 0; + int cnt = 0; + + NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - start\n"); + memcpy(&phAntenna_resp, phAntenna_St_Resp, sizeof(phAntenna_St_Resp_t)); + len = (sizeof(antenna_self_test_data) / sizeof(antenna_self_test_data[0])); + + for (cnt = 0; cnt < len; cnt++) { + status = phNxpNciHal_performTest(&(antenna_self_test_data[cnt])); + if (status == NFCSTATUS_RESPONSE_TIMEOUT || status == NFCSTATUS_FAILED) { + NXPLOG_NCIHAL_E( + "phNxpNciHal_AntennaSelfTest: commnad execution - FAILED\n"); + break; + } + } + + if (status == NFCSTATUS_SUCCESS) { + if ((gtxldo_status == NFCSTATUS_SUCCESS) && + (gagc_value_status == NFCSTATUS_SUCCESS) && + (gagc_nfcld_status == NFCSTATUS_SUCCESS) && + (gagc_differential_status == NFCSTATUS_SUCCESS)) { + antenna_st_status = NFCSTATUS_SUCCESS; + NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - SUCESS\n"); + } else { + NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - FAILED\n"); + } + } else { + NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - FAILED\n"); + } + + NXPLOG_NCIHAL_D("phNxpNciHal_AntennaSelfTest - end\n"); + + return antenna_st_status; +} + +#endif /*#ifdef NXP_HW_SELF_TEST*/ |