diff --git a/OWNERS b/OWNERS
new file mode 100644
index 0000000..984e5f9
--- /dev/null
+++ b/OWNERS
@@ -0,0 +1,2 @@
+eisenbach@google.com
+kandoiruchi@google.com
diff --git a/halimpl/pn54x/common/phNfcCommon.h b/halimpl/pn54x/common/phNfcCommon.h
index 13b7070..638a133 100644
--- a/halimpl/pn54x/common/phNfcCommon.h
+++ b/halimpl/pn54x/common/phNfcCommon.h
@@ -73,6 +73,10 @@
 
 #if (NFC_NXP_CHIP_TYPE == PN548C2)
 #define COMPILATION_MW "PN548C2"
+#elif (NFC_NXP_CHIP_TYPE == PN551)
+#define COMPILATION_MW "PN551"
+#elif (NFC_NXP_CHIP_TYPE == PN553)
+#define COMPILATION_MW "PN553"
 #else
 #define COMPILATION_MW "PN547C2"
 #endif
diff --git a/halimpl/pn54x/dnld/phDnldNfc.c b/halimpl/pn54x/dnld/phDnldNfc.c
index 6feb644..d2258ef 100644
--- a/halimpl/pn54x/dnld/phDnldNfc.c
+++ b/halimpl/pn54x/dnld/phDnldNfc.c
@@ -766,8 +766,8 @@
 #endif
     wStatus = phDnldNfc_LoadFW(pathName, &pImageInfo, &ImageInfoLen);
 
-  NXPLOG_FWDNLD_D("FW Image Length - ImageInfoLen %d", ImageInfoLen);
-  NXPLOG_FWDNLD_D("FW Image Info Pointer - pImageInfo %p", pImageInfo);
+  NXPLOG_FWDNLD_E("FW Image Length - ImageInfoLen %d", ImageInfoLen);
+  NXPLOG_FWDNLD_E("FW Image Info Pointer - pImageInfo %p", pImageInfo);
 
   if ((pImageInfo == NULL) || (ImageInfoLen == 0)) {
     NXPLOG_FWDNLD_E(
@@ -791,12 +791,12 @@
     gpphDnldContext->nxp_nfc_fw_len = ImageInfoLen;
     if ((NULL != gpphDnldContext->nxp_nfc_fw) &&
         (0 != gpphDnldContext->nxp_nfc_fw_len)) {
-      NXPLOG_FWDNLD_D("FW Major Version Num - %x",
+      NXPLOG_FWDNLD_E("FW Major Version Num - %x",
                       gpphDnldContext->nxp_nfc_fw[5]);
-      NXPLOG_FWDNLD_D("FW Minor Version Num - %x",
+      NXPLOG_FWDNLD_E("FW Minor Version Num - %x",
                       gpphDnldContext->nxp_nfc_fw[4]);
-      NXPLOG_FWDNLD_D("FW Image Length - %d", ImageInfoLen);
-      NXPLOG_FWDNLD_D("FW Image Info Pointer - %p", pImageInfo);
+      NXPLOG_FWDNLD_E("FW Image Length - %d", ImageInfoLen);
+      NXPLOG_FWDNLD_E("FW Image Info Pointer - %p", pImageInfo);
 
       /* get the FW version */
       wFwVer = (((uint16_t)(gpphDnldContext->nxp_nfc_fw[5]) << 8U) |
@@ -1046,6 +1046,8 @@
     pathName = "/system/vendor/firmware/libpn548ad_fw.so";
 #elif (NFC_NXP_CHIP_TYPE == PN551)
     pathName = "/system/vendor/firmware/libpn551_fw.so";
+#elif (NFC_NXP_CHIP_TYPE == PN553)
+    pathName = "/system/vendor/firmware/libpn553_fw.so";
 #else
     pathName = "/system/vendor/firmware/libpn547_fw.so";
 #endif
diff --git a/halimpl/pn54x/dnld/phNxpNciHal_Dnld.c b/halimpl/pn54x/dnld/phNxpNciHal_Dnld.c
index d50d47f..42cadba 100644
--- a/halimpl/pn54x/dnld/phNxpNciHal_Dnld.c
+++ b/halimpl/pn54x/dnld/phNxpNciHal_Dnld.c
@@ -553,6 +553,11 @@
               ) {
         bExpectedLen = PHLIBNFC_IOCTL_DNLD_GETVERLEN_MRA2_1;
         (gphNxpNciHal_fw_IoctlCtx.bChipVer) = bHwVer;
+#if (NFC_NXP_CHIP_TYPE == PN553)
+        if (PHDNLDNFC_HWVER_PN553_MRA1_0_UPDATED & pRespBuff->pBuff[0]) {
+          (gphNxpNciHal_fw_IoctlCtx.bChipVer) = pRespBuff->pBuff[0];
+        }
+#endif
       } else if ((bHwVer >= PHDNLDNFC_HWVER_MRA1_0) &&
                  (bHwVer <= PHDNLDNFC_HWVER_MRA2_0)) {
         bExpectedLen = PHLIBNFC_IOCTL_DNLD_GETVERLEN;
@@ -1745,7 +1750,7 @@
 }
 
 static NFCSTATUS phLibNfc_VerifyCrcStatus(uint8_t bCrcStatus) {
-#if (NFC_NXP_CHIP_TYPE == PN551)
+#if ((NFC_NXP_CHIP_TYPE == PN551) || (NFC_NXP_CHIP_TYPE == PN553))
   uint8_t bBitPos = 1;
   uint8_t bShiftVal = 2;
 #else
diff --git a/halimpl/pn54x/hal/phNxpNciHal.c b/halimpl/pn54x/hal/phNxpNciHal.c
index 4ccc873..be26279 100644
--- a/halimpl/pn54x/hal/phNxpNciHal.c
+++ b/halimpl/pn54x/hal/phNxpNciHal.c
@@ -30,7 +30,19 @@
 #define PN547C2_CLOCK_SETTING
 #undef PN547C2_FACTORY_RESET_DEBUG
 #define CORE_RES_STATUS_BYTE 3
+/* FW Mobile major number */
+#define FW_MOBILE_MAJOR_NUMBER_PN553 0x01
+#define FW_MOBILE_MAJOR_NUMBER_PN81A 0x02
+#define FW_MOBILE_MAJOR_NUMBER_PN551 0x05
+#define FW_MOBILE_MAJOR_NUMBER_PN48AD 0x01
 
+#if (NFC_NXP_CHIP_TYPE == PN551)
+#define FW_MOBILE_MAJOR_NUMBER FW_MOBILE_MAJOR_NUMBER_PN551
+#elif (NFC_NXP_CHIP_TYPE == PN553)
+#define FW_MOBILE_MAJOR_NUMBER FW_MOBILE_MAJOR_NUMBER_PN553
+#else
+#define FW_MOBILE_MAJOR_NUMBER FW_MOBILE_MAJOR_NUMBER_PN48AD
+#endif
 /* Processing of ISO 15693 EOF */
 extern uint8_t icode_send_eof;
 extern uint8_t icode_detected;
@@ -40,6 +52,7 @@
 static uint8_t fw_download_success = 0;
 
 static uint8_t config_access = false;
+static uint8_t config_success = true;
 /* NCI HAL Control structure */
 phNxpNciHal_Control_t nxpncihal_ctrl;
 
@@ -259,6 +272,8 @@
  ******************************************************************************/
 static NFCSTATUS phNxpNciHal_fw_download(void) {
   NFCSTATUS status = NFCSTATUS_FAILED;
+  /*NCI_RESET_CMD*/
+  static uint8_t cmd_reset_nci[] = {0x20, 0x00, 0x01, 0x00};
 
   phNxpNciHal_get_clk_freq();
   status = phTmlNfc_IoCtl(phTmlNfc_e_EnableDownloadMode);
@@ -268,6 +283,12 @@
     NXPLOG_NCIHAL_D("Calling Seq handler for FW Download \n");
     status = phNxpNciHal_fw_download_seq(nxpprofile_ctrl.bClkSrcVal,
                                          nxpprofile_ctrl.bClkFreqVal);
+    if (status != NFCSTATUS_SUCCESS) {
+      /* Abort any pending read and write */
+      phNxpNciHal_send_ext_cmd(sizeof(cmd_reset_nci), cmd_reset_nci);
+      phTmlNfc_ReadAbort();
+      phTmlNfc_WriteAbort();
+    }
     phDnldNfc_ReSetHwDevHandle();
   } else {
     status = NFCSTATUS_FAILED;
@@ -290,11 +311,6 @@
  ******************************************************************************/
 static NFCSTATUS phNxpNciHal_CheckValidFwVersion(void) {
   NFCSTATUS status = NFCSTATUS_NOT_ALLOWED;
-#if (NFC_NXP_CHIP_TYPE == PN551)
-  const unsigned char sfw_mobile_major_no = 0x05;
-#else
-  const unsigned char sfw_mobile_major_no = 0x01;
-#endif
   const unsigned char sfw_infra_major_no = 0x02;
   unsigned char ufw_current_major_no = 0x00;
   unsigned long num = 0;
@@ -303,36 +319,54 @@
   /* extract the firmware's major no */
   ufw_current_major_no = ((0x00FF) & (wFwVer >> 8U));
 
-  NXPLOG_NCIHAL_D("%s current_major_no = 0x%x", __func__, ufw_current_major_no);
-  if (ufw_current_major_no == sfw_mobile_major_no) {
+  NXPLOG_NCIHAL_D("%s current_major_no = 0x%x", __FUNCTION__,
+                  ufw_current_major_no);
+  if ((ufw_current_major_no == FW_MOBILE_MAJOR_NUMBER) ||
+      ((ufw_current_major_no == FW_MOBILE_MAJOR_NUMBER_PN81A &&
+        (nxpncihal_ctrl.nci_info.nci_version == NCI_VERSION_2_0)))
+#if (NFC_NXP_CHIP_TYPE == PN553)
+      || ((rom_version == 0x00) &&
+          (ufw_current_major_no == FW_MOBILE_MAJOR_NUMBER_PN81A))
+#endif
+          )
+
+  {
     status = NFCSTATUS_SUCCESS;
   } else if (ufw_current_major_no == sfw_infra_major_no) {
-    /* Check the nxp config file if still want to go for download */
-    /* By default NAME_NXP_FW_PROTECION_OVERRIDE will not be defined in config
-       file.
-       If user really want to override the Infra firmware over mobile firmware,
-       please
-       put "NXP_FW_PROTECION_OVERRIDE=0x01" in libnfc-nxp.conf file.
-       Please note once Infra firmware downloaded to Mobile device, The device
-       can never be updated to Mobile firmware*/
-    isfound = GetNxpNumValue(NAME_NXP_FW_PROTECION_OVERRIDE, &num, sizeof(num));
-    if (isfound > 0) {
-      if (num == 0x01) {
-        NXPLOG_NCIHAL_D("Override Infra FW over Mobile");
-        status = NFCSTATUS_SUCCESS;
+    if (rom_version == FW_MOBILE_ROM_VERSION_PN553 &&
+        nxpncihal_ctrl.nci_info.nci_version == NCI_VERSION_2_0) {
+      NXPLOG_NCIHAL_D(" PN81A  allow Fw download with major number =  0x%x",
+                      ufw_current_major_no);
+      status = NFCSTATUS_SUCCESS;
+    } else {
+      /* Check the nxp config file if still want to go for download */
+      /* By default NAME_NXP_FW_PROTECION_OVERRIDE will not be defined in config
+         file.
+         If user really want to override the Infra firmware over mobile
+         firmware, please
+         put "NXP_FW_PROTECION_OVERRIDE=0x01" in libnfc-nxp.conf file.
+         Please note once Infra firmware downloaded to Mobile device, The device
+         can never be updated to Mobile firmware*/
+      isfound =
+          GetNxpNumValue(NAME_NXP_FW_PROTECION_OVERRIDE, &num, sizeof(num));
+      if (isfound > 0) {
+        if (num == 0x01) {
+          NXPLOG_NCIHAL_D("Override Infra FW over Mobile");
+          status = NFCSTATUS_SUCCESS;
+        } else {
+          NXPLOG_NCIHAL_D(
+              "Firmware download not allowed (NXP_FW_PROTECION_OVERRIDE "
+              "invalid value)");
+        }
       } else {
         NXPLOG_NCIHAL_D(
-            "Firmware download not allowed (NXP_FW_PROTECION_OVERRIDE invalid "
-            "value)");
+            "Firmware download not allowed (NXP_FW_PROTECION_OVERRIDE not "
+            "defined)");
       }
-    } else {
-      NXPLOG_NCIHAL_D(
-          "Firmware download not allowed (NXP_FW_PROTECION_OVERRIDE not "
-          "defiend)");
     }
   }
 #if (NFC_NXP_CHIP_TYPE != PN547C2)
-  else if (gRecFWDwnld == true) {
+  else if (gRecFWDwnld == TRUE) {
     status = NFCSTATUS_SUCCESS;
   }
 #endif
@@ -427,7 +461,8 @@
   static uint8_t cmd_init_nci[] = {0x20, 0x01, 0x00};
   /*NCI_RESET_CMD*/
   static uint8_t cmd_reset_nci[] = {0x20, 0x00, 0x01, 0x00};
-
+  /*NCI2_0_INIT_CMD*/
+  static uint8_t cmd_init_nci2_0[] = {0x20, 0x01, 0x02, 0x00, 0x00};
   if (nxpncihal_ctrl.halStatus == HAL_STATUS_OPEN) {
     NXPLOG_NCIHAL_E("phNxpNciHal_open already open");
     return NFCSTATUS_SUCCESS;
@@ -460,7 +495,8 @@
 
   nxpncihal_ctrl.p_nfc_stack_cback = p_cback;
   nxpncihal_ctrl.p_nfc_stack_data_cback = p_data_cback;
-
+  /*nci version NCI_VERSION_UNKNOWN version by default*/
+  nxpncihal_ctrl.nci_info.nci_version = NCI_VERSION_UNKNOWN;
   /* Read the nfc device node name */
   nfc_dev_node = (char*)malloc(max_len * sizeof(char));
   if (nfc_dev_node == NULL) {
@@ -548,7 +584,21 @@
     goto clean_and_return;
   }
 
-  status = phNxpNciHal_send_ext_cmd(sizeof(cmd_init_nci), cmd_init_nci);
+  status = phNxpNciHal_send_ext_cmd(sizeof(cmd_init_nci2_0), cmd_init_nci2_0);
+  if (status == NFCSTATUS_SUCCESS) {
+    if (nxpncihal_ctrl.nci_info.nci_version != NCI_VERSION_2_0) {
+      NXPLOG_NCIHAL_E("Chip is in NCI1.0 mode reset the chip again");
+      status = phNxpNciHal_send_ext_cmd(sizeof(cmd_reset_nci), cmd_reset_nci);
+      if (status == NFCSTATUS_SUCCESS) {
+        if (nxpncihal_ctrl.nci_info.nci_version == NCI_VERSION_2_0) {
+          status = phNxpNciHal_send_ext_cmd(sizeof(cmd_init_nci2_0),
+                                            cmd_init_nci2_0);
+        } else {
+          status = phNxpNciHal_send_ext_cmd(sizeof(cmd_init_nci), cmd_init_nci);
+        }
+      }
+    }
+  }
   if (status != NFCSTATUS_SUCCESS) {
     NXPLOG_NCIHAL_E("NCI_CORE_INIT : Failed");
     if (init_retry_cnt < 3) {
@@ -564,8 +614,8 @@
   phNxpNciHal_enable_i2c_fragmentation();
   /*Get FW version from device*/
   status = phDnldNfc_InitImgInfo();
-  NXPLOG_NCIHAL_D("FW version for FW file = 0x%x", wFwVer);
-  NXPLOG_NCIHAL_D("FW version from device = 0x%x", wFwVerRsp);
+  NXPLOG_NCIHAL_E("FW version for FW file = 0x%x", wFwVer);
+  NXPLOG_NCIHAL_E("FW version from device = 0x%x", wFwVerRsp);
   if ((wFwVerRsp & 0x0000FFFF) == wFwVer) {
     NXPLOG_NCIHAL_D("FW uptodate not required");
     phDnldNfc_ReSetHwDevHandle();
@@ -581,10 +631,7 @@
       if (status != NFCSTATUS_SUCCESS) {
         if (NFCSTATUS_SUCCESS != phNxpNciHal_fw_mw_ver_check()) {
           NXPLOG_NCIHAL_D("Chip Version Middleware Version mismatch!!!!");
-          /* Abort any pending read and write */
-          phNxpNciHal_send_ext_cmd(sizeof(cmd_reset_nci), cmd_reset_nci);
-          phTmlNfc_ReadAbort();
-          phTmlNfc_WriteAbort();
+          phOsalNfc_Timer_Cleanup();
           phTmlNfc_Shutdown();
           wConfigStatus = NFCSTATUS_FAILED;
           goto clean_and_return;
@@ -641,13 +688,20 @@
  ******************************************************************************/
 int phNxpNciHal_fw_mw_ver_check() {
   NFCSTATUS status = NFCSTATUS_FAILED;
-  if (!strcmp(COMPILATION_MW, "PN551") && (rom_version == 0x10) &&
-      (fw_maj_ver == 0x05)) {
+  if (!(strcmp(COMPILATION_MW, "PN553")) &&
+      (rom_version == FW_MOBILE_ROM_VERSION_PN553) &&
+      (fw_maj_ver == 0x01 || fw_maj_ver == 0x02)) {
     status = NFCSTATUS_SUCCESS;
-  } else if (!strcmp(COMPILATION_MW, "PN548C2") && (rom_version == 0x10) &&
+  } else if (!strcmp(COMPILATION_MW, "PN551") &&
+             (rom_version == FW_MOBILE_ROM_VERSION_PN551) &&
+             (fw_maj_ver == 0x05)) {
+    status = NFCSTATUS_SUCCESS;
+  } else if (!strcmp(COMPILATION_MW, "PN548C2") &&
+             (rom_version == FW_MOBILE_ROM_VERSION_PN548AD) &&
              (fw_maj_ver == 0x01)) {
     status = NFCSTATUS_SUCCESS;
-  } else if (!strcmp(COMPILATION_MW, "PN547C2") && (rom_version == 0x08) &&
+  } else if (!strcmp(COMPILATION_MW, "PN547C2") &&
+             (rom_version == FW_MOBILE_ROM_VERSION_PN547C2) &&
              (fw_maj_ver == 0x01)) {
     status = NFCSTATUS_SUCCESS;
   }
@@ -810,8 +864,8 @@
     if (nxpncihal_ctrl.retry_cnt++ < MAX_RETRY_COUNT) {
       NXPLOG_NCIHAL_E(
           "write_unlocked failed - PN54X Maybe in Standby Mode - Retry");
-      /* 1ms delay to give NFCC wake up delay */
-      usleep(1000);
+      /* 10ms delay to give NFCC wake up delay */
+      usleep(1000 * 10);
       goto retry;
     } else {
       NXPLOG_NCIHAL_E(
@@ -906,18 +960,25 @@
     phNxpNciHal_print_res_status(nxpncihal_ctrl.p_rx_data,
                                  &nxpncihal_ctrl.rx_data_len);
     /* Check if response should go to hal module only */
-    if (nxpncihal_ctrl.hal_ext_enabled == 1 &&
-        (nxpncihal_ctrl.p_rx_data[0x00] & 0xF0) == 0x40) {
+    if (nxpncihal_ctrl.hal_ext_enabled == TRUE &&
+        (nxpncihal_ctrl.p_rx_data[0x00] & NCI_MT_MASK) == NCI_MT_RSP) {
       if (status == NFCSTATUS_FAILED) {
         NXPLOG_NCIHAL_D("enter into NFCC init recovery");
         nxpncihal_ctrl.ext_cb_data.status = status;
       }
       /* Unlock semaphore only for responses*/
-      if ((nxpncihal_ctrl.p_rx_data[0x00] & 0xF0) == 0x40 ||
+      if ((nxpncihal_ctrl.p_rx_data[0x00] & NCI_MT_MASK) == NCI_MT_RSP ||
           ((icode_detected == true) && (icode_send_eof == 3))) {
         /* Unlock semaphore */
         SEM_POST(&(nxpncihal_ctrl.ext_cb_data));
       }
+    }  // Notification Checking
+    else if ((nxpncihal_ctrl.hal_ext_enabled == TRUE) &&
+             ((nxpncihal_ctrl.p_rx_data[0x00] & NCI_MT_MASK) == NCI_MT_NTF) &&
+             (nxpncihal_ctrl.nci_info.wait_for_ntf == TRUE)) {
+      /* Unlock semaphore waiting for only  ntf*/
+      SEM_POST(&(nxpncihal_ctrl.ext_cb_data));
+      nxpncihal_ctrl.nci_info.wait_for_ntf = FALSE;
     }
     /* Read successful send the event to higher layer */
     else if ((nxpncihal_ctrl.p_nfc_stack_data_cback != NULL) &&
@@ -929,7 +990,9 @@
     NXPLOG_NCIHAL_E("read error status = 0x%x", pInfo->wStatus);
   }
 
-  if (nxpncihal_ctrl.halStatus == HAL_STATUS_CLOSE) {
+  if (nxpncihal_ctrl.halStatus == HAL_STATUS_CLOSE &&
+      nxpncihal_ctrl.nci_info.wait_for_ntf == FALSE) {
+    NXPLOG_NCIHAL_E(" Ignoring read , HAL close triggered");
     return;
   }
   /* Read again because read must be pending always.*/
@@ -977,7 +1040,7 @@
       0x20, 0x02, 0x05, 0x01, 0xA0, 0x91, 0x01, 0x01};
   static uint8_t swp_switch_timeout_cmd[] = {0x20, 0x02, 0x06, 0x01, 0xA0,
                                              0xF3, 0x02, 0x00, 0x00};
-
+  config_success = true;
   uint8_t* buffer = NULL;
   long bufflen = 260;
   long retlen = 0;
@@ -996,6 +1059,7 @@
   /*NCI_RESET_CMD*/
   static uint8_t cmd_reset_nci[] = {0x20, 0x00, 0x01,
                                     0x00};  // keep configuration
+  static uint8_t cmd_init_nci2_0[] = {0x20, 0x01, 0x02, 0x00, 0x00};
   /* reset config cache */
   static uint8_t retry_core_init_cnt;
   if (nxpncihal_ctrl.halStatus != HAL_STATUS_OPEN) {
@@ -1037,8 +1101,12 @@
       NXPLOG_NCIHAL_E(" Last command is CORE_RESET!!");
       goto invoke_callback;
     }
-
-    status = phNxpNciHal_send_ext_cmd(sizeof(cmd_init_nci), cmd_init_nci);
+    if (nxpncihal_ctrl.nci_info.nci_version == NCI_VERSION_2_0) {
+      status =
+          phNxpNciHal_send_ext_cmd(sizeof(cmd_init_nci2_0), cmd_init_nci2_0);
+    } else {
+      status = phNxpNciHal_send_ext_cmd(sizeof(cmd_init_nci), cmd_init_nci);
+    }
     if (status != NFCSTATUS_SUCCESS) {
       NXPLOG_NCIHAL_E("NCI_CORE_INIT : Failed");
       retry_core_init_cnt++;
@@ -1680,6 +1748,7 @@
     }
   }
 
+  if (config_success == false) return NFCSTATUS_FAILED;
 #ifdef PN547C2_CLOCK_SETTING
   if (isNxpConfigModified()) {
     updateNxpConfigTimestamp();
@@ -1747,19 +1816,17 @@
       status = phNxpNciHal_fw_download();
       if (status == NFCSTATUS_SUCCESS) {
         fw_download_success = 1;
-        status = phTmlNfc_Read(
-            nxpncihal_ctrl.p_cmd_data, NCI_MAX_DATA_LEN,
-            (pphTmlNfc_TransactCompletionCb_t)&phNxpNciHal_read_complete, NULL);
-        if (status != NFCSTATUS_PENDING) {
-          NXPLOG_NCIHAL_E("TML Read status error status = %x", status);
-          phTmlNfc_Shutdown();
-          status = NFCSTATUS_FAILED;
-          break;
-        }
-      } else {
-        status = NFCSTATUS_FAILED;
-        break;
       }
+      status = phTmlNfc_Read(
+          nxpncihal_ctrl.p_cmd_data, NCI_MAX_DATA_LEN,
+          (pphTmlNfc_TransactCompletionCb_t)&phNxpNciHal_read_complete, NULL);
+      if (status != NFCSTATUS_PENDING) {
+        NXPLOG_NCIHAL_E("TML Read status error status = %x", status);
+        phOsalNfc_Timer_Cleanup();
+        phTmlNfc_Shutdown();
+        status = NFCSTATUS_FAILED;
+      }
+      break;
     }
     gRecFWDwnld = false;
   } while (recFWState--);
@@ -2140,8 +2207,12 @@
   if (nxpprofile_ctrl.bClkSrcVal == CLK_SRC_PLL) {
     static uint8_t set_clock_cmd[] = {0x20, 0x02, 0x09, 0x02, 0xA0, 0x03,
                                       0x01, 0x11, 0xA0, 0x04, 0x01, 0x01};
+#if (NFC_NXP_CHIP_TYPE == PN553)
+    uint8_t param_clock_src = 0x00;
+#else
     uint8_t param_clock_src = CLK_SRC_PLL;
     param_clock_src = param_clock_src << 3;
+#endif
 
     if (nxpprofile_ctrl.bClkFreqVal == CLK_FREQ_13MHZ) {
       param_clock_src |= 0x00;
@@ -2157,7 +2228,11 @@
       param_clock_src |= 0x05;
     } else {
       NXPLOG_NCIHAL_E("Wrong clock freq, send default PLL@19.2MHz");
+#if (NFC_NXP_CHIP_TYPE == PN553)
+      param_clock_src = 0x01;
+#else
       param_clock_src = 0x11;
+#endif
     }
 
     set_clock_cmd[7] = param_clock_src;
@@ -2297,8 +2372,9 @@
   NFCSTATUS status = NFCSTATUS_FAILED;
   uint8_t param_clock_src = CLK_SRC_PLL;
   if (nxpprofile_ctrl.bClkSrcVal == CLK_SRC_PLL) {
+#if (NFC_NXP_CHIP_TYPE != PN553)
     param_clock_src = param_clock_src << 3;
-
+#endif
     if (nxpprofile_ctrl.bClkFreqVal == CLK_FREQ_13MHZ) {
       param_clock_src |= 0x00;
     } else if (nxpprofile_ctrl.bClkFreqVal == CLK_FREQ_19_2MHZ) {
@@ -2343,6 +2419,7 @@
   static uint8_t cmd_reset_nci[] = {0x20, 0x00, 0x01, 0x00};
   /*NCI_INIT_CMD*/
   static uint8_t cmd_init_nci[] = {0x20, 0x01, 0x00};
+  static uint8_t cmd_init_nci2_0[] = {0x20, 0x01, 0x02, 0x00, 0x00};
   static uint8_t get_i2c_fragmentation_cmd[] = {0x20, 0x03, 0x03,
                                                 0x01, 0xA0, 0x05};
   isfound = (GetNxpNumValue(NAME_NXP_I2C_FRAGMENTATION_ENABLED,
@@ -2384,7 +2461,12 @@
       if (status != NFCSTATUS_SUCCESS) {
         NXPLOG_NCIHAL_E("NCI_CORE_RESET: Failed");
       }
-      status = phNxpNciHal_send_ext_cmd(sizeof(cmd_init_nci), cmd_init_nci);
+      if (nxpncihal_ctrl.nci_info.nci_version == NCI_VERSION_2_0) {
+        status =
+            phNxpNciHal_send_ext_cmd(sizeof(cmd_init_nci2_0), cmd_init_nci2_0);
+      } else {
+        status = phNxpNciHal_send_ext_cmd(sizeof(cmd_init_nci), cmd_init_nci);
+      }
       if (status != NFCSTATUS_SUCCESS) {
         NXPLOG_NCIHAL_E("NCI_CORE_INIT : Failed");
       } else if (i2c_status == 0x01) {
@@ -2504,8 +2586,8 @@
 
   if (p_rx_data[2] && (config_access == true)) {
     if (p_rx_data[3] != NFCSTATUS_SUCCESS) {
-      NXPLOG_NCIHAL_W("Invalid Data from config file . Aborting..");
-      phNxpNciHal_close();
+      NXPLOG_NCIHAL_W("Invalid Data from config file.");
+      config_success = false;
     }
   }
 }
@@ -2522,7 +2604,7 @@
   /*NCI_RESET_CMD*/
   static uint8_t cmd_reset_nci[] = {0x20, 0x00, 0x01,
                                     0x00};  // keep configuration
-
+  static uint8_t cmd_init_nci2_0[] = {0x20, 0x01, 0x02, 0x00, 0x00};
   /* reset config cache */
   uint8_t retry_core_init_cnt = 0;
 
@@ -2551,7 +2633,11 @@
     retry_core_init_cnt++;
     goto retry_core_init;
   }
-  status = phNxpNciHal_send_ext_cmd(sizeof(cmd_init_nci), cmd_init_nci);
+  if (nxpncihal_ctrl.nci_data.nci_version == NCI_VERSION_2_0) {
+    status = phNxpNciHal_send_ext_cmd(sizeof(cmd_init_nci2_0), cmd_init_nci2_0);
+  } else {
+    status = phNxpNciHal_send_ext_cmd(sizeof(cmd_init_nci), cmd_init_nci);
+  }
   if (status != NFCSTATUS_SUCCESS) {
     NXPLOG_NCIHAL_D("NCI_CORE_INIT : Failed");
     retry_core_init_cnt++;
diff --git a/halimpl/pn54x/hal/phNxpNciHal.h b/halimpl/pn54x/hal/phNxpNciHal.h
index 7fd9af0..00ec236 100644
--- a/halimpl/pn54x/hal/phNxpNciHal.h
+++ b/halimpl/pn54x/hal/phNxpNciHal.h
@@ -25,10 +25,29 @@
 #define NCI_POLL_DURATION 500
 #define HAL_NFC_ENABLE_I2C_FRAGMENTATION_EVT 0x07
 #undef P2P_PRIO_LOGIC_HAL_IMP
-
+#define NCI_VERSION_2_0 0x20
+#define NCI_VERSION_1_1 0x11
+#define NCI_VERSION_1_0 0x10
+#define NCI_VERSION_UNKNOWN 0x00
 typedef void(phNxpNciHal_control_granted_callback_t)();
 
+/*ROM CODE VERSION FW*/
+#define FW_MOBILE_ROM_VERSION_PN551 0x10
+#define FW_MOBILE_ROM_VERSION_PN553 0x11
+#define FW_MOBILE_ROM_VERSION_PN548AD 0x10
+#define FW_MOBILE_ROM_VERSION_PN547C2 0x08
 /* NCI Data */
+
+#define NCI_MT_CMD 0x20
+#define NCI_MT_RSP 0x40
+#define NCI_MT_NTF 0x60
+
+#define CORE_RESET_TRIGGER_TYPE_CORE_RESET_CMD_RECEIVED 0x02
+#define CORE_RESET_TRIGGER_TYPE_POWERED_ON 0x01
+#define NCI_MSG_CORE_RESET 0x00
+#define NCI_MSG_CORE_INIT 0x01
+#define NCI_MT_MASK 0xE0
+#define NCI_OID_MASK 0x3F
 typedef struct nci_data {
   uint16_t len;
   uint8_t p_data[NCI_MAX_DATA_LEN];
@@ -39,7 +58,10 @@
 /* Macros to enable and disable extensions */
 #define HAL_ENABLE_EXT() (nxpncihal_ctrl.hal_ext_enabled = 1)
 #define HAL_DISABLE_EXT() (nxpncihal_ctrl.hal_ext_enabled = 0)
-
+typedef struct phNxpNciInfo {
+  uint8_t nci_version;
+  bool_t wait_for_ntf;
+} phNxpNciInfo_t;
 /* NCI Control structure */
 typedef struct phNxpNciHal_Control {
   phNxpNci_HalStatus halStatus; /* Indicate if hal is open or closed */
@@ -75,6 +97,7 @@
   /* retry count used to force download */
   uint16_t retry_cnt;
   uint8_t read_retry_cnt;
+  phNxpNciInfo_t nci_info;
 } phNxpNciHal_Control_t;
 
 typedef struct phNxpNciClock {
diff --git a/halimpl/pn54x/hal/phNxpNciHal_ext.c b/halimpl/pn54x/hal/phNxpNciHal_ext.c
index 4dbf206..cbfa296 100644
--- a/halimpl/pn54x/hal/phNxpNciHal_ext.c
+++ b/halimpl/pn54x/hal/phNxpNciHal_ext.c
@@ -76,6 +76,8 @@
 #define PROPRIETARY_CMD_FELICA_READER_MODE 0xFE
 static uint8_t gFelicaReaderMode;
 
+static NFCSTATUS phNxpNciHal_ext_process_nfc_init_rsp(uint8_t* p_ntf,
+                                                      uint16_t* p_len);
 /*******************************************************************************
 **
 ** Function         phNxpNciHal_ext_init
@@ -260,6 +262,7 @@
         break;
     }
   }
+  phNxpNciHal_ext_process_nfc_init_rsp(p_ntf, p_len);
 
   if (p_ntf[0] == 0x61 && p_ntf[1] == 0x05 && p_ntf[2] == 0x15 &&
       p_ntf[4] == 0x01 && p_ntf[5] == 0x06 && p_ntf[6] == 0x06) {
@@ -273,12 +276,14 @@
     if (icode_send_eof == 3) {
       icode_send_eof = 0;
     }
-    if (p_ntf[p_ntf[2] + 2] == 0x00) {
-      NXPLOG_NCIHAL_D("> Going through workaround - data of ISO 15693");
-      p_ntf[2]--;
-      (*p_len)--;
-    } else {
-      p_ntf[p_ntf[2] + 2] |= 0x01;
+    if (nxpncihal_ctrl.nci_info.nci_version != NCI_VERSION_2_0) {
+      if (p_ntf[p_ntf[2] + 2] == 0x00) {
+        NXPLOG_NCIHAL_D("> Going through workaround - data of ISO 15693");
+        p_ntf[2]--;
+        (*p_len)--;
+      } else {
+        p_ntf[p_ntf[2] + 2] |= 0x01;
+      }
     }
   } else if (p_ntf[2] == 0x02 && p_ntf[1] == 0x00 && icode_detected == 1) {
     NXPLOG_NCIHAL_D("> ICODE EOF response do not send to upper layer");
@@ -296,17 +301,6 @@
     p_ntf[3] = 0x00;
     p_ntf[4] = 0x00;
     *p_len = 5;
-  } else if ((p_ntf[0] == 0x40) && (p_ntf[1] == 0x01)) {
-    int len = p_ntf[2] + 2; /*include 2 byte header*/
-    wFwVerRsp = (((uint32_t)p_ntf[len - 2]) << 16U) |
-                (((uint32_t)p_ntf[len - 1]) << 8U) | p_ntf[len];
-    if (wFwVerRsp == 0) status = NFCSTATUS_FAILED;
-    iCoreInitRspLen = *p_len;
-    memcpy(bCoreInitRsp, p_ntf, *p_len);
-    NXPLOG_NCIHAL_D("NxpNci> FW Version: %x.%x.%x", p_ntf[len - 2],
-                    p_ntf[len - 1], p_ntf[len]);
-    fw_maj_ver = p_ntf[len - 1];
-    rom_version = p_ntf[len - 2];
   }
   // 4200 02 00 01
   else if (p_ntf[0] == 0x42 && p_ntf[1] == 0x00 && ee_disc_done == 0x01) {
@@ -335,21 +329,6 @@
   } else if (p_ntf[0] == 0x41 && p_ntf[1] == 0x04 && cleanup_timer != 0) {
     status = NFCSTATUS_FAILED;
     return status;
-  } else if (p_ntf[0] == 0x60 && p_ntf[1] == 0x00) {
-    NXPLOG_NCIHAL_E("CORE_RESET_NTF received!");
-#if (NFC_NXP_CHIP_TYPE == PN548C2)
-    if (nfcdep_detected &&
-        !(p_ntf[2] == 0x06 && p_ntf[3] == 0xA0 && p_ntf[4] == 0x00 &&
-          ((p_ntf[5] == 0xC9 && p_ntf[6] == 0x95 && p_ntf[7] == 0x00 &&
-            p_ntf[8] == 0x00) ||
-           (p_ntf[5] == 0x07 && p_ntf[6] == 0x39 && p_ntf[7] == 0xF2 &&
-            p_ntf[8] == 0x00)))) {
-      nfcdep_detected = 0x00;
-    }
-#endif
-    phNxpNciHal_emergency_recovery();
-    status = NFCSTATUS_FAILED;
-    return status;
   }
 #if (NFC_NXP_CHIP_TYPE == PN547C2)
   else if (p_ntf[0] == 0x61 && p_ntf[1] == 0x05 && p_ntf[4] == 0x02 &&
@@ -422,6 +401,83 @@
 }
 
 /******************************************************************************
+ * Function         phNxpNciHal_ext_process_nfc_init_rsp
+ *
+ * Description      This function is used to process the HAL NFC core reset rsp
+ *                  and ntf and core init rsp of NCI 1.0 or NCI2.0 and update
+ *                  NCI version.
+ *                  It also handles error response such as core_reset_ntf with
+ *                  error status in both NCI2.0 and NCI1.0.
+ *
+ * Returns          Returns NFCSTATUS_SUCCESS if parsing response is successful
+ *                  or returns failure.
+ *
+ *******************************************************************************/
+static NFCSTATUS phNxpNciHal_ext_process_nfc_init_rsp(uint8_t* p_ntf,
+                                                      uint16_t* p_len) {
+  NFCSTATUS status = NFCSTATUS_SUCCESS;
+  /* Parsing CORE_RESET_RSP and CORE_RESET_NTF to update NCI version.*/
+  if (p_ntf == NULL || *p_len == 0x00) {
+    return NFCSTATUS_FAILED;
+  }
+  if (p_ntf[0] == NCI_MT_RSP &&
+      ((p_ntf[1] & NCI_OID_MASK) == NCI_MSG_CORE_RESET)) {
+    if (p_ntf[2] == 0x01 && p_ntf[3] == 0x00) {
+      NXPLOG_NCIHAL_D("CORE_RESET_RSP NCI2.0");
+      if (nxpncihal_ctrl.hal_ext_enabled == TRUE) {
+        nxpncihal_ctrl.nci_info.wait_for_ntf = TRUE;
+      }
+    } else if (p_ntf[2] == 0x03 && p_ntf[3] == 0x00) {
+      NXPLOG_NCIHAL_D("CORE_RESET_RSP NCI1.0");
+      nxpncihal_ctrl.nci_info.nci_version = p_ntf[4];
+    }
+  } else if (p_ntf[0] == NCI_MT_NTF &&
+             ((p_ntf[1] & NCI_OID_MASK) == NCI_MSG_CORE_RESET)) {
+    if (p_ntf[3] == CORE_RESET_TRIGGER_TYPE_CORE_RESET_CMD_RECEIVED ||
+        p_ntf[3] == CORE_RESET_TRIGGER_TYPE_POWERED_ON) {
+      NXPLOG_NCIHAL_D("CORE_RESET_NTF NCI2.0 reason CORE_RESET_CMD received !");
+      nxpncihal_ctrl.nci_info.nci_version = p_ntf[5];
+      int len = p_ntf[2] + 2; /*include 2 byte header*/
+      wFwVerRsp = (((uint32_t)p_ntf[len - 2]) << 16U) |
+                  (((uint32_t)p_ntf[len - 1]) << 8U) | p_ntf[len];
+      NXPLOG_NCIHAL_D("NxpNci> FW Version: %x.%x.%x", p_ntf[len - 2],
+                      p_ntf[len - 1], p_ntf[len]);
+    } else {
+#if (NFC_NXP_CHIP_TYPE == PN548C2)
+      if (nfcdep_detected &&
+          !(p_ntf[2] == 0x06 && p_ntf[3] == 0xA0 && p_ntf[4] == 0x00 &&
+            ((p_ntf[5] == 0xC9 && p_ntf[6] == 0x95 && p_ntf[7] == 0x00 &&
+              p_ntf[8] == 0x00) ||
+             (p_ntf[5] == 0x07 && p_ntf[6] == 0x39 && p_ntf[7] == 0xF2 &&
+              p_ntf[8] == 0x00)))) {
+        nfcdep_detected = 0x00;
+      }
+#endif
+      phNxpNciHal_emergency_recovery();
+      status = NFCSTATUS_FAILED;
+    } /* Parsing CORE_INIT_RSP*/
+  } else if (p_ntf[0] == NCI_MT_RSP &&
+             ((p_ntf[1] & NCI_OID_MASK) == NCI_MSG_CORE_INIT)) {
+    if (nxpncihal_ctrl.nci_info.nci_version == NCI_VERSION_2_0) {
+      NXPLOG_NCIHAL_D("CORE_INIT_RSP NCI2.0 received !");
+    } else {
+      NXPLOG_NCIHAL_D("CORE_INIT_RSP NCI1.0 received !");
+      int len = p_ntf[2] + 2; /*include 2 byte header*/
+      wFwVerRsp = (((uint32_t)p_ntf[len - 2]) << 16U) |
+                  (((uint32_t)p_ntf[len - 1]) << 8U) | p_ntf[len];
+      if (wFwVerRsp == 0) status = NFCSTATUS_FAILED;
+      iCoreInitRspLen = *p_len;
+      memcpy(bCoreInitRsp, p_ntf, *p_len);
+      NXPLOG_NCIHAL_D("NxpNci> FW Version: %x.%x.%x", p_ntf[len - 2],
+                      p_ntf[len - 1], p_ntf[len]);
+      fw_maj_ver = p_ntf[len - 1];
+      rom_version = p_ntf[len - 2];
+    }
+  }
+  return status;
+}
+
+/******************************************************************************
  * Function         phNxpNciHal_process_ext_cmd_rsp
  *
  * Description      This function process the extension command response. It
@@ -472,7 +528,6 @@
 
   /* Stop Timer */
   status = phOsalNfc_Timer_Stop(timeoutTimerId);
-
   if (NFCSTATUS_SUCCESS == status) {
     NXPLOG_NCIHAL_D("Response timer stopped");
   } else {
@@ -480,6 +535,32 @@
     status = NFCSTATUS_FAILED;
     goto clean_and_return;
   }
+  /* Start timer to wait for NTF*/
+  if (nxpncihal_ctrl.nci_info.wait_for_ntf == TRUE) {
+    status = phOsalNfc_Timer_Start(timeoutTimerId, HAL_EXTNS_WRITE_RSP_TIMEOUT,
+                                   &hal_extns_write_rsp_timeout_cb, NULL);
+    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;
+    }
+    if (SEM_WAIT(nxpncihal_ctrl.ext_cb_data)) {
+      NXPLOG_NCIHAL_E("p_hal_ext->ext_cb_data.sem semaphore error");
+      /* Stop Timer */
+      status = phOsalNfc_Timer_Stop(timeoutTimerId);
+      goto clean_and_return;
+    }
+    status = phOsalNfc_Timer_Stop(timeoutTimerId);
+    if (NFCSTATUS_SUCCESS == status) {
+      NXPLOG_NCIHAL_D("Response timer stopped");
+    } else {
+      NXPLOG_NCIHAL_E("Response timer stop ERROR!!!");
+      status = NFCSTATUS_FAILED;
+      goto clean_and_return;
+    }
+  }
 
   if (nxpncihal_ctrl.ext_cb_data.status != NFCSTATUS_SUCCESS) {
     NXPLOG_NCIHAL_E(
@@ -494,7 +575,7 @@
 
 clean_and_return:
   phNxpNciHal_cleanup_cb_data(&nxpncihal_ctrl.ext_cb_data);
-
+  nxpncihal_ctrl.nci_info.wait_for_ntf = FALSE;
   return status;
 }
 
diff --git a/halimpl/pn54x/libnfc-brcm_NCI2_0.conf b/halimpl/pn54x/libnfc-brcm_NCI2_0.conf
new file mode 100644
index 0000000..a4d3290
--- /dev/null
+++ b/halimpl/pn54x/libnfc-brcm_NCI2_0.conf
@@ -0,0 +1,407 @@
+###################### Start of libnfc-brcm.conf #######################
+
+###############################################################################
+# Application options
+APPL_TRACE_LEVEL=0xFF
+PROTOCOL_TRACE_LEVEL=0xFFFFFFFF
+
+###############################################################################
+# performance measurement
+# Change this setting to control how often USERIAL log the performance (throughput)
+# data on read/write/poll
+# defailt is to log performance dara for every 100 read or write
+#REPORT_PERFORMANCE_MEASURE=100
+
+###############################################################################
+# File used for NFA storage
+NFA_STORAGE="/data/nfc"
+
+###############################################################################
+# Snooze Mode Settings
+#
+#  By default snooze mode is enabled.  Set SNOOZE_MODE_CFG byte[0] to 0
+#  to disable.
+#
+#  If SNOOZE_MODE_CFG is not provided, the default settings are used:
+#  They are as follows:
+#       8             Sleep Mode (0=Disabled 1=UART 8=SPI/I2C)
+#       0             Idle Threshold Host
+#       0             Idle Threshold HC
+#       0             NFC Wake active mode (0=ActiveLow 1=ActiveHigh)
+#       1             Host Wake active mode (0=ActiveLow 1=ActiveHigh)
+#
+#SNOOZE_MODE_CFG={08:00:00:00:01}
+
+###############################################################################
+# Insert a delay in milliseconds after NFC_WAKE and before write to NFCC
+#NFC_WAKE_DELAY=20
+
+###############################################################################
+# Various Delay settings (in ms) used in USERIAL
+#  POWER_ON_DELAY
+#    Delay after turning on chip, before writing to transport (default 300)
+#  PRE_POWER_OFF_DELAY
+#    Delay after deasserting NFC-Wake before turn off chip (default 0)
+#  POST_POWER_OFF_DELAY
+#    Delay after turning off chip, before USERIAL_close returns (default 0)
+#
+#POWER_ON_DELAY=300
+#PRE_POWER_OFF_DELAY=0
+#POST_POWER_OFF_DELAY=0
+
+###############################################################################
+# Maximum time (ms) to wait for RESET NTF after setting REG_PU to high
+# The default is 1000.
+#NFCC_ENABLE_TIMEOUT=0
+
+###############################################################################
+# LPTD mode configuration
+#  byte[0] is the length of the remaining bytes in this value
+#     if set to 0, LPTD params will NOT be sent to NFCC (i.e. disabled).
+#  byte[1] is the param id it should be set to B9.
+#  byte[2] is the length of the LPTD parameters
+#  byte[3] indicates if LPTD is enabled
+#     if set to 0, LPTD will be disabled (parameters will still be sent).
+#  byte[4-n] are the LPTD parameters.
+#  By default, LPTD is enabled and default settings are used.
+#  See nfc_hal_dm_cfg.c for defaults
+#LPTD_CFG={23:B9:21:01:02:FF:FF:04:A0:0F:40:00:80:02:02:10:00:00:00:31:0C:30:00:00:00:00:00:00:00:00:00:00:00:00:00:00}
+
+###############################################################################
+# Startup Configuration (100 bytes maximum)
+#
+# For the 0xCA parameter, byte[9] (marked by 'AA') is for UICC0, and byte[10] (marked by BB) is
+#    for UICC1.  The values are defined as:
+#   0 : UICCx only supports ISO_DEP in low power mode.
+#   2 : UICCx only supports Mifare in low power mode.
+#   3 : UICCx supports both ISO_DEP and Mifare in low power mode.
+#
+#                                                                          AA BB
+#NFA_DM_START_UP_CFG={1F:CB:01:01:A5:01:01:CA:14:00:00:00:00:06:E8:03:00:00:00:00:00:00:00:00:00:00:00:00:00:80:01:01}
+
+###############################################################################
+# Startup Vendor Specific Configuration (100 bytes maximum);
+#  byte[0] TLV total len = 0x5
+#  byte[1] NCI_MTS_CMD|NCI_GID_PROP = 0x2f
+#  byte[2] NCI_MSG_FRAME_LOG = 0x9
+#  byte[3] 2
+#  byte[4] 0=turn off RF frame logging; 1=turn on
+#  byte[5] 0=turn off SWP frame logging; 1=turn on
+#  NFA_DM_START_UP_VSC_CFG={05:2F:09:02:01:01}
+
+###############################################################################
+# Antenna Configuration - This data is used when setting 0xC8 config item
+# at startup (before discovery is started).  If not used, no value is sent.
+#
+# The settings for this value are documented here:
+# http://wcgbu.broadcom.com/wpan/PM/Project%20Document%20Library/bcm20791B0/
+#   Design/Doc/PHY%20register%20settings/BCM20791-B2-1027-02_PHY_Recommended_Reg_Settings.xlsx
+# This document is maintained by Paul Forshaw.
+#
+# The values marked as ?? should be tweaked per antenna or customer/app:
+# {20:C8:1E:06:??:00:??:??:??:00:??:24:00:1C:00:75:00:77:00:76:00:1C:00:03:00:0A:00:??:01:00:00:40:04}
+# array[0] = 0x20 is length of the payload from array[1] to the end
+# array[1] = 0xC8 is PREINIT_DSP_CFG
+#PREINIT_DSP_CFG={20:C8:1E:06:1F:00:0F:03:3C:00:04:24:00:1C:00:75:00:77:00:76:00:1C:00:03:00:0A:00:48:01:00:00:40:04}
+
+###############################################################################
+# Configure crystal frequency when internal LPO can't detect the frequency.
+#XTAL_FREQUENCY=0
+###############################################################################
+# Configure the default Destination Gate used by HCI (the default is 4, which
+# is the ETSI loopback gate.
+NFA_HCI_DEFAULT_DEST_GATE=0xF0
+
+###############################################################################
+# Configure the single default SE to use.  The default is to use the first
+# SE that is detected by the stack.  This value might be used when the phone
+# supports multiple SE (e.g. 0xF3 and 0xF4) but you want to force it to use
+# one of them (e.g. 0xF4).
+#ACTIVE_SE=0xF3
+
+###############################################################################
+# Configure the default NfcA/IsoDep techology and protocol route. Can be
+# either a secure element (e.g. 0xF4) or the host (0x00)
+#DEFAULT_ISODEP_ROUTE=0x00
+
+###############################################################################
+# Configure the NFC Extras to open and use a static pipe.  If the value is
+# not set or set to 0, then the default is use a dynamic pipe based on a
+# destination gate (see NFA_HCI_DEFAULT_DEST_GATE).  Note there is a value
+# for each UICC (where F3="UICC0" and F4="UICC1")
+#NFA_HCI_STATIC_PIPE_ID_F3=0x70
+#NFA_HCI_STATIC_PIPE_ID_01=0x19
+NFA_HCI_STATIC_PIPE_ID_C0=0x19
+###############################################################################
+# When disconnecting from Oberthur secure element, perform a warm-reset of
+# the secure element to deselect the applet.
+# The default hex value of the command is 0x3.  If this variable is undefined,
+# then this feature is not used.
+#OBERTHUR_WARM_RESET_COMMAND=0x03
+
+###############################################################################
+# Force UICC to only listen to the following technology(s).
+# The bits are defined as tNFA_TECHNOLOGY_MASK in nfa_api.h.
+# Default is NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B | NFA_TECHNOLOGY_MASK_F
+UICC_LISTEN_TECH_MASK=0x07
+
+###############################################################################
+# Force HOST listen feature enable or disable.
+# 0: Disable
+# 1: Enable
+HOST_LISTEN_ENABLE=0x01
+
+###############################################################################
+# Enabling/Disabling Forward functionality
+# Disable           0x00
+# Enable            0x01
+NXP_FWD_FUNCTIONALITY_ENABLE=0x01
+
+###############################################################################
+# Allow UICC to be powered off if there is no traffic.
+# Timeout is in ms. If set to 0, then UICC will not be powered off.
+#UICC_IDLE_TIMEOUT=30000
+UICC_IDLE_TIMEOUT=0
+
+###############################################################################
+# AID for Empty Select command
+# If specified, this AID will be substituted when an Empty SELECT command is
+# detected.  The first byte is the length of the AID.  Maximum length is 16.
+AID_FOR_EMPTY_SELECT={08:A0:00:00:01:51:00:00:00}
+###############################################################################
+# Maximum Number of Credits to be allowed by the NFCC
+#   This value overrides what the NFCC specifices allowing the host to have
+#   the control to work-around transport limitations.  If this value does
+#   not exist or is set to 0, the NFCC will provide the number of credits.
+MAX_RF_DATA_CREDITS=1
+
+###############################################################################
+# This setting allows you to disable registering the T4t Virtual SE that causes
+# the NFCC to send PPSE requests to the DH.
+# The default setting is enabled (i.e. T4t Virtual SE is registered).
+#REGISTER_VIRTUAL_SE=1
+
+###############################################################################
+# When screen is turned off, specify the desired power state of the controller.
+# 0: power-off-sleep state; DEFAULT
+# 1: full-power state
+# 2: screen-off card-emulation (CE4/CE3/CE1 modes are used)
+SCREEN_OFF_POWER_STATE=1
+
+###############################################################################
+# Firmware patch file
+#  If the value is not set then patch download is disabled.
+#FW_PATCH="/vendor/firmware/bcm2079x_firmware.ncd"
+
+###############################################################################
+# Firmware pre-patch file (sent before the above patch file)
+#  If the value is not set then pre-patch is not used.
+#FW_PRE_PATCH="/vendor/firmware/bcm2079x_pre_firmware.ncd"
+
+###############################################################################
+# Firmware patch format
+#   1 = HCD
+#   2 = NCD (default)
+#NFA_CONFIG_FORMAT=2
+
+###############################################################################
+# SPD Debug mode
+#  If set to 1, any failure of downloading a patch will trigger a hard-stop
+#SPD_DEBUG=0
+
+###############################################################################
+# SPD Max Retry Count
+#  The number of attempts to download a patch before giving up (defualt is 3).
+#  Note, this resets after a power-cycle.
+#SPD_MAX_RETRY_COUNT=3
+
+###############################################################################
+# transport driver
+#
+# TRANSPORT_DRIVER=<driver>
+#
+#  where <driver> can be, for example:
+#    "/dev/ttyS"        (UART)
+#    "/dev/bcmi2cnfc"   (I2C)
+#    "hwtun"            (HW Tunnel)
+#    "/dev/bcmspinfc"   (SPI)
+#    "/dev/btusb0"      (BT USB)
+#TRANSPORT_DRIVER="/dev/bcm2079x-i2c"
+
+###############################################################################
+# power control driver
+# Specify a kernel driver that support ioctl commands to control NFC_EN and
+# NFC_WAKE gpio signals.
+#
+# POWER_CONTRL_DRIVER=<driver>
+#  where <driver> can be, for example:
+#    "/dev/nfcpower"
+#    "/dev/bcmi2cnfc"   (I2C)
+#    "/dev/bcmspinfc"   (SPI)
+#    i2c and spi driver may be used to control NFC_EN and NFC_WAKE signal
+#POWER_CONTROL_DRIVER="/dev/bcm2079x-i2c"
+
+###############################################################################
+# I2C transport driver options
+# Mako does not support 10-bit I2C addresses
+# Revert to 7-bit address
+#BCMI2CNFC_ADDRESS=0x77
+
+###############################################################################
+# I2C transport driver try to read multiple packets in read() if data is available
+# remove the comment below to enable this feature
+#READ_MULTIPLE_PACKETS=1
+
+###############################################################################
+# SPI transport driver options
+#SPI_NEGOTIATION={0A:F0:00:01:00:00:00:FF:FF:00:00}
+
+###############################################################################
+# UART transport driver options
+#
+# PORT=1,2,3,...
+# BAUD=115200, 19200, 9600, 4800,
+# DATABITS=8, 7, 6, 5
+# PARITY="even" | "odd" | "none"
+# STOPBITS="0" | "1" | "1.5" | "2"
+
+#UART_PORT=2
+#UART_BAUD=115200
+#UART_DATABITS=8
+#UART_PARITY="none"
+#UART_STOPBITS="1"
+
+###############################################################################
+# Insert a delay in microseconds per byte after a write to NFCC.
+# after writing a block of data to the NFCC, delay this an amopunt of time before
+# writing next block of data.  the delay is calculated as below
+#   NFC_WRITE_DELAY * (number of byte written) / 1000 milliseconds
+# e.g. after 259 bytes is written, delay (259 * 20 / 1000) 5 ms before next write
+#NFC_WRITE_DELAY=20
+
+###############################################################################
+# Maximum Number of Credits to be allowed by the NFCC
+#   This value overrides what the NFCC specifices allowing the host to have
+#   the control to work-around transport limitations.  If this value does
+#   not exist or is set to 0, the NFCC will provide the number of credits.
+MAX_RF_DATA_CREDITS=1
+
+###############################################################################
+# Default poll duration (in ms)
+#  The defualt is 500ms if not set (see nfc_target.h)
+#NFA_DM_DISC_DURATION_POLL=333
+###############################################################################
+# Antenna Configuration - This data is used when setting 0xC8 config item
+# at startup (before discovery is started).  If not used, no value is sent.
+#
+# The settings for this value are documented here:
+# http://wcgbu.broadcom.com/wpan/PM/Project%20Document%20Library/bcm20791B0/
+#   Design/Doc/PHY%20register%20settings/BCM20791-B2-1027-02_PHY_Recommended_Reg_Settings.xlsx
+# This document is maintained by Paul Forshaw.
+#
+# The values marked as ?? should be tweaked per antenna or customer/app:
+# {20:C8:1E:06:??:00:??:??:??:00:??:24:00:1C:00:75:00:77:00:76:00:1C:00:03:00:0A:00:??:01:00:00:40:04}
+# array[0] = 0x20 is length of the payload from array[1] to the end
+# array[1] = 0xC8 is PREINIT_DSP_CFG
+#PREINIT_DSP_CFG={20:C8:1E:06:1F:00:0F:03:3C:00:04:24:00:1C:00:75:00:77:00:76:00:1C:00:03:00:0A:00:48:01:00:00:40:04}
+
+###############################################################################
+# Choose the presence-check algorithm for type-4 tag.  If not defined, the default value is 1.
+# 0  NFA_RW_PRES_CHK_DEFAULT; Let stack selects an algorithm
+# 1  NFA_RW_PRES_CHK_I_BLOCK; ISO-DEP protocol's empty I-block
+# 2  NFA_RW_PRES_CHK_RESET; Deactivate to Sleep, then re-activate
+# 3  NFA_RW_PRES_CHK_RB_CH0; Type-4 tag protocol's ReadBinary command on channel 0
+# 4  NFA_RW_PRES_CHK_RB_CH3; Type-4 tag protocol's ReadBinary command on channel 3
+# 5  NFA_RW_PRES_CHK_ISO_DEP_NAK; Type - 4 tag protocol iso-dep nak presence check
+#    command is sent waiting for rsp and ntf.
+PRESENCE_CHECK_ALGORITHM=5
+
+###############################################################################
+# Force tag polling for the following technology(s).
+# The bits are defined as tNFA_TECHNOLOGY_MASK in nfa_api.h.
+# Default is NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B |
+#            NFA_TECHNOLOGY_MASK_F | NFA_TECHNOLOGY_MASK_ISO15693 |
+#            NFA_TECHNOLOGY_MASK_B_PRIME | NFA_TECHNOLOGY_MASK_KOVIO |
+#NFA_TECHNOLOGY_MASK_ACTIVE
+#
+# Notable bits:
+# NFA_TECHNOLOGY_MASK_A             0x01    /* NFC Technology A             */
+# NFA_TECHNOLOGY_MASK_B             0x02    /* NFC Technology B             */
+# NFA_TECHNOLOGY_MASK_F             0x04    /* NFC Technology F             */
+# NFA_TECHNOLOGY_MASK_ISO15693      0x08    /* Proprietary Technology       */
+# NFA_TECHNOLOGY_MASK_KOVIO         0x20    /* Proprietary Technology       */
+# NFA_TECHNOLOGY_MASK_ACTIVE        0x40    /* NFC Technology Active        */
+POLLING_TECH_MASK=0x6F
+
+###############################################################################
+# Force P2P to only listen for the following technology(s).
+# The bits are defined as tNFA_TECHNOLOGY_MASK in nfa_api.h.
+# Default is NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_F |
+#NFA_TECHNOLOGY_MASK_ACTIVE
+#
+# Notable bits:
+# NFA_TECHNOLOGY_MASK_A             0x01    /* NFC Technology A             */
+# NFA_TECHNOLOGY_MASK_F             0x04    /* NFC Technology F             */
+#NFA_TECHNOLOGY_MASK_ACTIVE         0x40    /* NFC Technology Active        */
+P2P_LISTEN_TECH_MASK=0x45
+
+PRESERVE_STORAGE=0x01
+
+###############################################################################
+# Override the stack default for NFA_EE_MAX_EE_SUPPORTED set in nfc_target.h.
+# The value is set to 3 by default as it assumes we will discover 0xF2,
+# 0xF3, and 0xF4. If a platform will exclude and SE, this value can be reduced
+# so that the stack will not wait any longer than necessary.
+
+# Maximum EE supported number
+# NXP PN547C2 0x02
+# NXP PN65T 0x03
+# NXP PN548C2 0x02
+# NXP PN66T 0x03
+NFA_MAX_EE_SUPPORTED=0x02
+
+###############################################################################
+# NCI Hal Module name
+NCI_HAL_MODULE="nfc_nci"
+
+##############################################################################
+# Deactivate notification wait time out in seconds used in ETSI Reader mode
+# 0 - Infinite wait
+#NFA_DM_DISC_NTF_TIMEOUT=0
+
+###############################################################################
+# AID_MATCHING constants
+# AID_MATCHING_EXACT_ONLY 0x00
+# AID_MATCHING_EXACT_OR_PREFIX 0x01
+# AID_MATCHING_PREFIX_ONLY 0x02
+# AID_MATCHING_EXACT_OR_SUBSET_OR_PREFIX 0x03
+AID_MATCHING_MODE=0x03
+
+###############################################################################
+# Default Secure Element route id
+DEFAULT_OFFHOST_ROUTE=0x02
+
+###############################################################################
+# Vendor Specific Proprietary Protocol & Discovery Configuration
+# Set to 0xFF if unsupported
+#  byte[0] NCI_PROTOCOL_18092_ACTIVE
+#  byte[1] NCI_PROTOCOL_B_PRIME
+#  byte[2] NCI_PROTOCOL_DUAL
+#  byte[3] NCI_PROTOCOL_15693
+#  byte[4] NCI_PROTOCOL_KOVIO
+#  byte[5] NCI_PROTOCOL_MIFARE
+#  byte[6] NCI_DISCOVERY_TYPE_POLL_KOVIO
+#  byte[7] NCI_DISCOVERY_TYPE_POLL_B_PRIME
+#  byte[8] NCI_DISCOVERY_TYPE_LISTEN_B_PRIME
+NFA_PROPRIETARY_CFG={05:FF:FF:06:81:80:70:FF:FF}
+
+###############################################################################
+# Bail out mode
+#  If set to 1, NFCC is using bail out mode for either Type A or Type B poll.
+NFA_POLL_BAIL_OUT_MODE=0x01
+###############################################################################
+# Enable/Disable Block Route feature.
+# Block Route will restrict routing to first matched rule
+# Block Route enable   0x01
+# Block Route disable  0x00
+NFA_BLOCK_ROUTE=0x00
diff --git a/halimpl/pn54x/libnfc-nxp-PN553_example_NCI2_0.conf b/halimpl/pn54x/libnfc-nxp-PN553_example_NCI2_0.conf
new file mode 100644
index 0000000..3dca16e
--- /dev/null
+++ b/halimpl/pn54x/libnfc-nxp-PN553_example_NCI2_0.conf
@@ -0,0 +1,449 @@
+## This file is used by NFC NXP NCI HAL(external/libnfc-nci/halimpl/pn547)
+## and NFC Service Java Native Interface Extensions (packages/apps/Nfc/nci/jni/extns/pn547)
+###############################################################################
+# Application options
+# Logging Levels
+# NXPLOG_DEFAULT_LOGLEVEL    0x01
+# ANDROID_LOG_DEBUG          0x03
+# ANDROID_LOG_WARN           0x02
+# ANDROID_LOG_ERROR          0x01
+# ANDROID_LOG_SILENT         0x00
+NXPLOG_EXTNS_LOGLEVEL=0x03
+NXPLOG_NCIHAL_LOGLEVEL=0x03
+NXPLOG_NCIX_LOGLEVEL=0x03
+NXPLOG_NCIR_LOGLEVEL=0x03
+NXPLOG_FWDNLD_LOGLEVEL=0x03
+NXPLOG_TML_LOGLEVEL=0x03
+
+###############################################################################
+# Nfc Device Node name
+NXP_NFC_DEV_NODE="/dev/pn553"
+
+###############################################################################
+# Extension for Mifare reader enable
+MIFARE_READER_ENABLE=0x01
+
+###############################################################################
+# Vzw Feature enable
+VZW_FEATURE_ENABLE=0x01
+
+###############################################################################
+# File name for Firmware
+NXP_FW_NAME="libpn553_fw.so"
+
+###############################################################################
+# System clock source selection configuration
+#define CLK_SRC_XTAL       1
+#define CLK_SRC_PLL        2
+NXP_SYS_CLK_SRC_SEL=0x02
+
+###############################################################################
+# System clock frequency selection configuration
+#define CLK_FREQ_13MHZ         1
+#define CLK_FREQ_19_2MHZ       2
+#define CLK_FREQ_24MHZ         3
+#define CLK_FREQ_26MHZ         4
+#define CLK_FREQ_38_4MHZ       5
+#define CLK_FREQ_52MHZ         6
+NXP_SYS_CLK_FREQ_SEL=0x02
+
+###############################################################################
+# The timeout value to be used for clock request acknowledgment
+# min value = 0x01 to max = 0x06
+NXP_SYS_CLOCK_TO_CFG=0x01
+
+###############################################################################
+# NXP proprietary settings
+NXP_ACT_PROP_EXTN={2F, 02, 00}
+
+###############################################################################
+# NFC forum profile settings
+NXP_NFC_PROFILE_EXTN={20, 02, 05, 01, A0, 44, 01, 00}
+
+###############################################################################
+# NFCC Configuration Control
+# Allow NFCC to manage RF Config       0x01
+# Don't allow NFCC to manage RF Config 0x00
+NXP_NFC_MERGE_RF_PARAMS={20, 02, 04, 01, 85, 01, 01}
+
+###############################################################################
+# Standby enable settings
+#NXP_CORE_STANDBY={2F, 00, 01, 01}
+
+###############################################################################
+# NXP TVDD configurations settings
+# Allow NFCC to configure External TVDD, two configurations (1 and 2) supported,
+# out of them only one can be configured at a time.
+NXP_EXT_TVDD_CFG=0x02
+
+###############################################################################
+#config1:SLALM, 3.3V for both RM and CM
+NXP_EXT_TVDD_CFG_1={20, 02, 0F, 01, A0, 0E, 0B, 31, 01, 01, 31, 00, 00, 00, 01, 00, D0, 0C}
+
+###############################################################################
+#config2: use DCDC in CE, use Tx_Pwr_Req, set CFG2 mode, SLALM,
+#monitoring 5V from DCDC, 3.3V for both RM and CM, DCDCWaitTime=4.2ms
+NXP_EXT_TVDD_CFG_2={20, 02, 0F, 01, A0, 0E, 0B, 11, 01, C2, B2, 00, B2, 1E, 1F, 00, D0, 0C}
+
+###############################################################################
+# NXP RF configuration ALM/PLM settings
+# This section needs to be updated with the correct values based on the platform
+#NXP_RF_CONF_BLK_1={
+#}
+
+###############################################################################
+# NXP RF configuration ALM/PLM settings
+# This section needs to be updated with the correct values based on the platform
+#NXP_RF_CONF_BLK_2={
+#}
+
+###############################################################################
+# NXP RF configuration ALM/PLM settings
+# This section needs to be updated with the correct values based on the platform
+#NXP_RF_CONF_BLK_3={
+#}
+
+###############################################################################
+# NXP RF configuration ALM/PLM settings
+# This section needs to be updated with the correct values based on the platform
+#NXP_RF_CONF_BLK_4={
+#}
+
+###############################################################################
+# NXP RF configuration ALM/PLM settings
+# This section needs to be updated with the correct values based on the platform
+#NXP_RF_CONF_BLK_5={
+#}
+
+###############################################################################
+# NXP RF configuration ALM/PLM settings
+# This section needs to be updated with the correct values based on the platform
+#NXP_RF_CONF_BLK_6={
+#}
+
+###############################################################################
+# Set configuration optimization decision setting
+# Enable    = 0x01
+# Disable   = 0x00
+NXP_SET_CONFIG_ALWAYS=0x00
+
+###############################################################################
+# Core configuration extensions
+# It includes
+# Wired mode settings A0ED, A0EE
+# Tag Detector A040, A041, A043
+# Low Power mode A007
+# Clock settings A002, A003
+# PbF settings A008
+# Clock timeout settings A004
+# eSE (SVDD) PWR REQ settings A0F2
+# How eSE connected to PN553 A012
+# UICC2 bit rate A0D1
+# SWP1A interface A0D4
+# DWP intf behavior config, SVDD Load activated by default if set to 0x31 - A037
+NXP_CORE_CONF_EXTN={20, 02, 25, 09,
+    A0, EC, 01, 01,
+    A0, ED, 01, 00,
+    A0, 5E, 01, 01,
+    A0, 12, 01, 02,
+    A0, 40, 01, 01,
+    A0, DD, 01, 2D,
+    A0, D1, 01, 02,
+    A0, D4, 01, 01,
+    A0, 37, 01, 35
+   }
+#       A0, F2, 01, 01,
+#       A0, 40, 01, 01,
+#       A0, 41, 01, 02,
+#       A0, 43, 01, 04,
+#       A0, 02, 01, 01,
+#       A0, 03, 01, 11,
+#       A0, 07, 01, 03,
+#       A0, 08, 01, 01
+#       }
+
+###############################################################################
+# Core configuration rf field filter settings to enable set to 01 to disable set
+# to 00 last bit
+NXP_CORE_RF_FIELD={ 20, 02, 05, 01, A0, 62, 01, 00 }
+
+###############################################################################
+# To enable i2c fragmentation set i2c fragmentation enable 0x01 to disable set
+# to 0x00
+NXP_I2C_FRAGMENTATION_ENABLED=0x00
+
+###############################################################################
+# Core configuration settings
+NXP_CORE_CONF={ 20, 02, 34, 10,
+        85, 01, 01,
+        28, 01, 00,
+        21, 01, 00,
+        30, 01, 08,
+        31, 01, 03,
+        32, 01, 60,
+        38, 01, 01,
+        33, 04, 01, 02, 03, 04,
+        54, 01, 06,
+        50, 01, 02,
+        5B, 01, 00,
+        80, 01, 01,
+        81, 01, 01,
+        82, 01, 0E,
+        18, 01, 01,
+        68, 01, 00
+        }
+
+###############################################################################
+# Mifare Classic Key settings
+#NXP_CORE_MFCKEY_SETTING={20, 02, 25,04, A0, 51, 06, A0, A1, A2, A3, A4, A5,
+#                                     A0, 52, 06, D3, F7, D3, F7, D3, F7,
+#                                     A0, 53, 06, FF, FF, FF, FF, FF, FF,
+#                                     A0, 54, 06, 00, 00, 00, 00, 00, 00}
+
+
+###############################################################################
+# Default SE Options
+# No secure element 0x00
+# eSE               0x01
+# UICC              0x02
+# UICC2             0x04
+
+NXP_DEFAULT_SE=0x07
+
+###############################################################################
+#Enable SWP full power mode when phone is power off
+NXP_SWP_FULL_PWR_ON=0x00
+
+###############################################################################
+#### Select the CHIP ####
+#PN547C2            0x01
+#PN65T              0x02
+#PN548AD            0x03
+#PN66T              0x04
+#PN551              0x05
+#PN67T              0x06
+#PN553              0x07
+#PN80T              0x08
+NXP_NFC_CHIP=0x07
+
+###############################################################################
+# CE when Screen state is locked
+# This setting is for DEFAULT_AID_ROUTE,
+# DEFAULT_DESFIRE_ROUTE and DEFAULT_MIFARE_CLT_ROUTE
+# Disable           0x00
+# Enable            0x01
+NXP_CE_ROUTE_STRICT_DISABLE=0x01
+
+###############################################################################
+#Timeout in secs to get NFCEE Discover notification
+NXP_DEFAULT_NFCEE_DISC_TIMEOUT=20
+
+###############################################################################
+NXP_DEFAULT_NFCEE_TIMEOUT=20
+
+###############################################################################
+#Timeout in secs
+NXP_SWP_RD_START_TIMEOUT=0x0A
+
+###############################################################################
+#Timeout in secs
+NXP_SWP_RD_TAG_OP_TIMEOUT=0x01
+
+###############################################################################
+#Set the default AID route Location :
+#This settings will be used when application does not set this parameter
+# host  0x00
+# eSE   0x01
+# UICC  0x02
+# UICC2 0x03
+DEFAULT_AID_ROUTE=0x00
+
+###############################################################################
+#Set the Mifare Desfire route Location :
+#This settings will be used when application does not set this parameter
+# host  0x00
+# eSE   0x01
+# UICC  0x02
+# UICC2 0x03
+DEFAULT_DESFIRE_ROUTE=0x02
+
+###############################################################################
+#Set the Mifare CLT route Location :
+#This settings will be used when application does not set this parameter
+# host  0x00
+# eSE   0x01
+# UICC  0x02
+# UICC2 0x03
+DEFAULT_MIFARE_CLT_ROUTE=0x02
+
+###############################################################################
+#Set the default AID Power state :
+#This settings will be used when application does not set this parameter
+# bit pos 0 = Switch On
+# bit pos 1 = Switch Off
+# bit pos 2 = Battery Off
+# bit pos 3 = Screen Lock
+# bit pos 4 = Screen Off
+DEFAULT_AID_PWR_STATE=0x19
+
+###############################################################################
+#Set the Mifare Desfire Power state :
+#This settings will be used when application does not set this parameter
+# bit pos 0 = Switch On
+# bit pos 1 = Switch Off
+# bit pos 2 = Battery Off
+# bit pos 3 = Screen Lock
+# bit pos 4 = Screen Off
+DEFAULT_DESFIRE_PWR_STATE=0x1B
+
+###############################################################################
+#Set the Mifare CLT Power state :
+#This settings will be used when application does not set this parameter
+# bit pos 0 = Switch On
+# bit pos 1 = Switch Off
+# bit pos 2 = Battery Off
+# bit pos 3 = Screen Lock
+# bit pos 4 = Screen Off
+DEFAULT_MIFARE_CLT_PWR_STATE=0x1B
+
+###############################################################################
+#Set the Felica CLT route Location :
+#This settings will be used when application does not set this parameter
+# eSE  0x01
+# UICC 0x02
+# UICC2 0x03
+DEFAULT_FELICA_CLT_ROUTE=0x01
+
+###############################################################################
+#Set the Felica CLT Power state :
+#This settings will be used when application does not set this parameter
+# bit pos 0 = Switch On
+# bit pos 1 = Switch Off
+# bit pos 2 = Battery Off
+# bit pos 3 = Screen Lock
+# bit pos 4 = Screen Off
+DEFAULT_FELICA_CLT_PWR_STATE=0x1B
+
+###############################################################################
+# AID Matching platform options
+# AID_MATCHING_L 0x01
+# AID_MATCHING_K 0x02
+AID_MATCHING_PLATFORM=0x01
+
+###############################################################################
+# P61 interface options
+# NFC 0x01
+# SPI 0x02
+NXP_P61_LS_DEFAULT_INTERFACE=0x01
+
+###############################################################################
+# P61 LTSM interface options
+# NFC 0x01
+# SPI 0x02
+NXP_P61_LTSM_DEFAULT_INTERFACE=0x01
+
+###############################################################################
+#CHINA_TIANJIN_RF_SETTING
+#Enable  0x01
+#Disable  0x00
+NXP_CHINA_TIANJIN_RF_ENABLED=0x01
+
+###############################################################################
+#SWP_SWITCH_TIMEOUT_SETTING
+# Allowed range of swp timeout setting is 0x00 to 0x3C [0 - 60].
+# Timeout in milliseconds, for example
+# No Timeout  0x00
+# 10 millisecond timeout 0x0A
+NXP_SWP_SWITCH_TIMEOUT=0x0A
+
+###############################################################################
+# P61 interface options for JCOP Download
+# NFC 0x01
+# SPI 0x02
+NXP_P61_JCOP_DEFAULT_INTERFACE=0x01
+
+###############################################################################
+# P61 JCOP OS download  options
+# FRAMEWORK API BY APPLICATION 0x00
+# AT BOOT_TIME 0x01
+NXP_JCOPDL_AT_BOOT_ENABLE=0x00
+
+###############################################################################
+# Loader service version
+# NFC service checks for LS version 2.0 or 2.1
+# LS2.0 0x20
+# LS2.1 0x21
+# LS2.2 0x22
+# AT NFC service intialization
+NXP_LOADER_SERVICE_VERSION=0x22
+
+###############################################################################
+#Timeout value  in milliseconds for NFCC standby mode.The range is between 5000
+#msec to 20000 msec and zero is to disable.
+NXP_NFCC_STANDBY_TIMEOUT=20000
+
+###############################################################################
+#Dynamic RSSI feature enable
+# Disable           0x00
+# Enable            0x01
+NXP_AGC_DEBUG_ENABLE=0x00
+
+###############################################################################
+#Virtual Mode ESE and Wired Mode ongoing delay Wired Mode
+# For Technology routing to ESE Technology Mask = 4
+# For ISO-DEP Protocol routing to ESE Mask      = 2
+# It can also take TECH|PROTO    = 6
+# To ignore the delay set mask to = 0
+NXP_ESE_WIRED_PRT_MASK=0x00
+
+###############################################################################
+#Virtual Mode UICC and Wired Mode  ongoing delay Wired Mode
+#For Technology routing to UICC Technology Mask = 4
+#For ISO-DEP Protocol routing to UICC set Mask  = 2
+#For Select AID Routing to UICC       set Mask  = 1
+#It can also take values TECH|PROTO|SELECT_AID  = 7 , 6 , 5 ,3 .To ignore delay
+#set mask = 0
+NXP_UICC_WIRED_PRT_MASK=0x00
+
+###############################################################################
+#RF field true delay Wired Mode
+# delay wired mode = 1
+# allow wired mode = 0
+NXP_WIRED_MODE_RF_FIELD_ENABLE=0x00
+
+###############################################################################
+#Config to allow adding aids
+#NFC on/off is required after this config
+#1 = enabling adding aid  to NFCC routing table.
+#0 = disabling adding aid to NFCC routing table.
+NXP_ENABLE_ADD_AID=0x01
+
+###############################################################################
+# JCOP-3.3 continuous process timeout in msec and value should be in Hexadecimal
+# JCOP CP TIMEOUT
+NXP_CP_TIMEOUT={00, 77}
+
+###############################################################################
+# Enable/Disable checking default proto SE Id
+# Disable           0x00
+# Enable            0x01
+NXP_CHECK_DEFAULT_PROTO_SE_ID=0x01
+
+###############################################################################
+#NXP_CN_TRANSIT_BLK_NUM_CHECK_ENABLE
+#Enable/Disable block number checks for china transit use case
+#Enable  0x01
+#Disable  0x00
+NXP_CN_TRANSIT_BLK_NUM_CHECK_ENABLE=0x01
+
+###############################################################################
+# Restrict routing to first matched rule only.
+# Blacklist enable   0x01
+# Blacklist disable  0x00
+NXP_PROP_BLACKLIST_ROUTING=0x00
+
+###############################################################################
+# Timeout value in milliseconds to send response for Felica command received
+NXP_HCEF_CMD_RSP_TIMEOUT_VALUE=5000
+
+###############################################################################
\ No newline at end of file
diff --git a/halimpl/pn54x/libnfc-nxp-PN80T_example_NCI2_0.conf b/halimpl/pn54x/libnfc-nxp-PN80T_example_NCI2_0.conf
new file mode 100644
index 0000000..1f64ec7
--- /dev/null
+++ b/halimpl/pn54x/libnfc-nxp-PN80T_example_NCI2_0.conf
@@ -0,0 +1,488 @@
+## This file is used by NFC NXP NCI HAL(external/libnfc-nci/halimpl/pn547)
+## and NFC Service Java Native Interface Extensions (packages/apps/Nfc/nci/jni/extns/pn547)
+###############################################################################
+# Application options
+# Logging Levels
+# NXPLOG_DEFAULT_LOGLEVEL    0x01
+# ANDROID_LOG_DEBUG          0x03
+# ANDROID_LOG_WARN           0x02
+# ANDROID_LOG_ERROR          0x01
+# ANDROID_LOG_SILENT         0x00
+NXPLOG_EXTNS_LOGLEVEL=0x03
+NXPLOG_NCIHAL_LOGLEVEL=0x03
+NXPLOG_NCIX_LOGLEVEL=0x03
+NXPLOG_NCIR_LOGLEVEL=0x03
+NXPLOG_FWDNLD_LOGLEVEL=0x03
+NXPLOG_TML_LOGLEVEL=0x03
+
+###############################################################################
+# Nfc Device Node name
+NXP_NFC_DEV_NODE="/dev/pn553"
+
+###############################################################################
+# Extension for Mifare reader enable
+MIFARE_READER_ENABLE=0x01
+
+###############################################################################
+# Vzw Feature enable
+VZW_FEATURE_ENABLE=0x01
+
+###############################################################################
+# File name for Firmware
+NXP_FW_NAME="libpn553_fw.so"
+
+###############################################################################
+# System clock source selection configuration
+#define CLK_SRC_XTAL       1
+#define CLK_SRC_PLL        2
+NXP_SYS_CLK_SRC_SEL=0x02
+
+###############################################################################
+# System clock frequency selection configuration
+#define CLK_FREQ_13MHZ         1
+#define CLK_FREQ_19_2MHZ       2
+#define CLK_FREQ_24MHZ         3
+#define CLK_FREQ_26MHZ         4
+#define CLK_FREQ_38_4MHZ       5
+#define CLK_FREQ_52MHZ         6
+NXP_SYS_CLK_FREQ_SEL=0x02
+
+###############################################################################
+# The timeout value to be used for clock request acknowledgment
+# min value = 0x01 to max = 0x06
+NXP_SYS_CLOCK_TO_CFG=0x06
+
+###############################################################################
+# NXP proprietary settings
+NXP_ACT_PROP_EXTN={2F, 02, 00}
+
+###############################################################################
+# NFC forum profile settings
+NXP_NFC_PROFILE_EXTN={20, 02, 05, 01, A0, 44, 01, 00}
+
+###############################################################################
+# NFCC Configuration Control
+# Allow NFCC to manage RF Config       0x01
+# Don't allow NFCC to manage RF Config 0x00
+NXP_NFC_MERGE_RF_PARAMS={20, 02, 04, 01, 85, 01, 01}
+
+###############################################################################
+# Standby enable settings
+#NXP_CORE_STANDBY={2F, 00, 01, 01}
+
+###############################################################################
+# NXP TVDD configurations settings
+# Allow NFCC to configure External TVDD, two configurations (1 and 2) supported,
+# out of them only one can be configured at a time.
+NXP_EXT_TVDD_CFG=0x02
+
+###############################################################################
+#config1:SLALM, 3.3V for both RM and CM
+NXP_EXT_TVDD_CFG_1={20, 02, 0F, 01, A0, 0E, 0B, 31, 01, 01, 31, 00, 00, 00, 01, 00, D0, 0C}
+
+###############################################################################
+#config2: use DCDC in CE, use Tx_Pwr_Req, set CFG2 mode, SLALM,
+#monitoring 5V from DCDC, 3.3V for both RM and CM, DCDCWaitTime=4.2ms
+NXP_EXT_TVDD_CFG_2={20, 02, 0F, 01, A0, 0E, 0B, 11, 01, C2, B2, 00, B2, 1E, 1F, 00, D0, 0C}
+
+###############################################################################
+# NXP RF configuration ALM/PLM settings
+# This section needs to be updated with the correct values based on the platform
+#NXP_RF_CONF_BLK_1={
+#}
+
+###############################################################################
+# NXP RF configuration ALM/PLM settings
+# This section needs to be updated with the correct values based on the platform
+#NXP_RF_CONF_BLK_2={
+#}
+
+###############################################################################
+# NXP RF configuration ALM/PLM settings
+# This section needs to be updated with the correct values based on the platform
+#NXP_RF_CONF_BLK_3={
+#}
+
+###############################################################################
+# NXP RF configuration ALM/PLM settings
+# This section needs to be updated with the correct values based on the platform
+#NXP_RF_CONF_BLK_4={
+#}
+
+###############################################################################
+# NXP RF configuration ALM/PLM settings
+# This section needs to be updated with the correct values based on the platform
+#NXP_RF_CONF_BLK_5={
+#}
+
+###############################################################################
+# NXP RF configuration ALM/PLM settings
+# This section needs to be updated with the correct values based on the platform
+#NXP_RF_CONF_BLK_6={
+#}
+
+###############################################################################
+# Set configuration optimization decision setting
+# Enable    = 0x01
+# Disable   = 0x00
+NXP_SET_CONFIG_ALWAYS=0x00
+
+###############################################################################
+# Core configuration extensions
+# It includes
+# Wired mode settings A0ED, A0EE
+# Tag Detector A040, A041, A043
+# Low Power mode A007
+# Clock settings A002, A003
+# PbF settings A008
+# Clock timeout settings A004
+# eSE (SVDD) PWR REQ settings A0F2
+# Window size A0D8
+# DWP Speed   A0D5
+# How eSE connected to PN553 A012
+# UICC2 bit rate A0D1
+# SWP1A interface A0D4
+# DWP intf behavior config, SVDD Load activated by default if set to 0x31 A037
+NXP_CORE_CONF_EXTN={20, 02, 29, 0A,
+    A0, EC, 01, 01,
+    A0, ED, 01, 01,
+    A0, 5E, 01, 01,
+    A0, 12, 01, 02,
+    A0, 40, 01, 01,
+    A0, D1, 01, 02,
+    A0, D4, 01, 01,
+    A0, 37, 01, 35,
+    A0, D8, 01, 02,
+    A0, D5, 01, 0A
+   }
+#       A0, F2, 01, 01,
+#       A0, 40, 01, 01,
+#       A0, 41, 01, 02,
+#       A0, 43, 01, 04,
+#       A0, 02, 01, 01,
+#       A0, 03, 01, 11,
+#       A0, 07, 01, 03,
+#       A0, 08, 01, 01
+#       }
+
+###############################################################################
+# Core configuration rf field filter settings to enable set to 01 to disable set
+# to 00 last bit
+NXP_CORE_RF_FIELD={ 20, 02, 05, 01, A0, 62, 01, 00 }
+
+###############################################################################
+# To enable i2c fragmentation set i2c fragmentation enable 0x01 to disable set
+# to 0x00
+NXP_I2C_FRAGMENTATION_ENABLED=0x00
+
+###############################################################################
+# Core configuration settings
+NXP_CORE_CONF={ 20, 02, 31, 0F,
+        85, 01, 01,
+        28, 01, 00,
+        21, 01, 00,
+        30, 01, 08,
+        31, 01, 03,
+        32, 01, 60,
+        38, 01, 01,
+        33, 04, 01, 02, 03, 04,
+        54, 01, 06,
+        50, 01, 02,
+        5B, 01, 00,
+        80, 01, 01,
+        81, 01, 01,
+        82, 01, 0E,
+        18, 01, 01
+        }
+
+###############################################################################
+# Mifare Classic Key settings
+#NXP_CORE_MFCKEY_SETTING={20, 02, 25,04, A0, 51, 06, A0, A1, A2, A3, A4, A5,
+#                                     A0, 52, 06, D3, F7, D3, F7, D3, F7,
+#                                     A0, 53, 06, FF, FF, FF, FF, FF, FF,
+#                                     A0, 54, 06, 00, 00, 00, 00, 00, 00}
+
+###############################################################################
+# Default SE Options
+# No secure element 0x00
+# eSE               0x01
+# UICC              0x02
+# UICC2             0x04
+NXP_DEFAULT_SE=0x07
+
+###############################################################################
+#Enable SWP full power mode when phone is power off
+NXP_SWP_FULL_PWR_ON=0x00
+
+###############################################################################
+#### Select the CHIP ####
+#PN547C2            0x01
+#PN65T              0x02
+#PN548AD            0x03
+#PN66T              0x04
+#PN551              0x05
+#PN67T              0x06
+#PN553              0x07
+#PN80T              0x08
+NXP_NFC_CHIP=0x08
+
+###############################################################################
+# CE when Screen state is locked
+# This setting is for DEFAULT_AID_ROUTE,
+# DEFAULT_DESFIRE_ROUTE and DEFAULT_MIFARE_CLT_ROUTE
+# Disable           0x00
+# Enable            0x01
+NXP_CE_ROUTE_STRICT_DISABLE=0x01
+
+###############################################################################
+#Timeout in secs to get NFCEE Discover notification
+NXP_DEFAULT_NFCEE_DISC_TIMEOUT=20
+
+###############################################################################
+NXP_DEFAULT_NFCEE_TIMEOUT=20
+
+###############################################################################
+#Timeout in secs
+NXP_SWP_RD_START_TIMEOUT=0x0A
+
+###############################################################################
+#Timeout in secs
+NXP_SWP_RD_TAG_OP_TIMEOUT=0x01
+
+###############################################################################
+#Set the default AID route Location :
+#This settings will be used when application does not set this parameter
+# host  0x00
+# eSE   0x01
+# UICC  0x02
+# UICC2 0x03
+DEFAULT_AID_ROUTE=0x00
+
+###############################################################################
+#Set the Mifare Desfire route Location :
+#This settings will be used when application does not set this parameter
+# host  0x00
+# eSE   0x01
+# UICC  0x02
+# UICC2 0x03
+DEFAULT_DESFIRE_ROUTE=0x02
+
+###############################################################################
+#Set the Mifare CLT route Location :
+#This settings will be used when application does not set this parameter
+# host  0x00
+# eSE   0x01
+# UICC  0x02
+# UICC2 0x03
+DEFAULT_MIFARE_CLT_ROUTE=0x02
+
+###############################################################################
+#Set the Felica CLT route Location :
+#This settings will be used when application does not set this parameter
+# eSE   0x01
+# UICC  0x02
+# UICC2 0x03
+DEFAULT_FELICA_CLT_ROUTE=0x01
+
+###############################################################################
+#Set the default AID Power state :
+#This settings will be used when application does not set this parameter
+# bit pos 0 = Switch On
+# bit pos 1 = Switch Off
+# bit pos 2 = Battery Off
+# bit pos 3 = Screen Lock
+# bit pos 4 = Screen Off
+DEFAULT_AID_PWR_STATE=0x19
+
+###############################################################################
+#Set the Mifare Desfire Power state :
+#This settings will be used when application does not set this parameter
+# bit pos 0 = Switch On
+# bit pos 1 = Switch Off
+# bit pos 2 = Battery Off
+# bit pos 3 = Screen Lock
+# bit pos 4 = Screen Off
+DEFAULT_DESFIRE_PWR_STATE=0x1B
+
+###############################################################################
+#Set the Mifare CLT Power state :
+#This settings will be used when application does not set this parameter
+# bit pos 0 = Switch On
+# bit pos 1 = Switch Off
+# bit pos 2 = Battery Off
+# bit pos 3 = Screen Lock
+# bit pos 4 = Screen Off
+DEFAULT_MIFARE_CLT_PWR_STATE=0x1B
+
+###############################################################################
+#Set the Felica CLT Power state :
+#This settings will be used when application does not set this parameter
+# bit pos 0 = Switch On
+# bit pos 1 = Switch Off
+# bit pos 2 = Battery Off
+# bit pos 3 = Screen Lock
+# bit pos 4 = Screen Off
+DEFAULT_FELICA_CLT_PWR_STATE=0x1B
+
+###############################################################################
+# AID Matching platform options
+# AID_MATCHING_L 0x01
+# AID_MATCHING_K 0x02
+AID_MATCHING_PLATFORM=0x01
+
+###############################################################################
+# P61 interface options
+# NFC 0x01
+# SPI 0x02
+NXP_P61_LS_DEFAULT_INTERFACE=0x01
+
+###############################################################################
+# P61 LTSM interface options
+# NFC 0x01
+# SPI 0x02
+NXP_P61_LTSM_DEFAULT_INTERFACE=0x01
+
+###############################################################################
+#CHINA_TIANJIN_RF_SETTING
+#Enable  0x01
+#Disable  0x00
+NXP_CHINA_TIANJIN_RF_ENABLED=0x01
+
+###############################################################################
+#SWP_SWITCH_TIMEOUT_SETTING
+# Allowed range of swp timeout setting is 0x00 to 0x3C [0 - 60].
+# Timeout in milliseconds, for example
+# No Timeout  0x00
+# 10 millisecond timeout 0x0A
+NXP_SWP_SWITCH_TIMEOUT=0x0A
+
+###############################################################################
+# P61 interface options for JCOP Download
+# NFC 0x01
+# SPI 0x02
+NXP_P61_JCOP_DEFAULT_INTERFACE=0x01
+
+###############################################################################
+# P61 JCOP OS download  options
+# FRAMEWORK API BY APPLICATION 0x00
+# AT BOOT_TIME 0x01
+NXP_JCOPDL_AT_BOOT_ENABLE=0x00
+
+###############################################################################
+# Loader service version
+# NFC service checks for LS version 2.0 or 2.1
+# LS2.0 0x20
+# LS2.1 0x21
+# LS2.2 0x22
+# AT NFC service intialization
+NXP_LOADER_SERVICE_VERSION=0x22
+
+###############################################################################
+#Timeout value  in milliseconds for NFCC standby mode.The range is between 5000
+#msec to 20000 msec and zero is to disable.
+NXP_NFCC_STANDBY_TIMEOUT=20000
+
+###############################################################################
+#Dynamic RSSI feature enable
+# Disable           0x00
+# Enable            0x01
+NXP_AGC_DEBUG_ENABLE=0x00
+
+###############################################################################
+#Virtual Mode ESE and Wired Mode ongoing delay Wired Mode
+# For Technology routing to ESE Technology Mask = 4
+# For ISO-DEP Protocol routing to ESE Mask      = 2
+# It can also take TECH|PROTO    = 6
+# To ignore the delay set mask to = 0
+NXP_ESE_WIRED_PRT_MASK=0x00
+
+###############################################################################
+#Virtual Mode UICC and Wired Mode  ongoing delay Wired Mode
+#For Technology routing to UICC Technology Mask = 4
+#For ISO-DEP Protocol routing to UICC set Mask  = 2
+#For Select AID Routing to UICC       set Mask  = 1
+#It can also take values TECH|PROTO|SELECT_AID  = 7 , 6 , 5 ,3 .To ignore delay
+#set mask = 0
+NXP_UICC_WIRED_PRT_MASK=0x00
+
+################################################################################
+#RF field true delay Wired Mode
+# delay wired mode = 1
+# allow wired mode = 0
+NXP_WIRED_MODE_RF_FIELD_ENABLE=0x00
+
+###############################################################################
+#Config to allow adding aids
+#NFC on/off is required after this config
+#1 = enabling adding aid  to NFCC routing table.
+#0 = disabling adding aid to NFCC routing table.
+NXP_ENABLE_ADD_AID=0x01
+
+###############################################################################
+# JCOP-3.3 continuous process timeout in msec and value should be in Hexadecimal
+# JCOP CP TIMEOUT
+NXP_CP_TIMEOUT={00, 77}
+
+###############################################################################
+# Enable/Disable checking default proto SE Id
+# Disable           0x00
+# Enable            0x01
+NXP_CHECK_DEFAULT_PROTO_SE_ID=0x01
+
+###############################################################################
+#NXP_CN_TRANSIT_BLK_NUM_CHECK_ENABLE
+#Enable/Disable block number checks for china transit use case
+#Enable  0x01
+#Disable  0x00
+NXP_CN_TRANSIT_BLK_NUM_CHECK_ENABLE=0x01
+
+###############################################################################
+# Wired mode resume timeout vaule in wired mode resume feature enable
+# DWP resume time out in ms( 4 bytes hex value and LSB first)
+#example 1000 = 0x03E8
+#exmaple 2000 = 0x07D0
+#example 500 = 0x01F4
+NXP_WIREDMODE_RESUME_TIMEOUT={E8,03,00,00}
+###############################################################################
+# Power to eSE is controlled by DH or PMU depending on following configurations
+#define DH_PWR_CONTROL         1
+#define PMU_PWR_CONTROL        2
+NXP_ESE_POWER_DH_CONTROL=1
+
+###############################################################################
+# Timeout value in milliseconds for wired mode resume after RF field event timeout
+NXP_NFCC_RF_FIELD_EVENT_TIMEOUT=3000
+
+###############################################################################
+# NXP PMU Support configuration is sent if PMU_PWR_CONTROL is configured
+# External PMU available in phone ON and phone OFF case if NXP_ESE_POWER_EXT_PMU=1
+# External PMU available only in phone ON case if NXP_ESE_POWER_EXT_PMU=2
+NXP_ESE_POWER_EXT_PMU=2
+
+###############################################################################
+# Whether to allow wired mode in desfire and mifare CLT
+# Disable           0x00
+# Enable            0x01
+NXP_ALLOW_WIRED_IN_MIFARE_DESFIRE_CLT=0x00
+
+###############################################################################
+# Restrict routing to first matched rule only.
+# Blacklist enable   0x01
+# Blacklist disable  0x00
+NXP_PROP_BLACKLIST_ROUTING=0x00
+
+###############################################################################
+# Send DWP interface reset command as part of SE open
+# Disable           0x00
+# Enable            0x01
+NXP_DWP_INTF_RESET_ENABLE=0x01
+
+###############################################################################
+# Timeout value in milliseconds for JCOP OS download to complete
+OS_DOWNLOAD_TIMEOUT_VALUE=60000
+
+###############################################################################
+# Timeout value in milliseconds to send response for Felica command received
+NXP_HCEF_CMD_RSP_TIMEOUT_VALUE=5000
+
+###############################################################################
\ No newline at end of file
diff --git a/halimpl/pn54x/tml/phTmlNfc.c b/halimpl/pn54x/tml/phTmlNfc.c
index 995c9ba..8aad810 100644
--- a/halimpl/pn54x/tml/phTmlNfc.c
+++ b/halimpl/pn54x/tml/phTmlNfc.c
@@ -451,6 +451,8 @@
             if (retry_cnt++ < MAX_WRITE_RETRY_COUNT) {
               NXPLOG_NCIHAL_E("PN54X - Error in I2C Write  - Retry 0x%x",
                               retry_cnt);
+              // Add a 10 ms delay to ensure NFCC is not still in stand by mode.
+              usleep(10 * 1000);
               goto retry;
             }
           }
diff --git a/src/Android.bp b/src/Android.bp
index d1f1860..39d3007 100644
--- a/src/Android.bp
+++ b/src/Android.bp
@@ -10,7 +10,9 @@
         "liblog",
         "libdl",
         "libhardware",
+        "libmetricslogger",
         "libpower",
+        "libz",
 
         // Treble configuration
         "libhidlbase",
@@ -50,9 +52,11 @@
         "nfc/nci/*.c",
         "nfc/ndef/*.c",
         "nfc/nfc/*.c",
+        "nfc/nfc/*.cc",
         "nfc/tags/*.c",
         "adaptation/*.c",
         "adaptation/*.cpp",
+        "adaptation/*.cc",
         "gki/common/*.c",
         "gki/ulinux/*.c",
         "nfca_version.c",
diff --git a/src/adaptation/NfcAdaptation.cpp b/src/adaptation/NfcAdaptation.cpp
index 4194ff6..42bf55f 100644
--- a/src/adaptation/NfcAdaptation.cpp
+++ b/src/adaptation/NfcAdaptation.cpp
@@ -22,6 +22,9 @@
 #include <hwbinder/ProcessState.h>
 #include <pthread.h>
 #include "NfcAdaptation.h"
+#include "debug_nfcsnoop.h"
+#include "nfc_target.h"
+
 extern "C" {
 #include "gki.h"
 #include "nfa_api.h"
@@ -61,6 +64,7 @@
 
 uint32_t ScrProtocolTraceFlag = SCR_PROTO_TRACE_ALL;  // 0x017F00;
 uint8_t appl_trace_level = 0xff;
+uint8_t appl_dta_mode_flag = 0x00;
 char bcm_nfc_location[120];
 
 static uint8_t nfa_dm_cfg[sizeof(tNFA_DM_CFG)];
@@ -227,6 +231,7 @@
   mHalCallback = NULL;
   memset(&mHalEntryFuncs, 0, sizeof(mHalEntryFuncs));
   InitializeHalDeviceContext();
+  debug_nfcsnoop_init();
   ALOGD("%s: exit", func);
 }
 
@@ -257,6 +262,17 @@
 
 /*******************************************************************************
 **
+** Function:    NfcAdaptation::Dump
+**
+** Description: Native support for dumpsys function.
+**
+** Returns:     None.
+**
+*******************************************************************************/
+void NfcAdaptation::Dump(int fd) { debug_nfcsnoop_dump(fd); }
+
+/*******************************************************************************
+**
 ** Function:    NfcAdaptation::signal()
 **
 ** Description: signal the CondVar to release the thread that is waiting
diff --git a/src/adaptation/OverrideLog.cpp b/src/adaptation/OverrideLog.cpp
index a07aab6..81beafc 100644
--- a/src/adaptation/OverrideLog.cpp
+++ b/src/adaptation/OverrideLog.cpp
@@ -93,3 +93,8 @@
 
   return ScrProtocolTraceFlag;
 }
+
+void initializeGlobalAppDtaMode() {
+  appl_dta_mode_flag = 0x01;
+  ALOGD("%s: DTA Enabled", __func__);
+}
diff --git a/src/adaptation/debug_nfcsnoop.cc b/src/adaptation/debug_nfcsnoop.cc
new file mode 100644
index 0000000..b7229d6
--- /dev/null
+++ b/src/adaptation/debug_nfcsnoop.cc
@@ -0,0 +1,182 @@
+/******************************************************************************
+ *
+ *  Copyright (C) 2017 Google Inc.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at:
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ ******************************************************************************/
+
+#include <assert.h>
+#include <resolv.h>
+#include <zlib.h>
+#include <mutex>
+
+#include "bt_types.h"
+#include "include/debug_nfcsnoop.h"
+#include "include/ringbuffer.h"
+#include "nfc_int.h"
+#include "nfc_types.h"
+
+#define USEC_PER_SEC 1000000ULL
+
+// Total nfcsnoop memory log buffer size
+#ifndef NFCSNOOP_MEM_BUFFER_SIZE
+static const size_t NFCSNOOP_MEM_BUFFER_SIZE = (256 * 1024);
+#endif
+
+// Block size for copying buffers (for compression/encoding etc.)
+static const size_t BLOCK_SIZE = 16384;
+
+// Maximum line length in bugreport (should be multiple of 4 for base64 output)
+static const uint8_t MAX_LINE_LENGTH = 128;
+
+static std::mutex buffer_mutex;
+static ringbuffer_t* buffer = NULL;
+static uint64_t last_timestamp_ms = 0;
+
+static void nfcsnoop_cb(const uint8_t* data, const size_t length,
+                        bool is_received, const uint64_t timestamp_us) {
+  nfcsnooz_header_t header;
+
+  std::lock_guard<std::mutex> lock(buffer_mutex);
+
+  // Make room in the ring buffer
+
+  while (ringbuffer_available(buffer) < (length + sizeof(nfcsnooz_header_t))) {
+    ringbuffer_pop(buffer, (uint8_t*)&header, sizeof(nfcsnooz_header_t));
+    ringbuffer_delete(buffer, header.length - 1);
+  }
+
+  // Insert data
+  header.length = length;
+  header.is_received = is_received ? 1 : 0;
+  header.delta_time_ms =
+      last_timestamp_ms ? timestamp_us - last_timestamp_ms : 0;
+  last_timestamp_ms = timestamp_us;
+
+  ringbuffer_insert(buffer, (uint8_t*)&header, sizeof(nfcsnooz_header_t));
+  ringbuffer_insert(buffer, data, length);
+}
+
+static bool nfcsnoop_compress(ringbuffer_t* rb_dst, ringbuffer_t* rb_src) {
+  assert(rb_dst != NULL);
+  assert(rb_src != NULL);
+
+  z_stream zs;
+  zs.zalloc = Z_NULL;
+  zs.zfree = Z_NULL;
+  zs.opaque = Z_NULL;
+
+  if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) != Z_OK) return false;
+
+  bool rc = true;
+  uint8_t block_src[BLOCK_SIZE];
+  uint8_t block_dst[BLOCK_SIZE];
+
+  const size_t num_blocks =
+      (ringbuffer_size(rb_src) + BLOCK_SIZE - 1) / BLOCK_SIZE;
+  for (size_t i = 0; i < num_blocks; ++i) {
+    zs.avail_in =
+        ringbuffer_peek(rb_src, i * BLOCK_SIZE, block_src, BLOCK_SIZE);
+    zs.next_in = block_src;
+
+    do {
+      zs.avail_out = BLOCK_SIZE;
+      zs.next_out = block_dst;
+
+      int err = deflate(&zs, (i == num_blocks - 1) ? Z_FINISH : Z_NO_FLUSH);
+      if (err == Z_STREAM_ERROR) {
+        rc = false;
+        break;
+      }
+
+      const size_t length = BLOCK_SIZE - zs.avail_out;
+      ringbuffer_insert(rb_dst, block_dst, length);
+    } while (zs.avail_out == 0);
+  }
+
+  deflateEnd(&zs);
+  return rc;
+}
+
+void nfcsnoop_capture(const NFC_HDR* packet, bool is_received) {
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  uint64_t timestamp = static_cast<uint64_t>(tv.tv_sec) * USEC_PER_SEC +
+                       static_cast<uint64_t>(tv.tv_usec);
+  uint8_t* p = (uint8_t*)(packet + 1) + packet->offset;
+  uint8_t mt = (*(p)&NCI_MT_MASK) >> NCI_MT_SHIFT;
+
+  if (mt == NCI_MT_DATA) {
+    nfcsnoop_cb(p, NCI_DATA_HDR_SIZE, is_received, timestamp);
+  } else if (packet->len > 2) {
+    nfcsnoop_cb(p, p[2] + NCI_MSG_HDR_SIZE, is_received, timestamp);
+  }
+}
+
+void debug_nfcsnoop_init(void) {
+  if (buffer == NULL) buffer = ringbuffer_init(NFCSNOOP_MEM_BUFFER_SIZE);
+}
+
+void debug_nfcsnoop_dump(int fd) {
+  ringbuffer_t* ringbuffer = ringbuffer_init(NFCSNOOP_MEM_BUFFER_SIZE);
+  if (ringbuffer == NULL) {
+    dprintf(fd, "%s Unable to allocate memory for compression", __func__);
+    return;
+  }
+
+  // Prepend preamble
+
+  nfcsnooz_preamble_t preamble;
+  preamble.version = NFCSNOOZ_CURRENT_VERSION;
+  preamble.last_timestamp_ms = last_timestamp_ms;
+  ringbuffer_insert(ringbuffer, (uint8_t*)&preamble,
+                    sizeof(nfcsnooz_preamble_t));
+
+  // Compress data
+
+  uint8_t b64_in[3] = {0};
+  char b64_out[5] = {0};
+
+  size_t line_length = 0;
+
+  bool rc;
+  {
+    std::lock_guard<std::mutex> lock(buffer_mutex);
+    dprintf(fd, "--- BEGIN:NFCSNOOP_LOG_SUMMARY (%zu bytes in) ---\n",
+            ringbuffer_size(buffer));
+    rc = nfcsnoop_compress(ringbuffer, buffer);
+  }
+
+  if (rc == false) {
+    dprintf(fd, "%s Log compression failed", __func__);
+    goto error;
+  }
+
+  // Base64 encode & output
+
+  while (ringbuffer_size(ringbuffer) > 0) {
+    size_t read = ringbuffer_pop(ringbuffer, b64_in, 3);
+    if (line_length >= MAX_LINE_LENGTH) {
+      dprintf(fd, "\n");
+      line_length = 0;
+    }
+    line_length += b64_ntop(b64_in, read, b64_out, 5);
+    dprintf(fd, "%s", b64_out);
+  }
+
+  dprintf(fd, "\n--- END:NFCSNOOP_LOG_SUMMARY ---\n");
+
+error:
+  ringbuffer_free(ringbuffer);
+}
diff --git a/src/adaptation/ringbuffer.cc b/src/adaptation/ringbuffer.cc
new file mode 100644
index 0000000..d7798fd
--- /dev/null
+++ b/src/adaptation/ringbuffer.cc
@@ -0,0 +1,116 @@
+/******************************************************************************
+ *
+ *  Copyright (C) 2017 Google Inc.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at:
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ ******************************************************************************/
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include "ringbuffer.h"
+
+struct ringbuffer_t {
+  size_t total;
+  size_t available;
+  uint8_t* base;
+  uint8_t* head;
+  uint8_t* tail;
+};
+
+ringbuffer_t* ringbuffer_init(const size_t size) {
+  ringbuffer_t* p = static_cast<ringbuffer_t*>(calloc(1, sizeof(ringbuffer_t)));
+
+  if (p == NULL) return p;
+
+  p->base = static_cast<uint8_t*>(calloc(size, sizeof(uint8_t)));
+  p->head = p->tail = p->base;
+  p->total = p->available = size;
+
+  return p;
+}
+
+void ringbuffer_free(ringbuffer_t* rb) {
+  if (rb != NULL) free(rb->base);
+  free(rb);
+}
+
+size_t ringbuffer_available(const ringbuffer_t* rb) {
+  assert(rb);
+  return rb->available;
+}
+
+size_t ringbuffer_size(const ringbuffer_t* rb) {
+  assert(rb);
+  return rb->total - rb->available;
+}
+
+size_t ringbuffer_insert(ringbuffer_t* rb, const uint8_t* p, size_t length) {
+  assert(rb);
+  assert(p);
+
+  if (length > ringbuffer_available(rb)) length = ringbuffer_available(rb);
+
+  for (size_t i = 0; i != length; ++i) {
+    *rb->tail++ = *p++;
+    if (rb->tail >= (rb->base + rb->total)) rb->tail = rb->base;
+  }
+
+  rb->available -= length;
+  return length;
+}
+
+size_t ringbuffer_delete(ringbuffer_t* rb, size_t length) {
+  assert(rb);
+
+  if (length > ringbuffer_size(rb)) length = ringbuffer_size(rb);
+
+  rb->head += length;
+  if (rb->head >= (rb->base + rb->total)) rb->head -= rb->total;
+
+  rb->available += length;
+  return length;
+}
+
+size_t ringbuffer_peek(const ringbuffer_t* rb, off_t offset, uint8_t* p,
+                       size_t length) {
+  assert(rb);
+  assert(p);
+  assert(offset >= 0);
+  assert((size_t)offset <= ringbuffer_size(rb));
+
+  uint8_t* b = ((rb->head - rb->base + offset) % rb->total) + rb->base;
+  const size_t bytes_to_copy = (offset + length > ringbuffer_size(rb))
+                                   ? ringbuffer_size(rb) - offset
+                                   : length;
+
+  for (size_t copied = 0; copied < bytes_to_copy; ++copied) {
+    *p++ = *b++;
+    if (b >= (rb->base + rb->total)) b = rb->base;
+  }
+
+  return bytes_to_copy;
+}
+
+size_t ringbuffer_pop(ringbuffer_t* rb, uint8_t* p, size_t length) {
+  assert(rb);
+  assert(p);
+
+  const size_t copied = ringbuffer_peek(rb, 0, p, length);
+  rb->head += copied;
+  if (rb->head >= (rb->base + rb->total)) rb->head -= rb->total;
+
+  rb->available += copied;
+  return copied;
+}
diff --git a/src/gki/common/gki.h b/src/gki/common/gki.h
index 8f34774..465cd59 100644
--- a/src/gki/common/gki.h
+++ b/src/gki/common/gki.h
@@ -298,6 +298,10 @@
 
 #endif /* GKI_NUM_FIXED_BUF_POOLS < 16 */
 
+#ifndef GKI_SHUTDOWN_EVT
+#define GKI_SHUTDOWN_EVT APPL_EVT_7
+#endif
+
 /* Timer list entry callback type
 */
 typedef void(TIMER_CBACK)(void* p_tle);
diff --git a/src/gki/ulinux/gki_ulinux.c b/src/gki/ulinux/gki_ulinux.c
index da857cf..92f3898 100644
--- a/src/gki/ulinux/gki_ulinux.c
+++ b/src/gki/ulinux/gki_ulinux.c
@@ -70,12 +70,6 @@
 static pthread_t timer_thread_id = 0;
 #endif
 
-/* For Android */
-
-#ifndef GKI_SHUTDOWN_EVT
-#define GKI_SHUTDOWN_EVT APPL_EVT_7
-#endif
-
 typedef struct {
   uint8_t task_id;         /* GKI task id */
   TASKPTR task_entry;      /* Task entry function*/
@@ -109,7 +103,7 @@
   GKI_TRACE_ERROR_1("gki_task task_id=%i terminating", p_pthread_info->task_id);
   gki_cb.os.thread_id[p_pthread_info->task_id] = 0;
 
-  pthread_exit(0); /* GKI tasks have no return value */
+  return;
 }
 /* end android */
 
@@ -451,7 +445,7 @@
     GKI_timer_update(1);
   }
   GKI_TRACE_ERROR_1("%s exit", __func__);
-  pthread_exit(NULL);
+  return;
 }
 #endif
 
@@ -602,8 +596,7 @@
   if (rtask >= GKI_MAX_TASKS) {
     GKI_TRACE_ERROR_3("%s() Exiting thread; rtask %d >= %d", __func__, rtask,
                       GKI_MAX_TASKS);
-    pthread_exit(NULL);
-    return 0;
+    return EVENT_MASK(GKI_SHUTDOWN_EVT);
   }
 
   gki_pthread_info_t* p_pthread_info = &gki_pthread_info[rtask];
@@ -692,7 +685,6 @@
       GKI_TRACE_ERROR_1("GKI TASK_DEAD received. exit thread %d...", rtask);
 
       gki_cb.os.thread_id[rtask] = 0;
-      pthread_exit(NULL);
       return (EVENT_MASK(GKI_SHUTDOWN_EVT));
     }
   }
diff --git a/src/hal/include/nci_defs.h b/src/hal/include/nci_defs.h
index fea2f4e..1428e50 100644
--- a/src/hal/include/nci_defs.h
+++ b/src/hal/include/nci_defs.h
@@ -41,6 +41,7 @@
 #define NCI_MAX_CTRL_SIZE 0xFF /* max control message size */
 #define NCI_CTRL_INIT_SIZE 32  /* initial NFCC control payload size */
 #define NCI_MAX_VSC_SIZE 0xFF
+#define APPL_DTA_MODE FALSE
 /* NCI header (3) + callback function pointer(8; use 8 to be safe) + HCIT (1
  * byte) */
 #define NCI_VSC_MSG_HDR_SIZE 12
@@ -164,6 +165,11 @@
 
 /* Logical target ID 0x01-0xFE */
 
+/* CORE_RESET_NTF reset trigger type*/
+#define NCI2_0_RESET_TRIGGER_TYPE_ERROR 0x00
+#define NCI2_0_RESET_TRIGGER_TYPE_POWERED_ON 0x01
+#define NCI2_0_RESET_TRIGGER_TYPE_CORE_RESET_CMD_RECEIVED 0x02
+
 /* Status Codes */
 #define NCI_STATUS_OK 0x00
 #define NCI_STATUS_REJECTED 0x01
@@ -197,7 +203,7 @@
 #define NCI_RF_TECHNOLOGY_A 0x00
 #define NCI_RF_TECHNOLOGY_B 0x01
 #define NCI_RF_TECHNOLOGY_F 0x02
-#define NCI_RF_TECHNOLOGY_15693 0x03
+#define NCI_RF_TECHNOLOGY_V 0x03
 
 /* Bit Rates */
 #define NCI_BIT_RATE_106 0x00  /* 106 kbit/s */
@@ -220,6 +226,7 @@
 #define NCI_MSG_CORE_CONN_CREDITS 6
 #define NCI_MSG_CORE_GEN_ERR_STATUS 7
 #define NCI_MSG_CORE_INTF_ERR_STATUS 8
+#define NCI_MSG_CORE_SET_POWER_SUB_STATE 9
 
 /**********************************************
  * RF MANAGEMENT Group Opcode    - 1
@@ -236,6 +243,7 @@
 #define NCI_MSG_RF_EE_ACTION 9
 #define NCI_MSG_RF_EE_DISCOVERY_REQ 10
 #define NCI_MSG_RF_PARAMETER_UPDATE 11
+#define NCI_MSG_RF_ISO_DEP_NAK_PRESENCE 16
 
 /**********************************************
  * NFCEE MANAGEMENT Group Opcode - 2
@@ -254,12 +262,15 @@
 #define NCI_CORE_PARAM_SIZE_RESET_RSP 0x03
 #define NCI_CORE_PARAM_SIZE_RESET_NTF 0x02
 
-#define NCI_CORE_PARAM_SIZE_INIT 0x00 /* no payload */
+#define NCI_CORE_PARAM_SIZE_INIT(X) (((X) == NCI_VERSION_2_0) ? (0x02) : (0x00))
+#define NCI2_0_CORE_INIT_CMD_BYTE_0 0x00
+#define NCI2_0_CORE_INIT_CMD_BYTE_1 0x00
 #define NCI_CORE_PARAM_SIZE_INIT_RSP 0x11
 #define NCI_CORE_INIT_RSP_OFFSET_NUM_INTF 0x05
 
 /* Status (1 octet) and number of params */
 #define NCI_CORE_PARAM_SIZE_SET_CONFIG_RSP 0x02
+#define NCI_CORE_PARAM_SIZE_SET_POWER_SUB_STATE 0x01
 
 /* octet 0 */
 #define NCI_FEAT_DISCOVERY_FREG 0x00000001
@@ -358,6 +369,8 @@
 #define NCI_DEACTIVATE_REASON_ENDPOINT_REQ 1 /* Endpoint Request */
 #define NCI_DEACTIVATE_REASON_RF_LINK_LOSS 2 /* RF Link Loss     */
 #define NCI_DEACTIVATE_REASON_NFCB_BAD_AFI 3 /* NFC-B Bad AFI    */
+/* DH Request Failed due to error */
+#define NCI_DEACTIVATE_REASON_DH_REQ_FAILED 4
 
 /**********************************************
 * NCI Interface Mode
@@ -374,6 +387,7 @@
 #define NCI_INTERFACE_ISO_DEP 2
 #define NCI_INTERFACE_NFC_DEP 3
 #define NCI_INTERFACE_MAX NCI_INTERFACE_NFC_DEP
+#define NCI_INTERFACE_EXTENSION_MAX 2
 #define NCI_INTERFACE_FIRST_VS 0x80
 typedef uint8_t tNCI_INTF_TYPE;
 
@@ -397,6 +411,7 @@
 #define NCI_PROTOCOL_T1T 0x01
 #define NCI_PROTOCOL_T2T 0x02
 #define NCI_PROTOCOL_T3T 0x03
+#define NCI_PROTOCOL_T5T 0x06
 #define NCI_PROTOCOL_ISO_DEP 0x04
 #define NCI_PROTOCOL_NFC_DEP 0x05
 
@@ -404,14 +419,18 @@
 #define NCI_DISCOVERY_TYPE_POLL_A 0x00
 #define NCI_DISCOVERY_TYPE_POLL_B 0x01
 #define NCI_DISCOVERY_TYPE_POLL_F 0x02
+#define NCI_DISCOVERY_TYPE_POLL_V 0x06
 #define NCI_DISCOVERY_TYPE_POLL_A_ACTIVE 0x03
+/* NCI2.0 standardizes P2P poll active*/
+#define NCI_DISCOVERY_TYPE_POLL_ACTIVE 0x03
 #define NCI_DISCOVERY_TYPE_POLL_F_ACTIVE 0x05
 #define NCI_DISCOVERY_TYPE_LISTEN_A 0x80
 #define NCI_DISCOVERY_TYPE_LISTEN_B 0x81
 #define NCI_DISCOVERY_TYPE_LISTEN_F 0x82
 #define NCI_DISCOVERY_TYPE_LISTEN_A_ACTIVE 0x83
+/* NCI2.0 standardizes P2P listen active*/
+#define NCI_DISCOVERY_TYPE_LISTEN_ACTIVE 0x83
 #define NCI_DISCOVERY_TYPE_LISTEN_F_ACTIVE 0x85
-#define NCI_DISCOVERY_TYPE_POLL_ISO15693 0x06
 #define NCI_DISCOVERY_TYPE_LISTEN_ISO15693 0x86
 #define NCI_DISCOVERY_TYPE_MAX NCI_DISCOVERY_TYPE_LISTEN_ISO15693
 
@@ -439,6 +458,12 @@
 #define NCI_ROUTE_PWR_STATE_SWITCH_OFF 0x02
 /* The device's battery is removed */
 #define NCI_ROUTE_PWR_STATE_BATT_OFF 0x04
+/* The device is in screen off Unlock mode */
+#define NCI_ROUTE_PWR_STATE_SCREEN_OFF_UNLOCK 0x08
+/* The device is in screen on lock mode */
+#define NCI_ROUTE_PWR_STATE_SCREEN_ON_LOCK 0x10
+/* The device is in screen off lock mode */
+#define NCI_ROUTE_PWR_STATE_SCREEN_OFF_LOCK 0x20
 
 /* Hardware / Registration Identification  */
 #define NCI_NFCEE_TAG_HW_ID 0x00
@@ -460,6 +485,7 @@
 
 #define NCI_PARAM_ID_TOTAL_DURATION 0x00
 #define NCI_PARAM_ID_CON_DEVICES_LIMIT 0x01
+#define NCI_PARAM_ID_CON_DISCOVERY_PARAM 0x02
 #define NCI_PARAM_ID_PA_BAILOUT 0x08
 #define NCI_PARAM_ID_PB_AFI 0x10
 #define NCI_PARAM_ID_PB_BAILOUT 0x11
@@ -506,6 +532,10 @@
 #define NCI_PARAM_ID_LF_T3T_MAX 0x52
 #define NCI_PARAM_ID_LF_T3T_FLAGS2 0x53
 #define NCI_PARAM_ID_LF_CON_BITR_F 0x54
+#define NCI_PARAM_ID_LF_CON_ADV_FEAT 0x55
+/*LF_T3T name changed in NCI2.0*/
+#define NCI_PARAM_ID_LF_T3T_RD_ALLOWED 0x55
+
 #define NCI_PARAM_ID_FWI 0x58
 #define NCI_PARAM_ID_LA_HIST_BY 0x59
 #define NCI_PARAM_ID_LB_H_INFO_RSP 0x5A
@@ -544,6 +574,8 @@
  **********************************************/
 #define NCI_PARAM_LEN_TOTAL_DURATION 2
 
+#define NCI_PARAM_LEN_CON_DISCOVERY_PARAM 1
+
 #define NCI_PARAM_LEN_PA_FSDI 1
 
 #define NCI_PARAM_LEN_PF_RC 1
@@ -560,7 +592,12 @@
 #define NCI_PARAM_LEN_LF_PROTOCOL 1
 #define NCI_PARAM_LEN_LF_T3T_FLAGS2 2
 #define NCI_PARAM_LEN_LF_T3T_PMM 8
-#define NCI_PARAM_LEN_LF_T3T_ID 10
+#define NCI_PARAM_LEN_LF_T3T_ID(X) (((X) == NCI_VERSION_2_0) ? (0x12) : (0x0A))
+#define NCI_PARAM_LEN_LF_CON_ADV_FEAT 1
+
+#define NCI_PARAM_LEN_LF_T3T_RD_ALLOWED 1  // Listen F NCI2.0 Parameter
+#define NCI_PARAM_LEN_LF_T3T_ID_MAX 16     // LF T3T indentifier Max Value 16
+#define NFA_CE_LISTEN_INFO_LF_MAX 16       // LF T3T indentifier Max Value 16
 
 #define NCI_PARAM_LEN_FWI 1
 #define NCI_PARAM_LEN_WT 1
@@ -577,6 +614,23 @@
 #define NCI_LF_T3T_FLAGS2_ALL_DISABLED 0x0000
 #define NCI_LF_T3T_FLAGS2_ID1_ENABLED 0x0001
 
+/* The DH-NFCEE listen is considered as a enable NFCEE */
+#define NCI_LISTEN_DH_NFCEE_ENABLE_MASK 0x00
+/* The DH-NFCEE listen is considered as a disable NFCEE */
+#define NCI_LISTEN_DH_NFCEE_DISABLE_MASK 0x02
+/* The DH polling is considered as a disable NFCEE */
+#define NCI_POLLING_DH_DISABLE_MASK 0x00
+/* The DH polling is considered as a enable NFCEE */
+#define NCI_POLLING_DH_ENABLE_MASK 0x01
+
+#define NCI_ROUTE_QUAL_MASK 0x70
+/* AID matching is allowed when the SELECT AID is longer */
+#define NCI_ROUTE_QUAL_LONG_SELECT 0x10
+/* AID matching is allowed when the SELECT AID is shorter */
+#define NCI_ROUTE_QUAL_SHORT_SELECT 0x20
+/* AID is blocked in unsupported power mode */
+#define NCI_ROUTE_QUAL_BLOCK_ROUTE 0x40
+
 typedef struct {
   uint16_t addr;
   uint8_t len;
@@ -744,6 +798,15 @@
   } intf_param; /* Activation Parameters   0 - n Bytes */
 } tNCI_INTF_PARAMS;
 
+typedef struct {
+  uint8_t atr_res_len;                      /* Length of ATR_RES            */
+  uint8_t atr_res[NCI_MAX_ATS_LEN];         /* ATR_RES (Byte 3 - Byte 17+n) */
+  uint8_t max_payload_size;                 /* 64, 128, 192 or 254          */
+  uint8_t gen_bytes_len;                    /* len of general bytes         */
+  uint8_t gen_bytes[NCI_MAX_GEN_BYTES_LEN]; /* general bytes                */
+  uint8_t waiting_time;                     /* WT -> Response Waiting Time
+                                               RWT = (256 x 16/fC) x 2WT    */
+} tNCI_RF_ACM_P_PARAMS;
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/include/NfcAdaptation.h b/src/include/NfcAdaptation.h
index 06c0c38..606f66b 100644
--- a/src/include/NfcAdaptation.h
+++ b/src/include/NfcAdaptation.h
@@ -80,6 +80,7 @@
   static NfcAdaptation& GetInstance();
   tHAL_NFC_ENTRY* GetHalEntryFuncs();
   void DownloadFirmware();
+  void Dump(int fd);
 
  private:
   NfcAdaptation();
diff --git a/src/include/_OverrideLog.h b/src/include/_OverrideLog.h
index 065e271..dd412ab 100644
--- a/src/include/_OverrideLog.h
+++ b/src/include/_OverrideLog.h
@@ -40,6 +40,10 @@
 
 extern unsigned char appl_trace_level;
 extern uint32_t ScrProtocolTraceFlag;
+/* defined for run time DTA mode selection */
+extern unsigned char appl_dta_mode_flag;
+
+void initializeGlobalAppDtaMode();
 
 /*******************************************************************************
 **
diff --git a/src/include/config.h b/src/include/config.h
index f0e45aa..23c80fb 100644
--- a/src/include/config.h
+++ b/src/include/config.h
@@ -58,6 +58,7 @@
 #define NAME_POWER_ON_DELAY "POWER_ON_DELAY"
 #define NAME_PRE_POWER_OFF_DELAY "PRE_POWER_OFF_DELAY"
 #define NAME_POST_POWER_OFF_DELAY "POST_POWER_OFF_DELAY"
+#define NAME_APPL_DTA_MODE "APPL_DTA_MODE"
 #define NAME_CE3_PRE_POWER_OFF_DELAY "CE3_PRE_POWER_OFF_DELAY"
 #define NAME_NFA_STORAGE "NFA_STORAGE"
 #define NAME_NFA_DM_START_UP_VSC_CFG "NFA_DM_START_UP_VSC_CFG"
@@ -90,6 +91,7 @@
 #define NAME_NCI_HAL_MODULE "NCI_HAL_MODULE"
 #define NAME_NFA_POLL_BAIL_OUT_MODE "NFA_POLL_BAIL_OUT_MODE"
 #define NAME_NFA_PROPRIETARY_CFG "NFA_PROPRIETARY_CFG"
+#define NAME_NFA_AID_BLOCK_ROUTE "NFA_AID_BLOCK_ROUTE"
 
 #define LPTD_PARAM_LEN (40)
 
diff --git a/src/include/debug_nfcsnoop.h b/src/include/debug_nfcsnoop.h
new file mode 100644
index 0000000..2dd7b6b
--- /dev/null
+++ b/src/include/debug_nfcsnoop.h
@@ -0,0 +1,50 @@
+/******************************************************************************
+ *
+ *  Copyright (C) 2017 Google Inc.
+ *
+ *  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.
+ *
+ ******************************************************************************/
+#ifndef _DEBUG_NFCSNOOP_
+#define _DEBUG_NFCSNOOP_
+
+#include <stdint.h>
+#include "nfc_target.h"
+#include "nfc_types.h"
+
+#define NFCSNOOZ_CURRENT_VERSION 0x01
+
+// The preamble is stored un-encrypted as the first part
+// of the file.
+typedef struct nfcsnooz_preamble_t {
+  uint8_t version;
+  uint64_t last_timestamp_ms;
+} __attribute__((__packed__)) nfcsnooz_preamble_t;
+
+// One header for each NCI packet
+typedef struct nfcsnooz_header_t {
+  uint16_t length;
+  uint32_t delta_time_ms;
+  uint8_t is_received;
+} __attribute__((__packed__)) nfcsnooz_header_t;
+
+// Initializes nfcsnoop memory logging and registers
+void debug_nfcsnoop_init(void);
+
+// Writes nfcsnoop data base64 encoded to fd
+void debug_nfcsnoop_dump(int fd);
+
+// capture the packet
+void nfcsnoop_capture(const NFC_HDR* packet, bool is_received);
+
+#endif /* _DEBUG_NFCSNOOP_ */
diff --git a/src/include/nfc_target.h b/src/include/nfc_target.h
index eef3e5b..fd56462 100644
--- a/src/include/nfc_target.h
+++ b/src/include/nfc_target.h
@@ -156,13 +156,15 @@
 ** NCI
 **
 ******************************************************************************/
-
-#define NCI_VERSION_0_F 0x0F
+#define NCI_VERSION_UNKNOWN 0x00
 #define NCI_VERSION_1_0 0x10
-
+#define NCI_VERSION_1_1 0x11
+#define NCI_VERSION_2_0 0x20
 #ifndef NCI_VERSION
-#define NCI_VERSION NCI_VERSION_1_0
+#define NCI_VERSION NCI_VERSION_2_0
 #endif
+#define NCI_CORE_RESET_RSP_LEN(X) (((X) == NCI_VERSION_2_0) ? (0x01) : (0x03))
+#define NCI_VERSION_0_F 0x0F
 
 /* TRUE I2C patch is needed */
 #ifndef NFC_I2C_PATCH_INCLUDED
diff --git a/src/include/ringbuffer.h b/src/include/ringbuffer.h
new file mode 100644
index 0000000..d2c310a
--- /dev/null
+++ b/src/include/ringbuffer.h
@@ -0,0 +1,62 @@
+/******************************************************************************
+ *
+ *  Copyright (C) 2017 Google Inc.
+ *
+ *  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.
+ *
+ ******************************************************************************/
+
+#pragma once
+
+#include <stdint.h>
+
+typedef struct ringbuffer_t ringbuffer_t;
+
+// NOTE:
+// None of the functions below are thread safe when it comes to accessing the
+// *rb pointer. It is *NOT* possible to insert and pop/delete at the same time.
+// Callers must protect the *rb pointer separately.
+
+// Create a ringbuffer with the specified size
+// Returns NULL if memory allocation failed. Resulting pointer must be freed
+// using |ringbuffer_free|.
+ringbuffer_t* ringbuffer_init(const size_t size);
+
+// Frees the ringbuffer structure and buffer
+// Save to call with NULL.
+void ringbuffer_free(ringbuffer_t* rb);
+
+// Returns remaining buffer size
+size_t ringbuffer_available(const ringbuffer_t* rb);
+
+// Returns size of data in buffer
+size_t ringbuffer_size(const ringbuffer_t* rb);
+
+// Attempts to insert up to |length| bytes of data at |p| into the buffer
+// Return actual number of bytes added. Can be less than |length| if buffer
+// is full.
+size_t ringbuffer_insert(ringbuffer_t* rb, const uint8_t* p, size_t length);
+
+// Peek |length| number of bytes from the ringbuffer, starting at |offset|,
+// into the buffer |p|. Return the actual number of bytes peeked. Can be less
+// than |length| if there is less than |length| data available. |offset| must
+// be non-negative.
+size_t ringbuffer_peek(const ringbuffer_t* rb, off_t offset, uint8_t* p,
+                       size_t length);
+
+// Does the same as |ringbuffer_peek|, but also advances the ring buffer head
+size_t ringbuffer_pop(ringbuffer_t* rb, uint8_t* p, size_t length);
+
+// Deletes |length| bytes from the ringbuffer starting from the head
+// Return actual number of bytes deleted.
+size_t ringbuffer_delete(ringbuffer_t* rb, size_t length);
diff --git a/src/nfa/ce/nfa_ce_act.c b/src/nfa/ce/nfa_ce_act.c
index 38a0576..6e1166b 100644
--- a/src/nfa/ce/nfa_ce_act.c
+++ b/src/nfa/ce/nfa_ce_act.c
@@ -285,10 +285,13 @@
 void nfc_ce_t3t_set_listen_params(void) {
   uint8_t i;
   tNFA_CE_CB* p_cb = &nfa_ce_cb;
-  uint8_t tlv[32], *p_params;
+  uint8_t tlv[128], *p_params;
   uint8_t tlv_size;
   uint16_t t3t_flags2_mask = 0xFFFF; /* Mask of which T3T_IDs are disabled */
   uint8_t t3t_idx = 0;
+  uint8_t adv_Feat = 1;
+  uint8_t t3tPMM[NCI_T3T_PMM_LEN] = {0xFF, 0xFF, 0xFF, 0xFF,
+                                     0xFF, 0xFF, 0xFF, 0xFF};
 
   /* Point to start of tlv buffer */
   p_params = tlv;
@@ -299,12 +302,16 @@
         (p_cb->listen_info[i].protocol_mask & NFA_PROTOCOL_MASK_T3T)) {
       /* Set tag's system code and NFCID2 */
       UINT8_TO_STREAM(p_params, NFC_PMID_LF_T3T_ID1 + t3t_idx); /* type */
-      UINT8_TO_STREAM(p_params, NCI_PARAM_LEN_LF_T3T_ID);       /* length */
+      /* length */
+      UINT8_TO_STREAM(p_params, NCI_PARAM_LEN_LF_T3T_ID(NFC_GetNCIVersion()));
       /* System Code */
       UINT16_TO_BE_STREAM(p_params, p_cb->listen_info[i].t3t_system_code);
       ARRAY_TO_BE_STREAM(p_params, p_cb->listen_info[i].t3t_nfcid2,
                          NCI_RF_F_UID_LEN);
-
+      if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+        ARRAY_TO_BE_STREAM(p_params, p_cb->listen_info[i].t3t_pmm,
+                           NCI_T3T_PMM_LEN);
+      }
       /* Set mask for this ID */
       t3t_flags2_mask &= ~((uint16_t)(1 << t3t_idx));
       t3t_idx++;
@@ -319,7 +326,25 @@
   /* Mask of IDs to disable listening */
   UINT16_TO_STREAM(p_params, t3t_flags2_mask);
 
+  if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+    /*Name changed in NCI2.0*/
+    UINT8_TO_STREAM(p_params, NCI_PARAM_ID_LF_T3T_RD_ALLOWED);  /* type */
+    UINT8_TO_STREAM(p_params, NCI_PARAM_LEN_LF_T3T_RD_ALLOWED); /* length */
+  } else {
+    UINT8_TO_STREAM(p_params, NCI_PARAM_ID_LF_CON_ADV_FEAT);  /* type */
+    UINT8_TO_STREAM(p_params, NCI_PARAM_LEN_LF_CON_ADV_FEAT); /* length */
+  }
+  UINT8_TO_STREAM(p_params, adv_Feat);
+
+  if (NFC_GetNCIVersion() != NCI_VERSION_2_0) {
+    UINT8_TO_STREAM(p_params, NCI_PARAM_ID_LF_T3T_PMM);  /* type */
+    UINT8_TO_STREAM(p_params, NCI_PARAM_LEN_LF_T3T_PMM); /* length */
+    ARRAY_TO_BE_STREAM(p_params, t3tPMM, NCI_T3T_PMM_LEN);
+  }
   tlv_size = (uint8_t)(p_params - tlv);
+  if (appl_dta_mode_flag == 0x01) {
+    nfa_dm_cb.eDtaMode |= NFA_DTA_HCEF_MODE;
+  }
   nfa_dm_check_set_config(tlv_size, (uint8_t*)tlv, false);
 }
 
@@ -1246,6 +1271,8 @@
             p_ce_msg->reg_listen.system_code;
         memcpy(p_cb->listen_info[listen_info_idx].t3t_nfcid2,
                p_ce_msg->reg_listen.nfcid2, NCI_RF_F_UID_LEN);
+        memcpy(p_cb->listen_info[listen_info_idx].t3t_pmm,
+               p_ce_msg->reg_listen.t3tPmm, NCI_T3T_PMM_LEN);
         break;
 
 #if (NFC_NFCEE_INCLUDED == TRUE)
diff --git a/src/nfa/ce/nfa_ce_api.c b/src/nfa/ce/nfa_ce_api.c
index c988f70..836f0c3 100644
--- a/src/nfa/ce/nfa_ce_api.c
+++ b/src/nfa/ce/nfa_ce_api.c
@@ -245,6 +245,7 @@
 *******************************************************************************/
 tNFA_STATUS NFA_CeRegisterFelicaSystemCodeOnDH(uint16_t system_code,
                                                uint8_t nfcid2[NCI_RF_F_UID_LEN],
+                                               uint8_t t3tPmm[NCI_T3T_PMM_LEN],
                                                tNFA_CONN_CBACK* p_conn_cback) {
   tNFA_CE_MSG* p_msg;
 
@@ -261,6 +262,7 @@
 
     /* Listen info */
     memcpy(p_msg->reg_listen.nfcid2, nfcid2, NCI_RF_F_UID_LEN);
+    memcpy(p_msg->reg_listen.t3tPmm, t3tPmm, NCI_T3T_PMM_LEN);
     p_msg->reg_listen.system_code = system_code;
 
     nfa_sys_sendmsg(p_msg);
diff --git a/src/nfa/dm/nfa_dm_act.c b/src/nfa/dm/nfa_dm_act.c
index 9899ce0..e3964c8 100644
--- a/src/nfa/dm/nfa_dm_act.c
+++ b/src/nfa/dm/nfa_dm_act.c
@@ -133,17 +133,38 @@
 
   /* set NCI default value if other than zero */
 
-  /* LF_T3T_IDENTIFIERS_1/2/.../16 */
-  for (xx = 0; xx < NFA_CE_LISTEN_INFO_MAX; xx++) {
-    nfa_dm_cb.params.lf_t3t_id[xx][0] = 0xFF;
-    nfa_dm_cb.params.lf_t3t_id[xx][1] = 0xFF;
-    nfa_dm_cb.params.lf_t3t_id[xx][2] = 0x02;
-    nfa_dm_cb.params.lf_t3t_id[xx][3] = 0xFE;
-  }
+  if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+    /* Default Values: For each identifier
+     * Octet 0-1   = OxFF
+     * Octet 2     = Ox02
+     * Octet 3     = 0xFE
+     * Octet 4-9   = 0x00
+     * Octet 10-17 = 0xFF*/
+    for (xx = 0; xx < NFA_CE_LISTEN_INFO_MAX; xx++) {
+      nfa_dm_cb.params.lf_t3t_id[xx][0] = 0xFF;
+      nfa_dm_cb.params.lf_t3t_id[xx][1] = 0xFF;
+      nfa_dm_cb.params.lf_t3t_id[xx][2] = 0x02;
+      nfa_dm_cb.params.lf_t3t_id[xx][3] = 0xFE;
+    }
 
-  /* LF_T3T_PMM */
-  for (xx = 0; xx < NCI_PARAM_LEN_LF_T3T_PMM; xx++) {
-    nfa_dm_cb.params.lf_t3t_pmm[xx] = 0xFF;
+    /* LF_T3T_PMM value is added to LF_T3T_IDENTIFIERS_X in NCI2.0. */
+    for (xx = 0; xx < NFA_CE_LISTEN_INFO_MAX; xx++) {
+      for (uint8_t yy = 10; yy < NCI_PARAM_LEN_LF_T3T_ID(NCI_VERSION_2_0); yy++)
+        nfa_dm_cb.params.lf_t3t_id[xx][yy] = 0xFF;
+    }
+  } else {
+    /* LF_T3T_IDENTIFIERS_1/2/.../16 */
+    for (xx = 0; xx < NFA_CE_LISTEN_INFO_MAX; xx++) {
+      nfa_dm_cb.params.lf_t3t_id[xx][0] = 0xFF;
+      nfa_dm_cb.params.lf_t3t_id[xx][1] = 0xFF;
+      nfa_dm_cb.params.lf_t3t_id[xx][2] = 0x02;
+      nfa_dm_cb.params.lf_t3t_id[xx][3] = 0xFE;
+    }
+
+    /* LF_T3T_PMM */
+    for (xx = 0; xx < NCI_PARAM_LEN_LF_T3T_PMM; xx++) {
+      nfa_dm_cb.params.lf_t3t_pmm[xx] = 0xFF;
+    }
   }
 
   /* LF_T3T_FLAGS:
@@ -344,6 +365,12 @@
       break;
 #endif
 
+    case NFC_SET_POWER_SUB_STATE_REVT:
+      dm_cback_data.power_sub_state.status = p_data->status;
+      dm_cback_data.power_sub_state.power_state = nfa_dm_cb.power_state;
+      (*nfa_dm_cb.p_dm_cback)(NFA_DM_SET_POWER_SUB_STATE_EVT, &dm_cback_data);
+      break;
+
     case NFC_RF_FIELD_REVT: /* RF Field information            */
       dm_cback_data.rf_field.status = NFA_STATUS_OK;
       dm_cback_data.rf_field.rf_field_status = p_data->rf_field.rf_field;
@@ -562,7 +589,39 @@
 
   return true;
 }
+/*******************************************************************************
+**
+** Function         nfa_dm_set_power_sub_state
+**
+** Description      Process the power sub state command
+**
+** Returns          TRUE (message buffer to be freed by caller)
+**
+*******************************************************************************/
+bool nfa_dm_set_power_sub_state(tNFA_DM_MSG* p_data) {
+  tNFC_STATUS status;
+  tNFA_DM_CBACK_DATA dm_cback_data;
 
+  NFA_TRACE_DEBUG0(" nfa_dm_set_power_sub_state ()");
+
+  nfa_dm_cb.power_state = p_data->set_power_state.screen_state;
+  if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE) {
+    NFA_TRACE_DEBUG0(
+        "nfa_dm_set_power_sub_state () : NFA_DM_RFST_LISTEN_ACTIVE");
+    /* NFCC will give semantic error for power sub state command in Rf listen
+     * active state */
+    status = NFC_STATUS_SEMANTIC_ERROR;
+  } else {
+    status = NFC_SetPowerSubState(p_data->set_power_state.screen_state);
+  }
+
+  if (status != NFC_STATUS_OK) {
+    dm_cback_data.power_sub_state.status = NFC_STATUS_FAILED;
+    dm_cback_data.power_sub_state.power_state = nfa_dm_cb.power_state;
+    (*nfa_dm_cb.p_dm_cback)(NFA_DM_SET_POWER_SUB_STATE_EVT, &dm_cback_data);
+  }
+  return (true);
+}
 /*******************************************************************************
 **
 ** Function         nfa_dm_conn_cback_event_notify
@@ -702,16 +761,21 @@
 
   /* Always allow deactivate to IDLE */
   /* Do not allow deactivate to SLEEP for T1T,NFCDEP, ISO15693 */
-  if ((p_data->deactivate.sleep_mode == false) ||
-      ((nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_T1T) &&
-       (nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_NFC_DEP) &&
-       (nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_ISO15693) &&
-       (nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_KOVIO))) {
+  if (p_data->deactivate.sleep_mode == false ||
+      (nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_T1T &&
+       (nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_NFC_DEP ||
+        appl_dta_mode_flag) &&
+       nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_T5T &&
+       nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_KOVIO)) {
     deact_type = NFA_DEACTIVATE_TYPE_DISCOVERY;
     if (p_data->deactivate.sleep_mode) {
       if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_HOST_SELECT) {
         /* Deactivate to sleep mode not allowed in this state. */
         deact_type = NFA_DEACTIVATE_TYPE_IDLE;
+      } else if (appl_dta_mode_flag == true &&
+                 (nfa_dm_cb.disc_cb.disc_state != NFA_DM_RFST_LISTEN_SLEEP ||
+                  nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE)) {
+        deact_type = NFA_DEACTIVATE_TYPE_SLEEP;
       } else if (nfa_dm_cb.disc_cb.disc_state != NFA_DM_RFST_LISTEN_SLEEP) {
         deact_type = NFA_DEACTIVATE_TYPE_SLEEP;
       }
@@ -722,7 +786,8 @@
     }
 
     if ((nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_NFC_DEP) &&
-        ((nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) == 0x00)) {
+        ((nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) == 0x00) &&
+        appl_dta_mode_flag != true) {
       /* Exclusive RF control doesn't use NFA P2P */
       /* NFA P2P will deactivate NFC link after deactivating LLCP link */
       if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_P2P_PAUSED)) {
@@ -802,6 +867,29 @@
   NFC_SendVsCommand(p_data->send_vsc.oid, p_cmd, p_data->send_vsc.p_cback);
 
   /* Most dm action functions return TRUE, so nfa-sys frees the GKI buffer
+   * carrying the message, This action function re-use the GKI buffer to
+   * send the VSC, so the GKI buffer can not be freed by nfa-sys */
+
+  return false;
+}
+
+/*******************************************************************************
+**
+** Function         nfa_dm_act_send_raw_vs
+**
+** Description      Send the raw vs command to the NCI command queue
+**
+** Returns          FALSE (message buffer is NOT freed by caller)
+**
+*******************************************************************************/
+bool nfa_dm_act_send_raw_vs(tNFA_DM_MSG* p_data) {
+  NFC_HDR* p_cmd = (NFC_HDR*)p_data;
+
+  p_cmd->offset = sizeof(tNFA_DM_API_SEND_VSC) - NFC_HDR_SIZE;
+  p_cmd->len = p_data->send_vsc.cmd_params_len;
+  NFC_SendRawVsCommand(p_cmd, p_data->send_vsc.p_cback);
+
+  /* Most dm action functions return TRUE, so nfa-sys frees the GKI buffer
    * carrying the message,
    * This action function re-use the GKI buffer to send the VSC, so the GKI
    * buffer can not be freed by nfa-sys */
@@ -835,8 +923,17 @@
       poll_disc_mask |= NFA_DM_DISC_MASK_PA_NFC_DEP;
       poll_disc_mask |= NFA_DM_DISC_MASK_P_LEGACY;
     }
-    if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE) {
-      poll_disc_mask |= NFA_DM_DISC_MASK_PAA_NFC_DEP;
+    if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+      if (poll_tech_mask & NFA_TECHNOLOGY_MASK_ACTIVE) {
+        poll_disc_mask |= NFA_DM_DISC_MASK_PACM_NFC_DEP;
+      }
+    } else {
+      if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE) {
+        poll_disc_mask |= NFA_DM_DISC_MASK_PAA_NFC_DEP;
+      }
+      if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE) {
+        poll_disc_mask |= NFA_DM_DISC_MASK_PFA_NFC_DEP;
+      }
     }
     if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B) {
       poll_disc_mask |= NFA_DM_DISC_MASK_PB_ISO_DEP;
@@ -845,11 +942,8 @@
       poll_disc_mask |= NFA_DM_DISC_MASK_PF_T3T;
       poll_disc_mask |= NFA_DM_DISC_MASK_PF_NFC_DEP;
     }
-    if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE) {
-      poll_disc_mask |= NFA_DM_DISC_MASK_PFA_NFC_DEP;
-    }
-    if (poll_tech_mask & NFA_TECHNOLOGY_MASK_ISO15693) {
-      poll_disc_mask |= NFA_DM_DISC_MASK_P_ISO15693;
+    if (poll_tech_mask & NFA_TECHNOLOGY_MASK_V) {
+      poll_disc_mask |= NFA_DM_DISC_MASK_P_T5T;
     }
     if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B_PRIME) {
       poll_disc_mask |= NFA_DM_DISC_MASK_P_B_PRIME;
@@ -1082,7 +1176,7 @@
          (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T2T) ||
          (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T3T) ||
          (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO_DEP) ||
-         (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO15693))) {
+         (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T5T))) {
       /* if RW is checking presence then it will put into pending queue */
       status = nfa_rw_send_raw_frame((NFC_HDR*)p_data);
     } else {
@@ -1398,7 +1492,7 @@
               (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) ||
               (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) ||
               (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP) ||
-              (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO15693) ||
+              (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T5T) ||
               (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_KOVIO)) {
             /* Notify NFA tag sub-system */
             nfa_rw_proc_disc_evt(NFA_DM_RF_DISC_ACTIVATED_EVT, p_data, false);
@@ -1484,28 +1578,35 @@
       if (nfa_dm_cb.p_activate_ntf) {
         memcpy(nfa_dm_cb.p_activate_ntf, &(p_data->activate),
                sizeof(tNFC_ACTIVATE_DEVT));
-
         if ((nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP) &&
             (nfa_dm_cb.disc_cb.activated_rf_interface ==
              NFC_INTERFACE_NFC_DEP)) {
-          if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_P2P_PAUSED)) {
-            /* activate LLCP */
-            nfa_p2p_activate_llcp(p_data);
-            if (nfa_dm_cb.p_activate_ntf) {
-              GKI_freebuf(nfa_dm_cb.p_activate_ntf);
-              nfa_dm_cb.p_activate_ntf = NULL;
-            }
-          } else {
-            NFA_TRACE_DEBUG0("P2P is paused");
+          /* For P2P mode(Default DTA mode) open Raw channel to bypass LLCP
+           * layer. For LLCP DTA mode activate LLCP */
+          if ((appl_dta_mode_flag == 1) &&
+              ((nfa_dm_cb.eDtaMode & 0x0F) == NFA_DTA_DEFAULT_MODE)) {
+            /* Open raw channel in case of p2p for DTA testing */
+            NFC_SetStaticRfCback(nfa_dm_act_data_cback);
             nfa_dm_notify_activation_status(NFA_STATUS_OK, NULL);
+          } else {
+            if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_P2P_PAUSED)) {
+              /* activate LLCP */
+              nfa_p2p_activate_llcp(p_data);
+              if (nfa_dm_cb.p_activate_ntf) {
+                GKI_freebuf(nfa_dm_cb.p_activate_ntf);
+                nfa_dm_cb.p_activate_ntf = NULL;
+              }
+            } else {
+              NFA_TRACE_DEBUG0("P2P is paused");
+              nfa_dm_notify_activation_status(NFA_STATUS_OK, NULL);
+            }
           }
         } else if ((nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T1T) ||
                    (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) ||
                    (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) ||
                    (nfa_dm_cb.disc_cb.activated_protocol ==
                     NFC_PROTOCOL_ISO_DEP) ||
-                   (nfa_dm_cb.disc_cb.activated_protocol ==
-                    NFC_PROTOCOL_15693) ||
+                   (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T5T) ||
                    (nfa_dm_cb.disc_cb.activated_protocol ==
                     NFC_PROTOCOL_KOVIO) ||
                    (nfa_dm_cb.disc_cb.activated_protocol ==
@@ -1581,6 +1682,19 @@
 }
 
 /*******************************************************************************
+** Function         nfa_dm_poll_disc_cback_dta_wrapper
+**
+** Description      Accessing the nfa_dm_poll_disc_cback for DTA wrapper
+**
+** Returns          None
+**
+*******************************************************************************/
+void nfa_dm_poll_disc_cback_dta_wrapper(tNFA_DM_RF_DISC_EVT event,
+                                        tNFC_DISCOVER* p_data) {
+  nfa_dm_poll_disc_cback(event, p_data);
+}
+
+/*******************************************************************************
 **
 ** Function         nfa_dm_notify_activation_status
 **
@@ -1633,7 +1747,7 @@
     } else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_F) {
       nfcid_len = NFC_NFCID2_LEN;
       p_nfcid = p_tech_params->param.pf.nfcid2;
-    } else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_ISO15693) {
+    } else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_V) {
       nfcid_len = NFC_ISO15693_UID_LEN;
       p_nfcid = p_tech_params->param.pi93.uid;
     } else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_KOVIO) {
@@ -1669,7 +1783,7 @@
             ((nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP) &&
              (nfa_dm_cb.disc_cb.activated_rf_interface ==
               NFC_INTERFACE_ISO_DEP)) ||
-            (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO15693)) {
+            (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T5T)) {
           if (p_nfa_dm_cfg->auto_detect_ndef) {
             if (p_nfa_dm_cfg->auto_read_ndef) {
               nfa_dm_cb.flags |= NFA_DM_FLAGS_AUTO_READING_NDEF;
diff --git a/src/nfa/dm/nfa_dm_api.c b/src/nfa/dm/nfa_dm_api.c
index e9b0b16..474a525 100644
--- a/src/nfa/dm/nfa_dm_api.c
+++ b/src/nfa/dm/nfa_dm_api.c
@@ -152,7 +152,53 @@
 
   return (NFA_STATUS_FAILED);
 }
+/*******************************************************************************
+**
+** Function         NFA_SetPowerSubStateForScreenState
+**
+** Description      Update the power sub-state as per current screen state to
+**                  NFCC.
+**
+** Returns          NFA_STATUS_OK if successfully initiated
+**                  NFA_STATUS_FAILED otherwise
+**
+*******************************************************************************/
+tNFA_STATUS NFA_SetPowerSubStateForScreenState(uint8_t screenState) {
+  NFA_TRACE_API2("%s: state:0x%X", __func__, screenState);
 
+  uint8_t nci_scren_state = 0xFF;
+  uint16_t buf_size = sizeof(tNFA_DM_API_SET_POWER_SUB_STATE);
+  tNFA_DM_API_SET_POWER_SUB_STATE* p_msg =
+      (tNFA_DM_API_SET_POWER_SUB_STATE*)GKI_getbuf(buf_size);
+
+  if (p_msg != NULL) {
+    p_msg->hdr.event = NFA_DM_API_SET_POWER_SUB_STATE_EVT;
+    switch (screenState) {
+      case NFA_SCREEN_STATE_ON_UNLOCKED:
+        nci_scren_state = SCREEN_STATE_ON_UNLOCKED;
+        break;
+      case NFA_SCREEN_STATE_OFF_UNLOCKED:
+        nci_scren_state = SCREEN_STATE_OFF_UNLOCKED;
+        break;
+      case NFA_SCREEN_STATE_ON_LOCKED:
+        nci_scren_state = SCREEN_STATE_ON_LOCKED;
+        break;
+      case NFA_SCREEN_STATE_OFF_LOCKED:
+        nci_scren_state = SCREEN_STATE_OFF_LOCKED;
+        break;
+
+      default:
+        NFA_TRACE_API1("%s, unknown screen state", __func__);
+        break;
+    }
+
+    p_msg->screen_state = nci_scren_state;
+
+    nfa_sys_sendmsg(p_msg);
+    return (NFA_STATUS_OK);
+  }
+  return (NFA_STATUS_FAILED);
+}
 /*******************************************************************************
 **
 ** Function         NFA_SetConfig
@@ -1180,6 +1226,50 @@
 
 /*******************************************************************************
 **
+** Function         NFA_SendRawVsCommand
+**
+** Description      This function is called to send raw Vendor Specific
+**                  command to NFCC.
+**
+**                  cmd_params_len  - The command parameter len
+**                  p_cmd_params    - The command parameter
+**                  p_cback         - The callback function to receive the
+**                                    command
+**
+** Returns          NFA_STATUS_OK if successfully initiated
+**                  NFA_STATUS_FAILED otherwise
+**
+*******************************************************************************/
+tNFA_STATUS NFA_SendRawVsCommand(uint8_t cmd_params_len, uint8_t* p_cmd_params,
+                                 tNFA_VSC_CBACK* p_cback) {
+  if (cmd_params_len == 0x00 || p_cmd_params == NULL || p_cback == NULL) {
+    return NFA_STATUS_INVALID_PARAM;
+  }
+  uint16_t size = sizeof(tNFA_DM_API_SEND_VSC) + cmd_params_len;
+  tNFA_DM_API_SEND_VSC* p_msg = (tNFA_DM_API_SEND_VSC*)GKI_getbuf(size);
+
+  if (p_msg != NULL) {
+    p_msg->hdr.event = NFA_DM_API_SEND_RAW_VS_EVT;
+    p_msg->p_cback = p_cback;
+    if (cmd_params_len && p_cmd_params) {
+      p_msg->cmd_params_len = cmd_params_len;
+      p_msg->p_cmd_params = (uint8_t*)(p_msg + 1);
+      memcpy(p_msg->p_cmd_params, p_cmd_params, cmd_params_len);
+    } else {
+      p_msg->cmd_params_len = 0;
+      p_msg->p_cmd_params = NULL;
+    }
+
+    nfa_sys_sendmsg(p_msg);
+
+    return NFA_STATUS_OK;
+  }
+
+  return NFA_STATUS_FAILED;
+}
+
+/*******************************************************************************
+**
 ** Function         NFA_SetTraceLevel
 **
 ** Description      This function sets the trace level for NFA.  If called with
@@ -1193,3 +1283,17 @@
 
   return (nfa_sys_cb.trace_level);
 }
+/*******************************************************************************
+**
+** Function:        NFA_EnableDtamode
+**
+** Description:     Enable DTA Mode
+**
+** Returns:         none:
+**
+*******************************************************************************/
+void NFA_EnableDtamode(tNFA_eDtaModes eDtaMode) {
+  NFA_TRACE_API2("%s: 0x%x ", __func__, eDtaMode);
+  appl_dta_mode_flag = 0x01;
+  nfa_dm_cb.eDtaMode = eDtaMode;
+}
diff --git a/src/nfa/dm/nfa_dm_cfg.c b/src/nfa/dm/nfa_dm_cfg.c
index 5300f8c..9e51a6a 100644
--- a/src/nfa/dm/nfa_dm_cfg.c
+++ b/src/nfa/dm/nfa_dm_cfg.c
@@ -59,7 +59,8 @@
     1, /* Frequency for Proprietary Technology/B-Prime */
     1, /* Frequency for Proprietary Technology/Kovio   */
     1, /* Frequency for NFC Technology A active mode   */
-    1  /* Frequency for NFC Technology F active mode   */
+    1, /* Frequency for NFC Technology F active mode   */
+    1  /* Frequency for NFC Technology active mode     */
 };
 
 tNFA_DM_DISC_FREQ_CFG* p_nfa_dm_rf_disc_freq_cfg =
diff --git a/src/nfa/dm/nfa_dm_discover.c b/src/nfa/dm/nfa_dm_discover.c
index 4d7d95f..e28af09 100644
--- a/src/nfa/dm/nfa_dm_discover.c
+++ b/src/nfa/dm/nfa_dm_discover.c
@@ -1,6 +1,5 @@
 /******************************************************************************
  *
- *  Copyright (C) 2010-2014 Broadcom Corporation
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -72,6 +71,8 @@
 
 static nfa_dm_p2p_prio_logic_t p2p_prio_logic_data;
 
+static void nfa_dm_send_tag_deselect_cmd(tNFA_NFC_PROTOCOL protocol);
+
 /*******************************************************************************
 **
 ** Function         nfa_dm_get_rf_discover_config
@@ -126,25 +127,34 @@
 
     if (num_params >= max_params) return num_params;
   }
+  if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+    /* Check polling Active mode  */
+    if (dm_disc_mask & NFA_DM_DISC_MASK_PACM_NFC_DEP) {
+      disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_ACTIVE;
+      disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pacm;
+      num_params++;
 
-  /* Check polling A Active mode  */
-  if (dm_disc_mask & NFA_DM_DISC_MASK_PAA_NFC_DEP) {
-    disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_A_ACTIVE;
-    disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->paa;
-    num_params++;
+      if (num_params >= max_params) return num_params;
+    }
+  } else {
+    /* Check polling A Active mode  */
+    if (dm_disc_mask & NFA_DM_DISC_MASK_PAA_NFC_DEP) {
+      disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_A_ACTIVE;
+      disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->paa;
+      num_params++;
 
-    if (num_params >= max_params) return num_params;
+      if (num_params >= max_params) return num_params;
+    }
+
+    /* Check polling F Active mode  */
+    if (dm_disc_mask & NFA_DM_DISC_MASK_PFA_NFC_DEP) {
+      disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_F_ACTIVE;
+      disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pfa;
+      num_params++;
+
+      if (num_params >= max_params) return num_params;
+    }
   }
-
-  /* Check polling F Active mode  */
-  if (dm_disc_mask & NFA_DM_DISC_MASK_PFA_NFC_DEP) {
-    disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_F_ACTIVE;
-    disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pfa;
-    num_params++;
-
-    if (num_params >= max_params) return num_params;
-  }
-
   /* Check listening A */
   if (dm_disc_mask &
       (NFA_DM_DISC_MASK_LA_T1T | NFA_DM_DISC_MASK_LA_T2T |
@@ -173,28 +183,37 @@
 
     if (num_params >= max_params) return num_params;
   }
+  if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+    /* Check polling Active mode  */
+    if (dm_disc_mask & NFA_DM_DISC_MASK_LACM_NFC_DEP) {
+      disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_ACTIVE;
+      disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pacm;
+      num_params++;
+      if (num_params >= max_params) return num_params;
+    }
+  } else {
+    /* Check listening A Active mode */
+    if (dm_disc_mask & NFA_DM_DISC_MASK_LAA_NFC_DEP) {
+      disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE;
+      disc_params[num_params].frequency = 1;
+      num_params++;
 
-  /* Check listening A Active mode */
-  if (dm_disc_mask & NFA_DM_DISC_MASK_LAA_NFC_DEP) {
-    disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE;
-    disc_params[num_params].frequency = 1;
-    num_params++;
+      if (num_params >= max_params) return num_params;
+    }
 
-    if (num_params >= max_params) return num_params;
-  }
+    /* Check listening F Active mode */
+    if (dm_disc_mask & NFA_DM_DISC_MASK_LFA_NFC_DEP) {
+      disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE;
+      disc_params[num_params].frequency = 1;
+      num_params++;
 
-  /* Check listening F Active mode */
-  if (dm_disc_mask & NFA_DM_DISC_MASK_LFA_NFC_DEP) {
-    disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE;
-    disc_params[num_params].frequency = 1;
-    num_params++;
-
-    if (num_params >= max_params) return num_params;
+      if (num_params >= max_params) return num_params;
+    }
   }
 
   /* Check polling ISO 15693 */
-  if (dm_disc_mask & NFA_DM_DISC_MASK_P_ISO15693) {
-    disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_ISO15693;
+  if (dm_disc_mask & NFA_DM_DISC_MASK_P_T5T) {
+    disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_V;
     disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pi93;
     num_params++;
 
@@ -623,16 +642,12 @@
       disc_mask = NFA_DM_DISC_MASK_PF_T3T;
     else if (protocol == NFC_PROTOCOL_NFC_DEP)
       disc_mask = NFA_DM_DISC_MASK_PF_NFC_DEP;
-  } else if (NFC_DISCOVERY_TYPE_POLL_ISO15693 == tech_n_mode) {
-    disc_mask = NFA_DM_DISC_MASK_P_ISO15693;
+  } else if (NFC_DISCOVERY_TYPE_POLL_V == tech_n_mode) {
+    disc_mask = NFA_DM_DISC_MASK_P_T5T;
   } else if (NFC_DISCOVERY_TYPE_POLL_B_PRIME == tech_n_mode) {
     disc_mask = NFA_DM_DISC_MASK_P_B_PRIME;
   } else if (NFC_DISCOVERY_TYPE_POLL_KOVIO == tech_n_mode) {
     disc_mask = NFA_DM_DISC_MASK_P_KOVIO;
-  } else if (NFC_DISCOVERY_TYPE_POLL_A_ACTIVE == tech_n_mode) {
-    disc_mask = NFA_DM_DISC_MASK_PAA_NFC_DEP;
-  } else if (NFC_DISCOVERY_TYPE_POLL_F_ACTIVE == tech_n_mode) {
-    disc_mask = NFA_DM_DISC_MASK_PFA_NFC_DEP;
   } else if (NFC_DISCOVERY_TYPE_LISTEN_A == tech_n_mode) {
     switch (protocol) {
       case NFC_PROTOCOL_T1T:
@@ -660,10 +675,23 @@
     disc_mask = NFA_DM_DISC_MASK_L_ISO15693;
   } else if (NFC_DISCOVERY_TYPE_LISTEN_B_PRIME == tech_n_mode) {
     disc_mask = NFA_DM_DISC_MASK_L_B_PRIME;
-  } else if (NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE == tech_n_mode) {
-    disc_mask = NFA_DM_DISC_MASK_LAA_NFC_DEP;
-  } else if (NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE == tech_n_mode) {
-    disc_mask = NFA_DM_DISC_MASK_LFA_NFC_DEP;
+  }
+  if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+    if (NFC_DISCOVERY_TYPE_POLL_ACTIVE == tech_n_mode) {
+      disc_mask = NFA_DM_DISC_MASK_PACM_NFC_DEP;
+    } else if (NFC_DISCOVERY_TYPE_LISTEN_ACTIVE == tech_n_mode) {
+      disc_mask = NFA_DM_DISC_MASK_LACM_NFC_DEP;
+    }
+  } else {
+    if (NFC_DISCOVERY_TYPE_POLL_A_ACTIVE == tech_n_mode) {
+      disc_mask = NFA_DM_DISC_MASK_PAA_NFC_DEP;
+    } else if (NFC_DISCOVERY_TYPE_POLL_F_ACTIVE == tech_n_mode) {
+      disc_mask = NFA_DM_DISC_MASK_PFA_NFC_DEP;
+    } else if (NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE == tech_n_mode) {
+      disc_mask = NFA_DM_DISC_MASK_LAA_NFC_DEP;
+    } else if (NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE == tech_n_mode) {
+      disc_mask = NFA_DM_DISC_MASK_LFA_NFC_DEP;
+    }
   }
 
   NFA_TRACE_DEBUG3(
@@ -913,18 +941,28 @@
           listen_mask |=
               nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask &
               (NFA_DM_DISC_MASK_LA_T1T | NFA_DM_DISC_MASK_LA_T2T |
-               NFA_DM_DISC_MASK_LA_ISO_DEP | NFA_DM_DISC_MASK_LA_NFC_DEP |
-               NFA_DM_DISC_MASK_LAA_NFC_DEP);
+               NFA_DM_DISC_MASK_LA_ISO_DEP | NFA_DM_DISC_MASK_LA_NFC_DEP);
+          if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+            listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask &
+                           NFA_DM_DISC_MASK_LACM_NFC_DEP;
+          } else {
+            listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask &
+                           NFA_DM_DISC_MASK_LAA_NFC_DEP;
+          }
         } else {
           /* host can listen ISO-DEP based on AID routing */
           listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask &
                           NFA_DM_DISC_MASK_LA_ISO_DEP);
-
-          /* host can listen NFC-DEP based on protocol routing */
-          listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask &
-                          NFA_DM_DISC_MASK_LA_NFC_DEP);
-          listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask &
-                          NFA_DM_DISC_MASK_LAA_NFC_DEP);
+          if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+            listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask &
+                            NFA_DM_DISC_MASK_LACM_NFC_DEP);
+          } else {
+            /* host can listen NFC-DEP based on protocol routing */
+            listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask &
+                            NFA_DM_DISC_MASK_LA_NFC_DEP);
+            listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask &
+                            NFA_DM_DISC_MASK_LAA_NFC_DEP);
+          }
         }
 
         /* NFC-B */
@@ -936,9 +974,11 @@
         /* NFCC can support NFC-DEP and T3T listening based on NFCID routing
          * regardless of NFC-F tech routing */
         listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask &
-                       (NFA_DM_DISC_MASK_LF_T3T | NFA_DM_DISC_MASK_LF_NFC_DEP |
-                        NFA_DM_DISC_MASK_LFA_NFC_DEP);
-
+                       (NFA_DM_DISC_MASK_LF_T3T | NFA_DM_DISC_MASK_LF_NFC_DEP);
+        if (NFC_GetNCIVersion() != NCI_VERSION_2_0) {
+          listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask &
+                         NFA_DM_DISC_MASK_LFA_NFC_DEP;
+        }
         /* NFC-B Prime */
         if (nfa_dm_cb.disc_cb.entry[xx].host_id ==
             nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_BP]) {
@@ -972,10 +1012,18 @@
          * on AID routing */
 
         /* Check if other modules are listening NFC-DEP */
-        if (dm_disc_mask &
-            (NFA_DM_DISC_MASK_LA_NFC_DEP | NFA_DM_DISC_MASK_LAA_NFC_DEP)) {
-          listen_mask &=
-              ~(NFA_DM_DISC_MASK_LA_NFC_DEP | NFA_DM_DISC_MASK_LAA_NFC_DEP);
+        if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+          if (dm_disc_mask &
+              (NFA_DM_DISC_MASK_LA_NFC_DEP | NFA_DM_DISC_MASK_LACM_NFC_DEP)) {
+            listen_mask &=
+                ~(NFA_DM_DISC_MASK_LA_NFC_DEP | NFA_DM_DISC_MASK_LACM_NFC_DEP);
+          }
+        } else {
+          if (dm_disc_mask &
+              (NFA_DM_DISC_MASK_LA_NFC_DEP | NFA_DM_DISC_MASK_LAA_NFC_DEP)) {
+            listen_mask &=
+                ~(NFA_DM_DISC_MASK_LA_NFC_DEP | NFA_DM_DISC_MASK_LAA_NFC_DEP);
+          }
         }
 
         nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask =
@@ -1268,6 +1316,14 @@
     /* if any ISO-DEP or T3T listening even if host in LRT is not matched */
     xx = iso_dep_t3t__listen;
   }
+  if (protocol == NFC_PROTOCOL_NFC_DEP &&
+      (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE ||
+       tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE ||
+       tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_A)) {
+    if (appl_dta_mode_flag == 1 && tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_A) {
+      NFA_TRACE_DEBUG0("DTA Mode Enabled : NFC-A Passive Listen Mode");
+    }
+  }
 
   if (xx < NFA_DM_DISC_NUM_ENTRIES) {
     nfa_dm_cb.disc_cb.activated_tech_mode = tech_n_mode;
@@ -2101,6 +2157,15 @@
 
   switch (event) {
     case NFA_DM_RF_DEACTIVATE_CMD:
+      if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+        if ((nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_FRAME) &&
+            (p_data->deactivate_type == NFC_DEACTIVATE_TYPE_SLEEP)) {
+          /* NCI 2.0- DH is responsible for sending deactivation commands before
+           * RF_DEACTIVATE_CMD */
+          nfa_dm_send_tag_deselect_cmd(nfa_dm_cb.disc_cb.activated_protocol);
+        }
+      }
+
       if (nfa_dm_cb.disc_cb.activated_protocol == NCI_PROTOCOL_MIFARE) {
         nfa_dm_cb.disc_cb.deact_pending = true;
         nfa_dm_cb.disc_cb.pending_deact_type = p_data->deactivate_type;
@@ -2148,35 +2213,60 @@
         NFA_TRACE_DEBUG0("Rx deactivate NTF while waiting for deactivate RSP");
         break;
       }
-
-      sleep_wakeup_event = true;
-
-      nfa_dm_disc_notify_deactivation(NFA_DM_RF_DEACTIVATE_NTF,
-                                      &(p_data->nfc_discover));
-
-      if ((p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) ||
-          (p_data->nfc_discover.deactivate.type ==
-           NFC_DEACTIVATE_TYPE_SLEEP_AF)) {
-        nfa_dm_disc_new_state(NFA_DM_RFST_W4_HOST_SELECT);
-        if (old_sleep_wakeup_flag) {
-          sleep_wakeup_event_processed = true;
-          /* process pending deactivate request */
-          if (nfa_dm_cb.disc_cb.deact_pending) {
-            /* notify RW module that sleep wakeup is finished */
-            /* if deactivation is pending then deactivate  */
-            nfa_dm_disc_end_sleep_wakeup(NFC_STATUS_OK);
-
-            /* Notify NFA RW sub-systems because NFA_DM_RF_DEACTIVATE_RSP will
-             * not call this function */
-            nfa_rw_proc_disc_evt(NFA_DM_RF_DISC_DEACTIVATED_EVT, NULL, true);
-          } else {
-            /* Successfully went to sleep mode for sleep wakeup */
-            /* Now wake up the tag to complete the operation */
-            NFC_DiscoverySelect(nfa_dm_cb.disc_cb.activated_rf_disc_id,
-                                nfa_dm_cb.disc_cb.activated_protocol,
-                                nfa_dm_cb.disc_cb.activated_rf_interface);
-          }
+      if (p_data->nfc_discover.deactivate.reason !=
+          NFC_DEACTIVATE_REASON_DH_REQ_FAILED) {
+        sleep_wakeup_event = true;
+        nfa_dm_disc_notify_deactivation(NFA_DM_RF_DEACTIVATE_NTF,
+                                        &(p_data->nfc_discover));
         }
+        if ((p_data->nfc_discover.deactivate.type ==
+             NFC_DEACTIVATE_TYPE_SLEEP) ||
+            (p_data->nfc_discover.deactivate.type ==
+             NFC_DEACTIVATE_TYPE_SLEEP_AF)) {
+          if (p_data->nfc_discover.deactivate.reason !=
+              NFC_DEACTIVATE_REASON_DH_REQ_FAILED) {
+            /* count for number of times deactivate cmd sent */
+            nfa_dm_cb.deactivate_cmd_retry_count = 0;
+          }
+          nfa_dm_disc_new_state(NFA_DM_RFST_W4_HOST_SELECT);
+          if (old_sleep_wakeup_flag) {
+            sleep_wakeup_event_processed = true;
+            /* process pending deactivate request */
+            if (nfa_dm_cb.disc_cb.deact_pending) {
+              /* notify RW module that sleep wakeup is finished */
+              /* if deactivation is pending then deactivate  */
+              nfa_dm_disc_end_sleep_wakeup(NFC_STATUS_OK);
+
+              /* Notify NFA RW sub-systems because NFA_DM_RF_DEACTIVATE_RSP will
+               * not call this function */
+              nfa_rw_proc_disc_evt(NFA_DM_RF_DISC_DEACTIVATED_EVT, NULL, true);
+            } else {
+              /* Successfully went to sleep mode for sleep wakeup */
+              /* Now wake up the tag to complete the operation */
+              NFC_DiscoverySelect(nfa_dm_cb.disc_cb.activated_rf_disc_id,
+                                  nfa_dm_cb.disc_cb.activated_protocol,
+                                  nfa_dm_cb.disc_cb.activated_rf_interface);
+            }
+          }
+          if (p_data->nfc_discover.deactivate.reason ==
+              NFC_DEACTIVATE_REASON_DH_REQ_FAILED) {
+            /* in case deactivation is not sucessfull, NFCC shall send
+               RF_DEACTIVATE_NTF with DH Req failed due to error.
+               MW shall send deactivation cmd again for 3 three times. if
+               deactivation is not successfull 3 times also,
+               then MW shall send deacivate cmd with deactivate type is
+               discovery */
+            if (nfa_dm_cb.deactivate_cmd_retry_count == 3) {
+              if ((!old_sleep_wakeup_flag) ||
+                  (!nfa_dm_cb.disc_cb.deact_pending)) {
+                nfa_dm_send_deactivate_cmd(NFA_DEACTIVATE_TYPE_DISCOVERY);
+              }
+              nfa_dm_cb.deactivate_cmd_retry_count = 0;
+            } else {
+              nfa_dm_cb.deactivate_cmd_retry_count++;
+              nfa_dm_send_deactivate_cmd(p_data->nfc_discover.deactivate.type);
+            }
+          }
       } else if (p_data->nfc_discover.deactivate.type ==
                  NFC_DEACTIVATE_TYPE_IDLE) {
         nfa_dm_disc_new_state(NFA_DM_RFST_IDLE);
@@ -2550,9 +2640,19 @@
     poll_disc_mask |= NFA_DM_DISC_MASK_PA_NFC_DEP;
     poll_disc_mask |= NFA_DM_DISC_MASK_P_LEGACY;
   }
-  if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE) {
-    poll_disc_mask |= NFA_DM_DISC_MASK_PAA_NFC_DEP;
+  if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+    if (poll_tech_mask & NFA_TECHNOLOGY_MASK_ACTIVE) {
+      poll_disc_mask |= NFA_DM_DISC_MASK_PACM_NFC_DEP;
+    }
+  } else {
+    if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE) {
+      poll_disc_mask |= NFA_DM_DISC_MASK_PAA_NFC_DEP;
+    }
+    if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE) {
+      poll_disc_mask |= NFA_DM_DISC_MASK_PFA_NFC_DEP;
+    }
   }
+
   if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B) {
     poll_disc_mask |= NFA_DM_DISC_MASK_PB_ISO_DEP;
   }
@@ -2560,11 +2660,8 @@
     poll_disc_mask |= NFA_DM_DISC_MASK_PF_T3T;
     poll_disc_mask |= NFA_DM_DISC_MASK_PF_NFC_DEP;
   }
-  if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE) {
-    poll_disc_mask |= NFA_DM_DISC_MASK_PFA_NFC_DEP;
-  }
-  if (poll_tech_mask & NFA_TECHNOLOGY_MASK_ISO15693) {
-    poll_disc_mask |= NFA_DM_DISC_MASK_P_ISO15693;
+  if (poll_tech_mask & NFA_TECHNOLOGY_MASK_V) {
+    poll_disc_mask |= NFA_DM_DISC_MASK_P_T5T;
   }
   if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B_PRIME) {
     poll_disc_mask |= NFA_DM_DISC_MASK_P_B_PRIME;
@@ -2813,7 +2910,10 @@
         "returning from nfa_dm_p2p_prio_logic  Disable p2p_prio_logic");
     return true;
   }
-
+  if (appl_dta_mode_flag == 0x01) {
+    /*Disable the P2P Prio Logic when DTA is running*/
+    return TRUE;
+  }
   if (event == NCI_MSG_RF_DISCOVER &&
       p2p_prio_logic_data.timer_expired == true &&
       event_type == NFA_DM_P2P_PRIO_RSP) {
@@ -2975,3 +3075,40 @@
 void nfa_dm_p2p_prio_logic_cleanup() {
   memset(&p2p_prio_logic_data, 0x00, sizeof(nfa_dm_p2p_prio_logic_t));
 }
+
+/*******************************************************************************
+**
+** Function         nfa_dm_send_tag_deselect_cmd
+**
+** Description      Send command to send tag in sleep state
+**
+** Returns          void
+**
+*******************************************************************************/
+static void nfa_dm_send_tag_deselect_cmd(tNFA_NFC_PROTOCOL protocol) {
+  NFC_HDR* p_msg;
+  uint8_t* p;
+
+  NFA_TRACE_DEBUG0("nfa_dm_send_tag_deselect_cmd");
+  p_msg = (NFC_HDR*)GKI_getpoolbuf(NFC_RW_POOL_ID);
+
+  if (p_msg) {
+    if (protocol == NFC_PROTOCOL_ISO_DEP) {
+      /* send one byte of 0xc2 as as deselect command to Tag */
+      p_msg->len = 1;
+      p_msg->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE;
+      p = (uint8_t*)(p_msg + 1) + p_msg->offset;
+      *p = NFA_RW_TAG_DESELECT_CMD;
+    } else if (protocol == NFC_PROTOCOL_T2T) {
+      p_msg->len = NFA_RW_TAG_SLP_REQ_LEN;
+      p_msg->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE;
+      p = (uint8_t*)(p_msg + 1) + p_msg->offset;
+      memcpy((uint8_t*)(p_msg + 1) + p_msg->offset, NFA_RW_TAG_SLP_REQ,
+             p_msg->len);
+    } else {
+      GKI_freebuf(p_msg);
+      return;
+    }
+    NFC_SendData(NFC_RF_CONN_ID, p_msg);
+  }
+}
diff --git a/src/nfa/dm/nfa_dm_main.c b/src/nfa/dm/nfa_dm_main.c
index a8754f5..dbc51ba 100644
--- a/src/nfa/dm/nfa_dm_main.c
+++ b/src/nfa/dm/nfa_dm_main.c
@@ -72,7 +72,9 @@
     nfa_dm_ndef_dereg_hdlr,          /* NFA_DM_API_DEREG_NDEF_HDLR_EVT       */
     nfa_dm_act_reg_vsc,              /* NFA_DM_API_REG_VSC_EVT               */
     nfa_dm_act_send_vsc,             /* NFA_DM_API_SEND_VSC_EVT              */
-    nfa_dm_act_disable_timeout       /* NFA_DM_TIMEOUT_DISABLE_EVT           */
+    nfa_dm_act_disable_timeout,      /* NFA_DM_TIMEOUT_DISABLE_EVT           */
+    nfa_dm_set_power_sub_state,      /* NFA_DM_API_SET_POWER_SUB_STATE_EVT   */
+    nfa_dm_act_send_raw_vs           /* NFA_DM_API_SEND_RAW_VS_EVT           */
 };
 
 /*****************************************************************************
@@ -171,12 +173,12 @@
 **
 *******************************************************************************/
 bool nfa_dm_is_protocol_supported(tNFC_PROTOCOL protocol, uint8_t sel_res) {
-  return (
-      (protocol == NFC_PROTOCOL_T1T) ||
-      ((protocol == NFC_PROTOCOL_T2T) &&
-       (sel_res == NFC_SEL_RES_NFC_FORUM_T2T)) ||
-      (protocol == NFC_PROTOCOL_T3T) || (protocol == NFC_PROTOCOL_ISO_DEP) ||
-      (protocol == NFC_PROTOCOL_NFC_DEP) || (protocol == NFC_PROTOCOL_15693));
+  return ((protocol == NFC_PROTOCOL_T1T) ||
+          ((protocol == NFC_PROTOCOL_T2T) &&
+           (sel_res == NFC_SEL_RES_NFC_FORUM_T2T)) ||
+          (protocol == NFC_PROTOCOL_T3T) ||
+          (protocol == NFC_PROTOCOL_ISO_DEP) ||
+          (protocol == NFC_PROTOCOL_NFC_DEP) || (protocol == NFC_PROTOCOL_T5T));
 }
 /*******************************************************************************
 **
@@ -352,7 +354,7 @@
         if ((type >= NFC_PMID_LF_T3T_ID1) &&
             (type < NFC_PMID_LF_T3T_ID1 + NFA_CE_LISTEN_INFO_MAX)) {
           p_stored = nfa_dm_cb.params.lf_t3t_id[type - NFC_PMID_LF_T3T_ID1];
-          max_len = NCI_PARAM_LEN_LF_T3T_ID;
+          max_len = NCI_PARAM_LEN_LF_T3T_ID(NFC_GetNCIVersion());
         } else {
           /* we don't stored this config items */
           update = true;
@@ -368,11 +370,21 @@
           update = true;
         } else if (memcmp(p_value, p_stored, len)) {
           update = true;
+        } else if (appl_dta_mode_flag && app_init) {
+          /* In DTA mode, config update is forced so that length of config
+           * params (i.e update_len) is updated accordingly even for setconfig
+           * have only one tlv */
+          update = true;
         }
       } else if (len == max_len) /* fixed length */
       {
         if (memcmp(p_value, p_stored, len)) {
           update = true;
+        } else if (appl_dta_mode_flag && app_init) {
+          /* In DTA mode, config update is forced so that length of config
+           * params (i.e update_len) is updated accordingly even for setconfig
+           * have only one tlv */
+          update = true;
         }
       }
     }
@@ -395,9 +407,17 @@
 
   /* If any TVLs to update, or if the SetConfig was initiated by the
    * application, then send the SET_CONFIG command */
-  if (updated_len || app_init) {
+  if (((updated_len || app_init) &&
+       (appl_dta_mode_flag == 0x00 ||
+        (nfa_dm_cb.eDtaMode & 0x0F) == NFA_DTA_HCEF_MODE)) ||
+      (appl_dta_mode_flag && app_init)) {
     nfc_status = NFC_SetConfig(updated_len, p_tlv_list);
+
     if (nfc_status == NFC_STATUS_OK) {
+      if ((nfa_dm_cb.eDtaMode & 0x0F) == NFA_DTA_HCEF_MODE) {
+        nfa_dm_cb.eDtaMode &= ~NFA_DTA_HCEF_MODE;
+        nfa_dm_cb.eDtaMode |= NFA_DTA_DEFAULT_MODE;
+      }
       /* Keep track of whether we will need to notify NFA_DM_SET_CONFIG_EVT on
        * NFC_SET_CONFIG_REVT */
 
@@ -507,6 +527,9 @@
 
     case NFA_DM_TIMEOUT_DISABLE_EVT:
       return "NFA_DM_TIMEOUT_DISABLE_EVT";
+
+    case NFA_DM_API_SET_POWER_SUB_STATE_EVT:
+      return "NFA_DM_API_SET_POWER_SUB_STATE_EVT";
   }
 
   return "Unknown or Vendor Specific";
diff --git a/src/nfa/ee/nfa_ee_act.c b/src/nfa/ee/nfa_ee_act.c
index 53f9c39..3ae939d 100644
--- a/src/nfa/ee/nfa_ee_act.c
+++ b/src/nfa/ee/nfa_ee_act.c
@@ -52,6 +52,30 @@
 /* the following 2 tables convert the protocol mask in API and control block to
  * the command for NFCC */
 #define NFA_EE_NUM_PROTO 5
+
+static void add_route_tech_proto_tlv(uint8_t** pp, uint8_t tlv_type,
+                                     uint8_t nfcee_id, uint8_t pwr_cfg,
+                                     uint8_t tech_proto) {
+  *(*pp)++ = tlv_type;
+  *(*pp)++ = 3;
+  *(*pp)++ = nfcee_id;
+  *(*pp)++ = pwr_cfg;
+  *(*pp)++ = tech_proto;
+}
+
+static void add_route_aid_tlv(uint8_t** pp, uint8_t* pa, uint8_t nfcee_id,
+                              uint8_t pwr_cfg, uint8_t tag) {
+  pa++;                /* EMV tag */
+  uint8_t len = *pa++; /* aid_len */
+  *(*pp)++ = tag;
+  *(*pp)++ = len + 2;
+  *(*pp)++ = nfcee_id;
+  *(*pp)++ = pwr_cfg;
+  /* copy the AID */
+  memcpy(*pp, pa, len);
+  *pp += len;
+}
+
 const uint8_t nfa_ee_proto_mask_list[NFA_EE_NUM_PROTO] = {
     NFA_PROTOCOL_MASK_T1T, NFA_PROTOCOL_MASK_T2T, NFA_PROTOCOL_MASK_T3T,
     NFA_PROTOCOL_MASK_ISO_DEP, NFA_PROTOCOL_MASK_NFC_DEP};
@@ -62,6 +86,8 @@
 
 static void nfa_ee_report_discover_req_evt(void);
 static void nfa_ee_build_discover_req_evt(tNFA_EE_DISCOVER_REQ* p_evt_data);
+void nfa_ee_check_set_routing(uint16_t new_size, int* p_max_len, uint8_t* p,
+                              int* p_cur_offset);
 /*******************************************************************************
 **
 ** Function         nfa_ee_trace_aid
@@ -200,6 +226,144 @@
   return lmrt_size;
 }
 
+static void nfa_ee_add_tech_route_to_ecb(tNFA_EE_ECB* p_cb, uint8_t* pp,
+                                         uint8_t* p, uint8_t* ps,
+                                         int* p_cur_offset) {
+  uint8_t num_tlv = *ps;
+
+  /* add the Technology based routing */
+  for (int xx = 0; xx < NFA_EE_NUM_TECH; xx++) {
+    uint8_t power_cfg = 0;
+    if (p_cb->tech_switch_on & nfa_ee_tech_mask_list[xx])
+      power_cfg |= NCI_ROUTE_PWR_STATE_ON;
+    if (p_cb->tech_switch_off & nfa_ee_tech_mask_list[xx])
+      power_cfg |= NCI_ROUTE_PWR_STATE_SWITCH_OFF;
+    if (p_cb->tech_battery_off & nfa_ee_tech_mask_list[xx])
+      power_cfg |= NCI_ROUTE_PWR_STATE_BATT_OFF;
+    if (power_cfg) {
+      add_route_tech_proto_tlv(&pp, NFC_ROUTE_TAG_TECH, p_cb->nfcee_id,
+                               power_cfg, nfa_ee_tech_list[xx]);
+      num_tlv++;
+      if (power_cfg != NCI_ROUTE_PWR_STATE_ON)
+        nfa_ee_cb.ee_cfged |= NFA_EE_CFGED_OFF_ROUTING;
+    }
+  }
+
+  /* update the num_tlv and current offset */
+  uint8_t entry_size = (uint8_t)(pp - p);
+  *p_cur_offset += entry_size;
+  *ps = num_tlv;
+}
+
+static void nfa_ee_add_proto_route_to_ecb(tNFA_EE_ECB* p_cb, uint8_t* pp,
+                                          uint8_t* p, uint8_t* ps,
+                                          int* p_cur_offset) {
+  uint8_t num_tlv = *ps;
+
+  /* add the Protocol based routing */
+  for (int xx = 0; xx < NFA_EE_NUM_PROTO; xx++) {
+    uint8_t power_cfg = 0, proto_tag = 0;
+    if (p_cb->proto_switch_on & nfa_ee_proto_mask_list[xx])
+      power_cfg |= NCI_ROUTE_PWR_STATE_ON;
+    if (p_cb->proto_switch_off & nfa_ee_proto_mask_list[xx])
+      power_cfg |= NCI_ROUTE_PWR_STATE_SWITCH_OFF;
+    if (p_cb->proto_battery_off & nfa_ee_proto_mask_list[xx])
+      power_cfg |= NCI_ROUTE_PWR_STATE_BATT_OFF;
+    if (power_cfg) {
+      /* Applying Route Block for ISO DEP Protocol, so that AIDs
+       * which are not in the routing table can also be blocked */
+      if (nfa_ee_proto_mask_list[xx] == NFA_PROTOCOL_MASK_ISO_DEP) {
+        proto_tag = NFC_ROUTE_TAG_PROTO | nfa_ee_cb.route_block_control;
+
+        /* Enable screen on lock power state for ISO-DEP protocol to
+           enable HCE screen lock */
+        if (NFC_GetNCIVersion() == NCI_VERSION_2_0)
+          power_cfg |= NCI_ROUTE_PWR_STATE_SCREEN_ON_LOCK;
+      } else {
+        proto_tag = NFC_ROUTE_TAG_PROTO;
+      }
+
+      add_route_tech_proto_tlv(&pp, proto_tag, p_cb->nfcee_id, power_cfg,
+                               nfa_ee_proto_list[xx]);
+      num_tlv++;
+      if (power_cfg != NCI_ROUTE_PWR_STATE_ON)
+        nfa_ee_cb.ee_cfged |= NFA_EE_CFGED_OFF_ROUTING;
+    }
+  }
+
+  /* add NFC-DEP routing to HOST */
+  if (p_cb->nfcee_id == NFC_DH_ID) {
+    add_route_tech_proto_tlv(&pp, NFC_ROUTE_TAG_PROTO, NFC_DH_ID,
+                             NCI_ROUTE_PWR_STATE_ON, NFC_PROTOCOL_NFC_DEP);
+
+    num_tlv++;
+    NFA_TRACE_DEBUG1("%s - NFC DEP added for DH!!!", __func__);
+  }
+  /* update the num_tlv and current offset */
+  uint8_t entry_size = (uint8_t)(pp - p);
+  *p_cur_offset += entry_size;
+  *ps = num_tlv;
+}
+
+static void nfa_ee_add_aid_route_to_ecb(tNFA_EE_ECB* p_cb, uint8_t* pp,
+                                        uint8_t* p, uint8_t* ps,
+                                        int* p_cur_offset, int* p_max_len) {
+  uint8_t num_tlv = *ps;
+
+  /* add the AID routing */
+  if (p_cb->aid_entries) {
+    int start_offset = 0;
+    for (int xx = 0; xx < p_cb->aid_entries; xx++) {
+      /* remember the beginning of this AID routing entry, just in case we
+       * need to put it in next command */
+      uint8_t route_qual = 0;
+      uint8_t* p_start = pp;
+      /* add one AID entry */
+      if (p_cb->aid_rt_info[xx] & NFA_EE_AE_ROUTE) {
+        num_tlv++;
+        uint8_t* pa = &p_cb->aid_cfg[start_offset];
+
+        NFA_TRACE_DEBUG2("%s -  p_cb->aid_info%x", __func__,
+                         p_cb->aid_info[xx]);
+        if (p_cb->aid_info[xx] & NCI_ROUTE_QUAL_LONG_SELECT) {
+          NFA_TRACE_DEBUG2("%s - %x", __func__,
+                           p_cb->aid_info[xx] & NCI_ROUTE_QUAL_LONG_SELECT);
+          route_qual |= NCI_ROUTE_QUAL_LONG_SELECT;
+        }
+        if (p_cb->aid_info[xx] & NCI_ROUTE_QUAL_SHORT_SELECT) {
+          NFA_TRACE_DEBUG2("%s - %x", __func__,
+                           p_cb->aid_info[xx] & NCI_ROUTE_QUAL_SHORT_SELECT);
+          route_qual |= NCI_ROUTE_QUAL_SHORT_SELECT;
+        }
+
+        uint8_t tag =
+            NFC_ROUTE_TAG_AID | nfa_ee_cb.route_block_control | route_qual;
+
+        add_route_aid_tlv(&pp, pa, p_cb->nfcee_id, p_cb->aid_pwr_cfg[xx], tag);
+      }
+      start_offset += p_cb->aid_len[xx];
+      uint8_t new_size = (uint8_t)(pp - p_start);
+      nfa_ee_check_set_routing(new_size, p_max_len, ps, p_cur_offset);
+      if (*ps == 0) {
+        /* just sent routing command, update local */
+        *ps = 1;
+        num_tlv = *ps;
+        *p_cur_offset = new_size;
+        pp = ps + 1;
+        p = pp;
+        memcpy(p, p_start, new_size);
+        pp += new_size;
+      } else {
+        /* add the new entry */
+        *ps = num_tlv;
+        *p_cur_offset += new_size;
+      }
+    }
+  } else {
+    NFA_TRACE_DEBUG1("%s - No AID entries available", __func__);
+  }
+}
+
 /*******************************************************************************
 **
 ** Function         nfa_ee_conn_cback
@@ -587,6 +751,7 @@
         "nfa_ee_api_add_aid The AID entry is already in the database");
     if (p_chk_cb == p_cb) {
       p_cb->aid_rt_info[entry] |= NFA_EE_AE_ROUTE;
+      p_cb->aid_info[entry] = p_add->aidInfo;
       new_size = nfa_ee_total_lmrt_size();
       if (new_size > NFC_GetLmrtSize()) {
         NFA_TRACE_ERROR1("Exceed LMRT size:%d (add ROUTE)", new_size);
@@ -624,6 +789,7 @@
       } else {
         /* add AID */
         p_cb->aid_pwr_cfg[p_cb->aid_entries] = p_add->power_state;
+        p_cb->aid_info[p_cb->aid_entries] = p_add->aidInfo;
         p_cb->aid_rt_info[p_cb->aid_entries] = NFA_EE_AE_ROUTE;
         p = p_cb->aid_cfg + len;
         p_start = p;
@@ -1896,6 +2062,84 @@
 
   return status;
 }
+/*******************************************************************************
+**
+** Function         nfa_ee_route_add_one_ecb_order
+**
+** Description      Add the routing entries for NFCEE/DH in order defined
+**
+** Returns          NFA_STATUS_OK, if ok to continue
+**
+*******************************************************************************/
+void nfa_ee_route_add_one_ecb_by_route_order(tNFA_EE_ECB* p_cb, int rout_type,
+                                             int* p_max_len, bool more,
+                                             uint8_t* ps, int* p_cur_offset) {
+  nfa_ee_check_set_routing(p_cb->size_mask, p_max_len, ps, p_cur_offset);
+
+  /* use the first byte of the buffer (ps) to keep the num_tlv */
+  uint8_t num_tlv = *ps;
+  NFA_TRACE_DEBUG6(
+      "%s - max_len:%d, cur_offset:%d, more:%d, num_tlv:%d,rout_type:- %d",
+      __func__, *p_max_len, *p_cur_offset, more, num_tlv, rout_type);
+  uint8_t* pp = ps + 1 + *p_cur_offset;
+  uint8_t* p = pp;
+  uint16_t tlv_size = (uint8_t)*p_cur_offset;
+
+  switch (rout_type) {
+    case NCI_ROUTE_ORDER_TECHNOLOGY: {
+      nfa_ee_add_tech_route_to_ecb(p_cb, pp, p, ps, p_cur_offset);
+    } break;
+
+    case NCI_ROUTE_ORDER_PROTOCOL: {
+      nfa_ee_add_proto_route_to_ecb(p_cb, pp, p, ps, p_cur_offset);
+    } break;
+    case NCI_ROUTE_ORDER_AID: {
+      nfa_ee_add_aid_route_to_ecb(p_cb, pp, p, ps, p_cur_offset, p_max_len);
+    } break;
+    default: {
+      NFA_TRACE_DEBUG2("%s -  Route type - NA:- %d", __func__, rout_type);
+    }
+  }
+
+  /* update the total number of entries */
+  num_tlv = *ps;
+
+  tlv_size = nfa_ee_total_lmrt_size();
+  if (tlv_size) {
+    nfa_ee_cb.ee_cfged |= nfa_ee_ecb_to_mask(p_cb);
+  }
+  if (p_cb->ecb_flags & NFA_EE_ECB_FLAGS_ROUTING) {
+    nfa_ee_cb.ee_cfg_sts |= NFA_EE_STS_CHANGED_ROUTING;
+  }
+  NFA_TRACE_DEBUG2("ee_cfg_sts:0x%02x lmrt_size:%d", nfa_ee_cb.ee_cfg_sts,
+                   tlv_size);
+
+  if (more == false) {
+    /* last entry. update routing table now */
+    if (nfa_ee_cb.ee_cfg_sts & NFA_EE_STS_CHANGED_ROUTING) {
+      if (tlv_size) {
+        nfa_ee_cb.ee_cfg_sts |= NFA_EE_STS_PREV_ROUTING;
+      } else {
+        nfa_ee_cb.ee_cfg_sts &= ~NFA_EE_STS_PREV_ROUTING;
+      }
+      NFA_TRACE_DEBUG3("%s : set routing num_tlv:%d tlv_size:%d", __func__,
+                       num_tlv, tlv_size);
+      if (NFC_SetRouting(more, num_tlv, (uint8_t)(*p_cur_offset), ps + 1) ==
+          NFA_STATUS_OK) {
+        nfa_ee_cb.wait_rsp++;
+      }
+    } else if (nfa_ee_cb.ee_cfg_sts & NFA_EE_STS_PREV_ROUTING) {
+      if (tlv_size == 0) {
+        nfa_ee_cb.ee_cfg_sts &= ~NFA_EE_STS_PREV_ROUTING;
+        /* indicated routing is configured to NFCC */
+        nfa_ee_cb.ee_cfg_sts |= NFA_EE_STS_CHANGED_ROUTING;
+        if (NFC_SetRouting(more, 0, 0, ps + 1) == NFA_STATUS_OK) {
+          nfa_ee_cb.wait_rsp++;
+        }
+      }
+    }
+  }
+}
 
 /*******************************************************************************
 **
@@ -2020,8 +2264,9 @@
   tNFA_EE_ECB* p_cb;
   uint8_t* p = NULL;
   bool more = true;
+  bool check = true;
   uint8_t last_active = NFA_EE_INVALID;
-  int max_len, len;
+  int max_len;
   tNFA_STATUS status = NFA_STATUS_FAILED;
   int cur_offset;
   uint8_t max_tlv;
@@ -2046,11 +2291,9 @@
     }
   }
   if (last_active == NFA_EE_INVALID) {
-    more = false;
+    check = false;
   }
 
-  /* add the routing for DH first */
-  status = NFA_STATUS_OK;
   max_len = NFC_GetLmrtSize();
   max_tlv =
       (uint8_t)((max_len > NFA_EE_ROUT_MAX_TLV_SIZE) ? NFA_EE_ROUT_MAX_TLV_SIZE
@@ -2058,30 +2301,23 @@
   cur_offset = 0;
   /* use the first byte of the buffer (p) to keep the num_tlv */
   *p = 0;
-  status = nfa_ee_route_add_one_ecb(&nfa_ee_cb.ecb[NFA_EE_CB_4_DH], &max_len,
-                                    more, p, &cur_offset);
-
-  /* add only what is supported by NFCC. report overflow */
-  if (status == NFA_STATUS_OK) {
-    /* add the routing for NFCEEs */
+  for (int rt = NCI_ROUTE_ORDER_AID; rt <= NCI_ROUTE_ORDER_TECHNOLOGY; rt++) {
+    /* add the routing entries for NFCEEs */
     p_cb = &nfa_ee_cb.ecb[0];
-    for (xx = 0; (xx < nfa_ee_cb.cur_ee) && more; xx++, p_cb++) {
-      len = 0;
+    for (xx = 0; (xx < nfa_ee_cb.cur_ee) && check; xx++, p_cb++) {
       if (p_cb->ee_status == NFC_NFCEE_STATUS_ACTIVE) {
-        NFA_TRACE_DEBUG2("nfcee_id:0x%x, last_active: 0x%x", p_cb->nfcee_id,
-                         last_active);
-        if (last_active == p_cb->nfcee_id) more = false;
-        status = nfa_ee_route_add_one_ecb(p_cb, &max_len, more, p, &cur_offset);
-        if (status != NFA_STATUS_OK) {
-          more = false;
-        }
+        NFA_TRACE_DEBUG1("%s --add the routing for NFCEEs!!", __func__);
+        nfa_ee_route_add_one_ecb_by_route_order(p_cb, rt, &max_len, more, p,
+                                                &cur_offset);
       }
     }
+    if (rt == NCI_ROUTE_ORDER_TECHNOLOGY) more = false;
+    /* add the routing entries for DH */
+    NFA_TRACE_DEBUG1("%s --add the routing for DH!!", __func__);
+    nfa_ee_route_add_one_ecb_by_route_order(&nfa_ee_cb.ecb[NFA_EE_CB_4_DH], rt,
+                                            &max_len, more, p, &cur_offset);
   }
-  if (status != NFA_STATUS_OK) {
-    nfa_ee_report_event(NULL, NFA_EE_ROUT_ERR_EVT,
-                        (tNFA_EE_CBACK_DATA*)&status);
-  }
+
   GKI_freebuf(p);
 }
 
diff --git a/src/nfa/ee/nfa_ee_api.c b/src/nfa/ee/nfa_ee_api.c
index f7f09ff..a1290b7 100644
--- a/src/nfa/ee/nfa_ee_api.c
+++ b/src/nfa/ee/nfa_ee_api.c
@@ -396,7 +396,8 @@
 **
 *******************************************************************************/
 tNFA_STATUS NFA_EeAddAidRouting(tNFA_HANDLE ee_handle, uint8_t aid_len,
-                                uint8_t* p_aid, tNFA_EE_PWR_STATE power_state) {
+                                uint8_t* p_aid, tNFA_EE_PWR_STATE power_state,
+                                uint8_t aidInfo) {
   tNFA_EE_API_ADD_AID* p_msg;
   tNFA_STATUS status = NFA_STATUS_FAILED;
   uint16_t size = sizeof(tNFA_EE_API_ADD_AID) + aid_len;
@@ -421,6 +422,7 @@
       p_msg->aid_len = aid_len;
       p_msg->power_state = power_state;
       p_msg->p_aid = (uint8_t*)(p_msg + 1);
+      p_msg->aidInfo = aidInfo;
       memcpy(p_msg->p_aid, p_aid, aid_len);
 
       nfa_sys_sendmsg(p_msg);
diff --git a/src/nfa/ee/nfa_ee_main.c b/src/nfa/ee/nfa_ee_main.c
index fcf2bb6..b3e957d 100644
--- a/src/nfa/ee/nfa_ee_main.c
+++ b/src/nfa/ee/nfa_ee_main.c
@@ -22,6 +22,7 @@
  *
  ******************************************************************************/
 #include <string.h>
+#include "config.h"
 #include "nfa_dm_int.h"
 #include "nfa_ee_int.h"
 #include "nfa_sys.h"
@@ -112,6 +113,20 @@
 **
 *******************************************************************************/
 void nfa_ee_sys_enable(void) {
+  unsigned long retlen = 0;
+
+  NFA_TRACE_DEBUG1("%s", __func__);
+
+  nfa_ee_cb.route_block_control = 0x00;
+
+  if (GetNumValue(NAME_NFA_AID_BLOCK_ROUTE, (void*)&retlen, sizeof(retlen))) {
+    if ((retlen == 0x01) && (NFC_GetNCIVersion() == NCI_VERSION_2_0)) {
+      nfa_ee_cb.route_block_control = NCI_ROUTE_QUAL_BLOCK_ROUTE;
+      NFA_TRACE_DEBUG1("nfa_ee_cb.route_block_control=0x%x",
+                       nfa_ee_cb.route_block_control);
+    }
+  }
+
   if (nfa_ee_max_ee_cfg) {
     /* collect NFCEE information */
     NFC_NfceeDiscover(true);
diff --git a/src/nfa/include/nfa_api.h b/src/nfa/include/nfa_api.h
index 4d83841..3467fdb 100644
--- a/src/nfa/include/nfa_api.h
+++ b/src/nfa/include/nfa_api.h
@@ -146,9 +146,12 @@
 #define NFA_TECHNOLOGY_MASK_A 0x01        /* NFC Technology A             */
 #define NFA_TECHNOLOGY_MASK_B 0x02        /* NFC Technology B             */
 #define NFA_TECHNOLOGY_MASK_F 0x04        /* NFC Technology F             */
-#define NFA_TECHNOLOGY_MASK_ISO15693 0x08 /* Proprietary Technology       */
+/* TECHNOLOGY_MASK_V in NCI2.0 and TECHNOLOGY_MASK_15693 proprietary in NCI1.0*/
+#define NFA_TECHNOLOGY_MASK_V 0x08
 #define NFA_TECHNOLOGY_MASK_B_PRIME 0x10  /* Proprietary Technology       */
 #define NFA_TECHNOLOGY_MASK_KOVIO 0x20    /* Proprietary Technology       */
+/* NFC technology NFC-DEP protocol active mode */
+#define NFA_TECHNOLOGY_MASK_ACTIVE 0x40
 /* NFC Technology A active mode */
 #define NFA_TECHNOLOGY_MASK_A_ACTIVE 0x40
 /* NFC Technology F active mode */
@@ -168,7 +171,8 @@
 #define NFA_PROTOCOL_ISO_DEP NFC_PROTOCOL_ISO_DEP
 /* NFCDEP/LLCP - NFC-A or NFC-F */
 #define NFA_PROTOCOL_NFC_DEP NFC_PROTOCOL_NFC_DEP
-#define NFA_PROTOCOL_ISO15693 NFC_PROTOCOL_15693
+/* NFC_PROTOCOL_T5T in NCI2.0 and NFC_PROTOCOL_ISO15693 proprietary in NCI1.0*/
+#define NFA_PROTOCOL_T5T NFC_PROTOCOL_T5T
 #define NFA_PROTOCOL_B_PRIME NFC_PROTOCOL_B_PRIME
 #define NFA_PROTOCOL_KOVIO NFC_PROTOCOL_KOVIO
 #define NFA_PROTOCOL_MIFARE NFC_PROTOCOL_MIFARE
@@ -200,7 +204,8 @@
 #define NFA_DM_NFCC_TIMEOUT_EVT 6
 /* NCI Tranport error               */
 #define NFA_DM_NFCC_TRANSPORT_ERR_EVT 7
-
+/* Result of NFA_SetPowerSubStateForScreenState */
+#define NFA_DM_SET_POWER_SUB_STATE_EVT 11
 /* T1T HR length            */
 #define NFA_T1T_HR_LEN T1T_HR_LEN
 /* Max UID length of T1/T2  */
@@ -245,6 +250,29 @@
   uint8_t param_tlvs[1]; /* TLV (Parameter ID-Len-Value byte stream) */
 } tNFA_GET_CONFIG;
 
+/* Structure to store screen state */
+typedef enum screen_state {
+  NFA_SCREEN_STATE_UNKNOWN = 0x00,
+  NFA_SCREEN_STATE_OFF_UNLOCKED = 0x01,
+  NFA_SCREEN_STATE_OFF_LOCKED = 0x02,
+  NFA_SCREEN_STATE_ON_LOCKED = 0x04,
+  NFA_SCREEN_STATE_ON_UNLOCKED = 0x08
+} eScreenState_t;
+
+typedef enum power_substate {
+  SCREEN_STATE_ON_UNLOCKED = 0x00,
+  SCREEN_STATE_OFF_UNLOCKED,
+  SCREEN_STATE_ON_LOCKED,
+  SCREEN_STATE_OFF_LOCKED,
+} epower_substate_t;
+
+#define NFA_SCREEN_STATE_MASK 0x0F
+
+/* CONN_DISCOVER_PARAM */
+#define NFA_LISTEN_DH_NFCEE_ENABLE_MASK NCI_LISTEN_DH_NFCEE_ENABLE_MASK
+#define NFA_LISTEN_DH_NFCEE_DISABLE_MASK NCI_LISTEN_DH_NFCEE_DISABLE_MASK
+#define NFA_POLLING_DH_DISABLE_MASK NCI_POLLING_DH_DISABLE_MASK
+#define NFA_POLLING_DH_ENABLE_MASK NCI_POLLING_DH_ENABLE_MASK
 #define NFA_DM_PWR_MODE_FULL 0x04
 #define NFA_DM_PWR_MODE_OFF_SLEEP 0x00
 
@@ -267,6 +295,11 @@
   uint8_t rf_field_status;
 } tNFA_DM_RF_FIELD;
 
+typedef struct {
+  tNFA_STATUS status;  /* NFA_STATUS_OK if successful  */
+  uint8_t power_state; /* current screen/power state */
+} tNFA_DM_POWER_STATE;
+
 /* Union of all DM callback structures */
 typedef union {
   tNFA_STATUS status;                 /* NFA_DM_ENABLE_EVT        */
@@ -275,11 +308,25 @@
   tNFA_DM_PWR_MODE_CHANGE power_mode; /* NFA_DM_PWR_MODE_CHANGE_EVT   */
   tNFA_DM_RF_FIELD rf_field;          /* NFA_DM_RF_FIELD_EVT      */
   void* p_vs_evt_data;                /* Vendor-specific evt data */
+  tNFA_DM_POWER_STATE power_sub_state; /* power sub state */
 } tNFA_DM_CBACK_DATA;
 
 /* NFA_DM callback */
 typedef void(tNFA_DM_CBACK)(uint8_t event, tNFA_DM_CBACK_DATA* p_data);
 
+/* NFA Enable DTA Type Mode */
+typedef enum {
+  NFA_DTA_DEFAULT_MODE = 0x00000001,
+  NFA_DTA_LLCP_MODE = 0x00000002,
+  NFA_DTA_SNEP_MODE = 0x00000003,
+  NFA_DTA_HCEF_MODE = 0x00000004,
+  NFA_DTA_CR8 = 0x00000080,
+  NFA_DTA_CR9 = 0x00000090,
+  NFA_DTA_CR10 = 0x000000A0,
+  NFA_DTA_CR11 = 0x000000B0,
+  NFA_DTA_CR12 = 0x000000C0,
+} tNFA_eDtaModes;
+
 /* NFA Connection Callback Events */
 #define NFA_POLL_ENABLED_EVT 0  /* Polling enabled event */
 #define NFA_POLL_DISABLED_EVT 1 /* Polling disabled event */
@@ -570,6 +617,7 @@
   uint8_t pk;   /* Frequency for Proprietary Technology/Kovio   */
   uint8_t paa;  /* Frequency for NFC Technology A active mode   */
   uint8_t pfa;  /* Frequency for NFC Technology F active mode   */
+  uint8_t pacm; /* Frequency for NFC Technology active mode     */
 } tNFA_DM_DISC_FREQ_CFG;
 
 /* definitions for tNFA_DM_CFG.presence_check_option */
@@ -1350,6 +1398,27 @@
 
 /*******************************************************************************
 **
+** Function         NFA_SendRawVsCommand
+**
+** Description      This function is called to send raw vendor specific
+**                  command to NFCC.
+**
+**                  cmd_params_len  - The command parameter len
+**                  p_cmd_params    - The command parameter
+**                  p_cback         - The callback function to receive the
+**                                    command
+**
+** Returns          NFA_STATUS_OK if successfully initiated
+**                  NFA_STATUS_FAILED otherwise
+**
+*******************************************************************************/
+
+extern tNFA_STATUS NFA_SendRawVsCommand(uint8_t cmd_params_len,
+                                        uint8_t* p_cmd_params,
+                                        tNFA_VSC_CBACK* p_cback);
+
+/*******************************************************************************
+**
 ** Function         NFA_SetTraceLevel
 **
 ** Description      This function sets the trace level for NFA.  If called with
@@ -1360,6 +1429,27 @@
 *******************************************************************************/
 extern uint8_t NFA_SetTraceLevel(uint8_t new_level);
 
+/*******************************************************************************
+**
+** Function:        NFA_EnableDTA_TypeMode
+**
+** Description:     Initialize and get global DTA type mode from .conf
+**
+** Returns:         none:
+**
+*******************************************************************************/
+extern void NFA_EnableDtamode(tNFA_eDtaModes eDtaMode);
+
+/*******************************************************************************
+** Function:        NFA_SetPowerSubStateForScreenState
+**
+** Description:     This function send the current screen state
+**
+** Returns:        NFA_STATUS_OK if successfully initiated
+**                  NFA_STATUS_FAILED otherwise
+*******************************************************************************/
+extern tNFA_STATUS NFA_SetPowerSubStateForScreenState(uint8_t ScreenState);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/nfa/include/nfa_ce_api.h b/src/nfa/include/nfa_ce_api.h
index e94daad..8acff20 100644
--- a/src/nfa/include/nfa_ce_api.h
+++ b/src/nfa/include/nfa_ce_api.h
@@ -133,7 +133,7 @@
 *******************************************************************************/
 extern tNFA_STATUS NFA_CeRegisterFelicaSystemCodeOnDH(
     uint16_t system_code, uint8_t nfcid2[NCI_RF_F_UID_LEN],
-    tNFA_CONN_CBACK* p_conn_cback);
+    uint8_t t3tPmm[NCI_T3T_PMM_LEN], tNFA_CONN_CBACK* p_conn_cback);
 
 /*******************************************************************************
 **
diff --git a/src/nfa/include/nfa_ee_api.h b/src/nfa/include/nfa_ee_api.h
index 2411b10..f4acbe0 100644
--- a/src/nfa/include/nfa_ee_api.h
+++ b/src/nfa/include/nfa_ee_api.h
@@ -385,7 +385,8 @@
 *******************************************************************************/
 extern tNFA_STATUS NFA_EeAddAidRouting(tNFA_HANDLE ee_handle, uint8_t aid_len,
                                        uint8_t* p_aid,
-                                       tNFA_EE_PWR_STATE power_state);
+                                       tNFA_EE_PWR_STATE power_state,
+                                       uint8_t aidInfo);
 
 /*******************************************************************************
 **
diff --git a/src/nfa/include/nfa_rw_api.h b/src/nfa/include/nfa_rw_api.h
index 17bbcc5..f4eaded 100644
--- a/src/nfa/include/nfa_rw_api.h
+++ b/src/nfa/include/nfa_rw_api.h
@@ -31,11 +31,13 @@
 **  Constants and data types
 *****************************************************************************/
 enum {
-  NFA_RW_PRES_CHK_DEFAULT, /* The default behavior             */
-  NFA_RW_PRES_CHK_I_BLOCK, /* Empty I Block                    */
-  NFA_RW_PRES_CHK_RESET,   /* Deactivate to Sleep; Re-activate */
-  NFA_RW_PRES_CHK_RB_CH0,  /* ReadBinary on Channel 0          */
-  NFA_RW_PRES_CHK_RB_CH3   /* ReadBinary on Channel 3          */
+  NFA_RW_PRES_CHK_DEFAULT,    /* The default behavior             */
+  NFA_RW_PRES_CHK_I_BLOCK,    /* Empty I Block                    */
+  NFA_RW_PRES_CHK_RESET,      /* Deactivate to Sleep; Re-activate */
+  NFA_RW_PRES_CHK_RB_CH0,     /* ReadBinary on Channel 0          */
+  NFA_RW_PRES_CHK_RB_CH3,     /* ReadBinary on Channel 3          */
+  NFA_RW_PRES_CHK_ISO_DEP_NAK /* presence check command ISO-DEP
+                                 NAK as per NCI2.0                */
 };
 typedef uint8_t tNFA_RW_PRES_CHK_OPTION;
 
diff --git a/src/nfa/int/nfa_ce_int.h b/src/nfa/int/nfa_ce_int.h
index fb70ee8..ef41242 100644
--- a/src/nfa/int/nfa_ce_int.h
+++ b/src/nfa/int/nfa_ce_int.h
@@ -87,6 +87,7 @@
   /* For registering Felica */
   uint16_t system_code;
   uint8_t nfcid2[NCI_RF_F_UID_LEN];
+  uint8_t t3tPmm[NCI_T3T_PMM_LEN];
 
   /* For registering Type-4 */
   uint8_t aid[NFC_MAX_AID_LEN]; /* AID to listen for (For type-4 only)  */
@@ -147,6 +148,7 @@
 
   /* For host tag emulation (NFA_CeRegisterVirtualT4tSE and
    * NFA_CeRegisterT4tAidOnDH) */
+  uint8_t t3t_pmm[NCI_T3T_PMM_LEN];
   uint8_t t3t_nfcid2[NCI_RF_F_UID_LEN];
   uint16_t t3t_system_code; /* Type-3 system code */
   uint8_t
@@ -198,6 +200,8 @@
 /* type definition for action functions */
 typedef bool (*tNFA_CE_ACTION)(tNFA_CE_MSG* p_data);
 
+extern uint8_t NFC_GetNCIVersion();
+
 /* Action function prototypes */
 bool nfa_ce_api_cfg_local_tag(tNFA_CE_MSG* p_ce_msg);
 bool nfa_ce_api_reg_listen(tNFA_CE_MSG* p_ce_msg);
diff --git a/src/nfa/int/nfa_dm_int.h b/src/nfa/int/nfa_dm_int.h
index 8c2c77d..a527927 100644
--- a/src/nfa/int/nfa_dm_int.h
+++ b/src/nfa/int/nfa_dm_int.h
@@ -61,6 +61,8 @@
   NFA_DM_API_REG_VSC_EVT,
   NFA_DM_API_SEND_VSC_EVT,
   NFA_DM_TIMEOUT_DISABLE_EVT,
+  NFA_DM_API_SET_POWER_SUB_STATE_EVT,
+  NFA_DM_API_SEND_RAW_VS_EVT,
   NFA_DM_MAX_EVT
 };
 
@@ -182,6 +184,12 @@
   uint8_t* p_cmd_params;
 } tNFA_DM_API_SEND_VSC;
 
+/* data type for NFA_DM_API_SET_POWER_SUB_STATE_EVT */
+typedef struct {
+  NFC_HDR hdr;
+  uint8_t screen_state;
+} tNFA_DM_API_SET_POWER_SUB_STATE;
+
 /* union of all data types */
 typedef union {
   /* GKI event buffer header */
@@ -211,6 +219,8 @@
   tNFA_DM_API_DEACTIVATE deactivate; /* NFA_DM_API_DEACTIVATE_EVT            */
   tNFA_DM_API_SEND_VSC send_vsc;     /* NFA_DM_API_SEND_VSC_EVT              */
   tNFA_DM_API_REG_VSC reg_vsc;       /* NFA_DM_API_REG_VSC_EVT               */
+  /* NFA_DM_API_SET_POWER_SUB_STATE_EVT */
+  tNFA_DM_API_SET_POWER_SUB_STATE set_power_state;
 } tNFA_DM_MSG;
 
 /* DM RF discovery state */
@@ -275,10 +285,11 @@
 #define NFA_DM_DISC_MASK_PB_ISO_DEP 0x00000010
 #define NFA_DM_DISC_MASK_PF_T3T 0x00000020
 #define NFA_DM_DISC_MASK_PF_NFC_DEP 0x00000040
-#define NFA_DM_DISC_MASK_P_ISO15693 0x00000100
+#define NFA_DM_DISC_MASK_P_T5T 0x00000100
 #define NFA_DM_DISC_MASK_P_B_PRIME 0x00000200
 #define NFA_DM_DISC_MASK_P_KOVIO 0x00000400
 #define NFA_DM_DISC_MASK_PAA_NFC_DEP 0x00000800
+#define NFA_DM_DISC_MASK_PACM_NFC_DEP 0x00000800
 #define NFA_DM_DISC_MASK_PFA_NFC_DEP 0x00001000
 /* Legacy/proprietary/non-NFC Forum protocol (e.g Shanghai transit card) */
 #define NFA_DM_DISC_MASK_P_LEGACY 0x00002000
@@ -293,6 +304,7 @@
 #define NFA_DM_DISC_MASK_LF_NFC_DEP 0x00400000
 #define NFA_DM_DISC_MASK_L_ISO15693 0x01000000
 #define NFA_DM_DISC_MASK_L_B_PRIME 0x02000000
+#define NFA_DM_DISC_MASK_LACM_NFC_DEP 0x04000000
 #define NFA_DM_DISC_MASK_LAA_NFC_DEP 0x04000000
 #define NFA_DM_DISC_MASK_LFA_NFC_DEP 0x08000000
 #define NFA_DM_DISC_MASK_L_LEGACY 0x10000000
@@ -467,7 +479,8 @@
   uint8_t lf_t3t_flags2[NCI_PARAM_LEN_LF_T3T_FLAGS2];
   uint8_t lf_t3t_flags2_len;
   uint8_t lf_t3t_pmm[NCI_PARAM_LEN_LF_T3T_PMM];
-  uint8_t lf_t3t_id[NFA_CE_LISTEN_INFO_MAX][NCI_PARAM_LEN_LF_T3T_ID];
+  uint8_t lf_t3t_id[NFA_CE_LISTEN_INFO_MAX]
+                   [NCI_PARAM_LEN_LF_T3T_ID(NCI_VERSION_2_0)];
 
   uint8_t fwi[NCI_PARAM_LEN_FWI];
   uint8_t wt[NCI_PARAM_LEN_WT];
@@ -530,6 +543,12 @@
 
   /* NFCC power mode */
   uint8_t nfcc_pwr_mode; /* NFA_DM_PWR_MODE_FULL or NFA_DM_PWR_MODE_OFF_SLEEP */
+
+  uint8_t deactivate_cmd_retry_count; /*number of times the deactivation cmd
+                                         sent in case of error scenerio */
+
+  uint8_t power_state; /* current screen/power  state */
+  uint32_t eDtaMode;   /* To enable the DTA type modes. */
 } tNFA_DM_CB;
 
 /* Internal function prototypes */
@@ -539,6 +558,9 @@
 void nfa_dm_act_conn_cback_notify(uint8_t event, tNFA_CONN_EVT_DATA* p_data);
 void nfa_dm_notify_activation_status(tNFA_STATUS status,
                                      tNFA_TAG_PARAMS* p_params);
+
+bool nfa_dm_act_send_raw_vs(tNFA_DM_MSG* p_data);
+
 void nfa_dm_disable_complete(void);
 
 /* Internal functions from nfa_rw */
@@ -561,6 +583,10 @@
 extern uint8_t nfa_dm_num_dm_interface_mapping;
 extern bool nfa_poll_bail_out_mode;
 
+void nfa_dm_poll_disc_cback_dta_wrapper(tNFA_DM_RF_DISC_EVT event,
+                                        tNFC_DISCOVER* p_data);
+extern unsigned char appl_dta_mode_flag;
+
 /* NFA device manager control block */
 extern tNFA_DM_CB nfa_dm_cb;
 
@@ -611,6 +637,7 @@
 uint16_t nfa_dm_act_get_rf_disc_duration();
 bool nfa_dm_act_disable_timeout(tNFA_DM_MSG* p_data);
 bool nfa_dm_act_nfc_cback_data(tNFA_DM_MSG* p_data);
+bool nfa_dm_set_power_sub_state(tNFA_DM_MSG* p_data);
 
 void nfa_dm_proc_nfcc_power_mode(uint8_t nfcc_power_mode);
 
diff --git a/src/nfa/int/nfa_ee_int.h b/src/nfa/int/nfa_ee_int.h
index 5017195..28b049d 100644
--- a/src/nfa/int/nfa_ee_int.h
+++ b/src/nfa/int/nfa_ee_int.h
@@ -182,6 +182,7 @@
   tNFA_NFC_PROTOCOL lbp_protocol;  /* Listen B' protocol   */
   uint8_t size_mask; /* the size for technology and protocol routing */
   uint16_t size_aid; /* the size for aid routing */
+  uint8_t aid_info[NFA_EE_MAX_AID_ENTRIES]; /* Aid Info Prefix/Suffix/Exact */
 } tNFA_EE_ECB;
 
 /* data type for NFA_EE_API_DISCOVER_EVT */
@@ -238,6 +239,7 @@
   uint8_t aid_len;
   uint8_t* p_aid;
   tNFA_EE_PWR_STATE power_state;
+  uint8_t aidInfo;
 } tNFA_EE_API_ADD_AID;
 
 /* data type for NFA_EE_API_REMOVE_AID_EVT */
@@ -425,8 +427,16 @@
   uint8_t ee_cfg_sts;        /* configuration status             */
   tNFA_EE_WAIT ee_wait_evt;  /* Pending event(s) to be reported  */
   tNFA_EE_FLAGS ee_flags;    /* flags                            */
+  uint8_t route_block_control; /* controls route block feature   */
 } tNFA_EE_CB;
 
+/* Order of Routing entries in Routing Table */
+#define NCI_ROUTE_ORDER_AID 0x01        /* AID routing order */
+#define NCI_ROUTE_ORDER_PATTERN 0x02    /* Pattern routing order*/
+#define NCI_ROUTE_ORDER_SYS_CODE 0x03   /* System Code routing order*/
+#define NCI_ROUTE_ORDER_PROTOCOL 0x04   /* Protocol routing order*/
+#define NCI_ROUTE_ORDER_TECHNOLOGY 0x05 /* Technology routing order*/
+
 /*****************************************************************************
 **  External variables
 *****************************************************************************/
diff --git a/src/nfa/int/nfa_rw_int.h b/src/nfa/int/nfa_rw_int.h
index f91b3f8..f9a53c2 100644
--- a/src/nfa/int/nfa_rw_int.h
+++ b/src/nfa/int/nfa_rw_int.h
@@ -48,6 +48,14 @@
 /* Both Lock and Memory control Tlvs are detected */
 #define NFA_RW_TLV_DETECT_ST_COMPLETE 0x03
 
+/* Tag deselect cmd*/
+#define NFA_RW_TAG_DESELECT_CMD 0xC2
+
+#define NFA_RW_TAG_SLP_REQ_LEN 0x02
+
+/* Tag sleep req cmd*/
+extern uint8_t NFA_RW_TAG_SLP_REQ[];
+
 typedef uint8_t tNFA_RW_TLV_ST;
 
 /* RW events */
diff --git a/src/nfa/p2p/nfa_p2p_main.c b/src/nfa/p2p/nfa_p2p_main.c
index c68d85f..2787634 100644
--- a/src/nfa/p2p/nfa_p2p_main.c
+++ b/src/nfa/p2p/nfa_p2p_main.c
@@ -206,8 +206,12 @@
     nfa_p2p_cb.listen_tech_mask_to_restore = nfa_p2p_cb.listen_tech_mask;
 
     /* remove active listen mode */
-    nfa_p2p_cb.listen_tech_mask &=
-        ~(NFA_TECHNOLOGY_MASK_A_ACTIVE | NFA_TECHNOLOGY_MASK_F_ACTIVE);
+    if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+      nfa_p2p_cb.listen_tech_mask &= ~(NFA_TECHNOLOGY_MASK_ACTIVE);
+    } else {
+      nfa_p2p_cb.listen_tech_mask &=
+          ~(NFA_TECHNOLOGY_MASK_A_ACTIVE | NFA_TECHNOLOGY_MASK_F_ACTIVE);
+    }
   }
 
   if (nfa_p2p_cb.dm_disc_handle != NFA_HANDLE_INVALID) {
@@ -221,17 +225,36 @@
 
   if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_F)
     p2p_listen_mask |= NFA_DM_DISC_MASK_LF_NFC_DEP;
+  if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+    if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_ACTIVE)
+      p2p_listen_mask |= NFA_DM_DISC_MASK_LACM_NFC_DEP;
+  } else {
+    if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE)
+      p2p_listen_mask |= NFA_DM_DISC_MASK_LAA_NFC_DEP;
+    if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE)
+      p2p_listen_mask |= NFA_DM_DISC_MASK_LFA_NFC_DEP;
+  }
 
-  if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE)
-    p2p_listen_mask |= NFA_DM_DISC_MASK_LAA_NFC_DEP;
+  /* For P2P mode(Default DTA mode) open Raw channel to bypass LLCP layer. For
+   * LLCP DTA mode activate LLCP Bypassing LLCP is handled in
+   * nfa_dm_poll_disc_cback */
 
-  if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE)
-    p2p_listen_mask |= NFA_DM_DISC_MASK_LFA_NFC_DEP;
+  if (appl_dta_mode_flag == 1 &&
+      ((nfa_dm_cb.eDtaMode & 0x0F) == NFA_DTA_DEFAULT_MODE)) {
+    // Configure listen technologies and protocols and register callback to DTA
 
-  /* Configure listen technologies and protocols and register callback to NFA DM
-   * discovery */
-  nfa_p2p_cb.dm_disc_handle = nfa_dm_add_rf_discover(
-      p2p_listen_mask, NFA_DM_DISC_HOST_ID_DH, nfa_p2p_discovery_cback);
+    P2P_TRACE_DEBUG1(
+        "%s: DTA mode:Registering nfa_dm_poll_disc_cback to avoid LLCP in P2P",
+        __func__);
+    nfa_p2p_cb.dm_disc_handle =
+        nfa_dm_add_rf_discover(p2p_listen_mask, NFA_DM_DISC_HOST_ID_DH,
+                               nfa_dm_poll_disc_cback_dta_wrapper);
+  } else {
+    /* Configure listen technologies and protocols and register callback to NFA
+     * DM discovery */
+    nfa_p2p_cb.dm_disc_handle = nfa_dm_add_rf_discover(
+        p2p_listen_mask, NFA_DM_DISC_HOST_ID_DH, nfa_p2p_discovery_cback);
+  }
 
   /* restart RF discovery to update RF technologies */
   p_msg = (NFC_HDR*)GKI_getbuf(sizeof(NFC_HDR));
@@ -326,7 +349,13 @@
     if (reason != LLCP_LINK_RF_LINK_LOSS_ERR) /* if NFC link is still up */
     {
       if (nfa_p2p_cb.is_initiator) {
-        nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_DISCOVERY);
+        /*For LLCP DTA test, Deactivate to Sleep is needed to send DSL_REQ*/
+        if (appl_dta_mode_flag == 1 &&
+            ((nfa_dm_cb.eDtaMode & 0x0F) == NFA_DTA_LLCP_MODE)) {
+          nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_SLEEP);
+        } else {
+          nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_DISCOVERY);
+        }
       } else if ((nfa_p2p_cb.is_active_mode) && (reason == LLCP_LINK_TIMEOUT)) {
         /*
         ** target needs to trun off RF in case of receiving invalid
@@ -355,27 +384,45 @@
   P2P_TRACE_DEBUG0("nfa_p2p_activate_llcp ()");
 
   if ((p_data->activate.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) ||
-      (p_data->activate.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_F) ||
-      (p_data->activate.rf_tech_param.mode ==
-       NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) ||
-      (p_data->activate.rf_tech_param.mode ==
-       NFC_DISCOVERY_TYPE_POLL_F_ACTIVE)) {
+      (p_data->activate.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_F)) {
     config.is_initiator = true;
   } else {
     config.is_initiator = false;
   }
-
-  if ((p_data->activate.rf_tech_param.mode ==
-       NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) ||
-      (p_data->activate.rf_tech_param.mode ==
-       NFC_DISCOVERY_TYPE_POLL_F_ACTIVE) ||
-      (p_data->activate.rf_tech_param.mode ==
-       NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE) ||
-      (p_data->activate.rf_tech_param.mode ==
-       NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE)) {
-    nfa_p2p_cb.is_active_mode = true;
+  if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+    if (p_data->activate.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_ACTIVE) {
+      config.is_initiator = true;
+    }
   } else {
-    nfa_p2p_cb.is_active_mode = false;
+    if ((p_data->activate.rf_tech_param.mode ==
+         NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) ||
+        (p_data->activate.rf_tech_param.mode ==
+         NFC_DISCOVERY_TYPE_POLL_F_ACTIVE)) {
+      config.is_initiator = true;
+    }
+  }
+  if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+    if ((p_data->activate.rf_tech_param.mode ==
+         NFC_DISCOVERY_TYPE_POLL_ACTIVE) ||
+        (p_data->activate.rf_tech_param.mode ==
+         NFC_DISCOVERY_TYPE_LISTEN_ACTIVE)) {
+      nfa_p2p_cb.is_active_mode = true;
+    } else {
+      nfa_p2p_cb.is_active_mode = false;
+    }
+  } else {
+    if ((p_data->activate.rf_tech_param.mode ==
+         NFC_DISCOVERY_TYPE_POLL_A_ACTIVE) ||
+        (p_data->activate.rf_tech_param.mode ==
+         NFC_DISCOVERY_TYPE_POLL_F_ACTIVE) ||
+        (p_data->activate.rf_tech_param.mode ==
+         NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE) ||
+        (p_data->activate.rf_tech_param.mode ==
+         NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE)) {
+      nfa_p2p_cb.is_active_mode = true;
+    } else {
+      nfa_p2p_cb.is_active_mode = false;
+    }
   }
 
   nfa_p2p_cb.is_initiator = config.is_initiator;
@@ -475,9 +522,13 @@
     gen_bytes_len = 0;
   }
 
-  if (disc_mask &
-      (NFA_DM_DISC_MASK_PA_NFC_DEP | NFA_DM_DISC_MASK_PF_NFC_DEP |
-       NFA_DM_DISC_MASK_PAA_NFC_DEP | NFA_DM_DISC_MASK_PFA_NFC_DEP)) {
+  if ((disc_mask &
+       (NFA_DM_DISC_MASK_PA_NFC_DEP | NFA_DM_DISC_MASK_PF_NFC_DEP)) ||
+      ((NFC_GetNCIVersion() == NCI_VERSION_2_0) &&
+       (disc_mask & NFA_DM_DISC_MASK_PACM_NFC_DEP)) ||
+      ((NFC_GetNCIVersion() != NCI_VERSION_2_0) &&
+       (disc_mask &
+        (NFA_DM_DISC_MASK_PAA_NFC_DEP | NFA_DM_DISC_MASK_PFA_NFC_DEP)))) {
     p = params;
 
     UINT8_TO_BE_STREAM(p, NFC_PMID_ATR_REQ_GEN_BYTES);
@@ -489,9 +540,13 @@
     nfa_dm_check_set_config(length, params, false);
   }
 
-  if (disc_mask &
-      (NFA_DM_DISC_MASK_LA_NFC_DEP | NFA_DM_DISC_MASK_LF_NFC_DEP |
-       NFA_DM_DISC_MASK_LAA_NFC_DEP | NFA_DM_DISC_MASK_LFA_NFC_DEP)) {
+  if ((disc_mask &
+       (NFA_DM_DISC_MASK_LA_NFC_DEP | NFA_DM_DISC_MASK_LF_NFC_DEP)) ||
+      ((NFC_GetNCIVersion() == NCI_VERSION_2_0) &&
+       (disc_mask & NFA_DM_DISC_MASK_LACM_NFC_DEP)) ||
+      ((NFC_GetNCIVersion() != NCI_VERSION_2_0) &&
+       (disc_mask &
+        (NFA_DM_DISC_MASK_LFA_NFC_DEP | NFA_DM_DISC_MASK_LAA_NFC_DEP)))) {
     p = params;
 
     UINT8_TO_BE_STREAM(p, NFC_PMID_ATR_RES_GEN_BYTES);
@@ -548,17 +603,38 @@
   if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_F)
     p2p_listen_mask |= NFA_DM_DISC_MASK_LF_NFC_DEP;
 
-  if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE)
-    p2p_listen_mask |= NFA_DM_DISC_MASK_LAA_NFC_DEP;
+  if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+    if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_ACTIVE)
+      p2p_listen_mask |= NFA_DM_DISC_MASK_LACM_NFC_DEP;
+  } else {
+    if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE)
+      p2p_listen_mask |= NFA_DM_DISC_MASK_LAA_NFC_DEP;
 
-  if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE)
-    p2p_listen_mask |= NFA_DM_DISC_MASK_LFA_NFC_DEP;
+    if (nfa_p2p_cb.listen_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE)
+      p2p_listen_mask |= NFA_DM_DISC_MASK_LFA_NFC_DEP;
+  }
 
   if (p2p_listen_mask) {
-    /* Configure listen technologies and protocols and register callback to NFA
-     * DM discovery */
-    nfa_p2p_cb.dm_disc_handle = nfa_dm_add_rf_discover(
-        p2p_listen_mask, NFA_DM_DISC_HOST_ID_DH, nfa_p2p_discovery_cback);
+    /* For P2P mode(Default DTA mode) open Raw channel to bypass LLCP layer.
+     * For LLCP DTA mode activate LLCP Bypassing LLCP is handled in
+     * nfa_dm_poll_disc_cback */
+    if (appl_dta_mode_flag == 1 &&
+        ((nfa_dm_cb.eDtaMode & 0x0F) == NFA_DTA_DEFAULT_MODE)) {
+      /* Configure listen technologies and protocols and register callback to
+       * NFA DM discovery */
+      P2P_TRACE_DEBUG1(
+          "%s: DTA mode:Registering nfa_dm_poll_disc_cback to avoid LLCP in "
+          "P2P",
+          __func__);
+      nfa_p2p_cb.dm_disc_handle =
+          nfa_dm_add_rf_discover(p2p_listen_mask, NFA_DM_DISC_HOST_ID_DH,
+                                 nfa_dm_poll_disc_cback_dta_wrapper);
+    } else {
+      /* Configure listen technologies and protocols and register callback to
+       * NFA DM discovery */
+      nfa_p2p_cb.dm_disc_handle = nfa_dm_add_rf_discover(
+          p2p_listen_mask, NFA_DM_DISC_HOST_ID_DH, nfa_p2p_discovery_cback);
+    }
   }
 }
 
@@ -629,7 +705,7 @@
     }
 
     /* restart discovery without updating sub-module status */
-    if (nfa_p2p_cb.is_p2p_listening)
+    if (nfa_p2p_cb.is_p2p_listening || appl_dta_mode_flag)
       nfa_p2p_enable_listening(NFA_ID_P2P, false);
     else if (nfa_p2p_cb.is_snep_listening)
       nfa_p2p_enable_listening(NFA_ID_SNEP, false);
diff --git a/src/nfa/rw/nfa_rw_act.c b/src/nfa/rw/nfa_rw_act.c
index 8aee4cb..d369219 100644
--- a/src/nfa/rw/nfa_rw_act.c
+++ b/src/nfa/rw/nfa_rw_act.c
@@ -31,6 +31,9 @@
 
 #define NFA_RW_OPTION_INVALID 0xFF
 
+/* Tag sleep req cmd*/
+uint8_t NFA_RW_TAG_SLP_REQ[] = {0x50, 0x00};
+
 /* Local static function prototypes */
 static tNFC_STATUS nfa_rw_start_ndef_read(void);
 static tNFC_STATUS nfa_rw_start_ndef_write(void);
@@ -1430,7 +1433,7 @@
   } else if (NFC_PROTOCOL_ISO_DEP == protocol) {
     /* ISODEP/4A,4B- NFC-A or NFC-B */
     status = RW_T4tDetectNDef();
-  } else if (NFC_PROTOCOL_15693 == protocol) {
+  } else if (NFC_PROTOCOL_T5T == protocol) {
     /* ISO 15693 */
     status = RW_I93DetectNDef();
   }
@@ -1498,7 +1501,7 @@
   } else if (NFC_PROTOCOL_ISO_DEP == protocol) {
     /* ISODEP/4A,4B- NFC-A or NFC-B */
     status = RW_T4tReadNDef();
-  } else if (NFC_PROTOCOL_15693 == protocol) {
+  } else if (NFC_PROTOCOL_T5T == protocol) {
     /* ISO 15693 */
     status = RW_I93ReadNDef();
   }
@@ -1573,7 +1576,7 @@
       /* ISODEP/4A,4B- NFC-A or NFC-B */
       status = RW_T4tUpdateNDef((uint16_t)nfa_rw_cb.ndef_wr_len,
                                 nfa_rw_cb.p_ndef_wr_buf);
-    } else if (NFC_PROTOCOL_15693 == protocol) {
+    } else if (NFC_PROTOCOL_T5T == protocol) {
       /* ISO 15693 */
       status = RW_I93UpdateNDef((uint16_t)nfa_rw_cb.ndef_wr_len,
                                 nfa_rw_cb.p_ndef_wr_buf);
@@ -1740,6 +1743,11 @@
         option = RW_T4T_CHK_READ_BINARY_CH3;
         break;
 
+      case NFA_RW_PRES_CHK_ISO_DEP_NAK:
+        if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+          option = RW_T4T_CHK_ISO_DEP_NAK_PRES_CHK;
+        }
+        break;
       default:
         if (nfa_rw_cb.flags & NFA_RW_FL_NDEF_OK) {
           /* read binary on channel 0 */
@@ -1773,8 +1781,8 @@
       /* use sleep/wake for presence check */
       unsupported = true;
     }
-  } else if (NFC_PROTOCOL_15693 == protocol) {
-    /* ISO 15693 */
+  } else if (NFC_PROTOCOL_T5T == protocol) {
+    /* T5T/ISO 15693 */
     status = RW_I93PresenceCheck();
   } else {
     /* Protocol unsupported by RW module... */
@@ -1857,7 +1865,7 @@
     status = RW_T2tFormatNDef();
   } else if (protocol == NFC_PROTOCOL_T3T) {
     status = RW_T3tFormatNDef();
-  } else if (protocol == NFC_PROTOCOL_15693) {
+  } else if (protocol == NFC_PROTOCOL_T5T) {
     status = RW_I93FormatNDef();
   } else if (protocol == NFC_PROTOCOL_ISO_DEP) {
     status = RW_T4tFormatNDef();
@@ -1934,7 +1942,7 @@
   } else if (NFC_PROTOCOL_ISO_DEP == protocol) {
     /* ISODEP/4A,4B- NFC-A or NFC-B */
     status = RW_T4tSetNDefReadOnly();
-  } else if (NFC_PROTOCOL_15693 == protocol) {
+  } else if (NFC_PROTOCOL_T5T == protocol) {
     /* ISO 15693 */
     status = RW_I93SetTagReadOnly();
   }
@@ -2460,7 +2468,7 @@
     if ((p_activate_params->protocol != NFA_PROTOCOL_T1T) &&
         (p_activate_params->protocol != NFA_PROTOCOL_T2T) &&
         (p_activate_params->protocol != NFA_PROTOCOL_T3T) &&
-        (p_activate_params->protocol != NFC_PROTOCOL_15693)) {
+        (p_activate_params->protocol != NFA_PROTOCOL_T5T)) {
       nfa_rw_cb.protocol = NFA_PROTOCOL_INVALID;
     }
   } else if (p_activate_params->intf_param.type == NCI_INTERFACE_ISO_DEP) {
@@ -2508,27 +2516,41 @@
   /* Perform protocol-specific actions */
   if (NFC_PROTOCOL_T1T == nfa_rw_cb.protocol) {
     /* Retrieve HR and UID fields from activation notification */
-    memcpy(tag_params.t1t.hr,
-           p_activate_params->intf_param.intf_param.frame.param,
-           NFA_T1T_HR_LEN);
     memcpy(tag_params.t1t.uid, p_activate_params->rf_tech_param.param.pa.nfcid1,
            p_activate_params->rf_tech_param.param.pa.nfcid1_len);
-    msg.op = NFA_RW_OP_T1T_RID;
-    nfa_rw_handle_op_req((tNFA_RW_MSG*)&msg);
-    activate_notify = false; /* Delay notifying upper layer of NFA_ACTIVATED_EVT
-                                until HR0/HR1 is received */
+
+    if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+      memcpy(tag_params.t1t.hr, p_activate_params->rf_tech_param.param.pa.hr,
+             NFA_T1T_HR_LEN);
+    } else {
+      memcpy(tag_params.t1t.hr,
+             p_activate_params->intf_param.intf_param.frame.param,
+             NFA_T1T_HR_LEN);
+      msg.op = NFA_RW_OP_T1T_RID;
+      nfa_rw_handle_op_req((tNFA_RW_MSG*)&msg);
+      /* Delay notifying upper layer of NFA_ACTIVATED_EVT
+         until HR0/HR1 is received */
+      activate_notify = false;
+    }
   } else if (NFC_PROTOCOL_T2T == nfa_rw_cb.protocol) {
     /* Retrieve UID fields from activation notification */
     memcpy(tag_params.t2t.uid, p_activate_params->rf_tech_param.param.pa.nfcid1,
            p_activate_params->rf_tech_param.param.pa.nfcid1_len);
   } else if (NFC_PROTOCOL_T3T == nfa_rw_cb.protocol) {
-    /* Issue command to get Felica system codes */
-    activate_notify =
-        false; /* Delay notifying upper layer of NFA_ACTIVATED_EVT until system
-                  codes are retrieved */
-    msg.op = NFA_RW_OP_T3T_GET_SYSTEM_CODES;
-    nfa_rw_handle_op_req((tNFA_RW_MSG*)&msg);
-  } else if (NFC_PROTOCOL_15693 == nfa_rw_cb.protocol) {
+    if (appl_dta_mode_flag) {
+      /* Incase of DTA mode Dont send commands to get system code. Just notify
+       * activation */
+      activate_notify = true;
+    } else {
+      /* Delay notifying upper layer of NFA_ACTIVATED_EVT until system codes
+       * are retrieved */
+      activate_notify = false;
+
+      /* Issue command to get Felica system codes */
+      msg.op = NFA_RW_OP_T3T_GET_SYSTEM_CODES;
+      nfa_rw_handle_op_req((tNFA_RW_MSG*)&msg);
+    }
+  } else if (NFA_PROTOCOL_T5T == nfa_rw_cb.protocol) {
     /* Delay notifying upper layer of NFA_ACTIVATED_EVT to retrieve additional
      * tag infomation */
     nfa_rw_cb.flags |= NFA_RW_FL_ACTIVATION_NTF_PENDING;
diff --git a/src/nfa/rw/nfa_rw_api.c b/src/nfa/rw/nfa_rw_api.c
index 318eabc..c21414d 100644
--- a/src/nfa/rw/nfa_rw_api.c
+++ b/src/nfa/rw/nfa_rw_api.c
@@ -243,8 +243,8 @@
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_REJECTED if protocol is not T1/T2/ISO15693
-**                 (or) if hard lock is not requested for protocol ISO15693
+**      NFA_STATUS_REJECTED if protocol is not T1/T2/T5T
+**                 (or) if hard lock is not requested for protocol T5T
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -253,7 +253,7 @@
   tNFC_PROTOCOL protocol = nfa_rw_cb.protocol;
 
   if ((protocol != NFC_PROTOCOL_T1T) && (protocol != NFC_PROTOCOL_T2T) &&
-      (protocol != NFC_PROTOCOL_15693) && (protocol != NFC_PROTOCOL_ISO_DEP) &&
+      (protocol != NFC_PROTOCOL_T5T) && (protocol != NFC_PROTOCOL_ISO_DEP) &&
       (protocol != NFC_PROTOCOL_T3T)) {
     NFA_TRACE_API1(
         "NFA_RwSetTagReadOnly (): Cannot Configure as read only for Protocol: "
@@ -262,7 +262,7 @@
     return (NFA_STATUS_REJECTED);
   }
 
-  if ((!b_hard_lock && (protocol == NFC_PROTOCOL_15693)) ||
+  if ((!b_hard_lock && (protocol == NFC_PROTOCOL_T5T)) ||
       (b_hard_lock && (protocol == NFC_PROTOCOL_ISO_DEP))) {
     NFA_TRACE_API2("NFA_RwSetTagReadOnly (): Cannot %s for Protocol: %d",
                    b_hard_lock ? "Hard lock" : "Soft lock", protocol);
@@ -799,7 +799,7 @@
 ** Function         NFA_RwI93Inventory
 **
 ** Description:
-**      Send Inventory command to the activated ISO 15693 tag with/without AFI
+**      Send Inventory command to the activated ISO T5T tag with/without AFI
 **      If UID is provided then set UID[0]:MSB, ... UID[7]:LSB
 **
 **      When the operation has completed (or if an error occurs), the
@@ -807,7 +807,7 @@
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -817,7 +817,7 @@
   NFA_TRACE_API2("NFA_RwI93Inventory (): afi_present:%d, AFI: 0x%02X",
                  afi_present, afi);
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
@@ -850,14 +850,14 @@
 ** Function         NFA_RwI93StayQuiet
 **
 ** Description:
-**      Send Stay Quiet command to the activated ISO 15693 tag.
+**      Send Stay Quiet command to the activated T5T tag.
 **
 **      When the operation has completed (or if an error occurs), the
 **      app will be notified with NFA_I93_CMD_CPLT_EVT.
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -866,7 +866,7 @@
 
   NFA_TRACE_API0("NFA_RwI93StayQuiet ()");
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
@@ -889,7 +889,7 @@
 ** Function         NFA_RwI93ReadSingleBlock
 **
 ** Description:
-**      Send Read Single Block command to the activated ISO 15693 tag.
+**      Send Read Single Block command to the activated T5T tag.
 **
 **      Data is returned to the application using the NFA_DATA_EVT. When the
 **      read operation has completed, or if an error occurs, the app will be
@@ -897,7 +897,7 @@
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -907,7 +907,7 @@
   NFA_TRACE_API1("NFA_RwI93ReadSingleBlock (): block_number: 0x%02X",
                  block_number);
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
@@ -932,14 +932,14 @@
 ** Function         NFA_RwI93WriteSingleBlock
 **
 ** Description:
-**      Send Write Single Block command to the activated ISO 15693 tag.
+**      Send Write Single Block command to the activated T5T tag.
 **
 **      When the write operation has completed (or if an error occurs), the
 **      app will be notified with NFA_I93_CMD_CPLT_EVT.
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -949,7 +949,7 @@
   NFA_TRACE_API1("NFA_RwI93WriteSingleBlock (): block_number: 0x%02X",
                  block_number);
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
@@ -983,14 +983,14 @@
 ** Function         NFA_RwI93LockBlock
 **
 ** Description:
-**      Send Lock block command to the activated ISO 15693 tag.
+**      Send Lock block command to the activated T5T tag.
 **
 **      When the operation has completed (or if an error occurs), the
 **      app will be notified with NFA_I93_CMD_CPLT_EVT.
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -999,7 +999,7 @@
 
   NFA_TRACE_API1("NFA_RwI93LockBlock (): block_number: 0x%02X", block_number);
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
@@ -1024,7 +1024,7 @@
 ** Function         NFA_RwI93ReadMultipleBlocks
 **
 ** Description:
-**      Send Read Multiple Block command to the activated ISO 15693 tag.
+**      Send Read Multiple Block command to the activated T5T tag.
 **
 **      Data is returned to the application using the NFA_DATA_EVT. When the
 **      read operation has completed, or if an error occurs, the app will be
@@ -1032,7 +1032,7 @@
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -1043,7 +1043,7 @@
   NFA_TRACE_API2("NFA_RwI93ReadMultipleBlocks(): %d, %d", first_block_number,
                  number_blocks);
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
@@ -1069,14 +1069,14 @@
 ** Function         NFA_RwI93WriteMultipleBlocks
 **
 ** Description:
-**      Send Write Multiple Block command to the activated ISO 15693 tag.
+**      Send Write Multiple Block command to the activated T5T tag.
 **
 **      When the write operation has completed (or if an error occurs), the
 **      app will be notified with NFA_I93_CMD_CPLT_EVT.
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -1089,7 +1089,7 @@
   NFA_TRACE_API2("NFA_RwI93WriteMultipleBlocks (): %d, %d", first_block_number,
                  number_blocks);
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
@@ -1126,7 +1126,7 @@
 ** Function         NFA_RwI93Select
 **
 ** Description:
-**      Send Select command to the activated ISO 15693 tag.
+**      Send Select command to the activated T5T tag.
 **
 **      UID[0]: 0xE0, MSB
 **      UID[1]: IC Mfg Code
@@ -1138,7 +1138,7 @@
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -1148,7 +1148,7 @@
   NFA_TRACE_API3("NFA_RwI93Select (): UID: [%02X%02X%02X...]", *(p_uid),
                  *(p_uid + 1), *(p_uid + 2));
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
@@ -1175,14 +1175,14 @@
 ** Function         NFA_RwI93ResetToReady
 **
 ** Description:
-**      Send Reset to ready command to the activated ISO 15693 tag.
+**      Send Reset to ready command to the activated T5T tag.
 **
 **      When the operation has completed (or if an error occurs), the
 **      app will be notified with NFA_I93_CMD_CPLT_EVT.
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -1191,7 +1191,7 @@
 
   NFA_TRACE_API0("NFA_RwI93ResetToReady ()");
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
@@ -1214,14 +1214,14 @@
 ** Function         NFA_RwI93WriteAFI
 **
 ** Description:
-**      Send Write AFI command to the activated ISO 15693 tag.
+**      Send Write AFI command to the activated T5T tag.
 **
 **      When the operation has completed (or if an error occurs), the
 **      app will be notified with NFA_I93_CMD_CPLT_EVT.
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -1230,7 +1230,7 @@
 
   NFA_TRACE_API1("NFA_RwI93WriteAFI (): AFI: 0x%02X", afi);
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
@@ -1255,14 +1255,14 @@
 ** Function         NFA_RwI93LockAFI
 **
 ** Description:
-**      Send Lock AFI command to the activated ISO 15693 tag.
+**      Send Lock AFI command to the activated T5T tag.
 **
 **      When the operation has completed (or if an error occurs), the
 **      app will be notified with NFA_I93_CMD_CPLT_EVT.
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -1271,7 +1271,7 @@
 
   NFA_TRACE_API0("NFA_RwI93LockAFI ()");
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
@@ -1294,14 +1294,14 @@
 ** Function         NFA_RwI93WriteDSFID
 **
 ** Description:
-**      Send Write DSFID command to the activated ISO 15693 tag.
+**      Send Write DSFID command to the activated T5T tag.
 **
 **      When the operation has completed (or if an error occurs), the
 **      app will be notified with NFA_I93_CMD_CPLT_EVT.
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -1310,7 +1310,7 @@
 
   NFA_TRACE_API1("NFA_RwI93WriteDSFID (): DSFID: 0x%02X", dsfid);
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
@@ -1335,14 +1335,14 @@
 ** Function         NFA_RwI93LockDSFID
 **
 ** Description:
-**      Send Lock DSFID command to the activated ISO 15693 tag.
+**      Send Lock DSFID command to the activated T5T tag.
 **
 **      When the operation has completed (or if an error occurs), the
 **      app will be notified with NFA_I93_CMD_CPLT_EVT.
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -1351,7 +1351,7 @@
 
   NFA_TRACE_API0("NFA_RwI93LockDSFID ()");
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
@@ -1374,7 +1374,7 @@
 ** Function         NFA_RwI93GetSysInfo
 **
 ** Description:
-**      Send Get system information command to the activated ISO 15693 tag.
+**      Send Get system information command to the activated T5T tag.
 **      If UID is provided then set UID[0]:MSB, ... UID[7]:LSB
 **
 **      When the operation has completed (or if an error occurs), the
@@ -1382,7 +1382,7 @@
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -1391,7 +1391,7 @@
 
   NFA_TRACE_API0("NFA_RwI93GetSysInfo ()");
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
@@ -1421,8 +1421,8 @@
 ** Function         NFA_RwI93GetMultiBlockSecurityStatus
 **
 ** Description:
-**      Send Get Multiple block security status command to the activated ISO
-**      15693 tag.
+**      Send Get Multiple block security status command to the activated
+**      T5T tag.
 **
 **      Data is returned to the application using the NFA_DATA_EVT. When the
 **      read operation has completed, or if an error occurs, the app will be
@@ -1430,7 +1430,7 @@
 **
 ** Returns:
 **      NFA_STATUS_OK if successfully initiated
-**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
+**      NFA_STATUS_WRONG_PROTOCOL: T5T tag not activated
 **      NFA_STATUS_FAILED otherwise
 **
 *******************************************************************************/
@@ -1441,7 +1441,7 @@
   NFA_TRACE_API2("NFA_RwI93GetMultiBlockSecurityStatus(): %d, %d",
                  first_block_number, number_blocks);
 
-  if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693) {
+  if (nfa_rw_cb.protocol != NFC_PROTOCOL_T5T) {
     return (NFA_STATUS_WRONG_PROTOCOL);
   }
 
diff --git a/src/nfc/include/llcp_api.h b/src/nfc/include/llcp_api.h
index d3c507b..50b0740 100644
--- a/src/nfc/include/llcp_api.h
+++ b/src/nfc/include/llcp_api.h
@@ -668,7 +668,19 @@
 ** Returns          The new or current trace level
 **
 *******************************************************************************/
+
 extern uint8_t LLCP_SetTraceLevel(uint8_t new_level);
+/*******************************************************************************
+**
+** Function         LLCP_RegisterDtaCback
+**
+** Description      Register callback function for LLCP DTA testing
+**
+**
+** Returns          void
+**
+*******************************************************************************/
+extern void LLCP_RegisterDtaCback(tLLCP_DTA_CBACK* p_dta_cback);
 
 #if (LLCP_TEST_INCLUDED == TRUE)
 /*******************************************************************************
diff --git a/src/nfc/include/nci_hmsgs.h b/src/nfc/include/nci_hmsgs.h
index 948d418..d013cde 100644
--- a/src/nfc/include/nci_hmsgs.h
+++ b/src/nfc/include/nci_hmsgs.h
@@ -40,10 +40,11 @@
 void nci_proc_rf_management_ntf(NFC_HDR* p_msg);
 void nci_proc_ee_management_ntf(NFC_HDR* p_msg);
 void nci_proc_prop_rsp(NFC_HDR* p_msg);
+void nci_proc_prop_raw_vs_rsp(NFC_HDR* p_msg);
 void nci_proc_prop_ntf(NFC_HDR* p_msg);
 
 uint8_t nci_snd_core_reset(uint8_t reset_type);
-uint8_t nci_snd_core_init(void);
+uint8_t nci_snd_core_init(uint8_t nci_version);
 uint8_t nci_snd_core_get_config(uint8_t* param_ids, uint8_t num_ids);
 uint8_t nci_snd_core_set_config(uint8_t* p_param_tlvs, uint8_t tlv_size);
 
@@ -59,6 +60,8 @@
 uint8_t nci_snd_discover_map_cmd(uint8_t num, tNCI_DISCOVER_MAPS* p_maps);
 uint8_t nci_snd_t3t_polling(uint16_t system_code, uint8_t rc, uint8_t tsn);
 uint8_t nci_snd_parameter_update_cmd(uint8_t* p_param_tlvs, uint8_t tlv_size);
+uint8_t nci_snd_iso_dep_nak_presence_check_cmd();
+uint8_t nci_snd_core_set_power_sub_state(uint8_t screen_state);
 
 #if (NFC_NFCEE_INCLUDED == TRUE && NFC_RW_ONLY == FALSE)
 uint8_t nci_snd_nfcee_discover(uint8_t discover_action);
diff --git a/src/nfc/include/nfc_api.h b/src/nfc/include/nfc_api.h
index ec40d28..2a35942 100644
--- a/src/nfc/include/nfc_api.h
+++ b/src/nfc/include/nfc_api.h
@@ -115,6 +115,7 @@
 #define NFC_PMID_TOTAL_DURATION NCI_PARAM_ID_TOTAL_DURATION
 #define NFC_PMID_CON_DEVICES_LIMIT NCI_PARAM_ID_CON_DEVICES_LIMIT
 #define NFC_PMID_PA_BAILOUT NCI_PARAM_ID_PA_BAILOUT
+#define NFC_PMID_CON_DISCOVERY_PARAM NCI_PARAM_ID_CON_DISCOVERY_PARAM
 #define NFC_PMID_PB_AFI NCI_PARAM_ID_PB_AFI
 #define NFC_PMID_PB_BAILOUT NCI_PARAM_ID_PB_BAILOUT
 #define NFC_PMID_PB_ATTRIB_PARAM1 NCI_PARAM_ID_PB_ATTRIB_PARAM1
@@ -221,8 +222,8 @@
   NFC_NFCC_TIMEOUT_REVT,            /* 15 NFCC is not responding        */
   NFC_NFCC_TRANSPORT_ERR_REVT,      /* 16 NCI Tranport error            */
   NFC_NFCC_POWER_OFF_REVT,          /* 17 NFCC turned off               */
-
-  NFC_FIRST_VS_REVT /* First vendor-specific rsp event  */
+  NFC_SET_POWER_SUB_STATE_REVT,     /* 18 Set power sub state response  */
+  NFC_FIRST_VS_REVT                 /* First vendor-specific rsp event  */
 };
 typedef uint16_t tNFC_RESPONSE_EVT;
 
@@ -252,6 +253,9 @@
   uint8_t nfcc_info[NFC_NFCC_INFO_LEN]; /* the Manufacture Info for NFCC      */
   uint8_t vs_interface
       [NFC_NFCC_MAX_NUM_VS_INTERFACE]; /* the NCI VS interfaces of NFCC    */
+  uint8_t hci_packet_size;             /*HCI payload size*/
+  uint8_t hci_conn_credits;            /*max number of HCI credits*/
+  uint16_t max_nfc_v_size;             /* maximum frame size for NFC-V*/
 } tNFC_ENABLE_REVT;
 
 #define NFC_MAX_NUM_IDS 125
@@ -321,6 +325,14 @@
   tNFC_NFCEE_MODE mode; /* NFCEE mode       */
 } tNFC_NFCEE_MODE_SET_REVT;
 
+#if (APPL_DTA_MODE == TRUE)
+/* This data type is for FW Version */
+typedef struct {
+  uint8_t rom_code_version; /* ROM code Version  */
+  uint8_t major_version;    /* Major Version */
+  uint8_t minor_version;    /* Minor Version  */
+} tNFC_FW_VERSION;
+#endif
 #define NFC_MAX_AID_LEN NCI_MAX_AID_LEN /* 16 */
 
 /* the data type associated with NFC_CE_GET_ROUTING_REVT */
@@ -363,9 +375,15 @@
 #define NFC_RF_TECHNOLOGY_A NCI_RF_TECHNOLOGY_A
 #define NFC_RF_TECHNOLOGY_B NCI_RF_TECHNOLOGY_B
 #define NFC_RF_TECHNOLOGY_F NCI_RF_TECHNOLOGY_F
-#define NFC_RF_TECHNOLOGY_15693 NCI_RF_TECHNOLOGY_15693
+#define NFC_RF_TECHNOLOGY_V NCI_RF_TECHNOLOGY_V
 typedef uint8_t tNFC_RF_TECH;
 
+#ifdef __cplusplus
+extern "C" uint8_t NFC_GetNCIVersion();
+#else
+extern uint8_t NFC_GetNCIVersion();
+#endif
+
 /* Supported Protocols */
 #define NFC_PROTOCOL_UNKNOWN NCI_PROTOCOL_UNKNOWN /* Unknown */
 /* Type1Tag    - NFC-A            */
@@ -374,13 +392,17 @@
 #define NFC_PROTOCOL_T2T NCI_PROTOCOL_T2T
 /* Type3Tag    - NFC-F            */
 #define NFC_PROTOCOL_T3T NCI_PROTOCOL_T3T
+/* Type5Tag    - NFC-V/ISO15693*/
+#define NFC_PROTOCOL_T5T NFC_PROTOCOL_T5T_(NFC_GetNCIVersion())
+#define NFC_PROTOCOL_T5T_(x) \
+  ((x == NCI_VERSION_2_0) ? NCI_PROTOCOL_T5T : NCI_PROTOCOL_15693)
 /* Type 4A,4B  - NFC-A or NFC-B   */
 #define NFC_PROTOCOL_ISO_DEP NCI_PROTOCOL_ISO_DEP
 /* NFCDEP/LLCP - NFC-A or NFC-F       */
 #define NFC_PROTOCOL_NFC_DEP NCI_PROTOCOL_NFC_DEP
 #define NFC_PROTOCOL_MIFARE NCI_PROTOCOL_MIFARE
+#define NFC_PROTOCOL_ISO15693 NCI_PROTOCOL_15693
 #define NFC_PROTOCOL_B_PRIME NCI_PROTOCOL_B_PRIME
-#define NFC_PROTOCOL_15693 NCI_PROTOCOL_15693
 #define NFC_PROTOCOL_KOVIO NCI_PROTOCOL_KOVIO
 typedef uint8_t tNFC_PROTOCOL;
 
@@ -390,7 +412,8 @@
 #define NFC_DISCOVERY_TYPE_POLL_F NCI_DISCOVERY_TYPE_POLL_F
 #define NFC_DISCOVERY_TYPE_POLL_A_ACTIVE NCI_DISCOVERY_TYPE_POLL_A_ACTIVE
 #define NFC_DISCOVERY_TYPE_POLL_F_ACTIVE NCI_DISCOVERY_TYPE_POLL_F_ACTIVE
-#define NFC_DISCOVERY_TYPE_POLL_ISO15693 NCI_DISCOVERY_TYPE_POLL_ISO15693
+#define NFC_DISCOVERY_TYPE_POLL_ACTIVE NCI_DISCOVERY_TYPE_POLL_ACTIVE
+#define NFC_DISCOVERY_TYPE_POLL_V NCI_DISCOVERY_TYPE_POLL_V
 #define NFC_DISCOVERY_TYPE_POLL_B_PRIME NCI_DISCOVERY_TYPE_POLL_B_PRIME
 #define NFC_DISCOVERY_TYPE_POLL_KOVIO NCI_DISCOVERY_TYPE_POLL_KOVIO
 #define NFC_DISCOVERY_TYPE_LISTEN_A NCI_DISCOVERY_TYPE_LISTEN_A
@@ -398,6 +421,7 @@
 #define NFC_DISCOVERY_TYPE_LISTEN_F NCI_DISCOVERY_TYPE_LISTEN_F
 #define NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE NCI_DISCOVERY_TYPE_LISTEN_A_ACTIVE
 #define NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE NCI_DISCOVERY_TYPE_LISTEN_F_ACTIVE
+#define NFC_DISCOVERY_TYPE_LISTEN_ACTIVE NCI_DISCOVERY_TYPE_LISTEN_ACTIVE
 #define NFC_DISCOVERY_TYPE_LISTEN_ISO15693 NCI_DISCOVERY_TYPE_LISTEN_ISO15693
 #define NFC_DISCOVERY_TYPE_LISTEN_B_PRIME NCI_DISCOVERY_TYPE_LISTEN_B_PRIME
 typedef uint8_t tNFC_DISCOVERY_TYPE;
@@ -447,6 +471,7 @@
 #define NFC_DEACTIVATE_REASON_ENDPOINT_REQ NCI_DEACTIVATE_REASON_ENDPOINT_REQ
 #define NFC_DEACTIVATE_REASON_RF_LINK_LOSS NCI_DEACTIVATE_REASON_RF_LINK_LOSS
 #define NFC_DEACTIVATE_REASON_NFCB_BAD_AFI NCI_DEACTIVATE_REASON_NFCB_BAD_AFI
+#define NFC_DEACTIVATE_REASON_DH_REQ_FAILED NCI_DEACTIVATE_REASON_DH_REQ_FAILED
 typedef uint8_t tNFC_DEACT_REASON;
 
 /* the data type associated with NFC_RF_FIELD_REVT */
@@ -606,6 +631,8 @@
   uint8_t uid[NFC_KOVIO_MAX_LEN];
 } tNFC_RF_PKOVIO_PARAMS;
 
+typedef tNCI_RF_ACM_P_PARAMS tNFC_RF_ACM_P_PARAMS;
+
 typedef union {
   tNFC_RF_PA_PARAMS pa;
   tNFC_RF_PB_PARAMS pb;
@@ -613,6 +640,7 @@
   tNFC_RF_LF_PARAMS lf;
   tNFC_RF_PISO15693_PARAMS pi93;
   tNFC_RF_PKOVIO_PARAMS pk;
+  tNFC_RF_ACM_P_PARAMS acm_p;
 } tNFC_RF_TECH_PARAMU;
 
 typedef struct {
@@ -731,6 +759,7 @@
   tNFC_STATUS status;   /* The event status.        */
   tNFC_DEACT_TYPE type; /* De-activate type         */
   bool is_ntf;          /* TRUE, if deactivate notif*/
+  tNFC_DEACT_REASON reason; /* De-activate reason    */
 } tNFC_DEACTIVATE_DEVT;
 
 typedef union {
@@ -1182,6 +1211,21 @@
 
 /*******************************************************************************
 **
+** Function         NFC_SetPowerSubState
+**
+** Description      This function is called to send the power sub state(screen
+**                  state) to NFCC. The response from NFCC is reported by
+**                  tNFC_RESPONSE_CBACK as NFC_SET_POWER_STATE_REVT.
+**
+** Parameters       scree_state
+**
+** Returns          tNFC_STATUS
+**
+*******************************************************************************/
+extern tNFC_STATUS NFC_SetPowerSubState(uint8_t screen_state);
+
+/*******************************************************************************
+**
 ** Function         NFC_PowerCycleNFCC
 **
 ** Description      This function turns off and then on NFCC.
@@ -1254,6 +1298,22 @@
 
 /*******************************************************************************
 **
+** Function         NFC_SendRawVsCommand
+**
+** Description      This function is called to send the given raw command to
+**                  NFCC. The response from NFCC is reported to the given
+**                  tNFC_VS_CBACK.
+**
+** Parameters       p_data - The command buffer
+**
+** Returns          tNFC_STATUS
+**
+*******************************************************************************/
+extern tNFC_STATUS NFC_SendRawVsCommand(NFC_HDR* p_data,
+                                        tNFC_VS_CBACK* p_cback);
+
+/*******************************************************************************
+**
 ** Function         NFC_TestLoopback
 **
 ** Description      This function is called to send the given data packet
@@ -1280,6 +1340,32 @@
 *******************************************************************************/
 extern uint8_t NFC_SetTraceLevel(uint8_t new_level);
 
+/*******************************************************************************
+**
+** Function         NFC_ISODEPNakPresCheck
+**
+** Description      This function is called to send the ISO DEP nak presence
+**                  check cmd to check that the remote end point in RF field.
+**
+** Returns          tNFC_STATUS
+**
+*******************************************************************************/
+extern tNFC_STATUS NFC_ISODEPNakPresCheck();
+
+#if (APPL_DTA_MODE == TRUE)
+/*******************************************************************************
+**
+** Function         nfc_ncif_getFWVersion
+**
+** Description      This function sets the trace level for NFC.  If called with
+**                  a value of 0xFF, it simply returns the current trace level.
+**
+** Returns          The new or current trace level
+**
+*******************************************************************************/
+extern tNFC_FW_VERSION nfc_ncif_getFWVersion();
+#endif
+
 #if (BT_TRACE_VERBOSE == TRUE)
 /*******************************************************************************
 **
diff --git a/src/nfc/include/rw_api.h b/src/nfc/include/rw_api.h
index b69e9ce..c8bb55b 100644
--- a/src/nfc/include/rw_api.h
+++ b/src/nfc/include/rw_api.h
@@ -153,7 +153,7 @@
 #define RW_T4T_CHK_READ_BINARY_CH2 2
 #define RW_T4T_CHK_READ_BINARY_CH3 3
 #define RW_T4T_CHK_EMPTY_I_BLOCK 4
-
+#define RW_T4T_CHK_ISO_DEP_NAK_PRES_CHK 5
 typedef struct {
   tNFC_STATUS status;
   uint8_t hr[T1T_HR_LEN];
diff --git a/src/nfc/include/tags_defs.h b/src/nfc/include/tags_defs.h
index 66b2875..6ac16ed 100644
--- a/src/nfc/include/tags_defs.h
+++ b/src/nfc/include/tags_defs.h
@@ -263,6 +263,14 @@
 #define T2T_RSP_NACK5 0x5
 #define T2T_RSP_NACK1 0x1 /* Nack can be either 1    */
 
+#define T2T_STATUS_OK_1_BIT 0x11
+#define T2T_STATUS_OK_2_BIT 0x12
+#define T2T_STATUS_OK_3_BIT 0x13
+#define T2T_STATUS_OK_4_BIT 0x14
+#define T2T_STATUS_OK_5_BIT 0x15
+#define T2T_STATUS_OK_6_BIT 0x16
+#define T2T_STATUS_OK_7_BIT 0x17
+
 #define T2T_FIRST_DATA_BLOCK 4
 #define T2T_READ_BLOCKS 4
 #define T2T_BLOCK_LEN 4
@@ -283,8 +291,11 @@
 #define T2T_TLEN_MEM_CTRL_TLV 3 /* Tag len for MEM_CTRL TLV per spec */
 
 /* Maximum number of sectors supported */
+#if (APPL_DTA_MODE == TRUE)
+#define T2T_MAX_SECTOR 3
+#else
 #define T2T_MAX_SECTOR 2
-
+#endif
 /* Tlv type identifier len                */
 #define T2T_TLV_TYPE_LEN 1
 
@@ -514,6 +525,8 @@
 #define T4T_FC_READ_ACCESS 0x00
 /* write access granted without any security */
 #define T4T_FC_WRITE_ACCESS 0x00
+/* proprietary write access range start */
+#define T4T_FC_WRITE_ACCESS_PROP_START 0x80
 /* no write access granted at all (read-only) */
 #define T4T_FC_NO_WRITE_ACCESS 0xFF
 
diff --git a/src/nfc/int/llcp_int.h b/src/nfc/int/llcp_int.h
index e40a674..fdf1c70 100644
--- a/src/nfc/int/llcp_int.h
+++ b/src/nfc/int/llcp_int.h
@@ -272,6 +272,8 @@
   uint8_t total_rx_ui_pdu;   /* total number of rx UI PDU in all of ui_rx_q  */
   uint8_t total_rx_i_pdu;    /* total number of rx I PDU in all of i_rx_q    */
   bool overall_rx_congested; /* TRUE if overall rx link is congested         */
+  tLLCP_DTA_CBACK* p_dta_cback; /* callback to notify DTA when respoding SNL */
+  bool dta_snl_resp; /* TRUE if need to notify DTA when respoding SNL*/
 } tLLCP_CB;
 
 #if (LLCP_TEST_INCLUDED == TRUE) /* this is for LLCP testing */
diff --git a/src/nfc/int/nfc_int.h b/src/nfc/int/nfc_int.h
index 280bd82..c3fb85c 100644
--- a/src/nfc/int/nfc_int.h
+++ b/src/nfc/int/nfc_int.h
@@ -49,6 +49,7 @@
 /* NFC Timer events */
 #define NFC_TTYPE_NCI_WAIT_RSP 0
 #define NFC_TTYPE_WAIT_2_DEACTIVATE 1
+#define NFC_WAIT_RSP_RAW_VS 0x02
 
 #define NFC_TTYPE_LLCP_LINK_MANAGER 100
 #define NFC_TTYPE_LLCP_LINK_INACT 101
@@ -128,6 +129,7 @@
   BUFFER_Q rx_q;        /* receive queue                                    */
   uint8_t id;           /* NFCEE ID or RF Discovery ID or NFC_TEST_ID       */
   uint8_t act_protocol; /* the active protocol on this logical connection   */
+  uint8_t act_interface; /* the active interface on this logical connection   */
   uint8_t conn_id;      /* the connection id assigned by NFCC for this conn */
   uint8_t buff_size;    /* the max buffer size for this connection.     .   */
   uint8_t num_buff;     /* num of buffers left to send on this connection   */
@@ -185,6 +187,8 @@
   uint8_t vs_interface
       [NFC_NFCC_MAX_NUM_VS_INTERFACE]; /* the NCI VS interfaces of NFCC    */
   uint16_t nci_interfaces;             /* the NCI interfaces of NFCC       */
+  uint8_t nci_intf_extensions;
+  uint8_t nci_intf_extension_map[NCI_INTERFACE_EXTENSION_MAX];
   uint8_t num_disc_maps; /* number of RF Discovery interface mappings */
   void* p_disc_pending;  /* the parameters associated with pending
                             NFC_DiscoveryStart */
@@ -214,6 +218,17 @@
                               HAL_NFC_POST_INIT_CPLT_EVT */
   tHAL_NFC_ENTRY* p_hal;
 
+  uint8_t nci_version; /* NCI version used for NCI communication*/
+
+  uint8_t hci_packet_size; /* maximum hci payload size*/
+
+  uint8_t hci_conn_credits; /* maximum conn credits for static HCI*/
+
+  uint16_t nci_max_v_size; /*maximum NFC V rf frame size*/
+
+  uint8_t rawVsCbflag;
+  uint8_t deact_reason;
+
 } tNFC_CB;
 
 /*****************************************************************************
@@ -227,6 +242,10 @@
 ** Internal nfc functions
 ****************************************************************************/
 
+#define NCI_CALCULATE_ACK(a, v) \
+  { a &= ((1 << v) - 1); }
+#define MAX_NUM_VALID_BITS_FOR_ACK 0x07
+
 extern void nfc_init(void);
 
 /* from nfc_utils.c */
@@ -271,8 +290,11 @@
 extern void nfc_ncif_proc_data(NFC_HDR* p_msg);
 extern bool nfa_dm_p2p_prio_logic(uint8_t event, uint8_t* p, uint8_t ntf_rsp);
 extern void nfa_dm_p2p_timer_event();
+extern bool nfc_ncif_proc_proprietary_rsp(uint8_t mt, uint8_t gid, uint8_t oid);
 extern void nfa_dm_p2p_prio_logic_cleanup();
-
+extern void nfc_ncif_proc_isodep_nak_presence_check_status(uint8_t status,
+                                                           bool is_ntf);
+extern void nfc_ncif_update_window(void);
 #if (NFC_RW_ONLY == FALSE)
 extern void nfc_ncif_proc_rf_field_ntf(uint8_t rf_status);
 #else
diff --git a/src/nfc/int/nfc_vs.h b/src/nfc/int/nfc_vs.h
new file mode 100644
index 0000000..adc2f25
--- /dev/null
+++ b/src/nfc/int/nfc_vs.h
@@ -0,0 +1,41 @@
+/******************************************************************************
+ * Copyright (C) 2017 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.
+ *
+ ******************************************************************************/
+
+/******************************************************************************
+ *
+ *  This file contains the Near Field Communication (NFC) VS related internal
+ *  function / definitions.
+ *
+ ******************************************************************************/
+
+#ifndef NFC_VS_H_
+#define NFC_VS_H_
+
+// DTA API for MW Version need to change according to release
+#define NXP_EN_PN547C2 0
+#define NXP_EN_PN65T 0
+#define NXP_EN_PN548C2 0
+#define NXP_EN_PN66T 0
+#define NXP_EN_PN551 0
+#define NXP_EN_PN67T 0
+#define NXP_EN_PN553 1
+#define NXP_EN_PN80T 1
+#define NXP_ANDROID_VER (7U)        /* NXP android version */
+#define NFC_NXP_MW_VERSION_MAJ (4U) /* MW Major Version */
+#define NFC_NXP_MW_VERSION_MIN (9U) /* MW Minor Version */
+
+#endif /* NFC_VS_H_ */
diff --git a/src/nfc/int/rw_int.h b/src/nfc/int/rw_int.h
index 7344087..38958b2 100644
--- a/src/nfc/int/rw_int.h
+++ b/src/nfc/int/rw_int.h
@@ -776,7 +776,7 @@
 
 extern tNFC_STATUS rw_i93_select(uint8_t* p_uid);
 extern void rw_i93_process_timeout(TIMER_LIST_ENT* p_tle);
-
+extern void rw_t4t_handle_isodep_nak_rsp(uint8_t status, bool is_ntf);
 #if (RW_STATS_INCLUDED == TRUE)
 /* Internal fcns for statistics (from rw_main.c) */
 void rw_main_reset_stats(void);
diff --git a/src/nfc/llcp/llcp_api.c b/src/nfc/llcp/llcp_api.c
index 3329bb4..9d87ec0 100644
--- a/src/nfc/llcp/llcp_api.c
+++ b/src/nfc/llcp/llcp_api.c
@@ -58,6 +58,22 @@
 
 /*******************************************************************************
 **
+** Function         LLCP_RegisterDtaCback
+**
+** Description      Register callback function for LLCP DTA testing
+**
+**
+** Returns          void
+**
+*******************************************************************************/
+void LLCP_RegisterDtaCback(tLLCP_DTA_CBACK* p_dta_cback) {
+  LLCP_TRACE_API1("%s", __func__);
+
+  llcp_cb.p_dta_cback = p_dta_cback;
+}
+
+/*******************************************************************************
+**
 ** Function         LLCP_SetConfig
 **
 ** Description      Set configuration parameters for LLCP
diff --git a/src/nfc/llcp/llcp_dlc.c b/src/nfc/llcp/llcp_dlc.c
index a5fe51c..0465a95 100644
--- a/src/nfc/llcp/llcp_dlc.c
+++ b/src/nfc/llcp/llcp_dlc.c
@@ -42,6 +42,7 @@
                                         tLLCP_DLC_EVENT event, void* p_data);
 static tLLCP_STATUS llcp_dlsm_w4_remote_dm(tLLCP_DLCB* p_dlcb,
                                            tLLCP_DLC_EVENT event, void* p_data);
+extern unsigned char appl_dta_mode_flag;
 
 #if (BT_TRACE_VERBOSE == TRUE)
 static char* llcp_dlsm_get_state_name(tLLCP_DLC_STATE state);
@@ -645,7 +646,18 @@
   /* parse CONNECT PDU and get connection parameters */
   if (llcp_util_parse_connect(p_data, length, &params) != LLCP_STATUS_SUCCESS) {
     LLCP_TRACE_ERROR0("llcp_dlc_proc_connect_pdu (): Bad format CONNECT");
-    llcp_util_send_dm(ssap, dsap, LLCP_SAP_DM_REASON_NO_SERVICE);
+    /* fix to pass TC_CTO_TAR_BI_02_x (x=5) test case
+     * As per the LLCP test specification v1.2.00 by receiving erroneous SNL PDU
+     * i'e with improper length and service name "urn:nfc:sn:dta-co-echo-in",
+     * the IUT should not send any PDU except SYMM PDU */
+
+    if (appl_dta_mode_flag == 1 &&
+        p_data[1] == strlen((const char*)&p_data[2])) {
+      LLCP_TRACE_DEBUG1("%s: Strings are not equal", __func__);
+      llcp_util_send_dm(ssap, dsap, LLCP_SAP_DM_REASON_NO_SERVICE);
+    } else {
+      llcp_util_send_dm(ssap, dsap, LLCP_SAP_DM_REASON_NO_SERVICE);
+    }
     return;
   }
 
diff --git a/src/nfc/llcp/llcp_link.c b/src/nfc/llcp/llcp_link.c
index 4be2e5f..5fa6a41 100644
--- a/src/nfc/llcp/llcp_link.c
+++ b/src/nfc/llcp/llcp_link.c
@@ -27,6 +27,7 @@
 #include "gki.h"
 #include "llcp_defs.h"
 #include "llcp_int.h"
+#include "nfa_dm_int.h"
 #include "nfc_int.h"
 #include "nfc_target.h"
 #include "trace_api.h"
@@ -76,6 +77,8 @@
 extern tLLCP_TEST_PARAMS llcp_test_params;
 #endif
 
+extern unsigned char appl_dta_mode_flag;
+
 /* debug functions type */
 #if (BT_TRACE_VERBOSE == TRUE)
 static char* llcp_pdu_type(uint8_t ptype);
@@ -183,6 +186,27 @@
   if (llcp_link_parse_gen_bytes(p_config->gen_bytes_len,
                                 p_config->p_gen_bytes) == false) {
     LLCP_TRACE_ERROR0("llcp_link_activate (): Failed to parse general bytes");
+    /* For LLCP DTA test, In case of bad magic bytes normal p2p communication is
+     * expected,but in case of wrong magic bytes in ATR_REQ, LLC layer will be
+     * disconnected but P2P connection is expected to be in connected state
+     * and non LLC PDU is expected.
+     * As per NFC forum expectation below changes is to send PDU after
+     * disconnect of LLCP PDU.
+     * This is fix for TC_MAC_TAR_BI_01 LLCP test case */
+
+    if (appl_dta_mode_flag == 1 && p_config->is_initiator == FALSE) {
+      NFC_HDR* p_msg = (NFC_HDR*)GKI_getpoolbuf(LLCP_POOL_ID);
+
+      if (p_msg) {
+        /*LLCP test scenario requires non LLC PDU to be sent in case of wrong
+          magic bytes. So sending NFC-DEP pdu with size 1 (0x00)*/
+        p_msg->len = 1;
+        p_msg->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE;
+
+        NFC_SendData(NFC_RF_CONN_ID, p_msg);
+      }
+    }
+
     (*llcp_cb.lcb.p_link_cback)(LLCP_LINK_ACTIVATION_FAILED_EVT,
                                 LLCP_LINK_BAD_GEN_BYTES);
 
@@ -206,11 +230,13 @@
         p_config->waiting_time, llcp_link_rwt[p_config->waiting_time],
         llcp_cb.lcb.peer_lto);
   }
-
-  /* extend LTO as much as internally required processing time and propagation
-   * delays */
-  llcp_cb.lcb.peer_lto += LLCP_INTERNAL_TX_DELAY + LLCP_INTERNAL_RX_DELAY;
-
+  /* For DTA mode Peer LTO Should not include TX RX Delay, Just llcp deactivate
+   * after Peer LTO time */
+  if (!appl_dta_mode_flag) {
+    /* extend LTO as much as internally required processing time and propagation
+     * delays */
+    llcp_cb.lcb.peer_lto += LLCP_INTERNAL_TX_DELAY + LLCP_INTERNAL_RX_DELAY;
+  }
   /* LLCP version number agreement */
   if (llcp_link_version_agreement() == false) {
     LLCP_TRACE_ERROR0("llcp_link_activate (): Failed to agree version");
@@ -403,8 +429,18 @@
   llcp_cb.overall_tx_congested = false;
   llcp_cb.overall_rx_congested = false;
 
+  /* As per the LLCP test specification v1.2.00 for test case TC_LLC_TAR_BV_04
+   * the receiving LLC shall commence sending an LLC PDU to the remote
+   * LLC. So, after IUT receives DISC PDU from LT(remote device), IUT shall
+   * send DISC PDU to LT. appl_dta_mode_flag condition is added to fulfil
+   * above requirement. Only in CR8, the IUT shall acknoweledge with SYMM for
+   * DISC PDU. For other CRx, send DISC PDU.
+   */
   if ((reason == LLCP_LINK_FRAME_ERROR) ||
-      (reason == LLCP_LINK_LOCAL_INITIATED)) {
+      (reason == LLCP_LINK_LOCAL_INITIATED) ||
+      (appl_dta_mode_flag && reason == LLCP_LINK_REMOTE_INITIATED &&
+       llcp_cb.lcb.is_initiator == false &&
+       (nfa_dm_cb.eDtaMode & 0xF0) != NFA_DTA_CR8)) {
     /* get rid of the data pending in NFC tx queue, so DISC PDU can be sent ASAP
      */
     NFC_FlushData(NFC_RF_CONN_ID);
@@ -836,7 +872,9 @@
   */
   llcp_link_check_congestion();
 
-  if (llcp_cb.lcb.symm_state == LLCP_LINK_SYMM_LOCAL_XMIT_NEXT) {
+  if (llcp_cb.lcb.symm_state == LLCP_LINK_SYMM_LOCAL_XMIT_NEXT ||
+      (appl_dta_mode_flag &&
+       llcp_cb.lcb.link_state == LLCP_LINK_STATE_DEACTIVATING)) {
     LLCP_TRACE_DEBUG0(
         "llcp_link_check_send_data () in state of "
         "LLCP_LINK_SYMM_LOCAL_XMIT_NEXT");
@@ -1233,7 +1271,10 @@
         (llcp_cb.lcb.sig_xmit_q.count == 0)) {
       /* this indicates that DISC PDU had been sent out to peer */
       /* initiator may wait for SYMM PDU */
-      llcp_link_process_link_timeout();
+      if (appl_dta_mode_flag == 0x01)
+        llcp_util_send_disc(LLCP_SAP_LM, LLCP_SAP_LM);
+      else
+        llcp_link_process_link_timeout();
     } else {
       if (p_msg->len < LLCP_PDU_HEADER_SIZE) {
         LLCP_TRACE_ERROR1("Received too small PDU: got %d bytes", p_msg->len);
diff --git a/src/nfc/llcp/llcp_sdp.c b/src/nfc/llcp/llcp_sdp.c
index 7253186..2c40263 100644
--- a/src/nfc/llcp/llcp_sdp.c
+++ b/src/nfc/llcp/llcp_sdp.c
@@ -28,6 +28,7 @@
 #include "llcp_api.h"
 #include "llcp_defs.h"
 #include "llcp_int.h"
+#include "nfa_dm_int.h"
 #include "nfc_target.h"
 
 /*******************************************************************************
@@ -73,6 +74,13 @@
 
     GKI_enqueue(&llcp_cb.lcb.sig_xmit_q, llcp_cb.sdp_cb.p_snl);
     llcp_cb.sdp_cb.p_snl = NULL;
+  } else {
+    /* Notify DTA after sending out SNL with SDRES not to send SNLs in AGF PDU
+     */
+    if (llcp_cb.p_dta_cback && llcp_cb.dta_snl_resp) {
+      llcp_cb.dta_snl_resp = false;
+      (*llcp_cb.p_dta_cback)();
+    }
   }
 }
 
@@ -285,6 +293,12 @@
     if ((p_app_cb) && (p_app_cb->p_app_cback) &&
         (strlen((char*)p_app_cb->p_service_name) == length) &&
         (!strncmp((char*)p_app_cb->p_service_name, p_name, length))) {
+      /* if device is under LLCP DTA testing */
+      if (llcp_cb.p_dta_cback && (!strncmp((char*)p_app_cb->p_service_name,
+                                           "urn:nfc:sn:cl-echo-in", length))) {
+        llcp_cb.dta_snl_resp = true;
+      }
+
       return (sap);
     }
   }
@@ -347,6 +361,7 @@
   }
 
   llcp_cb.sdp_cb.next_tid = 0;
+  llcp_cb.dta_snl_resp = false;
 }
 
 /*******************************************************************************
@@ -386,8 +401,29 @@
           p_value = p;
           BE_STREAM_TO_UINT8(tid, p_value);
           sap = llcp_sdp_get_sap_by_name((char*)p_value, (uint8_t)(length - 1));
-          llcp_sdp_send_sdres(tid, sap);
+          /* fix to pass TC_CTO_TAR_BI_03_x (x=5) test case
+           * As per the LLCP test specification v1.2.00 by receiving erroneous
+           * SNL PDU i'e with improper service name "urn:nfc:sn:dta-co-echo-in",
+           * the IUT should not send any PDU except SYMM PDU */
+          if (appl_dta_mode_flag == 1 && sap == 0x00) {
+            LLCP_TRACE_DEBUG2("%s: In dta mode sap == 0x00 p_value = %s",
+                              __func__, p_value);
+            if ((length - 1) == strlen((const char*)p_value)) {
+              LLCP_TRACE_DEBUG1("%s: Strings are not equal", __func__);
+              llcp_sdp_send_sdres(tid, sap);
+            }
+          } else {
+            llcp_sdp_send_sdres(tid, sap);
+          }
         } else {
+          /*For P2P in LLCP mode TC_CTO_TAR_BI_03_x(x=3) fix*/
+          if (appl_dta_mode_flag == 1 &&
+              ((nfa_dm_cb.eDtaMode & 0x0F) == NFA_DTA_LLCP_MODE)) {
+            LLCP_TRACE_ERROR1("%s: Calling llcp_sdp_send_sdres", __func__);
+            tid = 0x01;
+            sap = 0x00;
+            llcp_sdp_send_sdres(tid, sap);
+          }
           LLCP_TRACE_ERROR1(
               "llcp_sdp_proc_snl (): bad length (%d) in LLCP_SDREQ_TYPE",
               length);
diff --git a/src/nfc/nci/nci_hmsgs.c b/src/nfc/nci/nci_hmsgs.c
index 7cecea5..aa4aa94 100644
--- a/src/nfc/nci/nci_hmsgs.c
+++ b/src/nfc/nci/nci_hmsgs.c
@@ -70,22 +70,26 @@
 ** Returns          status
 **
 *******************************************************************************/
-uint8_t nci_snd_core_init(void) {
+uint8_t nci_snd_core_init(uint8_t nci_version) {
   NFC_HDR* p;
   uint8_t* pp;
 
-  p = NCI_GET_CMD_BUF(NCI_CORE_PARAM_SIZE_INIT);
-  if (p == NULL) return (NCI_STATUS_FAILED);
+  if ((p = NCI_GET_CMD_BUF(NCI_CORE_PARAM_SIZE_INIT(nci_version))) == NULL)
+    return (NCI_STATUS_FAILED);
 
   p->event = BT_EVT_TO_NFC_NCI;
-  p->len = NCI_MSG_HDR_SIZE + NCI_CORE_PARAM_SIZE_INIT;
+  p->len = NCI_MSG_HDR_SIZE + NCI_CORE_PARAM_SIZE_INIT(nci_version);
   p->offset = NCI_MSG_OFFSET_SIZE;
   p->layer_specific = 0;
   pp = (uint8_t*)(p + 1) + p->offset;
 
   NCI_MSG_BLD_HDR0(pp, NCI_MT_CMD, NCI_GID_CORE);
   NCI_MSG_BLD_HDR1(pp, NCI_MSG_CORE_INIT);
-  UINT8_TO_STREAM(pp, NCI_CORE_PARAM_SIZE_INIT);
+  UINT8_TO_STREAM(pp, NCI_CORE_PARAM_SIZE_INIT(nci_version));
+  if (nfc_cb.nci_version == NCI_VERSION_2_0) {
+    UINT8_TO_STREAM(pp, NCI2_0_CORE_INIT_CMD_BYTE_0);
+    UINT8_TO_STREAM(pp, NCI2_0_CORE_INIT_CMD_BYTE_1);
+  }
 
   nfc_ncif_send_cmd(p);
   return (NCI_STATUS_OK);
@@ -306,6 +310,36 @@
   nfc_ncif_send_cmd(p);
   return (NCI_STATUS_OK);
 }
+
+/*******************************************************************************
+**
+** Function         nci_snd_iso_dep_nak_presence_check_cmd
+**
+** Description      compose and send RF Management presence check ISO-DEP NAK
+**                  command.
+**
+**
+** Returns          status
+**
+*******************************************************************************/
+uint8_t nci_snd_iso_dep_nak_presence_check_cmd() {
+  NFC_HDR* p;
+  uint8_t* pp;
+
+  if ((p = NCI_GET_CMD_BUF(0)) == NULL) return (NCI_STATUS_FAILED);
+
+  p->event = BT_EVT_TO_NFC_NCI;
+  p->offset = NCI_MSG_OFFSET_SIZE;
+  p->len = NCI_MSG_HDR_SIZE + 0;
+  p->layer_specific = 0;
+  pp = (uint8_t*)(p + 1) + p->offset;
+
+  NCI_MSG_BLD_HDR0(pp, NCI_MT_CMD, NCI_GID_RF_MANAGE);
+  NCI_MSG_BLD_HDR1(pp, NCI_MSG_RF_ISO_DEP_NAK_PRESENCE);
+  UINT8_TO_STREAM(pp, 0x00);
+  nfc_ncif_send_cmd(p);
+  return (NCI_STATUS_OK);
+}
 #endif
 #endif
 
@@ -592,7 +626,37 @@
 
   return (NCI_STATUS_OK);
 }
+/*******************************************************************************
+**
+** Function         nci_snd_set_power_sub_state_cmd
+**
+** Description      compose and send core CORE_SET_POWER_SUB_STATE command
+**                  to command queue
+**
+** Returns          status
+**
+*******************************************************************************/
+uint8_t nci_snd_core_set_power_sub_state(uint8_t screen_state) {
+  NFC_HDR* p = NCI_GET_CMD_BUF(NCI_CORE_PARAM_SIZE_SET_POWER_SUB_STATE);
+  uint8_t* pp;
 
+  if (p == NULL) return (NCI_STATUS_FAILED);
+
+  p->event = BT_EVT_TO_NFC_NCI;
+  p->offset = NCI_MSG_OFFSET_SIZE;
+  p->len = NCI_MSG_HDR_SIZE + NCI_CORE_PARAM_SIZE_SET_POWER_SUB_STATE;
+  p->layer_specific = 0;
+  pp = (uint8_t*)(p + 1) + p->offset;
+
+  NCI_MSG_BLD_HDR0(pp, NCI_MT_CMD, NCI_GID_CORE);
+  NCI_MSG_BLD_HDR1(pp, NCI_MSG_CORE_SET_POWER_SUB_STATE);
+  UINT8_TO_STREAM(pp, NCI_CORE_PARAM_SIZE_SET_POWER_SUB_STATE);
+  UINT8_TO_STREAM(pp, screen_state);
+
+  nfc_ncif_send_cmd(p);
+
+  return (NCI_STATUS_OK);
+}
 /*******************************************************************************
 **
 ** Function         nci_snd_get_routing_cmd
diff --git a/src/nfc/nci/nci_hrcv.c b/src/nfc/nci/nci_hrcv.c
index 1b64384..07757de 100644
--- a/src/nfc/nci/nci_hrcv.c
+++ b/src/nfc/nci/nci_hrcv.c
@@ -80,7 +80,9 @@
     case NCI_MSG_CORE_CONN_CLOSE:
       nfc_ncif_report_conn_close_evt(*p_old, *pp);
       break;
-
+    case NCI_MSG_CORE_SET_POWER_SUB_STATE:
+      nfc_ncif_event_status(NFC_SET_POWER_SUB_STATE_REVT, *pp);
+      break;
     default:
       NFC_TRACE_ERROR1("unknown opcode:0x%x", op_code);
       break;
@@ -200,6 +202,9 @@
       nfc_ncif_event_status(NFC_RF_COMM_PARAMS_UPDATE_REVT, *pp);
       break;
 
+    case NCI_MSG_RF_ISO_DEP_NAK_PRESENCE:
+      nfc_ncif_proc_isodep_nak_presence_check_status(*pp, false);
+      break;
     default:
       NFC_TRACE_ERROR1("unknown opcode:0x%x", op_code);
       break;
@@ -234,6 +239,9 @@
       if (nfa_dm_p2p_prio_logic(op_code, pp, NFA_DM_P2P_PRIO_NTF) == false) {
         return;
       }
+      if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+        nfc_cb.deact_reason = *(pp + 1);
+      }
       nfc_ncif_proc_deactivate(NFC_STATUS_OK, *pp, true);
       break;
 
@@ -268,7 +276,9 @@
       break;
 #endif
 #endif
-
+    case NCI_MSG_RF_ISO_DEP_NAK_PRESENCE:
+      nfc_ncif_proc_isodep_nak_presence_check_status(*pp, true);
+      break;
     default:
       NFC_TRACE_ERROR1("unknown opcode:0x%x", op_code);
       break;
@@ -438,6 +448,34 @@
 
 /*******************************************************************************
 **
+** Function         nci_proc_prop_raw_vs_rsp
+**
+** Description      Process RAW VS responses
+**
+** Returns          void
+**
+*******************************************************************************/
+void nci_proc_prop_raw_vs_rsp(NFC_HDR* p_msg) {
+  uint8_t op_code;
+  tNFC_VS_CBACK* p_cback = (tNFC_VS_CBACK*)nfc_cb.p_vsc_cback;
+
+  /* find the start of the NCI message and parse the NCI header */
+  uint8_t* p_evt = (uint8_t*)(p_msg + 1) + p_msg->offset;
+  uint8_t* p = p_evt + 1;
+  NCI_MSG_PRS_HDR1(p, op_code);
+
+  /* If there's a pending/stored command, restore the associated address of the
+   * callback function */
+  if (p_cback) {
+    (*p_cback)((tNFC_VS_EVT)(NCI_RSP_BIT | op_code), p_msg->len, p_evt);
+    nfc_cb.p_vsc_cback = NULL;
+  }
+  nfc_cb.rawVsCbflag = false;
+  nfc_ncif_update_window();
+}
+
+/*******************************************************************************
+**
 ** Function         nci_proc_prop_ntf
 **
 ** Description      Process NCI notifications in the Proprietary group
diff --git a/src/nfc/nfc/nfc_main.c b/src/nfc/nfc/nfc_main.c
index 2f9c214..9eb147d 100644
--- a/src/nfc/nfc/nfc_main.c
+++ b/src/nfc/nfc/nfc_main.c
@@ -193,8 +193,9 @@
   tNFC_CONN_CB* p_cb = &nfc_cb.conn_cb[NFC_RF_CONN_ID];
   uint8_t* p;
   uint8_t num_interfaces = 0, xx;
+  uint8_t num_interface_extensions = 0, zz;
+  uint8_t interface_type;
   int yy = 0;
-
   memset(&evt_data, 0, sizeof(tNFC_RESPONSE));
 
   if (nfc_status == NCI_STATUS_OK) {
@@ -204,24 +205,26 @@
         NCI_MSG_HDR_SIZE + 1;
     /* we currently only support NCI of the same version.
     * We may need to change this, when we support multiple version of NFCC */
-    evt_data.enable.nci_version = NCI_VERSION;
-    STREAM_TO_UINT32(evt_data.enable.nci_features, p);
-    STREAM_TO_UINT8(num_interfaces, p);
 
-    evt_data.enable.nci_interfaces = 0;
-    for (xx = 0; xx < num_interfaces; xx++) {
-      if ((*p) <= NCI_INTERFACE_MAX)
-        evt_data.enable.nci_interfaces |= (1 << (*p));
-      else if (((*p) >= NCI_INTERFACE_FIRST_VS) &&
-               (yy < NFC_NFCC_MAX_NUM_VS_INTERFACE)) {
-        /* save the VS RF interface in control block, if there's still room */
-        nfc_cb.vs_interface[yy++] = *p;
+    evt_data.enable.nci_version = nfc_cb.nci_version;
+    STREAM_TO_UINT32(evt_data.enable.nci_features, p);
+    if (nfc_cb.nci_version == NCI_VERSION_1_0) {
+      STREAM_TO_UINT8(num_interfaces, p);
+      evt_data.enable.nci_interfaces = 0;
+      for (xx = 0; xx < num_interfaces; xx++) {
+        if ((*p) <= NCI_INTERFACE_MAX)
+          evt_data.enable.nci_interfaces |= (1 << (*p));
+        else if (((*p) >= NCI_INTERFACE_FIRST_VS) &&
+                 (yy < NFC_NFCC_MAX_NUM_VS_INTERFACE)) {
+          /* save the VS RF interface in control block, if there's still room */
+          nfc_cb.vs_interface[yy++] = *p;
+        }
+        p++;
       }
-      p++;
+      nfc_cb.nci_interfaces = evt_data.enable.nci_interfaces;
+      memcpy(evt_data.enable.vs_interface, nfc_cb.vs_interface,
+             NFC_NFCC_MAX_NUM_VS_INTERFACE);
     }
-    nfc_cb.nci_interfaces = evt_data.enable.nci_interfaces;
-    memcpy(evt_data.enable.vs_interface, nfc_cb.vs_interface,
-           NFC_NFCC_MAX_NUM_VS_INTERFACE);
     evt_data.enable.max_conn = *p++;
     STREAM_TO_UINT16(evt_data.enable.max_ce_table, p);
 #if (NFC_RW_ONLY == FALSE)
@@ -231,10 +234,47 @@
 #endif
     nfc_cb.nci_ctrl_size = *p++; /* Max Control Packet Payload Length */
     p_cb->init_credits = p_cb->num_buff = 0;
-    STREAM_TO_UINT16(evt_data.enable.max_param_size, p);
     nfc_set_conn_id(p_cb, NFC_RF_CONN_ID);
-    evt_data.enable.manufacture_id = *p++;
-    STREAM_TO_ARRAY(evt_data.enable.nfcc_info, p, NFC_NFCC_INFO_LEN);
+    if (nfc_cb.nci_version == NCI_VERSION_2_0) {
+      evt_data.enable.hci_packet_size = *p++;
+      evt_data.enable.hci_conn_credits = *p++;
+      STREAM_TO_UINT16(evt_data.enable.max_nfc_v_size, p);
+      STREAM_TO_UINT8(num_interfaces, p);
+#if (NFC_RW_ONLY == FALSE)
+      nfc_cb.hci_packet_size = evt_data.enable.hci_packet_size;
+      nfc_cb.hci_conn_credits = evt_data.enable.hci_conn_credits;
+      nfc_cb.nci_max_v_size = evt_data.enable.max_nfc_v_size;
+#endif
+      evt_data.enable.nci_interfaces = 0;
+
+      for (xx = 0; xx < num_interfaces; xx++) {
+        if ((*p) <= NCI_INTERFACE_MAX)
+          evt_data.enable.nci_interfaces |= (1 << (*p));
+        else if (((*p) >= NCI_INTERFACE_FIRST_VS) &&
+                 (yy < NFC_NFCC_MAX_NUM_VS_INTERFACE)) {
+          /* save the VS RF interface in control block, if there's still room */
+          nfc_cb.vs_interface[yy++] = *p;
+        }
+        interface_type = *p++;
+        num_interface_extensions = *p++;
+        for (zz = 0; zz < num_interface_extensions; zz++) {
+          if (((*p) < NCI_INTERFACE_EXTENSION_MAX) &&
+              (interface_type <= NCI_INTERFACE_MAX)) {
+            nfc_cb.nci_intf_extensions |= (1 << (*p));
+            nfc_cb.nci_intf_extension_map[*p] = (1 << interface_type);
+          }
+          p++;
+        }
+      }
+
+      nfc_cb.nci_interfaces = evt_data.enable.nci_interfaces;
+      memcpy(evt_data.enable.vs_interface, nfc_cb.vs_interface,
+             NFC_NFCC_MAX_NUM_VS_INTERFACE);
+    } else {
+      STREAM_TO_UINT16(evt_data.enable.max_param_size, p);
+      evt_data.enable.manufacture_id = *p++;
+      STREAM_TO_ARRAY(evt_data.enable.nfcc_info, p, NFC_NFCC_INFO_LEN);
+    }
     NFC_DiscoveryMap(nfc_cb.num_disc_maps,
                      (tNCI_DISCOVER_MAPS*)nfc_cb.p_disc_maps, NULL);
   }
@@ -683,7 +723,7 @@
   nfc_cb.trace_level = NFC_INITIAL_TRACE_LEVEL;
   nfc_cb.nci_ctrl_size = NCI_CTRL_INIT_SIZE;
   nfc_cb.reassembly = true;
-
+  nfc_cb.nci_version = NCI_VERSION_UNKNOWN;
   rw_init();
   ce_init();
   llcp_init();
@@ -1104,7 +1144,22 @@
   status = nci_snd_deactivate_cmd(deactivate_type);
   return status;
 }
-
+/*******************************************************************************
+**
+** Function         NFC_SetPowerSubState
+**
+** Description      This function is called to send the power sub state (screen
+**                  state) to NFCC. The response from NFCC is reported by
+**                  tNFC_RESPONSE_CBACK as NFC_SET_POWER_STATE_REVT.
+**
+** Parameters       scree_state
+**
+** Returns          tNFC_STATUS
+**
+*******************************************************************************/
+tNFC_STATUS NFC_SetPowerSubState(uint8_t screen_state) {
+  return nci_snd_core_set_power_sub_state(screen_state);
+}
 /*******************************************************************************
 **
 ** Function         NFC_UpdateRFCommParams
@@ -1241,6 +1296,36 @@
   return (nfc_cb.trace_level);
 }
 
+/*******************************************************************************
+**
+** Function         NFC_GetNCIVersion
+**
+** Description      Called by higher layer to get the current nci
+**                  version of nfc.
+**
+** Returns          NCI version NCI2.0 / NCI1.0
+**
+*******************************************************************************/
+uint8_t NFC_GetNCIVersion() { return nfc_cb.nci_version; }
+
+/*******************************************************************************
+**
+** Function         NFC_ISODEPNakPresCheck
+**
+** Description      This function is called to send the ISO DEP nak presenc
+**                  check cmd to check that the remote end point in RF field.
+**
+**                  The response from NFCC is reported by call back.The ntf
+**                  indicates success if card is present in field or failed
+**                  if card is lost.
+**
+** Returns          tNFC_STATUS
+**
+*******************************************************************************/
+tNFC_STATUS NFC_ISODEPNakPresCheck() {
+  return nci_snd_iso_dep_nak_presence_check_cmd();
+}
+
 #if (BT_TRACE_VERBOSE == TRUE)
 /*******************************************************************************
 **
diff --git a/src/nfc/nfc/nfc_ncif.c b/src/nfc/nfc/nfc_ncif.cc
similarity index 81%
rename from src/nfc/nfc/nfc_ncif.c
rename to src/nfc/nfc/nfc_ncif.cc
index a961bfe..47f49e2 100644
--- a/src/nfc/nfc/nfc_ncif.c
+++ b/src/nfc/nfc/nfc_ncif.cc
@@ -23,10 +23,12 @@
  *  (callback). On the transmit side, it manages the command transmission.
  *
  ******************************************************************************/
+#include <metricslogger/metrics_logger.h>
 #include <stdlib.h>
 #include <string.h>
 #include "nfc_target.h"
 
+#include "include/debug_nfcsnoop.h"
 #include "nci_defs.h"
 #include "nci_hmsgs.h"
 #include "nfc_api.h"
@@ -34,15 +36,18 @@
 #include "nfc_int.h"
 #include "rw_api.h"
 #include "rw_int.h"
-
 #if (NFC_RW_ONLY == FALSE)
 static const uint8_t nfc_mpl_code_to_size[] = {64, 128, 192, 254};
 
 #endif /* NFC_RW_ONLY */
-
+#if (APPL_DTA_MODE == TRUE)
+// Global Structure varibale for FW Version
+static tNFC_FW_VERSION nfc_fw_version;
+#endif
 #define NFC_PB_ATTRIB_REQ_FIXED_BYTES 1
 #define NFC_LB_ATTRIB_REQ_FIXED_BYTES 8
 
+extern unsigned char appl_dta_mode_flag;
 /*******************************************************************************
 **
 ** Function         nfc_ncif_update_window
@@ -207,6 +212,7 @@
 
     /* send to HAL */
     HAL_WRITE(p);
+    nfcsnoop_capture(p, false);
 
     if (!fragmented) {
       /* check if there are more data to send */
@@ -252,14 +258,17 @@
       if (p_buf->layer_specific == NFC_WAIT_RSP_VSC) {
         /* save the callback for NCI VSCs)  */
         nfc_cb.p_vsc_cback = (void*)((tNFC_NCI_VS_MSG*)p_buf)->p_cback;
+      } else if (p_buf->layer_specific == NFC_WAIT_RSP_RAW_VS) {
+        /* save the callback for RAW VS */
+        nfc_cb.p_vsc_cback = (void*)((tNFC_NCI_VS_MSG*)p_buf)->p_cback;
+        nfc_cb.rawVsCbflag = true;
       }
 
-      /* send to HAL */
-      HAL_WRITE(p_buf);
-
       /* Indicate command is pending */
       nfc_cb.nci_cmd_window--;
 
+      /* send to HAL */
+      HAL_WRITE(p_buf);
       /* start NFC command-timeout timer */
       nfc_start_timer(&nfc_cb.nci_wait_rsp_timer,
                       (uint16_t)(NFC_TTYPE_NCI_WAIT_RSP),
@@ -297,6 +306,19 @@
   }
 }
 
+#if (APPL_DTA_MODE == TRUE)
+/*******************************************************************************
+**
+** Function         nfc_ncif_getFWVersion
+**
+** Description      This function is called to fet the FW Version
+**
+** Returns          tNFC_FW_VERSION
+**
+*******************************************************************************/
+tNFC_FW_VERSION nfc_ncif_getFWVersion() { return nfc_fw_version; }
+#endif
+
 /*******************************************************************************
 **
 ** Function         nfc_ncif_send_cmd
@@ -310,6 +332,7 @@
   /* post the p_buf to NCIT task */
   p_buf->event = BT_EVT_TO_NFC_NCI;
   p_buf->layer_specific = 0;
+  nfcsnoop_capture(p_buf, false);
   nfc_ncif_check_cmd_queue(p_buf);
 }
 
@@ -333,7 +356,15 @@
 
   pp = p;
   NCI_MSG_PRS_HDR0(pp, mt, pbf, gid);
+  oid = ((*pp) & NCI_OID_MASK);
+  if (nfc_cb.rawVsCbflag == true &&
+      nfc_ncif_proc_proprietary_rsp(mt, gid, oid) == true) {
+    nci_proc_prop_raw_vs_rsp(p_msg);
+    nfc_cb.rawVsCbflag = false;
+    return free;
+  }
 
+  nfcsnoop_capture(p_msg, true);
   switch (mt) {
     case NCI_MT_DATA:
       NFC_TRACE_DEBUG0("NFC received data");
@@ -465,6 +496,8 @@
 *******************************************************************************/
 void nfc_ncif_event_status(tNFC_RESPONSE_EVT event, uint8_t status) {
   tNFC_RESPONSE evt_data;
+  if (event == NFC_NFCC_TIMEOUT_REVT && status == NFC_STATUS_HW_TIMEOUT)
+    android::metricslogger::LogCounter("nfc_hw_timeout_error", 1);
   if (nfc_cb.p_resp_cback) {
     evt_data.status = (tNFC_STATUS)status;
     (*nfc_cb.p_resp_cback)(event, &evt_data);
@@ -487,6 +520,22 @@
   if (p_cb && p_cb->p_cback) {
     (*p_cb->p_cback)(conn_id, NFC_ERROR_CEVT, (tNFC_CONN*)&status);
   }
+  if (status == NFC_STATUS_TIMEOUT)
+    android::metricslogger::LogCounter("nfc_rf_timeout_error", 1);
+  else if (status == NFC_STATUS_EE_TIMEOUT)
+    android::metricslogger::LogCounter("nfc_ee_timeout_error", 1);
+  else if (status == NFC_STATUS_ACTIVATION_FAILED)
+    android::metricslogger::LogCounter("nfc_rf_activation_failed", 1);
+  else if (status == NFC_STATUS_EE_INTF_ACTIVE_FAIL)
+    android::metricslogger::LogCounter("nfc_ee_activation_failed", 1);
+  else if (status == NFC_STATUS_RF_TRANSMISSION_ERR)
+    android::metricslogger::LogCounter("nfc_rf_transmission_error", 1);
+  else if (status == NFC_STATUS_EE_TRANSMISSION_ERR)
+    android::metricslogger::LogCounter("nfc_ee_transmission_error", 1);
+  else if (status == NFC_STATUS_RF_PROTOCOL_ERR)
+    android::metricslogger::LogCounter("nfc_rf_protocol_error", 1);
+  else if (status == NFC_STATUS_EE_PROTOCOL_ERR)
+    android::metricslogger::LogCounter("nfc_ee_protocol_error", 1);
 }
 
 /*******************************************************************************
@@ -563,13 +612,16 @@
   tNFC_RF_LF_PARAMS* p_lf;
   tNFC_RF_PF_PARAMS* p_pf;
   tNFC_RF_PISO15693_PARAMS* p_i93;
-
+  tNFC_RF_ACM_P_PARAMS* acm_p;
+  uint8_t mpl_idx = 0;
+  uint8_t gb_idx = 0, mpl;
   len = *p++;
   p_start = p;
   memset(&p_param->param, 0, sizeof(tNFC_RF_TECH_PARAMU));
 
   if (NCI_DISCOVERY_TYPE_POLL_A == p_param->mode ||
-      NCI_DISCOVERY_TYPE_POLL_A_ACTIVE == p_param->mode) {
+      (NCI_DISCOVERY_TYPE_POLL_A_ACTIVE == p_param->mode &&
+       NFC_GetNCIVersion() != NCI_VERSION_2_0)) {
     p_pa = &p_param->param.pa;
     /*
 SENS_RES Response   2 bytes Defined in [DIGPROT] Available after Technology
@@ -616,7 +668,8 @@
     STREAM_TO_ARRAY(p_pb->sensb_res, p, p_pb->sensb_res_len);
     memcpy(p_pb->nfcid0, p_pb->sensb_res, NFC_NFCID0_MAX_LEN);
   } else if (NCI_DISCOVERY_TYPE_POLL_F == p_param->mode ||
-             NCI_DISCOVERY_TYPE_POLL_F_ACTIVE == p_param->mode) {
+             (NCI_DISCOVERY_TYPE_POLL_F_ACTIVE == p_param->mode &&
+              NFC_GetNCIVersion() != NCI_VERSION_2_0)) {
     /*
 Bit Rate    1 byte  1   212 kbps/2   424 kbps/0 and 3 to 255  RFU
 SENSF_RES Response length.(n) 1 byte  Length of SENSF_RES (Byte 2 - Byte 17 or
@@ -634,13 +687,14 @@
     p_pf->mrti_check = p_pf->sensf_res[NCI_MRTI_CHECK_INDEX];
     p_pf->mrti_update = p_pf->sensf_res[NCI_MRTI_UPDATE_INDEX];
   } else if (NCI_DISCOVERY_TYPE_LISTEN_F == p_param->mode ||
-             NCI_DISCOVERY_TYPE_LISTEN_F_ACTIVE == p_param->mode) {
+             (NCI_DISCOVERY_TYPE_LISTEN_F_ACTIVE == p_param->mode &&
+              NFC_GetNCIVersion() != NCI_VERSION_2_0)) {
     p_lf = &p_param->param.lf;
     u8 = *p++;
     if (u8) {
       STREAM_TO_ARRAY(p_lf->nfcid2, p, NCI_NFCID2_LEN);
     }
-  } else if (NCI_DISCOVERY_TYPE_POLL_ISO15693 == p_param->mode) {
+  } else if (NCI_DISCOVERY_TYPE_POLL_V == p_param->mode) {
     p_i93 = &p_param->param.pi93;
     p_i93->flag = *p++;
     p_i93->dsfid = *p++;
@@ -653,6 +707,49 @@
       p_param->param.pk.uid_len = NFC_KOVIO_MAX_LEN;
     }
     STREAM_TO_ARRAY(p_param->param.pk.uid, p, p_param->param.pk.uid_len);
+  } else if (NCI_DISCOVERY_TYPE_POLL_ACTIVE == p_param->mode) {
+    acm_p = &p_param->param.acm_p;
+    acm_p->atr_res_len = *p++;
+    if (acm_p->atr_res_len > 0) {
+      if (acm_p->atr_res_len > NFC_MAX_ATS_LEN)
+        acm_p->atr_res_len = NFC_MAX_ATS_LEN;
+      STREAM_TO_ARRAY(acm_p->atr_res, p, acm_p->atr_res_len);
+      /* ATR_RES
+      Byte 3~12 Byte 13 Byte 14 Byte 15 Byte 16 Byte 17 Byte 18~18+n
+      NFCID3T   DIDT    BST     BRT     TO      PPT     [GT0 ... GTn] */
+      mpl_idx = 14;
+      gb_idx = NCI_P_GEN_BYTE_INDEX;
+      acm_p->waiting_time = acm_p->atr_res[NCI_L_NFC_DEP_TO_INDEX] & 0x0F;
+      mpl = ((acm_p->atr_res[mpl_idx]) >> 4) & 0x03;
+      acm_p->max_payload_size = nfc_mpl_code_to_size[mpl];
+      if (acm_p->atr_res_len > gb_idx) {
+        acm_p->gen_bytes_len = acm_p->atr_res_len - gb_idx;
+        if (acm_p->gen_bytes_len > NFC_MAX_GEN_BYTES_LEN)
+          acm_p->gen_bytes_len = NFC_MAX_GEN_BYTES_LEN;
+        memcpy(acm_p->gen_bytes, &acm_p->atr_res[gb_idx], acm_p->gen_bytes_len);
+      }
+    }
+  } else if (NCI_DISCOVERY_TYPE_LISTEN_ACTIVE == p_param->mode) {
+    acm_p = &p_param->param.acm_p;
+    acm_p->atr_res_len = *p++;
+    if (acm_p->atr_res_len > 0) {
+      if (acm_p->atr_res_len > NFC_MAX_ATS_LEN)
+        acm_p->atr_res_len = NFC_MAX_ATS_LEN;
+      STREAM_TO_ARRAY(acm_p->atr_res, p, acm_p->atr_res_len);
+      /* ATR_REQ
+      Byte 3~12 Byte 13 Byte 14 Byte 15 Byte 16 Byte 17~17+n
+      NFCID3I   DIDI    BSI     BRI     PPI     [GI0 ... GIn] */
+      mpl_idx = 13;
+      gb_idx = NCI_L_GEN_BYTE_INDEX;
+      mpl = ((acm_p->atr_res[mpl_idx]) >> 4) & 0x03;
+      acm_p->max_payload_size = nfc_mpl_code_to_size[mpl];
+      if (acm_p->atr_res_len > gb_idx) {
+        acm_p->gen_bytes_len = acm_p->atr_res_len - gb_idx;
+        if (acm_p->gen_bytes_len > NFC_MAX_GEN_BYTES_LEN)
+          acm_p->gen_bytes_len = NFC_MAX_GEN_BYTES_LEN;
+        memcpy(acm_p->gen_bytes, &acm_p->atr_res[gb_idx], acm_p->gen_bytes_len);
+      }
+    }
   }
 
   return (p_start + len);
@@ -687,6 +784,20 @@
 
 /*******************************************************************************
 **
+** Function         nfc_ncif_proc_isodep_nak_presence_check_status
+**
+** Description      This function is called to handle response and notification
+**                  for presence check nak command
+**
+** Returns          void
+**
+*******************************************************************************/
+void nfc_ncif_proc_isodep_nak_presence_check_status(uint8_t status,
+                                                    bool is_ntf) {
+  rw_t4t_handle_isodep_nak_rsp(status, is_ntf);
+}
+/*******************************************************************************
+**
 ** Function         nfc_ncif_proc_activate
 **
 ** Description      This function is called to process de-activate
@@ -852,8 +963,11 @@
       STREAM_TO_ARRAY(p_pa_nfc->atr_res, p, p_pa_nfc->atr_res_len);
       if ((mode == NCI_DISCOVERY_TYPE_POLL_A) ||
           (mode == NCI_DISCOVERY_TYPE_POLL_F) ||
-          (mode == NCI_DISCOVERY_TYPE_POLL_A_ACTIVE) ||
-          (mode == NCI_DISCOVERY_TYPE_POLL_F_ACTIVE)) {
+          ((mode == NCI_DISCOVERY_TYPE_POLL_A_ACTIVE ||
+            mode == NCI_DISCOVERY_TYPE_POLL_F_ACTIVE) &&
+           NFC_GetNCIVersion() != NCI_VERSION_2_0) ||
+          (NFC_GetNCIVersion() == NCI_VERSION_2_0 &&
+           mode == NCI_DISCOVERY_TYPE_POLL_ACTIVE)) {
         /* ATR_RES
         Byte 3~12 Byte 13 Byte 14 Byte 15 Byte 16 Byte 17 Byte 18~18+n
         NFCID3T   DIDT    BST     BRT     TO      PPT     [GT0 ... GTn] */
@@ -863,8 +977,11 @@
             p_pa_nfc->atr_res[NCI_L_NFC_DEP_TO_INDEX] & 0x0F;
       } else if ((mode == NCI_DISCOVERY_TYPE_LISTEN_A) ||
                  (mode == NCI_DISCOVERY_TYPE_LISTEN_F) ||
-                 (mode == NCI_DISCOVERY_TYPE_LISTEN_A_ACTIVE) ||
-                 (mode == NCI_DISCOVERY_TYPE_LISTEN_F_ACTIVE)) {
+                 (NFC_GetNCIVersion() != NCI_VERSION_2_0 &&
+                  (mode == NCI_DISCOVERY_TYPE_LISTEN_A_ACTIVE ||
+                   mode == NCI_DISCOVERY_TYPE_LISTEN_F_ACTIVE)) ||
+                 (NFC_GetNCIVersion() == NCI_VERSION_2_0 &&
+                  mode == NCI_DISCOVERY_TYPE_LISTEN_ACTIVE)) {
         /* ATR_REQ
         Byte 3~12 Byte 13 Byte 14 Byte 15 Byte 16 Byte 17~17+n
         NFCID3I   DIDI    BSI     BRI     PPI     [GI0 ... GIn] */
@@ -895,6 +1012,7 @@
   }
 
   p_cb->act_protocol = evt_data.activate.protocol;
+  p_cb->act_interface = evt_data.activate.intf_param.type;
   p_cb->buff_size = buff_size;
   p_cb->num_buff = num_buff;
   p_cb->init_credits = num_buff;
@@ -925,6 +1043,9 @@
   p_deact->status = status;
   p_deact->type = deact_type;
   p_deact->is_ntf = is_ntf;
+  if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
+    p_deact->reason = nfc_cb.deact_reason;
+  }
 
   while ((p_data = GKI_dequeue(&p_cb->rx_q)) != NULL) {
     GKI_freebuf(p_data);
@@ -1165,37 +1286,60 @@
 **
 *******************************************************************************/
 void nfc_ncif_proc_reset_rsp(uint8_t* p, bool is_ntf) {
+  uint8_t* p_len = p - 1;
   uint8_t status = *p++;
-
+  uint8_t wait_for_ntf = FALSE;
   if (is_ntf) {
     NFC_TRACE_ERROR1("reset notification!!:0x%x ", status);
     /* clean up, if the state is OPEN
      * FW does not report reset ntf right now */
+    if (status == NCI2_0_RESET_TRIGGER_TYPE_CORE_RESET_CMD_RECEIVED ||
+        status == NCI2_0_RESET_TRIGGER_TYPE_POWERED_ON) {
+      NFC_TRACE_DEBUG2("CORE_RESET_NTF Received status nfc_state : 0x%x : 0x%x",
+                       status, nfc_cb.nfc_state);
+      nfc_stop_timer(&nfc_cb.nci_wait_rsp_timer);
+      p++;
+      STREAM_TO_UINT8(nfc_cb.nci_version, p);
+      NFC_TRACE_DEBUG1(" CORE_RESET_NTF nci_version%x", nfc_cb.nci_version);
+      status = NCI_STATUS_OK;
+    } else {
+      /* CORE_RESET_NTF received error case , trigger recovery*/
+      NFC_TRACE_DEBUG2("CORE_RESET_NTF Received status nfc_state : 0x%x : 0x%x",
+                       status, nfc_cb.nfc_state);
+      nfc_ncif_cmd_timeout();
+      status = NCI_STATUS_FAILED;
+    }
     if (nfc_cb.nfc_state == NFC_STATE_OPEN) {
       /*if any conn_cb is connected, close it.
         if any pending outgoing packets are dropped.*/
       nfc_reset_all_conn_cbs();
     }
-    status = NCI_STATUS_OK;
+  } else {
+    NFC_TRACE_DEBUG1("CORE_RESET_RSP len :0x%x ", *p_len);
+    if ((*p_len) == NCI_CORE_RESET_RSP_LEN(NCI_VERSION_2_0)) {
+      wait_for_ntf = TRUE;
+    } else if ((*p_len) == NCI_CORE_RESET_RSP_LEN(NCI_VERSION_1_0)) {
+      nfc_cb.nci_version = NCI_VERSION_1_0;
+    }
   }
 
   if (nfc_cb.flags & (NFC_FL_RESTARTING | NFC_FL_POWER_CYCLE_NFCC)) {
     nfc_reset_all_conn_cbs();
   }
 
-  if (!is_ntf && status == NCI_STATUS_OK) {
-    if ((*p) != NCI_VERSION) {
-      NFC_TRACE_ERROR2("NCI version mismatch!!:0x%02x != 0x%02x ", NCI_VERSION,
-                       *p);
-      if ((*p) < NCI_VERSION_0_F) {
-        NFC_TRACE_ERROR0("NFCC version is too old");
-        status = NCI_STATUS_FAILED;
-      }
-    }
-  }
-
   if (status == NCI_STATUS_OK) {
-    nci_snd_core_init();
+    if (wait_for_ntf == TRUE) {
+      /* reset version reported by NFCC is NCI2.0 , start a timer for 2000ms to
+       * wait for NTF*/
+      nfc_start_timer(&nfc_cb.nci_wait_rsp_timer,
+                      (uint16_t)(NFC_TTYPE_NCI_WAIT_RSP),
+                      nfc_cb.nci_wait_rsp_tout);
+    } else {
+      if (nfc_cb.nci_version == NCI_VERSION_1_0)
+        nci_snd_core_init(NCI_VERSION_1_0);
+      else
+        nci_snd_core_init(NCI_VERSION_2_0);
+    }
   } else {
     NFC_TRACE_ERROR0("Failed to reset NFCC");
     nfc_enabled(status, NULL);
@@ -1220,16 +1364,25 @@
   /* handle init params in nfc_enabled */
   status = *(p + NCI_MSG_HDR_SIZE);
   if (status == NCI_STATUS_OK) {
-    p_cb->id = NFC_RF_CONN_ID;
-    p_cb->act_protocol = NCI_PROTOCOL_UNKNOWN;
+    if (nfc_cb.nci_version == NCI_VERSION_UNKNOWN) {
+      nci_snd_core_reset(NCI_RESET_TYPE_RESET_CFG);
+    } else {
+      p_cb->id = NFC_RF_CONN_ID;
+      p_cb->act_protocol = NCI_PROTOCOL_UNKNOWN;
 
-    nfc_set_state(NFC_STATE_W4_POST_INIT_CPLT);
+      nfc_set_state(NFC_STATE_W4_POST_INIT_CPLT);
 
-    nfc_cb.p_nci_init_rsp = p_msg;
-    nfc_cb.p_hal->core_initialized(p_msg->len - p_msg->offset, p);
+      nfc_cb.p_nci_init_rsp = p_msg;
+      nfc_cb.p_hal->core_initialized(p_msg->len - p_msg->offset, p);
+    }
   } else {
-    nfc_enabled(status, NULL);
-    GKI_freebuf(p_msg);
+    if (nfc_cb.nci_version == NCI_VERSION_UNKNOWN) {
+      nfc_cb.nci_version = NCI_VERSION_1_0;
+      nci_snd_core_reset(NCI_RESET_TYPE_RESET_CFG);
+    } else {
+      nfc_enabled(status, NULL);
+      GKI_freebuf(p_msg);
+    }
   }
 }
 
@@ -1330,6 +1483,22 @@
           p_evt->len--;
           p = (uint8_t*)(p_evt + 1);
           data_cevt.status = *(p + p_evt->offset + p_evt->len);
+          if ((NFC_GetNCIVersion() == NCI_VERSION_2_0) &&
+              (p_cb->act_protocol == NCI_PROTOCOL_T2T) &&
+              (p_cb->act_interface == NCI_INTERFACE_FRAME)) {
+            if ((data_cevt.status != NFC_STATUS_OK) &&
+                ((data_cevt.status >= T2T_STATUS_OK_1_BIT) &&
+                 (data_cevt.status <= T2T_STATUS_OK_7_BIT))) {
+              NFC_TRACE_DEBUG1("%s: T2T tag data xchange", __func__);
+              data_cevt.status = NFC_STATUS_OK;
+            }
+          }
+        }
+        if ((NFC_GetNCIVersion() == NCI_VERSION_2_0) &&
+            (p_cb->act_protocol == NCI_PROTOCOL_T5T)) {
+          p_evt->len--;
+          p = (uint8_t*)(p_evt + 1);
+          data_cevt.status = *(p + p_evt->offset + p_evt->len);
         }
       }
       (*p_cb->p_cback)(p_cb->conn_id, NFC_DATA_CEVT, (tNFC_CONN*)&data_cevt);
@@ -1442,3 +1611,51 @@
   }
   GKI_freebuf(p_msg);
 }
+
+/*******************************************************************************
+**
+** Function         nfc_ncif_process_proprietary_rsp
+**
+** Description      Process the response to avoid collision
+**                  while rawVsCbflag is set
+**
+** Returns          true if proprietary response else false
+**
+*******************************************************************************/
+bool nfc_ncif_proc_proprietary_rsp(uint8_t mt, uint8_t gid, uint8_t oid) {
+  bool stat = FALSE;
+  NFC_TRACE_DEBUG4("%s: mt=%u, gid=%u, oid=%u", __func__, mt, gid, oid);
+
+  switch (mt) {
+    case NCI_MT_DATA:
+      /* check for Data Response */
+      if (gid != 0x03 && oid != 0x00) stat = TRUE;
+      break;
+
+    case NCI_MT_NTF:
+      switch (gid) {
+        case NCI_GID_CORE:
+          /* check for CORE_RESET_NTF or CORE_CONN_CREDITS_NTF */
+          if (oid != 0x00 && oid != 0x06) stat = TRUE;
+          break;
+        case NCI_GID_RF_MANAGE:
+          /* check for CORE_CONN_CREDITS_NTF or NFA_EE_ACTION_NTF or
+           * NFA_EE_DISCOVERY_REQ_NTF */
+          if (oid != 0x06 && oid != 0x09 && oid != 0x0A) stat = TRUE;
+          break;
+        case NCI_GID_EE_MANAGE:
+          if (oid != 0x00) stat = TRUE;
+          break;
+        default:
+          stat = TRUE;
+          break;
+      }
+      break;
+
+    default:
+      stat = TRUE;
+      break;
+  }
+  NFC_TRACE_DEBUG2("%s: exit status=%u", __func__, stat);
+  return stat;
+}
diff --git a/src/nfc/nfc/nfc_task.c b/src/nfc/nfc/nfc_task.c
index 789aca2..3cd9c7a 100644
--- a/src/nfc/nfc/nfc_task.c
+++ b/src/nfc/nfc/nfc_task.c
@@ -343,7 +343,9 @@
   /* main loop */
   while (true) {
     event = GKI_wait(0xFFFF, 0);
-
+    if (event == EVENT_MASK(GKI_SHUTDOWN_EVT)) {
+      break;
+    }
     /* Handle NFC_TASK_EVT_TRANSPORT_READY from NFC HAL */
     if (event & NFC_TASK_EVT_TRANSPORT_READY) {
       NFC_TRACE_DEBUG0("NFC_TASK got NFC_TASK_EVT_TRANSPORT_READY.");
diff --git a/src/nfc/nfc/nfc_vs.c b/src/nfc/nfc/nfc_vs.c
index 7f8be28..5e2548a 100644
--- a/src/nfc/nfc/nfc_vs.c
+++ b/src/nfc/nfc/nfc_vs.c
@@ -73,6 +73,36 @@
 
 /*******************************************************************************
 **
+** Function         NFC_SendRawVsCommand
+**
+** Description      This function is called to send the raw vendor specific
+**                  command to NFCC. The response from NFCC is reported to the
+**                  given tNFC_VS_CBACK.
+**
+** Parameters       p_data - The command buffer
+**
+** Returns          tNFC_STATUS
+**
+*******************************************************************************/
+tNFC_STATUS NFC_SendRawVsCommand(NFC_HDR* p_data, tNFC_VS_CBACK* p_cback) {
+  /* Validate parameters */
+  if (p_data == NULL || (p_data->len > NCI_MAX_VSC_SIZE)) {
+    NFC_TRACE_ERROR1("buffer offset must be >= %d", NCI_VSC_MSG_HDR_SIZE);
+    if (p_data) GKI_freebuf(p_data);
+    return NFC_STATUS_INVALID_PARAM;
+  }
+
+  p_data->event = BT_EVT_TO_NFC_NCI;
+  p_data->layer_specific = NFC_WAIT_RSP_RAW_VS;
+  /* save the callback function in the BT_HDR, to receive the response */
+  ((tNFC_NCI_VS_MSG*)p_data)->p_cback = p_cback;
+
+  nfc_ncif_check_cmd_queue(p_data);
+  return NFC_STATUS_OK;
+}
+
+/*******************************************************************************
+**
 ** Function         NFC_SendVsCommand
 **
 ** Description      This function is called to send the given vendor specific
diff --git a/src/nfc/tags/rw_i93.c b/src/nfc/tags/rw_i93.c
index e6b1323..a4740db 100644
--- a/src/nfc/tags/rw_i93.c
+++ b/src/nfc/tags/rw_i93.c
@@ -1717,7 +1717,7 @@
       }
 
       rw_data.ndef.status = NFC_STATUS_OK;
-      rw_data.ndef.protocol = NFC_PROTOCOL_15693;
+      rw_data.ndef.protocol = NFC_PROTOCOL_T5T;
       rw_data.ndef.flags = 0;
       rw_data.ndef.flags |= RW_NDEF_FL_SUPPORTED;
       rw_data.ndef.flags |= RW_NDEF_FL_FORMATED;
@@ -2580,7 +2580,7 @@
         break;
 
       case RW_I93_STATE_DETECT_NDEF:
-        rw_data.ndef.protocol = NFC_PROTOCOL_15693;
+        rw_data.ndef.protocol = NFC_PROTOCOL_T5T;
         rw_data.ndef.cur_size = 0;
         rw_data.ndef.max_size = 0;
         rw_data.ndef.flags = 0;
@@ -2693,7 +2693,8 @@
 
   RW_TRACE_DEBUG1("rw_i93_data_cback () event = 0x%X", event);
 
-  if ((event == NFC_DEACTIVATE_CEVT) || (event == NFC_ERROR_CEVT)) {
+  if ((event == NFC_DEACTIVATE_CEVT) || (event == NFC_ERROR_CEVT) ||
+      ((event == NFC_DATA_CEVT) && (p_data->status != NFC_STATUS_OK))) {
     nfc_stop_quick_timer(&p_i93->timer);
 
     if (event == NFC_ERROR_CEVT) {
@@ -2831,7 +2832,7 @@
 **
 ** Function         rw_i93_select
 **
-** Description      Initialise ISO 15693 RW
+** Description      Initialise ISO 15693 / T5T RW
 **
 ** Returns          NFC_STATUS_OK if success
 **
diff --git a/src/nfc/tags/rw_main.c b/src/nfc/tags/rw_main.c
index 04ee723..9ff1d14 100644
--- a/src/nfc/tags/rw_main.c
+++ b/src/nfc/tags/rw_main.c
@@ -239,10 +239,9 @@
         (p_activate_params->rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A)) {
       status = rw_t4t_select();
     }
-  } else if (NFC_PROTOCOL_15693 == p_activate_params->protocol) {
-    /* ISO 15693 */
-    if (p_activate_params->rf_tech_param.mode ==
-        NFC_DISCOVERY_TYPE_POLL_ISO15693) {
+  } else if (NFC_PROTOCOL_T5T == p_activate_params->protocol) {
+    /* T5T */
+    if (p_activate_params->rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_V) {
       status = rw_i93_select(p_activate_params->rf_tech_param.param.pi93.uid);
     }
   }
diff --git a/src/nfc/tags/rw_t1t.c b/src/nfc/tags/rw_t1t.c
index 6d685b8..2c7e02d 100644
--- a/src/nfc/tags/rw_t1t.c
+++ b/src/nfc/tags/rw_t1t.c
@@ -32,6 +32,7 @@
 #include "rw_api.h"
 #include "rw_int.h"
 
+extern unsigned char appl_dta_mode_flag;
 /* Local Functions */
 static tRW_EVENT rw_t1t_handle_rid_rsp(NFC_HDR* p_pkt);
 static void rw_t1t_data_cback(uint8_t conn_id, tNFC_CONN_EVT event,
@@ -682,7 +683,7 @@
 
   p_t1t->state = RW_T1T_STATE_IDLE;
 #if (RW_NDEF_INCLUDED == TRUE)
-  if (p_t1t->state != RW_T1T_STATE_READ_NDEF) {
+  if (appl_dta_mode_flag == 0 && (p_t1t->state != RW_T1T_STATE_READ_NDEF)) {
     p_t1t->b_update = false;
     p_t1t->b_rseg = false;
   }
diff --git a/src/nfc/tags/rw_t4t.c b/src/nfc/tags/rw_t4t.c
index f0ac0b9..e7b3c96 100644
--- a/src/nfc/tags/rw_t4t.c
+++ b/src/nfc/tags/rw_t4t.c
@@ -976,7 +976,7 @@
   }
 
   if ((p_t4t->cc_file.ndef_fc.write_access != T4T_FC_WRITE_ACCESS) &&
-      (p_t4t->cc_file.ndef_fc.write_access != T4T_FC_NO_WRITE_ACCESS)) {
+      (p_t4t->cc_file.ndef_fc.write_access < T4T_FC_WRITE_ACCESS_PROP_START)) {
     RW_TRACE_ERROR1(
         "rw_t4t_validate_cc_file (): Write Access (0x%02X) is invalid",
         p_t4t->cc_file.ndef_fc.write_access);
@@ -1736,6 +1736,27 @@
 
 /*******************************************************************************
 **
+** Function         rw_t4t_handle_isodep_nak_rsp
+**
+** Description      This function handles the response and ntf .
+**
+** Returns          none
+**
+*******************************************************************************/
+void rw_t4t_handle_isodep_nak_rsp(uint8_t status, bool is_ntf) {
+  tRW_DATA rw_data;
+  tRW_T4T_CB* p_t4t = &rw_cb.tcb.t4t;
+  RW_TRACE_DEBUG1("rw_t4t_handle_isodep_nak_rsp %d", status);
+  if (is_ntf || (status != NFC_STATUS_OK)) {
+    rw_data.status = status;
+    nfc_stop_quick_timer(&p_t4t->timer);
+    p_t4t->state = RW_T4T_STATE_IDLE;
+    (*(rw_cb.p_cback))(RW_T4T_PRESENCE_CHECK_EVT, &rw_data);
+  }
+}
+
+/*******************************************************************************
+**
 ** Function         rw_t4t_data_cback
 **
 ** Description      This callback function receives the data from NFCC.
@@ -2124,6 +2145,8 @@
         if (NFC_SendData(NFC_RF_CONN_ID, (NFC_HDR*)p_data) == NFC_STATUS_OK)
           status = true;
       }
+    } else if (option == RW_T4T_CHK_ISO_DEP_NAK_PRES_CHK) {
+      if (NFC_ISODEPNakPresCheck() == NFC_STATUS_OK) status = true;
     } else {
       /* use read binary on the given channel */
       rw_cb.tcb.t4t.channel = 0;