NFC: Merge branch 'caf/caf/nxpnfc-project/br_android_ncihalx_o' into nfc.lnx.3.1

* caf/caf/nxpnfc-project/br_android_ncihalx_o: (36 commits)
  NFC_NCIHALx_AR003C.8.3.0_O_OpnSrc
  NFC_NCIHALx_AR0054.8.3.0_O_OpnSrc
  Update README.md
  NFC_NCIHALx_AR180C.8.3.0_O_OpnSrc
  SE Preference is set wrongly while calling selectSecureElement API in PN6xT.
  Nfc service died during Nfc on/off steability test.
  Corrected screen state condition checking
  Fix for HCE F failure
  Code cleanup, Removed redundant commitRouting API calling
  Fix for atr not working for conflict AID sent in screen lock state after selecting corresponding application
  Jcop download failed on DWP interface.
  Fix for NFC init fail when DUAL_UICC Flag is enabled
  JCOP Download over SPI interface failing in PN6xt, If NFC is On
  SPI open failing in PN6xt
  p61-jcop-kit library dynamic loading improvements
  Code correction in p2p_prio_logic_multiprotocol
  p61-jcop-lib library dynamic loading implementation
  NFCEE_MODE_SET_CMD to eSE disabled during NFC init in 6Xt.
  NFC_NCIHALx_AR18C0.8.2.3_O_OpnSrc
  NFC_NCIHALx_AR18C0.8.2.3_O_OpnSrc
  ...

Change-Id: I946cbbf54a861bdf6f530814e914ecb07a92cea2

20 files changed, 1152 insertions, 299 deletions

diff --git a/README.md b/README.md
index 46f881f6..c71c23a1 100644
--- a/README.md
+++ b/README.md
@@ -42,3 +42,7 @@
 | android-o-preview2                     |  8.0.C_O (PN553/PN557) |  NFC_NCIHALx_AR1800.8.0.C_O_OpnSrc |
 | android-o-preview2                     |  8.0.13_O (PN553/PN557) |  NFC_NCIHALx_AR18C0.8.0.13_O_OpnSrc |
 | android-8.0.0_r4               |  8.1.0_O (PN553) |  NFC_NCIHALx_AR00C0.8.1.0_O_OpnSrc |
+| android-8.0.0_r4               |  8.2.0_O (PN557) |  NFC_NCIHALx_AR18C0.8.2.0_O_OpnSrc |
+| android-8.0.0_r4               |  8.2.3_O (PN557) |  NFC_NCIHALx_AR18C0.8.2.3_O_OpnSrc |
+| android-8.0.0_r4               |  8.3.0_O (PN548C2/PN551/PN553) |  NFC_NCIHALx_AR0054.8.3.0_O_OpnSrc |
+| android-8.0.0_r4               |  8.3.0_O (PN548C2/PN551) | NFC_NCIHALx_AR003C.8.3.0_O_OpnSrc  |
diff --git a/nci/jni/Android.mk b/nci/jni/Android.mk
index 3e321bf8..97b12cd6 100644
--- a/nci/jni/Android.mk
+++ b/nci/jni/Android.mk
@@ -22,8 +22,6 @@ LOCAL_CFLAGS += -DNFC_NXP_HFO_SETTINGS=FALSE
 #Enable HCE-F specific
 LOCAL_CFLAGS += -DNXP_NFCC_HCE_F=TRUE
 
-NFC_NXP_ESE:= TRUE
-
 NFC_POWER_MANAGEMENT:= TRUE
 ifeq ($(NFC_POWER_MANAGEMENT),TRUE)
 LOCAL_CFLAGS += -DNFC_POWER_MANAGEMENT=TRUE
@@ -31,16 +29,13 @@ else
 LOCAL_CFLAGS += -DNFC_POWER_MANAGEMENT=FALSE
 endif
 
-ifeq ($(NFC_NXP_ESE),TRUE)
 LOCAL_CFLAGS += -DNXP_LDR_SVC_VER_2=TRUE
-else
-LOCAL_CFLAGS += -DNXP_LDR_SVC_VER_2=FALSE
-endif
 
 LOCAL_SRC_FILES := $(call all-subdir-cpp-files) $(call all-subdir-c-files)
 
 LOCAL_C_INCLUDES += \
     frameworks/native/include \
+    libnativehelper/include/nativehelper \
     $(NFA)/include \
     $(NFA)/brcm \
     $(NFC)/include \
diff --git a/nci/jni/HciRFParams.cpp b/nci/jni/HciRFParams.cpp
index 391a1b91..38a9d8f9 100644
--- a/nci/jni/HciRFParams.cpp
+++ b/nci/jni/HciRFParams.cpp
@@ -16,12 +16,18 @@
 
 
 #include "HciRFParams.h"
+#include "SecureElement.h"
 
 #define VAL_START_IDX 4
 #define MAX_AID_SIZE 10
 #define MAX_APP_DATA_SIZE 15
 #define MAX_HIGHER_LAYER_RSP_SIZE 15
 
+#if(NXP_EXTNS == true)
+#define ESE_HANDLE    0x4C0
+bool IsEseCeDisabled;
+#endif
+
 HciRFParams HciRFParams::sHciRFParams;
 
 /*******************************************************************************
@@ -118,6 +124,15 @@ bool HciRFParams::initialize ()
     ALOGV("%s: tlv_size %d", __func__,get_config->tlv_size);
     ALOGV("%s: param_tlvs %x", __func__,get_config->param_tlvs[0]);
 
+#if(NXP_EXTNS == true)
+    if((get_config->param_tlvs[1] == 0xA0 && get_config->param_tlvs[2] == 0xF0) &&
+        (get_config->param_tlvs[5] == 0xFF || get_config->param_tlvs[43] == 0xFF) &&
+         SecureElement::getInstance().getEeStatus(ESE_HANDLE) == NFA_EE_STATUS_ACTIVE) {
+        ALOGV("%s: CE with ESE is disabled", __func__);
+        IsEseCeDisabled = true;
+    }
+#endif
+
     uint8_t *params = get_config->param_tlvs;
     params+=VAL_START_IDX;
 
diff --git a/nci/jni/IntervalTimer.cpp b/nci/jni/IntervalTimer.cpp
index e5644bdf..5f034f42 100644
--- a/nci/jni/IntervalTimer.cpp
+++ b/nci/jni/IntervalTimer.cpp
@@ -118,3 +118,17 @@ bool IntervalTimer::create(TIMER_FUNC cb)
         ALOGE("fail create timer");
     return stat == 0;
 }
+
+bool IntervalTimer::isRunning(void)
+{
+   if (mTimerId == 0)
+       return false;
+
+    int stat = 0;
+    struct itimerspec ts;
+
+    stat = timer_gettime(mTimerId, &ts);
+    if (stat != 0)
+        return false;
+    return ((ts.it_value.tv_sec > 0 || ts.it_value.tv_nsec > 0) ? true : false);
+}
diff --git a/nci/jni/IntervalTimer.h b/nci/jni/IntervalTimer.h
index 66e345d3..b6bbd5a9 100644
--- a/nci/jni/IntervalTimer.h
+++ b/nci/jni/IntervalTimer.h
@@ -31,6 +31,7 @@ public:
     bool set(int ms, TIMER_FUNC cb);
     void kill();
     bool create(TIMER_FUNC );
+    bool isRunning(void);    //This function returns true if a valid timer is running(curTime > 0)
 
 private:
     timer_t mTimerId;
diff --git a/nci/jni/JcopManager.cpp b/nci/jni/JcopManager.cpp
new file mode 100644
index 00000000..30d10a8c
--- /dev/null
+++ b/nci/jni/JcopManager.cpp
@@ -0,0 +1,369 @@
+/*
+ * 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.
+ */
+
+#include "JcopManager.h"
+#include "_OverrideLog.h"
+#include <dlfcn.h>
+
+JcopManager* JcopManager::mJcpMgr = NULL;
+static void* Pgpx_JCP_handle = NULL;
+static phJcop_Context_t g_mPhJcpCtxt;
+static phJcop_Context_t *pg_mPhJcpCtxt = &g_mPhJcpCtxt;
+static void *Pgpx_Jcop_handle = NULL;
+#define DL_STATUS_OK 0x00
+
+JcopManager::JcopManager()
+{
+}
+
+JcopManager::~JcopManager()
+{
+}
+
+/*******************************************************************************
+**
+** Function:        getInstance
+**
+** Description:     Get the JcopManager singleton object.
+**
+** Returns:         JcopManager object.
+**
+*******************************************************************************/
+JcopManager* JcopManager::getInstance ()
+{
+    if(mJcpMgr == NULL){
+        mJcpMgr = new JcopManager();
+    }
+    return mJcpMgr;
+}
+
+/*******************************************************************************
+**
+** Function:        deleteInstance
+**
+** Description:     Delete the JcopManager singleton object.
+**
+*******************************************************************************/
+void JcopManager::deleteInstance ()
+{
+    if(mJcpMgr != NULL)
+    {
+        delete mJcpMgr;
+        mJcpMgr = NULL;
+    }
+}
+
+/*******************************************************************************
+**
+** Function:        JcopInitialize
+**
+** Description:     Load the library and initialize the symbols and variables.
+**
+** Returns:         STATUS_OK if Success.
+**                  STATUS_FAILED if unSuccessfull
+**
+*******************************************************************************/
+tNFA_STATUS JcopManager::JcopInitialize ()
+{
+    tNFA_STATUS wStatus = NFA_STATUS_OK;
+    //Getting pointer to JCOP module
+    Pgpx_Jcop_handle = dlopen("system/lib64/libp61-jcop-kit.so",RTLD_NOW);
+    if(Pgpx_Jcop_handle == NULL){
+        ALOGE("%s: Error : opening (system/lib64/libp61-jcop-kit.so) !!", __func__);
+        return NFA_STATUS_FAILED;
+    }
+    // Getting pointer to ALA_Init function
+    if((pg_mPhJcpCtxt->ala_init = (tJCOP_INIT_CBACK *)dlsym(Pgpx_Jcop_handle, "ALA_Init")) == NULL){
+        ALOGE("%s: Error while linking JCOP context (ALA_Init) !!", __func__);
+        return NFA_STATUS_FAILED;
+    }
+    // Getting pointer to ALA_Start function
+    if((pg_mPhJcpCtxt->ala_start = (tALA_START_CBACK *)dlsym(Pgpx_Jcop_handle, "ALA_Start")) == NULL){
+        wStatus = NFA_STATUS_FAILED;
+        ALOGE("%s: Error while linking JCOP context (ALA_Start) !!", __func__);
+    }
+
+#if (NXP_LDR_SVC_VER_2 == FALSE)
+    // Getting pointer to ALA_GetlistofApplets function
+    if((pg_mPhJcpCtxt->ala_applets_list = (tALA_APPLET_LIST_CBACK *)dlsym(Pgpx_Jcop_handle, "ALA_GetlistofApplets")) == NULL){
+        wStatus = NFA_STATUS_FAILED;
+        ALOGE("%s: Error while linking JCOP context (ALA_GetlistofApplets) !!", __func__);
+    }
+    // Getting pointer to ALA_GetCertificateKey function
+    if((pg_mPhJcpCtxt->ala_get_certkey = (tALA_GET_CERTKEY_CBACK *)dlsym(Pgpx_Jcop_handle, "ALA_GetCertificateKey")) == NULL){
+        wStatus = NFA_STATUS_FAILED;
+        ALOGE("%s: Error while linking JCOP context (ALA_GetCertificateKey) !!", __func__);
+    }
+#endif
+
+    // Getting pointer to ALA_DeInit function
+    if((pg_mPhJcpCtxt->ala_deinit = (tJCOP_DEINIT_CBACK *)dlsym(Pgpx_Jcop_handle, "ALA_DeInit")) == NULL){
+        wStatus = NFA_STATUS_FAILED;
+        ALOGE("%s: Error while linking JCOP context (ALA_DeInit) !!", __func__);
+    }
+    // Getting pointer to ALA_lsGetVersion function
+    if((pg_mPhJcpCtxt->ala_lsgetversion = (tALA_LS_CBACK *)dlsym(Pgpx_Jcop_handle, "ALA_lsGetVersion")) == NULL){
+        wStatus = NFA_STATUS_FAILED;
+        ALOGE("%s: Error while linking JCOP context (ALA_lsGetVersion) !!", __func__);
+    }
+    // Getting pointer to ALA_lsGetStatus function
+    if((pg_mPhJcpCtxt->ala_lsgetstatus = (tALA_LS_CBACK *)dlsym(Pgpx_Jcop_handle, "ALA_lsGetStatus")) == NULL){
+        wStatus = NFA_STATUS_FAILED;
+        ALOGE("%s: Error while linking JCOP context (ALA_lsGetStatus) !!", __func__);
+    }
+    // Getting pointer to ALA_lsGetAppletStatus function
+    if((pg_mPhJcpCtxt->ala_lsgetappletstatus = (tALA_LS_CBACK *)dlsym(Pgpx_Jcop_handle, "ALA_lsGetAppletStatus")) == NULL){
+        wStatus = NFA_STATUS_FAILED;
+        ALOGE("%s: Error while linking JCOP context (ALA_lsGetAppletStatus) !!", __func__);
+    }
+    // Getting pointer to JCDNLD_Init function
+    if((pg_mPhJcpCtxt->jcop_init = (tJCOP_INIT_CBACK *)dlsym(Pgpx_Jcop_handle, "JCDNLD_Init")) == NULL){
+        wStatus = NFA_STATUS_FAILED;
+        ALOGE("%s: Error while linking JCOP context (JCDNLD_Init) !!", __func__);
+    }
+    // Getting pointer to JCDNLD_StartDownload function
+    if((pg_mPhJcpCtxt->jcdnld_startdnld = (tJCDNLD_DWLD_CBACK *)dlsym(Pgpx_Jcop_handle, "JCDNLD_StartDownload")) == NULL){
+        wStatus = NFA_STATUS_FAILED;
+        ALOGE("%s: Error while linking JCOP context (JCDNLD_StartDownload) !!", __func__);
+    }
+    // Getting pointer to JCDNLD_DeInit function
+    if((pg_mPhJcpCtxt->jcdnld_deinit = (tJCOP_DEINIT_CBACK *)dlsym(Pgpx_Jcop_handle, "JCDNLD_DeInit")) == NULL){
+        wStatus = NFA_STATUS_FAILED;
+        ALOGE("%s: Error while linking JCOP context (JCDNLD_DeInit) !!", __func__);
+    }
+    return wStatus;
+}
+
+/*******************************************************************************
+**
+** Function:        JcopDeInitialize
+**
+** Description:     De-initialize the library
+**
+** Returns:         STATUS_OK if Success.
+**                  STATUS_FAILED if unSuccessfull
+**
+*******************************************************************************/
+tNFA_STATUS JcopManager::JcopDeInitialize ()
+{
+    if(Pgpx_Jcop_handle != NULL){
+        if((dlclose(Pgpx_Jcop_handle)) != DL_STATUS_OK){
+            ALOGE("%s: Error : closing (system/lib64/libp61-jcop-kit.so) !!", __func__);
+            return NFA_STATUS_FAILED;
+        }
+    }else{
+        ALOGE("%s: Invalid handle !!", __func__);
+    }
+    return NFA_STATUS_OK;
+}
+
+/*******************************************************************************
+**
+** Function:        AlaInitialize
+**
+** Description:     Initializes the ALA library and opens the DWP communication channel
+**
+** Returns:         STATUS_OK if Success.
+**                  STATUS_FAILED if unSuccessfull
+**
+*******************************************************************************/
+tNFC_JBL_STATUS JcopManager::AlaInitialize (IChannel_t *channel)
+{
+    if(channel == NULL)
+    {
+        ALOGE("%s: Invalid handle !!", __func__);
+        return NFA_STATUS_FAILED;
+    }
+    return pg_mPhJcpCtxt->ala_init(channel);
+}
+
+/*******************************************************************************
+**
+** Function:        AlaDeInitialize
+**
+** Description:     Deinitializes the ALA Lib
+**
+** Returns:         True if ok.
+**
+*******************************************************************************/
+bool JcopManager::AlaDeInitialize () { return pg_mPhJcpCtxt->ala_deinit(); }
+
+/*******************************************************************************
+**
+** Function:        AlaStart
+**
+** Description:     Starts the ALA over DWP
+**
+** Returns:         STATUS_OK if Success.
+**                  STATUS_FAILED if unSuccessfull
+**
+*******************************************************************************/
+#if (NXP_LDR_SVC_VER_2 == TRUE)
+tNFC_JBL_STATUS JcopManager::AlaStart (const char *name, const char *dest, uint8_t *pdata, uint16_t len, uint8_t *respSW)
+{
+    if( !name || !dest || !pdata || !respSW){
+        ALOGE("%s: Invalid Params !!", __func__);
+        return NFA_STATUS_FAILED;
+    }
+    return pg_mPhJcpCtxt->ala_start(name, dest, pdata, len, respSW);
+}
+#else
+tNFC_JBL_STATUS JcopManager::AlaStart (const char *name, uint8_t *pdata, uint16_t len)
+{
+    if( !name || !pdata ){
+        ALOGE("%s: Invalid Params !!", __func__);
+        return NFA_STATUS_FAILED;
+    }
+    return pg_mPhJcpCtxt->ala_start(name, dest, pdata, len, respSW);
+}
+#endif
+
+#if (NXP_LDR_SVC_VER_2 == FALSE)
+/*******************************************************************************
+**
+** Function:        AlaGetlistofApplets
+**
+** Description:     list all the applets.
+**
+*******************************************************************************/
+void JcopManager::AlaGetlistofApplets (char *list[], uint8_t* num)
+{
+    if(!list || !num){
+        ALOGE("%s: Invalid Params !!", __func__);
+        return;
+    }
+    pg_mPhJcpCtxt->ala_applets_list(list, num);
+}
+
+/*******************************************************************************
+**
+** Function:        AlaGetCertificateKey
+**
+** Description:     Get the certification key
+**
+** Returns:         True if ok.
+**
+*******************************************************************************/
+tNFC_JBL_STATUS JcopManager::AlaGetCertificateKey (uint8_t *pKey, int32_t *pKeylen)
+{
+    if(!pKey || !pKeylen){
+        ALOGE("%s: Invalid Params !!", __func__);
+        return NFA_STATUS_FAILED;
+    }
+    return pg_mPhJcpCtxt->ala_get_certkey(pKey, pKeylen);
+}
+#endif
+
+/*******************************************************************************
+**
+** Function:        AlaLsGetVersion
+**
+** Description:     Get the version of the loader version
+**
+** Returns:         STATUS_OK if Success.
+**                  STATUS_FAILED if unSuccessfull
+**
+*******************************************************************************/
+tNFC_JBL_STATUS JcopManager::AlaLsGetVersion (uint8_t *pVersion)
+{
+    if(!pVersion){
+        ALOGE("%s: Invalid Params !!", __func__);
+        return NFA_STATUS_FAILED;
+    }
+    return pg_mPhJcpCtxt->ala_lsgetversion(pVersion);
+}
+
+/*******************************************************************************
+**
+** Function:        AlaLsGetAppletStatus
+**
+** Description:     Get the status of the loader service version
+**
+** Returns:         STATUS_OK if Success.
+**                  STATUS_FAILED if unSuccessfull
+**
+*******************************************************************************/
+tNFC_JBL_STATUS JcopManager::AlaLsGetAppletStatus (uint8_t *pVersion)
+{
+    if(!pVersion){
+        ALOGE("%s: Invalid Params !!", __func__);
+        return NFA_STATUS_FAILED;
+    }
+    return pg_mPhJcpCtxt->ala_lsgetappletstatus(pVersion);
+}
+
+/*******************************************************************************
+**
+** Function:        AlaLsGetAppletStatus
+**
+** Description:     Get the status of the loader service
+**
+** Returns:         STATUS_OK if Success.
+**                  STATUS_FAILED if unSuccessfull
+**
+*******************************************************************************/
+tNFC_JBL_STATUS JcopManager::AlaLsGetStatus (uint8_t *pVersion)
+{
+    if(!pVersion){
+        ALOGE("%s: Invalid Params !!", __func__);
+        return NFA_STATUS_FAILED;
+    }
+    return pg_mPhJcpCtxt->ala_lsgetstatus(pVersion);
+}
+
+/*******************************************************************************
+**
+** Function:        JCDnldInit
+**
+** Description:     Initializes the JCOP library and opens the DWP communication channel
+**
+** Returns:         STATUS_OK if Success.
+**                  STATUS_FAILED if unSuccessfull
+**
+*******************************************************************************/
+tNFC_JBL_STATUS JcopManager::JCDnldInit (IChannel_t *channel)
+{
+    if(!channel){
+        ALOGE("%s: Invalid Params !!", __func__);
+        return NFA_STATUS_FAILED;
+    }
+    return pg_mPhJcpCtxt->jcop_init(channel);
+}
+
+/*******************************************************************************
+**
+** Function:        JCDnldStartDownload
+**
+** Description:     Starts the JCOP update
+**
+** Returns:         STATUS_OK if Success.
+**                  STATUS_FAILED if unSuccessfull
+**
+*******************************************************************************/
+tNFC_JBL_STATUS JcopManager::JCDnldStartDownload () { return pg_mPhJcpCtxt->jcdnld_startdnld(); }
+
+/*******************************************************************************
+**
+** Function:        JCDnldDeInit
+**
+** Description:     De-initializes the JCOP Library
+**
+** Returns:         True if ok.
+**
+*******************************************************************************/
+bool JcopManager::JCDnldDeInit () { return pg_mPhJcpCtxt->jcdnld_deinit(); }
+
+
diff --git a/nci/jni/JcopManager.h b/nci/jni/JcopManager.h
new file mode 100644
index 00000000..2e1ac349
--- /dev/null
+++ b/nci/jni/JcopManager.h
@@ -0,0 +1,274 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+extern "C"{
+#include "nfa_api.h"
+}
+
+typedef struct IChannel
+{
+    int16_t (*open)();              /* Initialize the channel. */
+    bool (*close)(int16_t mHandle); /* Close the channel. */
+    bool (*transceive) (uint8_t* xmitBuffer, int32_t xmitBufferSize, uint8_t* recvBuffer,
+                     int32_t recvBufferMaxSize, int32_t& recvBufferActualSize, int32_t timeoutMillisec); /* Send/receive data to the secure element*/
+    void (*doeSE_Reset)();          /* Power OFF and ON to eSE */
+    void (*doeSE_JcopDownLoadReset)(); /* Power OFF and ON to eSE during JCOP Update */
+}IChannel_t;
+
+
+#define pJcopMgr     (JcopManager::getInstance ())
+typedef unsigned char (tJCOP_INIT_CBACK)(IChannel_t *channel);
+#if (NXP_LDR_SVC_VER_2 == TRUE)
+typedef unsigned char (tALA_START_CBACK)(const char *name, const char *dest, uint8_t *pdata, uint16_t len, uint8_t *respSW);
+#else
+typedef unsigned char (tALA_START_CBACK)(const char *name, uint8_t *pdata, uint16_t len);
+typedef unsigned char (tALA_GET_CERTKEY_CBACK)(uint8_t *pKey, int32_t *pKeylen);
+typedef void (tALA_APPLET_LIST_CBACK)(char *list[], uint8_t* num);
+#endif
+typedef unsigned char (tALA_LS_CBACK)(uint8_t *pVersion);
+typedef unsigned char (tJCDNLD_DWLD_CBACK)();
+typedef bool (tJCOP_DEINIT_CBACK)();
+
+typedef struct phJcop_Context
+{
+    /* Call backs */
+    tJCOP_INIT_CBACK          *jcop_init;
+    tJCOP_INIT_CBACK          *ala_init;
+    tALA_START_CBACK          *ala_start;
+#if (NXP_LDR_SVC_VER_2 == FALSE)
+    tALA_APPLET_LIST_CBACK    *ala_applets_list;
+    tALA_GET_CERTKEY_CBACK    *ala_get_certkey;
+#endif
+    tALA_LS_CBACK             *ala_lsgetversion;
+    tALA_LS_CBACK             *ala_lsgetstatus;
+    tALA_LS_CBACK             *ala_lsgetappletstatus;
+    tJCDNLD_DWLD_CBACK        *jcdnld_startdnld;
+    tJCOP_DEINIT_CBACK        *ala_deinit;
+    tJCOP_DEINIT_CBACK        *jcdnld_deinit;
+}phJcop_Context_t;
+typedef unsigned char tNFC_JBL_STATUS;
+
+class JcopManager
+{
+private:
+    static JcopManager *mJcpMgr;
+    /*******************************************************************************
+    **
+    ** Function:        JcopManager
+    **
+    ** Description:     Initialize member variables.
+    **
+    ** Returns:         None
+    **
+    *******************************************************************************/
+    JcopManager ();
+
+
+    /*******************************************************************************
+    **
+    ** Function:        ~JcopManager
+    **
+    ** Description:     Release all resources.
+    **
+    ** Returns:         None
+    **
+    *******************************************************************************/
+    ~JcopManager ();
+
+public:
+    /*******************************************************************************
+    **
+    ** Function:        getInstance
+    **
+    ** Description:     Get the JcopManager singleton object.
+    **
+    ** Returns:         JcopManager object.
+    **
+    *******************************************************************************/
+    static JcopManager* getInstance ();
+
+    /*******************************************************************************
+    **
+    ** Function:        deleteInstance
+    **
+    ** Description:     Delete the JcopManager singleton object.
+    **
+    *******************************************************************************/
+    void deleteInstance ();
+
+    /*******************************************************************************
+    **
+    ** Function:        JcopInitialize
+    **
+    ** Description:     Load the library and initialize the symbols and variables.
+    **
+    ** Returns:         STATUS_OK if Success.
+    **                  STATUS_FAILED if unSuccessfull
+    **
+    *******************************************************************************/
+    tNFA_STATUS JcopInitialize ();
+
+    /*******************************************************************************
+    **
+    ** Function:        JcopDeInitialize
+    **
+    ** Description:     De-initialize the library
+    **
+    ** Returns:         STATUS_OK if Success.
+    **                  STATUS_FAILED if unSuccessfull
+    **
+    *******************************************************************************/
+    tNFA_STATUS JcopDeInitialize ();
+
+    /*******************************************************************************
+    **
+    ** Function:        AlaInitialize
+    **
+    ** Description:     Initializes the ALA library and opens the DWP communication channel
+    **
+    ** Returns:         STATUS_OK if Success.
+    **                  STATUS_FAILED if unSuccessfull
+    **
+    *******************************************************************************/
+    tNFC_JBL_STATUS AlaInitialize (IChannel_t *channel);
+
+    /*******************************************************************************
+    **
+    ** Function:        AlaDeInitialize
+    **
+    ** Description:     Deinitializes the ALA Lib
+    **
+    ** Returns:         True if ok.
+    **
+    *******************************************************************************/
+    bool AlaDeInitialize ();
+
+    /*******************************************************************************
+    **
+    ** Function:        AlaStart
+    **
+    ** Description:     Starts the ALA over DWP
+    **
+    ** Returns:         STATUS_OK if Success.
+    **                  STATUS_FAILED if unSuccessfull
+    **
+    *******************************************************************************/
+#if (NXP_LDR_SVC_VER_2 == TRUE)
+    tNFC_JBL_STATUS AlaStart (const char *name, const char *dest, uint8_t *pdata, uint16_t len, uint8_t *respSW);
+#else
+    tNFC_JBL_STATUS AlaStart (const char *name, uint8_t *pdata, uint16_t len);
+#endif
+
+    /*******************************************************************************
+    **
+    ** Function:        AlaLsGetVersion
+    **
+    ** Description:     Get the version of the loader version
+    **
+    ** Returns:         STATUS_OK if Success.
+    **                  STATUS_FAILED if unSuccessfull
+    **
+    *******************************************************************************/
+    tNFC_JBL_STATUS AlaLsGetVersion (uint8_t *pVersion);
+
+    /*******************************************************************************
+    **
+    ** Function:        AlaLsGetAppletStatus
+    **
+    ** Description:     Get the status of the loader service version
+    **
+    ** Returns:         STATUS_OK if Success.
+    **                  STATUS_FAILED if unSuccessfull
+    **
+    *******************************************************************************/
+    tNFC_JBL_STATUS AlaLsGetAppletStatus (uint8_t *pVersion);
+
+    /*******************************************************************************
+    **
+    ** Function:        AlaLsGetAppletStatus
+    **
+    ** Description:     Get the status of the loader service
+    **
+    ** Returns:         STATUS_OK if Success.
+    **                  STATUS_FAILED if unSuccessfull
+    **
+    *******************************************************************************/
+    tNFC_JBL_STATUS AlaLsGetStatus (uint8_t *pVersion);
+
+#if (NXP_LDR_SVC_VER_2 == FALSE)
+    /*******************************************************************************
+    **
+    ** Function:        AlaGetlistofApplets
+    **
+    ** Description:     list all the applets.
+    **
+    *******************************************************************************/
+
+    void AlaGetlistofApplets (char *list[], uint8_t* num);
+
+
+    /*******************************************************************************
+    **
+    ** Function:        AlaGetCertificateKey
+    **
+    ** Description:     Get the certification key
+    **
+    ** Returns:         True if ok.
+    **
+    *******************************************************************************/
+    tNFC_JBL_STATUS AlaGetCertificateKey (uint8_t *pKey, int32_t *pKeylen);
+#endif
+
+
+
+    /*******************************************************************************
+    **
+    ** Function:        JCDnldInit
+    **
+    ** Description:     Initializes the JCOP library and opens the DWP communication channel
+    **
+    ** Returns:         STATUS_OK if Success.
+    **                  STATUS_FAILED if unSuccessfull
+    **
+    *******************************************************************************/
+    tNFC_JBL_STATUS JCDnldInit (IChannel_t *channel);
+
+    /*******************************************************************************
+    **
+    ** Function:        JCDnldStartDownload
+    **
+    ** Description:     Starts the JCOP update
+    **
+    ** Returns:         STATUS_OK if Success.
+    **                  STATUS_FAILED if unSuccessfull
+    **
+    *******************************************************************************/
+    tNFC_JBL_STATUS JCDnldStartDownload ();
+
+    /*******************************************************************************
+    **
+    ** Function:        JCDnldDeInit
+    **
+    ** Description:     De-initializes the JCOP Library
+    **
+    ** Returns:         True if ok.
+    **
+    *******************************************************************************/
+    bool JCDnldDeInit ();
+
+};
diff --git a/nci/jni/NativeNfcAla.cpp b/nci/jni/NativeNfcAla.cpp
index b6145283..99f14722 100644
--- a/nci/jni/NativeNfcAla.cpp
+++ b/nci/jni/NativeNfcAla.cpp
@@ -24,10 +24,9 @@
 #include "DwpChannel.h"
 #include "SecureElement.h"
 #include "TransactionController.h"
+#include "JcopManager.h"
 extern "C"
 {
-    #include "AlaLib.h"
-    #include "IChannel.h"
     #include "phNxpConfig.h"
 }
 #define LS_DEFAULT_VERSION 0x20
@@ -85,7 +84,7 @@ int nfcManager_GetAppletsList(JNIEnv* e, jobject o, jobjectArray list)
             startRfDiscovery (false);
         }
         ALOGV("%s: list_len=0x%x", __func__, list_len);
-        ALA_GetlistofApplets(name, &num);
+        pJcopMgr->AlaGetlistofApplets(name, &num);
 
         if((num != 0) &&
                 (list_len >= num))
@@ -158,7 +157,7 @@ int nfcManager_doAppletLoadApplet(JNIEnv* e, jobject o, jstring name, jbyteArray
             startRfDiscovery (false);
         }
         DWPChannel_init(&Dwp);
-        wStatus = ALA_Init(&Dwp);
+        wStatus = pJcopMgr->AlaInitialize(&Dwp);
         if(wStatus != NFA_STATUS_OK)
         {
             ALOGE("%s: ALA initialization failed", __func__);
@@ -171,9 +170,9 @@ int nfcManager_doAppletLoadApplet(JNIEnv* e, jobject o, jstring name, jbyteArray
             ScopedByteArrayRO bytes(e, data);
             uint8_t* buf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0]));
             size_t bufLen = bytes.size();
-            wStatus = ALA_Start(choice, buf, bufLen);
+            wStatus = pJcopMgr->AlaStart(choice, buf, bufLen);
         }
-        stat = ALA_DeInit();
+        stat = pJcopMgr->AlaDeInitialize();
         if(choice != NULL)
             e->ReleaseStringUTFChars(name, choice);
 
@@ -240,7 +239,7 @@ jbyteArray nfcManager_lsExecuteScript(JNIEnv* e, jobject o, jstring name, jstrin
             startRfDiscovery (false);
         }
         DWPChannel_init(&Dwp);
-        wStatus = ALA_Init(&Dwp);
+        wStatus = pJcopMgr->AlaInitialize(&Dwp);
         if(wStatus != NFA_STATUS_OK)
         {
             ALOGE("%s: ALA initialization failed", __func__);
@@ -267,7 +266,7 @@ jbyteArray nfcManager_lsExecuteScript(JNIEnv* e, jobject o, jstring name, jstrin
             ScopedByteArrayRO bytes(e, data);
             uint8_t* buf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0]));
             size_t bufLen = bytes.size();
-            wStatus = ALA_Start(choice,destpath, buf, bufLen,resSW);
+            wStatus = pJcopMgr->AlaStart(choice,destpath, buf, bufLen,resSW);
 
             //copy results back to java
             result = e->NewByteArray(lsExecuteResponseSize);
@@ -286,7 +285,7 @@ jbyteArray nfcManager_lsExecuteScript(JNIEnv* e, jobject o, jstring name, jstrin
         sNfaVSCResponseEvent.wait(); //wait for NFA VS command to finish
     }*/
 
-        stat = ALA_DeInit();
+        stat = pJcopMgr->AlaDeInitialize();
         if(choice != NULL)
             e->ReleaseStringUTFChars(name, choice);
 
@@ -341,7 +340,7 @@ jbyteArray nfcManager_GetCertificateKey(JNIEnv* e, jobject)
             startRfDiscovery (false);
         }
         DWPChannel_init(&Dwp);
-        wStatus = ALA_Init(&Dwp);
+        wStatus = pJcopMgr->AlaInitialize(&Dwp);
         if(wStatus != NFA_STATUS_OK)
         {
             ALOGE("%s: ALA initialization failed", __func__);
@@ -349,7 +348,7 @@ jbyteArray nfcManager_GetCertificateKey(JNIEnv* e, jobject)
         else
         {
             ALOGE("%s: start Get reference Certificate Key", __func__);
-            wStatus = ALA_GetCertificateKey(recvBuffer, &recvBufferActualSize);
+            wStatus = pJcopMgr->AlaGetCertificateKey(recvBuffer, &recvBufferActualSize);
         }
 
         //copy results back to java
@@ -359,7 +358,7 @@ jbyteArray nfcManager_GetCertificateKey(JNIEnv* e, jobject)
             e->SetByteArrayRegion(result, 0, recvBufferActualSize, (jbyte *) recvBuffer);
         }
 
-        stat = ALA_DeInit();
+        stat = pJcopMgr->AlaDeInitialize();
         startRfDiscovery (true);
 
         ALOGV("%s: exit: recv len=%ld", __func__, recvBufferActualSize);
@@ -407,7 +406,7 @@ jbyteArray nfcManager_lsGetVersion(JNIEnv* e, jobject)
             startRfDiscovery (false);
         }
         DWPChannel_init(&Dwp);
-        wStatus = ALA_Init(&Dwp);
+        wStatus = pJcopMgr->AlaInitialize(&Dwp);
         if(wStatus != NFA_STATUS_OK)
         {
             ALOGE("%s: ALA initialization failed", __func__);
@@ -415,7 +414,7 @@ jbyteArray nfcManager_lsGetVersion(JNIEnv* e, jobject)
         else
         {
             ALOGE("%s: start Get reference Certificate Key", __func__);
-            wStatus = ALA_lsGetVersion(recvBuffer);
+            wStatus = pJcopMgr->AlaLsGetVersion(recvBuffer);
         }
 
         //copy results back to java
@@ -425,7 +424,7 @@ jbyteArray nfcManager_lsGetVersion(JNIEnv* e, jobject)
             e->SetByteArrayRegion(result, 0, recvBufferMaxSize, (jbyte *) recvBuffer);
         }
 
-        stat = ALA_DeInit();
+        stat = pJcopMgr->AlaDeInitialize();
         if(dwpChannelForceClose == false)
             startRfDiscovery (true);
 
@@ -472,7 +471,7 @@ jbyteArray nfcManager_lsGetAppletStatus(JNIEnv* e, jobject)
             startRfDiscovery (false);
         }
         DWPChannel_init(&Dwp);
-        wStatus = ALA_Init(&Dwp);
+        wStatus = pJcopMgr->AlaInitialize(&Dwp);
         if(wStatus != NFA_STATUS_OK)
         {
             ALOGE("%s: ALA initialization failed", __func__);
@@ -480,7 +479,7 @@ jbyteArray nfcManager_lsGetAppletStatus(JNIEnv* e, jobject)
         else
         {
             ALOGE("%s: start Get reference Certificate Key", __func__);
-            wStatus = ALA_lsGetAppletStatus(recvBuffer);
+            wStatus = pJcopMgr->AlaLsGetAppletStatus(recvBuffer);
         }
 
         ALOGV("%s: lsGetAppletStatus values %x %x", __func__, recvBuffer[0], recvBuffer[1]);
@@ -490,7 +489,7 @@ jbyteArray nfcManager_lsGetAppletStatus(JNIEnv* e, jobject)
         {
             e->SetByteArrayRegion(result, 0, recvBufferMaxSize, (jbyte *) recvBuffer);
         }
-        stat = ALA_DeInit();
+        stat = pJcopMgr->AlaDeInitialize();
 
         if(dwpChannelForceClose == false)
             startRfDiscovery (true);
@@ -526,7 +525,7 @@ jbyteArray nfcManager_lsGetStatus(JNIEnv* e, jobject)
         const int32_t recvBufferMaxSize = 2;
         uint8_t recvBuffer [recvBufferMaxSize] = {0x63,0x40};
 
-        wStatus = ALA_lsGetStatus(recvBuffer);
+        wStatus = pJcopMgr->AlaLsGetStatus(recvBuffer);
 
         ALOGV("%s: lsGetStatus values %x %x", __func__, recvBuffer[0], recvBuffer[1]);
         //copy results back to java
diff --git a/nci/jni/NativeNfcManager.cpp b/nci/jni/NativeNfcManager.cpp
index 73574ed8..132d99bb 100644
--- a/nci/jni/NativeNfcManager.cpp
+++ b/nci/jni/NativeNfcManager.cpp
@@ -48,6 +48,7 @@
 #include "DwpChannel.h"
 #include "TransactionController.h"
 #include <fcntl.h>
+#include "JcopManager.h"
 extern "C"
 {
     #include "nfc_api.h"
@@ -60,10 +61,6 @@ extern "C"
     #include "phNxpExtns.h"
     #include "phNxpConfig.h"
 
-#if(NXP_EXTNS == TRUE)
-    #include "JcDnld.h"
-    #include "IChannel.h"
-#endif
 }
 #define ALOGV ALOGD
 #define SAK_VALUE_AT 17
@@ -96,6 +93,7 @@ extern bool                 recovery;
 extern uint8_t              swp_getconfig_status;
 extern int                  gUICCVirtualWiredProtectMask;
 extern int                  gEseVirtualWiredProtectMask;
+extern bool                 IsEseCeDisabled;
 static int32_t              gNfcInitTimeout;
 int32_t                     gdisc_timeout;
 int32_t                     gSeDiscoverycount = 0;
@@ -529,7 +527,6 @@ void *enableThread(void *arg);
 static IntervalTimer scleanupTimerProc_transaction;
 static bool gIsDtaEnabled=false;
 
-tNfc_featureList nfcFL;
 static void nfcManager_getFeatureList();
 static jbyteArray nfcManager_getAdditionalConfigOptions(JNIEnv *e, jobject o);
 static void register_signal_handler();
@@ -635,7 +632,7 @@ void *p2p_prio_logic_multiprotocol(void* /* arg */)
 
     ALOGD ("%s: enter", __FUNCTION__);
     /* Do not need if it is already in screen off state */
-    if ((getScreenState() != (NFA_SCREEN_STATE_OFF_LOCKED || NFA_SCREEN_STATE_OFF_UNLOCKED)))
+    if (!(getScreenState() & (NFA_SCREEN_STATE_OFF_LOCKED | NFA_SCREEN_STATE_OFF_UNLOCKED)))
     {
         /* Stop polling */
         if (sRfEnabled)
@@ -1632,7 +1629,17 @@ void nfaDeviceManagementCallback (uint8_t dmEvent, tNFA_DM_CBACK_DATA* eventData
              }
             else
             {
-                pTransactionController->transactionEnd(TRANSACTION_REQUESTOR(RF_FIELD_EVT));
+                /*In case of 66T/67T if Field On is not received before activation, consider NFA_ACTIVATED_EVENT for
+                 locking the transaction and use Field Off received while removing the reader from proximity to end the lock*/
+                if(((nfcFL.chipType == pn548C2) || (nfcFL.chipType == pn551)) &&
+                    pTransactionController->getCurTransactionRequestor() == TRANSACTION_REQUESTOR(NFA_ACTIVATED_EVENT))
+                {
+                    pTransactionController->transactionEnd(TRANSACTION_REQUESTOR(NFA_ACTIVATED_EVENT));
+                }
+                else
+                {
+                    pTransactionController->transactionEnd(TRANSACTION_REQUESTOR(RF_FIELD_EVT));
+                }
                 sRfFieldOff = true;
                 e->CallVoidMethod (nat->manager, android::gCachedNfcManagerNotifyRfFieldDeactivated);
             }
@@ -1821,12 +1828,21 @@ static jboolean nfcManager_routeAid (JNIEnv* e, jobject, jbyteArray aid, jint ro
     ScopedByteArrayRO bytes(e, aid);
     uint8_t* buf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0]));
     size_t bufLen = bytes.size();
+
 #if (NXP_EXTNS == TRUE)
     if((nfcFL.nfccFL._NFC_NXP_STAT_DUAL_UICC_WO_EXT_SWITCH) &&
             (route == 2 || route == 4)) { //UICC or UICC2 HANDLE
         ALOGV("sCurrentSelectedUICCSlot:  %d", sCurrentSelectedUICCSlot);
         route = (sCurrentSelectedUICCSlot != 0x02) ? 0x02 : 0x04;
     }
+    /*In case of 66T/67T field on is observed as last field event once reader
+     is removed from proximity, which will hold the transaction lock unnecessarily
+     In such cases end the lock as it is not required*/
+    if(((nfcFL.chipType == pn548C2) || (nfcFL.chipType == pn551)) &&
+        pTransactionController->getCurTransactionRequestor() == TRANSACTION_REQUESTOR(RF_FIELD_EVT))
+    {
+        pTransactionController->transactionEnd(TRANSACTION_REQUESTOR(RF_FIELD_EVT));
+    }
     if(nfcManager_isTransanctionOnGoing(true))
     {
        return false;
@@ -2050,6 +2066,14 @@ static jint nfcManager_getRemainingAidTableSize (JNIEnv* , jobject )
 static bool nfcManager_clearAidTable (JNIEnv*, jobject)
 {
 #if(NXP_EXTNS == TRUE)
+    /*In case of 66T/67T field on is observed as last field event once reader
+     is removed from proximity, which will hold the transaction lock unnecessarily
+     In such cases end the lock as it is not required*/
+    if(((nfcFL.chipType == pn548C2) || (nfcFL.chipType == pn551)) &&
+        pTransactionController->getCurTransactionRequestor() == TRANSACTION_REQUESTOR(RF_FIELD_EVT))
+    {
+        pTransactionController->transactionEnd(TRANSACTION_REQUESTOR(RF_FIELD_EVT));
+    }
     if(nfcManager_isTransanctionOnGoing(true))
     {
        return false;
@@ -2139,6 +2163,7 @@ static jboolean nfcManager_doInitialize (JNIEnv* e, jobject o)
     tNFA_PMID ven_config_addr[]  = {0xA0, 0x07};
     bool isSuccess = false;
     sNfcee_disc_state = UICC_SESSION_NOT_INTIALIZED;
+    IsEseCeDisabled = false;
 
     /* NFC initialization in progress */
     if(NFC_OFF == sNfcState)
@@ -2187,6 +2212,11 @@ static jboolean nfcManager_doInitialize (JNIEnv* e, jobject o)
 #endif
             stat = nfcManagerEnableNfc(theInstance);
             nfcManager_getFeatureList();
+            if(nfcFL.nfcNxpEse){
+                ALOGV("ESE Present Loading p61-jcop-lib");
+                pJcopMgr->JcopInitialize();
+            }else
+                ALOGV("ESE Not Present");
             EXTNS_Init (nfaDeviceManagementCallback, nfaConnectionCallback);
 
         if (stat == NFA_STATUS_OK )
@@ -2229,6 +2259,8 @@ static jboolean nfcManager_doInitialize (JNIEnv* e, jobject o)
                         ALOGV("All ESE are discovered ");
                     }
                 }
+                //Create transaction controller
+                (void)transactionController::controller();
                 if(nfcFL.nfccFL._NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH) {
                     checkforESERemoval();
                     GetNxpNumValue (NAME_NXP_DUAL_UICC_ENABLE, (void*)&dualUiccInfo.dualUiccEnable, sizeof(dualUiccInfo.dualUiccEnable));
@@ -2286,6 +2318,19 @@ static jboolean nfcManager_doInitialize (JNIEnv* e, jobject o)
                 /////////////////////////////////////////////////////////////////////////////////
                 // Add extra configuration here (work-arounds, etc.)
 #if (NXP_EXTNS == TRUE)
+                    if(IsEseCeDisabled)
+                    {
+                        ALOGV("CE with ESE is disable, Hence reset the session");
+                        stat = android::ResetEseSession();
+                        if(stat == NFA_STATUS_OK)
+                        {
+                            SecureElement::getInstance().SecEle_Modeset(0x00);
+                            usleep(50*1000);
+                            SecureElement::getInstance().SecEle_Modeset(0x01);
+                        }
+                        IsEseCeDisabled = false;
+                    }
+
                     if(nfcFL.nfcNxpEse) {
                         if(nfcFL.eseFL._ESE_SVDD_SYNC || nfcFL.eseFL._ESE_JCOP_DWNLD_PROTECTION ||
                                 nfcFL.nfccFL._NFCC_SPI_FW_DOWNLOAD_SYNC ||
@@ -2300,8 +2345,6 @@ static jboolean nfcManager_doInitialize (JNIEnv* e, jobject o)
                         }
                     }
 #endif
-                    //Create transaction controller
-                    (void)transactionController::controller();
                     pendingScreenState = false;
                     {
                         SyncEventGuard guard (android::sNfaGetConfigEvent);
@@ -2854,7 +2897,7 @@ static void nfcManager_enableDiscovery (JNIEnv* e, jobject o, jint technologies_
         handle = SecureElement::getInstance().getEseHandleFromGenericId(SecureElement::UICC_ID);
 
 #if(NXP_EXTNS == TRUE)
-        if((getScreenState() == (NFA_SCREEN_STATE_ON_LOCKED)) || sProvisionMode)
+        if((getScreenState() == (NFA_SCREEN_STATE_ON_UNLOCKED)) || sProvisionMode)
         {
             ALOGV("%s: Enable p2pListening", __func__);
             PeerToPeer::getInstance().enableP2pListening (true);
@@ -3341,6 +3384,11 @@ if(nfcFL.eseFL._JCOP_WA_ENABLE) {
     if(nfcFL.eseFL._JCOP_WA_ENABLE) {
         NFA_HciW4eSETransaction_Complete(Wait);
     }
+    if(nfcFL.nfcNxpEse){
+        ALOGV("De-Initializing p61-jcop-lib library");
+        pJcopMgr->JcopDeInitialize();
+        pJcopMgr->deleteInstance();
+    }
     pn544InteropAbortNow ();
 
     RoutingManager::getInstance().onNfccShutdown();
@@ -5540,14 +5588,14 @@ static int nfcManager_doJcosDownload(JNIEnv* /* e */, jobject /* o */)
     if(nfcFL.nfcNxpEse) {
         ALOGV("%s: enter", __func__);
         bool stat = false;
+        int ret_val = -1;
+        NFCSTATUS ese_status = NFA_STATUS_FAILED;
+        p61_access_state_t p61_current_state = P61_STATE_INVALID;
+        eScreenState_t last_screen_state_request = get_lastScreenStateRequest();
         SecureElement &se = SecureElement::getInstance();
 
 
         if(nfcFL.eseFL._ESE_JCOP_DWNLD_PROTECTION) {
-            int ret_val = -1;
-            NFCSTATUS ese_status = NFA_STATUS_FAILED;
-            p61_access_state_t p61_current_state = P61_STATE_INVALID;
-            eScreenState_t last_screen_state_request = get_lastScreenStateRequest();
 
             if (sIsDisabling || !sIsNfaEnabled || nfcManager_checkNfcStateBusy())
             {
@@ -5592,12 +5640,14 @@ static int nfcManager_doJcosDownload(JNIEnv* /* e */, jobject /* o */)
                         return NFA_STATUS_FAILED;
                     }
                 }
+            }
+        }
                 if (sRfEnabled) {
                     // Stop RF Discovery if we were polling
                     startRfDiscovery (false);
                 }
                 DWPChannel_init(&Dwp);
-                status = JCDNLD_Init(&Dwp);
+                status = pJcopMgr->JCDnldInit(&Dwp);
                 if(status != NFA_STATUS_OK)
                 {
                     ALOGE("%s: JCDND initialization failed", __func__);
@@ -5606,7 +5656,7 @@ static int nfcManager_doJcosDownload(JNIEnv* /* e */, jobject /* o */)
                 {
                     ALOGE("%s: start JcopOs_Download", __func__);
                     se.mDownloadMode = JCOP_DOWNLOAD;
-                    status = JCDNLD_StartDownload();
+                    status = pJcopMgr->JCDnldStartDownload();
                 }
                 if(nfcFL.eseFL._ESE_JCOP_DWNLD_PROTECTION) {
                     ret_val = NFC_SetP61Status ((void *)&ese_status, JCP_DWP_DWNLD_COMPLETE);
@@ -5623,7 +5673,7 @@ static int nfcManager_doJcosDownload(JNIEnv* /* e */, jobject /* o */)
                         }
                     }
                 }
-                stat = JCDNLD_DeInit();
+                stat = pJcopMgr->JCDnldDeInit();
                 if(nfcFL.eseFL._ESE_JCOP_DWNLD_PROTECTION) {
                     pTransactionController->transactionEnd(TRANSACTION_REQUESTOR(jcosDownload));
                     if(pendingScreenState == true)
@@ -5633,8 +5683,6 @@ static int nfcManager_doJcosDownload(JNIEnv* /* e */, jobject /* o */)
                         nfcManager_doSetScreenState(NULL,NULL,last_screen_state_request);
                     }
                 }
-            }
-        }
         startRfDiscovery (true);
         se.mDownloadMode = NONE;
         ALOGV("%s: exit; status =0x%X", __func__,status);
@@ -5704,11 +5752,6 @@ static void nfcManager_doCommitRouting(JNIEnv* e, jobject o)
         startRfDiscovery(true);
 #if(NXP_EXTNS == TRUE && NXP_NFCC_HCE_F == TRUE)
     }
-#endif
-
-    RoutingManager::getInstance().commitRouting();
-    startRfDiscovery(true);
-#if(NXP_EXTNS == TRUE && NXP_NFCC_HCE_F == TRUE)
     pTransactionController->transactionEnd(TRANSACTION_REQUESTOR(commitRouting));
 #endif
     ALOGV("%s: exit", __func__);
@@ -5831,7 +5874,7 @@ static void nfcManager_doSetScreenState (JNIEnv* /* e */, jobject /* o */, jint
         return;
     }
 #endif
-
+    pendingScreenState = false;
     int prevScreenState = getScreenState();
     if(prevScreenState == state) {
         ALOGV("Screen state is not changed. ");
@@ -6005,13 +6048,13 @@ static void nfcManager_doSetScreenState (JNIEnv* /* e */, jobject /* o */, jint
 static void nfcManager_doSetScreenOrPowerState (JNIEnv* e, jobject o, jint state)
 {
     ALOGE("%s: Enter", __func__);
-    if (state <= NFA_SCREEN_STATE_ON_UNLOCKED ) // SCREEN_STATE
+    if ((state & NFA_SCREEN_STATE_MASK) <= NFA_SCREEN_STATE_ON_UNLOCKED ) // SCREEN_STATE
         nfcManager_doSetScreenState(e, o, state);
-    else if (state == VEN_POWER_STATE_ON) // POWER_ON NFC_OFF
+    else if ((state & NFA_SCREEN_STATE_MASK) == VEN_POWER_STATE_ON) // POWER_ON NFC_OFF
     {
         nfcManager_doSetNfcMode(e , o, NFC_MODE_OFF);
     }
-    else if (state == VEN_POWER_STATE_OFF) // POWER_OFF
+    else if ((state & NFA_SCREEN_STATE_MASK) == VEN_POWER_STATE_OFF) // POWER_OFF
     {
         if(sIsNfaEnabled)
         {
@@ -6041,7 +6084,6 @@ static void nfcManager_doSetScreenOrPowerState (JNIEnv* e, jobject o, jint state
 bool nfcManager_isRequestPending(void)
 {
     bool isPending = false;
-
     if((transaction_data.current_transcation_state != NFA_TRANS_ACTIVATED_EVT) &&
             ((pendingScreenState == true) || (get_last_request() != 0x00)))
     {
@@ -6441,12 +6483,7 @@ void *enableThread(void *arg)
     if(nfcFL.chipType != pn547C2) {
         set_AGC_process_state(false);
     }
-#if (NXP_EXTNS == TRUE)
-    if(!pTransactionController->transactionTerminate(TRANSACTION_REQUESTOR(exec_pending_req)))
-    {
-        ALOGE("%s: Transaction in progress. Can not reset", __func__);
-    }
-#endif
+
     bool screen_lock_flag = false;
     bool disable_discovery = false;
 
diff --git a/nci/jni/NativeNfcTag.cpp b/nci/jni/NativeNfcTag.cpp
index 4362e375..6e048396 100644
--- a/nci/jni/NativeNfcTag.cpp
+++ b/nci/jni/NativeNfcTag.cpp
@@ -1244,6 +1244,7 @@ static jint nativeNfcTag_doReconnect (JNIEnv*, jobject)
 
     uint8_t* uid;
     uint32_t uid_len;
+    tNFC_STATUS stat;
     ALOGV("%s: enter; handle=%x", __func__, handle);
     natTag.getTypeATagUID(&uid,&uid_len);
 
@@ -1283,74 +1284,84 @@ static jint nativeNfcTag_doReconnect (JNIEnv*, jobject)
                     uid_len > 0 && uid[0] == 0x08))
          )
     {
-        ALOGV("%s: reconnect for TypeB / TypeA random uid", __func__);
-        sReconnectNtfTimer.set(500, sReconnectTimerProc);
+        if(NFA_GetNCIVersion() != NCI_VERSION_2_0)
+		{
+            ALOGV("%s: reconnect for TypeB / TypeA random uid", __func__);
+            sReconnectNtfTimer.set(500, sReconnectTimerProc);
 
-        tNFC_STATUS stat = NFA_RegVSCback (true,nfaVSCNtfCallback); //Register CallBack for VS NTF
-        if(NFA_STATUS_OK != stat)
-        {
-            retCode = 0x01;
-            goto TheEnd;
-        }
+            tNFC_STATUS stat = NFA_RegVSCback (true,nfaVSCNtfCallback); //Register CallBack for VS NTF
+            if(NFA_STATUS_OK != stat)
+            {
+                retCode = 0x01;
+                goto TheEnd;
+            }
 
-        SyncEventGuard guard (sNfaVSCResponseEvent);
-        stat = NFA_SendVsCommand (0x11,0x00,NULL,nfaVSCCallback);
-        if(NFA_STATUS_OK == stat)
-        {
-            sIsReconnecting = true;
-            ALOGV("%s: reconnect for TypeB - wait for NFA VS command to finish", __func__);
-            sNfaVSCResponseEvent.wait(); //wait for NFA VS command to finish
-            ALOGV("%s: reconnect for TypeB - Got RSP", __func__);
-        }
+            SyncEventGuard guard (sNfaVSCResponseEvent);
+            stat = NFA_SendVsCommand (0x11,0x00,NULL,nfaVSCCallback);
+            if(NFA_STATUS_OK == stat)
+            {
+                sIsReconnecting = true;
+                ALOGV("%s: reconnect for TypeB - wait for NFA VS command to finish", __func__);
+                sNfaVSCResponseEvent.wait(); //wait for NFA VS command to finish
+                ALOGV("%s: reconnect for TypeB - Got RSP", __func__);
+            }
 
-        if(false == sVSCRsp)
-        {
-            retCode = 0x01;
-            sIsReconnecting = false;
-        }
-        else
-        {
+            if(false == sVSCRsp)
             {
-                ALOGV("%s: reconnect for TypeB - wait for NFA VS NTF to come", __func__);
-                SyncEventGuard guard (sNfaVSCNotificationEvent);
-                sNfaVSCNotificationEvent.wait(); //wait for NFA VS NTF to come
-                ALOGV("%s: reconnect for TypeB - GOT NFA VS NTF", __func__);
-                sReconnectNtfTimer.kill();
+                retCode = 0x01;
                 sIsReconnecting = false;
             }
-
-            if(false == sIsTagInField)
+            else
             {
-                ALOGV("%s: NxpNci: TAG OUT OF FIELD", __func__);
-                retCode = STATUS_CODE_TARGET_LOST;
-
-                SyncEventGuard g (gDeactivatedEvent);
+                {
+                    ALOGV("%s: reconnect for TypeB - wait for NFA VS NTF to come", __func__);
+                    SyncEventGuard guard (sNfaVSCNotificationEvent);
+                    sNfaVSCNotificationEvent.wait(); //wait for NFA VS NTF to come
+                    ALOGV("%s: reconnect for TypeB - GOT NFA VS NTF", __func__);
+                    sReconnectNtfTimer.kill();
+                    sIsReconnecting = false;
+                }
 
-                //Tag not present, deactivate the TAG.
-                stat = NFA_Deactivate (false);
-                if (stat == NFA_STATUS_OK)
+                if(false == sIsTagInField)
                 {
-                    gDeactivatedEvent.wait ();
+                    ALOGV("%s: NxpNci: TAG OUT OF FIELD", __func__);
+                    retCode = STATUS_CODE_TARGET_LOST;
+
+                    SyncEventGuard g (gDeactivatedEvent);
+
+                    //Tag not present, deactivate the TAG.
+                    stat = NFA_Deactivate (false);
+                    if (stat == NFA_STATUS_OK)
+                    {
+                        gDeactivatedEvent.wait ();
+                    }
+                    else
+                    {
+                        ALOGE("%s: deactivate failed; error=0x%X", __func__, stat);
+                    }
                 }
+
                 else
                 {
-                    ALOGE("%s: deactivate failed; error=0x%X", __func__, stat);
+                    retCode = 0x00;
                 }
             }
 
-            else
+            stat = NFA_RegVSCback (false,nfaVSCNtfCallback); //DeRegister CallBack for VS NTF
+            if(NFA_STATUS_OK != stat)
             {
-                retCode = 0x00;
+                retCode = 0x01;
             }
+            ALOGV("%s: reconnect for TypeB - return", __func__);
+        }else{
+                SyncEventGuard guard (sPresenceCheckEvent);
+                stat = NFA_RwPresenceCheck (NfcTag::getInstance().getPresenceCheckAlgorithm());
+                if (stat == NFA_STATUS_OK)
+                {
+                    sPresenceCheckEvent.wait ();
+                    retCode = sIsTagPresent ? NCI_STATUS_OK : NCI_STATUS_FAILED;
+                }
         }
-
-        stat = NFA_RegVSCback (false,nfaVSCNtfCallback); //DeRegister CallBack for VS NTF
-        if(NFA_STATUS_OK != stat)
-        {
-            retCode = 0x01;
-        }
-        ALOGV("%s: reconnect for TypeB - return", __func__);
-
         goto TheEnd;
     }
      // this is only supported for type 2 or 4 (ISO_DEP) tags
diff --git a/nci/jni/NativeSecureElement.cpp b/nci/jni/NativeSecureElement.cpp
index 93fd1a82..e41d0501 100644
--- a/nci/jni/NativeSecureElement.cpp
+++ b/nci/jni/NativeSecureElement.cpp
@@ -340,7 +340,8 @@ if(nfcFL.nfcNxpEse && stat)
 
     if(status != NFA_STATUS_OK)
     {
-        if(nfcFL.eseFL._WIRED_MODE_STANDBY && (se.mNfccPowerMode == 1)) {
+        if(nfcFL.eseFL._WIRED_MODE_STANDBY && (se.mNfccPowerMode == 1) &&
+        !(p61_current_state & (P61_STATE_SPI | P61_STATE_SPI_PRIO))) {
             se.setNfccPwrConfig(se.NFCC_DECIDES);
         }
         se.disconnectEE (secElemHandle);
diff --git a/nci/jni/NfcTag.cpp b/nci/jni/NfcTag.cpp
index 7d6ba77c..0aa16bbd 100644..100755
--- a/nci/jni/NfcTag.cpp
+++ b/nci/jni/NfcTag.cpp
@@ -424,6 +424,18 @@ void NfcTag::discoverTechnologies (tNFA_ACTIVATED& activationData)
     }
     else if(NFC_PROTOCOL_ISO_DEP == rfDetail.protocol)
     {
+        if((rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) ||
+           (rfDetail.rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A_ACTIVE))
+        {
+            uint8_t fwi = rfDetail.intf_param.intf_param.pa_iso.fwi;
+            if(fwi > 0 && fwi < 15)
+            {
+                // fwt = (((2^fwi) * 256 * 16 ) / (13.56 * 10^6)) * 1000msec
+                double fwt = (((2 << (fwi - 1)) * 256 * 16) / 13560000) * 1000;
+                ALOGD ("Setting the Xceive timeout = %f, fwi = %0#x", fwt, fwi);
+                setTransceiveTimeout(mTechList[mNumTechList], fwt);
+            }
+        }
         //type-4 tag uses technology ISO-DEP and technology A or B
         mTechList [mNumTechList] = TARGET_TYPE_ISO14443_4; //is TagTechnology.ISO_DEP by Java API
 #if(NXP_EXTNS == TRUE)
diff --git a/nci/jni/RoutingManager.cpp b/nci/jni/RoutingManager.cpp
index a6f8d188..c257d6be 100644
--- a/nci/jni/RoutingManager.cpp
+++ b/nci/jni/RoutingManager.cpp
@@ -787,9 +787,16 @@ void RoutingManager::setCeRouteStrictDisable(uint32_t state)
  ********************************************************************************/
 void RoutingManager::nfaEEConnect()
 {
-    if(NFA_STATUS_OK == NFA_EeConnect(EE_HCI_DEFAULT_HANDLE,
-                NFC_NFCEE_INTERFACE_HCI_ACCESS,
-                nfaEeCallback))
+    tNFA_STATUS nfaStat = NFA_STATUS_FAILED;
+    if(NFA_GetNCIVersion() != NCI_VERSION_2_0)
+    {
+      nfaStat = NFA_EeConnect(EE_HCI_DEFAULT_HANDLE, NFC_NFCEE_INTERFACE_HCI_ACCESS, nfaEeCallback);
+    }
+    else
+    {
+      nfaStat = NFA_EeDiscover(nfaEeCallback);
+    }
+    if(nfaStat == NFA_STATUS_OK)
     {
         SyncEventGuard g(gNfceeDiscCbEvent);
         ALOGV("%s, Sem wait for gNfceeDiscCbEvent %d", __FUNCTION__, gdisc_timeout);
@@ -2437,7 +2444,7 @@ void RoutingManager::nfaEeCallback (tNFA_EE_EVT event, tNFA_EE_CBACK_DATA* event
             se.mPwrLinkCtrlEvent.notifyOne();
         }
         break;
-
+#endif
     case NFA_EE_SET_TECH_CFG_EVT:
         {
             ALOGV("%s: NFA_EE_SET_TECH_CFG_EVT; status=0x%X", fn, eventData->status);
@@ -3058,7 +3065,6 @@ void *ee_removed_ntf_handler_thread(void *data)
             ALOGV("%s: power link command failed", __func__);
         }
     }
-#endif
     stat = NFA_EeModeSet(SecureElement::EE_HANDLE_0xF3, NFA_EE_MD_DEACTIVATE);
 
     if(stat == NFA_STATUS_OK)
@@ -3213,6 +3219,17 @@ bool RoutingManager::is_ee_recovery_ongoing()
     return recovery;
 }
 
+void RoutingManager::setEERecovery(bool value)
+{
+    static const char fn [] = "RoutingManager::setEERecovery";
+    if(!nfcFL.nfccFL._NFCEE_REMOVED_NTF_RECOVERY) {
+        ALOGV("%s : NFCEE_REMOVED_NTF_RECOVERY not avaialble.Returning",__func__);
+        return;
+    }
+    ALOGV("%s: value %x", __func__,value);
+    recovery = value;
+}
+
 /*******************************************************************************
 **
 ** Function:        getRouting
diff --git a/nci/jni/RoutingManager.h b/nci/jni/RoutingManager.h
index aef6f8fd..fc3e8dc8 100644
--- a/nci/jni/RoutingManager.h
+++ b/nci/jni/RoutingManager.h
@@ -185,7 +185,7 @@ public:
          uint8_t apduDataLen ,const uint8_t* apduMask, uint8_t apduMaskLen);
 
     bool removeApduRouting(uint8_t apduDataLen, const uint8_t* apduData);
-
+    void setEERecovery(bool value);
     void cleanRouting();
     bool removeAidRouting(const uint8_t* aid, uint8_t aidLen);
     bool commitRouting();
diff --git a/nci/jni/SecureElement.cpp b/nci/jni/SecureElement.cpp
index 49d68d04..8898b6dc 100644..100755
--- a/nci/jni/SecureElement.cpp
+++ b/nci/jni/SecureElement.cpp
@@ -131,6 +131,9 @@ namespace android
 #if(NXP_EXTNS == TRUE)
 #define NFC_NUM_INTERFACE_MAP 3
 #define NFC_SWP_RD_NUM_INTERFACE_MAP 1
+#define STATIC_PIPE_0x19 0x19 //PN54X Gemalto's proprietary static pipe
+#define STATIC_PIPE_0x70 0x70 //Broadcom's proprietary static pipe
+uint8_t  SecureElement::mStaticPipeProp;
 
 static const tNCI_DISCOVER_MAPS nfc_interface_mapping_default[NFC_NUM_INTERFACE_MAP] =
 {
@@ -347,6 +350,7 @@ bool SecureElement::initialize (nfc_jni_native_data* native)
         mDestinationGate = num;
     ALOGV("%s: Default destination gate: 0x%X", fn, mDestinationGate);
 
+    mStaticPipeProp = nfcFL.nfccFL._GEMALTO_SE_SUPPORT ? STATIC_PIPE_0x19 : STATIC_PIPE_0x70;
     // active SE, if not set active all SEs, use the first one.
     if (GetNumValue("ACTIVE_SE", &num, sizeof(num)))
     {
@@ -474,13 +478,9 @@ bool SecureElement::initialize (nfc_jni_native_data* native)
     for (size_t xx = 0; xx < MAX_NUM_EE; xx++)
     {
 
-#ifdef GEMALTO_SE_SUPPORT
-        if ((mEeInfo[xx].ee_handle != EE_HANDLE_0xF4 ) )
-#else
-            if (((mEeInfo[xx].ee_interface[0] == NCI_NFCEE_INTERFACE_HCI_ACCESS)
-                    &&(mEeInfo[xx].ee_status == NFC_NFCEE_STATUS_ACTIVE)) || (NFA_GetNCIVersion() == NCI_VERSION_2_0))
-#endif
-
+        if((!nfcFL.nfccFL._GEMALTO_SE_SUPPORT && mEeInfo[xx].ee_handle != EE_HANDLE_0xF4)
+           || (nfcFL.nfccFL._GEMALTO_SE_SUPPORT && (((mEeInfo[xx].ee_interface[0] == NCI_NFCEE_INTERFACE_HCI_ACCESS)
+                 && (mEeInfo[xx].ee_status == NFC_NFCEE_STATUS_ACTIVE)) || (NFA_GetNCIVersion() == NCI_VERSION_2_0))))
             {
                 ALOGV("%s: Found HCI network, try hci register", fn);
 
@@ -525,13 +525,10 @@ bool SecureElement::updateEEStatus ()
     // If the controller has an HCI Network, register for that
     for (size_t xx = 0; xx < mActualNumEe; xx++)
     {
-#ifdef GEMALTO_SE_SUPPORT
-        if ((mEeInfo[xx].ee_handle != EE_HANDLE_0xF4 ) )
-#else
-            if (((mEeInfo[xx].ee_interface[0] == NCI_NFCEE_INTERFACE_HCI_ACCESS))
-              || (NFA_GetNCIVersion() == NCI_VERSION_2_0))
-#endif
-            {
+        if((!nfcFL.nfccFL._GEMALTO_SE_SUPPORT && (mEeInfo[xx].ee_handle != EE_HANDLE_0xF4 ))
+            || (nfcFL.nfccFL._GEMALTO_SE_SUPPORT && (((mEeInfo[xx].ee_interface[0] == NCI_NFCEE_INTERFACE_HCI_ACCESS))
+            || (NFA_GetNCIVersion() == NCI_VERSION_2_0))))
+         {
                 ALOGV("%s: Found HCI network, try hci register", __func__);
 
                 SyncEventGuard guard (mHciRegisterEvent);
@@ -1459,28 +1456,28 @@ bool SecureElement::connectEE ()
         uint8_t host;
         if(mActiveEeHandle == EE_HANDLE_0xF3)
         {
-            host = (mNewPipeId == STATIC_PIPE_0x70) ? 0xC0 : 0x03;
+            host = (mNewPipeId == mStaticPipeProp) ? 0xC0 : 0x03;
         }
         else
         {
             host = (mNewPipeId == STATIC_PIPE_UICC) ? 0x02 : 0x03;
         }
 #else
-        uint8_t host = (mNewPipeId == STATIC_PIPE_0x70) ? 0x02 : 0x03;
+        uint8_t host = (mNewPipeId == mStaticPipeProp) ? 0x02 : 0x03;
 #endif
         //TODO according ETSI12 APDU Gate
 #if(NXP_EXTNS == TRUE)
         uint8_t gate;
         if(mActiveEeHandle == EE_HANDLE_0xF3)
         {
-            gate = (mNewPipeId == STATIC_PIPE_0x70) ? 0xF0 : 0xF1;
+            gate = (mNewPipeId == mStaticPipeProp) ? 0xF0 : 0xF1;
         }
         else
         {
             gate = (mNewPipeId == STATIC_PIPE_UICC) ? 0x30 : 0x31;
         }
 #else
-        uint8_t gate = (mNewPipeId == STATIC_PIPE_0x70) ? 0xF0 : 0xF1;
+        uint8_t gate = (mNewPipeId == mStaticPipeProp) ? 0xF0 : 0xF1;
 #endif
 #if(NXP_EXTNS == TRUE)
         ALOGV("%s: Using host id : 0x%X,gate id : 0x%X,pipe id : 0x%X", __func__,host,gate, mNewPipeId);
@@ -1784,7 +1781,7 @@ bool SecureElement::transceive (uint8_t* xmitBuffer, int32_t xmitBufferSize, uin
             }
         }
 #endif
-        if ((mNewPipeId == STATIC_PIPE_0x70) || (mNewPipeId == STATIC_PIPE_0x71))
+        if ((mNewPipeId == mStaticPipeProp) || (mNewPipeId == STATIC_PIPE_0x71))
 #if(NXP_EXTNS == TRUE)
         {
             if (nfcFL.nfccFL._NFCEE_REMOVED_NTF_RECOVERY) {
@@ -2345,8 +2342,8 @@ bool SecureElement::getSeVerInfo(int seIndex, char * verInfo, int verInfoSz, uin
     strlcpy(verInfo, "Version info not available", verInfoSz-2);
 
     uint8_t pipe = (mEeInfo[seIndex].ee_handle == EE_HANDLE_0xF3) ? 0x70 : 0x71;
-    uint8_t host = (pipe == STATIC_PIPE_0x70) ? 0x02 : 0x03;
-    uint8_t gate = (pipe == STATIC_PIPE_0x70) ? 0xF0 : 0xF1;
+    uint8_t host = (pipe == mStaticPipeProp) ? 0x02 : 0x03;
+    uint8_t gate = (pipe == mStaticPipeProp) ? 0xF0 : 0xF1;
 
     tNFA_STATUS nfaStat = NFA_HciAddStaticPipe(mNfaHciHandle, host, gate, pipe);
     if (nfaStat != NFA_STATUS_OK)
@@ -2541,7 +2538,7 @@ void SecureElement::nfaHciCallback (tNFA_HCI_EVT event, tNFA_HCI_EVT_DATA* event
             sSecElem.mAtrStatus = eventData->registry.status;
             sSecElem.mGetRegisterEvent.notifyOne();
         }
-        else if (eventData->registry.data_len >= 19 && ((eventData->registry.pipe == STATIC_PIPE_0x70) || (eventData->registry.pipe == STATIC_PIPE_0x71)))
+        else if (eventData->registry.data_len >= 19 && ((eventData->registry.pipe == mStaticPipeProp) || (eventData->registry.pipe == STATIC_PIPE_0x71)))
         {
             SyncEventGuard guard (sSecElem.mVerInfoEvent);
             // Oberthur OS version is in bytes 16,17, and 18
@@ -2590,7 +2587,7 @@ void SecureElement::nfaHciCallback (tNFA_HCI_EVT event, tNFA_HCI_EVT_DATA* event
         }
 #if(NXP_EXTNS == TRUE)
         else if (((eventData->rcvd_evt.evt_code == NFA_HCI_ABORT) || (eventData->rcvd_evt.last_SentEvtType == EVT_ABORT))
-                &&(eventData->rcvd_evt.pipe == STATIC_PIPE_0x70))
+                &&(eventData->rcvd_evt.pipe == mStaticPipeProp))
         {
             ALOGV("%s: NFA_HCI_EVENT_RCVD_EVT: NFA_HCI_ABORT; status:0x%X, pipe:0x%X, len:%d", fn,\
                 eventData->rcvd_evt.status, eventData->rcvd_evt.pipe, eventData->rcvd_evt.evt_len);
@@ -2611,7 +2608,7 @@ void SecureElement::nfaHciCallback (tNFA_HCI_EVT event, tNFA_HCI_EVT_DATA* event
             }
         }
 #endif
-        else if ((eventData->rcvd_evt.pipe == STATIC_PIPE_0x70) || (eventData->rcvd_evt.pipe == STATIC_PIPE_0x71))
+        else if ((eventData->rcvd_evt.pipe == mStaticPipeProp) || (eventData->rcvd_evt.pipe == STATIC_PIPE_0x71))
         {
             ALOGV("%s: NFA_HCI_EVENT_RCVD_EVT; data from static pipe", fn);
 #if (NXP_EXTNS == TRUE)
@@ -2733,6 +2730,24 @@ void SecureElement::nfaHciCallback (tNFA_HCI_EVT event, tNFA_HCI_EVT_DATA* event
             sSecElem.mNfceeInitCbEvent.notifyOne();
             break;
         }
+    case NFA_HCI_EE_RECOVERY_EVT:
+    {
+        tNFA_HCI_EE_RECOVERY_EVT &ee_recovery = eventData->ee_recovery;
+        ALOGV("%s: NFA_HCI_EE_RECOVERY_EVT; status=0x%X", fn, ee_recovery.status);
+        if(ee_recovery.status == NFA_HCI_EE_RECOVERY_STARTED)
+            RoutingManager::getInstance().setEERecovery(true);
+        else if(ee_recovery.status == NFA_HCI_EE_RECOVERY_COMPLETED)
+        {
+            ALOGV("%s: NFA_HCI_EE_RECOVERY_EVT; recovery completed status=0x%X", fn, ee_recovery.status);
+            RoutingManager::getInstance().setEERecovery(false);
+            if(active_ese_reset_control & TRANS_WIRED_ONGOING)
+            {
+                SyncEventGuard guard(sSecElem.mTransceiveEvent);
+                sSecElem.mTransceiveEvent.notifyOne();
+            }
+        }
+        break;
+    }
     case NFA_HCI_ADD_STATIC_PIPE_EVT:
     {
         ALOGV("%s: NFA_HCI_ADD_STATIC_PIPE_EVT; status=0x%X", fn, eventData->admin_rsp_rcvd.status);
@@ -2833,17 +2848,18 @@ tNFA_HANDLE SecureElement::getDefaultEeHandle ()
             continue; //skip all the EE's that are ignored
         ALOGV("%s: - mEeInfo[xx].ee_handle = 0x%02x, mEeInfo[xx].ee_status = 0x%02x", fn,mEeInfo[xx].ee_handle, mEeInfo[xx].ee_status);
 
+              if((nfcFL.nfccFL._GEMALTO_SE_SUPPORT && (mEeInfo[xx].ee_interface[0] != NCI_NFCEE_INTERFACE_HCI_ACCESS)))
+              {
+                  return (mEeInfo[xx].ee_handle);
+              }
+              else if((!nfcFL.nfccFL._GEMALTO_SE_SUPPORT && ((mEeInfo[xx].ee_handle == EE_HANDLE_0xF3
+                  || mEeInfo[xx].ee_handle == SecureElement::getInstance().EE_HANDLE_0xF4
+                  || (mEeInfo[xx].ee_handle == EE_HANDLE_0xF8 && nfcFL.nfccFL._NFCC_DYNAMIC_DUAL_UICC))
+                  && (mEeInfo[xx].ee_status != NFC_NFCEE_STATUS_INACTIVE))))
+              {
+                  return (mEeInfo[xx].ee_handle);
+              }
 
-#ifndef GEMALTO_SE_SUPPORT
-
-            if((mEeInfo[xx].ee_interface[0] != NCI_NFCEE_INTERFACE_HCI_ACCESS)
-#else
-            if(((mEeInfo[xx].ee_handle == EE_HANDLE_0xF3 || mEeInfo[xx].ee_handle == SecureElement::getInstance().EE_HANDLE_0xF4
-                || (mEeInfo[xx].ee_handle == EE_HANDLE_0xF8 && nfcFL.nfccFL._NXP_NFCC_DYNAMIC_DUAL_UICC))
-                && (mEeInfo[xx].ee_status != NFC_NFCEE_STATUS_INACTIVE))
-#endif
-                )
-            return (mEeInfo[xx].ee_handle);
     }
     return NFA_HANDLE_INVALID;
 }
@@ -2870,21 +2886,20 @@ tNFA_HANDLE SecureElement::getActiveEeHandle (tNFA_HANDLE handle)
     for (uint8_t xx = 0; xx < mActualNumEe; xx++)
     {
         if ( (mActiveSeOverride != ACTIVE_SE_USE_ANY) && (overrideEeHandle != mEeInfo[xx].ee_handle))
-        ALOGE("%s: - mEeInfo[xx].ee_handle = 0x%02x, mEeInfo[xx].ee_status = 0x%02x", fn,mEeInfo[xx].ee_handle, mEeInfo[xx].ee_status);
-
+             ALOGE("%s: - mEeInfo[xx].ee_handle = 0x%02x, mEeInfo[xx].ee_status = 0x%02x", fn,mEeInfo[xx].ee_handle, mEeInfo[xx].ee_status);
 
-#ifndef GEMALTO_SE_SUPPORT
-
-            if((mEeInfo[xx].ee_interface[0] != NCI_NFCEE_INTERFACE_HCI_ACCESS)
-#else
-
-            if((mEeInfo[xx].ee_handle == EE_HANDLE_0xF3 || mEeInfo[xx].ee_handle == SecureElement::getInstance().EE_HANDLE_0xF4
-                || (mEeInfo[xx].ee_handle == EE_HANDLE_0xF8 && nfcFL.nfccFL._NXP_NFCC_DYNAMIC_DUAL_UICC))
+        if(nfcFL.nfccFL._GEMALTO_SE_SUPPORT && (mEeInfo[xx].ee_interface[0] != NCI_NFCEE_INTERFACE_HCI_ACCESS)
+             && (mEeInfo[xx].ee_status != NFC_NFCEE_STATUS_INACTIVE) && (mEeInfo[xx].ee_handle == handle))
+         {
+             return (mEeInfo[xx].ee_handle);
+         }
+         else if (!nfcFL.nfccFL._GEMALTO_SE_SUPPORT && (mEeInfo[xx].ee_handle == EE_HANDLE_0xF3 || mEeInfo[xx].ee_handle == SecureElement::getInstance().EE_HANDLE_0xF4
+              || (mEeInfo[xx].ee_handle == EE_HANDLE_0xF8 && nfcFL.nfccFL._NFCC_DYNAMIC_DUAL_UICC))
+              && (mEeInfo[xx].ee_status != NFC_NFCEE_STATUS_INACTIVE) && (mEeInfo[xx].ee_handle == handle))
+         {
+             return (mEeInfo[xx].ee_handle);
+         }
 
-#endif
-            &&
-            (mEeInfo[xx].ee_status != NFC_NFCEE_STATUS_INACTIVE)&& (mEeInfo[xx].ee_handle == handle))
-            return (mEeInfo[xx].ee_handle);
     }
     return NFA_HANDLE_INVALID;
 }
@@ -3217,15 +3232,6 @@ bool SecureElement::SecEle_Modeset(uint8_t type)
             retval = true;
         }
 #endif
-        /*Mode set on wait for ntf*/
-        if(type)
-        {
-            SyncEventGuard guard (SecureElement::getInstance().mEeSetModeEvent);
-            if(SecureElement::getInstance().mEeSetModeEvent.wait(500) == false)
-            {
-                ALOGE("%s: timeout waiting for setModeNtf", __func__);
-            }
-        }
     }
     else
 #endif
@@ -4028,6 +4034,10 @@ TheEnd:
     return decoded_length;
 }
 #if(NXP_EXTNS == TRUE)
+void cleanupStack(void* p)
+{
+    return;
+}
 /*******************************************************************************
 **
 ** Function:       spiEventHandlerThread
@@ -4039,6 +4049,10 @@ TheEnd:
 *******************************************************************************/
 void *spiEventHandlerThread(void *arg)
 {
+    void (*pCleanupRoutine)(void* ptr) = cleanupStack;
+    __pthread_cleanup_t  __cleanup;
+    SecureElement &se = SecureElement::getInstance();
+
     if(!nfcFL.nfcNxpEse) {
         ALOGV("%s: nfcNxpEse not available. Returning", __func__);
         return NULL;
@@ -4050,7 +4064,7 @@ void *spiEventHandlerThread(void *arg)
     }
     (void)arg;
     uint16_t usEvent = 0, usEvtLen = 0;
-
+    tNFC_STATUS stat;
 
     NFCSTATUS ese_status = NFA_STATUS_FAILED;
 
@@ -4079,6 +4093,8 @@ void *spiEventHandlerThread(void *arg)
          {
              ALOGV("%s: SPI PRIO End Signal\n", __func__);
              hold_the_transceive = false;
+             if(!se.mIsWiredModeOpen)
+                spiDwpSyncState = STATE_DWP_CLOSE;
              setSPIState(false);
              SyncEventGuard guard (sSPIPrioSessionEndEvent);
              sSPIPrioSessionEndEvent.notifyOne ();
@@ -4092,6 +4108,8 @@ void *spiEventHandlerThread(void *arg)
         {
             ALOGV("%s: SPI End Signal\n", __func__);
             hold_the_transceive = false;
+            if(!se.mIsWiredModeOpen)
+                spiDwpSyncState = STATE_DWP_CLOSE;
             setSPIState(false);
         }
 
@@ -4103,6 +4121,10 @@ void *spiEventHandlerThread(void *arg)
                         (usEvent & P61_STATE_SPI))
                 {
                     nfaVSC_ForceDwpOnOff(true);
+                    if(nfcFL.eseFL._WIRED_MODE_STANDBY) {
+                    if(android::nfcManager_getNfcState() != NFC_OFF)
+                        NFC_RelForceDwpOnOffWait((void*)&stat);
+                    }
                 }
                 else if((usEvent & P61_STATE_SPI_PRIO_END) ||
                         (usEvent & P61_STATE_SPI_END))
@@ -4126,6 +4148,10 @@ void *spiEventHandlerThread(void *arg)
                         (usEvent & P61_STATE_SPI)))
         {
             nfaVSC_ForceDwpOnOff(true);
+            if(nfcFL.eseFL._WIRED_MODE_STANDBY) {
+            if(android::nfcManager_getNfcState() != NFC_OFF)
+                NFC_RelForceDwpOnOffWait((void*)&stat);
+            }
         }
         else if(nfcFL.eseFL._ESE_DWP_SPI_SYNC_ENABLE &&
                 ((usEvent & P61_STATE_SPI_PRIO_END) ||
@@ -4167,6 +4193,9 @@ void *spiEventHandlerThread(void *arg)
         }
     }
     ALOGV("%s: exit", __func__);
+    /*Explicit cleanup to avoid any issue due to pthread datastructure corruption*/
+    __pthread_cleanup_push(&__cleanup, pCleanupRoutine, NULL);
+    __pthread_cleanup_pop(&__cleanup, 0);
     pthread_exit(NULL);
     return NULL;
 }
@@ -4221,6 +4250,10 @@ void releaseSPIEvtHandlerThread()
     /* Notifying the signal handler thread to exit if it is waiting */
     SyncEventGuard guard(sSPISignalHandlerEvent);
     sSPISignalHandlerEvent.notifyOne ();
+    {
+        SyncEventGuard guard(SecureElement::getInstance().mModeSetNtf);
+        SecureElement::getInstance().mModeSetNtf.notifyOne();
+    }
 }
 /*******************************************************************************
 **
@@ -4379,6 +4412,7 @@ static void nfaVSC_ForceDwpOnOff(bool type)
             /*If DWP session is closed*/
             (void)SecureElement::getInstance().setNfccPwrConfig(SecureElement::getInstance().NFCC_DECIDES);
         }
+
         if(spiDwpSyncState & STATE_DWP_CLOSE)
         {
             stat = NFA_HciSendEvent (NFA_HANDLE_GROUP_HCI, 0x19, EVT_END_OF_APDU_TRANSFER,
@@ -4722,9 +4756,14 @@ tNFA_STATUS SecureElement::SecElem_EeModeSet(uint16_t handle, uint8_t mode)
             sSecElem.mResetEvent.wait();
         }
     }
+    if((dual_mode_current_state & SPI_ON) && (handle == EE_HANDLE_0xF3) &&
+        (mode == NFA_EE_MD_DEACTIVATE))
+        return NFA_STATUS_OK;
+
     SyncEventGuard guard (sSecElem.mEeSetModeEvent);
     stat =  NFA_EeModeSet(handle, mode);
-    if(stat == NFA_STATUS_OK && !android::nfcManager_isNfcDisabling())
+    if(stat == NFA_STATUS_OK && !android::nfcManager_isNfcDisabling() &&
+       (android::nfcManager_getNfcState() != NFC_OFF))
     {
         sSecElem.mEeSetModeEvent.wait ();
     }
diff --git a/nci/jni/SecureElement.h b/nci/jni/SecureElement.h
index 479862c3..5043726b 100644
--- a/nci/jni/SecureElement.h
+++ b/nci/jni/SecureElement.h
@@ -817,13 +817,9 @@ public:
 #endif
 
 private:
+    static uint8_t mStaticPipeProp;
     static const unsigned int MAX_RESPONSE_SIZE = 0x8800;//1024; //34K
     enum RouteSelection {NoRoute, DefaultRoute, SecElemRoute};
-#ifndef GEMATO_SE_SUPPORT
-    static const uint8_t STATIC_PIPE_0x70 = 0x19; //PN54X Gemalto's proprietary static pipe
-#else
-    static const uint8_t STATIC_PIPE_0x70 = 0x70; //Broadcom's proprietary static pipe
-#endif
     static const uint8_t STATIC_PIPE_0x71 = 0x71; //Broadcom's proprietary static pipe
     static const uint8_t EVT_SEND_DATA = 0x10;    //see specification ETSI TS 102 622 v9.0.0 (Host Controller Interface); section 9.3.3.3
 #if(NXP_EXTNS == TRUE)
diff --git a/nci/jni/TransactionController.cpp b/nci/jni/TransactionController.cpp
index 7250523d..990ab592 100644..100755
--- a/nci/jni/TransactionController.cpp
+++ b/nci/jni/TransactionController.cpp
@@ -61,7 +61,24 @@ void transactionController::lastRequestResume(void)
     pthread_attr_destroy(&attr);
     pTransactionDetail->current_transcation_state = NFA_TRANS_DM_RF_TRANS_END;
 }
+/*******************************************************************************
+ **
+ ** Function:       transactionHandlePendingCb
+ **
+ ** Description:    This is a callback function registered against
+ **                 pendingTransHandleTimer timer. This timer handler
+ **                 triggers enable_thread for handling pending transactions
+ **
+ ** Returns:       None
+ **
+ *******************************************************************************/
 
+extern "C" void transactionController::transactionHandlePendingCb(union sigval)
+{
+    ALOGD("Inside %s", __FUNCTION__);
+
+    pInstance->lastRequestResume();
+}
 /*******************************************************************************
  **
  ** Function:       transactionAbortTimerCb
@@ -76,7 +93,8 @@ extern "C" void transactionController::transactionAbortTimerCb(union sigval)
 {
     ALOGD("Inside %s", __FUNCTION__);
 
-    pInstance->lastRequestResume();
+    pInstance->transactionTerminate(TRANSACTION_REQUESTOR(exec_pending_req));
+
 }
 
 /*******************************************************************************
@@ -97,6 +115,7 @@ transactionController::transactionController(void)
 
     pTransactionDetail = android::nfcManager_transactionDetail();
     abortTimer = new IntervalTimer();
+    pendingTransHandleTimer = new IntervalTimer();
     requestor = NULL;
 }
 /*******************************************************************************
@@ -139,6 +158,11 @@ bool transactionController::transactionAttempt(const char* transactionRequestor,
     sem_getvalue(&barrier, &semVal);
     ALOGD ("%s: Transaction attempted : %s when barrier is: %d", __FUNCTION__, transactionRequestor, semVal);
 
+    if(pendingTransHandleTimer->isRunning())
+    {
+        ALOGD ("%s: Transaction denied due to pending transaction: %s ", __FUNCTION__, transactionRequestor);
+        return false;
+    }
     //Block wait on barrier
     if(sem_timedwait(&barrier, &timeout) != 0)
     {
@@ -177,6 +201,12 @@ bool transactionController::transactionAttempt(const char* transactionRequestor)
     sem_getvalue(&barrier, &semVal);
     ALOGD ("%s: Transaction attempted : %s when barrier is: %d", __FUNCTION__, transactionRequestor, semVal);
 
+    if(pendingTransHandleTimer->isRunning())
+    {
+        ALOGD ("%s: Transaction denied due to pending transaction: %s ", __FUNCTION__, transactionRequestor);
+        return false;
+    }
+
     if(sem_trywait(&barrier) == 0)
     {
         pTransactionDetail->trans_in_progress = true;
@@ -210,13 +240,14 @@ void transactionController::transactionEnd(const char* transactionRequestor)
 
     if(requestor == transactionRequestor)
     {
+        /*If any abort timer is running for this transaction then stop it*/
+        if(abortTimer != NULL && abortTimer->isRunning())
+        {
+            ALOGD ("%s: Transaction control timer killed", __FUNCTION__);
+            killAbortTimer();
+        }
         pTransactionDetail->trans_in_progress = false;
-
-        sem_getvalue(&barrier, &val);
-
-        if(!val)
-            sem_post(&barrier);
-
+        requestor = NULL;
         ALOGD ("%s: Transaction ended : %s ", __FUNCTION__, transactionRequestor);
 
         /*
@@ -224,9 +255,12 @@ void transactionController::transactionEnd(const char* transactionRequestor)
         **/
         if(android::nfcManager_isRequestPending())
         {
-            abortTimer->set(5, transactionAbortTimerCb);
+            pendingTransHandleTimer->set(1, transactionHandlePendingCb);
         }
 
+        sem_getvalue(&barrier, &val);
+        if(!val)
+            sem_post(&barrier);
     }
 }
 /*******************************************************************************
@@ -249,12 +283,17 @@ bool  transactionController::transactionTerminate(const char* transactionRequest
        (requestor == transactionRequestor || !strcmp(transactionRequestor,"exec_pending_req")))
     {
         pTransactionDetail->trans_in_progress = false;
-        abortTimer->kill();
+        requestor = NULL;
+        killAbortTimer();
+
+        if(android::nfcManager_isRequestPending())
+        {
+            pendingTransHandleTimer->set(1, transactionHandlePendingCb);
+        }
 
         sem_getvalue(&barrier, &val);
         if(!val)
             sem_post(&barrier);
-
         ALOGD ("%s: Transaction terminated : %s ", __FUNCTION__, transactionRequestor);
         return true;
     }
@@ -308,6 +347,10 @@ transactionController* transactionController::controller(void)
         pInstance->requestor = NULL;
 
         pInstance->abortTimer->kill();
+        pInstance->pendingTransHandleTimer->kill();
+
+        pInstance->abortTimer = new IntervalTimer();
+        pInstance->pendingTransHandleTimer = new IntervalTimer();
 
         sem_destroy(&pInstance->barrier);
 
@@ -332,7 +375,10 @@ void transactionController::killAbortTimer(void)
     ALOGD ("%s: transaction controller abort timer killed", __FUNCTION__);
 
     if(transactionInProgress())
+    {
         abortTimer->kill();
+        abortTimer = new IntervalTimer();
+    }
 }
 /*******************************************************************************
  **
@@ -349,4 +395,18 @@ void transactionController::setAbortTimer(unsigned int msec)
 
     if(transactionInProgress())
         abortTimer->set(msec, transactionAbortTimerCb);
+}
+
+/*******************************************************************************
+ **
+ ** Function:       getCurTransactionRequestor
+ **
+ ** Description:   This function returns current active requestor
+ **
+ ** Returns:       active requestor
+ **
+ *******************************************************************************/
+const char * transactionController::getCurTransactionRequestor()
+{
+    return requestor;
 }
\ No newline at end of file
diff --git a/nci/jni/TransactionController.h b/nci/jni/TransactionController.h
index d3965dd9..a0df7a1e 100644..100755
--- a/nci/jni/TransactionController.h
+++ b/nci/jni/TransactionController.h
@@ -1,96 +1,99 @@
-/******************************************************************************

- *

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

- *

- ******************************************************************************/

-#pragma once

-#include <semaphore.h>

-#include <NfcJniUtil.h>

-extern "C"

-{

-    #include "nfa_api.h"

-}

-#define TRANSACTION_REQUESTOR(name) #name

-#define TRANSACTION_ATTEMPT_FOR_SECONDS(seconds)  (seconds)

-#define pTransactionController      (transactionController::getInstance())

-

-

-

-/* Transaction Events in order */

-typedef enum transcation_events

-{

-    NFA_TRANS_DEFAULT = 0x00,

-    NFA_TRANS_ACTIVATED_EVT,

-    NFA_TRANS_EE_ACTION_EVT,

-    NFA_TRANS_DM_RF_FIELD_EVT,

-    NFA_TRANS_DM_RF_FIELD_EVT_ON,

-    NFA_TRANS_DM_RF_TRANS_START,

-    NFA_TRANS_DM_RF_FIELD_EVT_OFF,

-    NFA_TRANS_DM_RF_TRANS_PROGRESS,

-    NFA_TRANS_DM_RF_TRANS_END,

-    NFA_TRANS_MIFARE_ACT_EVT,

-    NFA_TRANS_CE_ACTIVATED = 0x18,

-    NFA_TRANS_CE_DEACTIVATED = 0x19,

-}eTranscation_events_t;

-/*Structure to store  discovery parameters*/

-typedef struct discovery_Parameters

-{

-    int technologies_mask;

-    bool enable_lptd;

-    bool reader_mode;

-    bool enable_p2p;

-    bool restart;

-}discovery_Parameters_t;

-/*Structure to store transcation result*/

-typedef struct Transcation_Check

-{

-    bool trans_in_progress;

-    char last_request;

-    struct nfc_jni_native_data *transaction_nat;

-    eScreenState_t last_screen_state_request;

-    eTranscation_events_t current_transcation_state;

-    discovery_Parameters_t discovery_params;

-#if(NXP_EXTNS == TRUE)

-#if(NXP_NFCC_HCE_F == TRUE)

-    int t3thandle;

-    bool isInstallRequest;

-#endif

-#endif

-} Transcation_Check_t;

-

-class transactionController

-{

-    private:

-        static transactionController* pInstance;    //Reference to controller

-        sem_t barrier;                             //barrier: Guard for controlling access to NFCC when profile switch happening

-        IntervalTimer* abortTimer;                //abortTimer: Used for aborting a stuck transaction

-        Transcation_Check_t* pTransactionDetail; //transactionDetail: holds last transaction detail

-        const char* requestor;                  //requestor: Identifier of transaction trigger

-

-        transactionController(void);           //Constructor

-        bool transactionLiveLockable(const char* transactionRequestor);

-    public:

-        void lastRequestResume(void);

-        bool transactionAttempt(const char* transactionRequestor, unsigned int timeoutInMsec);

-        bool transactionAttempt(const char* transactionRequestor);

-        bool transactionTerminate(const char* transactionRequestor);

-        void transactionEnd(const char* transactionRequestor);

-        bool transactionInProgress(void);

-        void killAbortTimer(void);

-        void setAbortTimer(unsigned int msec);

-        static void  transactionAbortTimerCb(union sigval);

-        static transactionController* controller(void);

-        static transactionController* getInstance(void);

-};

+/******************************************************************************
+ *
+ *  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.
+ *
+ ******************************************************************************/
+#pragma once
+#include <semaphore.h>
+#include <NfcJniUtil.h>
+extern "C"
+{
+    #include "nfa_api.h"
+}
+#define TRANSACTION_REQUESTOR(name) #name
+#define TRANSACTION_ATTEMPT_FOR_SECONDS(seconds)  (seconds)
+#define pTransactionController      (transactionController::getInstance())
+
+
+
+/* Transaction Events in order */
+typedef enum transcation_events
+{
+    NFA_TRANS_DEFAULT = 0x00,
+    NFA_TRANS_ACTIVATED_EVT,
+    NFA_TRANS_EE_ACTION_EVT,
+    NFA_TRANS_DM_RF_FIELD_EVT,
+    NFA_TRANS_DM_RF_FIELD_EVT_ON,
+    NFA_TRANS_DM_RF_TRANS_START,
+    NFA_TRANS_DM_RF_FIELD_EVT_OFF,
+    NFA_TRANS_DM_RF_TRANS_PROGRESS,
+    NFA_TRANS_DM_RF_TRANS_END,
+    NFA_TRANS_MIFARE_ACT_EVT,
+    NFA_TRANS_CE_ACTIVATED = 0x18,
+    NFA_TRANS_CE_DEACTIVATED = 0x19,
+}eTranscation_events_t;
+/*Structure to store  discovery parameters*/
+typedef struct discovery_Parameters
+{
+    int technologies_mask;
+    bool enable_lptd;
+    bool reader_mode;
+    bool enable_p2p;
+    bool restart;
+}discovery_Parameters_t;
+/*Structure to store transcation result*/
+typedef struct Transcation_Check
+{
+    bool trans_in_progress;
+    char last_request;
+    struct nfc_jni_native_data *transaction_nat;
+    eScreenState_t last_screen_state_request;
+    eTranscation_events_t current_transcation_state;
+    discovery_Parameters_t discovery_params;
+#if(NXP_EXTNS == TRUE)
+#if(NXP_NFCC_HCE_F == TRUE)
+    int t3thandle;
+    bool isInstallRequest;
+#endif
+#endif
+} Transcation_Check_t;
+
+class transactionController
+{
+    private:
+        static transactionController* pInstance;    //Reference to controller
+        sem_t barrier;                             //barrier: Guard for controlling access to NFCC when profile switch happening
+        IntervalTimer* abortTimer;                //abortTimer: Used for aborting a stuck transaction
+        IntervalTimer* pendingTransHandleTimer;  //pendingTransHandleTimer: Used to schedule pending transaction handler thread
+        Transcation_Check_t* pTransactionDetail; //transactionDetail: holds last transaction detail
+        const char* requestor;                  //requestor: Identifier of transaction trigger
+
+        transactionController(void);           //Constructor
+        bool transactionLiveLockable(const char* transactionRequestor);
+    public:
+        void lastRequestResume(void);
+        bool transactionAttempt(const char* transactionRequestor, unsigned int timeoutInMsec);
+        bool transactionAttempt(const char* transactionRequestor);
+        bool transactionTerminate(const char* transactionRequestor);
+        void transactionEnd(const char* transactionRequestor);
+        bool transactionInProgress(void);
+        void killAbortTimer(void);
+        void setAbortTimer(unsigned int msec);
+        static void  transactionAbortTimerCb(union sigval);
+        static void transactionHandlePendingCb(union sigval);
+        static transactionController* controller(void);
+        static transactionController* getInstance(void);
+        const char * getCurTransactionRequestor();
+};
diff --git a/src/com/android/nfc/NfcService.java b/src/com/android/nfc/NfcService.java
index 92ebd44d..49fa0dff 100644
--- a/src/com/android/nfc/NfcService.java
+++ b/src/com/android/nfc/NfcService.java
@@ -463,6 +463,7 @@ public class NfcService implements DeviceHostListener {
     // as SE access is not granted for non-owner users.
     HashSet<String> mSePackages = new HashSet<String>();
     int mScreenState;
+    int mChipVer;
     boolean mIsTaskBoot = false;
     boolean mInProvisionMode; // whether we're in setup wizard and enabled NFC provisioning
     boolean mIsNdefPushEnabled;
@@ -1294,7 +1295,6 @@ public class NfcService implements DeviceHostListener {
                         mNxpPrefs.getInt(PREF_SECURE_ELEMENT_ID, SECURE_ELEMENT_ID_DEFAULT);
 
                 if (seList != null) {
-
                     if (secureElementId != ALL_SE_ID_TYPE/* SECURE_ELEMENT_ALL */) {
                         mDeviceHost.doDeselectSecureElement(UICC_ID_TYPE);
                         mDeviceHost.doDeselectSecureElement(UICC2_ID_TYPE);
@@ -1456,9 +1456,9 @@ public class NfcService implements DeviceHostListener {
             } finally {
                 watchDog.cancel();
             }
-            int chipVer = mDeviceHost.getChipVer();
-            if((chipVer == PN80T_ID) || (chipVer == PN553_ID)) {
-                ALL_SE_ID_TYPE |= UICC2_ID_TYPE;
+            mChipVer = mDeviceHost.getChipVer();
+            if(mChipVer < PN553_ID) {
+                ALL_SE_ID_TYPE &= ~UICC2_ID_TYPE;
             }
             checkSecureElementConfuration();
 
@@ -2213,7 +2213,9 @@ public class NfcService implements DeviceHostListener {
         @Override
         public int deselectSecureElement(String pkg) throws RemoteException {
             NfcService.this.enforceNfcSeAdminPerm(pkg);
-
+            if(mChipVer < PN553_ID) {
+                mSelectedSeId &= ~UICC2_ID_TYPE;
+            }
             // Check if NFC is enabled
             if (!isNfcEnabled()) {
                 return ErrorCodes.ERROR_NOT_INITIALIZED;
@@ -2253,6 +2255,9 @@ public class NfcService implements DeviceHostListener {
 
         @Override
         public void storeSePreference(int seId) {
+            if(mChipVer < PN553_ID) {
+                seId &= ~UICC2_ID_TYPE;
+            }
             NfcPermissions.enforceAdminPermissions(mContext);
             /* store */
             Log.d(TAG, "SE Preference stored");
@@ -2265,6 +2270,10 @@ public class NfcService implements DeviceHostListener {
         public int selectSecureElement(String pkg,int seId) throws RemoteException {
             NfcService.this.enforceNfcSeAdminPerm(pkg);
 
+            if(mChipVer < PN553_ID) {
+                seId &= ~UICC2_ID_TYPE;
+            }
+
             // Check if NFC is enabled
             if (!isNfcEnabled()) {
                 return ErrorCodes.ERROR_NOT_INITIALIZED;
@@ -5267,17 +5276,14 @@ public class NfcService implements DeviceHostListener {
                 case MSG_APPLY_SCREEN_STATE:
 
                     mScreenState = (int)msg.obj;
-
-                    if(mScreenState == ScreenStateHelper.SCREEN_STATE_ON_UNLOCKED)
-                    {
-                      applyRouting(false);
-                    }
                     int screen_state_mask = (mNfcUnlockManager.isLockscreenPollingEnabled()) ?
                                 (ScreenStateHelper.SCREEN_POLLING_TAG_MASK | mScreenState) : mScreenState;
+                    mDeviceHost.doSetScreenOrPowerState(screen_state_mask);
 
-                   if(mNfcUnlockManager.isLockscreenPollingEnabled())
+                    if(mScreenState == ScreenStateHelper.SCREEN_STATE_ON_UNLOCKED
+                       || mNfcUnlockManager.isLockscreenPollingEnabled()) {
                         applyRouting(false);
-                   mDeviceHost.doSetScreenOrPowerState(screen_state_mask);
+                    }
 
 /*                    mRoutingWakeLock.acquire();
                     try {
diff --git a/src/com/android/nfc/cardemulation/HostNfcFEmulationManager.java b/src/com/android/nfc/cardemulation/HostNfcFEmulationManager.java
index d79a1ec8..398f1bd9 100644
--- a/src/com/android/nfc/cardemulation/HostNfcFEmulationManager.java
+++ b/src/com/android/nfc/cardemulation/HostNfcFEmulationManager.java
@@ -310,7 +310,7 @@ public class HostNfcFEmulationManager {
                     return;
                 }
                 */
-                if (data.length == 0) {
+                if (data == null || data.length == 0) {
                     Log.e(TAG, "Empty response packet");
                     sendEmptyData();
                     return;