shinano-common: pn54x: Import from lineage-15.1

* https://github.com/LineageOS/android_system_nfc/tree/lineage-15.1/halimpl/pn54x/common
* support for pn54x has been dropped in lineage-16.0 and above

Change-Id: I19f2c3a6e3066bf9aaaaf4ddcd7d7ad867de0ed8

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