Chip type decided at runtime.

Dynamically detect chip type, load configuarations
and firmware file base on chip type.

Test: NFC enable/disable.
Change-Id: Iec6bd7f82ed65482df4b800e841e39e88968e201
diff --git a/Android.bp b/Android.bp
index 0666007..0a5cd9a 100755
--- a/Android.bp
+++ b/Android.bp
@@ -18,8 +18,6 @@
     proprietary: true,
 
     cflags: [
-        "-DNFC_NXP_CHIP_TYPE=PN557",
-        "-DPN557=1",
         "-Wall",
         "-Werror",
         "-Wextra",
@@ -42,6 +40,7 @@
         "halimpl/tml/phTmlNfc.cc",
         "halimpl/tml/phTmlNfc_i2c.cc",
         "halimpl/tml/spi_spm.cc",
+        "halimpl/utils/NxpNfcCapability.cpp",
         "halimpl/utils/phNxpConfig.cpp",
         "halimpl/utils/phNxpNciHal_utils.cc",
         "halimpl/utils/sparse_crc32.cc",
diff --git a/extns/impl/Nxp_Features.h b/extns/impl/Nxp_Features.h
index 10f2400..6c03877 100755
--- a/extns/impl/Nxp_Features.h
+++ b/extns/impl/Nxp_Features.h
@@ -16,26 +16,16 @@
  *
  ******************************************************************************/
 
-#include <unistd.h>
-#include <string.h>
 #ifndef NXP_FEATURES_H
 #define NXP_FEATURES_H
-
-#define STRMAX_1 40
-#define STRMAX_2 100
-#define FW_DLL_EXTENSION ".so"
+#include <unistd.h>
+#include <string>
 
 #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
-
-#define NFA_EE_MAX_EE_SUPPORTED 4
-
-#define JCOP_VER_3_1 1
-#define JCOP_VER_3_2 2
-#define JCOP_VER_3_3 3
-#define JCOP_VER_4_0 4
-
+#define FW_MOBILE_MAJOR_NUMBER_PN557 0x01
+ using namespace std;
 typedef enum {
   pn547C2 = 0x01,
   pn65T,
@@ -50,86 +40,12 @@
 } tNFC_chipType;
 
 typedef struct {
-  /*Flags common to all chip types*/
-  uint8_t _NXP_NFCC_EMPTY_DATA_PACKET : 1;
-  uint8_t _GEMALTO_SE_SUPPORT : 1;
-  uint8_t _NFCC_I2C_READ_WRITE_IMPROVEMENT : 1;
-  uint8_t _NFCC_MIFARE_TIANJIN : 1;
-  uint8_t _NFCC_MW_RCVRY_BLK_FW_DNLD : 1;
-  uint8_t _NFCC_DYNAMIC_DUAL_UICC : 1;
-  uint8_t _NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH : 1;
-  uint8_t _NFC_NXP_STAT_DUAL_UICC_WO_EXT_SWITCH : 1;
-  uint8_t _NFCC_FW_WA : 1;
-  uint8_t _NFCC_FORCE_NCI1_0_INIT : 1;
-  uint8_t _NFCC_ROUTING_BLOCK_BIT : 1;
-  uint8_t _NFCC_SPI_FW_DOWNLOAD_SYNC : 1;
-  uint8_t _HW_ANTENNA_LOOP4_SELF_TEST : 1;
-  uint8_t _NFCEE_REMOVED_NTF_RECOVERY : 1;
-  uint8_t _NFCC_FORCE_FW_DOWNLOAD : 1;
-  uint8_t _UICC_CREATE_CONNECTIVITY_PIPE : 1;
-  uint8_t _NFCC_AID_MATCHING_PLATFORM_CONFIG : 1;
-  uint8_t _NFCC_ROUTING_BLOCK_BIT_PROP : 1;
-  uint8_t _NXP_NFC_UICC_ETSI12 : 1;
-  uint8_t _NFA_EE_MAX_EE_SUPPORTED : 3;
-} tNfc_nfccFeatureList;
-
-typedef struct {
-  uint8_t _ESE_EXCLUSIVE_WIRED_MODE : 2;
-  uint8_t _ESE_WIRED_MODE_RESUME : 2;
-  uint8_t _ESE_WIRED_MODE_TIMEOUT : 2;
-  uint8_t _ESE_PN67T_RESET : 2;
-  uint8_t _ESE_APDU_GATE_RESET : 2;
-  uint8_t _ESE_WIRED_MODE_DISABLE_DISCOVERY : 1;
-  uint8_t _LEGACY_APDU_GATE : 1;
-  uint8_t _TRIPLE_MODE_PROTECTION : 1;
-  uint8_t _ESE_FELICA_CLT : 1;
-  uint8_t _WIRED_MODE_STANDBY_PROP : 1;
-  uint8_t _WIRED_MODE_STANDBY : 1;
-  uint8_t _ESE_DUAL_MODE_PRIO_SCHEME : 2;
-  uint8_t _ESE_FORCE_ENABLE : 1;
-  uint8_t _ESE_RESET_METHOD : 1;
-  uint8_t _EXCLUDE_NV_MEM_DEPENDENCY : 1;
-  uint8_t _ESE_ETSI_READER_ENABLE : 1;
-  uint8_t _ESE_SVDD_SYNC : 1;
-  uint8_t _NFCC_ESE_UICC_CONCURRENT_ACCESS_PROTECTION : 1;
-  uint8_t _ESE_JCOP_DWNLD_PROTECTION : 1;
-  uint8_t _UICC_HANDLE_CLEAR_ALL_PIPES : 1;
-  uint8_t _GP_CONTINOUS_PROCESSING : 1;
-  uint8_t _ESE_DWP_SPI_SYNC_ENABLE : 1;
-  uint8_t _ESE_ETSI12_PROP_INIT : 1;
-  uint8_t _ESE_WIRED_MODE_PRIO : 1;
-  uint8_t _ESE_UICC_EXCLUSIVE_WIRED_MODE : 1;
-  uint8_t _ESE_POWER_MODE : 1;
-  uint8_t _ESE_P73_ISO_RST : 1;
-  uint8_t _BLOCK_PROPRIETARY_APDU_GATE : 1;
-  uint8_t _JCOP_WA_ENABLE : 1;
-  uint8_t _NXP_LDR_SVC_VER_2 : 1;
-  uint8_t _NXP_ESE_VER : 3;
-} tNfc_eseFeatureList;
-typedef struct { uint8_t _NFCC_RESET_RSP_LEN; } tNfc_platformFeatureList;
-
-typedef struct {
-  uint8_t _NCI_INTERFACE_UICC_DIRECT;
-  uint8_t _NCI_INTERFACE_ESE_DIRECT;
-  uint8_t _NCI_PWR_LINK_PARAM_CMD_SIZE;
-  uint8_t _NCI_EE_PWR_LINK_ALWAYS_ON;
-  uint8_t _NFA_EE_MAX_AID_ENTRIES;
-  uint8_t _NFC_NXP_AID_MAX_SIZE_DYN : 1;
-  uint8_t _FW_LIB_PATH[STRMAX_2];
-  uint8_t _PLATFORM_LIB_PATH[STRMAX_2];
-  uint8_t _PKU_LIB_PATH[STRMAX_2];
+  tNFC_chipType chipType;
+  std::string _FW_LIB_PATH;
+  std::string _FW_BIN_PATH;
   uint16_t _PHDNLDNFC_USERDATA_EEPROM_OFFSET;
   uint16_t _PHDNLDNFC_USERDATA_EEPROM_LEN;
   uint8_t _FW_MOBILE_MAJOR_NUMBER;
-} tNfc_nfcMwFeatureList;
-
-typedef struct {
-  uint8_t nfcNxpEse : 1;
-  tNFC_chipType chipType;
-  tNfc_nfccFeatureList nfccFL;
-  tNfc_eseFeatureList eseFL;
-  tNfc_platformFeatureList platformFL;
-  tNfc_nfcMwFeatureList nfcMwFL;
 } tNfc_featureList;
 
 extern tNfc_featureList nfcFL;
@@ -137,308 +53,55 @@
 #define CONFIGURE_FEATURELIST(chipType)                                      \
   {                                                                          \
     nfcFL.chipType = chipType;                                               \
-    nfcFL.nfcMwFL._NFC_NXP_AID_MAX_SIZE_DYN = true;                          \
     if (chipType == pn81T) {                                                 \
       nfcFL.chipType = pn557;                                                \
     } else if (chipType == pn80T) {                                          \
       nfcFL.chipType = pn553;                                                \
     } else if (chipType == pn67T) {                                          \
       nfcFL.chipType = pn551;                                                \
-    } else if (chipType == pn66T) {                                          \
-      nfcFL.chipType = pn548C2;                                              \
-    } else if (chipType == pn65T) {                                          \
-      nfcFL.chipType = pn547C2;                                              \
     }                                                                        \
-    if ((chipType == pn65T) || (chipType == pn66T) || (chipType == pn67T) || \
-        (chipType == pn80T) || (chipType == pn81T)) {                        \
-      nfcFL.nfcNxpEse = true;                                                \
-      CONFIGURE_FEATURELIST_NFCC_WITH_ESE(chipType)                          \
-    } else {                                                                 \
-      nfcFL.nfcNxpEse = false;                                               \
       CONFIGURE_FEATURELIST_NFCC(chipType)                                   \
-    }                                                                        \
-  }
-
-#define CONFIGURE_FEATURELIST_NFCC_WITH_ESE(chipType)                 \
-  {                                                                   \
-    nfcFL.nfccFL._NXP_NFCC_EMPTY_DATA_PACKET = true;                  \
-    nfcFL.nfccFL._GEMALTO_SE_SUPPORT = true;                          \
-                                                                      \
-    nfcFL.eseFL._ESE_EXCLUSIVE_WIRED_MODE = 1;                        \
-    nfcFL.eseFL._ESE_WIRED_MODE_RESUME = 2;                           \
-    nfcFL.eseFL._ESE_PN67T_RESET = 1;                                 \
-    nfcFL.eseFL._ESE_APDU_GATE_RESET = 2;                             \
-    nfcFL.eseFL._NXP_ESE_VER = JCOP_VER_4_0;                          \
-    nfcFL.eseFL._NXP_LDR_SVC_VER_2 = true;                            \
-                                                                      \
-    if (chipType == pn81T) {                                          \
-      CONFIGURE_FEATURELIST_NFCC(pn557)                               \
-      nfcFL.nfccFL._NFCC_SPI_FW_DOWNLOAD_SYNC = true;                 \
-      nfcFL.nfccFL._NFA_EE_MAX_EE_SUPPORTED = 4;                      \
-                                                                      \
-      nfcFL.eseFL._ESE_FELICA_CLT = true;                             \
-      nfcFL.eseFL._ESE_DUAL_MODE_PRIO_SCHEME =                        \
-          nfcFL.eseFL._ESE_WIRED_MODE_RESUME;                         \
-      nfcFL.eseFL._ESE_RESET_METHOD = true;                           \
-      nfcFL.eseFL._ESE_POWER_MODE = true;                             \
-      nfcFL.eseFL._ESE_P73_ISO_RST = true;                            \
-      nfcFL.eseFL._WIRED_MODE_STANDBY = true;                         \
-      nfcFL.eseFL._ESE_ETSI_READER_ENABLE = true;                     \
-      nfcFL.eseFL._ESE_SVDD_SYNC = true;                              \
-      nfcFL.eseFL._ESE_JCOP_DWNLD_PROTECTION = true;                  \
-      nfcFL.eseFL._UICC_HANDLE_CLEAR_ALL_PIPES = true;                \
-      nfcFL.eseFL._GP_CONTINOUS_PROCESSING = false;                   \
-      nfcFL.eseFL._ESE_DWP_SPI_SYNC_ENABLE = true;                    \
-      nfcFL.eseFL._ESE_ETSI12_PROP_INIT = true;                       \
-    }                                                                 \
-    if (chipType == pn80T) {                                          \
-      CONFIGURE_FEATURELIST_NFCC(pn553)                               \
-      nfcFL.nfccFL._NFA_EE_MAX_EE_SUPPORTED = 4;                      \
-                                                                      \
-      nfcFL.eseFL._ESE_FELICA_CLT = true;                             \
-      nfcFL.eseFL._WIRED_MODE_STANDBY = true;                         \
-      nfcFL.eseFL._ESE_DUAL_MODE_PRIO_SCHEME =                        \
-          nfcFL.eseFL._ESE_WIRED_MODE_RESUME;                         \
-      nfcFL.eseFL._ESE_RESET_METHOD = true;                           \
-      nfcFL.eseFL._ESE_ETSI_READER_ENABLE = true;                     \
-      nfcFL.eseFL._ESE_SVDD_SYNC = true;                              \
-      nfcFL.eseFL._ESE_JCOP_DWNLD_PROTECTION = true;                  \
-      nfcFL.eseFL._UICC_HANDLE_CLEAR_ALL_PIPES = true;                \
-      nfcFL.eseFL._ESE_DWP_SPI_SYNC_ENABLE = true;                    \
-      nfcFL.eseFL._ESE_POWER_MODE = true;                             \
-      nfcFL.eseFL._ESE_P73_ISO_RST = true;                            \
-                                                                      \
-      nfcFL.nfcMwFL._NCI_PWR_LINK_PARAM_CMD_SIZE = 0x02;              \
-      nfcFL.nfcMwFL._NCI_EE_PWR_LINK_ALWAYS_ON = 0x01;                \
-    } else if (chipType == pn67T) {                                   \
-      CONFIGURE_FEATURELIST_NFCC(pn551)                               \
-      nfcFL.nfccFL._NFA_EE_MAX_EE_SUPPORTED = 3;                      \
-                                                                      \
-      nfcFL.eseFL._TRIPLE_MODE_PROTECTION = true;                     \
-      nfcFL.eseFL._WIRED_MODE_STANDBY_PROP = true;                    \
-      nfcFL.eseFL._ESE_FORCE_ENABLE = true;                           \
-      nfcFL.eseFL._ESE_ETSI_READER_ENABLE = true;                     \
-      nfcFL.eseFL._ESE_SVDD_SYNC = true;                              \
-      nfcFL.eseFL._LEGACY_APDU_GATE = true;                           \
-      nfcFL.eseFL._NFCC_ESE_UICC_CONCURRENT_ACCESS_PROTECTION = true; \
-      nfcFL.eseFL._ESE_DWP_SPI_SYNC_ENABLE = true;                    \
-      nfcFL.eseFL._NXP_ESE_VER = JCOP_VER_3_3;                        \
-    } else if (chipType == pn66T) {                                   \
-      CONFIGURE_FEATURELIST_NFCC(pn548C2)                             \
-      nfcFL.nfccFL._NFA_EE_MAX_EE_SUPPORTED = 3;                      \
-                                                                      \
-      nfcFL.eseFL._TRIPLE_MODE_PROTECTION = true;                     \
-      nfcFL.eseFL._WIRED_MODE_STANDBY_PROP = true;                    \
-      nfcFL.eseFL._ESE_FORCE_ENABLE = true;                           \
-      nfcFL.eseFL._ESE_ETSI_READER_ENABLE = true;                     \
-      nfcFL.eseFL._ESE_SVDD_SYNC = true;                              \
-      nfcFL.eseFL._LEGACY_APDU_GATE = true;                           \
-      nfcFL.eseFL._NFCC_ESE_UICC_CONCURRENT_ACCESS_PROTECTION = true; \
-      nfcFL.eseFL._ESE_DWP_SPI_SYNC_ENABLE = true;                    \
-      nfcFL.eseFL._NXP_ESE_VER = JCOP_VER_3_3;                        \
-    } else if (chipType == pn65T) {                                   \
-      CONFIGURE_FEATURELIST_NFCC(pn547C2)                             \
-      nfcFL.nfccFL._NFA_EE_MAX_EE_SUPPORTED = 3;                      \
-      nfcFL.eseFL._ESE_WIRED_MODE_DISABLE_DISCOVERY = true;           \
-      nfcFL.eseFL._LEGACY_APDU_GATE = true;                           \
-    }                                                                 \
   }
 
 #define CONFIGURE_FEATURELIST_NFCC(chipType)                                \
   {                                                                         \
-    nfcFL.eseFL._ESE_WIRED_MODE_TIMEOUT = 3;                                \
-    nfcFL.eseFL._ESE_WIRED_MODE_DISABLE_DISCOVERY = false;                  \
-    nfcFL.eseFL._LEGACY_APDU_GATE = false;                                  \
-    nfcFL.eseFL._TRIPLE_MODE_PROTECTION = false;                            \
-    nfcFL.eseFL._ESE_FELICA_CLT = false;                                    \
-    nfcFL.eseFL._WIRED_MODE_STANDBY_PROP = false;                           \
-    nfcFL.eseFL._WIRED_MODE_STANDBY = false;                                \
-    nfcFL.eseFL._ESE_DUAL_MODE_PRIO_SCHEME =                                \
-        nfcFL.eseFL._ESE_WIRED_MODE_TIMEOUT;                                \
-    nfcFL.eseFL._ESE_FORCE_ENABLE = false;                                  \
-    nfcFL.eseFL._ESE_RESET_METHOD = false;                                  \
-    nfcFL.eseFL._ESE_ETSI_READER_ENABLE = false;                            \
-    nfcFL.eseFL._ESE_SVDD_SYNC = false;                                     \
-    nfcFL.eseFL._NFCC_ESE_UICC_CONCURRENT_ACCESS_PROTECTION = false;        \
-    nfcFL.eseFL._ESE_JCOP_DWNLD_PROTECTION = false;                         \
-    nfcFL.eseFL._UICC_HANDLE_CLEAR_ALL_PIPES = false;                       \
-    nfcFL.eseFL._GP_CONTINOUS_PROCESSING = false;                           \
-    nfcFL.eseFL._ESE_DWP_SPI_SYNC_ENABLE = false;                           \
-    nfcFL.eseFL._ESE_ETSI12_PROP_INIT = false;                              \
-    nfcFL.eseFL._ESE_WIRED_MODE_PRIO = false;                               \
-    nfcFL.eseFL._ESE_UICC_EXCLUSIVE_WIRED_MODE = false;                     \
-    nfcFL.eseFL._ESE_POWER_MODE = false;                                    \
-    nfcFL.eseFL._ESE_P73_ISO_RST = false;                                   \
-    nfcFL.eseFL._BLOCK_PROPRIETARY_APDU_GATE = false;                       \
-    nfcFL.eseFL._JCOP_WA_ENABLE = true;                                     \
-    nfcFL.eseFL._EXCLUDE_NV_MEM_DEPENDENCY = false;                         \
-    nfcFL.nfccFL._NXP_NFC_UICC_ETSI12 = false;                              \
-    nfcFL.nfccFL._NFCC_SPI_FW_DOWNLOAD_SYNC = false;                        \
+    nfcFL._PHDNLDNFC_USERDATA_EEPROM_OFFSET = 0x023CU;                      \
+    nfcFL._PHDNLDNFC_USERDATA_EEPROM_LEN = 0x0C80U;                         \
                                                                             \
-    nfcFL.platformFL._NFCC_RESET_RSP_LEN = 0;                               \
+    if (chipType == pn557 || chipType == pn81T) {                           \
                                                                             \
-    nfcFL.nfcMwFL._NCI_INTERFACE_UICC_DIRECT = 0x00;                        \
-    nfcFL.nfcMwFL._NCI_INTERFACE_ESE_DIRECT = 0x00;                         \
-    nfcFL.nfcMwFL._NCI_PWR_LINK_PARAM_CMD_SIZE = 0x02;                      \
-    nfcFL.nfcMwFL._NCI_EE_PWR_LINK_ALWAYS_ON = 0x01;                        \
-    nfcFL.nfcMwFL._PHDNLDNFC_USERDATA_EEPROM_OFFSET = 0x023CU;              \
-    nfcFL.nfcMwFL._PHDNLDNFC_USERDATA_EEPROM_LEN = 0x0C80U;                 \
-    nfcFL.nfcMwFL._FW_MOBILE_MAJOR_NUMBER = FW_MOBILE_MAJOR_NUMBER_PN48AD;  \
+      STRCPY_FW_LIB("libpn557_fw")                                          \
+      STRCPY_FW_BIN("pn557")                                                \
                                                                             \
-    if (chipType == pn557) {                                                \
-      nfcFL.nfccFL._NFCC_I2C_READ_WRITE_IMPROVEMENT = true;                 \
-      nfcFL.nfccFL._NFCC_MIFARE_TIANJIN = false;                            \
-      nfcFL.nfccFL._NFCC_MW_RCVRY_BLK_FW_DNLD = true;                       \
-      nfcFL.nfccFL._NFCC_DYNAMIC_DUAL_UICC = true;                          \
-      nfcFL.nfccFL._NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH = false;              \
-      nfcFL.nfccFL._NFC_NXP_STAT_DUAL_UICC_WO_EXT_SWITCH = true;            \
-      nfcFL.nfccFL._NFCC_FW_WA = true;                                      \
-      nfcFL.nfccFL._NFCC_FORCE_NCI1_0_INIT = false;                         \
-      nfcFL.nfccFL._NFCC_SPI_FW_DOWNLOAD_SYNC = true;                       \
-      nfcFL.nfccFL._HW_ANTENNA_LOOP4_SELF_TEST = false;                     \
-      nfcFL.nfccFL._NFCEE_REMOVED_NTF_RECOVERY = true;                      \
-      nfcFL.nfccFL._NFCC_FORCE_FW_DOWNLOAD = true;                          \
-      nfcFL.nfccFL._UICC_CREATE_CONNECTIVITY_PIPE = true;                   \
-      nfcFL.nfccFL._NXP_NFC_UICC_ETSI12 = false;                            \
-      nfcFL.nfccFL._NFA_EE_MAX_EE_SUPPORTED = 3;                            \
+      nfcFL._FW_MOBILE_MAJOR_NUMBER = FW_MOBILE_MAJOR_NUMBER_PN557;         \
+    } else if (chipType == pn553 || chipType == pn80T) {                    \
                                                                             \
-      nfcFL.eseFL._ESE_ETSI12_PROP_INIT = true;                             \
-      nfcFL.eseFL._EXCLUDE_NV_MEM_DEPENDENCY = true;                        \
+      STRCPY_FW_LIB("libpn553_fw")                                          \
+      STRCPY_FW_BIN("pn553")                                                \
                                                                             \
-      nfcFL.platformFL._NFCC_RESET_RSP_LEN = 0x10U;                         \
+      nfcFL._FW_MOBILE_MAJOR_NUMBER = FW_MOBILE_MAJOR_NUMBER_PN553;         \
                                                                             \
-      nfcFL.nfcMwFL._NCI_INTERFACE_UICC_DIRECT = 0x82;                      \
-      nfcFL.nfcMwFL._NCI_INTERFACE_ESE_DIRECT = 0x83;                       \
+    } else if (chipType == pn551 || chipType == pn67T) {                    \
                                                                             \
-    } else if (chipType == pn553) {                                         \
-      nfcFL.nfccFL._NFCC_I2C_READ_WRITE_IMPROVEMENT = true;                 \
-      nfcFL.nfccFL._NFCC_MIFARE_TIANJIN = false;                            \
-      nfcFL.nfccFL._NFCC_MW_RCVRY_BLK_FW_DNLD = true;                       \
-      nfcFL.nfccFL._NFCC_DYNAMIC_DUAL_UICC = true;                          \
-      nfcFL.nfccFL._NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH = false;              \
-      nfcFL.nfccFL._NFC_NXP_STAT_DUAL_UICC_WO_EXT_SWITCH = true;            \
-      nfcFL.nfccFL._NFCC_FW_WA = true;                                      \
-      nfcFL.nfccFL._NFCC_FORCE_NCI1_0_INIT = true;                          \
-      nfcFL.nfccFL._NFCC_ROUTING_BLOCK_BIT = true;                          \
-      nfcFL.nfccFL._NFCC_SPI_FW_DOWNLOAD_SYNC = true;                       \
-      nfcFL.nfccFL._HW_ANTENNA_LOOP4_SELF_TEST = false;                     \
-      nfcFL.nfccFL._NFCEE_REMOVED_NTF_RECOVERY = true;                      \
-      nfcFL.nfccFL._NFCC_FORCE_FW_DOWNLOAD = true;                          \
-      nfcFL.nfccFL._UICC_CREATE_CONNECTIVITY_PIPE = true;                   \
-      nfcFL.nfccFL._NFCC_AID_MATCHING_PLATFORM_CONFIG = false;              \
-      nfcFL.nfccFL._NFCC_ROUTING_BLOCK_BIT_PROP = false;                    \
-      nfcFL.nfccFL._NFA_EE_MAX_EE_SUPPORTED = 3;                            \
+      STRCPY_FW_LIB("libpn551_fw")                                          \
+      STRCPY_FW_BIN("pn551")                                                \
                                                                             \
-      nfcFL.eseFL._ESE_ETSI12_PROP_INIT = true;                             \
-      nfcFL.eseFL._JCOP_WA_ENABLE = false;                                  \
-      nfcFL.eseFL._EXCLUDE_NV_MEM_DEPENDENCY = true;                        \
+      nfcFL._PHDNLDNFC_USERDATA_EEPROM_OFFSET = 0x02BCU;                    \
+      nfcFL._PHDNLDNFC_USERDATA_EEPROM_LEN = 0x0C00U;                       \
+      nfcFL._FW_MOBILE_MAJOR_NUMBER = FW_MOBILE_MAJOR_NUMBER_PN551;         \
                                                                             \
-      nfcFL.platformFL._NFCC_RESET_RSP_LEN = 0x10U;                         \
-                                                                            \
-      nfcFL.nfcMwFL._NCI_INTERFACE_UICC_DIRECT = 0x82;                      \
-      nfcFL.nfcMwFL._NCI_INTERFACE_ESE_DIRECT = 0x83;                       \
-                                                                            \
-      SRTCPY_FW("libpn553tc_fw", "libpn553tc_fw_platform",                  \
-                "libpn553tc_fw_pku")                                        \
-                                                                            \
-      nfcFL.nfcMwFL._FW_MOBILE_MAJOR_NUMBER = FW_MOBILE_MAJOR_NUMBER_PN553; \
-                                                                            \
-    } else if (chipType == pn551) {                                         \
-      nfcFL.nfccFL._NFCC_I2C_READ_WRITE_IMPROVEMENT = true;                 \
-      nfcFL.nfccFL._NFCC_MIFARE_TIANJIN = true;                             \
-      nfcFL.nfccFL._NFCC_MW_RCVRY_BLK_FW_DNLD = false;                      \
-      nfcFL.nfccFL._NFCC_DYNAMIC_DUAL_UICC = false;                         \
-      nfcFL.nfccFL._NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH = true;               \
-      nfcFL.nfccFL._NFC_NXP_STAT_DUAL_UICC_WO_EXT_SWITCH = false;           \
-      nfcFL.nfccFL._NFCC_FW_WA = false;                                     \
-      nfcFL.nfccFL._NFCC_FORCE_NCI1_0_INIT = false;                         \
-      nfcFL.nfccFL._NFCC_ROUTING_BLOCK_BIT = false;                         \
-      nfcFL.nfccFL._NFCC_SPI_FW_DOWNLOAD_SYNC = false;                      \
-      nfcFL.nfccFL._HW_ANTENNA_LOOP4_SELF_TEST = true;                      \
-      nfcFL.nfccFL._NFCEE_REMOVED_NTF_RECOVERY = true;                      \
-      nfcFL.nfccFL._NFCC_FORCE_FW_DOWNLOAD = false;                         \
-      nfcFL.nfccFL._UICC_CREATE_CONNECTIVITY_PIPE = false;                  \
-      nfcFL.nfccFL._NFCC_AID_MATCHING_PLATFORM_CONFIG = true;               \
-      nfcFL.nfccFL._NFCC_ROUTING_BLOCK_BIT_PROP = true;                     \
-      nfcFL.nfccFL._NFA_EE_MAX_EE_SUPPORTED = 2;                            \
-                                                                            \
-      nfcFL.eseFL._ESE_FORCE_ENABLE = true;                                 \
-                                                                            \
-      nfcFL.platformFL._NFCC_RESET_RSP_LEN = 0x11U;                         \
-                                                                            \
-      nfcFL.nfcMwFL._NCI_INTERFACE_UICC_DIRECT = 0x82;                      \
-      nfcFL.nfcMwFL._NCI_INTERFACE_ESE_DIRECT = 0x83;                       \
-                                                                            \
-      SRTCPY_FW("libpn551_fw", "libpn551_fw_platform", "libpn551_fw_pku")   \
-                                                                            \
-      nfcFL.nfcMwFL._PHDNLDNFC_USERDATA_EEPROM_OFFSET = 0x02BCU;            \
-      nfcFL.nfcMwFL._PHDNLDNFC_USERDATA_EEPROM_LEN = 0x0C00U;               \
-      nfcFL.nfcMwFL._FW_MOBILE_MAJOR_NUMBER = FW_MOBILE_MAJOR_NUMBER_PN551; \
-                                                                            \
-    } else if (chipType == pn548C2) {                                       \
-      nfcFL.nfccFL._NFCC_I2C_READ_WRITE_IMPROVEMENT = true;                 \
-      nfcFL.nfccFL._NFCC_MIFARE_TIANJIN = true;                             \
-      nfcFL.nfccFL._NFCC_MW_RCVRY_BLK_FW_DNLD = false;                      \
-      nfcFL.nfccFL._NFCC_DYNAMIC_DUAL_UICC = false;                         \
-      nfcFL.nfccFL._NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH = true;               \
-      nfcFL.nfccFL._NFC_NXP_STAT_DUAL_UICC_WO_EXT_SWITCH = false;           \
-      nfcFL.nfccFL._NFCC_FW_WA = false;                                     \
-      nfcFL.nfccFL._NFCC_FORCE_NCI1_0_INIT = false;                         \
-      nfcFL.nfccFL._NFCC_ROUTING_BLOCK_BIT = false;                         \
-      nfcFL.nfccFL._NFCC_SPI_FW_DOWNLOAD_SYNC = false;                      \
-      nfcFL.nfccFL._HW_ANTENNA_LOOP4_SELF_TEST = true;                      \
-      nfcFL.nfccFL._NFCEE_REMOVED_NTF_RECOVERY = true;                      \
-      nfcFL.nfccFL._NFCC_FORCE_FW_DOWNLOAD = false;                         \
-      nfcFL.nfccFL._UICC_CREATE_CONNECTIVITY_PIPE = false;                  \
-      nfcFL.nfccFL._NFCC_AID_MATCHING_PLATFORM_CONFIG = true;               \
-      nfcFL.nfccFL._NFCC_ROUTING_BLOCK_BIT_PROP = true;                     \
-      nfcFL.nfccFL._NFA_EE_MAX_EE_SUPPORTED = 2;                            \
-                                                                            \
-      nfcFL.eseFL._ESE_FORCE_ENABLE = true;                                 \
-                                                                            \
-      nfcFL.nfcMwFL._NCI_INTERFACE_UICC_DIRECT = 0x82;                      \
-      nfcFL.nfcMwFL._NCI_INTERFACE_ESE_DIRECT = 0x83;                       \
-                                                                            \
-      SRTCPY_FW("libpn548ad_fw", "libpn548ad_fw_platform",                  \
-                "libpn548ad_fw_pku")                                        \
-                                                                            \
-      nfcFL.nfcMwFL._PHDNLDNFC_USERDATA_EEPROM_OFFSET = 0x02BCU;            \
-      nfcFL.nfcMwFL._PHDNLDNFC_USERDATA_EEPROM_LEN = 0x0C00U;               \
-                                                                            \
-    } else if (chipType == pn547C2) {                                       \
-      nfcFL.nfccFL._NFCC_I2C_READ_WRITE_IMPROVEMENT = false;                \
-      nfcFL.nfccFL._NFCC_MIFARE_TIANJIN = true;                             \
-      nfcFL.nfccFL._NFCC_MW_RCVRY_BLK_FW_DNLD = false;                      \
-      nfcFL.nfccFL._NFCC_DYNAMIC_DUAL_UICC = false;                         \
-      nfcFL.nfccFL._NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH = false;              \
-      nfcFL.nfccFL._NFC_NXP_STAT_DUAL_UICC_WO_EXT_SWITCH = false;           \
-      nfcFL.nfccFL._NFCC_FW_WA = false;                                     \
-      nfcFL.nfccFL._NFCC_FORCE_NCI1_0_INIT = false;                         \
-      nfcFL.nfccFL._NFCC_ROUTING_BLOCK_BIT = false;                         \
-      nfcFL.nfccFL._NFCC_SPI_FW_DOWNLOAD_SYNC = false;                      \
-      nfcFL.nfccFL._HW_ANTENNA_LOOP4_SELF_TEST = true;                      \
-      nfcFL.nfccFL._NFCEE_REMOVED_NTF_RECOVERY = true;                      \
-      nfcFL.nfccFL._NFCC_FORCE_FW_DOWNLOAD = false;                         \
-      nfcFL.nfccFL._UICC_CREATE_CONNECTIVITY_PIPE = false;                  \
-      nfcFL.nfccFL._NFCC_AID_MATCHING_PLATFORM_CONFIG = true;               \
-      nfcFL.nfccFL._NFCC_ROUTING_BLOCK_BIT_PROP = false;                    \
-      nfcFL.nfccFL._NFA_EE_MAX_EE_SUPPORTED = 2;                            \
-                                                                            \
-      nfcFL.nfcMwFL._NCI_INTERFACE_UICC_DIRECT = 0x81;                      \
-      nfcFL.nfcMwFL._NCI_INTERFACE_ESE_DIRECT = 0x82;                       \
-                                                                            \
-      SRTCPY_FW("libpn547_fw", "libpn547_fw_platform", "libpn547_fw_pku")   \
     }                                                                       \
   }
-#ifdef __cplusplus
-#define SRTCPY_FW(str1, str2, str3)
-#else
-#define SRTCPY_FW(str1, str2, str3)                                          \
-  snprintf(nfcFL.nfcMwFL._FW_LIB_PATH, STRMAX_2, "%s%s%s", FW_DLL_ROOT_DIR,  \
-           str1, FW_DLL_EXTENSION);                                          \
-  snprintf(nfcFL.nfcMwFL._PLATFORM_LIB_PATH, STRMAX_2, "%s%s%s",             \
-           FW_DLL_ROOT_DIR, str2, FW_DLL_EXTENSION);                         \
-  snprintf(nfcFL.nfcMwFL._PKU_LIB_PATH, STRMAX_2, "%s%s%s", FW_DLL_ROOT_DIR, \
-           str3, FW_DLL_EXTENSION);
-#endif
+#define STRCPY_FW_LIB(str) {                                                \
+  nfcFL._FW_LIB_PATH.clear();                                               \
+  nfcFL._FW_LIB_PATH.append(FW_LIB_ROOT_DIR);                               \
+  nfcFL._FW_LIB_PATH.append(str);                                           \
+  nfcFL._FW_LIB_PATH.append(FW_LIB_EXTENSION);                              \
+}
+#define STRCPY_FW_BIN(str) {                                                \
+  nfcFL._FW_BIN_PATH.clear();                                               \
+  nfcFL._FW_BIN_PATH.append(FW_BIN_ROOT_DIR);                               \
+  nfcFL._FW_BIN_PATH.append(str);                                           \
+  nfcFL._FW_BIN_PATH.append(FW_BIN_EXTENSION);                              \
+}
 #endif
diff --git a/halimpl/common/phNfcCommon.h b/halimpl/common/phNfcCommon.h
index ba1970e..919b191 100755
--- a/halimpl/common/phNfcCommon.h
+++ b/halimpl/common/phNfcCommon.h
@@ -33,42 +33,11 @@
 #include <pthread.h>
 #include <semaphore.h>
 
-#define FW_DLL_ROOT_DIR "/system/vendor/lib/"
-#define FW_DLL_EXTENSION ".so"
+#define FW_LIB_ROOT_DIR "/vendor/lib/"
+#define FW_BIN_ROOT_DIR "/vendor/firmware/"
+#define FW_LIB_EXTENSION ".so"
+#define FW_BIN_EXTENSION ".bin"
 
-#if(NFC_NXP_CHIP_TYPE == PN551)
-/* Actual FW library name*/
-#define FW_LIB_PATH FLASH_CONF_ROOT_DIR "libpn551_fw" FW_DLL_EXTENSION
-/* Restore Corrupted PLL Settings/etc */
-#define PLATFORM_LIB_PATH \
-  FW_DLL_ROOT_DIR "libpn551_fw_platform" FW_DLL_EXTENSION
-/* Upgrade the public Key */
-#define PKU_LIB_PATH FW_DLL_ROOT_DIR "libpn551_fw_pku" FW_DLL_EXTENSION
-#elif(NFC_NXP_CHIP_TYPE == PN553)
-/* Actual FW library name*/
-#define FW_LIB_PATH FLASH_CONF_ROOT_DIR "libpn553_fw" FW_DLL_EXTENSION
-/* Restore Corrupted PLL Settings/etc */
-#define PLATFORM_LIB_PATH \
-  FW_DLL_ROOT_DIR "libpn553_fw_platform" FW_DLL_EXTENSION
-/* Upgrade the public Key */
-#define PKU_LIB_PATH FW_DLL_ROOT_DIR "libpn553_fw_pku" FW_DLL_EXTENSION
-#elif(NFC_NXP_CHIP_TYPE == PN557)
-/* Actual FW library name*/
-#define FW_LIB_PATH FLASH_CONF_ROOT_DIR "libpn557_fw" FW_DLL_EXTENSION
-/* Restore Corrupted PLL Settings/etc */
-#define PLATFORM_LIB_PATH \
-FW_DLL_ROOT_DIR "libpn557_fw_platform" FW_DLL_EXTENSION
-/* Upgrade the public Key */
-#define PKU_LIB_PATH FW_DLL_ROOT_DIR "libpn557_fw_pku" FW_DLL_EXTENSION
-#endif
-
-#if(NFC_NXP_CHIP_TYPE == PN551)
-#define COMPILATION_MW "PN551"
-#elif(NFC_NXP_CHIP_TYPE == PN553)
-#define COMPILATION_MW "PN553"
-#elif(NFC_NXP_CHIP_TYPE == PN557)
-#define COMPILATION_MW "PN557"
-#endif
 /* HAL Version number (Updated as per release) */
 #define NXP_MW_VERSION_MAJ (3U)
 #define NXP_MW_VERSION_MIN (5U)
diff --git a/halimpl/common/phNfcTypes.h b/halimpl/common/phNfcTypes.h
index 9f9b222..5333e3c 100755
--- a/halimpl/common/phNfcTypes.h
+++ b/halimpl/common/phNfcTypes.h
@@ -23,6 +23,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#include "Nxp_Features.h"
 
 #ifndef TRUE
 #define TRUE (0x01) /* Logical True Value */
diff --git a/halimpl/dnld/phDnldNfc.cc b/halimpl/dnld/phDnldNfc.cc
old mode 100755
new mode 100644
index 419da0d..1adf3ad
--- a/halimpl/dnld/phDnldNfc.cc
+++ b/halimpl/dnld/phDnldNfc.cc
@@ -24,11 +24,11 @@
 #include <phNxpConfig.h>
 #include <phNxpLog.h>
 #include <phTmlNfc.h>
-
+#include <string>
 static void* pFwHandle; /* Global firmware handle */
-uint16_t wMwVer = 0; /* Middleware version no */
-uint16_t wFwVer = 0; /* Firmware version no */
-uint8_t gRecFWDwnld;  // flag set to true to indicate dummy FW download
+uint16_t wMwVer = 0;    /* Middleware version no */
+uint16_t wFwVer = 0;    /* Firmware version no */
+uint8_t gRecFWDwnld;    // flag set to true to indicate dummy FW download
 phTmlNfc_i2cfragmentation_t fragmentation_enabled = I2C_FRAGMENATATION_DISABLED;
 static pphDnldNfc_DlContext_t gpphDnldContext = NULL; /* Download contex */
 #undef EEPROM_Read_Mem_IMP
@@ -242,15 +242,13 @@
       wStatus = PHNFCSTVAL(CID_NFC_DNLD, NFCSTATUS_BUSY);
     } else {
       if ((PHDNLDNFC_HWVER_MRA2_1 == bChipVer) ||
-          (PHDNLDNFC_HWVER_MRA2_2 == bChipVer)
-#if (NFC_NXP_CHIP_TYPE == PN551)
-          || (PHDNLDNFC_HWVER_PN551_MRA1_0 == bChipVer)
-#elif (NFC_NXP_CHIP_TYPE == PN553 || NFC_NXP_CHIP_TYPE == PN557)
-          || (PHDNLDNFC_HWVER_PN553_MRA1_0 == bChipVer) ||
-          (PHDNLDNFC_HWVER_PN553_MRA1_0_UPDATED & bChipVer) ||
-          (PHDNLDNFC_HWVER_PN557_MRA1_0 ==  bChipVer)
-#endif
-              ) {
+          (PHDNLDNFC_HWVER_MRA2_2 == bChipVer) ||
+          ((nfcFL.chipType == pn551) &&
+           (PHDNLDNFC_HWVER_PN551_MRA1_0 == bChipVer)) ||
+          (((nfcFL.chipType == pn553) || (nfcFL.chipType == pn557)) &&
+           ((PHDNLDNFC_HWVER_PN553_MRA1_0 == bChipVer) ||
+            (PHDNLDNFC_HWVER_PN553_MRA1_0_UPDATED & bChipVer) ||
+            (PHDNLDNFC_HWVER_PN557_MRA1_0 == bChipVer)))) {
         (gpphDnldContext->FrameInp.Type) = phDnldNfc_ChkIntg;
       } else {
         (gpphDnldContext->FrameInp.Type) = phDnldNfc_FTNone;
@@ -730,16 +728,10 @@
 **
 *******************************************************************************/
 NFCSTATUS phDnldNfc_InitImgInfo(void) {
-  NFCSTATUS wStatus     = NFCSTATUS_SUCCESS;
-  uint8_t* pImageInfo   = NULL;
+  NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
+  uint8_t* pImageInfo = NULL;
   uint16_t ImageInfoLen = 0;
-  uint8_t fwPathLen     = 0;
-  char* fwFullPath      = NULL;
-  char fwName[50];
-  char fwPath[100];
-
-  memset(fwName, 0, sizeof(fwName));
-  memset(fwPath, 0, sizeof(fwPath));
+  unsigned long fwType = FW_FORMAT_SO;
 
   /* if memory is not allocated then allocate memory for download context
    * structure */
@@ -748,27 +740,22 @@
   gpphDnldContext->FwFormat = FW_FORMAT_UNKNOWN;
 
   /*Read Firmware file name from config file*/
-  if (GetNxpStrValue(NAME_NXP_FW_NAME, (char*)fwName, sizeof(fwName)) == true) {
-    strcpy(fwPath, FW_DLL_ROOT_DIR);
-    strncat(fwPath, fwName, strlen(fwName));
-    fwPathLen = strlen(fwPath);
-    fwFullPath = fwPath;
+  if (GetNxpNumValue(NAME_NXP_FW_TYPE, &fwType, sizeof(fwType)) == true) {
+    NXPLOG_FWDNLD_D("firmware type from conf file: %lu",fwType);
+  } else {
+    NXPLOG_FWDNLD_W("firmware type not found. Taking default value: %lu",fwType);
   }
 
-  if (!memcmp(&fwPath[fwPathLen - 3], ".so", 3) ) {
-    gpphDnldContext->FwFormat = FW_FORMAT_SO;
-  } else  if (!memcmp(&fwPath[fwPathLen - 4], ".bin", 4) ) {
+  if(fwType == FW_FORMAT_BIN) {
     gpphDnldContext->FwFormat = FW_FORMAT_BIN;
-  }
-
-  if(gpphDnldContext->FwFormat == FW_FORMAT_SO) {
-  /* load the library and get the image info pointer */
-  if (gRecFWDwnld == true)
-    wStatus = phDnldNfc_LoadRecoveryFW(fwFullPath, &pImageInfo, &ImageInfoLen);
-  else
-    wStatus = phDnldNfc_LoadFW(fwFullPath, &pImageInfo, &ImageInfoLen);
-  } else if(gpphDnldContext->FwFormat == FW_FORMAT_BIN) {
-      wStatus = phDnldNfc_LoadBinFW(fwFullPath, &pImageInfo, &ImageInfoLen);
+    wStatus = phDnldNfc_LoadBinFW(&pImageInfo, &ImageInfoLen);
+  } else if(fwType == FW_FORMAT_SO) {
+    gpphDnldContext->FwFormat = FW_FORMAT_SO;
+    if (gRecFWDwnld == true) {
+      wStatus = phDnldNfc_LoadRecoveryFW(&pImageInfo, &ImageInfoLen);
+    } else {
+      wStatus = phDnldNfc_LoadFW(&pImageInfo, &ImageInfoLen);
+    }
   } else {
     NXPLOG_FWDNLD_E("firmware file format mismatch!!!\n");
     return NFCSTATUS_FAILED;
@@ -841,10 +828,10 @@
    * structure */
   phDnldNfc_SetHwDevHandle();
   if (gRecFWDwnld == true)
-    wStatus =
-        phDnldNfc_LoadRecoveryFW(PLATFORM_LIB_PATH, &pImageInfo, &ImageInfoLen);
+    wStatus = phDnldNfc_LoadRecoveryFW(&pImageInfo, &ImageInfoLen);
   else
-    wStatus = phDnldNfc_LoadFW(PLATFORM_LIB_PATH, &pImageInfo, &ImageInfoLen);
+    wStatus = phDnldNfc_LoadFW(&pImageInfo, &ImageInfoLen);
+
   if ((pImageInfo == NULL) || (ImageInfoLen == 0)) {
     NXPLOG_FWDNLD_E(
         "Image extraction Failed - invalid imginfo or imginfolen!!");
@@ -895,13 +882,11 @@
   /* if memory is not allocated then allocate memory for donwload context
    * structure */
   phDnldNfc_SetHwDevHandle();
-
-/* load the PKU image library */
+  /* load the PKU image library */
   if (gRecFWDwnld == true)
-    wStatus =
-        phDnldNfc_LoadRecoveryFW(PKU_LIB_PATH, &pImageInfo, &ImageInfoLen);
+    wStatus = phDnldNfc_LoadRecoveryFW(&pImageInfo, &ImageInfoLen);
   else
-    wStatus = phDnldNfc_LoadFW(PKU_LIB_PATH, &pImageInfo, &ImageInfoLen);
+    wStatus = phDnldNfc_LoadFW(&pImageInfo, &ImageInfoLen);
   if ((pImageInfo == NULL) || (ImageInfoLen == 0)) {
     NXPLOG_FWDNLD_E(
         "Image extraction Failed - invalid imginfo or imginfolen!!");
@@ -945,18 +930,18 @@
 *******************************************************************************/
 void phDnldNfc_CloseFwLibHandle(void) {
   NFCSTATUS wStatus = NFCSTATUS_FAILED;
-  if(gpphDnldContext->FwFormat == FW_FORMAT_SO) {
-      wStatus = phDnldNfc_UnloadFW();
-      if (wStatus != NFCSTATUS_SUCCESS) {
-          NXPLOG_FWDNLD_E("free library FAILED !!\n");
-      } else {
-          NXPLOG_FWDNLD_E("free library SUCCESS !!\n");
-      }
-  } else if(gpphDnldContext->FwFormat == FW_FORMAT_BIN) {
-      if(pFwHandle!=NULL) {
-          free(pFwHandle);
-          pFwHandle = NULL;
-      }
+  if (gpphDnldContext->FwFormat == FW_FORMAT_SO) {
+    wStatus = phDnldNfc_UnloadFW();
+    if (wStatus != NFCSTATUS_SUCCESS) {
+      NXPLOG_FWDNLD_E("free library FAILED !!\n");
+    } else {
+      NXPLOG_FWDNLD_E("free library SUCCESS !!\n");
+    }
+  } else if (gpphDnldContext->FwFormat == FW_FORMAT_BIN) {
+    if (pFwHandle != NULL) {
+      free(pFwHandle);
+      pFwHandle = NULL;
+    }
   }
   return;
 }
@@ -967,36 +952,25 @@
 **
 ** Description      Load the firmware version form firmware lib
 **
-** Parameters       pathName    - Firmware image path
-**                  pImgInfo    - Firmware image handle
+** Parameters       pImgInfo    - Firmware image handle
 **                  pImgInfoLen - Firmware image length
 **
 ** Returns          NFC status
 **
 *******************************************************************************/
-NFCSTATUS phDnldNfc_LoadFW(const char* pathName, uint8_t** pImgInfo,
-                           uint16_t* pImgInfoLen) {
+NFCSTATUS phDnldNfc_LoadFW(uint8_t** pImgInfo, uint16_t* pImgInfoLen) {
   void* pImageInfo = NULL;
   void* pImageInfoLen = NULL;
-  if (pathName == NULL) {
-#if (NFC_NXP_CHIP_TYPE == PN551)
-    pathName = "/system/vendor/lib/libpn551_fw.so";
-#elif (NFC_NXP_CHIP_TYPE == PN553)
-    pathName = "/system/vendor/lib/libpn553_fw.so";
-#elif (NFC_NXP_CHIP_TYPE == PN557)
-    pathName = "/system/vendor/lib/libpn557_fw.so";
-#endif
-  }
 
   /* check if the handle is not NULL then free the library */
   if (pFwHandle != NULL) {
-    phDnldNfc_UnloadFW();
+    phDnldNfc_CloseFwLibHandle();
     pFwHandle = NULL;
   }
 
   /* load the DLL file */
-  pFwHandle = dlopen(pathName, RTLD_LAZY);
-  NXPLOG_FWDNLD_D("@@@%s", pathName);
+  pFwHandle = dlopen(nfcFL._FW_LIB_PATH.c_str(), RTLD_LAZY);
+  NXPLOG_FWDNLD_D("@@@%s", nfcFL._FW_LIB_PATH.c_str());
 
   /* if library load failed then handle will be NULL */
   if (pFwHandle == NULL) {
@@ -1033,34 +1007,32 @@
 **
 ** Description      Load the firmware version form firmware lib
 **
-** Parameters       pathName    - Firmware image path
-**                  pImgInfo    - Firmware image handle
+** Parameters       pImgInfo    - Firmware image handle
 **                  pImgInfoLen - Firmware image length
 **
 ** Returns          NFC status
 **
 *******************************************************************************/
-NFCSTATUS phDnldNfc_LoadBinFW(const char* pathName, uint8_t **pImgInfo,
-                              uint16_t* pImgInfoLen) {
-  FILE * pFile = NULL;
+NFCSTATUS phDnldNfc_LoadBinFW(uint8_t** pImgInfo, uint16_t* pImgInfoLen) {
+  FILE* pFile = NULL;
   uint32_t fileSize = 0;
   uint32_t bytesRead = 0;
   long ftellFileSize = 0;
 
   /* check for path name */
-  if (pathName == NULL) {
+  if (nfcFL._FW_BIN_PATH.c_str() == NULL) {
     NXPLOG_FWDNLD_E("Invalid FW file path!!!\n");
     return NFCSTATUS_FAILED;
   }
 
   /* check if the handle is not NULL then free the memory*/
   if (pFwHandle != NULL) {
-    free(pFwHandle);
+    phDnldNfc_CloseFwLibHandle();
     pFwHandle = NULL;
   }
 
   /* Open the FW binary image file to be read */
-  pFile = fopen(pathName, "r");
+  pFile = fopen(nfcFL._FW_BIN_PATH.c_str(), "r");
   if (NULL == pFile) {
     NXPLOG_FWDNLD_E("Failed to load FW binary image file!!!\n");
     return NFCSTATUS_FAILED;
@@ -1072,7 +1044,7 @@
   /* get the actual length of the file */
   ftellFileSize = ftell(pFile);
 
-  if(ftellFileSize > 0) {
+  if (ftellFileSize > 0) {
     fileSize = ftellFileSize;
   } else {
     fileSize = 0;
@@ -1082,17 +1054,18 @@
   fseek(pFile, 0, SEEK_SET);
 
   /* allocate the memory to read the FW binary image */
-  pFwHandle = (void*)malloc(sizeof(uint8_t)*fileSize);
+  pFwHandle = (void*)malloc(sizeof(uint8_t) * fileSize);
 
   /* check for valid memory allocation */
-  if(NULL == pFwHandle) {
+  if (NULL == pFwHandle) {
     NXPLOG_FWDNLD_E("Failed to allocate memory to load FW image !!!\n");
     fclose(pFile);
     return NFCSTATUS_FAILED;
   }
 
   /* Read the actual contents of the FW binary image */
-  bytesRead = (uint32_t)fread(pFwHandle, sizeof(uint8_t), (size_t)fileSize, pFile);
+  bytesRead =
+      (uint32_t)fread(pFwHandle, sizeof(uint8_t), (size_t)fileSize, pFile);
   if (bytesRead != fileSize) {
     NXPLOG_FWDNLD_E("Unable to read the specified size from file !!!\n");
     fclose(pFile);
@@ -1118,37 +1091,24 @@
 **                  recovery. This will change the FW version of the NFCC
 **                  firmware and enable flashing of firmware of same version.
 **
-** Parameters       pathName    - Firmware image path
-**                  pImgInfo    - Firmware image handle
+** Parameters       pImgInfo    - Firmware image handle
 **                  pImgInfoLen - Firmware image length
 **
 ** Returns          NFCSTATUS
 **
 *******************************************************************************/
-NFCSTATUS phDnldNfc_LoadRecoveryFW(const char* pathName, uint8_t** pImgInfo,
-                                   uint16_t* pImgInfoLen) {
+NFCSTATUS phDnldNfc_LoadRecoveryFW(uint8_t** pImgInfo, uint16_t* pImgInfoLen) {
   void* pImageInfo = NULL;
   void* pImageInfoLen = NULL;
 
-  /* check for path name */
-  if (pathName == NULL) {
-#if (NFC_NXP_CHIP_TYPE == PN551)
-    pathName = "/system/vendor/lib/libpn551_fw.so";
-#elif (NFC_NXP_CHIP_TYPE == PN553)
-    pathName = "/system/vendor/lib/libpn553_fw.so";
-#elif(NFC_NXP_CHIP_TYPE == PN557)
-    pathName = "/system/vendor/lib/libpn557_fw.so";
-#endif
-  }
-
   /* check if the handle is not NULL then free the library */
   if (pFwHandle != NULL) {
-    phDnldNfc_UnloadFW();
+    phDnldNfc_CloseFwLibHandle();
     pFwHandle = NULL;
   }
   /* load the DLL file */
-  pFwHandle = dlopen(pathName, RTLD_LAZY);
-  NXPLOG_FWDNLD_D("phDnldNfc_LoadRecoveryFW %s ", pathName);
+  pFwHandle = dlopen(nfcFL._FW_LIB_PATH.c_str(), RTLD_LAZY);
+  NXPLOG_FWDNLD_D("phDnldNfc_LoadRecoveryFW %s ", nfcFL._FW_LIB_PATH.c_str());
 
   /* if library load failed then handle will be NULL */
   if (pFwHandle == NULL) {
diff --git a/halimpl/dnld/phDnldNfc.h b/halimpl/dnld/phDnldNfc.h
index 0c02a83..ae672ef 100755
--- a/halimpl/dnld/phDnldNfc.h
+++ b/halimpl/dnld/phDnldNfc.h
@@ -128,12 +128,9 @@
 extern NFCSTATUS phDnldNfc_LoadRecInfo(void);
 extern NFCSTATUS phDnldNfc_LoadPKInfo(void);
 extern void phDnldNfc_CloseFwLibHandle(void);
-extern NFCSTATUS phDnldNfc_LoadFW(const char* pathName, uint8_t** pImgInfo,
-                                  uint16_t* pImgInfoLen);
-extern NFCSTATUS phDnldNfc_LoadBinFW(const char* pathName, uint8_t** pImgInfo,
-                                     uint16_t* pImgInfoLen);
-extern NFCSTATUS phDnldNfc_LoadRecoveryFW(const char* pathName,
-                                          uint8_t** pImgInfo,
+extern NFCSTATUS phDnldNfc_LoadFW(uint8_t** pImgInfo, uint16_t* pImgInfoLen);
+extern NFCSTATUS phDnldNfc_LoadBinFW(uint8_t** pImgInfo, uint16_t* pImgInfoLen);
+extern NFCSTATUS phDnldNfc_LoadRecoveryFW(uint8_t** pImgInfo,
                                           uint16_t* pImgInfoLen);
 extern NFCSTATUS phDnldNfc_UnloadFW(void);
 #endif /* PHDNLDNFC_H */
diff --git a/halimpl/dnld/phDnldNfc_Internal.cc b/halimpl/dnld/phDnldNfc_Internal.cc
index 87302f8..f5cbb3a 100755
--- a/halimpl/dnld/phDnldNfc_Internal.cc
+++ b/halimpl/dnld/phDnldNfc_Internal.cc
@@ -68,29 +68,6 @@
 /* size of EEPROM offset */
 #define PHDNLDNFC_USERDATA_EEPROM_OFFSIZE (0x02U)
 
-#ifdef NXP_PN547C1_DOWNLOAD
-/* EEPROM offset and length value for PN547C1 */
-/* 16 bits offset indicating user data area start location */
-#define PHDNLDNFC_USERDATA_EEPROM_OFFSET (0x003CU)
-/* 16 bits length of user data area */
-#define PHDNLDNFC_USERDATA_EEPROM_LEN (0x0DC0U)
-#else
-
-#if (NFC_NXP_CHIP_TYPE == PN551)
-/* EEPROM offset and length value for PN551 */
-/* 16 bits offset indicating user data area start location */
-#define PHDNLDNFC_USERDATA_EEPROM_OFFSET (0x02BCU)
-/* 16 bits length of user data area */
-#define PHDNLDNFC_USERDATA_EEPROM_LEN (0x0C00U)
-#elif(NFC_NXP_CHIP_TYPE == PN553 || NFC_NXP_CHIP_TYPE == PN557)
-/* EEPROM offset and length value for PN553/PN557 */
-/* 16 bits offset indicating user data area start location */
-#define PHDNLDNFC_USERDATA_EEPROM_OFFSET (0x02BCU)
-/* 16 bits length of user data area */
-#define PHDNLDNFC_USERDATA_EEPROM_LEN (0x0BC0U)
-#endif
-
-#endif
 #define PH_LIBNFC_VEN_RESET_ON_DOWNLOAD_TIMEOUT (1)
 
 /* Function prototype declarations */
@@ -706,12 +683,13 @@
     } else if (phDnldNfc_ChkIntg == (pDlContext->FrameInp.Type)) {
       (pDlContext->tCmdRspFrameInfo.dwSendlength) += PHDNLDNFC_MIN_PLD_LEN;
 
-      wChkIntgVal = PHDNLDNFC_USERDATA_EEPROM_OFFSET;
+      wChkIntgVal = nfcFL._PHDNLDNFC_USERDATA_EEPROM_OFFSET;
+
       memcpy(&(pDlContext->tCmdRspFrameInfo
                    .aFrameBuff[PHDNLDNFC_FRAME_RDDATA_OFFSET]),
              &wChkIntgVal, sizeof(wChkIntgVal));
 
-      wChkIntgVal = PHDNLDNFC_USERDATA_EEPROM_LEN;
+      wChkIntgVal = nfcFL._PHDNLDNFC_USERDATA_EEPROM_LEN;
       memcpy(&(pDlContext->tCmdRspFrameInfo
                    .aFrameBuff[PHDNLDNFC_FRAME_RDDATA_OFFSET +
                                PHDNLDNFC_USERDATA_EEPROM_OFFSIZE]),
diff --git a/halimpl/dnld/phDnldNfc_Internal.h b/halimpl/dnld/phDnldNfc_Internal.h
index ed8f32e..d37a16f 100755
--- a/halimpl/dnld/phDnldNfc_Internal.h
+++ b/halimpl/dnld/phDnldNfc_Internal.h
@@ -120,8 +120,8 @@
  */
 typedef enum phDnldNfc_FwFormat {
   FW_FORMAT_UNKNOWN = 0x00,
-  FW_FORMAT_BIN = 0x01,
-  FW_FORMAT_SO = 0x02,
+  FW_FORMAT_SO = 0x01,
+  FW_FORMAT_BIN = 0x02,
 } phDnldNfc_FwFormat_t;
 
 /*
diff --git a/halimpl/dnld/phNxpNciHal_Dnld.cc b/halimpl/dnld/phNxpNciHal_Dnld.cc
old mode 100755
new mode 100644
index 2af6d8c..ceca050
--- a/halimpl/dnld/phNxpNciHal_Dnld.cc
+++ b/halimpl/dnld/phNxpNciHal_Dnld.cc
@@ -176,26 +176,18 @@
 static NFCSTATUS (*phNxpNciHal_dwnld_seqhandler[])(void* pContext,
                                                    NFCSTATUS status,
                                                    void* pInfo) = {
-    phNxpNciHal_fw_dnld_get_sessn_state,
-    phNxpNciHal_fw_dnld_get_version,
-    phNxpNciHal_fw_dnld_log_read,
-    phNxpNciHal_fw_dnld_write,
-    phNxpNciHal_fw_dnld_get_sessn_state,
-    phNxpNciHal_fw_dnld_get_version,
-    phNxpNciHal_fw_dnld_log,
-    phNxpNciHal_fw_dnld_chk_integrity,
-    NULL};
+    phNxpNciHal_fw_dnld_get_sessn_state, phNxpNciHal_fw_dnld_get_version,
+    phNxpNciHal_fw_dnld_log_read, phNxpNciHal_fw_dnld_write,
+    phNxpNciHal_fw_dnld_get_sessn_state, phNxpNciHal_fw_dnld_get_version,
+    phNxpNciHal_fw_dnld_log, phNxpNciHal_fw_dnld_chk_integrity, NULL};
 
 /* Array of pointers to start dummy fw download seq */
 static NFCSTATUS (*phNxpNciHal_dummy_rec_dwnld_seqhandler[])(void* pContext,
                                                              NFCSTATUS status,
                                                              void* pInfo) = {
-    phNxpNciHal_fw_dnld_normal,
-    phNxpNciHal_fw_dnld_normal,
-    phNxpNciHal_fw_dnld_get_sessn_state,
-    phNxpNciHal_fw_dnld_get_version,
-    phNxpNciHal_fw_dnld_log_read,
-    phNxpNciHal_fw_dnld_write,
+    phNxpNciHal_fw_dnld_normal,          phNxpNciHal_fw_dnld_normal,
+    phNxpNciHal_fw_dnld_get_sessn_state, phNxpNciHal_fw_dnld_get_version,
+    phNxpNciHal_fw_dnld_log_read,        phNxpNciHal_fw_dnld_write,
     NULL};
 
 /* Download Recovery Sequence */
@@ -530,21 +522,18 @@
       bHwVer &= 0x0F; /* 0x0F is the mask to extract chip version */
 
       if ((PHDNLDNFC_HWVER_MRA2_1 == bHwVer) ||
-          (PHDNLDNFC_HWVER_MRA2_2 == bHwVer)
-#if (NFC_NXP_CHIP_TYPE == PN551)
-          || (PHDNLDNFC_HWVER_PN551_MRA1_0 == bHwVer)
-#elif(NFC_NXP_CHIP_TYPE == PN553 || NFC_NXP_CHIP_TYPE == PN557)
-          || (PHDNLDNFC_HWVER_PN553_MRA1_0 == bHwVer ||
-              PHDNLDNFC_HWVER_PN553_MRA1_0_UPDATED & pRespBuff->pBuff[0])
-#endif
-              ) {
+          (PHDNLDNFC_HWVER_MRA2_2 == bHwVer) ||
+          ((nfcFL.chipType == pn551) &&
+           (PHDNLDNFC_HWVER_PN551_MRA1_0 == bHwVer)) ||
+          (((nfcFL.chipType == pn553) || (nfcFL.chipType == pn557)) &&
+           (PHDNLDNFC_HWVER_PN553_MRA1_0 == bHwVer ||
+            PHDNLDNFC_HWVER_PN553_MRA1_0_UPDATED & pRespBuff->pBuff[0]))) {
         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]) {
+        if ((nfcFL.chipType == pn553) &&
+            (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;
@@ -1501,7 +1490,7 @@
 
   while (seq_handler[seq_counter] != NULL) {
     status = NFCSTATUS_FAILED;
-    status = (seq_handler[seq_counter])((void *)pContext, status, &pInfo);
+    status = (seq_handler[seq_counter])((void*)pContext, status, &pInfo);
     if (NFCSTATUS_SUCCESS != status) {
       NXPLOG_FWDNLD_E(" phNxpNciHal_fw_seq_handler : FAILED");
       break;
@@ -1712,8 +1701,7 @@
     if (gRecFWDwnld == true) {
       status =
           phNxpNciHal_fw_seq_handler(phNxpNciHal_dummy_rec_dwnld_seqhandler);
-    } else
-    {
+    } else {
       status = phNxpNciHal_fw_seq_handler(phNxpNciHal_dwnld_seqhandler);
     }
   } else {
@@ -1721,7 +1709,7 @@
   }
 
   /* Chage to normal mode */
-  status = phNxpNciHal_fw_dnld_complete((void *)pContext, status, &pInfo);
+  status = phNxpNciHal_fw_dnld_complete((void*)pContext, status, &pInfo);
   /*if (NFCSTATUS_SUCCESS == status)
   {
       NXPLOG_FWDNLD_D(" phNxpNciHal_fw_dnld_complete : SUCCESS");
@@ -1735,14 +1723,8 @@
 }
 
 static NFCSTATUS phLibNfc_VerifyCrcStatus(uint8_t bCrcStatus) {
-#if ((NFC_NXP_CHIP_TYPE == PN551) || (NFC_NXP_CHIP_TYPE == PN553)\
-    || (NFC_NXP_CHIP_TYPE == PN557))
   uint8_t bBitPos = 1;
   uint8_t bShiftVal = 2;
-#else
-  uint8_t bBitPos = 0;
-  uint8_t bShiftVal = 1;
-#endif
   NFCSTATUS wStatus = NFCSTATUS_SUCCESS;
   while (bBitPos < 7) {
     if (!(bCrcStatus & bShiftVal)) {
diff --git a/halimpl/hal/phNxpNciHal.cc b/halimpl/hal/phNxpNciHal.cc
index af2062f..65bc7d9 100755
--- a/halimpl/hal/phNxpNciHal.cc
+++ b/halimpl/hal/phNxpNciHal.cc
@@ -37,22 +37,7 @@
 #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
-#define FW_MOBILE_MAJOR_NUMBER_PN557 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
-#elif(NFC_NXP_CHIP_TYPE == PN557)
-#define FW_MOBILE_MAJOR_NUMBER FW_MOBILE_MAJOR_NUMBER_PN557
-#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;
@@ -348,20 +333,9 @@
   /* extract the firmware's major no */
   ufw_current_major_no = ((0x00FF) & (wFwVer >> 8U));
 
-  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 &&
+  if ((ufw_current_major_no == nfcFL._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))
-#elif (NFC_NXP_CHIP_TYPE == PN557)
-      || ((rom_version == FW_MOBILE_MAJOR_NUMBER) &&
-          (ufw_current_major_no == FW_MOBILE_MAJOR_NUMBER_PN557))
-#endif
-          )
-
   {
     status = NFCSTATUS_SUCCESS;
   } else if (ufw_current_major_no == sfw_infra_major_no) {
@@ -614,17 +588,17 @@
     goto clean_and_return;
   }
 
-  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");
+  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 && (nfcFL.chipType == pn557)) {
+      NXPLOG_NCIHAL_E("Chip is in NCI1.0 mode reset the chip to 2.0 mode");
       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) {
+        status = phNxpNciHal_send_ext_cmd(sizeof(cmd_init_nci2_0), cmd_init_nci2_0);
+        if(status == NFCSTATUS_SUCCESS) {
+          goto init_retry;
         }
       }
     }
@@ -778,15 +752,15 @@
  ******************************************************************************/
 int phNxpNciHal_fw_mw_ver_check() {
   NFCSTATUS status = NFCSTATUS_FAILED;
-  if (!(strcmp(COMPILATION_MW, "PN557")) &&
+  if ((nfcFL.chipType == pn557) &&
       (rom_version == FW_MOBILE_ROM_VERSION_PN557) &&
       (fw_maj_ver == 0x01)) {
     status = NFCSTATUS_SUCCESS;
-  } else if (!(strcmp(COMPILATION_MW, "PN553")) &&
+  } else if ((nfcFL.chipType == pn553) &&
       (rom_version == FW_MOBILE_ROM_VERSION_PN553) &&
       (fw_maj_ver == 0x01 || fw_maj_ver == 0x02)) {
     status = NFCSTATUS_SUCCESS;
-  } else if (!strcmp(COMPILATION_MW, "PN551") &&
+  } else if ((nfcFL.chipType == pn551) &&
              (rom_version == FW_MOBILE_ROM_VERSION_PN551) &&
              (fw_maj_ver == 0x05)) {
     status = NFCSTATUS_SUCCESS;
@@ -1152,10 +1126,8 @@
   static uint8_t cmd_ven_enable[] = {0x20, 0x02, 0x05, 0x01,
                                          0xA0, 0x07, 0x01, 0x01};
 
-#ifndef NXP_NFC_CHIP_PN81T
   static uint8_t android_l_aid_matching_mode_on_cmd[] = {
       0x20, 0x02, 0x05, 0x01, 0xA0, 0x91, 0x01, 0x01};
-#endif
   static uint8_t swp_switch_timeout_cmd[] = {0x20, 0x02, 0x06, 0x01, 0xA0,
                                              0xF3, 0x02, 0x00, 0x00};
   config_success = true;
@@ -1677,9 +1649,8 @@
     }
   }
 
-#ifndef NXP_NFC_CHIP_PN81T
   /* Android L AID Matching Platform Setting*/
-  if (GetNxpNumValue(NAME_AID_MATCHING_PLATFORM, (void*)&retlen,
+  if ((nfcFL.chipType != pn557) && GetNxpNumValue(NAME_AID_MATCHING_PLATFORM, (void*)&retlen,
                      sizeof(retlen))) {
     if (1 == retlen) {
       status =
@@ -1702,7 +1673,6 @@
       }
     }
   }
-#endif
 
   if ((*p_core_init_rsp_params > 0) && (*p_core_init_rsp_params < 4)) {
     static phLibNfc_Message_t msg;
@@ -2528,12 +2498,11 @@
   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 || NFC_NXP_CHIP_TYPE == PN557)
     uint8_t param_clock_src = 0x00;
-#else
-    uint8_t param_clock_src = CLK_SRC_PLL;
-    param_clock_src = param_clock_src << 3;
-#endif
+    if((nfcFL.chipType != pn553)&&(nfcFL.chipType != pn557)) {
+      uint8_t param_clock_src = CLK_SRC_PLL;
+      param_clock_src = param_clock_src << 3;
+    }
 
     if (nxpprofile_ctrl.bClkFreqVal == CLK_FREQ_13MHZ) {
       param_clock_src |= 0x00;
@@ -2549,11 +2518,11 @@
       param_clock_src |= 0x05;
     } else {
       NXPLOG_NCIHAL_E("Wrong clock freq, send default PLL@19.2MHz");
-#if (NFC_NXP_CHIP_TYPE == PN553 || NFC_NXP_CHIP_TYPE == PN557)
-      param_clock_src = 0x01;
-#else
-      param_clock_src = 0x11;
-#endif
+      if((nfcFL.chipType == pn553) || (nfcFL.chipType == pn557)) {
+        param_clock_src = 0x01;
+      } else {
+        param_clock_src = 0x11;
+      }
     }
 
     set_clock_cmd[7] = param_clock_src;
@@ -2749,9 +2718,9 @@
 int check_config_parameter() {
   uint8_t param_clock_src = CLK_SRC_PLL;
   if (nxpprofile_ctrl.bClkSrcVal == CLK_SRC_PLL) {
-#if (NFC_NXP_CHIP_TYPE != PN553 && NFC_NXP_CHIP_TYPE != PN557)
-    param_clock_src = param_clock_src << 3;
-#endif
+    if((nfcFL.chipType != pn553)&&(nfcFL.chipType != pn557)) {
+      param_clock_src = param_clock_src << 3;
+    }
     if (nxpprofile_ctrl.bClkFreqVal == CLK_FREQ_13MHZ) {
       param_clock_src |= 0x00;
     } else if (nxpprofile_ctrl.bClkFreqVal == CLK_FREQ_19_2MHZ) {
@@ -2916,6 +2885,26 @@
 #endif
 }
 
+/*******************************************************************************
+**
+** Function         phNxpNciHal_configFeatureList
+**
+** Description      Configures the featureList based on chip type
+**                  HW Version information number will provide chipType.
+**                  HW Version can be obtained from CORE_INIT_RESPONSE(NCI 1.0)
+**                  or CORE_RST_NTF(NCI 2.0)
+**
+** Parameters       CORE_INIT_RESPONSE/CORE_RST_NTF, len
+**
+** Returns          none
+*******************************************************************************/
+void phNxpNciHal_configFeatureList(uint8_t* init_rsp, uint16_t rsp_len) {
+    nxpncihal_ctrl.chipType = pConfigFL->processChipType(init_rsp,rsp_len);
+    tNFC_chipType chipType = nxpncihal_ctrl.chipType;
+    CONFIGURE_FEATURELIST(chipType);
+    NXPLOG_NCIHAL_D("NFC_GetFeatureList ()chipType = %d", chipType);
+}
+
 /******************************************************************************
  * Function         phNxpNciHal_print_res_status
  *
diff --git a/halimpl/hal/phNxpNciHal.h b/halimpl/hal/phNxpNciHal.h
index 9a216e1..e9cfe06 100755
--- a/halimpl/hal/phNxpNciHal.h
+++ b/halimpl/hal/phNxpNciHal.h
@@ -18,6 +18,7 @@
 
 #include <hardware/nfc.h>
 #include <phNxpNciHal_utils.h>
+#include "NxpNfcCapability.h"
 
 /********************* Definitions and structures *****************************/
 #define MAX_RETRY_COUNT 5
@@ -47,7 +48,6 @@
 #define NCI_MSG_CORE_INIT 0x01
 #define NCI_MT_MASK 0xE0
 #define NCI_OID_MASK 0x3F
-#define NXP_NFC_CHIP_PN81T
 
 #define NXP_MAX_CONFIG_STRING_LEN 260
 
@@ -127,6 +127,7 @@
 
   /* to store and restore gpio values */
   phNxpNciGpioInfo_t phNxpNciGpioInfo;
+  tNFC_chipType chipType;
 } phNxpNciHal_Control_t;
 
 typedef struct phNxpNciClock {
@@ -175,4 +176,13 @@
 void phNxpNciHal_request_control(void);
 void phNxpNciHal_release_control(void);
 int phNxpNciHal_write_unlocked(uint16_t data_len, const uint8_t* p_data);
+/*******************************************************************************
+**
+** Function         phNxpNciHal_configFeatureList
+**
+** Description      Configures the featureList based on chip type
+
+** Returns          none
+*******************************************************************************/
+void phNxpNciHal_configFeatureList(uint8_t* init_rsp, uint16_t rsp_len);
 #endif /* _PHNXPNCIHAL_H_ */
diff --git a/halimpl/hal/phNxpNciHal_ext.cc b/halimpl/hal/phNxpNciHal_ext.cc
index a24317c..646a07b 100755
--- a/halimpl/hal/phNxpNciHal_ext.cc
+++ b/halimpl/hal/phNxpNciHal_ext.cc
@@ -395,6 +395,7 @@
 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;
@@ -416,6 +417,10 @@
         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];
+      NXPLOG_NCIHAL_D("nci_version : 0x%02x",nxpncihal_ctrl.nci_info.nci_version);
+      if(!nxpncihal_ctrl.hal_open_status) {
+        phNxpNciHal_configFeatureList(p_ntf,*p_len);
+      }
       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];
@@ -442,6 +447,9 @@
       NXPLOG_NCIHAL_D("CORE_INIT_RSP NCI2.0 received !");
     } else {
       NXPLOG_NCIHAL_D("CORE_INIT_RSP NCI1.0 received !");
+      if(!nxpncihal_ctrl.hal_open_status) {
+        phNxpNciHal_configFeatureList(p_ntf,*p_len);
+      }
       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];
diff --git a/halimpl/libnfc-nxp-PN553_example.conf b/halimpl/libnfc-nxp-PN553_example.conf
index 818e473..e11e495 100755
--- a/halimpl/libnfc-nxp-PN553_example.conf
+++ b/halimpl/libnfc-nxp-PN553_example.conf
@@ -28,8 +28,10 @@
 VZW_FEATURE_ENABLE=0x01
 
 ###############################################################################
-# File name for Firmware
-NXP_FW_NAME="libpn553_fw.so"
+# Firmware file type
+#.so file   0x01
+#.bin file  0x02
+NXP_FW_TYPE=0x01
 
 ###############################################################################
 # System clock source selection configuration
diff --git a/halimpl/libnfc-nxp-PN553_example_NCI2_0.conf b/halimpl/libnfc-nxp-PN553_example_NCI2_0.conf
index 935b73e..f683666 100755
--- a/halimpl/libnfc-nxp-PN553_example_NCI2_0.conf
+++ b/halimpl/libnfc-nxp-PN553_example_NCI2_0.conf
@@ -28,8 +28,10 @@
 VZW_FEATURE_ENABLE=0x01
 
 ###############################################################################
-# File name for Firmware
-NXP_FW_NAME="libpn553_fw.so"
+# Firmware file type
+#.so file   0x01
+#.bin file  0x02
+NXP_FW_TYPE=0x01
 
 ###############################################################################
 # System clock source selection configuration
diff --git a/halimpl/libnfc-nxp-PN80T_example.conf b/halimpl/libnfc-nxp-PN80T_example.conf
index 45d276c..634435c 100755
--- a/halimpl/libnfc-nxp-PN80T_example.conf
+++ b/halimpl/libnfc-nxp-PN80T_example.conf
@@ -28,8 +28,10 @@
 VZW_FEATURE_ENABLE=0x01
 
 ###############################################################################
-# File name for Firmware
-NXP_FW_NAME="libpn553_fw.so"
+# Firmware file type
+#.so file   0x01
+#.bin file  0x02
+NXP_FW_TYPE=0x01
 
 ###############################################################################
 # System clock source selection configuration
diff --git a/halimpl/libnfc-nxp-PN80T_example_NCI2_0.conf b/halimpl/libnfc-nxp-PN80T_example_NCI2_0.conf
index 185b07d..aa4883d 100755
--- a/halimpl/libnfc-nxp-PN80T_example_NCI2_0.conf
+++ b/halimpl/libnfc-nxp-PN80T_example_NCI2_0.conf
@@ -28,8 +28,10 @@
 VZW_FEATURE_ENABLE=0x01
 
 ###############################################################################
-# File name for Firmware
-NXP_FW_NAME="libpn553_fw.so"
+# Firmware file type
+#.so file   0x01
+#.bin file  0x02
+NXP_FW_TYPE=0x01
 
 ###############################################################################
 # System clock source selection configuration
diff --git a/halimpl/libnfc-nxp-PN81T_example_NCI2_0.conf b/halimpl/libnfc-nxp-PN81T_example_NCI2_0.conf
index 979d04d..a2b9465 100755
--- a/halimpl/libnfc-nxp-PN81T_example_NCI2_0.conf
+++ b/halimpl/libnfc-nxp-PN81T_example_NCI2_0.conf
@@ -29,10 +29,10 @@
 VZW_FEATURE_ENABLE=0x01
 
 ###############################################################################
-# File name for Firmware
-# for library format ex: libpn5xx_fw.so
-# for binary format ex: pn5xx.bin
-NXP_FW_NAME="pn557.bin"
+# Firmware file type
+#.so file   0x01
+#.bin file  0x02
+NXP_FW_TYPE=0x01
 
 ###############################################################################
 # System clock source selection configuration
diff --git a/halimpl/utils/NxpNfcCapability.cpp b/halimpl/utils/NxpNfcCapability.cpp
new file mode 100644
index 0000000..fc0a6c3
--- /dev/null
+++ b/halimpl/utils/NxpNfcCapability.cpp
@@ -0,0 +1,94 @@
+/******************************************************************************
+ *
+ *  Copyright (C) 2015 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.
+ *
+ ******************************************************************************/
+#define LOG_TAG "NxpHal"
+#include "NxpNfcCapability.h"
+#include <phNxpLog.h>
+
+capability* capability::instance = NULL;
+tNFC_chipType capability::chipType = pn81T;
+tNfc_featureList nfcFL;
+
+capability::capability() {}
+
+capability* capability::getInstance() {
+  if (NULL == instance) {
+    instance = new capability();
+  }
+  return instance;
+}
+
+tNFC_chipType capability::processChipType(uint8_t* msg, uint16_t msg_len) {
+  if ((msg != NULL) && (msg_len != 0)) {
+    if (msg[0] == 0x60 && msg[1] == 00) {
+      if ((msg[offsetRstFwVersion] == 0x12) &&
+          (msg[offsetRstFwVersion + 1] == 0x01)) {
+        chipType = pn81T;
+      } else if ((msg[offsetRstFwVersion] == 0x11) &&
+                 (msg[offsetRstFwVersion + 1] == 0x02)) {
+        chipType = pn553;
+      }
+    } else if ((offsetInitFwVersion < msg_len) &&
+               (msg[offsetInitFwVersion] == 0x12)) {
+      chipType = pn81T;
+    }
+
+    else if (offsetHwVersion < msg_len) {
+      ALOGD("%s HwVersion : 0x%02x", __func__, msg[offsetHwVersion]);
+      switch (msg[offsetHwVersion]) {
+        case 0x40:  // PN553 A0
+        case 0x41:  // PN553 B0
+          // NQ310
+          chipType = pn553;
+          break;
+
+        case 0x50:  // PN553 A0 + P73
+        case 0x51:  // PN553 B0 + P73 , NQ440
+          // NQ330
+          chipType = pn80T;
+          break;
+
+        case 0x98:
+          chipType = pn551;
+          break;
+
+        case 0xA8:
+        case 0x08:
+          chipType = pn67T;
+          break;
+
+        case 0x28:
+        case 0x48:  // NQ210
+          chipType = pn548C2;
+          break;
+
+        case 0x18:
+        case 0x58:  // NQ220
+          chipType = pn66T;
+          break;
+
+        default:
+          chipType = pn80T;
+      }
+    } else {
+      ALOGD("%s Wrong msg_len. Setting Default ChiptType pn80T", __func__);
+      chipType = pn81T;
+    }
+  }
+  ALOGD("%s Product : %s", __func__, product[chipType]);
+  return chipType;
+}
diff --git a/halimpl/utils/NxpNfcCapability.h b/halimpl/utils/NxpNfcCapability.h
new file mode 100644
index 0000000..41e7b64
--- /dev/null
+++ b/halimpl/utils/NxpNfcCapability.h
@@ -0,0 +1,41 @@
+/******************************************************************************
+ *
+ *  Copyright (C) 2015 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.
+ *
+ ******************************************************************************/
+#ifndef __CAP_H__
+#define __CAP_H__
+#include "Nxp_Features.h"
+#define pConfigFL (capability::getInstance())
+
+class capability {
+ private:
+  static capability* instance;
+  const uint16_t offsetHwVersion = 24;
+  const uint16_t offsetInitFwVersion = 25;
+  const uint16_t offsetRstFwVersion = 9;
+  /*product[] will be used to print product version and
+  should be kept in accordance with tNFC_chipType*/
+  const char* product[11] = {"UNKNOWN", "PN547C2", "PN65T", "PN548C2",
+                             "PN66T",   "PN551",   "PN67T", "PN553",
+                             "PN80T",   "PN557",   "PN81T"};
+  capability();
+
+ public:
+  static tNFC_chipType chipType;
+  static capability* getInstance();
+  tNFC_chipType processChipType(uint8_t* msg, uint16_t msg_len);
+};
+#endif
diff --git a/halimpl/utils/phNxpConfig.h b/halimpl/utils/phNxpConfig.h
index 496cc24..e775d7c 100755
--- a/halimpl/utils/phNxpConfig.h
+++ b/halimpl/utils/phNxpConfig.h
@@ -65,7 +65,7 @@
 #define NAME_MIFARE_READER_ENABLE "MIFARE_READER_ENABLE"
 #define NAME_FW_STORAGE "FW_STORAGE"
 #define NAME_NXP_NFC_DEV_NODE "NXP_NFC_DEV_NODE"
-#define NAME_NXP_FW_NAME "NXP_FW_NAME"
+#define NAME_NXP_FW_TYPE "NXP_FW_TYPE"
 #define NAME_NXP_FW_PROTECION_OVERRIDE "NXP_FW_PROTECION_OVERRIDE"
 #define NAME_NXP_SYS_CLK_SRC_SEL "NXP_SYS_CLK_SRC_SEL"
 #define NAME_NXP_SYS_CLK_FREQ_SEL "NXP_SYS_CLK_FREQ_SEL"
diff --git a/halimpl/utils/phNxpNciHal_utils.cc b/halimpl/utils/phNxpNciHal_utils.cc
old mode 100755
new mode 100644
index c38e19a..4f50a10
--- a/halimpl/utils/phNxpNciHal_utils.cc
+++ b/halimpl/utils/phNxpNciHal_utils.cc
@@ -23,7 +23,6 @@
 #include <phNxpNciHal.h>
 #include <phNxpNciHal_utils.h>
 
-
 /*********************** Link list functions **********************************/
 
 /*******************************************************************************
@@ -338,10 +337,9 @@
 **
 *******************************************************************************/
 phNxpNciHal_Monitor_t* phNxpNciHal_get_monitor(void) {
- if(nxpncihal_monitor == NULL)
- {
+  if (nxpncihal_monitor == NULL) {
     NXPLOG_NCIHAL_E("nxpncihal_monitor is null");
- }
+  }
   return nxpncihal_monitor;
 }