| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * 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. |
| */ |
| /****************************************************************************** |
| * |
| * The original Work has been changed by NXP Semiconductors. |
| * |
| * 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. |
| * |
| ******************************************************************************/ |
| #include <semaphore.h> |
| #include <errno.h> |
| #include "OverrideLog.h" |
| #include "NfcJniUtil.h" |
| #include "NfcAdaptation.h" |
| #include "SyncEvent.h" |
| #include "PeerToPeer.h" |
| #include "SecureElement.h" |
| #include "RoutingManager.h" |
| #include "NfcTag.h" |
| #include "config.h" |
| #include "PowerSwitch.h" |
| #include "JavaClassConstants.h" |
| #include "Pn544Interop.h" |
| #include <ScopedLocalRef.h> |
| #include <ScopedUtfChars.h> |
| #include <sys/time.h> |
| #include "HciRFParams.h" |
| #include <pthread.h> |
| #include <ScopedPrimitiveArray.h> |
| #if((NFC_NXP_ESE == TRUE)&&(NXP_EXTNS == TRUE)) |
| #include <signal.h> |
| #include <sys/types.h> |
| #endif |
| #include "DwpChannel.h" |
| extern "C" |
| { |
| #include "nfa_api.h" |
| #include "nfa_p2p_api.h" |
| #include "rw_api.h" |
| #include "nfa_ee_api.h" |
| #include "nfc_brcm_defs.h" |
| #include "ce_api.h" |
| #include "phNxpExtns.h" |
| #include "phNxpConfig.h" |
| |
| #if (NFC_NXP_ESE == TRUE) |
| #include "JcDnld.h" |
| #include "IChannel.h" |
| #endif |
| } |
| |
| #define SAK_VALUE_AT 17 |
| |
| #if(NXP_EXTNS == TRUE) |
| #define UICC_HANDLE 0x402 |
| #define ESE_HANDLE 0x4C0 |
| #define RETRY_COUNT 10 |
| #define default_count 3 |
| extern bool recovery; |
| static INT32 gNfcInitTimeout; |
| static INT32 gdisc_timeout; |
| INT32 gSeDiscoverycount = 0; |
| INT32 gActualSeCount = 0; |
| #if(NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE) |
| UINT8 sSelectedUicc = 0; |
| #endif |
| SyncEvent gNfceeDiscCbEvent; |
| extern int gUICCVirtualWiredProtectMask; |
| extern int gEseVirtualWiredProtectMask; |
| #endif |
| |
| extern const UINT8 nfca_version_string []; |
| extern const UINT8 nfa_version_string []; |
| |
| #if (NFC_NXP_ESE == TRUE && ((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551))) |
| extern Rdr_req_ntf_info_t swp_rdr_req_ntf_info; |
| #endif |
| |
| extern tNFA_DM_DISC_FREQ_CFG* p_nfa_dm_rf_disc_freq_cfg; //defined in stack |
| bool sHCEEnabled = true; // whether HCE is enabled |
| extern bool gReaderNotificationflag; |
| |
| namespace android |
| { |
| extern bool gIsTagDeactivating; |
| extern bool gIsSelectingRfInterface; |
| extern void nativeNfcTag_doTransceiveStatus (tNFA_STATUS status, uint8_t * buf, uint32_t buflen); |
| extern void nativeNfcTag_notifyRfTimeout (); |
| extern void nativeNfcTag_doConnectStatus (jboolean is_connect_ok); |
| extern void nativeNfcTag_doDeactivateStatus (int status); |
| extern void nativeNfcTag_doWriteStatus (jboolean is_write_ok); |
| extern void nativeNfcTag_doCheckNdefResult (tNFA_STATUS status, uint32_t max_size, uint32_t current_size, uint8_t flags); |
| extern void nativeNfcTag_doMakeReadonlyResult (tNFA_STATUS status); |
| extern void nativeNfcTag_doPresenceCheckResult (tNFA_STATUS status); |
| extern void nativeNfcTag_formatStatus (bool is_ok); |
| extern void nativeNfcTag_resetPresenceCheck (); |
| extern void nativeNfcTag_doReadCompleted (tNFA_STATUS status); |
| extern void nativeNfcTag_setRfInterface (tNFA_INTF_TYPE rfInterface); |
| extern void nativeNfcTag_abortWaits (); |
| extern void doDwpChannel_ForceExit(); |
| extern void nativeLlcpConnectionlessSocket_abortWait (); |
| extern tNFA_STATUS EmvCo_dosetPoll(jboolean enable); |
| extern void nativeNfcTag_registerNdefTypeHandler (); |
| extern void nativeLlcpConnectionlessSocket_receiveData (uint8_t* data, uint32_t len, uint32_t remote_sap); |
| extern tNFA_STATUS SetScreenState(int state); |
| extern tNFA_STATUS SendAutonomousMode(int state , uint8_t num); |
| #if(NXP_EXTNS == TRUE) |
| #if((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551)) |
| extern tNFA_STATUS SendAGCDebugCommand(); |
| #endif |
| #endif |
| //Factory Test Code --start |
| extern tNFA_STATUS Nxp_SelfTest(uint8_t testcase, uint8_t* param); |
| extern void SetCbStatus(tNFA_STATUS status); |
| extern tNFA_STATUS GetCbStatus(void); |
| static void nfaNxpSelfTestNtfTimerCb (union sigval); |
| //Factory Test Code --end |
| extern bool getReconnectState(void); |
| extern tNFA_STATUS SetVenConfigValue(jint nfcMode); |
| extern tNFA_STATUS SetHfoConfigValue(void); |
| extern tNFA_STATUS SetUICC_SWPBitRate(bool); |
| extern tNFA_STATUS GetSwpStausValue(void); |
| #if((NXP_EXTNS == TRUE) && (NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE)) |
| extern tNFA_STATUS Set_EERegisterValue(UINT16 RegAddr, uint8_t bitVal); |
| extern tNFA_STATUS NxpNfc_Write_Cmd_Common(uint8_t retlen, uint8_t* buffer); |
| #endif |
| extern void acquireRfInterfaceMutexLock(); |
| extern void releaseRfInterfaceMutexLock(); |
| #if(NXP_EXTNS == TRUE && NFC_NXP_NON_STD_CARD == TRUE) |
| extern void nativeNfcTag_cacheNonNciCardDetection(); |
| extern void nativeNfcTag_handleNonNciCardDetection(tNFA_CONN_EVT_DATA* eventData); |
| extern void nativeNfcTag_handleNonNciMultiCardDetection(UINT8 connEvent, tNFA_CONN_EVT_DATA* eventData); |
| extern uint8_t checkTagNtf; |
| extern uint8_t checkCmdSent; |
| #endif |
| } |
| |
| |
| /***************************************************************************** |
| ** |
| ** public variables and functions |
| ** |
| *****************************************************************************/ |
| bool gActivated = false; |
| SyncEvent gDeactivatedEvent; |
| |
| namespace android |
| { |
| int gGeneralTransceiveTimeout = DEFAULT_GENERAL_TRANS_TIMEOUT; |
| int gGeneralPowershutDown = 0; |
| jmethodID gCachedNfcManagerNotifyNdefMessageListeners; |
| jmethodID gCachedNfcManagerNotifyTransactionListeners; |
| jmethodID gCachedNfcManagerNotifyConnectivityListeners; |
| jmethodID gCachedNfcManagerNotifyEmvcoMultiCardDetectedListeners; |
| jmethodID gCachedNfcManagerNotifyLlcpLinkActivation; |
| jmethodID gCachedNfcManagerNotifyLlcpLinkDeactivated; |
| jmethodID gCachedNfcManagerNotifyLlcpFirstPacketReceived; |
| jmethodID gCachedNfcManagerNotifySeFieldActivated; |
| jmethodID gCachedNfcManagerNotifySeFieldDeactivated; |
| jmethodID gCachedNfcManagerNotifySeListenActivated; |
| jmethodID gCachedNfcManagerNotifySeListenDeactivated; |
| jmethodID gCachedNfcManagerNotifyHostEmuActivated; |
| jmethodID gCachedNfcManagerNotifyHostEmuData; |
| jmethodID gCachedNfcManagerNotifyHostEmuDeactivated; |
| jmethodID gCachedNfcManagerNotifyRfFieldActivated; |
| jmethodID gCachedNfcManagerNotifyRfFieldDeactivated; |
| jmethodID gCachedNfcManagerNotifySWPReaderRequested; |
| jmethodID gCachedNfcManagerNotifySWPReaderRequestedFail; |
| jmethodID gCachedNfcManagerNotifySWPReaderActivated; |
| jmethodID gCachedNfcManagerNotifyAidRoutingTableFull; |
| #if(NFC_NXP_ESE == TRUE && ((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551))) |
| jmethodID gCachedNfcManagerNotifyETSIReaderModeStartConfig; |
| jmethodID gCachedNfcManagerNotifyETSIReaderModeStopConfig; |
| jmethodID gCachedNfcManagerNotifyETSIReaderModeSwpTimeout; |
| #endif |
| #if((NXP_EXTNS == TRUE) && (NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE)) |
| jmethodID gCachedNfcManagerNotifyUiccStatusEvent; |
| #endif |
| const char* gNativeP2pDeviceClassName = "com/android/nfc/dhimpl/NativeP2pDevice"; |
| const char* gNativeLlcpServiceSocketClassName = "com/android/nfc/dhimpl/NativeLlcpServiceSocket"; |
| const char* gNativeLlcpConnectionlessSocketClassName = "com/android/nfc/dhimpl/NativeLlcpConnectionlessSocket"; |
| const char* gNativeLlcpSocketClassName = "com/android/nfc/dhimpl/NativeLlcpSocket"; |
| const char* gNativeNfcTagClassName = "com/android/nfc/dhimpl/NativeNfcTag"; |
| const char* gNativeNfcManagerClassName = "com/android/nfc/dhimpl/NativeNfcManager"; |
| const char* gNativeNfcSecureElementClassName = "com/android/nfc/dhimpl/NativeNfcSecureElement"; |
| const char* gNativeNfcAlaClassName = "com/android/nfc/dhimpl/NativeNfcAla"; |
| void doStartupConfig (); |
| void startStopPolling (bool isStartPolling); |
| void startRfDiscovery (bool isStart); |
| void setUiccIdleTimeout (bool enable); |
| void config_swp_reader_mode(bool mode); |
| bool isDiscoveryStarted (); |
| } |
| |
| |
| /***************************************************************************** |
| ** |
| ** private variables and functions |
| ** |
| *****************************************************************************/ |
| namespace android |
| { |
| static jint sLastError = ERROR_BUFFER_TOO_SMALL; |
| static jmethodID sCachedNfcManagerNotifySeApduReceived; |
| static jmethodID sCachedNfcManagerNotifySeMifareAccess; |
| static jmethodID sCachedNfcManagerNotifySeEmvCardRemoval; |
| static jmethodID sCachedNfcManagerNotifyTargetDeselected; |
| static SyncEvent sNfaEnableEvent; //event for NFA_Enable() |
| static SyncEvent sNfaDisableEvent; //event for NFA_Disable() |
| SyncEvent sNfaEnableDisablePollingEvent; //event for NFA_EnablePolling(), NFA_DisablePolling() |
| SyncEvent sNfaSetConfigEvent; // event for Set_Config.... |
| SyncEvent sNfaGetConfigEvent; // event for Get_Config.... |
| #if(NXP_EXTNS == TRUE) |
| SyncEvent sNfaGetRoutingEvent; // event for Get_Routing.... |
| static bool sProvisionMode = false; |
| #if((NXP_EXTNS == TRUE) && (NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE)) |
| SyncEvent sNfceeHciCbEnableEvent; |
| SyncEvent sNfceeHciCbDisableEvent; |
| #endif |
| #endif |
| |
| static bool sIsNfaEnabled = false; |
| static bool sDiscoveryEnabled = false; //is polling or listening |
| static bool sPollingEnabled = false; //is polling for tag? |
| static bool sIsDisabling = false; |
| static bool sRfEnabled = false; // whether RF discovery is enabled |
| static bool sSeRfActive = false; // whether RF with SE is likely active |
| static bool sReaderModeEnabled = false; // whether we're only reading tags, not allowing P2p/card emu |
| static bool sP2pEnabled = false; |
| static bool sP2pActive = false; // whether p2p was last active |
| static bool sAbortConnlessWait = false; |
| static jint sLfT3tMax = 0; |
| |
| static UINT8 sIsSecElemSelected = 0; //has NFC service selected a sec elem |
| static UINT8 sIsSecElemDetected = 0; //has NFC service deselected a sec elem |
| static bool sDiscCmdwhleNfcOff = false; |
| #if (NXP_EXTNS == TRUE) |
| static bool gsNfaPartialEnabled = false; |
| #endif |
| |
| #define CONFIG_UPDATE_TECH_MASK (1 << 1) |
| #define TRANSACTION_TIMER_VALUE 50 |
| #define DEFAULT_TECH_MASK (NFA_TECHNOLOGY_MASK_A \ |
| | NFA_TECHNOLOGY_MASK_B \ |
| | NFA_TECHNOLOGY_MASK_F \ |
| | NFA_TECHNOLOGY_MASK_ISO15693 \ |
| | NFA_TECHNOLOGY_MASK_B_PRIME \ |
| | NFA_TECHNOLOGY_MASK_A_ACTIVE \ |
| | NFA_TECHNOLOGY_MASK_F_ACTIVE \ |
| | NFA_TECHNOLOGY_MASK_KOVIO) |
| #define DEFAULT_DISCOVERY_DURATION 500 |
| #define READER_MODE_DISCOVERY_DURATION 200 |
| #if(NXP_EXTNS == TRUE) |
| #define DUAL_UICC_FEATURE_NOT_AVAILABLE 0xED; |
| #define STATUS_UNKNOWN_ERROR 0xEF; |
| #endif |
| #if((NXP_EXTNS == TRUE) && (NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE)) |
| enum |
| { |
| UICC_CONFIGURED, |
| UICC_NOT_CONFIGURED |
| }; |
| typedef enum dual_uicc_error_states{ |
| DUAL_UICC_ERROR_NFCC_BUSY = 0x02, |
| DUAL_UICC_ERROR_SELECT_FAILED, |
| DUAL_UICC_ERROR_NFC_TURNING_OFF, |
| DUAL_UICC_ERROR_INVALID_SLOT, |
| DUAL_UICC_ERROR_STATUS_UNKNOWN |
| }dual_uicc_error_state_t; |
| #endif |
| |
| static int screenstate = 0; |
| static bool pendingScreenState = false; |
| static void nfcManager_doSetScreenState(JNIEnv* e, jobject o, jint state); |
| static void nfcManager_doSetScreenOrPowerState (JNIEnv* e, jobject o, jint state); |
| static void StoreScreenState(int state); |
| int getScreenState(); |
| #if(NFC_NXP_ESE == TRUE && ((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551))) |
| bool isp2pActivated(); |
| #endif |
| static void nfaConnectionCallback (UINT8 event, tNFA_CONN_EVT_DATA *eventData); |
| static void nfaDeviceManagementCallback (UINT8 event, tNFA_DM_CBACK_DATA *eventData); |
| static bool isPeerToPeer (tNFA_ACTIVATED& activated); |
| static bool isListenMode(tNFA_ACTIVATED& activated); |
| static void setListenMode(); |
| static void enableDisableLptd (bool enable); |
| static tNFA_STATUS stopPolling_rfDiscoveryDisabled(); |
| static tNFA_STATUS startPolling_rfDiscoveryDisabled(tNFA_TECHNOLOGY_MASK tech_mask); |
| |
| static int nfcManager_getChipVer(JNIEnv* e, jobject o); |
| static jbyteArray nfcManager_getFwFileName(JNIEnv* e, jobject o); |
| static int nfcManager_getNfcInitTimeout(JNIEnv* e, jobject o); |
| static int nfcManager_doJcosDownload(JNIEnv* e, jobject o); |
| static void nfcManager_doCommitRouting(JNIEnv* e, jobject o); |
| #if(NXP_EXTNS == TRUE) |
| static void nfcManager_doSetNfcMode (JNIEnv *e, jobject o, jint nfcMode); |
| #endif |
| static void nfcManager_doSetVenConfigValue (JNIEnv *e, jobject o, jint venconfig); |
| static jint nfcManager_getSecureElementTechList(JNIEnv* e, jobject o); |
| static void nfcManager_setSecureElementListenTechMask(JNIEnv *e, jobject o, jint tech_mask); |
| static void notifyPollingEventwhileNfcOff(); |
| |
| #if (NFC_NXP_ESE == TRUE) |
| void DWPChannel_init(IChannel_t *DWP); |
| IChannel_t Dwp; |
| #endif |
| static UINT16 sCurrentConfigLen; |
| static UINT8 sConfig[256]; |
| #if((NXP_EXTNS == TRUE) && (NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE)) |
| typedef struct |
| { |
| UINT8 sUicc1Cntx[256]; |
| UINT16 sUicc1CntxLen; |
| UINT8 sUicc2Cntx[256]; |
| UINT16 sUicc2CntxLen; |
| UINT8 sUicc1TechCapblty[12]; |
| UINT8 sUicc2TechCapblty[12]; |
| UINT8 uiccActivStat = 0; |
| UINT8 uiccConfigStat = 0; |
| }dual_uicc_info_t; |
| dual_uicc_info_t dualUiccInfo; |
| typedef enum |
| { |
| UICC_CONNECTED_0, |
| UICC_CONNECTED_1, |
| UICC_CONNECTED_2 |
| }uicc_enumeration_t; |
| #endif |
| static UINT8 sLongGuardTime[] = { 0x00, 0x20 }; |
| static UINT8 sDefaultGuardTime[] = { 0x00, 0x11 }; |
| #if(NXP_EXTNS == TRUE) |
| /*Proprietary cmd sent to HAL to send reader mode flag |
| * Last byte of sProprietaryCmdBuf contains ReaderMode flag */ |
| #define PROPRIETARY_CMD_FELICA_READER_MODE 0xFE |
| static UINT8 sProprietaryCmdBuf[]={0xFE,0xFE,0xFE,0x00}; |
| UINT8 felicaReader_Disc_id; |
| static void NxpResponsePropCmd_Cb(UINT8 event, UINT16 param_len, UINT8 *p_param); |
| static int sTechMask = 0; // Copy of Tech Mask used in doEnableReaderMode |
| static SyncEvent sRespCbEvent; |
| bool rfActivation = false; |
| static void* pollT3TThread(void *arg); |
| static bool switchP2PToT3TRead(UINT8 disc_id); |
| typedef enum felicaReaderMode_state |
| { |
| STATE_IDLE = 0x00, |
| STATE_NFCDEP_ACTIVATED_NFCDEP_INTF, |
| STATE_DEACTIVATED_TO_SLEEP, |
| STATE_FRAMERF_INTF_SELECTED, |
| }eFelicaReaderModeState_t; |
| static eFelicaReaderModeState_t gFelicaReaderState=STATE_IDLE; |
| |
| UINT16 sRoutingBuffLen; |
| static UINT8 sRoutingBuff[MAX_GET_ROUTING_BUFFER_SIZE]; |
| static UINT8 sNfceeConfigured; |
| static UINT8 sCheckNfceeFlag; |
| void checkforNfceeBuffer(); |
| void checkforNfceeConfig(); |
| tNFA_STATUS getUICC_RF_Param_SetSWPBitRate(); |
| //self test start |
| static IntervalTimer nfaNxpSelfTestNtfTimer; // notification timer for swp self test |
| #if(NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE) |
| static IntervalTimer uiccEventTimer; // notification timer for uicc select |
| static void notifyUiccEvent (union sigval); |
| #endif |
| static SyncEvent sNfaNxpNtfEvent; |
| static void nfaNxpSelfTestNtfTimerCb (union sigval); |
| |
| static void nfcManager_doSetEEPROM(JNIEnv* e, jobject o, jbyteArray val); |
| static jint nfcManager_getFwVersion(JNIEnv* e, jobject o); |
| static jint nfcManager_SWPSelfTest(JNIEnv* e, jobject o, jint ch); |
| static void nfcManager_doPrbsOff(JNIEnv* e, jobject o); |
| static void nfcManager_doPrbsOn(JNIEnv* e, jobject o, jint prbs, jint hw_prbs, jint tech, jint rate); |
| static void nfcManager_Enablep2p(JNIEnv* e, jobject o, jboolean p2pFlag); |
| //self test end |
| static void nfcManager_setProvisionMode(JNIEnv* e, jobject o, jboolean provisionMode); |
| static bool nfcManager_doPartialInitialize (); |
| static bool nfcManager_doPartialDeInitialize(); |
| #if(NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE) |
| static int nfcManager_doSelectUicc(JNIEnv* e, jobject o, jint uiccSlot); |
| static int nfcManager_doGetSelectedUicc(JNIEnv* e, jobject o); |
| static void getUiccContext(); |
| static int nfcManager_staticDualUicc_Precondition(int uiccSlot); |
| #endif |
| #endif |
| |
| |
| static int nfcManager_doGetSeInterface(JNIEnv* e, jobject o, jint type); |
| |
| #if(NXP_EXTNS == TRUE && NFC_NXP_NON_STD_CARD == TRUE) |
| extern bool scoreGenericNtf; |
| #endif |
| #if(NXP_EXTNS == TRUE) |
| tNFC_FW_VERSION get_fw_version(); |
| bool isNfcInitializationDone(); |
| static UINT16 discDuration = 0x00; |
| UINT16 getrfDiscoveryDuration(); |
| #if((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551)) |
| typedef struct enableAGC_debug |
| { |
| long enableAGC; // config param |
| bool AGCdebugstarted;// flag to indicate agc ongoing |
| bool AGCdebugrunning;//flag to indicate agc running or stopped. |
| }enableAGC_debug_t; |
| static enableAGC_debug_t menableAGC_debug_t; |
| void *enableAGCThread(void *arg); |
| static void nfcManagerEnableAGCDebug(UINT8 connEvent); |
| void set_AGC_process_state(bool state); |
| bool get_AGC_process_state(); |
| #endif |
| #endif |
| |
| void checkforTranscation(UINT8 connEvent ,void * eventData); |
| void sig_handler(int signo); |
| void cleanup_timer(); |
| /* 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 screen state */ |
| typedef enum screen_state |
| { |
| NFA_SCREEN_STATE_DEFAULT = 0x00, |
| NFA_SCREEN_STATE_OFF, |
| NFA_SCREEN_STATE_LOCKED, |
| NFA_SCREEN_STATE_UNLOCKED |
| }eScreenState_t; |
| |
| typedef enum se_client |
| { |
| DEFAULT = 0x00, |
| LDR_SRVCE, |
| JCOP_SRVCE, |
| LTSM_SRVCE |
| }seClient_t; |
| |
| /*Structure to store discovery parameters*/ |
| typedef struct discovery_Parameters |
| { |
| int technologies_mask; |
| bool enable_lptd; |
| bool reader_mode; |
| bool enable_host_routing; |
| bool enable_p2p; |
| bool restart; |
| }discovery_Parameters_t; |
| |
| /*Structure to store transcation result*/ |
| typedef struct Transcation_Check |
| { |
| bool trans_in_progress; |
| char last_request; |
| eScreenState_t last_screen_state_request; |
| eTranscation_events_t current_transcation_state; |
| struct nfc_jni_native_data *transaction_nat; |
| discovery_Parameters_t discovery_params; |
| }Transcation_Check_t; |
| |
| extern tNFA_INTF_TYPE sCurrentRfInterface; |
| static Transcation_Check_t transaction_data; |
| static void nfcManager_enableDiscovery (JNIEnv* e, jobject o, jint technologies_mask, |
| jboolean enable_lptd, jboolean reader_mode, jboolean enable_host_routing, jboolean enable_p2p, |
| jboolean restart); |
| void nfcManager_disableDiscovery (JNIEnv*, jobject); |
| static bool get_transcation_stat(void); |
| static char get_last_request(void); |
| static void set_last_request(char status, struct nfc_jni_native_data *nat); |
| static eScreenState_t get_lastScreenStateRequest(void); |
| static void set_lastScreenStateRequest(eScreenState_t status); |
| void *enableThread(void *arg); |
| static IntervalTimer scleanupTimerProc_transaction; |
| static bool gIsDtaEnabled=false; |
| |
| #if(NXP_EXTNS == TRUE) |
| /***P2P-Prio Logic for Multiprotocol***/ |
| static UINT8 multiprotocol_flag = 1; |
| static UINT8 multiprotocol_detected = 0; |
| void *p2p_prio_logic_multiprotocol(void *arg); |
| static IntervalTimer multiprotocol_timer; |
| pthread_t multiprotocol_thread; |
| void reconfigure_poll_cb(union sigval); |
| void clear_multiprotocol(); |
| void multiprotocol_clear_flag(union sigval); |
| void set_transcation_stat(bool result); |
| #endif |
| |
| ///////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////// |
| |
| /******************************************************************************* |
| ** |
| ** Function: getNative |
| ** |
| ** Description: Get native data |
| ** |
| ** Returns: Native data structure. |
| ** |
| *******************************************************************************/ |
| nfc_jni_native_data *getNative (JNIEnv* e, jobject o) |
| { |
| static struct nfc_jni_native_data *sCachedNat = NULL; |
| if (e) |
| { |
| sCachedNat = nfc_jni_get_nat(e, o); |
| } |
| return sCachedNat; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: handleRfDiscoveryEvent |
| ** |
| ** Description: Handle RF-discovery events from the stack. |
| ** discoveredDevice: Discovered device. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void handleRfDiscoveryEvent (tNFC_RESULT_DEVT* discoveredDevice) |
| { |
| int thread_ret; |
| if(discoveredDevice->more == NCI_DISCOVER_NTF_MORE) |
| { |
| |
| //there is more discovery notification coming |
| NfcTag::getInstance ().mNumDiscNtf++; |
| return; |
| } |
| NfcTag::getInstance ().mNumDiscNtf++; |
| ALOGD("Total Notifications - %d ", NfcTag::getInstance ().mNumDiscNtf); |
| bool isP2p = NfcTag::getInstance ().isP2pDiscovered (); |
| if (!sReaderModeEnabled && isP2p) |
| { |
| //select the peer that supports P2P |
| ALOGD(" select P2P"); |
| #if(NXP_EXTNS == TRUE) |
| if(multiprotocol_detected == 1) |
| { |
| multiprotocol_timer.kill(); |
| } |
| #endif |
| NfcTag::getInstance ().selectP2p(); |
| } |
| #if(NXP_EXTNS == TRUE) |
| else if(!sReaderModeEnabled && multiprotocol_flag) |
| { |
| NfcTag::getInstance ().mNumDiscNtf = 0x00; |
| multiprotocol_flag = 0; |
| multiprotocol_detected = 1; |
| ALOGD("Prio_Logic_multiprotocol Logic"); |
| thread_ret = pthread_create(&multiprotocol_thread, NULL, p2p_prio_logic_multiprotocol, NULL); |
| if(thread_ret != 0) |
| ALOGD("unable to create the thread"); |
| ALOGD("Prio_Logic_multiprotocol start timer"); |
| multiprotocol_timer.set (300, reconfigure_poll_cb); |
| } |
| #endif |
| else |
| { |
| if (sReaderModeEnabled) |
| { |
| NfcTag::getInstance ().mNumDiscNtf = 0; |
| } |
| else |
| { |
| NfcTag::getInstance ().mNumDiscNtf--; |
| } |
| //select the first of multiple tags that is discovered |
| NfcTag::getInstance ().selectFirstTag(); |
| multiprotocol_flag = 1; |
| } |
| } |
| |
| #if(NXP_EXTNS == TRUE) |
| void *p2p_prio_logic_multiprotocol(void *arg) |
| { |
| tNFA_STATUS status = NFA_STATUS_FAILED; |
| tNFA_TECHNOLOGY_MASK tech_mask = 0; |
| |
| ALOGD ("%s ", __FUNCTION__); |
| |
| if (sRfEnabled) { |
| // Stop RF discovery to reconfigure |
| startRfDiscovery(false); |
| } |
| |
| { |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| status = NFA_DisablePolling (); |
| if (status == NFA_STATUS_OK) |
| { |
| sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_DISABLED_EVT |
| }else |
| ALOGE ("%s: Failed to disable polling; error=0x%X", __FUNCTION__, status); |
| } |
| |
| if(multiprotocol_detected) |
| { |
| ALOGD ("Enable Polling for TYPE F"); |
| tech_mask = NFA_TECHNOLOGY_MASK_F; |
| } |
| else |
| { |
| ALOGD ("Enable Polling for ALL"); |
| unsigned long num = 0; |
| if (GetNumValue(NAME_POLLING_TECH_MASK, &num, sizeof(num))) |
| tech_mask = num; |
| else |
| tech_mask = DEFAULT_TECH_MASK; |
| } |
| |
| { |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| status = NFA_EnablePolling (tech_mask); |
| if (status == NFA_STATUS_OK) |
| { |
| ALOGD ("%s: wait for enable event", __FUNCTION__); |
| sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_ENABLED_EVT |
| } |
| else |
| { |
| ALOGE ("%s: fail enable polling; error=0x%X", __FUNCTION__, status); |
| } |
| } |
| |
| /* start polling */ |
| if (!sRfEnabled) |
| { |
| // Start RF discovery to reconfigure |
| startRfDiscovery(true); |
| } |
| return NULL; |
| } |
| |
| void reconfigure_poll_cb(union sigval) |
| { |
| ALOGD ("Prio_Logic_multiprotocol timer expire"); |
| ALOGD ("CallBack Reconfiguring the POLL to Default"); |
| clear_multiprotocol(); |
| multiprotocol_timer.set (300, multiprotocol_clear_flag); |
| } |
| |
| void clear_multiprotocol() |
| { |
| int thread_ret; |
| |
| ALOGD ("clear_multiprotocol"); |
| multiprotocol_detected = 0; |
| |
| thread_ret = pthread_create(&multiprotocol_thread, NULL, p2p_prio_logic_multiprotocol, NULL); |
| if(thread_ret != 0) |
| ALOGD("unable to create the thread"); |
| } |
| |
| void multiprotocol_clear_flag(union sigval) |
| { |
| ALOGD ("multiprotocol_clear_flag"); |
| multiprotocol_flag = 1; |
| } |
| #endif |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfaConnectionCallback |
| ** |
| ** Description: Receive connection-related events from stack. |
| ** connEvent: Event code. |
| ** eventData: Event data. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfaConnectionCallback (UINT8 connEvent, tNFA_CONN_EVT_DATA* eventData) |
| { |
| tNFA_STATUS status = NFA_STATUS_FAILED; |
| static UINT8 prev_more_val = 0x00; |
| UINT8 cur_more_val=0x00; |
| ALOGD("%s: event= %u", __FUNCTION__, connEvent); |
| |
| switch (connEvent) |
| { |
| case NFA_POLL_ENABLED_EVT: // whether polling successfully started |
| { |
| ALOGD("%s: NFA_POLL_ENABLED_EVT: status = %u", __FUNCTION__, eventData->status); |
| |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| sNfaEnableDisablePollingEvent.notifyOne (); |
| } |
| break; |
| |
| case NFA_POLL_DISABLED_EVT: // Listening/Polling stopped |
| { |
| ALOGD("%s: NFA_POLL_DISABLED_EVT: status = %u", __FUNCTION__, eventData->status); |
| |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| sNfaEnableDisablePollingEvent.notifyOne (); |
| } |
| break; |
| |
| case NFA_RF_DISCOVERY_STARTED_EVT: // RF Discovery started |
| { |
| ALOGD("%s: NFA_RF_DISCOVERY_STARTED_EVT: status = %u", __FUNCTION__, eventData->status); |
| |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| sNfaEnableDisablePollingEvent.notifyOne (); |
| } |
| break; |
| |
| case NFA_RF_DISCOVERY_STOPPED_EVT: // RF Discovery stopped event |
| { |
| ALOGD("%s: NFA_RF_DISCOVERY_STOPPED_EVT: status = %u", __FUNCTION__, eventData->status); |
| notifyPollingEventwhileNfcOff(); |
| if (getReconnectState() == true) |
| { |
| eventData->deactivated.type = NFA_DEACTIVATE_TYPE_SLEEP; |
| NfcTag::getInstance().setDeactivationState (eventData->deactivated); |
| if (gIsTagDeactivating) |
| { |
| NfcTag::getInstance().setActive(false); |
| nativeNfcTag_doDeactivateStatus(0); |
| } |
| } |
| else |
| { |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| sNfaEnableDisablePollingEvent.notifyOne (); |
| } |
| } |
| break; |
| |
| case NFA_DISC_RESULT_EVT: // NFC link/protocol discovery notificaiton |
| status = eventData->disc_result.status; |
| cur_more_val = eventData->disc_result.discovery_ntf.more; |
| ALOGD("%s: NFA_DISC_RESULT_EVT: status = %d", __FUNCTION__, status); |
| if((cur_more_val == 0x01) && (prev_more_val != 0x02)) |
| { |
| ALOGE("NFA_DISC_RESULT_EVT failed"); |
| status = NFA_STATUS_FAILED; |
| }else |
| { |
| ALOGD("NFA_DISC_RESULT_EVT success"); |
| status = NFA_STATUS_OK; |
| prev_more_val = cur_more_val; |
| } |
| #if(NXP_EXTNS == TRUE && NFC_NXP_NON_STD_CARD == TRUE) |
| if (gIsSelectingRfInterface) |
| { |
| ALOGE("reselect mechanism did not save the modification"); |
| if(cur_more_val == 0x00) |
| { |
| ALOGE("error case select any one tag"); |
| multiprotocol_flag = 0; |
| } |
| } |
| #endif |
| if (status != NFA_STATUS_OK) |
| { |
| NfcTag::getInstance ().mNumDiscNtf = 0; |
| ALOGE("%s: NFA_DISC_RESULT_EVT error: status = %d", __FUNCTION__, status); |
| } |
| else |
| { |
| NfcTag::getInstance().connectionEventHandler(connEvent, eventData); |
| handleRfDiscoveryEvent(&eventData->disc_result.discovery_ntf); |
| } |
| break; |
| |
| case NFA_SELECT_RESULT_EVT: // NFC link/protocol discovery select response |
| ALOGD("%s: NFA_SELECT_RESULT_EVT: status = %d, gIsSelectingRfInterface = %d, sIsDisabling=%d", __FUNCTION__, eventData->status, gIsSelectingRfInterface, sIsDisabling); |
| |
| if (sIsDisabling) |
| break; |
| |
| if (eventData->status != NFA_STATUS_OK) |
| { |
| if (gIsSelectingRfInterface) |
| { |
| #if(NXP_EXTNS == TRUE && NFC_NXP_NON_STD_CARD == TRUE) |
| nativeNfcTag_cacheNonNciCardDetection(); |
| #endif |
| nativeNfcTag_doConnectStatus(false); |
| } |
| #if(NXP_EXTNS == TRUE) |
| NfcTag::getInstance().selectCompleteStatus(false); |
| NfcTag::getInstance ().mNumDiscNtf = 0x00; |
| #endif |
| NfcTag::getInstance().mTechListIndex = 0; |
| ALOGE("%s: NFA_SELECT_RESULT_EVT error: status = %d", __FUNCTION__, eventData->status); |
| NFA_Deactivate (FALSE); |
| } |
| #if(NXP_EXTNS == TRUE) |
| else if(sReaderModeEnabled && (gFelicaReaderState == STATE_DEACTIVATED_TO_SLEEP)) |
| { |
| SyncEventGuard g (sRespCbEvent); |
| ALOGD("%s: Sending Sem Post for Select Event", __FUNCTION__); |
| sRespCbEvent.notifyOne (); |
| gFelicaReaderState = STATE_FRAMERF_INTF_SELECTED; |
| ALOGD ("%s: FRM NFA_SELECT_RESULT_EVT", __FUNCTION__); |
| } |
| #endif |
| break; |
| |
| case NFA_DEACTIVATE_FAIL_EVT: |
| ALOGD("%s: NFA_DEACTIVATE_FAIL_EVT: status = %d", __FUNCTION__, eventData->status); |
| { |
| SyncEventGuard g (gDeactivatedEvent); |
| gActivated = false; |
| gDeactivatedEvent.notifyOne (); |
| } |
| { |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| sNfaEnableDisablePollingEvent.notifyOne (); |
| } |
| break; |
| |
| case NFA_ACTIVATED_EVT: // NFC link/protocol activated |
| #if(NXP_EXTNS == TRUE) |
| rfActivation = true; |
| #endif |
| checkforTranscation(NFA_ACTIVATED_EVT, (void *)eventData); |
| |
| ALOGD("%s: NFA_ACTIVATED_EVT: gIsSelectingRfInterface=%d, sIsDisabling=%d", __FUNCTION__, gIsSelectingRfInterface, sIsDisabling); |
| #if(NXP_EXTNS == TRUE) |
| NfcTag::getInstance().selectCompleteStatus(true); |
| if(eventData->activated.activate_ntf.intf_param.type==NFC_INTERFACE_EE_DIRECT_RF) |
| { |
| ALOGD("%s: NFA_ACTIVATED_EVT: gUICCVirtualWiredProtectMask=%d, gEseVirtualWiredProtectMask=%d", __FUNCTION__,gUICCVirtualWiredProtectMask, gEseVirtualWiredProtectMask); |
| if(gUICCVirtualWiredProtectMask != 0x00 || gEseVirtualWiredProtectMask != 0x00) |
| { |
| recovery=TRUE; |
| } |
| } |
| #endif |
| #if(NXP_EXTNS == TRUE) |
| /***P2P-Prio Logic for Multiprotocol***/ |
| if( (eventData->activated.activate_ntf.protocol == NFA_PROTOCOL_NFC_DEP) && (multiprotocol_detected == 1) ) |
| { |
| ALOGD("Prio_Logic_multiprotocol stop timer"); |
| multiprotocol_timer.kill(); |
| } |
| if( (eventData->activated.activate_ntf.protocol == NFA_PROTOCOL_T3T) && (multiprotocol_detected == 1) ) |
| { |
| ALOGD("Prio_Logic_multiprotocol stop timer"); |
| multiprotocol_timer.kill(); |
| clear_multiprotocol(); |
| } |
| #endif |
| #if (NFC_NXP_ESE == TRUE && ((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551))) |
| /* |
| * Handle Reader over SWP START_READER_EVENT |
| * */ |
| if(eventData->activated.activate_ntf.intf_param.type == NCI_INTERFACE_UICC_DIRECT || eventData->activated.activate_ntf.intf_param.type == NCI_INTERFACE_ESE_DIRECT ) |
| { |
| SecureElement::getInstance().notifyEEReaderEvent(NFA_RD_SWP_READER_START, eventData->activated.activate_ntf.rf_tech_param.mode); |
| gReaderNotificationflag = true; |
| break; |
| } |
| #endif |
| if((eventData->activated.activate_ntf.protocol != NFA_PROTOCOL_NFC_DEP) && (!isListenMode(eventData->activated))) |
| { |
| nativeNfcTag_setRfInterface ((tNFA_INTF_TYPE) eventData->activated.activate_ntf.intf_param.type); |
| } |
| |
| if (EXTNS_GetConnectFlag() == TRUE) |
| { |
| NfcTag::getInstance().setActivationState (); |
| nativeNfcTag_doConnectStatus(true); |
| break; |
| } |
| NfcTag::getInstance().setActive(true); |
| if (sIsDisabling || !sIsNfaEnabled) |
| break; |
| gActivated = true; |
| |
| NfcTag::getInstance().setActivationState (); |
| |
| if (gIsSelectingRfInterface) |
| { |
| nativeNfcTag_doConnectStatus(true); |
| if (NfcTag::getInstance ().isCashBeeActivated() == true || NfcTag::getInstance ().isEzLinkTagActivated() == true) |
| { |
| NfcTag::getInstance().connectionEventHandler (NFA_ACTIVATED_UPDATE_EVT, eventData); |
| } |
| break; |
| } |
| |
| nativeNfcTag_resetPresenceCheck(); |
| if (isPeerToPeer(eventData->activated)) |
| { |
| if (sReaderModeEnabled) |
| { |
| #if(NXP_EXTNS == TRUE) |
| /*if last transaction is complete or prev state is Idle |
| *then proceed to nxt state*/ |
| if((gFelicaReaderState == STATE_IDLE) || |
| (gFelicaReaderState == STATE_FRAMERF_INTF_SELECTED)) |
| { |
| ALOGD("%s: Activating Reader Mode in P2P ", __FUNCTION__); |
| gFelicaReaderState = STATE_NFCDEP_ACTIVATED_NFCDEP_INTF; |
| switchP2PToT3TRead(eventData->activated.activate_ntf.rf_disc_id); |
| } |
| else |
| { |
| ALOGD("%s: Invalid FelicaReaderState : %d ", __FUNCTION__,gFelicaReaderState); |
| gFelicaReaderState = STATE_IDLE; |
| #endif |
| ALOGD("%s: ignoring peer target in reader mode.", __FUNCTION__); |
| NFA_Deactivate (FALSE); |
| #if(NXP_EXTNS == TRUE) |
| } |
| #endif |
| break; |
| } |
| sP2pActive = true; |
| ALOGD("%s: NFA_ACTIVATED_EVT; is p2p", __FUNCTION__); |
| // Disable RF field events in case of p2p |
| // UINT8 nfa_disable_rf_events[] = { 0x00 }; /*commented to eliminate unused variable warning*/ |
| ALOGD ("%s: Disabling RF field events", __FUNCTION__); |
| #if 0 |
| status = NFA_SetConfig(NCI_PARAM_ID_RF_FIELD_INFO, sizeof(nfa_disable_rf_events), |
| &nfa_disable_rf_events[0]); |
| if (status == NFA_STATUS_OK) { |
| ALOGD ("%s: Disabled RF field events", __FUNCTION__); |
| } else { |
| ALOGE ("%s: Failed to disable RF field events", __FUNCTION__); |
| } |
| #endif |
| // For the SE, consider the field to be on while p2p is active. |
| SecureElement::getInstance().notifyRfFieldEvent (true); |
| } |
| else if (pn544InteropIsBusy() == false) |
| { |
| #if(NXP_EXTNS == TRUE && NFC_NXP_NON_STD_CARD == TRUE) |
| nativeNfcTag_handleNonNciMultiCardDetection(connEvent, eventData); |
| ALOGD("%s: scoreGenericNtf = 0x%x", __FUNCTION__ ,scoreGenericNtf); |
| if(scoreGenericNtf == true) |
| { |
| if( (eventData->activated.activate_ntf.intf_param.type == NFC_INTERFACE_ISO_DEP) && (eventData->activated.activate_ntf.protocol == NFC_PROTOCOL_ISO_DEP) ) |
| { |
| nativeNfcTag_handleNonNciCardDetection(eventData); |
| } |
| scoreGenericNtf = false; |
| } |
| |
| #else |
| NfcTag::getInstance().connectionEventHandler (connEvent, eventData); |
| if(NfcTag::getInstance ().mNumDiscNtf) |
| { |
| NFA_Deactivate (TRUE); |
| } |
| #endif |
| |
| // We know it is not activating for P2P. If it activated in |
| // listen mode then it is likely for an SE transaction. |
| // Send the RF Event. |
| if (isListenMode(eventData->activated)) |
| { |
| sSeRfActive = true; |
| SecureElement::getInstance().notifyListenModeState (true); |
| } |
| } |
| break; |
| |
| case NFA_DEACTIVATED_EVT: // NFC link/protocol deactivated |
| ALOGD("%s: NFA_DEACTIVATED_EVT Type: %u, gIsTagDeactivating: %d", __FUNCTION__, eventData->deactivated.type,gIsTagDeactivating); |
| #if(NXP_EXTNS == TRUE) |
| rfActivation = false; |
| #endif |
| #if(NFC_NXP_CHIP_TYPE == PN547C2 && NXP_EXTNS == TRUE) |
| if(eventData->deactivated.type == NFA_DEACTIVATE_TYPE_IDLE) |
| { |
| checkforTranscation(NFA_DEACTIVATED_EVT, (void *)eventData); |
| } |
| #endif |
| #if(NXP_EXTNS == TRUE && NFC_NXP_NON_STD_CARD == TRUE) |
| if(checkCmdSent == 1 && eventData->deactivated.type == 0) |
| { |
| ALOGD("%s: NFA_DEACTIVATED_EVT setting check flag to one", __FUNCTION__); |
| checkTagNtf = 1; |
| } |
| #endif |
| notifyPollingEventwhileNfcOff(); |
| if (true == getReconnectState()) |
| { |
| ALOGD("Reconnect in progress : Do nothing"); |
| break; |
| } |
| gReaderNotificationflag = false; |
| #if(NXP_EXTNS == TRUE) |
| /***P2P-Prio Logic for Multiprotocol***/ |
| if( (multiprotocol_detected == 1) && (sP2pActive == 1) ) |
| { |
| NfcTag::getInstance ().mNumDiscNtf = 0;//reset if any notifications are not cleared |
| clear_multiprotocol(); |
| multiprotocol_flag = 1; |
| } |
| #endif |
| NfcTag::getInstance().setDeactivationState (eventData->deactivated); |
| if(NfcTag::getInstance ().mNumDiscNtf) |
| { |
| NfcTag::getInstance ().mNumDiscNtf--; |
| NfcTag::getInstance().selectNextTag(); |
| } |
| if (eventData->deactivated.type != NFA_DEACTIVATE_TYPE_SLEEP) |
| { |
| { |
| SyncEventGuard g (gDeactivatedEvent); |
| gActivated = false; //guard this variable from multi-threaded access |
| gDeactivatedEvent.notifyOne (); |
| } |
| NfcTag::getInstance ().mNumDiscNtf = 0; |
| NfcTag::getInstance ().mTechListIndex =0; |
| nativeNfcTag_resetPresenceCheck(); |
| NfcTag::getInstance().connectionEventHandler (connEvent, eventData); |
| nativeNfcTag_abortWaits(); |
| NfcTag::getInstance().abort (); |
| } |
| else if (gIsTagDeactivating) |
| { |
| NfcTag::getInstance ().setActive (false); |
| nativeNfcTag_doDeactivateStatus (0); |
| } |
| else if (EXTNS_GetDeactivateFlag () == TRUE) |
| { |
| NfcTag::getInstance ().setActive (false); |
| nativeNfcTag_doDeactivateStatus (0); |
| } |
| |
| // If RF is activated for what we think is a Secure Element transaction |
| // and it is deactivated to either IDLE or DISCOVERY mode, notify w/event. |
| if ((eventData->deactivated.type == NFA_DEACTIVATE_TYPE_IDLE) |
| || (eventData->deactivated.type == NFA_DEACTIVATE_TYPE_DISCOVERY)) |
| { |
| #if(NXP_EXTNS == TRUE) |
| if(RoutingManager::getInstance().is_ee_recovery_ongoing()) |
| { |
| recovery=FALSE; |
| SyncEventGuard guard (SecureElement::getInstance().mEEdatapacketEvent); |
| SecureElement::getInstance().mEEdatapacketEvent.notifyOne(); |
| } |
| #endif |
| if (sSeRfActive) { |
| sSeRfActive = false; |
| if (!sIsDisabling && sIsNfaEnabled) |
| SecureElement::getInstance().notifyListenModeState (false); |
| } else if (sP2pActive) { |
| sP2pActive = false; |
| SecureElement::getInstance().notifyRfFieldEvent (false); |
| // Make sure RF field events are re-enabled |
| ALOGD("%s: NFA_DEACTIVATED_EVT; is p2p", __FUNCTION__); |
| // Disable RF field events in case of p2p |
| // UINT8 nfa_enable_rf_events[] = { 0x01 }; /*commented to eliminate unused variable warning*/ |
| /* |
| if (!sIsDisabling && sIsNfaEnabled) |
| { |
| ALOGD ("%s: Enabling RF field events", __FUNCTION__); |
| status = NFA_SetConfig(NCI_PARAM_ID_RF_FIELD_INFO, sizeof(nfa_enable_rf_events), |
| &nfa_enable_rf_events[0]); |
| if (status == NFA_STATUS_OK) { |
| ALOGD ("%s: Enabled RF field events", __FUNCTION__); |
| } else { |
| ALOGE ("%s: Failed to enable RF field events", __FUNCTION__); |
| } |
| // Consider the field to be off at this point |
| } |
| */ |
| } |
| } |
| #if(NXP_EXTNS == TRUE) |
| if (sReaderModeEnabled && (eventData->deactivated.type == NFA_DEACTIVATE_TYPE_SLEEP)) |
| { |
| if(gFelicaReaderState == STATE_NFCDEP_ACTIVATED_NFCDEP_INTF) |
| { |
| SyncEventGuard g (sRespCbEvent); |
| ALOGD("%s: Sending Sem Post for Deactivated", __FUNCTION__); |
| sRespCbEvent.notifyOne (); |
| ALOGD("Switching to T3T\n"); |
| gFelicaReaderState = STATE_DEACTIVATED_TO_SLEEP; |
| } |
| else |
| { |
| ALOGD("%s: FelicaReaderState Invalid", __FUNCTION__); |
| gFelicaReaderState = STATE_IDLE; |
| } |
| } |
| #endif |
| break; |
| |
| case NFA_TLV_DETECT_EVT: // TLV Detection complete |
| status = eventData->tlv_detect.status; |
| ALOGD("%s: NFA_TLV_DETECT_EVT: status = %d, protocol = %d, num_tlvs = %d, num_bytes = %d", |
| __FUNCTION__, status, eventData->tlv_detect.protocol, |
| eventData->tlv_detect.num_tlvs, eventData->tlv_detect.num_bytes); |
| if (status != NFA_STATUS_OK) |
| { |
| ALOGE("%s: NFA_TLV_DETECT_EVT error: status = %d", __FUNCTION__, status); |
| } |
| break; |
| |
| case NFA_NDEF_DETECT_EVT: // NDEF Detection complete; |
| //if status is failure, it means the tag does not contain any or valid NDEF data; |
| //pass the failure status to the NFC Service; |
| status = eventData->ndef_detect.status; |
| ALOGD("%s: NFA_NDEF_DETECT_EVT: status = 0x%X, protocol = %u, " |
| "max_size = %lu, cur_size = %lu, flags = 0x%X", __FUNCTION__, |
| status, |
| eventData->ndef_detect.protocol, eventData->ndef_detect.max_size, |
| eventData->ndef_detect.cur_size, eventData->ndef_detect.flags); |
| NfcTag::getInstance().connectionEventHandler (connEvent, eventData); |
| nativeNfcTag_doCheckNdefResult(status, |
| eventData->ndef_detect.max_size, eventData->ndef_detect.cur_size, |
| eventData->ndef_detect.flags); |
| break; |
| |
| case NFA_DATA_EVT: // Data message received (for non-NDEF reads) |
| ALOGD("%s: NFA_DATA_EVT: status = 0x%X, len = %d", __FUNCTION__, eventData->status, eventData->data.len); |
| nativeNfcTag_doTransceiveStatus(eventData->status, eventData->data.p_data, eventData->data.len); |
| break; |
| case NFA_RW_INTF_ERROR_EVT: |
| ALOGD("%s: NFC_RW_INTF_ERROR_EVT", __FUNCTION__); |
| nativeNfcTag_notifyRfTimeout(); |
| nativeNfcTag_doReadCompleted (NFA_STATUS_TIMEOUT); |
| break; |
| case NFA_SELECT_CPLT_EVT: // Select completed |
| status = eventData->status; |
| ALOGD("%s: NFA_SELECT_CPLT_EVT: status = %d", __FUNCTION__, status); |
| if (status != NFA_STATUS_OK) |
| { |
| ALOGE("%s: NFA_SELECT_CPLT_EVT error: status = %d", __FUNCTION__, status); |
| } |
| break; |
| |
| case NFA_READ_CPLT_EVT: // NDEF-read or tag-specific-read completed |
| ALOGD("%s: NFA_READ_CPLT_EVT: status = 0x%X", __FUNCTION__, eventData->status); |
| nativeNfcTag_doReadCompleted (eventData->status); |
| NfcTag::getInstance().connectionEventHandler (connEvent, eventData); |
| break; |
| |
| case NFA_WRITE_CPLT_EVT: // Write completed |
| ALOGD("%s: NFA_WRITE_CPLT_EVT: status = %d", __FUNCTION__, eventData->status); |
| nativeNfcTag_doWriteStatus (eventData->status == NFA_STATUS_OK); |
| break; |
| |
| case NFA_SET_TAG_RO_EVT: // Tag set as Read only |
| ALOGD("%s: NFA_SET_TAG_RO_EVT: status = %d", __FUNCTION__, eventData->status); |
| nativeNfcTag_doMakeReadonlyResult(eventData->status); |
| break; |
| |
| case NFA_CE_NDEF_WRITE_START_EVT: // NDEF write started |
| ALOGD("%s: NFA_CE_NDEF_WRITE_START_EVT: status: %d", __FUNCTION__, eventData->status); |
| |
| if (eventData->status != NFA_STATUS_OK) |
| ALOGE("%s: NFA_CE_NDEF_WRITE_START_EVT error: status = %d", __FUNCTION__, eventData->status); |
| break; |
| |
| case NFA_CE_NDEF_WRITE_CPLT_EVT: // NDEF write completed |
| ALOGD("%s: FA_CE_NDEF_WRITE_CPLT_EVT: len = %lu", __FUNCTION__, eventData->ndef_write_cplt.len); |
| break; |
| |
| case NFA_LLCP_ACTIVATED_EVT: // LLCP link is activated |
| ALOGD("%s: NFA_LLCP_ACTIVATED_EVT: is_initiator: %d remote_wks: %d, remote_lsc: %d, remote_link_miu: %d, local_link_miu: %d", |
| __FUNCTION__, |
| eventData->llcp_activated.is_initiator, |
| eventData->llcp_activated.remote_wks, |
| eventData->llcp_activated.remote_lsc, |
| eventData->llcp_activated.remote_link_miu, |
| eventData->llcp_activated.local_link_miu); |
| |
| PeerToPeer::getInstance().llcpActivatedHandler (getNative(0, 0), eventData->llcp_activated); |
| break; |
| |
| case NFA_LLCP_DEACTIVATED_EVT: // LLCP link is deactivated |
| ALOGD("%s: NFA_LLCP_DEACTIVATED_EVT", __FUNCTION__); |
| PeerToPeer::getInstance().llcpDeactivatedHandler (getNative(0, 0), eventData->llcp_deactivated); |
| break; |
| case NFA_LLCP_FIRST_PACKET_RECEIVED_EVT: // Received first packet over llcp |
| ALOGD("%s: NFA_LLCP_FIRST_PACKET_RECEIVED_EVT", __FUNCTION__); |
| PeerToPeer::getInstance().llcpFirstPacketHandler (getNative(0, 0)); |
| break; |
| case NFA_PRESENCE_CHECK_EVT: |
| ALOGD("%s: NFA_PRESENCE_CHECK_EVT", __FUNCTION__); |
| nativeNfcTag_doPresenceCheckResult (eventData->status); |
| break; |
| case NFA_FORMAT_CPLT_EVT: |
| ALOGD("%s: NFA_FORMAT_CPLT_EVT: status=0x%X", __FUNCTION__, eventData->status); |
| nativeNfcTag_formatStatus (eventData->status == NFA_STATUS_OK); |
| break; |
| |
| case NFA_I93_CMD_CPLT_EVT: |
| ALOGD("%s: NFA_I93_CMD_CPLT_EVT: status=0x%X", __FUNCTION__, eventData->status); |
| break; |
| |
| case NFA_CE_UICC_LISTEN_CONFIGURED_EVT : |
| ALOGD("%s: NFA_CE_UICC_LISTEN_CONFIGURED_EVT : status=0x%X", __FUNCTION__, eventData->status); |
| SecureElement::getInstance().connectionEventHandler (connEvent, eventData); |
| break; |
| |
| case NFA_CE_ESE_LISTEN_CONFIGURED_EVT : |
| ALOGD("%s: NFA_CE_ESE_LISTEN_CONFIGURED_EVT : status=0x%X", __FUNCTION__, eventData->status); |
| SecureElement::getInstance().connectionEventHandler (connEvent, eventData); |
| break; |
| |
| case NFA_SET_P2P_LISTEN_TECH_EVT: |
| ALOGD("%s: NFA_SET_P2P_LISTEN_TECH_EVT", __FUNCTION__); |
| PeerToPeer::getInstance().connectionEventHandler (connEvent, eventData); |
| break; |
| case NFA_CE_LOCAL_TAG_CONFIGURED_EVT: |
| ALOGD("%s: NFA_CE_LOCAL_TAG_CONFIGURED_EVT", __FUNCTION__); |
| break; |
| #if(NFC_NXP_ESE == TRUE && ((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551))) |
| case NFA_RECOVERY_EVT: |
| ALOGD("%s: NFA_RECOVERY_EVT", __FUNCTION__); |
| ALOGD("%s: Discovery Started in lower layer : Updating status in JNI", __FUNCTION__); |
| if(RoutingManager::getInstance().getEtsiReaederState() == STATE_SE_RDR_MODE_STOP_IN_PROGRESS) |
| { |
| ALOGD("%s: Reset the Etsi Reader State to STATE_SE_RDR_MODE_STOPPED", __FUNCTION__); |
| |
| RoutingManager::getInstance().setEtsiReaederState(STATE_SE_RDR_MODE_STOPPED); |
| } |
| |
| break; |
| #endif |
| default: |
| ALOGE("%s: unknown event ????", __FUNCTION__); |
| break; |
| } |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_initNativeStruc |
| ** |
| ** Description: Initialize variables. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| static jboolean nfcManager_initNativeStruc (JNIEnv* e, jobject o) |
| { |
| ALOGD ("%s: enter", __FUNCTION__); |
| |
| nfc_jni_native_data* nat = (nfc_jni_native_data*)malloc(sizeof(struct nfc_jni_native_data)); |
| if (nat == NULL) |
| { |
| ALOGE ("%s: fail allocate native data", __FUNCTION__); |
| return JNI_FALSE; |
| } |
| |
| memset (nat, 0, sizeof(*nat)); |
| e->GetJavaVM(&(nat->vm)); |
| nat->env_version = e->GetVersion(); |
| nat->manager = e->NewGlobalRef(o); |
| |
| ScopedLocalRef<jclass> cls(e, e->GetObjectClass(o)); |
| jfieldID f = e->GetFieldID(cls.get(), "mNative", "J"); |
| e->SetLongField(o, f, (jlong)nat); |
| |
| /* Initialize native cached references */ |
| gCachedNfcManagerNotifyNdefMessageListeners = e->GetMethodID(cls.get(), |
| "notifyNdefMessageListeners", "(Lcom/android/nfc/dhimpl/NativeNfcTag;)V"); |
| gCachedNfcManagerNotifyTransactionListeners = e->GetMethodID(cls.get(), |
| "notifyTransactionListeners", "([B[BI)V"); |
| gCachedNfcManagerNotifyConnectivityListeners = e->GetMethodID(cls.get(), |
| "notifyConnectivityListeners", "(I)V"); |
| gCachedNfcManagerNotifyEmvcoMultiCardDetectedListeners = e->GetMethodID(cls.get(), |
| "notifyEmvcoMultiCardDetectedListeners", "()V"); |
| gCachedNfcManagerNotifyLlcpLinkActivation = e->GetMethodID(cls.get(), |
| "notifyLlcpLinkActivation", "(Lcom/android/nfc/dhimpl/NativeP2pDevice;)V"); |
| gCachedNfcManagerNotifyLlcpLinkDeactivated = e->GetMethodID(cls.get(), |
| "notifyLlcpLinkDeactivated", "(Lcom/android/nfc/dhimpl/NativeP2pDevice;)V"); |
| gCachedNfcManagerNotifyLlcpFirstPacketReceived = e->GetMethodID(cls.get(), |
| "notifyLlcpLinkFirstPacketReceived", "(Lcom/android/nfc/dhimpl/NativeP2pDevice;)V"); |
| sCachedNfcManagerNotifyTargetDeselected = e->GetMethodID(cls.get(), |
| "notifyTargetDeselected","()V"); |
| gCachedNfcManagerNotifySeFieldActivated = e->GetMethodID(cls.get(), |
| "notifySeFieldActivated", "()V"); |
| gCachedNfcManagerNotifySeFieldDeactivated = e->GetMethodID(cls.get(), |
| "notifySeFieldDeactivated", "()V"); |
| gCachedNfcManagerNotifySeListenActivated = e->GetMethodID(cls.get(), |
| "notifySeListenActivated", "()V"); |
| gCachedNfcManagerNotifySeListenDeactivated = e->GetMethodID(cls.get(), |
| "notifySeListenDeactivated", "()V"); |
| |
| gCachedNfcManagerNotifyHostEmuActivated = e->GetMethodID(cls.get(), |
| "notifyHostEmuActivated", "(I)V"); |
| |
| gCachedNfcManagerNotifyAidRoutingTableFull = e->GetMethodID(cls.get(), |
| "notifyAidRoutingTableFull", "()V"); |
| |
| gCachedNfcManagerNotifyHostEmuData = e->GetMethodID(cls.get(), |
| "notifyHostEmuData", "(I[B)V"); |
| |
| gCachedNfcManagerNotifyHostEmuDeactivated = e->GetMethodID(cls.get(), |
| "notifyHostEmuDeactivated", "(I)V"); |
| |
| gCachedNfcManagerNotifyRfFieldActivated = e->GetMethodID(cls.get(), |
| "notifyRfFieldActivated", "()V"); |
| gCachedNfcManagerNotifyRfFieldDeactivated = e->GetMethodID(cls.get(), |
| "notifyRfFieldDeactivated", "()V"); |
| |
| sCachedNfcManagerNotifySeApduReceived = e->GetMethodID(cls.get(), |
| "notifySeApduReceived", "([B)V"); |
| |
| sCachedNfcManagerNotifySeMifareAccess = e->GetMethodID(cls.get(), |
| "notifySeMifareAccess", "([B)V"); |
| |
| sCachedNfcManagerNotifySeEmvCardRemoval = e->GetMethodID(cls.get(), |
| "notifySeEmvCardRemoval", "()V"); |
| |
| gCachedNfcManagerNotifySWPReaderRequested = e->GetMethodID (cls.get(), |
| "notifySWPReaderRequested", "(ZZ)V"); |
| |
| gCachedNfcManagerNotifySWPReaderRequestedFail= e->GetMethodID (cls.get(), |
| "notifySWPReaderRequestedFail", "(I)V"); |
| |
| |
| gCachedNfcManagerNotifySWPReaderActivated = e->GetMethodID (cls.get(), |
| "notifySWPReaderActivated", "()V"); |
| #if(NFC_NXP_ESE == TRUE && ((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551))) |
| gCachedNfcManagerNotifyETSIReaderModeStartConfig = e->GetMethodID (cls.get(), |
| "notifyonETSIReaderModeStartConfig", "(I)V"); |
| |
| gCachedNfcManagerNotifyETSIReaderModeStopConfig = e->GetMethodID (cls.get(), |
| "notifyonETSIReaderModeStopConfig", "(I)V"); |
| |
| gCachedNfcManagerNotifyETSIReaderModeSwpTimeout = e->GetMethodID (cls.get(), |
| "notifyonETSIReaderModeSwpTimeout", "(I)V"); |
| #endif |
| #if((NXP_EXTNS == TRUE) && (NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE)) |
| gCachedNfcManagerNotifyUiccStatusEvent= e->GetMethodID (cls.get(), |
| "notifyUiccStatusEvent", "(I)V"); |
| #endif |
| if (nfc_jni_cache_object(e, gNativeNfcTagClassName, &(nat->cached_NfcTag)) == -1) |
| { |
| ALOGE ("%s: fail cache NativeNfcTag", __FUNCTION__); |
| return JNI_FALSE; |
| } |
| |
| if (nfc_jni_cache_object(e, gNativeP2pDeviceClassName, &(nat->cached_P2pDevice)) == -1) |
| { |
| ALOGE ("%s: fail cache NativeP2pDevice", __FUNCTION__); |
| return JNI_FALSE; |
| } |
| |
| ALOGD ("%s: exit", __FUNCTION__); |
| return JNI_TRUE; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfaDeviceManagementCallback |
| ** |
| ** Description: Receive device management events from stack. |
| ** dmEvent: Device-management event ID. |
| ** eventData: Data associated with event ID. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void nfaDeviceManagementCallback (UINT8 dmEvent, tNFA_DM_CBACK_DATA* eventData) |
| { |
| ALOGD ("%s: enter; event=0x%X", __FUNCTION__, dmEvent); |
| |
| switch (dmEvent) |
| { |
| case NFA_DM_ENABLE_EVT: /* Result of NFA_Enable */ |
| { |
| SyncEventGuard guard (sNfaEnableEvent); |
| ALOGD ("%s: NFA_DM_ENABLE_EVT; status=0x%X", |
| __FUNCTION__, eventData->status); |
| sIsNfaEnabled = eventData->status == NFA_STATUS_OK; |
| sIsDisabling = false; |
| sNfaEnableEvent.notifyOne (); |
| } |
| break; |
| |
| case NFA_DM_DISABLE_EVT: /* Result of NFA_Disable */ |
| { |
| SyncEventGuard guard (sNfaDisableEvent); |
| ALOGD ("%s: NFA_DM_DISABLE_EVT", __FUNCTION__); |
| sIsNfaEnabled = false; |
| sIsDisabling = false; |
| sNfaDisableEvent.notifyOne (); |
| } |
| break; |
| |
| case NFA_DM_SET_CONFIG_EVT: //result of NFA_SetConfig |
| ALOGD ("%s: NFA_DM_SET_CONFIG_EVT", __FUNCTION__); |
| { |
| SyncEventGuard guard (sNfaSetConfigEvent); |
| sNfaSetConfigEvent.notifyOne(); |
| } |
| break; |
| |
| case NFA_DM_GET_CONFIG_EVT: /* Result of NFA_GetConfig */ |
| ALOGD ("%s: NFA_DM_GET_CONFIG_EVT", __FUNCTION__); |
| { |
| HciRFParams::getInstance().connectionEventHandler(dmEvent,eventData); |
| SyncEventGuard guard (sNfaGetConfigEvent); |
| if (eventData->status == NFA_STATUS_OK && |
| eventData->get_config.tlv_size <= sizeof(sConfig)) |
| { |
| sCurrentConfigLen = eventData->get_config.tlv_size; |
| memcpy(sConfig, eventData->get_config.param_tlvs, eventData->get_config.tlv_size); |
| |
| #if(NXP_EXTNS == TRUE) |
| if(sCheckNfceeFlag) |
| checkforNfceeBuffer(); |
| #endif |
| } |
| else |
| { |
| ALOGE("%s: NFA_DM_GET_CONFIG failed", __FUNCTION__); |
| sCurrentConfigLen = 0; |
| } |
| sNfaGetConfigEvent.notifyOne(); |
| } |
| break; |
| |
| case NFA_DM_RF_FIELD_EVT: |
| checkforTranscation(NFA_TRANS_DM_RF_FIELD_EVT, (void *)eventData); |
| ALOGD ("%s: NFA_DM_RF_FIELD_EVT; status=0x%X; field status=%u", __FUNCTION__, |
| eventData->rf_field.status, eventData->rf_field.rf_field_status); |
| if (sIsDisabling || !sIsNfaEnabled) |
| break; |
| |
| if (!sP2pActive && eventData->rf_field.status == NFA_STATUS_OK) |
| { |
| SecureElement::getInstance().notifyRfFieldEvent ( |
| eventData->rf_field.rf_field_status == NFA_DM_RF_FIELD_ON); |
| struct nfc_jni_native_data *nat = getNative(NULL, NULL); |
| JNIEnv* e = NULL; |
| ScopedAttach attach(nat->vm, &e); |
| if (e == NULL) |
| { |
| ALOGE ("jni env is null"); |
| return; |
| } |
| if (eventData->rf_field.rf_field_status == NFA_DM_RF_FIELD_ON) |
| e->CallVoidMethod (nat->manager, android::gCachedNfcManagerNotifyRfFieldActivated); |
| else |
| e->CallVoidMethod (nat->manager, android::gCachedNfcManagerNotifyRfFieldDeactivated); |
| } |
| break; |
| |
| case NFA_DM_NFCC_TRANSPORT_ERR_EVT: |
| case NFA_DM_NFCC_TIMEOUT_EVT: |
| { |
| if (dmEvent == NFA_DM_NFCC_TIMEOUT_EVT) |
| ALOGE ("%s: NFA_DM_NFCC_TIMEOUT_EVT; abort", __FUNCTION__); |
| else if (dmEvent == NFA_DM_NFCC_TRANSPORT_ERR_EVT) |
| ALOGE ("%s: NFA_DM_NFCC_TRANSPORT_ERR_EVT; abort", __FUNCTION__); |
| NFA_HciW4eSETransaction_Complete(Wait); |
| nativeNfcTag_abortWaits(); |
| NfcTag::getInstance().abort (); |
| sAbortConnlessWait = true; |
| nativeLlcpConnectionlessSocket_abortWait(); |
| { |
| ALOGD ("%s: aborting sNfaEnableDisablePollingEvent", __FUNCTION__); |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| sNfaEnableDisablePollingEvent.notifyOne(); |
| } |
| { |
| ALOGD ("%s: aborting sNfaEnableEvent", __FUNCTION__); |
| SyncEventGuard guard (sNfaEnableEvent); |
| sNfaEnableEvent.notifyOne(); |
| } |
| { |
| ALOGD ("%s: aborting sNfaDisableEvent", __FUNCTION__); |
| SyncEventGuard guard (sNfaDisableEvent); |
| sNfaDisableEvent.notifyOne(); |
| } |
| sDiscoveryEnabled = false; |
| sPollingEnabled = false; |
| PowerSwitch::getInstance ().abort (); |
| |
| if (!sIsDisabling && sIsNfaEnabled) |
| { |
| EXTNS_Close (); |
| NFA_Disable(FALSE); |
| sIsDisabling = true; |
| } |
| else |
| { |
| sIsNfaEnabled = false; |
| sIsDisabling = false; |
| } |
| PowerSwitch::getInstance ().initialize (PowerSwitch::UNKNOWN_LEVEL); |
| #if(NXP_EXTNS == TRUE) |
| if(eventData->status == NFA_STATUS_FAILED) |
| { |
| ALOGE ("%s: Disabling NFC service", __FUNCTION__); |
| } |
| else |
| { |
| #endif |
| ALOGE ("%s: crash NFC service", __FUNCTION__); |
| ////////////////////////////////////////////// |
| //crash the NFC service process so it can restart automatically |
| abort (); |
| ////////////////////////////////////////////// |
| #if(NXP_EXTNS == TRUE) |
| } |
| #endif |
| } |
| break; |
| |
| case NFA_DM_PWR_MODE_CHANGE_EVT: |
| PowerSwitch::getInstance ().deviceManagementCallback (dmEvent, eventData); |
| break; |
| |
| #if(NXP_EXTNS == TRUE) |
| case NFA_DM_SET_ROUTE_CONFIG_REVT: |
| ALOGD ("%s: NFA_DM_SET_ROUTE_CONFIG_REVT; status=0x%X", |
| __FUNCTION__, eventData->status); |
| if(eventData->status != NFA_STATUS_OK) |
| { |
| ALOGD("AID Routing table configuration Failed!!!"); |
| } |
| else |
| { |
| ALOGD("AID Routing Table configured."); |
| } |
| RoutingManager::getInstance().mLmrtEvent.notifyOne(); |
| break; |
| |
| case NFA_DM_GET_ROUTE_CONFIG_REVT: |
| { |
| RoutingManager::getInstance().processGetRoutingRsp(eventData,sRoutingBuff); |
| if (eventData->status == NFA_STATUS_OK) |
| { |
| SyncEventGuard guard (sNfaGetRoutingEvent); |
| sNfaGetRoutingEvent.notifyOne(); |
| } |
| break; |
| } |
| #if(NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE) |
| case NFA_DM_EE_HCI_DISABLE: |
| { |
| ALOGD("NFA_DM_EE_HCI_DISABLE wait releasing"); |
| sNfceeHciCbDisableEvent.notifyOne(); |
| ALOGD("NFA_DM_EE_HCI_DISABLE wait released"); |
| break; |
| } |
| case NFA_DM_EE_HCI_ENABLE: |
| { |
| ALOGD("NFA_DM_EE_HCI_ENABLE wait releasing"); |
| sNfceeHciCbEnableEvent.notifyOne(); |
| ALOGD("NFA_DM_EE_HCI_ENABLE wait released"); |
| break; |
| } |
| #endif |
| #endif |
| |
| case NFA_DM_EMVCO_PCD_COLLISION_EVT: |
| ALOGD("STATUS_EMVCO_PCD_COLLISION - Multiple card detected"); |
| SecureElement::getInstance().notifyEmvcoMultiCardDetectedListeners(); |
| break; |
| |
| default: |
| ALOGD ("%s: unhandled event", __FUNCTION__); |
| break; |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_sendRawFrame |
| ** |
| ** Description: Send a raw frame. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| static jboolean nfcManager_sendRawFrame (JNIEnv* e, jobject, jbyteArray data) |
| { |
| ScopedByteArrayRO bytes(e, data); |
| uint8_t* buf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0])); |
| size_t bufLen = bytes.size(); |
| tNFA_STATUS status = NFA_SendRawFrame (buf, bufLen, 0); |
| |
| return (status == NFA_STATUS_OK); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_routeAid |
| ** |
| ** Description: Route an AID to an EE |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| static jboolean nfcManager_routeAid (JNIEnv* e, jobject, jbyteArray aid, jint route, jint power, jboolean isprefix) |
| { |
| 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) |
| bool result = RoutingManager::getInstance().addAidRouting(buf, bufLen, route, power, isprefix); |
| #else |
| bool result = RoutingManager::getInstance().addAidRouting(buf, bufLen, route); |
| |
| #endif |
| return result; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_unrouteAid |
| ** |
| ** Description: Remove a AID routing |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| static jboolean nfcManager_unrouteAid (JNIEnv* e, jobject, jbyteArray aid) |
| { |
| ScopedByteArrayRO bytes(e, aid); |
| uint8_t* buf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0])); |
| size_t bufLen = bytes.size(); |
| bool result = RoutingManager::getInstance().removeAidRouting(buf, bufLen); |
| return result; |
| } |
| |
| #if(NXP_EXTNS == TRUE) |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_setRoutingEntry |
| ** |
| ** Description: Set the routing entry in routing table |
| ** e: JVM environment. |
| ** o: Java object. |
| ** type: technology or protocol routing |
| ** 0x01 - Technology |
| ** 0x02 - Protocol |
| ** value: technology /protocol value |
| ** route: routing destination |
| ** 0x00 : Device Host |
| ** 0x01 : ESE |
| ** 0x02 : UICC |
| ** power: power state for the routing entry |
| *******************************************************************************/ |
| |
| static jboolean nfcManager_setRoutingEntry (JNIEnv*, jobject, jint type, jint value, jint route, jint power) |
| { |
| jboolean result = FALSE; |
| |
| result = RoutingManager::getInstance().setRoutingEntry(type, value, route, power); |
| return result; |
| } |
| |
| static jint nfcManager_routeNfcid2 (JNIEnv* e, jobject, jbyteArray nfcid2, jbyteArray syscode, jbyteArray optparam) |
| { |
| ScopedByteArrayRO nfcid2bytes(e, nfcid2); |
| uint8_t* nfcid2buf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&nfcid2bytes[0])); |
| size_t nfcid2Len = 0; |
| if(nfcid2 != NULL) |
| { |
| nfcid2Len = nfcid2bytes.size(); |
| } |
| ScopedByteArrayRO syscodebytes(e, syscode); |
| uint8_t* syscodebuf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&syscodebytes[0])); |
| |
| size_t syscodelen = 0; |
| if(syscode != NULL) |
| { |
| syscodelen = syscodebytes.size(); |
| } |
| /* Will be used in NCI1.1 */ |
| // ScopedByteArrayRO optparambytes(e, optparam); |
| // uint8_t* optparambuf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&optparambytes[0])); |
| // size_t optparamlen = optparambytes.size(); |
| |
| int result = RoutingManager::getInstance().addNfcid2Routing(nfcid2buf, nfcid2Len,syscodebuf,syscodelen, |
| NULL, -1); |
| |
| return result; |
| } |
| |
| static jboolean nfcManager_unrouteNfcid2 (JNIEnv* e, jobject, jbyteArray nfcID2) |
| { |
| |
| ScopedByteArrayRO nfcid2bytes(e, nfcID2); |
| uint8_t* nfcid2buf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&nfcid2bytes[0])); |
| size_t nfcid2Len = 0; |
| if(nfcID2 != NULL) |
| { |
| nfcid2Len = nfcid2bytes.size(); |
| } |
| return RoutingManager::getInstance().removeNfcid2Routing(nfcid2buf); |
| } |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_clearRoutingEntry |
| ** |
| ** Description: Set the routing entry in routing table |
| ** e: JVM environment. |
| ** o: Java object. |
| ** type:technology/protocol/aid clear routing |
| ** |
| *******************************************************************************/ |
| |
| static jboolean nfcManager_clearRoutingEntry (JNIEnv*, jobject, jint type) |
| { |
| jboolean result = FALSE; |
| |
| result = RoutingManager::getInstance().clearRoutingEntry(type); |
| return result; |
| } |
| #endif |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_setDefaultRoute |
| ** |
| ** Description: Set the default route in routing table |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| *******************************************************************************/ |
| |
| static jboolean nfcManager_setDefaultRoute (JNIEnv*, jobject, jint defaultRouteEntry, jint defaultProtoRouteEntry, jint defaultTechRouteEntry) |
| { |
| jboolean result = FALSE; |
| ALOGD ("%s : enter", __FUNCTION__); |
| if (sRfEnabled) |
| { |
| // Stop RF discovery to reconfigure |
| startRfDiscovery(false); |
| } |
| |
| #if (NXP_EXTNS == TRUE) |
| result = RoutingManager::getInstance().setDefaultRoute(defaultRouteEntry, defaultProtoRouteEntry, defaultTechRouteEntry); |
| if(result) |
| result = RoutingManager::getInstance().commitRouting(); |
| else |
| ALOGD ("%s : Commit routing failed ", __FUNCTION__); |
| #else |
| result = RoutingManager::getInstance().setDefaultRouting(); |
| #endif |
| |
| startRfDiscovery(true); |
| ALOGD ("%s : exit", __FUNCTION__); |
| return result; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_getAidTableSize |
| ** Description: Get the maximum supported size for AID routing table. |
| ** |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| *******************************************************************************/ |
| static jint nfcManager_getAidTableSize (JNIEnv*, jobject ) |
| { |
| return NFA_GetAidTableSize(); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_getRemainingAidTableSize |
| ** Description: Get the remaining size of AID routing table. |
| ** |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| *******************************************************************************/ |
| static jint nfcManager_getRemainingAidTableSize (JNIEnv* , jobject ) |
| { |
| return NFA_GetRemainingAidTableSize(); |
| } |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_clearAidTable |
| ** |
| ** Description: Clean all AIDs in routing table |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| *******************************************************************************/ |
| static bool nfcManager_clearAidTable (JNIEnv*, jobject) |
| { |
| return RoutingManager::getInstance().clearAidTable(); |
| } |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doRegisterT3tIdentifier |
| ** |
| ** Description: Registers LF_T3T_IDENTIFIER for NFC-F. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** t3tIdentifier: LF_T3T_IDENTIFIER value (10 or 18 bytes) |
| ** |
| ** Returns: Handle retrieve from RoutingManager. |
| ** |
| *******************************************************************************/ |
| static jint nfcManager_doRegisterT3tIdentifier(JNIEnv* e, jobject, jbyteArray t3tIdentifier) |
| { |
| ALOGD ("%s: enter", __FUNCTION__); |
| ScopedByteArrayRO bytes(e, t3tIdentifier); |
| uint8_t* buf = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0])); |
| size_t bufLen = bytes.size(); |
| int handle = RoutingManager::getInstance().registerT3tIdentifier(buf, bufLen); |
| ALOGD ("%s: exit", __FUNCTION__); |
| return handle; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doDeregisterT3tIdentifier |
| ** |
| ** Description: Deregisters LF_T3T_IDENTIFIER for NFC-F. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** handle: Handle retrieve from libnfc-nci. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doDeregisterT3tIdentifier(JNIEnv*, jobject, jint handle) |
| { |
| ALOGD ("%s: enter", __FUNCTION__); |
| RoutingManager::getInstance().deregisterT3tIdentifier(handle); |
| ALOGD ("%s: exit", __FUNCTION__); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_getLfT3tMax |
| ** |
| ** Description: Returns LF_T3T_MAX value. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: LF_T3T_MAX value. |
| ** |
| *******************************************************************************/ |
| static jint nfcManager_getLfT3tMax(JNIEnv*, jobject) |
| { |
| return sLfT3tMax; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doInitialize |
| ** |
| ** Description: Turn on NFC. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| static jboolean nfcManager_doInitialize (JNIEnv* e, jobject o) |
| { |
| tNFA_MW_VERSION mwVer; |
| gSeDiscoverycount = 0; |
| gActualSeCount = 0; |
| UINT8 configData = 0; |
| UINT8 switchToUiccSlot = 0; |
| unsigned long uicc_active_state = 0; |
| #if(NXP_EXTNS == TRUE) |
| rfActivation = false; |
| tNFA_PMID ven_config_addr[] = {0xA0, 0x07}; |
| #endif |
| ALOGD ("%s: enter; ver=%s nfa=%s NCI_VERSION=0x%02X", |
| __FUNCTION__, nfca_version_string, nfa_version_string, NCI_VERSION); |
| mwVer= NFA_GetMwVersion(); |
| ALOGD ("%s: MW Version: NFC_NCIHALx_AR%X.%x.%x.%x", |
| __FUNCTION__, mwVer.validation, mwVer.android_version, |
| mwVer.major_version,mwVer.minor_version); |
| |
| tNFA_STATUS stat = NFA_STATUS_OK; |
| NfcTag::getInstance ().mNfcDisableinProgress = false; |
| PowerSwitch & powerSwitch = PowerSwitch::getInstance (); |
| #if((NFC_NXP_ESE == TRUE)&&(NXP_EXTNS == TRUE)) |
| struct sigaction sig; |
| |
| memset(&sig, 0, sizeof(struct sigaction)); |
| sig.sa_sigaction = spi_prio_signal_handler; |
| sig.sa_flags = SA_SIGINFO; |
| if(sigaction(SIG_NFC, &sig, NULL) < 0) |
| { |
| ALOGE("Failed to register spi prio session signal handeler"); |
| } |
| #endif |
| if (sIsNfaEnabled) |
| { |
| ALOGD ("%s: already enabled", __FUNCTION__); |
| goto TheEnd; |
| } |
| #if(NXP_EXTNS == TRUE) |
| if(gsNfaPartialEnabled) |
| { |
| ALOGD ("%s: already partial enable calling deinitialize", __FUNCTION__); |
| nfcManager_doPartialDeInitialize(); |
| } |
| #endif |
| if ((signal(SIGABRT, sig_handler) == SIG_ERR) && |
| (signal(SIGSEGV, sig_handler) == SIG_ERR)) |
| { |
| ALOGE("Failed to register signal handeler"); |
| } |
| |
| powerSwitch.initialize (PowerSwitch::FULL_POWER); |
| |
| { |
| unsigned long num = 0; |
| |
| NfcAdaptation& theInstance = NfcAdaptation::GetInstance(); |
| theInstance.Initialize(); //start GKI, NCI task, NFC task |
| |
| { |
| #if(NXP_EXTNS == TRUE) |
| NFA_SetBootMode(NFA_NORMAL_BOOT_MODE); |
| #endif |
| SyncEventGuard guard (sNfaEnableEvent); |
| tHAL_NFC_ENTRY* halFuncEntries = theInstance.GetHalEntryFuncs (); |
| NFA_Init (halFuncEntries); |
| stat = NFA_Enable (nfaDeviceManagementCallback, nfaConnectionCallback); |
| if (stat == NFA_STATUS_OK) |
| { |
| num = initializeGlobalAppLogLevel (); |
| CE_SetTraceLevel (num); |
| LLCP_SetTraceLevel (num); |
| NFC_SetTraceLevel (num); |
| RW_SetTraceLevel (num); |
| NFA_SetTraceLevel (num); |
| NFA_P2pSetTraceLevel (num); |
| sNfaEnableEvent.wait(); //wait for NFA command to finish |
| } |
| EXTNS_Init (nfaDeviceManagementCallback, nfaConnectionCallback); |
| } |
| |
| if (stat == NFA_STATUS_OK ) |
| { |
| //sIsNfaEnabled indicates whether stack started successfully |
| if (sIsNfaEnabled) |
| { |
| SecureElement::getInstance().initialize (getNative(e, o)); |
| //setListenMode(); |
| RoutingManager::getInstance().initialize(getNative(e, o)); |
| HciRFParams::getInstance().initialize (); |
| sIsSecElemSelected = (SecureElement::getInstance().getActualNumEe() - 1 ); |
| sIsSecElemDetected = sIsSecElemSelected; |
| nativeNfcTag_registerNdefTypeHandler (); |
| NfcTag::getInstance().initialize (getNative(e, o)); |
| PeerToPeer::getInstance().initialize (); |
| PeerToPeer::getInstance().handleNfcOnOff (true); |
| |
| #if(NXP_EXTNS == TRUE) |
| ALOGD("gSeDiscoverycount = %d", gSeDiscoverycount); |
| if (NFA_STATUS_OK == GetSwpStausValue()) |
| { |
| if (gSeDiscoverycount < gActualSeCount) |
| { |
| ALOGD("Wait for ESE to discover, gdisc_timeout = %d", gdisc_timeout); |
| SyncEventGuard g(gNfceeDiscCbEvent); |
| if(gNfceeDiscCbEvent.wait(gdisc_timeout) == false) |
| { |
| ALOGE ("%s: timeout waiting for nfcee dis event", __FUNCTION__); |
| } |
| } |
| else |
| { |
| ALOGD("All ESE are discovered "); |
| } |
| } |
| |
| #if(NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE) |
| GetNxpNumValue (NAME_NXP_DUAL_UICC_ENABLE, (void*)&uicc_active_state, sizeof(uicc_active_state)); |
| if(uicc_active_state == 0x01) |
| { |
| dualUiccInfo.uiccActivStat = 0x00; |
| if(SecureElement::getInstance().getEeStatus(UICC_HANDLE)!=NFC_NFCEE_STATUS_REMOVED) |
| { |
| dualUiccInfo.uiccActivStat = (sSelectedUicc & 0x0F); |
| getUiccContext(); |
| } |
| switchToUiccSlot = ((sSelectedUicc & 0x0F) == 0x01) ? 0x02 : 0x01; |
| nfcManager_doSelectUicc(e,o,switchToUiccSlot); |
| if(SecureElement::getInstance().getEeStatus(UICC_HANDLE)!=NFC_NFCEE_STATUS_REMOVED) |
| { |
| dualUiccInfo.uiccActivStat |= (sSelectedUicc & 0x0F); |
| } |
| uiccEventTimer.set (1, notifyUiccEvent); |
| } |
| else |
| #endif |
| checkforNfceeConfig(); |
| #endif |
| #if((NFC_NXP_ESE_VER == JCOP_VER_3_3)&& (NXP_EXTNS == TRUE)) |
| if(isNxpConfigModified()) |
| { |
| ALOGD("Set JCOP CP Timeout"); |
| SecureElement::getInstance().setCPTimeout(); |
| } |
| else |
| { |
| ALOGD("No Need to set JCOP CP Timeout "); |
| } |
| #endif |
| ///////////////////////////////////////////////////////////////////////////////// |
| // Add extra configuration here (work-arounds, etc.) |
| #if(NXP_EXTNS == TRUE) |
| set_transcation_stat(false); |
| pendingScreenState = false; |
| { |
| SyncEventGuard guard (android::sNfaGetConfigEvent); |
| stat = NFA_GetConfig(0x01,ven_config_addr); |
| if(stat == NFA_STATUS_OK) |
| { |
| android::sNfaGetConfigEvent.wait(); |
| } |
| /*sCurrentConfigLen should be > 4 (num_tlv:1 + addr:2 + value:1) and |
| *pos 4 gives the current eeprom value*/ |
| if((sCurrentConfigLen > 4)&&(sConfig[4] == 0x03)) |
| { |
| ALOGD ("%s: No need to update VEN_CONFIG. Already set to 0x%02x", __FUNCTION__,sConfig[4]); |
| } |
| else |
| { |
| SetVenConfigValue(NFC_MODE_ON); |
| if (stat != NFA_STATUS_OK) |
| { |
| ALOGE ("%s: fail enable SetVenConfigValue; error=0x%X", __FUNCTION__, stat); |
| } |
| } |
| gGeneralPowershutDown = 0; |
| } |
| if(gIsDtaEnabled == true){ |
| configData = 0x01; /**< Poll NFC-DEP : Highest Available Bit Rates */ |
| NFA_SetConfig(NFC_PMID_BITR_NFC_DEP, sizeof(UINT8), &configData); |
| configData = 0x0B; /**< Listen NFC-DEP : Waiting Time */ |
| NFA_SetConfig(NFC_PMID_WT, sizeof(UINT8), &configData); |
| configData = 0x0F; /**< Specific Parameters for NFC-DEP RF Interface */ |
| NFA_SetConfig(NFC_PMID_NFC_DEP_OP, sizeof(UINT8), &configData); |
| } |
| |
| #endif |
| struct nfc_jni_native_data *nat = getNative(e, o); |
| |
| if ( nat ) |
| { |
| if (GetNumValue(NAME_POLLING_TECH_MASK, &num, sizeof(num))) |
| nat->tech_mask = num; |
| else |
| nat->tech_mask = DEFAULT_TECH_MASK; |
| ALOGD ("%s: tag polling tech mask=0x%X", __FUNCTION__, nat->tech_mask); |
| } |
| |
| // if this value exists, set polling interval. |
| if (GetNumValue(NAME_NFA_DM_DISC_DURATION_POLL, &num, sizeof(num))) |
| nat->discovery_duration = num; |
| else |
| nat->discovery_duration = DEFAULT_DISCOVERY_DURATION; |
| #if(NXP_EXTNS == TRUE) |
| discDuration = nat->discovery_duration; |
| #endif |
| NFA_SetRfDiscoveryDuration(nat->discovery_duration); |
| |
| // get LF_T3T_MAX |
| { |
| SyncEventGuard guard (sNfaGetConfigEvent); |
| tNFA_PMID configParam[1] = {NCI_PARAM_ID_LF_T3T_MAX}; |
| stat = NFA_GetConfig(1, configParam); |
| if (stat == NFA_STATUS_OK) |
| { |
| sNfaGetConfigEvent.wait (); |
| if (sCurrentConfigLen >= 4 || sConfig[1] == NCI_PARAM_ID_LF_T3T_MAX) { |
| ALOGD("%s: lfT3tMax=%d", __FUNCTION__, sConfig[3]); |
| sLfT3tMax = sConfig[3]; |
| } |
| } |
| } |
| if (GetNxpNumValue (NAME_NXP_CE_ROUTE_STRICT_DISABLE, (void*)&num, sizeof(num)) == false) |
| num = 0x01; // default value |
| |
| //TODO: Check this in L_OSP_EXT[PN547C2] |
| // NFA_SetCEStrictDisable(num); |
| RoutingManager::getInstance().setCeRouteStrictDisable(num); |
| |
| #if(NXP_EXTNS != TRUE) |
| // Do custom NFCA startup configuration. |
| doStartupConfig(); |
| #endif |
| goto TheEnd; |
| } |
| } |
| |
| ALOGE ("%s: fail nfa enable; error=0x%X", __FUNCTION__, stat); |
| |
| if (sIsNfaEnabled) |
| { |
| EXTNS_Close (); |
| stat = NFA_Disable (FALSE /* ungraceful */); |
| } |
| |
| theInstance.Finalize(); |
| } |
| |
| TheEnd: |
| if (sIsNfaEnabled) |
| PowerSwitch::getInstance ().setLevel (PowerSwitch::LOW_POWER); |
| ALOGD ("%s: exit", __FUNCTION__); |
| #if (NXP_EXTNS == TRUE) |
| if (isNxpConfigModified()) |
| { |
| updateNxpConfigTimestamp(); |
| } |
| #endif |
| return sIsNfaEnabled ? JNI_TRUE : JNI_FALSE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doEnableDtaMode |
| ** |
| ** Description: Enable the DTA mode in NFC service. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doEnableDtaMode (JNIEnv* e, jobject o) |
| { |
| gIsDtaEnabled = true; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doDisableDtaMode |
| ** |
| ** Description: Disable the DTA mode in NFC service. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doDisableDtaMode(JNIEnv* e, jobject o) |
| { |
| gIsDtaEnabled = false; |
| } |
| |
| #if(NXP_EXTNS == TRUE) |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_Enablep2p |
| ** |
| ** Description: enable P2P |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None. |
| ** |
| *******************************************************************************/ |
| static void nfcManager_Enablep2p(JNIEnv* e, jobject o, jboolean p2pFlag) |
| { |
| ALOGD ("Enter :%s p2pFlag = %d", __FUNCTION__, p2pFlag); |
| /* if another transaction is already in progress, store this request */ |
| if(get_transcation_stat() == true) |
| { |
| ALOGD("Transcation is in progress store the request"); |
| set_last_request(3, NULL); |
| transaction_data.discovery_params.enable_p2p = p2pFlag; |
| return; |
| } |
| if(sRfEnabled && p2pFlag) |
| { |
| /* Stop discovery if already ON */ |
| startRfDiscovery(false); |
| } |
| |
| /* if already Polling, change to listen Mode */ |
| if (sPollingEnabled) |
| { |
| if (p2pFlag && !sP2pEnabled) |
| { |
| /* enable P2P listening, if we were not already listening */ |
| sP2pEnabled = true; |
| PeerToPeer::getInstance().enableP2pListening (true); |
| } |
| } |
| /* Beam ON - Discovery ON */ |
| if(p2pFlag) |
| { |
| NFA_ResumeP2p(); |
| startRfDiscovery (p2pFlag); |
| } |
| } |
| #endif |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_enableDiscovery |
| ** |
| ** Description: Start polling and listening for devices. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** technologies_mask: the bitmask of technologies for which to enable discovery |
| ** enable_lptd: whether to enable low power polling (default: false) |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfcManager_enableDiscovery (JNIEnv* e, jobject o, jint technologies_mask, |
| jboolean enable_lptd, jboolean reader_mode, jboolean enable_host_routing, jboolean enable_p2p, |
| jboolean restart) |
| { |
| tNFA_STATUS status = NFA_STATUS_OK; |
| tNFA_TECHNOLOGY_MASK tech_mask = DEFAULT_TECH_MASK; |
| unsigned long num = 0; |
| unsigned long p2p_listen_mask = 0; |
| tNFA_HANDLE handle = NFA_HANDLE_INVALID; |
| struct nfc_jni_native_data *nat = NULL; |
| |
| tNFA_STATUS stat = NFA_STATUS_OK; |
| |
| #if(NFC_NXP_ESE == TRUE && ((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551))) |
| tNFA_TECHNOLOGY_MASK etsi_tech_mask = 0; |
| #endif |
| if(e == NULL && o == NULL) |
| { |
| nat = transaction_data.transaction_nat; |
| } |
| else |
| { |
| nat = getNative(e, o); |
| } |
| |
| if(get_transcation_stat() == true) |
| { |
| ALOGD("Transcation is in progress store the requst"); |
| set_last_request(1, nat); |
| transaction_data.discovery_params.technologies_mask = technologies_mask; |
| transaction_data.discovery_params.enable_lptd = enable_lptd; |
| transaction_data.discovery_params.reader_mode = reader_mode; |
| transaction_data.discovery_params.enable_host_routing = enable_host_routing; |
| transaction_data.discovery_params.enable_p2p = enable_p2p; |
| transaction_data.discovery_params.restart = restart; |
| return; |
| } |
| |
| #if(NFC_NXP_ESE == TRUE && ((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551))) |
| if(RoutingManager::getInstance().getEtsiReaederState() == STATE_SE_RDR_MODE_STARTED) |
| { |
| ALOGD ("%s: enter STATE_SE_RDR_MODE_START_CONFIG", __FUNCTION__); |
| Rdr_req_ntf_info_t mSwp_info = RoutingManager::getInstance().getSwpRrdReqInfo(); |
| { |
| SyncEventGuard guard (android::sNfaEnableDisablePollingEvent); |
| ALOGD ("%s: disable polling", __FUNCTION__); |
| status = NFA_DisablePolling (); |
| if (status == NFA_STATUS_OK) |
| { |
| android::sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_DISABLED_EVT |
| } |
| else |
| { |
| ALOGE ("%s: fail disable polling; error=0x%X", __FUNCTION__, status); |
| } |
| |
| } |
| |
| if(mSwp_info.swp_rd_req_info.tech_mask & NFA_TECHNOLOGY_MASK_A) |
| etsi_tech_mask |= NFA_TECHNOLOGY_MASK_A; |
| if(mSwp_info.swp_rd_req_info.tech_mask & NFA_TECHNOLOGY_MASK_B) |
| etsi_tech_mask |= NFA_TECHNOLOGY_MASK_B; |
| |
| |
| { |
| SyncEventGuard guard (android::sNfaEnableDisablePollingEvent); |
| status = NFA_EnablePolling (etsi_tech_mask); |
| if (status == NFA_STATUS_OK) |
| { |
| ALOGD ("%s: wait for enable event", __FUNCTION__); |
| android::sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_ENABLED_EVT |
| } |
| else |
| { |
| ALOGE ("%s: fail enable polling; error=0x%X", __FUNCTION__, status); |
| } |
| } |
| startRfDiscovery (true); |
| set_transcation_stat(true); |
| goto TheEnd; |
| } |
| #endif |
| |
| if (technologies_mask == -1 && nat) |
| tech_mask = (tNFA_TECHNOLOGY_MASK)nat->tech_mask; |
| else if (technologies_mask != -1) |
| tech_mask = (tNFA_TECHNOLOGY_MASK) technologies_mask; |
| ALOGD ("%s: enter; tech_mask = %02x", __FUNCTION__, tech_mask); |
| |
| if( sDiscoveryEnabled && !restart) |
| { |
| ALOGE ("%s: already discovering", __FUNCTION__); |
| return; |
| } |
| |
| ALOGD ("%s: sIsSecElemSelected=%u", __FUNCTION__, sIsSecElemSelected); |
| acquireRfInterfaceMutexLock(); |
| PowerSwitch::getInstance ().setLevel (PowerSwitch::FULL_POWER); |
| |
| if (sRfEnabled) { |
| // Stop RF discovery to reconfigure |
| startRfDiscovery(false); |
| } |
| |
| if ((GetNumValue(NAME_UICC_LISTEN_TECH_MASK, &num, sizeof(num)))) |
| { |
| ALOGE ("%s:UICC_LISTEN_MASK=0x0%d;", __FUNCTION__, num); |
| } |
| |
| |
| // Check polling configuration |
| if (tech_mask != 0) |
| { |
| ALOGD ("%s: Disable p2pListening", __FUNCTION__); |
| PeerToPeer::getInstance().enableP2pListening (false); |
| stopPolling_rfDiscoveryDisabled(); |
| enableDisableLptd(enable_lptd); |
| startPolling_rfDiscoveryDisabled(tech_mask); |
| |
| // Start P2P listening if tag polling was enabled |
| if (sPollingEnabled) |
| { |
| ALOGD ("%s: Enable p2pListening", __FUNCTION__); |
| |
| if (enable_p2p && !sP2pEnabled) { |
| sP2pEnabled = true; |
| PeerToPeer::getInstance().enableP2pListening (true); |
| NFA_ResumeP2p(); |
| } else if (!enable_p2p && sP2pEnabled) { |
| sP2pEnabled = false; |
| PeerToPeer::getInstance().enableP2pListening (false); |
| NFA_PauseP2p(); |
| } |
| |
| if (reader_mode && !sReaderModeEnabled) |
| { |
| sReaderModeEnabled = true; |
| #if(NXP_EXTNS == TRUE) |
| NFA_SetReaderMode(true,0); |
| /*Send the state of readmode flag to Hal using proprietary command*/ |
| sProprietaryCmdBuf[3]=0x01; |
| status |= NFA_SendNxpNciCommand(sizeof(sProprietaryCmdBuf),sProprietaryCmdBuf,NxpResponsePropCmd_Cb); |
| if (status == NFA_STATUS_OK) |
| { |
| SyncEventGuard guard (sNfaNxpNtfEvent); |
| sNfaNxpNtfEvent.wait(500); //wait for callback |
| } |
| else |
| { |
| ALOGE ("%s: Failed NFA_SendNxpNciCommand", __FUNCTION__); |
| } |
| ALOGD ("%s: FRM Enable", __FUNCTION__); |
| #endif |
| NFA_DisableListening(); |
| #if(NXP_EXTNS == TRUE) |
| sTechMask = tech_mask; |
| |
| discDuration = READER_MODE_DISCOVERY_DURATION; |
| #endif |
| NFA_SetRfDiscoveryDuration(READER_MODE_DISCOVERY_DURATION); |
| } |
| else if (!reader_mode && sReaderModeEnabled) |
| { |
| struct nfc_jni_native_data *nat = getNative(e, o); |
| sReaderModeEnabled = false; |
| #if(NXP_EXTNS == TRUE) |
| NFA_SetReaderMode(false,0); |
| gFelicaReaderState = STATE_IDLE; |
| /*Send the state of readmode flag to Hal using proprietary command*/ |
| sProprietaryCmdBuf[3]=0x00; |
| status |= NFA_SendNxpNciCommand(sizeof(sProprietaryCmdBuf),sProprietaryCmdBuf,NxpResponsePropCmd_Cb); |
| if (status == NFA_STATUS_OK) |
| { |
| SyncEventGuard guard (sNfaNxpNtfEvent); |
| sNfaNxpNtfEvent.wait(500); //wait for callback |
| } |
| else |
| { |
| ALOGE ("%s: Failed NFA_SendNxpNciCommand", __FUNCTION__); |
| } |
| ALOGD ("%s: FRM Disable", __FUNCTION__); |
| #endif |
| NFA_EnableListening(); |
| #if(NXP_EXTNS == TRUE) |
| discDuration = nat->discovery_duration; |
| #endif |
| NFA_SetRfDiscoveryDuration(nat->discovery_duration); |
| } |
| else |
| { |
| { |
| ALOGD ("%s: restart UICC listen mode (%02X)", __FUNCTION__, (num & 0xC7)); |
| handle = SecureElement::getInstance().getEseHandleFromGenericId(SecureElement::UICC_ID); |
| SyncEventGuard guard (SecureElement::getInstance().mUiccListenEvent); |
| stat = NFA_CeConfigureUiccListenTech (handle, 0x00); |
| if(stat == NFA_STATUS_OK) |
| { |
| SecureElement::getInstance().mUiccListenEvent.wait (); |
| } |
| else |
| ALOGE ("fail to stop UICC listen"); |
| } |
| { |
| SyncEventGuard guard (SecureElement::getInstance().mUiccListenEvent); |
| stat = NFA_CeConfigureUiccListenTech (handle, (num & 0xC7)); |
| if(stat == NFA_STATUS_OK) |
| { |
| SecureElement::getInstance().mUiccListenEvent.wait (); |
| } |
| else |
| ALOGE ("fail to start UICC listen"); |
| } |
| } |
| } |
| } |
| else |
| { |
| // No technologies configured, stop polling |
| stopPolling_rfDiscoveryDisabled(); |
| } |
| //FIXME: Added in L, causing routing table update for screen on/off. Need to check. |
| #if 0 |
| // Check listen configuration |
| if (enable_host_routing) |
| { |
| RoutingManager::getInstance().enableRoutingToHost(); |
| RoutingManager::getInstance().commitRouting(); |
| } |
| else |
| { |
| RoutingManager::getInstance().disableRoutingToHost(); |
| RoutingManager::getInstance().commitRouting(); |
| } |
| #endif |
| // Start P2P listening if tag polling was enabled or the mask was 0. |
| if (sDiscoveryEnabled || (tech_mask == 0)) |
| { |
| handle = SecureElement::getInstance().getEseHandleFromGenericId(SecureElement::UICC_ID); |
| |
| #if(NXP_EXTNS == TRUE) |
| if((getScreenState() == NFA_SCREEN_STATE_UNLOCKED) || sProvisionMode) |
| { |
| ALOGD ("%s: Enable p2pListening", __FUNCTION__); |
| PeerToPeer::getInstance().enableP2pListening (true); |
| } |
| else |
| { |
| ALOGD ("%s: Disable p2pListening", __FUNCTION__); |
| PeerToPeer::getInstance().enableP2pListening (false); |
| } |
| #endif |
| |
| { |
| SyncEventGuard guard (SecureElement::getInstance().mUiccListenEvent); |
| stat = NFA_CeConfigureUiccListenTech (handle, 0x00); |
| if(stat == NFA_STATUS_OK) |
| { |
| SecureElement::getInstance().mUiccListenEvent.wait (); |
| } |
| else |
| ALOGE ("fail to start UICC listen"); |
| } |
| |
| { |
| SyncEventGuard guard (SecureElement::getInstance().mUiccListenEvent); |
| stat = NFA_CeConfigureUiccListenTech (handle, (num & 0xC7)); |
| if(stat == NFA_STATUS_OK) |
| { |
| SecureElement::getInstance().mUiccListenEvent.wait (); |
| } |
| else |
| ALOGE ("fail to start UICC listen"); |
| } |
| } |
| // Actually start discovery. |
| startRfDiscovery (true); |
| sDiscoveryEnabled = true; |
| |
| PowerSwitch::getInstance ().setModeOn (PowerSwitch::DISCOVERY); |
| releaseRfInterfaceMutexLock(); |
| |
| #if(NFC_NXP_ESE == TRUE && ((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551))) |
| TheEnd: |
| #endif |
| |
| ALOGD ("%s: exit", __FUNCTION__); |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_disableDiscovery |
| ** |
| ** Description: Stop polling and listening for devices. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void nfcManager_disableDiscovery (JNIEnv* e, jobject o) |
| { |
| (void)e; |
| (void)o; |
| tNFA_STATUS status = NFA_STATUS_OK; |
| unsigned long num = 0; |
| unsigned long p2p_listen_mask =0; |
| tNFA_HANDLE handle = NFA_HANDLE_INVALID; |
| ALOGD ("%s: enter;", __FUNCTION__); |
| |
| if(get_transcation_stat() == true) |
| { |
| ALOGD("Transcatin is in progress store the request"); |
| set_last_request(2, NULL); |
| return; |
| } |
| |
| #if(NFC_NXP_ESE == TRUE && ((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551))) |
| if(RoutingManager::getInstance().getEtsiReaederState() == STATE_SE_RDR_MODE_START_IN_PROGRESS) |
| { |
| Rdr_req_ntf_info_t mSwp_info = RoutingManager::getInstance().getSwpRrdReqInfo(); |
| // if(android::isDiscoveryStarted() == true) |
| |
| android::startRfDiscovery(false); |
| |
| PeerToPeer::getInstance().enableP2pListening (false); |
| { |
| SyncEventGuard guard ( SecureElement::getInstance().mUiccListenEvent); |
| status = NFA_CeConfigureUiccListenTech (mSwp_info.swp_rd_req_info.src, 0x00); |
| if (status == NFA_STATUS_OK) |
| { |
| SecureElement::getInstance().mUiccListenEvent.wait (); |
| } |
| else |
| { |
| ALOGE ("fail to stop listen"); |
| } |
| } |
| |
| goto TheEnd; |
| } |
| else if(RoutingManager::getInstance().getEtsiReaederState() == STATE_SE_RDR_MODE_STOP_IN_PROGRESS) |
| { |
| android::startRfDiscovery(false); |
| goto TheEnd; |
| } |
| #endif |
| |
| pn544InteropAbortNow (); |
| if (sDiscoveryEnabled == false) |
| { |
| ALOGD ("%s: already disabled", __FUNCTION__); |
| goto TheEnd; |
| } |
| acquireRfInterfaceMutexLock(); |
| // Stop RF Discovery. |
| startRfDiscovery (false); |
| |
| if (sPollingEnabled) |
| status = stopPolling_rfDiscoveryDisabled(); |
| sDiscoveryEnabled = false; |
| |
| if ((GetNumValue(NAME_UICC_LISTEN_TECH_MASK, &num, sizeof(num)))) |
| { |
| ALOGE ("%s:UICC_LISTEN_MASK=0x0%d;", __FUNCTION__, num); |
| } |
| if ((GetNumValue("P2P_LISTEN_TECH_MASK", &p2p_listen_mask, sizeof(p2p_listen_mask)))) |
| { |
| ALOGE ("%s:P2P_LISTEN_MASK=0x0%d;", __FUNCTION__, p2p_listen_mask); |
| } |
| |
| PeerToPeer::getInstance().enableP2pListening (false); |
| #if 0 //EEPROM Init optimization |
| { |
| UINT8 sel_info = 0x20; |
| UINT8 lf_protocol = 0x00; |
| { |
| SyncEventGuard guard (android::sNfaSetConfigEvent); |
| status = NFA_SetConfig(NCI_PARAM_ID_LA_SEL_INFO, sizeof(UINT8), &sel_info); |
| if (status == NFA_STATUS_OK) |
| sNfaSetConfigEvent.wait (); |
| else |
| ALOGE ("%s: Could not able to configure sel_info", __FUNCTION__); |
| } |
| |
| { |
| SyncEventGuard guard (android::sNfaSetConfigEvent); |
| status = NFA_SetConfig(NCI_PARAM_ID_LF_PROTOCOL, sizeof(UINT8), &lf_protocol); |
| if (status == NFA_STATUS_OK) |
| sNfaSetConfigEvent.wait (); |
| else |
| ALOGE ("%s: Could not able to configure lf_protocol", __FUNCTION__); |
| } |
| } |
| |
| #endif //EEPROM Init optimization |
| /* |
| { |
| StoreScreenState(1); |
| status = SetScreenState(1); |
| if (status != NFA_STATUS_OK) |
| { |
| ALOGE ("%s: fail disable SetScreenState; error=0x%X", __FUNCTION__, status); |
| } |
| }*/ |
| |
| //To support card emulation in screen off state. |
| // if (SecureElement::getInstance().isBusy() == true ) |
| if (sIsSecElemSelected /*&& (sHCEEnabled == false )*/) |
| { |
| handle = SecureElement::getInstance().getEseHandleFromGenericId(SecureElement::UICC_ID); |
| { |
| SyncEventGuard guard (SecureElement::getInstance().mUiccListenEvent); |
| status = NFA_CeConfigureUiccListenTech (handle, 0x00); |
| if (status == NFA_STATUS_OK) |
| { |
| SecureElement::getInstance().mUiccListenEvent.wait (); |
| } |
| else |
| ALOGE ("fail to start UICC listen"); |
| } |
| |
| { |
| SyncEventGuard guard (SecureElement::getInstance().mUiccListenEvent); |
| status = NFA_CeConfigureUiccListenTech (handle, (num & 0x07)); |
| if(status == NFA_STATUS_OK) |
| { |
| SecureElement::getInstance().mUiccListenEvent.wait (); |
| } |
| else |
| ALOGE ("fail to start UICC listen"); |
| } |
| #if 0 |
| { |
| ALOGE ("%s: configure lf_protocol", __FUNCTION__); |
| UINT8 lf_protocol = 0x00; |
| |
| SyncEventGuard guard (android::sNfaSetConfigEvent); |
| status = NFA_SetConfig(NCI_PARAM_ID_LF_PROTOCOL, sizeof(UINT8), &lf_protocol); |
| if (status == NFA_STATUS_OK) |
| sNfaSetConfigEvent.wait (); |
| else |
| ALOGE ("%s: Could not able to configure lf_protocol", __FUNCTION__); |
| } |
| { |
| ALOGE ("%s: configure sel_info", __FUNCTION__); |
| |
| UINT8 sel_info = 0x00; |
| SyncEventGuard guard (android::sNfaSetConfigEvent); |
| status = NFA_SetConfig(NCI_PARAM_ID_LA_SEL_INFO, sizeof(UINT8), &sel_info); |
| if (status == NFA_STATUS_OK) |
| sNfaSetConfigEvent.wait (); |
| else |
| ALOGE ("%s: Could not able to configure sel_info", __FUNCTION__); |
| } |
| |
| #endif |
| //PeerToPeer::getInstance().setP2pListenMask(p2p_listen_mask & 0x05); |
| //PeerToPeer::getInstance().enableP2pListening (true); |
| PeerToPeer::getInstance().enableP2pListening (false); |
| startRfDiscovery (true); |
| } |
| |
| sP2pEnabled = false; |
| //if nothing is active after this, then tell the controller to power down |
| //if (! PowerSwitch::getInstance ().setModeOff (PowerSwitch::DISCOVERY)) |
| //PowerSwitch::getInstance ().setLevel (PowerSwitch::LOW_POWER); |
| |
| // We may have had RF field notifications that did not cause |
| // any activate/deactive events. For example, caused by wireless |
| // charging orbs. Those may cause us to go to sleep while the last |
| // field event was indicating a field. To prevent sticking in that |
| // state, always reset the rf field status when we disable discovery. |
| SecureElement::getInstance().resetRfFieldStatus(); |
| releaseRfInterfaceMutexLock(); |
| TheEnd: |
| ALOGD ("%s: exit", __FUNCTION__); |
| } |
| |
| void enableDisableLongGuardTime (bool enable) |
| { |
| // TODO |
| // This is basically a work-around for an issue |
| // in BCM20791B5: if a reader is configured as follows |
| // 1) Only polls for NFC-A |
| // 2) Cuts field between polls |
| // 3) Has a short guard time (~5ms) |
| // the BCM20791B5 doesn't wake up when such a reader |
| // is polling it. Unfortunately the default reader |
| // mode configuration on Android matches those |
| // criteria. To avoid the issue, increase the guard |
| // time when in reader mode. |
| // |
| // Proper fix is firmware patch for B5 controllers. |
| SyncEventGuard guard(sNfaSetConfigEvent); |
| tNFA_STATUS stat = NFA_SetConfig(NCI_PARAM_ID_T1T_RDR_ONLY, 2, |
| enable ? sLongGuardTime : sDefaultGuardTime); |
| if (stat == NFA_STATUS_OK) |
| sNfaSetConfigEvent.wait (); |
| else |
| ALOGE("%s: Could not configure longer guard time", __FUNCTION__); |
| return; |
| } |
| |
| void enableDisableLptd (bool enable) |
| { |
| // This method is *NOT* thread-safe. Right now |
| // it is only called from the same thread so it's |
| // not an issue. |
| static bool sCheckedLptd = false; |
| static bool sHasLptd = false; |
| |
| tNFA_STATUS stat = NFA_STATUS_OK; |
| if (!sCheckedLptd) |
| { |
| sCheckedLptd = true; |
| SyncEventGuard guard (sNfaGetConfigEvent); |
| tNFA_PMID configParam[1] = {NCI_PARAM_ID_TAGSNIFF_CFG}; |
| stat = NFA_GetConfig(1, configParam); |
| if (stat != NFA_STATUS_OK) |
| { |
| ALOGE("%s: NFA_GetConfig failed", __FUNCTION__); |
| return; |
| } |
| sNfaGetConfigEvent.wait (); |
| if (sCurrentConfigLen < 4 || sConfig[1] != NCI_PARAM_ID_TAGSNIFF_CFG) { |
| ALOGE("%s: Config TLV length %d returned is too short", __FUNCTION__, |
| sCurrentConfigLen); |
| return; |
| } |
| if (sConfig[3] == 0) { |
| ALOGE("%s: LPTD is disabled, not enabling in current config", __FUNCTION__); |
| return; |
| } |
| sHasLptd = true; |
| } |
| // Bail if we checked and didn't find any LPTD config before |
| if (!sHasLptd) return; |
| UINT8 enable_byte = enable ? 0x01 : 0x00; |
| |
| SyncEventGuard guard(sNfaSetConfigEvent); |
| |
| stat = NFA_SetConfig(NCI_PARAM_ID_TAGSNIFF_CFG, 1, &enable_byte); |
| if (stat == NFA_STATUS_OK) |
| sNfaSetConfigEvent.wait (); |
| else |
| ALOGE("%s: Could not configure LPTD feature", __FUNCTION__); |
| return; |
| } |
| |
| void setUiccIdleTimeout (bool enable) |
| { |
| // This method is *NOT* thread-safe. Right now |
| // it is only called from the same thread so it's |
| // not an issue. |
| tNFA_STATUS stat = NFA_STATUS_OK; |
| UINT8 swp_cfg_byte0 = 0x00; |
| { |
| SyncEventGuard guard (sNfaGetConfigEvent); |
| tNFA_PMID configParam[1] = {0xC2}; |
| stat = NFA_GetConfig(1, configParam); |
| if (stat != NFA_STATUS_OK) |
| { |
| ALOGE("%s: NFA_GetConfig failed", __FUNCTION__); |
| return; |
| } |
| sNfaGetConfigEvent.wait (); |
| if (sCurrentConfigLen < 4 || sConfig[1] != 0xC2) { |
| ALOGE("%s: Config TLV length %d returned is too short", __FUNCTION__, |
| sCurrentConfigLen); |
| return; |
| } |
| swp_cfg_byte0 = sConfig[3]; |
| } |
| SyncEventGuard guard(sNfaSetConfigEvent); |
| if (enable) |
| swp_cfg_byte0 |= 0x01; |
| else |
| swp_cfg_byte0 &= ~0x01; |
| |
| stat = NFA_SetConfig(0xC2, 1, &swp_cfg_byte0); |
| if (stat == NFA_STATUS_OK) |
| sNfaSetConfigEvent.wait (); |
| else |
| ALOGE("%s: Could not configure UICC idle timeout feature", __FUNCTION__); |
| return; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doCreateLlcpServiceSocket |
| ** |
| ** Description: Create a new LLCP server socket. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** nSap: Service access point. |
| ** sn: Service name |
| ** miu: Maximum information unit. |
| ** rw: Receive window size. |
| ** linearBufferLength: Max buffer size. |
| ** |
| ** Returns: NativeLlcpServiceSocket Java object. |
| ** |
| *******************************************************************************/ |
| static jobject nfcManager_doCreateLlcpServiceSocket (JNIEnv* e, jobject, jint nSap, jstring sn, jint miu, jint rw, jint linearBufferLength) |
| { |
| PeerToPeer::tJNI_HANDLE jniHandle = PeerToPeer::getInstance().getNewJniHandle (); |
| |
| ScopedUtfChars serviceName(e, sn); |
| if (serviceName.c_str() == NULL) |
| { |
| ALOGE ("%s: service name can not be null error", __FUNCTION__); |
| return NULL; |
| } |
| |
| ALOGD ("%s: enter: sap=%i; name=%s; miu=%i; rw=%i; buffLen=%i", __FUNCTION__, nSap, serviceName.c_str(), miu, rw, linearBufferLength); |
| |
| /* Create new NativeLlcpServiceSocket object */ |
| jobject serviceSocket = NULL; |
| if (nfc_jni_cache_object_local(e, gNativeLlcpServiceSocketClassName, &(serviceSocket)) == -1) |
| { |
| ALOGE ("%s: Llcp socket object creation error", __FUNCTION__); |
| return NULL; |
| } |
| |
| /* Get NativeLlcpServiceSocket class object */ |
| ScopedLocalRef<jclass> clsNativeLlcpServiceSocket(e, e->GetObjectClass(serviceSocket)); |
| if (e->ExceptionCheck()) |
| { |
| e->ExceptionClear(); |
| ALOGE("%s: Llcp Socket get object class error", __FUNCTION__); |
| return NULL; |
| } |
| |
| if (!PeerToPeer::getInstance().registerServer (jniHandle, serviceName.c_str())) |
| { |
| ALOGE("%s: RegisterServer error", __FUNCTION__); |
| return NULL; |
| } |
| |
| jfieldID f; |
| |
| /* Set socket handle to be the same as the NfaHandle*/ |
| f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mHandle", "I"); |
| e->SetIntField(serviceSocket, f, (jint) jniHandle); |
| ALOGD ("%s: socket Handle = 0x%X", __FUNCTION__, jniHandle); |
| |
| /* Set socket linear buffer length */ |
| f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mLocalLinearBufferLength", "I"); |
| e->SetIntField(serviceSocket, f,(jint)linearBufferLength); |
| ALOGD ("%s: buffer length = %d", __FUNCTION__, linearBufferLength); |
| |
| /* Set socket MIU */ |
| f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mLocalMiu", "I"); |
| e->SetIntField(serviceSocket, f,(jint)miu); |
| ALOGD ("%s: MIU = %d", __FUNCTION__, miu); |
| |
| /* Set socket RW */ |
| f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mLocalRw", "I"); |
| e->SetIntField(serviceSocket, f,(jint)rw); |
| ALOGD ("%s: RW = %d", __FUNCTION__, rw); |
| |
| sLastError = 0; |
| ALOGD ("%s: exit", __FUNCTION__); |
| return serviceSocket; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doGetLastError |
| ** |
| ** Description: Get the last error code. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: Last error code. |
| ** |
| *******************************************************************************/ |
| static jint nfcManager_doGetLastError(JNIEnv*, jobject) |
| { |
| ALOGD ("%s: last error=%i", __FUNCTION__, sLastError); |
| return sLastError; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doDeinitialize |
| ** |
| ** Description: Turn off NFC. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| static jboolean nfcManager_doDeinitialize (JNIEnv*, jobject) |
| { |
| ALOGD ("%s: enter", __FUNCTION__); |
| sIsDisabling = true; |
| #if(NXP_EXTNS == TRUE) |
| rfActivation = false; |
| #endif |
| doDwpChannel_ForceExit(); |
| NFA_HciW4eSETransaction_Complete(Wait); |
| pn544InteropAbortNow (); |
| |
| RoutingManager::getInstance().onNfccShutdown(); |
| SecureElement::getInstance().finalize (); |
| PowerSwitch::getInstance ().initialize (PowerSwitch::UNKNOWN_LEVEL); |
| //Stop the discovery before calling NFA_Disable. |
| if(sRfEnabled) |
| startRfDiscovery(false); |
| tNFA_STATUS stat = NFA_STATUS_OK; |
| |
| if (sIsNfaEnabled) |
| { |
| stat = SetVenConfigValue(NFC_MODE_OFF); |
| if (stat != NFA_STATUS_OK) |
| { |
| ALOGE ("%s: fail enable SetVenConfigValue; error=0x%X", __FUNCTION__, stat); |
| } |
| SyncEventGuard guard (sNfaDisableEvent); |
| EXTNS_Close (); |
| stat = NFA_Disable (TRUE /* graceful */); |
| if (stat == NFA_STATUS_OK) |
| { |
| ALOGD ("%s: wait for completion", __FUNCTION__); |
| sNfaDisableEvent.wait (); //wait for NFA command to finish |
| PeerToPeer::getInstance ().handleNfcOnOff (false); |
| } |
| else |
| { |
| ALOGE ("%s: fail disable; error=0x%X", __FUNCTION__, stat); |
| } |
| } |
| NfcTag::getInstance ().mNfcDisableinProgress = true; |
| nativeNfcTag_abortWaits(); |
| NfcTag::getInstance().abort (); |
| sAbortConnlessWait = true; |
| nativeLlcpConnectionlessSocket_abortWait(); |
| sIsNfaEnabled = false; |
| sDiscoveryEnabled = false; |
| sIsDisabling = false; |
| sPollingEnabled = false; |
| // sIsSecElemSelected = false; |
| sIsSecElemSelected = 0; |
| gActivated = false; |
| sP2pEnabled = false; |
| sLfT3tMax = 0; |
| { |
| //unblock NFA_EnablePolling() and NFA_DisablePolling() |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| sNfaEnableDisablePollingEvent.notifyOne (); |
| } |
| |
| NfcAdaptation& theInstance = NfcAdaptation::GetInstance(); |
| theInstance.Finalize(); |
| |
| ALOGD ("%s: exit", __FUNCTION__); |
| return JNI_TRUE; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doCreateLlcpSocket |
| ** |
| ** Description: Create a LLCP connection-oriented socket. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** nSap: Service access point. |
| ** miu: Maximum information unit. |
| ** rw: Receive window size. |
| ** linearBufferLength: Max buffer size. |
| ** |
| ** Returns: NativeLlcpSocket Java object. |
| ** |
| *******************************************************************************/ |
| static jobject nfcManager_doCreateLlcpSocket (JNIEnv* e, jobject, jint nSap, jint miu, jint rw, jint linearBufferLength) |
| { |
| ALOGD ("%s: enter; sap=%d; miu=%d; rw=%d; buffer len=%d", __FUNCTION__, nSap, miu, rw, linearBufferLength); |
| |
| PeerToPeer::tJNI_HANDLE jniHandle = PeerToPeer::getInstance().getNewJniHandle (); |
| PeerToPeer::getInstance().createClient (jniHandle, miu, rw); |
| |
| /* Create new NativeLlcpSocket object */ |
| jobject clientSocket = NULL; |
| if (nfc_jni_cache_object_local(e, gNativeLlcpSocketClassName, &(clientSocket)) == -1) |
| { |
| ALOGE ("%s: fail Llcp socket creation", __FUNCTION__); |
| return clientSocket; |
| } |
| |
| /* Get NativeConnectionless class object */ |
| ScopedLocalRef<jclass> clsNativeLlcpSocket(e, e->GetObjectClass(clientSocket)); |
| if (e->ExceptionCheck()) |
| { |
| e->ExceptionClear(); |
| ALOGE ("%s: fail get class object", __FUNCTION__); |
| return clientSocket; |
| } |
| |
| jfieldID f; |
| |
| /* Set socket SAP */ |
| f = e->GetFieldID (clsNativeLlcpSocket.get(), "mSap", "I"); |
| e->SetIntField (clientSocket, f, (jint) nSap); |
| |
| /* Set socket handle */ |
| f = e->GetFieldID (clsNativeLlcpSocket.get(), "mHandle", "I"); |
| e->SetIntField (clientSocket, f, (jint) jniHandle); |
| |
| /* Set socket MIU */ |
| f = e->GetFieldID (clsNativeLlcpSocket.get(), "mLocalMiu", "I"); |
| e->SetIntField (clientSocket, f, (jint) miu); |
| |
| /* Set socket RW */ |
| f = e->GetFieldID (clsNativeLlcpSocket.get(), "mLocalRw", "I"); |
| e->SetIntField (clientSocket, f, (jint) rw); |
| |
| ALOGD ("%s: exit", __FUNCTION__); |
| return clientSocket; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doCreateLlcpConnectionlessSocket |
| ** |
| ** Description: Create a connection-less socket. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** nSap: Service access point. |
| ** sn: Service name. |
| ** |
| ** Returns: NativeLlcpConnectionlessSocket Java object. |
| ** |
| *******************************************************************************/ |
| static jobject nfcManager_doCreateLlcpConnectionlessSocket (JNIEnv *, jobject, jint nSap, jstring /*sn*/) |
| { |
| ALOGD ("%s: nSap=0x%X", __FUNCTION__, nSap); |
| return NULL; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doGetSecureElementList |
| ** |
| ** Description: Get a list of secure element handles. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: List of secure element handles. |
| ** |
| *******************************************************************************/ |
| static jintArray nfcManager_doGetSecureElementList(JNIEnv* e, jobject) |
| { |
| ALOGD ("%s", __FUNCTION__); |
| return SecureElement::getInstance().getListOfEeHandles(e); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: setListenMode |
| ** |
| ** Description: NFC controller starts routing data in listen mode. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| inline static void setListenMode() /*defined as inline to eliminate warning defined but not used*/ |
| { |
| ALOGD ("%s: enter", __FUNCTION__); |
| tNFA_HANDLE ee_handleList[NFA_EE_MAX_EE_SUPPORTED]; |
| UINT8 i, seId, count; |
| |
| PowerSwitch::getInstance ().setLevel (PowerSwitch::FULL_POWER); |
| |
| if (sRfEnabled) { |
| // Stop RF Discovery if we were polling |
| startRfDiscovery (false); |
| } |
| SecureElement::getInstance().getEeHandleList(ee_handleList, &count); |
| if (count > NFA_EE_MAX_EE_SUPPORTED) { |
| count = NFA_EE_MAX_EE_SUPPORTED; |
| ALOGD ("Count is more than NFA_EE_MAX_EE_SUPPORTED ,Forcing to NFA_EE_MAX_EE_SUPPORTED"); |
| } |
| for ( i = 0; i < count; i++) |
| { |
| seId = SecureElement::getInstance().getGenericEseId(ee_handleList[i]); |
| SecureElement::getInstance().activate (seId); |
| sIsSecElemSelected++; |
| } |
| |
| startRfDiscovery (true); |
| PowerSwitch::getInstance ().setModeOn (PowerSwitch::SE_ROUTING); |
| //TheEnd: /*commented to eliminate warning label defined but not used*/ |
| ALOGD ("%s: exit", __FUNCTION__); |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doSelectSecureElement |
| ** |
| ** Description: NFC controller starts routing data in listen mode. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doSelectSecureElement(JNIEnv *e, jobject o, jint seId) |
| { |
| (void)e; |
| (void)o; |
| ALOGD ("%s: enter", __FUNCTION__); |
| bool stat = true; |
| |
| if (sIsSecElemSelected >= sIsSecElemDetected) |
| { |
| ALOGD ("%s: already selected", __FUNCTION__); |
| goto TheEnd; |
| } |
| |
| PowerSwitch::getInstance ().setLevel (PowerSwitch::FULL_POWER); |
| |
| if (sRfEnabled) { |
| // Stop RF Discovery if we were polling |
| startRfDiscovery (false); |
| } |
| |
| stat = SecureElement::getInstance().activate (seId); |
| if (stat) |
| { |
| SecureElement::getInstance().routeToSecureElement (); |
| sIsSecElemSelected++; |
| // if(sHCEEnabled == false) |
| // { |
| // RoutingManager::getInstance().setRouting(false); |
| // } |
| } |
| // sIsSecElemSelected = true; |
| |
| startRfDiscovery (true); |
| PowerSwitch::getInstance ().setModeOn (PowerSwitch::SE_ROUTING); |
| TheEnd: |
| ALOGD ("%s: exit", __FUNCTION__); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doSetSEPowerOffState |
| ** |
| ** Description: NFC controller enable/disabe card emulation in power off |
| ** state from EE. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doSetSEPowerOffState(JNIEnv *e, jobject o, jint seId, jboolean enable) |
| { |
| (void)e; |
| (void)o; |
| tNFA_HANDLE ee_handle; |
| UINT8 power_state_mask = ~NFA_EE_PWR_STATE_SWITCH_OFF; |
| |
| if(enable == true) |
| { |
| power_state_mask = NFA_EE_PWR_STATE_SWITCH_OFF; |
| } |
| |
| ee_handle = SecureElement::getInstance().getEseHandleFromGenericId(seId); |
| |
| if (sRfEnabled) { |
| // Stop RF Discovery if we were polling |
| startRfDiscovery (false); |
| } |
| |
| tNFA_STATUS status = NFA_AddEePowerState(ee_handle,power_state_mask); |
| |
| |
| // Commit the routing configuration |
| status |= NFA_EeUpdateNow(); |
| |
| if (status != NFA_STATUS_OK) |
| ALOGE("Failed to commit routing configuration"); |
| |
| startRfDiscovery (true); |
| |
| // TheEnd: /*commented to eliminate warning label defined but not used*/ |
| ALOGD ("%s: exit", __FUNCTION__); |
| |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_GetDefaultSE |
| ** |
| ** Description: Get default Secure Element. |
| ** |
| ** |
| ** Returns: Returns 0. |
| ** |
| *******************************************************************************/ |
| static jint nfcManager_GetDefaultSE(JNIEnv *e, jobject o) |
| { |
| (void)e; |
| (void)o; |
| unsigned long num; |
| GetNxpNumValue (NAME_NXP_DEFAULT_SE, (void*)&num, sizeof(num)); |
| ALOGD ("%lu: nfcManager_GetDefaultSE", num); |
| return num; |
| |
| } |
| |
| |
| static jint nfcManager_getSecureElementTechList(JNIEnv *e, jobject o) |
| { |
| (void)e; |
| (void)o; |
| uint8_t sak; |
| jint tech = 0x00; |
| ALOGD ("nfcManager_getSecureElementTechList -Enter"); |
| sak = HciRFParams::getInstance().getESeSak(); |
| bool isTypeBPresent = HciRFParams::getInstance().isTypeBSupported(); |
| |
| ALOGD ("nfcManager_getSecureElementTechList - sak is %0x", sak); |
| |
| if(sak & 0x08) |
| { |
| tech |= TARGET_TYPE_MIFARE_CLASSIC; |
| } |
| |
| if( sak & 0x20 ) |
| { |
| tech |= NFA_TECHNOLOGY_MASK_A; |
| } |
| |
| if( isTypeBPresent == true) |
| { |
| tech |= NFA_TECHNOLOGY_MASK_B; |
| } |
| ALOGD ("nfcManager_getSecureElementTechList - tech is %0x", tech); |
| return tech; |
| |
| } |
| |
| static jintArray nfcManager_getActiveSecureElementList(JNIEnv *e, jobject o) |
| { |
| (void)e; |
| (void)o; |
| return SecureElement::getInstance().getActiveSecureElementList(e); |
| } |
| |
| static void nfcManager_setSecureElementListenTechMask(JNIEnv *e, jobject o, jint tech_mask) |
| { |
| (void)e; |
| (void)o; |
| ALOGD ("%s: ENTER", __FUNCTION__); |
| // tNFA_STATUS status; /*commented to eliminate unused variable warning*/ |
| |
| if (sRfEnabled) { |
| // Stop RF Discovery if we were polling |
| startRfDiscovery (false); |
| } |
| SecureElement::getInstance().setEseListenTechMask(tech_mask); |
| |
| startRfDiscovery (true); |
| |
| ALOGD ("%s: EXIT", __FUNCTION__); |
| } |
| |
| |
| static jbyteArray nfcManager_getSecureElementUid(JNIEnv *e, jobject o) |
| { |
| unsigned long num=0; |
| jbyteArray jbuff = NULL; |
| uint8_t bufflen = 0; |
| uint8_t buf[16] = {0,}; |
| |
| ALOGD ("nfcManager_getSecureElementUid -Enter"); |
| HciRFParams::getInstance().getESeUid(&buf[0], &bufflen); |
| if(bufflen > 0) |
| { |
| jbuff = e->NewByteArray (bufflen); |
| e->SetByteArrayRegion (jbuff, 0, bufflen, (jbyte*) buf); |
| } |
| return jbuff; |
| } |
| |
| static tNFA_STATUS nfcManager_setEmvCoPollProfile(JNIEnv *e, jobject o, |
| jboolean enable, jint route) |
| { |
| tNFA_STATUS status = NFA_STATUS_FAILED; |
| tNFA_TECHNOLOGY_MASK tech_mask = 0; |
| |
| ALOGE("In nfcManager_setEmvCoPollProfile enable = 0x%x route = 0x%x", enable, route); |
| /* Stop polling */ |
| if ( isDiscoveryStarted()) |
| { |
| // Stop RF discovery to reconfigure |
| startRfDiscovery(false); |
| } |
| |
| status = EmvCo_dosetPoll(enable); |
| if (status != NFA_STATUS_OK) |
| { |
| ALOGE ("%s: fail enable polling; error=0x%X", __FUNCTION__, status); |
| goto TheEnd; |
| } |
| |
| if (enable) |
| { |
| if (route == 0x00) |
| { |
| /* DH enable polling for A and B*/ |
| tech_mask = NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B; |
| } |
| else if(route == 0x01) |
| { |
| /* UICC is end-point at present not supported by FW */ |
| /* TBD : Get eeinfo (use handle appropirately, depending up |
| * on it enable the polling */ |
| } |
| else if(route == 0x02) |
| { |
| /* ESE is end-point at present not supported by FW */ |
| /* TBD : Get eeinfo (use handle appropirately, depending up |
| * on it enable the polling */ |
| } |
| else |
| { |
| |
| } |
| } |
| else |
| { |
| unsigned long num = 0; |
| if (GetNumValue(NAME_POLLING_TECH_MASK, &num, sizeof(num))) |
| tech_mask = num; |
| } |
| |
| ALOGD ("%s: enable polling", __FUNCTION__); |
| { |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| status = NFA_EnablePolling (tech_mask); |
| if (status == NFA_STATUS_OK) |
| { |
| ALOGD ("%s: wait for enable event", __FUNCTION__); |
| sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_ENABLED_EVT |
| } |
| else |
| { |
| ALOGE ("%s: fail enable polling; error=0x%X", __FUNCTION__, status); |
| } |
| } |
| |
| TheEnd: |
| /* start polling */ |
| if ( !isDiscoveryStarted()) |
| { |
| // Start RF discovery to reconfigure |
| startRfDiscovery(true); |
| } |
| return status; |
| |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doDeselectSecureElement |
| ** |
| ** Description: NFC controller stops routing data in listen mode. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doDeselectSecureElement(JNIEnv *e, jobject o, jint seId) |
| { |
| (void)e; |
| (void)o; |
| ALOGD ("%s: enter", __FUNCTION__); |
| bool stat = false; |
| bool bRestartDiscovery = false; |
| |
| if (! sIsSecElemSelected) |
| { |
| ALOGE ("%s: already deselected", __FUNCTION__); |
| goto TheEnd2; |
| } |
| |
| if (PowerSwitch::getInstance ().getLevel() == PowerSwitch::LOW_POWER) |
| { |
| ALOGD ("%s: do not deselect while power is OFF", __FUNCTION__); |
| // sIsSecElemSelected = false; |
| sIsSecElemSelected--; |
| goto TheEnd; |
| } |
| |
| if (sRfEnabled) { |
| // Stop RF Discovery if we were polling |
| startRfDiscovery (false); |
| bRestartDiscovery = true; |
| } |
| //sIsSecElemSelected = false; |
| //sIsSecElemSelected--; |
| |
| //if controller is not routing to sec elems AND there is no pipe connected, |
| //then turn off the sec elems |
| if (SecureElement::getInstance().isBusy() == false) |
| { |
| //SecureElement::getInstance().deactivate (0xABCDEF); |
| stat = SecureElement::getInstance().deactivate (seId); |
| if(stat) |
| { |
| sIsSecElemSelected--; |
| // RoutingManager::getInstance().commitRouting(); |
| } |
| } |
| |
| TheEnd: |
| /* |
| * conditional check is added to avoid multiple dicovery cmds |
| * at the time of NFC OFF in progress |
| */ |
| if ((gGeneralPowershutDown != NFC_MODE_OFF) && bRestartDiscovery) |
| startRfDiscovery (true); |
| |
| //if nothing is active after this, then tell the controller to power down |
| if (! PowerSwitch::getInstance ().setModeOff (PowerSwitch::SE_ROUTING)) |
| PowerSwitch::getInstance ().setLevel (PowerSwitch::LOW_POWER); |
| |
| TheEnd2: |
| ALOGD ("%s: exit", __FUNCTION__); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_getDefaultAidRoute |
| ** |
| ** Description: Get the default Aid Route Entry. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** mode: Not used. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static jint nfcManager_getDefaultAidRoute (JNIEnv* e, jobject o) |
| { |
| unsigned long num = 0; |
| #if(NXP_EXTNS == TRUE) |
| GetNxpNumValue(NAME_DEFAULT_AID_ROUTE, &num, sizeof(num)); |
| #endif |
| return num; |
| } |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_getDefaultDesfireRoute |
| ** |
| ** Description: Get the default Desfire Route Entry. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** mode: Not used. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static jint nfcManager_getDefaultDesfireRoute (JNIEnv* e, jobject o) |
| { |
| unsigned long num = 0; |
| #if(NXP_EXTNS == TRUE) |
| GetNxpNumValue(NAME_DEFAULT_DESFIRE_ROUTE, (void*)&num, sizeof(num)); |
| ALOGD ("%s: enter; NAME_DEFAULT_DESFIRE_ROUTE = %02x", __FUNCTION__, num); |
| #endif |
| return num; |
| } |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_getDefaultMifareCLTRoute |
| ** |
| ** Description: Get the default mifare CLT Route Entry. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** mode: Not used. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static jint nfcManager_getDefaultMifareCLTRoute (JNIEnv* e, jobject o) |
| { |
| unsigned long num = 0; |
| #if(NXP_EXTNS == TRUE) |
| GetNxpNumValue(NAME_DEFAULT_MIFARE_CLT_ROUTE, &num, sizeof(num)); |
| #endif |
| return num; |
| } |
| #if(NXP_EXTNS == TRUE) |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_getDefaultAidPowerState |
| ** |
| ** Description: Get the default Desfire Power States. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: Power State |
| ** |
| *******************************************************************************/ |
| static jint nfcManager_getDefaultAidPowerState (JNIEnv* e, jobject o) |
| { |
| unsigned long num = 0; |
| GetNxpNumValue(NAME_DEFAULT_AID_PWR_STATE, &num, sizeof(num)); |
| return num; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_getDefaultDesfirePowerState |
| ** |
| ** Description: Get the default Desfire Power States. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: Power State |
| ** |
| *******************************************************************************/ |
| static jint nfcManager_getDefaultDesfirePowerState (JNIEnv* e, jobject o) |
| { |
| unsigned long num = 0; |
| GetNxpNumValue(NAME_DEFAULT_DESFIRE_PWR_STATE, &num, sizeof(num)); |
| return num; |
| } |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_getDefaultMifareCLTPowerState |
| ** |
| ** Description: Get the default mifare CLT Power States. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: Power State |
| ** |
| *******************************************************************************/ |
| static jint nfcManager_getDefaultMifareCLTPowerState (JNIEnv* e, jobject o) |
| { |
| unsigned long num = 0; |
| GetNxpNumValue(NAME_DEFAULT_MIFARE_CLT_PWR_STATE, &num, sizeof(num)); |
| return num; |
| } |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_setDefaultTechRoute |
| ** |
| ** Description: Setting Default Technology Routing |
| ** e: JVM environment. |
| ** o: Java object. |
| ** seId: SecureElement Id |
| ** tech_swithon: technology switch_on |
| ** tech_switchoff: technology switch_off |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfcManager_setDefaultTechRoute(JNIEnv *e, jobject o, jint seId, |
| jint tech_switchon, jint tech_switchoff) |
| { |
| (void)e; |
| (void)o; |
| ALOGD ("%s: ENTER", __FUNCTION__); |
| // tNFA_STATUS status; /*commented to eliminate unused variable warning*/ |
| |
| if (sRfEnabled) { |
| // Stop RF Discovery if we were polling |
| startRfDiscovery (false); |
| } |
| RoutingManager::getInstance().setDefaultTechRouting (seId, tech_switchon, tech_switchoff); |
| // start discovery. |
| startRfDiscovery (true); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_setDefaultProtoRoute |
| ** |
| ** Description: Setting Default Protocol Routing |
| ** |
| ** e: JVM environment. |
| ** o: Java object. |
| ** seId: SecureElement Id |
| ** proto_swithon: Protocol switch_on |
| ** proto_switchoff: Protocol switch_off |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfcManager_setDefaultProtoRoute(JNIEnv *e, jobject o, jint seId, |
| jint proto_switchon, jint proto_switchoff) |
| { |
| (void)e; |
| (void)o; |
| ALOGD ("%s: ENTER", __FUNCTION__); |
| // tNFA_STATUS status; /*commented to eliminate unused variable warning*/ |
| // if (sRfEnabled) { |
| // // Stop RF Discovery if we were polling |
| // startRfDiscovery (false); |
| // } |
| RoutingManager::getInstance().setDefaultProtoRouting (seId, proto_switchon, proto_switchoff); |
| // start discovery. |
| // startRfDiscovery (true); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_isVzwFeatureEnabled |
| ** |
| ** Description: Check vzw feature is enabled or not |
| ** |
| ** Returns: True if the VZW_FEATURE_ENABLE is set. |
| ** |
| *******************************************************************************/ |
| static bool nfcManager_isVzwFeatureEnabled (JNIEnv *e, jobject o) |
| { |
| unsigned int num = 0; |
| bool mStat = false; |
| |
| if (GetNxpNumValue("VZW_FEATURE_ENABLE", &num, sizeof(num))) |
| { |
| if(num == 0x01) |
| { |
| mStat = true; |
| } |
| else |
| { |
| mStat = false; |
| } |
| } |
| else{ |
| mStat = false; |
| } |
| return mStat; |
| } |
| #endif |
| /******************************************************************************* |
| ** |
| ** Function: isPeerToPeer |
| ** |
| ** Description: Whether the activation data indicates the peer supports NFC-DEP. |
| ** activated: Activation data. |
| ** |
| ** Returns: True if the peer supports NFC-DEP. |
| ** |
| *******************************************************************************/ |
| static bool isPeerToPeer (tNFA_ACTIVATED& activated) |
| { |
| return activated.activate_ntf.protocol == NFA_PROTOCOL_NFC_DEP; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: isListenMode |
| ** |
| ** Description: Indicates whether the activation data indicates it is |
| ** listen mode. |
| ** |
| ** Returns: True if this listen mode. |
| ** |
| *******************************************************************************/ |
| static bool isListenMode(tNFA_ACTIVATED& activated) |
| { |
| return ((NFC_DISCOVERY_TYPE_LISTEN_A == activated.activate_ntf.rf_tech_param.mode) |
| || (NFC_DISCOVERY_TYPE_LISTEN_B == activated.activate_ntf.rf_tech_param.mode) |
| || (NFC_DISCOVERY_TYPE_LISTEN_F == activated.activate_ntf.rf_tech_param.mode) |
| || (NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE == activated.activate_ntf.rf_tech_param.mode) |
| || (NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE == activated.activate_ntf.rf_tech_param.mode) |
| || (NFC_DISCOVERY_TYPE_LISTEN_ISO15693 == activated.activate_ntf.rf_tech_param.mode) |
| || (NFC_DISCOVERY_TYPE_LISTEN_B_PRIME == activated.activate_ntf.rf_tech_param.mode) |
| || (NFC_INTERFACE_EE_DIRECT_RF == activated.activate_ntf.intf_param.type)); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doCheckLlcp |
| ** |
| ** Description: Not used. |
| ** |
| ** Returns: True |
| ** |
| *******************************************************************************/ |
| static jboolean nfcManager_doCheckLlcp(JNIEnv*, jobject) |
| { |
| ALOGD("%s", __FUNCTION__); |
| return JNI_TRUE; |
| } |
| |
| |
| static jboolean nfcManager_doCheckJcopDlAtBoot(JNIEnv* e, jobject o) |
| { |
| unsigned int num = 0; |
| ALOGD("%s", __FUNCTION__); |
| if(GetNxpNumValue(NAME_NXP_JCOPDL_AT_BOOT_ENABLE,(void*)&num,sizeof(num))) { |
| if(num == 0x01) { |
| return JNI_TRUE; |
| } |
| else { |
| return JNI_FALSE; |
| } |
| } |
| else { |
| return JNI_FALSE; |
| } |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doActivateLlcp |
| ** |
| ** Description: Not used. |
| ** |
| ** Returns: True |
| ** |
| *******************************************************************************/ |
| static jboolean nfcManager_doActivateLlcp(JNIEnv*, jobject) |
| { |
| ALOGD("%s", __FUNCTION__); |
| return JNI_TRUE; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doAbort |
| ** |
| ** Description: Not used. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doAbort(JNIEnv*, jobject) |
| { |
| ALOGE("%s: abort()", __FUNCTION__); |
| abort(); |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doDownload |
| ** |
| ** Description: Download firmware patch files. Do not turn on NFC. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| static jboolean nfcManager_doDownload(JNIEnv*, jobject) |
| { |
| ALOGD ("%s: enter", __FUNCTION__); |
| NfcAdaptation& theInstance = NfcAdaptation::GetInstance(); |
| |
| theInstance.Initialize(); //start GKI, NCI task, NFC task |
| theInstance.DownloadFirmware (); |
| theInstance.Finalize(); |
| ALOGD ("%s: exit", __FUNCTION__); |
| return JNI_TRUE; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doResetTimeouts |
| ** |
| ** Description: Not used. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doResetTimeouts(JNIEnv*, jobject) |
| { |
| ALOGD ("%s", __FUNCTION__); |
| NfcTag::getInstance().resetAllTransceiveTimeouts (); |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doSetTimeout |
| ** |
| ** Description: Set timeout value. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** tech: technology ID. |
| ** timeout: Timeout value. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| static bool nfcManager_doSetTimeout(JNIEnv*, jobject, jint tech, jint timeout) |
| { |
| if (timeout <= 0) |
| { |
| ALOGE("%s: Timeout must be positive.",__FUNCTION__); |
| return false; |
| } |
| ALOGD ("%s: tech=%d, timeout=%d", __FUNCTION__, tech, timeout); |
| gGeneralTransceiveTimeout = timeout; |
| NfcTag::getInstance().setTransceiveTimeout (tech, timeout); |
| return true; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doGetTimeout |
| ** |
| ** Description: Get timeout value. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** tech: technology ID. |
| ** |
| ** Returns: Timeout value. |
| ** |
| *******************************************************************************/ |
| static jint nfcManager_doGetTimeout(JNIEnv*, jobject, jint tech) |
| { |
| int timeout = NfcTag::getInstance().getTransceiveTimeout (tech); |
| ALOGD ("%s: tech=%d, timeout=%d", __FUNCTION__, tech, timeout); |
| return timeout; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doDump |
| ** |
| ** Description: Not used. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: Text dump. |
| ** |
| *******************************************************************************/ |
| static jstring nfcManager_doDump(JNIEnv* e, jobject) |
| { |
| char buffer[100]; |
| snprintf(buffer, sizeof(buffer), "libnfc llc error_count=%u", /*libnfc_llc_error_count*/ 0); |
| return e->NewStringUTF(buffer); |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doSetP2pInitiatorModes |
| ** |
| ** Description: Set P2P initiator's activation modes. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** modes: Active and/or passive modes. The values are specified |
| ** in external/libnfc-nxp/inc/phNfcTypes.h. See |
| ** enum phNfc_eP2PMode_t. |
| ** |
| ** Returns: None. |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doSetP2pInitiatorModes (JNIEnv *e, jobject o, jint modes) |
| { |
| ALOGD ("%s: modes=0x%X", __FUNCTION__, modes); |
| struct nfc_jni_native_data *nat = getNative(e, o); |
| |
| tNFA_TECHNOLOGY_MASK mask = 0; |
| if (modes & 0x01) mask |= NFA_TECHNOLOGY_MASK_A; |
| if (modes & 0x02) mask |= NFA_TECHNOLOGY_MASK_F; |
| if (modes & 0x04) mask |= NFA_TECHNOLOGY_MASK_F; |
| if (modes & 0x08) mask |= NFA_TECHNOLOGY_MASK_A_ACTIVE; |
| if (modes & 0x10) mask |= NFA_TECHNOLOGY_MASK_F_ACTIVE; |
| if (modes & 0x20) mask |= NFA_TECHNOLOGY_MASK_F_ACTIVE; |
| nat->tech_mask = mask; |
| } |
| |
| #if(NXP_EXTNS == TRUE) |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_getRouting |
| ** |
| ** Description: Get Routing Table information. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: Current routing Settings. |
| ** |
| *******************************************************************************/ |
| static jbyteArray nfcManager_getRouting (JNIEnv *e, jobject o) |
| { |
| ALOGD ("%s : Enter", __FUNCTION__); |
| jbyteArray jbuff = NULL; |
| if (sRfEnabled) { |
| // Stop RF Discovery if we were polling |
| startRfDiscovery (false); |
| } |
| SyncEventGuard guard (sNfaGetRoutingEvent); |
| sRoutingBuffLen = 0; |
| RoutingManager::getInstance().getRouting(); |
| sNfaGetRoutingEvent.wait (); |
| if(sRoutingBuffLen > 0) |
| { |
| jbuff = e->NewByteArray (sRoutingBuffLen); |
| e->SetByteArrayRegion (jbuff, 0, sRoutingBuffLen, (jbyte*) sRoutingBuff); |
| } |
| |
| startRfDiscovery(true); |
| return jbuff; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_getNfcInitTimeout |
| ** |
| ** Description: Gets the chip version. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: timeout in seconds |
| ** |
| *******************************************************************************/ |
| static int nfcManager_getNfcInitTimeout(JNIEnv* e, jobject o) |
| { |
| (void)e; |
| (void)o; |
| ALOGD ("%s: enter", __FUNCTION__); |
| unsigned long disc_timeout =0; |
| unsigned long session_id_timeout =0; |
| disc_timeout = 0; |
| gNfcInitTimeout = 0; |
| gdisc_timeout = 0; |
| |
| if(GetNxpNumValue(NAME_NXP_DEFAULT_NFCEE_DISC_TIMEOUT, (void *)&disc_timeout, sizeof(disc_timeout))==false) |
| { |
| ALOGD ("NAME_NXP_DEFAULT_NFCEE_DISC_TIMEOUT not found"); |
| disc_timeout = 0; |
| } |
| if(GetNxpNumValue(NAME_NXP_DEFAULT_NFCEE_TIMEOUT, (void *)&session_id_timeout, |
| sizeof(session_id_timeout))==false) |
| { |
| ALOGD ("NAME_NXP_DEFAULT_NFCEE_TIMEOUT not found"); |
| session_id_timeout = 0; |
| } |
| |
| gNfcInitTimeout = (disc_timeout + session_id_timeout) *1000; |
| gdisc_timeout = disc_timeout *1000; |
| |
| ALOGD (" gNfcInitTimeout = %d: gdisc_timeout = %d nfcManager_getNfcInitTimeout", |
| gNfcInitTimeout, gdisc_timeout); |
| return gNfcInitTimeout; |
| } |
| |
| #endif |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doSetP2pTargetModes |
| ** |
| ** Description: Set P2P target's activation modes. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** modes: Active and/or passive modes. |
| ** |
| ** Returns: None. |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doSetP2pTargetModes (JNIEnv*, jobject, jint modes) |
| { |
| ALOGD ("%s: modes=0x%X", __FUNCTION__, modes); |
| // Map in the right modes |
| tNFA_TECHNOLOGY_MASK mask = 0; |
| if (modes & 0x01) mask |= NFA_TECHNOLOGY_MASK_A; |
| if (modes & 0x02) mask |= NFA_TECHNOLOGY_MASK_F; |
| if (modes & 0x04) mask |= NFA_TECHNOLOGY_MASK_F; |
| if (modes & 0x08) mask |= NFA_TECHNOLOGY_MASK_A_ACTIVE | NFA_TECHNOLOGY_MASK_F_ACTIVE; |
| |
| PeerToPeer::getInstance().setP2pListenMask(mask); |
| } |
| |
| #if((NFC_NXP_ESE == TRUE) && ((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551))) |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_dosetEtsiReaederState |
| ** |
| ** Description: Set ETSI reader state |
| ** e: JVM environment. |
| ** o: Java object. |
| ** newState : new state to be set |
| ** |
| ** Returns: None. |
| ** |
| *******************************************************************************/ |
| static void nfcManager_dosetEtsiReaederState (JNIEnv*, jobject, se_rd_req_state_t newState) |
| { |
| ALOGD ("%s: Enter ", __FUNCTION__); |
| RoutingManager::getInstance().setEtsiReaederState(newState); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_dogetEtsiReaederState |
| ** |
| ** Description: Get current ETSI reader state |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: State. |
| ** |
| *******************************************************************************/ |
| static int nfcManager_dogetEtsiReaederState (JNIEnv*, jobject) |
| { |
| ALOGD ("%s: Enter ", __FUNCTION__); |
| return RoutingManager::getInstance().getEtsiReaederState(); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doEtsiReaderConfig |
| ** |
| ** Description: Configuring to Emvco profile |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None. |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doEtsiReaderConfig (JNIEnv*, jobject, int eeHandle) |
| { |
| tNFC_STATUS status; |
| ALOGD ("%s: Enter ", __FUNCTION__); |
| status = SecureElement::getInstance().etsiReaderConfig(eeHandle); |
| if(status != NFA_STATUS_OK) |
| { |
| ALOGD ("%s: etsiReaderConfig Failed ", __FUNCTION__); |
| } |
| else |
| { |
| ALOGD ("%s: etsiReaderConfig Success ", __FUNCTION__); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doEtsiResetReaderConfig |
| ** |
| ** Description: Configuring to Nfc forum profile |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None. |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doEtsiResetReaderConfig (JNIEnv*, jobject) |
| { |
| tNFC_STATUS status; |
| ALOGD ("%s: Enter ", __FUNCTION__); |
| status = SecureElement::getInstance().etsiResetReaderConfig(); |
| if(status != NFA_STATUS_OK) |
| { |
| ALOGD ("%s: etsiReaderConfig Failed ", __FUNCTION__); |
| } |
| else |
| { |
| ALOGD ("%s: etsiReaderConfig Success ", __FUNCTION__); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doNotifyEEReaderEvent |
| ** |
| ** Description: Notify with the Reader event |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None. |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doNotifyEEReaderEvent (JNIEnv*, jobject, int evt) |
| { |
| ALOGD ("%s: Enter ", __FUNCTION__); |
| |
| SecureElement::getInstance().notifyEEReaderEvent(evt,swp_rdr_req_ntf_info.swp_rd_req_info.tech_mask); |
| |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doEtsiInitConfig |
| ** |
| ** Description: Chnage the ETSI state before start configuration |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None. |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doEtsiInitConfig (JNIEnv*, jobject, int evt) |
| { |
| ALOGD ("%s: Enter ", __FUNCTION__); |
| SecureElement::getInstance().etsiInitConfig(); |
| } |
| #endif |
| |
| static void nfcManager_doEnableScreenOffSuspend(JNIEnv* e, jobject o) |
| { |
| PowerSwitch::getInstance().setScreenOffPowerState(PowerSwitch::POWER_STATE_FULL); |
| } |
| |
| static void nfcManager_doDisableScreenOffSuspend(JNIEnv* e, jobject o) |
| { |
| PowerSwitch::getInstance().setScreenOffPowerState(PowerSwitch::POWER_STATE_OFF); |
| } |
| #if((NFC_NXP_ESE == TRUE) && ((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551))) |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doUpdateScreenState |
| ** |
| ** Description: Update If any Pending screen state is present |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None. |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doUpdateScreenState(JNIEnv* e, jobject o) |
| { |
| ALOGD ("%s: Enter ", __FUNCTION__); |
| eScreenState_t last_screen_state_request; |
| |
| if(pendingScreenState == true) |
| { |
| ALOGD ("%s: pendingScreenState = TRUE ", __FUNCTION__); |
| pendingScreenState = false; |
| last_screen_state_request = get_lastScreenStateRequest(); |
| nfcManager_doSetScreenState(NULL,NULL,last_screen_state_request); |
| } |
| else |
| { |
| ALOGD ("%s: pendingScreenState = FALSE ", __FUNCTION__); |
| } |
| } |
| #endif |
| #if(NXP_EXTNS == TRUE) |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doSelectUicc() |
| ** |
| ** Description: Issue any single TLV set config command as per input |
| ** register values and bit values |
| ** |
| ** Returns: success/failure |
| ** |
| *******************************************************************************/ |
| static int nfcManager_doSelectUicc(JNIEnv* e, jobject o, jint uiccSlot) |
| { |
| (void)e; |
| (void)o; |
| uint8_t retStat = STATUS_UNKNOWN_ERROR; |
| #if(NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE) |
| tNFA_STATUS status = NFC_STATUS_FAILED; |
| ALOGD("%s: enter", __FUNCTION__); |
| ALOGD("%s: sUicc1CntxLen : 0x%02x sUicc2CntxLen : 0x%02x", __FUNCTION__,dualUiccInfo.sUicc1CntxLen,dualUiccInfo.sUicc2CntxLen); |
| tNFA_STATUS stat = NFA_STATUS_FAILED; |
| BOOLEAN result =FALSE; |
| UINT16 RegAddr = 0xA0EC; |
| uint8_t bitVal; |
| eScreenState_t last_screen_state_request; |
| dualUiccInfo.uiccConfigStat = UICC_NOT_CONFIGURED; |
| |
| RoutingManager& routingManager = RoutingManager::getInstance(); |
| SecureElement &se = SecureElement::getInstance(); |
| |
| retStat = nfcManager_staticDualUicc_Precondition(uiccSlot); |
| |
| if(retStat != UICC_NOT_CONFIGURED) |
| { |
| goto endSwitch; |
| } |
| |
| if(sRfEnabled) |
| { |
| startRfDiscovery(false); |
| } |
| |
| bitVal = ((0x10) | uiccSlot); |
| |
| if((dualUiccInfo.sUicc1CntxLen !=0)||(dualUiccInfo.sUicc2CntxLen !=0)) |
| { |
| if((bitVal == 0x11)&&(dualUiccInfo.sUicc1CntxLen !=0)) |
| { |
| ALOGD ("%s : update uicc1 context information ", __FUNCTION__); |
| UINT8 cfg[256] = {0x20,0x02}; |
| |
| memcpy(cfg+3, dualUiccInfo.sUicc1Cntx, dualUiccInfo.sUicc1CntxLen); |
| cfg[2] = dualUiccInfo.sUicc1CntxLen-1; |
| status = NxpNfc_Write_Cmd_Common(dualUiccInfo.sUicc1CntxLen+2, cfg); |
| |
| memcpy(cfg+3, dualUiccInfo.sUicc1TechCapblty, 10); |
| cfg[2] = 9; |
| status = NxpNfc_Write_Cmd_Common(12, cfg); |
| |
| } |
| else if((bitVal == 0x12)&&(dualUiccInfo.sUicc2CntxLen !=0)) |
| { |
| ALOGD ("%s : update uicc2 context information", __FUNCTION__); |
| UINT8 cfg[256] = {0x20,0x02}; |
| memcpy(cfg+3, dualUiccInfo.sUicc2Cntx, dualUiccInfo.sUicc2CntxLen); |
| cfg[2] = dualUiccInfo.sUicc2CntxLen-1; |
| status = NxpNfc_Write_Cmd_Common(dualUiccInfo.sUicc2CntxLen+2, cfg); |
| |
| memcpy(cfg+3, dualUiccInfo.sUicc2TechCapblty, 10); |
| cfg[2] = 9; |
| status = NxpNfc_Write_Cmd_Common(12, cfg); |
| } |
| } |
| |
| /*Update NFCC SWIO line accordingly*/ |
| if((Set_EERegisterValue(RegAddr, bitVal) != NFCSTATUS_OK)) |
| { |
| retStat = DUAL_UICC_ERROR_SELECT_FAILED; |
| ALOGE ("%s : Set_EERegisterValue Failed", __FUNCTION__); |
| goto endSwitch; |
| } |
| |
| /*Mode Set Off for UICC*/ |
| { |
| SyncEventGuard guard (routingManager.mEeSetModeEvent); |
| if ((NFA_EeModeSet (0x02, NFA_EE_MD_DEACTIVATE)) == NFA_STATUS_OK) |
| { |
| routingManager.mEeSetModeEvent.wait (); //wait for NFA_EE_MODE_SET_EVT |
| } |
| else |
| { |
| ALOGE ("%s : Failed to set EE inactive", __FUNCTION__); |
| goto endSwitch; |
| } |
| } |
| gSeDiscoverycount = 0; |
| /*Perform HAL re-initialisation |
| * NFA EE and HCI Subsystem de-init*/ |
| { |
| SyncEventGuard guard (sNfceeHciCbDisableEvent); |
| NFA_EE_HCI_Control(false); |
| sNfceeHciCbDisableEvent.wait(); |
| } |
| |
| /*Reset Nfcc*/ |
| status = NFA_ResetNfcc(); |
| /*Perform NFA EE and HCI Subsystem initialisation*/ |
| { |
| SyncEventGuard guard (sNfceeHciCbEnableEvent); |
| NFA_EE_HCI_Control(true); |
| sNfceeHciCbEnableEvent.wait (); |
| } |
| |
| { |
| se.updateEEStatus(); |
| //setListenMode(); |
| routingManager.initialize(getNative(e, o)); |
| HciRFParams::getInstance().initialize (); |
| sIsSecElemSelected = (se.getActualNumEe() - 1 ); |
| sIsSecElemDetected = sIsSecElemSelected; |
| } |
| |
| ALOGD("%s : gSeDiscoverycount = %d", __FUNCTION__ , gSeDiscoverycount); |
| /*Get the SWP1 and SWP2 lines status*/ |
| if (NFA_STATUS_OK == GetSwpStausValue()) |
| { |
| /*The SWP lines enabled and SE's discovered*/ |
| if (gSeDiscoverycount < gActualSeCount) |
| { |
| ALOGD("%s : Wait for ESE to discover, gdisc_timeout = %d", __FUNCTION__, gdisc_timeout); |
| SyncEventGuard g(gNfceeDiscCbEvent); |
| if(gNfceeDiscCbEvent.wait(gdisc_timeout) == false) |
| { |
| ALOGE ("%s: timeout waiting for nfcee dis event", __FUNCTION__); |
| } |
| } |
| else |
| { |
| ALOGD("%s : All ESE are discovered ", __FUNCTION__); |
| } |
| } |
| /*Get the eSE and UICC parameters for RF*/ |
| checkforNfceeConfig(); |
| |
| if(se.getEeStatus(UICC_HANDLE) == NFC_NFCEE_STATUS_REMOVED) |
| { |
| ALOGD("%s : UICC 0x%02x status : NFC_NFCEE_STATUS_REMOVED. Clearing buffer", __FUNCTION__,sSelectedUicc); |
| if((sSelectedUicc == 0x01)&&(dualUiccInfo.sUicc1CntxLen != 0x00)) |
| { |
| memset(dualUiccInfo.sUicc1Cntx,0x00,sizeof(dualUiccInfo.sUicc1Cntx)); |
| dualUiccInfo.sUicc1CntxLen = 0x00; |
| } |
| else if((sSelectedUicc == 0x02)&&(dualUiccInfo.sUicc2CntxLen != 0x00)) |
| { |
| memset(dualUiccInfo.sUicc2Cntx,0x00,sizeof(dualUiccInfo.sUicc2Cntx)); |
| dualUiccInfo.sUicc2CntxLen = 0x00; |
| } |
| } |
| |
| retStat = dualUiccInfo.uiccConfigStat; |
| |
| endSwitch: |
| if((retStat == UICC_CONFIGURED) || (retStat == UICC_NOT_CONFIGURED)) |
| { |
| if(get_transcation_stat() == true) |
| { |
| /*Apply screen state if pending*/ |
| set_transcation_stat(false); |
| if(pendingScreenState == true) |
| { |
| pendingScreenState = false; |
| last_screen_state_request = get_lastScreenStateRequest(); |
| nfcManager_doSetScreenState(NULL,NULL,last_screen_state_request); |
| } |
| } |
| } |
| |
| /*If retStat is success then routing table will be reconfigured from NfcService |
| * As a part of commitRouting startRfDiscovery will be called. |
| * If retStat is failed then NfcService will not reconfigured routing table |
| * So do startRfDiscovery here*/ |
| if((retStat != UICC_CONFIGURED) && (retStat != UICC_NOT_CONFIGURED) && (!sRfEnabled)) |
| { |
| startRfDiscovery(true); |
| } |
| |
| ALOGD("%s: exit retStat = %d", __FUNCTION__, retStat); |
| #else |
| retStat = DUAL_UICC_FEATURE_NOT_AVAILABLE; |
| ALOGD("%s: Dual uicc not supported retStat = %d", __FUNCTION__, retStat); |
| #endif |
| return retStat; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doGetSelectedUicc() |
| ** |
| ** Description: get the current selected active UICC |
| ** |
| ** Returns: UICC id |
| ** |
| *******************************************************************************/ |
| static int nfcManager_doGetSelectedUicc(JNIEnv* e, jobject o) |
| { |
| uint8_t uicc_stat = STATUS_UNKNOWN_ERROR; |
| #if(NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE) |
| ALOGD ("%s: enter ",__FUNCTION__); |
| uicc_stat = SecureElement::getInstance().getUiccStatus(sSelectedUicc); |
| #else |
| ALOGD ("%s: dual uicc not supported ",__FUNCTION__); |
| uicc_stat = DUAL_UICC_FEATURE_NOT_AVAILABLE; |
| #endif |
| return uicc_stat; |
| } |
| #endif |
| /***************************************************************************** |
| ** |
| ** JNI functions for android-4.0.1_r1 |
| ** |
| *****************************************************************************/ |
| static JNINativeMethod gMethods[] = |
| { |
| {"doDownload", "()Z", |
| (void *)nfcManager_doDownload}, |
| |
| {"initializeNativeStructure", "()Z", |
| (void*) nfcManager_initNativeStruc}, |
| |
| {"doInitialize", "()Z", |
| (void*) nfcManager_doInitialize}, |
| |
| {"doDeinitialize", "()Z", |
| (void*) nfcManager_doDeinitialize}, |
| |
| {"sendRawFrame", "([B)Z", |
| (void*) nfcManager_sendRawFrame}, |
| |
| {"doRouteAid", "([BIIZ)Z", |
| (void*) nfcManager_routeAid}, |
| |
| {"doRouteNfcid2", "([B[B[B)I", |
| (void*) nfcManager_routeNfcid2}, |
| |
| {"doUnRouteNfcid2", "([B)Z", |
| (void*) nfcManager_unrouteNfcid2}, |
| |
| |
| {"doUnrouteAid", "([B)Z", |
| (void*) nfcManager_unrouteAid}, |
| |
| {"doSetRoutingEntry", "(IIII)Z", |
| (void*)nfcManager_setRoutingEntry}, |
| |
| {"doClearRoutingEntry", "(I)Z", |
| (void*)nfcManager_clearRoutingEntry}, |
| |
| {"clearAidTable", "()Z", |
| (void*) nfcManager_clearAidTable}, |
| |
| {"setDefaultRoute", "(III)Z", |
| (void*) nfcManager_setDefaultRoute}, |
| |
| {"getAidTableSize", "()I", |
| (void*) nfcManager_getAidTableSize}, |
| |
| {"getRemainingAidTableSize", "()I", |
| (void*) nfcManager_getRemainingAidTableSize}, |
| |
| {"getDefaultAidRoute", "()I", |
| (void*) nfcManager_getDefaultAidRoute}, |
| |
| {"getDefaultDesfireRoute", "()I", |
| (void*) nfcManager_getDefaultDesfireRoute}, |
| |
| {"getDefaultMifareCLTRoute", "()I", |
| (void*) nfcManager_getDefaultMifareCLTRoute}, |
| #if(NXP_EXTNS == TRUE) |
| {"getDefaultAidPowerState", "()I", |
| (void*) nfcManager_getDefaultAidPowerState}, |
| |
| {"getDefaultDesfirePowerState", "()I", |
| (void*) nfcManager_getDefaultDesfirePowerState}, |
| |
| {"getDefaultMifareCLTPowerState", "()I", |
| (void*) nfcManager_getDefaultMifareCLTPowerState}, |
| #endif |
| {"doRegisterT3tIdentifier", "([B)I", |
| (void*) nfcManager_doRegisterT3tIdentifier}, |
| |
| {"doDeregisterT3tIdentifier", "(I)V", |
| (void*) nfcManager_doDeregisterT3tIdentifier}, |
| |
| {"getLfT3tMax", "()I", |
| (void*) nfcManager_getLfT3tMax}, |
| |
| {"doEnableDiscovery", "(IZZZZZ)V", |
| (void*) nfcManager_enableDiscovery}, |
| |
| {"doGetSecureElementList", "()[I", |
| (void *)nfcManager_doGetSecureElementList}, |
| |
| {"doSelectSecureElement", "(I)V", |
| (void *)nfcManager_doSelectSecureElement}, |
| |
| {"doDeselectSecureElement", "(I)V", |
| (void *)nfcManager_doDeselectSecureElement}, |
| |
| {"doSetSEPowerOffState", "(IZ)V", |
| (void *)nfcManager_doSetSEPowerOffState}, |
| {"setDefaultTechRoute", "(III)V", |
| (void *)nfcManager_setDefaultTechRoute}, |
| |
| {"setDefaultProtoRoute", "(III)V", |
| (void *)nfcManager_setDefaultProtoRoute}, |
| |
| {"GetDefaultSE", "()I", |
| (void *)nfcManager_GetDefaultSE}, |
| |
| {"doCheckLlcp", "()Z", |
| (void *)nfcManager_doCheckLlcp}, |
| |
| {"doActivateLlcp", "()Z", |
| (void *)nfcManager_doActivateLlcp}, |
| |
| {"doCreateLlcpConnectionlessSocket", "(ILjava/lang/String;)Lcom/android/nfc/dhimpl/NativeLlcpConnectionlessSocket;", |
| (void *)nfcManager_doCreateLlcpConnectionlessSocket}, |
| |
| {"doCreateLlcpServiceSocket", "(ILjava/lang/String;III)Lcom/android/nfc/dhimpl/NativeLlcpServiceSocket;", |
| (void*) nfcManager_doCreateLlcpServiceSocket}, |
| |
| {"doCreateLlcpSocket", "(IIII)Lcom/android/nfc/dhimpl/NativeLlcpSocket;", |
| (void*) nfcManager_doCreateLlcpSocket}, |
| |
| {"doGetLastError", "()I", |
| (void*) nfcManager_doGetLastError}, |
| |
| {"disableDiscovery", "()V", |
| (void*) nfcManager_disableDiscovery}, |
| |
| {"doSetTimeout", "(II)Z", |
| (void *)nfcManager_doSetTimeout}, |
| |
| {"doGetTimeout", "(I)I", |
| (void *)nfcManager_doGetTimeout}, |
| |
| {"doResetTimeouts", "()V", |
| (void *)nfcManager_doResetTimeouts}, |
| |
| {"doAbort", "()V", |
| (void *)nfcManager_doAbort}, |
| |
| {"doSetP2pInitiatorModes", "(I)V", |
| (void *)nfcManager_doSetP2pInitiatorModes}, |
| |
| {"doSetP2pTargetModes", "(I)V", |
| (void *)nfcManager_doSetP2pTargetModes}, |
| |
| {"doEnableScreenOffSuspend", "()V", |
| (void *)nfcManager_doEnableScreenOffSuspend}, |
| |
| {"doDisableScreenOffSuspend", "()V", |
| (void *)nfcManager_doDisableScreenOffSuspend}, |
| |
| {"doDump", "()Ljava/lang/String;", |
| (void *)nfcManager_doDump}, |
| |
| {"getChipVer", "()I", |
| (void *)nfcManager_getChipVer}, |
| |
| {"getFwFileName", "()[B", |
| (void *)nfcManager_getFwFileName}, |
| |
| {"JCOSDownload", "()I", |
| (void *)nfcManager_doJcosDownload}, |
| {"doCommitRouting", "()V", |
| (void *)nfcManager_doCommitRouting}, |
| #if(NXP_EXTNS == TRUE) |
| {"doSetNfcMode", "(I)V", |
| (void *)nfcManager_doSetNfcMode}, |
| #endif |
| {"doGetSecureElementTechList", "()I", |
| (void *)nfcManager_getSecureElementTechList}, |
| |
| {"doGetActiveSecureElementList", "()[I", |
| (void *)nfcManager_getActiveSecureElementList}, |
| |
| {"doGetSecureElementUid", "()[B", |
| (void *)nfcManager_getSecureElementUid}, |
| |
| {"setEmvCoPollProfile", "(ZI)I", |
| (void *)nfcManager_setEmvCoPollProfile}, |
| |
| {"doSetSecureElementListenTechMask", "(I)V", |
| (void *)nfcManager_setSecureElementListenTechMask}, |
| {"doSetScreenState", "(I)V", |
| (void*)nfcManager_doSetScreenState}, |
| {"doSetScreenOrPowerState", "(I)V", |
| (void*)nfcManager_doSetScreenOrPowerState}, |
| //Factory Test Code |
| {"doPrbsOn", "(IIII)V", |
| (void *)nfcManager_doPrbsOn}, |
| {"doPrbsOff", "()V", |
| (void *)nfcManager_doPrbsOff}, |
| // SWP self test |
| {"SWPSelfTest", "(I)I", |
| (void *)nfcManager_SWPSelfTest}, |
| // check firmware version |
| {"getFWVersion", "()I", |
| (void *)nfcManager_getFwVersion}, |
| #if((NFC_NXP_ESE == TRUE) && ((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551))) |
| {"setEtsiReaederState", "(I)V", |
| (void *)nfcManager_dosetEtsiReaederState}, |
| |
| {"getEtsiReaederState", "()I", |
| (void *)nfcManager_dogetEtsiReaederState}, |
| |
| {"etsiReaderConfig", "(I)V", |
| (void *)nfcManager_doEtsiReaderConfig}, |
| |
| {"etsiResetReaderConfig", "()V", |
| (void *)nfcManager_doEtsiResetReaderConfig}, |
| |
| {"notifyEEReaderEvent", "(I)V", |
| (void *)nfcManager_doNotifyEEReaderEvent}, |
| |
| {"etsiInitConfig", "()V", |
| (void *)nfcManager_doEtsiInitConfig}, |
| |
| {"updateScreenState", "()V", |
| (void *)nfcManager_doUpdateScreenState}, |
| #endif |
| #if(NXP_EXTNS == TRUE) |
| {"doEnablep2p", "(Z)V", |
| (void*)nfcManager_Enablep2p}, |
| {"doSetProvisionMode", "(Z)V", |
| (void *)nfcManager_setProvisionMode}, |
| {"doGetRouting", "()[B", |
| (void *)nfcManager_getRouting}, |
| {"getNfcInitTimeout", "()I", |
| (void *)nfcManager_getNfcInitTimeout}, |
| {"isVzwFeatureEnabled", "()Z", |
| (void *)nfcManager_isVzwFeatureEnabled}, |
| #endif |
| {"doSetEEPROM", "([B)V", |
| (void*)nfcManager_doSetEEPROM}, |
| {"doGetSeInterface","(I)I", |
| (void*)nfcManager_doGetSeInterface}, |
| //Factory Test Code |
| {"doCheckJcopDlAtBoot", "()Z", |
| (void *)nfcManager_doCheckJcopDlAtBoot}, |
| {"doEnableDtaMode", "()V", |
| (void*) nfcManager_doEnableDtaMode}, |
| {"doDisableDtaMode", "()V", |
| (void*) nfcManager_doDisableDtaMode} |
| #if(NXP_EXTNS == TRUE) |
| ,{"doselectUicc", "(I)I", |
| (void*) nfcManager_doSelectUicc}, |
| {"doGetSelectedUicc", "()I", |
| (void*) nfcManager_doGetSelectedUicc} |
| #endif |
| }; |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: register_com_android_nfc_NativeNfcManager |
| ** |
| ** Description: Regisgter JNI functions with Java Virtual Machine. |
| ** e: Environment of JVM. |
| ** |
| ** Returns: Status of registration. |
| ** |
| *******************************************************************************/ |
| int register_com_android_nfc_NativeNfcManager (JNIEnv *e) |
| { |
| ALOGD ("%s: enter", __FUNCTION__); |
| PowerSwitch::getInstance ().initialize (PowerSwitch::UNKNOWN_LEVEL); |
| ALOGD ("%s: exit", __FUNCTION__); |
| return jniRegisterNativeMethods (e, gNativeNfcManagerClassName, gMethods, NELEM (gMethods)); |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: startRfDiscovery |
| ** |
| ** Description: Ask stack to start polling and listening for devices. |
| ** isStart: Whether to start. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void startRfDiscovery(bool isStart) |
| { |
| tNFA_STATUS status = NFA_STATUS_FAILED; |
| |
| ALOGD ("%s: is start=%d", __FUNCTION__, isStart); |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| status = isStart ? NFA_StartRfDiscovery () : NFA_StopRfDiscovery (); |
| if (status == NFA_STATUS_OK) |
| { |
| if(gGeneralPowershutDown == NFC_MODE_OFF) |
| sDiscCmdwhleNfcOff = true; |
| sNfaEnableDisablePollingEvent.wait (); //wait for NFA_RF_DISCOVERY_xxxx_EVT |
| sRfEnabled = isStart; |
| sDiscCmdwhleNfcOff = false; |
| } |
| else |
| { |
| ALOGE ("%s: Failed to start/stop RF discovery; error=0x%X", __FUNCTION__, status); |
| } |
| ALOGD ("%s: is exit=%d", __FUNCTION__, isStart); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: isDiscoveryStarted |
| ** |
| ** Description: Indicates whether the discovery is started. |
| ** |
| ** Returns: True if discovery is started |
| ** |
| *******************************************************************************/ |
| bool isDiscoveryStarted () |
| { |
| return sRfEnabled; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: notifyPollingEventwhileNfcOff |
| ** |
| ** Description: Notifies sNfaEnableDisablePollingEvent if tag operations |
| ** is in progress at the time Nfc Off is in progress to avoid |
| ** NFC off thread infinite block. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void notifyPollingEventwhileNfcOff() |
| { |
| ALOGD ("%s: sDiscCmdwhleNfcOff=%x", __FUNCTION__, sDiscCmdwhleNfcOff); |
| if(sDiscCmdwhleNfcOff == true) |
| { |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| sNfaEnableDisablePollingEvent.notifyOne (); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: doStartupConfig |
| ** |
| ** Description: Configure the NFC controller. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void doStartupConfig() |
| { |
| struct nfc_jni_native_data *nat = getNative(0, 0); |
| tNFA_STATUS stat = NFA_STATUS_FAILED; |
| int actualLen = 0; |
| |
| // If polling for Active mode, set the ordering so that we choose Active over Passive mode first. |
| if (nat && (nat->tech_mask & (NFA_TECHNOLOGY_MASK_A_ACTIVE | NFA_TECHNOLOGY_MASK_F_ACTIVE))) |
| { |
| UINT8 act_mode_order_param[] = { 0x01 }; |
| SyncEventGuard guard (sNfaSetConfigEvent); |
| stat = NFA_SetConfig(NCI_PARAM_ID_ACT_ORDER, sizeof(act_mode_order_param), &act_mode_order_param[0]); |
| if (stat == NFA_STATUS_OK) |
| sNfaSetConfigEvent.wait (); |
| } |
| |
| //configure RF polling frequency for each technology |
| static tNFA_DM_DISC_FREQ_CFG nfa_dm_disc_freq_cfg; |
| //values in the polling_frequency[] map to members of nfa_dm_disc_freq_cfg |
| UINT8 polling_frequency [8] = {1, 1, 1, 1, 1, 1, 1, 1}; |
| actualLen = GetStrValue(NAME_POLL_FREQUENCY, (char*)polling_frequency, 8); |
| if (actualLen == 8) |
| { |
| ALOGD ("%s: polling frequency", __FUNCTION__); |
| memset (&nfa_dm_disc_freq_cfg, 0, sizeof(nfa_dm_disc_freq_cfg)); |
| nfa_dm_disc_freq_cfg.pa = polling_frequency [0]; |
| nfa_dm_disc_freq_cfg.pb = polling_frequency [1]; |
| nfa_dm_disc_freq_cfg.pf = polling_frequency [2]; |
| nfa_dm_disc_freq_cfg.pi93 = polling_frequency [3]; |
| nfa_dm_disc_freq_cfg.pbp = polling_frequency [4]; |
| nfa_dm_disc_freq_cfg.pk = polling_frequency [5]; |
| nfa_dm_disc_freq_cfg.paa = polling_frequency [6]; |
| nfa_dm_disc_freq_cfg.pfa = polling_frequency [7]; |
| p_nfa_dm_rf_disc_freq_cfg = &nfa_dm_disc_freq_cfg; |
| } |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_isNfcActive |
| ** |
| ** Description: Used externaly to determine if NFC is active or not. |
| ** |
| ** Returns: 'true' if the NFC stack is running, else 'false'. |
| ** |
| *******************************************************************************/ |
| bool nfcManager_isNfcActive() |
| { |
| return sIsNfaEnabled; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: startStopPolling |
| ** |
| ** Description: Start or stop polling. |
| ** isStartPolling: true to start polling; false to stop polling. |
| ** |
| ** Returns: None. |
| ** |
| *******************************************************************************/ |
| void startStopPolling (bool isStartPolling) |
| { |
| ALOGD ("%s: enter; isStart=%u", __FUNCTION__, isStartPolling); |
| startRfDiscovery (false); |
| |
| if (isStartPolling) startPolling_rfDiscoveryDisabled(0); |
| else stopPolling_rfDiscoveryDisabled(); |
| |
| startRfDiscovery (true); |
| ALOGD ("%s: exit", __FUNCTION__); |
| } |
| |
| static tNFA_STATUS startPolling_rfDiscoveryDisabled(tNFA_TECHNOLOGY_MASK tech_mask) { |
| tNFA_STATUS stat = NFA_STATUS_FAILED; |
| |
| unsigned long num = 0; |
| |
| if (tech_mask == 0 && GetNumValue(NAME_POLLING_TECH_MASK, &num, sizeof(num))) |
| tech_mask = num; |
| else if (tech_mask == 0) tech_mask = DEFAULT_TECH_MASK; |
| |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| ALOGD ("%s: enable polling", __FUNCTION__); |
| stat = NFA_EnablePolling (tech_mask); |
| if (stat == NFA_STATUS_OK) |
| { |
| ALOGD ("%s: wait for enable event", __FUNCTION__); |
| sPollingEnabled = true; |
| sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_ENABLED_EVT |
| } |
| else |
| { |
| ALOGE ("%s: fail enable polling; error=0x%X", __FUNCTION__, stat); |
| } |
| |
| return stat; |
| } |
| |
| static tNFA_STATUS stopPolling_rfDiscoveryDisabled() { |
| tNFA_STATUS stat = NFA_STATUS_FAILED; |
| |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| ALOGD ("%s: disable polling", __FUNCTION__); |
| stat = NFA_DisablePolling (); |
| if (stat == NFA_STATUS_OK) { |
| sPollingEnabled = false; |
| sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_DISABLED_EVT |
| } else { |
| ALOGE ("%s: fail disable polling; error=0x%X", __FUNCTION__, stat); |
| } |
| |
| return stat; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_getChipVer |
| ** |
| ** Description: Gets the chip version. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None 0x00 |
| ** PN547C2 0x01 |
| ** PN65T 0x02 . |
| ** |
| *******************************************************************************/ |
| static int nfcManager_getChipVer(JNIEnv* e, jobject o) |
| { |
| (void)e; |
| (void)o; |
| ALOGD ("%s: enter", __FUNCTION__); |
| unsigned long num =0; |
| |
| GetNxpNumValue(NAME_NXP_NFC_CHIP, (void *)&num, sizeof(num)); |
| ALOGD ("%d: nfcManager_getChipVer", num); |
| return num; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_getFwFileName |
| ** |
| ** Description: Read Fw file name from config file. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: jbyteArray: File name read from config file |
| ** NULL in case file name not found |
| ** |
| *******************************************************************************/ |
| static jbyteArray nfcManager_getFwFileName(JNIEnv* e, jobject o) |
| { |
| (void)o; |
| ALOGD ("%s: enter", __FUNCTION__); |
| char fwFileName[256]; |
| int fileLen = 0; |
| jbyteArray jbuff = NULL; |
| |
| if(GetNxpStrValue(NAME_NXP_FW_NAME, (char*)fwFileName, sizeof(fwFileName)) == TRUE) |
| { |
| ALOGD ("%s: FW_NAME read success = %s", __FUNCTION__, fwFileName); |
| fileLen = strlen(fwFileName); |
| jbuff = e->NewByteArray (fileLen); |
| e->SetByteArrayRegion (jbuff, 0, fileLen, (jbyte*) fwFileName); |
| } |
| else |
| { |
| ALOGD ("%s: FW_NAME not found", __FUNCTION__); |
| } |
| |
| return jbuff; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: DWPChannel_init |
| ** |
| ** Description: Initializes the DWP channel functions. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| #if (NFC_NXP_ESE == TRUE) |
| void DWPChannel_init(IChannel_t *DWP) |
| { |
| ALOGD ("%s: enter", __FUNCTION__); |
| DWP->open = open; |
| DWP->close = close; |
| DWP->transceive = transceive; |
| DWP->doeSE_Reset = doeSE_Reset; |
| } |
| #endif |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doJcosDownload |
| ** |
| ** Description: start jcos download. |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: True if ok. |
| ** |
| *******************************************************************************/ |
| static int nfcManager_doJcosDownload(JNIEnv* e, jobject o) |
| { |
| (void)e; |
| (void)o; |
| #if (NFC_NXP_ESE == TRUE) |
| ALOGD ("%s: enter", __FUNCTION__); |
| tNFA_STATUS status, tStatus; |
| bool stat = false; |
| UINT8 param; |
| status, tStatus= NFA_STATUS_FAILED; |
| |
| if (sRfEnabled) { |
| // Stop RF Discovery if we were polling |
| startRfDiscovery (false); |
| } |
| DWPChannel_init(&Dwp); |
| status = JCDNLD_Init(&Dwp); |
| if(status != NFA_STATUS_OK) |
| { |
| ALOGE("%s: JCDND initialization failed", __FUNCTION__); |
| } |
| else |
| { |
| #if 0 |
| param = 0x00; //Disable standby |
| SyncEventGuard guard (sNfaVSCResponseEvent); |
| tStatus = NFA_SendVsCommand (0x00,sizeof(param),¶m,nfaVSCCallback); |
| if(NFA_STATUS_OK == tStatus) |
| { |
| sNfaVSCResponseEvent.wait(); //wait for NFA VS command to finish |
| ALOGE("%s: start JcopOs_Download", __FUNCTION__); |
| status = JCDNLD_StartDownload(); |
| } |
| #endif |
| ALOGE("%s: start JcopOs_Download", __FUNCTION__); |
| status = JCDNLD_StartDownload(); |
| } |
| |
| #if 0 |
| param = 0x01; //Enable standby |
| SyncEventGuard guard (sNfaVSCResponseEvent); |
| tStatus = NFA_SendVsCommand (0x00,sizeof(param),¶m,nfaVSCCallback); |
| if(NFA_STATUS_OK == tStatus) |
| { |
| sNfaVSCResponseEvent.wait(); //wait for NFA VS command to finish |
| |
| } |
| #endif |
| stat = JCDNLD_DeInit(); |
| /*If Nfc OFF/deinitialization happening dont perform RF discovery*/ |
| if(dwpChannelForceClose == false) |
| startRfDiscovery (true); |
| |
| ALOGD ("%s: exit; status =0x%X", __FUNCTION__,status); |
| #else |
| tNFA_STATUS status = 0x0F; |
| ALOGD ("%s: No p61", __FUNCTION__); |
| #endif |
| return status; |
| } |
| |
| static void nfcManager_doCommitRouting(JNIEnv* e, jobject o) |
| { |
| (void)e; |
| (void)o; |
| ALOGD ("%s: enter", __FUNCTION__); |
| PowerSwitch::getInstance ().setLevel (PowerSwitch::FULL_POWER); |
| PowerSwitch::getInstance ().setModeOn (PowerSwitch::HOST_ROUTING); |
| if (sRfEnabled) { |
| // Stop RF discovery to reconfigure |
| startRfDiscovery(false); |
| } |
| RoutingManager::getInstance().commitRouting(); |
| startRfDiscovery(true); |
| ALOGD ("%s: exit", __FUNCTION__); |
| |
| } |
| #if(NXP_EXTNS == TRUE) |
| static void nfcManager_doSetNfcMode(JNIEnv *e, jobject o, jint nfcMode) |
| { |
| /* Store the shutdown state */ |
| gGeneralPowershutDown = nfcMode; |
| } |
| #endif |
| |
| bool isNfcInitializationDone() |
| { |
| return sIsNfaEnabled; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: StoreScreenState |
| ** |
| ** Description: Sets screen state |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void StoreScreenState(int state) |
| { |
| ALOGD ("%s: enter", __FUNCTION__); |
| screenstate = state; |
| nfc_ncif_storeScreenState(state); |
| ALOGD ("%s: exit", __FUNCTION__); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: getScreenState |
| ** |
| ** Description: returns screen state |
| ** |
| ** Returns: int |
| ** |
| *******************************************************************************/ |
| int getScreenState() |
| { |
| return screenstate; |
| } |
| |
| #if(NFC_NXP_ESE == TRUE && ((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551))) |
| /******************************************************************************* |
| ** |
| ** Function: isp2pActivated |
| ** |
| ** Description: returns p2pActive state |
| ** |
| ** Returns: bool |
| ** |
| *******************************************************************************/ |
| bool isp2pActivated() |
| { |
| return sP2pActive; |
| } |
| #endif |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doSetScreenState |
| ** |
| ** Description: Set screen state |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doSetScreenState (JNIEnv* e, jobject o, jint state) |
| { |
| tNFA_STATUS status = NFA_STATUS_OK; |
| unsigned long auto_num = 0; |
| uint8_t standby_num = 0x00; |
| uint8_t *buffer = NULL; |
| long bufflen = 260; |
| long retlen = 0; |
| int isfound; |
| |
| ALOGD ("%s: state = %d", __FUNCTION__, state); |
| if (sIsDisabling || !sIsNfaEnabled) |
| return; |
| if(get_transcation_stat() == true) |
| { |
| ALOGD("Payment is in progress stopping enable/disable discovery"); |
| set_lastScreenStateRequest((eScreenState_t)state); |
| pendingScreenState = true; |
| return; |
| } |
| int old = getScreenState(); |
| if(old == state) { |
| ALOGD("Screen state is not changed."); |
| return; |
| } |
| acquireRfInterfaceMutexLock(); |
| if (state) { |
| if (sRfEnabled) { |
| // Stop RF discovery to reconfigure |
| startRfDiscovery(false); |
| } |
| |
| if(state == NFA_SCREEN_STATE_LOCKED || state == NFA_SCREEN_STATE_OFF) |
| { |
| SyncEventGuard guard (sNfaEnableDisablePollingEvent); |
| status = NFA_DisablePolling (); |
| if (status == NFA_STATUS_OK) |
| { |
| sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_DISABLED_EVT |
| }else |
| ALOGE ("%s: Failed to disable polling; error=0x%X", __FUNCTION__, status); |
| } |
| |
| if(GetNxpNumValue(NAME_NXP_CORE_SCRN_OFF_AUTONOMOUS_ENABLE,&auto_num ,sizeof(auto_num))) |
| { |
| ALOGD ("%s: enter; NAME_NXP_CORE_SCRN_OFF_AUTONOMOUS_ENABLE = %02x", __FUNCTION__, auto_num); |
| } |
| if(auto_num == 0x01) |
| { |
| buffer = (uint8_t*) malloc(bufflen*sizeof(uint8_t)); |
| if(buffer == NULL) |
| { |
| ALOGD ("%s: enter; NAME_NXP_CORE_STANDBY buffer is NULL", __FUNCTION__); |
| } |
| else |
| { |
| isfound = GetNxpByteArrayValue(NAME_NXP_CORE_STANDBY, (char *) buffer,bufflen, &retlen); |
| if (retlen > 0) |
| { |
| standby_num = buffer[3]; |
| ALOGD ("%s: enter; NAME_NXP_CORE_STANDBY = %02x", __FUNCTION__, standby_num); |
| SendAutonomousMode(state,standby_num); |
| } |
| else |
| { |
| ALOGD ("%s: enter; NAME_NXP_CORE_STANDBY = %02x", __FUNCTION__, standby_num); |
| SendAutonomousMode(state , standby_num); |
| } |
| } |
| } |
| else |
| { |
| ALOGD ("%s: enter; NAME_NXP_CORE_SCRN_OFF_AUTONOMOUS_ENABLE = %02x", __FUNCTION__, auto_num); |
| } |
| if(buffer) |
| { |
| free(buffer); |
| } |
| |
| status = SetScreenState(state); |
| if (status != NFA_STATUS_OK) |
| { |
| ALOGE ("%s: fail enable SetScreenState; error=0x%X", __FUNCTION__, status); |
| } |
| else |
| { |
| if ((old == NFA_SCREEN_STATE_OFF && state == NFA_SCREEN_STATE_LOCKED)|| |
| #if(NXP_EXTNS == TRUE) |
| (old == NFA_SCREEN_STATE_LOCKED && state == NFA_SCREEN_STATE_UNLOCKED && sProvisionMode)|| |
| #endif |
| (old == NFA_SCREEN_STATE_LOCKED && state == NFA_SCREEN_STATE_OFF && sIsSecElemSelected)) |
| { |
| startRfDiscovery(true); |
| } |
| StoreScreenState(state); |
| } |
| } |
| releaseRfInterfaceMutexLock(); |
| } |
| #if(NXP_EXTNS == TRUE) |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doSetScreenOrPowerState |
| ** This function combines both screen state and power state(ven power) values. |
| ** |
| ** Description: Set screen or power state |
| ** e: JVM environment. |
| ** o: Java object. |
| ** state:represents power or screen state (0-3 screen state),6 (power on),7(power off) |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfcManager_doSetScreenOrPowerState (JNIEnv* e, jobject o, jint state) |
| { |
| tNFA_STATUS stat = NFA_STATUS_OK; |
| ALOGE ("%s: Enter", __FUNCTION__); |
| if (state <= NFA_SCREEN_STATE_UNLOCKED ) // SCREEN_STATE |
| nfcManager_doSetScreenState(e, o, state); |
| else if (state == VEN_POWER_STATE_ON) // POWER_ON NFC_OFF |
| { |
| nfcManager_doSetNfcMode(e , o, NFC_MODE_OFF); |
| } |
| else if (state == VEN_POWER_STATE_OFF) // POWER_OFF |
| { |
| if(sIsNfaEnabled) |
| { |
| nfcManager_doSetNfcMode(e , o, NFC_MODE_ON); |
| } |
| else |
| { |
| nfcManager_doSetNfcMode(e , o, NFC_MODE_OFF); |
| } |
| } |
| else |
| ALOGE ("%s: unknown screen or power state. state=%d", __FUNCTION__, state); |
| } |
| #endif |
| /******************************************************************************* |
| ** |
| ** Function: get_last_request |
| ** |
| ** Description: returns the last enable/disable discovery event |
| ** |
| ** Returns: last request (char) . |
| ** |
| *******************************************************************************/ |
| static char get_last_request() |
| { |
| return(transaction_data.last_request); |
| } |
| /******************************************************************************* |
| ** |
| ** Function: set_last_request |
| ** |
| ** Description: stores the last enable/disable discovery event |
| ** |
| ** Returns: None . |
| ** |
| *******************************************************************************/ |
| static void set_last_request(char status, struct nfc_jni_native_data *nat) |
| { |
| transaction_data.last_request = status; |
| if (nat != NULL) |
| { |
| transaction_data.transaction_nat = nat; |
| } |
| } |
| #if(NXP_EXTNS == TRUE) |
| /******************************************************************************* |
| ** |
| ** Function: set_transcation_stat |
| ** |
| ** Description: updates the transaction status |
| ** |
| ** Returns: None . |
| ** |
| *******************************************************************************/ |
| void set_transcation_stat(bool result) |
| { |
| ALOGD ("%s: %d", __FUNCTION__, result); |
| transaction_data.trans_in_progress = result; |
| } |
| |
| #endif |
| /******************************************************************************* |
| ** |
| ** Function: get_lastScreenStateRequest |
| ** |
| ** Description: returns the last screen state request |
| ** |
| ** Returns: last screen state request event (eScreenState_t) . |
| ** |
| *******************************************************************************/ |
| static eScreenState_t get_lastScreenStateRequest() |
| { |
| ALOGD ("%s: %d", __FUNCTION__, transaction_data.last_screen_state_request); |
| return(transaction_data.last_screen_state_request); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: set_lastScreenStateRequest |
| ** |
| ** Description: stores the last screen state request |
| ** |
| ** Returns: None . |
| ** |
| *******************************************************************************/ |
| static void set_lastScreenStateRequest(eScreenState_t status) |
| { |
| ALOGD ("%s: current=%d, new=%d", __FUNCTION__, transaction_data.last_screen_state_request, status); |
| transaction_data.last_screen_state_request = status; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: switchBackTimerProc_transaction |
| ** |
| ** Description: Callback function for interval timer. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void cleanupTimerProc_transaction(union sigval) |
| { |
| ALOGD("Inside cleanupTimerProc"); |
| cleanup_timer(); |
| } |
| |
| void cleanup_timer() |
| { |
| ALOGD("Inside cleanup"); |
| //set_transcation_stat(false); |
| pthread_t transaction_thread; |
| int irret = -1; |
| ALOGD ("%s", __FUNCTION__); |
| |
| /* Transcation is done process the last request*/ |
| pthread_attr_t attr; |
| pthread_attr_init(&attr); |
| pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); |
| irret = pthread_create(&transaction_thread, &attr, enableThread, NULL); |
| if(irret != 0) |
| { |
| ALOGE("Unable to create the thread"); |
| } |
| pthread_attr_destroy(&attr); |
| transaction_data.current_transcation_state = NFA_TRANS_DM_RF_TRANS_END; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: get_transcation_stat |
| ** |
| ** Description: returns the transaction status whether it is in progress |
| ** |
| ** Returns: bool . |
| ** |
| *******************************************************************************/ |
| static bool get_transcation_stat(void) |
| { |
| return( transaction_data.trans_in_progress); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: config_swp_reader_mode |
| ** |
| ** Description: handles the screen state during swp reader mode |
| ** |
| ** Returns: None. |
| ** |
| *******************************************************************************/ |
| void config_swp_reader_mode(bool mode) |
| { |
| eScreenState_t last_screen_state_request; |
| if(mode == true) |
| { |
| set_transcation_stat(true); |
| } |
| else |
| { |
| set_transcation_stat(false); |
| if(pendingScreenState == true) |
| { |
| pendingScreenState = false; |
| last_screen_state_request = get_lastScreenStateRequest(); |
| nfcManager_doSetScreenState(NULL,NULL,last_screen_state_request); |
| } |
| |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: checkforTranscation |
| ** |
| ** Description: Receive connection-related events from stack. |
| ** connEvent: Event code. |
| ** eventData: Event data. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| void checkforTranscation(UINT8 connEvent, void* eventData) |
| { |
| tNFA_CONN_EVT_DATA *eventAct_Data = (tNFA_CONN_EVT_DATA*) eventData; |
| tNFA_DM_CBACK_DATA* eventDM_Conn_data = (tNFA_DM_CBACK_DATA *) eventData; |
| tNFA_EE_CBACK_DATA* ee_action_data = (tNFA_EE_CBACK_DATA *) eventData; |
| tNFA_EE_ACTION& action = ee_action_data->action; |
| ALOGD ("%s: enter; event=0x%X transaction_data.current_transcation_state = 0x%x", __FUNCTION__, connEvent, |
| transaction_data.current_transcation_state); |
| switch(connEvent) |
| { |
| case NFA_ACTIVATED_EVT: |
| if((eventAct_Data->activated.activate_ntf.protocol != NFA_PROTOCOL_NFC_DEP) && (isListenMode(eventAct_Data->activated))) |
| { |
| ALOGD("ACTIVATED_EVT setting flag"); |
| transaction_data.current_transcation_state = NFA_TRANS_ACTIVATED_EVT; |
| set_transcation_stat(true); |
| }else{ |
| // ALOGD("other event clearing flag "); |
| // memset(&transaction_data, 0x00, sizeof(Transcation_Check_t)); |
| } |
| break; |
| case NFA_EE_ACTION_EVT: |
| if (transaction_data.current_transcation_state == NFA_TRANS_DEFAULT |
| || transaction_data.current_transcation_state == NFA_TRANS_ACTIVATED_EVT) |
| { |
| if(getScreenState() == NFA_SCREEN_STATE_OFF) |
| { |
| if (!sP2pActive && eventDM_Conn_data->rf_field.status == NFA_STATUS_OK) |
| SecureElement::getInstance().notifyRfFieldEvent (true); |
| } |
| #if((NFC_NXP_CHIP_TYPE != PN548C2) && (NFC_NXP_CHIP_TYPE != PN551)) |
| if((action.param.technology == NFC_RF_TECHNOLOGY_A)&&(( getScreenState () == NFA_SCREEN_STATE_OFF || getScreenState () == NFA_SCREEN_STATE_LOCKED))) |
| { |
| transaction_data.current_transcation_state = NFA_TRANS_MIFARE_ACT_EVT; |
| set_transcation_stat(true); |
| } |
| else |
| #endif |
| { |
| transaction_data.current_transcation_state = NFA_TRANS_EE_ACTION_EVT; |
| set_transcation_stat(true); |
| } |
| } |
| break; |
| case NFA_TRANS_CE_ACTIVATED: |
| if (transaction_data.current_transcation_state == NFA_TRANS_DEFAULT || transaction_data.current_transcation_state == NFA_TRANS_ACTIVATED_EVT) |
| { |
| if(getScreenState() == NFA_SCREEN_STATE_OFF) |
| { |
| if (!sP2pActive && eventDM_Conn_data->rf_field.status == NFA_STATUS_OK) |
| SecureElement::getInstance().notifyRfFieldEvent (true); |
| } |
| transaction_data.current_transcation_state = NFA_TRANS_CE_ACTIVATED; |
| set_transcation_stat(true); |
| } |
| break; |
| case NFA_TRANS_CE_DEACTIVATED: |
| if (transaction_data.current_transcation_state == NFA_TRANS_CE_ACTIVATED) |
| { |
| transaction_data.current_transcation_state = NFA_TRANS_CE_DEACTIVATED; |
| } |
| break; |
| #if (NFC_NXP_CHIP_TYPE == PN547C2) |
| case NFA_DEACTIVATED_EVT: |
| if(transaction_data.current_transcation_state == NFA_TRANS_MIFARE_ACT_EVT) |
| { |
| cleanup_timer(); |
| } |
| break; |
| #endif |
| case NFA_TRANS_DM_RF_FIELD_EVT: |
| if (eventDM_Conn_data->rf_field.status == NFA_STATUS_OK && |
| (transaction_data.current_transcation_state == NFA_TRANS_EE_ACTION_EVT |
| || transaction_data.current_transcation_state == NFA_TRANS_CE_DEACTIVATED) |
| && eventDM_Conn_data->rf_field.rf_field_status == 0) |
| { |
| ALOGD("start_timer"); |
| #if((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551)) |
| set_AGC_process_state(false); |
| #endif |
| transaction_data.current_transcation_state = NFA_TRANS_DM_RF_FIELD_EVT_OFF; |
| scleanupTimerProc_transaction.set (50, cleanupTimerProc_transaction); |
| } |
| else if (eventDM_Conn_data->rf_field.status == NFA_STATUS_OK && |
| transaction_data.current_transcation_state == NFA_TRANS_DM_RF_FIELD_EVT_OFF && |
| eventDM_Conn_data->rf_field.rf_field_status == 1) |
| { |
| #if((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551)) |
| nfcManagerEnableAGCDebug(connEvent); |
| #endif |
| transaction_data.current_transcation_state = NFA_TRANS_DM_RF_FIELD_EVT_ON; |
| ALOGD("Payment is in progress hold the screen on/off request "); |
| transaction_data.current_transcation_state = NFA_TRANS_DM_RF_TRANS_START; |
| scleanupTimerProc_transaction.kill (); |
| |
| } |
| else if (eventDM_Conn_data->rf_field.status == NFA_STATUS_OK && |
| transaction_data.current_transcation_state == NFA_TRANS_DM_RF_TRANS_START && |
| eventDM_Conn_data->rf_field.rf_field_status == 0) |
| { |
| ALOGD("Transcation is done"); |
| #if((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551)) |
| set_AGC_process_state(false); |
| #endif |
| transaction_data.current_transcation_state = NFA_TRANS_DM_RF_TRANS_PROGRESS; |
| //set_transcation_stat(false); |
| cleanup_timer(); |
| }else if(eventDM_Conn_data->rf_field.status == NFA_STATUS_OK && |
| transaction_data.current_transcation_state == NFA_TRANS_ACTIVATED_EVT && |
| eventDM_Conn_data->rf_field.rf_field_status == 0) |
| { |
| |
| ALOGD("No transaction done cleaning up the variables"); |
| cleanup_timer(); |
| } |
| break; |
| default: |
| break; |
| } |
| |
| ALOGD ("%s: exit; event=0x%X transaction_data.current_transcation_state = 0x%x", __FUNCTION__, connEvent, |
| transaction_data.current_transcation_state); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: enableThread |
| ** |
| ** Description: thread to trigger enable/disable discovery related events |
| ** |
| ** Returns: None . |
| ** |
| *******************************************************************************/ |
| void *enableThread(void *arg) |
| { |
| (void)arg; |
| ALOGD ("%s: enter", __FUNCTION__); |
| char last_request = get_last_request(); |
| eScreenState_t last_screen_state_request = get_lastScreenStateRequest(); |
| #if((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551)) |
| set_AGC_process_state(false); |
| #endif |
| set_transcation_stat(false); |
| bool screen_lock_flag = false; |
| bool disable_discovery = false; |
| |
| if(sIsNfaEnabled != true || sIsDisabling == true) |
| goto TheEnd; |
| |
| if (last_screen_state_request != NFA_SCREEN_STATE_DEFAULT) |
| { |
| ALOGD("update last screen state request: %d", last_screen_state_request); |
| nfcManager_doSetScreenState(NULL, NULL, last_screen_state_request); |
| if( last_screen_state_request == NFA_SCREEN_STATE_LOCKED) |
| screen_lock_flag = true; |
| } |
| else |
| { |
| ALOGD("No request pending"); |
| } |
| |
| |
| if (last_request == 1) |
| { |
| ALOGD("send the last request enable"); |
| sDiscoveryEnabled = false; |
| sPollingEnabled = false; |
| |
| nfcManager_enableDiscovery(NULL, NULL, transaction_data.discovery_params.technologies_mask, transaction_data.discovery_params.enable_lptd, |
| transaction_data.discovery_params.reader_mode, transaction_data.discovery_params.enable_host_routing, |
| transaction_data.discovery_params.enable_p2p,transaction_data.discovery_params.restart); |
| } |
| else if (last_request == 2) |
| { |
| ALOGD("send the last request disable"); |
| nfcManager_disableDiscovery(NULL, NULL); |
| disable_discovery = true; |
| } |
| #if(NXP_EXTNS == TRUE) |
| else if (last_request == 3) |
| { |
| ALOGD("send the last request to enable P2P "); |
| nfcManager_Enablep2p(NULL, NULL, transaction_data.discovery_params.enable_p2p); |
| } |
| #endif |
| if(screen_lock_flag && disable_discovery) |
| { |
| |
| startRfDiscovery(true); |
| } |
| screen_lock_flag = false; |
| disable_discovery = false; |
| memset(&transaction_data, 0x00, sizeof(Transcation_Check_t)); |
| #if((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551)) |
| memset(&menableAGC_debug_t, 0x00, sizeof(enableAGC_debug_t)); |
| #endif |
| TheEnd: |
| ALOGD ("%s: exit", __FUNCTION__); |
| pthread_exit(NULL); |
| return NULL; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function sig_handler |
| ** |
| ** Description This function is used to handle the different types of |
| ** signal events. |
| ** |
| ** Returns None |
| ** |
| *******************************************************************************/ |
| void sig_handler(int signo) |
| { |
| switch (signo) |
| { |
| case SIGINT: |
| ALOGE("received SIGINT\n"); |
| break; |
| case SIGABRT: |
| ALOGE("received SIGABRT\n"); |
| NFA_HciW4eSETransaction_Complete(Wait); |
| break; |
| case SIGSEGV: |
| ALOGE("received SIGSEGV\n"); |
| break; |
| case SIGHUP: |
| ALOGE("received SIGHUP\n"); |
| break; |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfcManager_doGetSeInterface |
| ** |
| ** Description This function is used to get the eSE Client interfaces. |
| ** |
| ** Returns integer - Physical medium |
| ** |
| *******************************************************************************/ |
| static int nfcManager_doGetSeInterface(JNIEnv* e, jobject o, jint type) |
| { |
| unsigned long num = 0; |
| switch(type) |
| { |
| case LDR_SRVCE: |
| if(GetNxpNumValue (NAME_NXP_P61_LS_DEFAULT_INTERFACE, (void*)&num, sizeof(num))==false) |
| { |
| ALOGD ("NAME_NXP_P61_LS_DEFAULT_INTERFACE not found"); |
| num = 1; |
| } |
| break; |
| case JCOP_SRVCE: |
| if(GetNxpNumValue (NAME_NXP_P61_JCOP_DEFAULT_INTERFACE, (void*)&num, sizeof(num))==false) |
| { |
| ALOGD ("NAME_NXP_P61_JCOP_DEFAULT_INTERFACE not found"); |
| num = 1; |
| } |
| break; |
| case LTSM_SRVCE: |
| if(GetNxpNumValue (NAME_NXP_P61_LTSM_DEFAULT_INTERFACE, (void*)&num, sizeof(num))==false) |
| { |
| ALOGD ("NAME_NXP_P61_LTSM_DEFAULT_INTERFACE not found"); |
| num = 1; |
| } |
| break; |
| default: |
| break; |
| } |
| ALOGD ("%d: nfcManager_doGetSeInterface", num); |
| return num; |
| } |
| |
| #if(NXP_EXTNS == TRUE) |
| /********************************************************************************** |
| ** |
| ** Function: pollT3TThread |
| ** |
| ** Description: This thread sends commands to switch from P2P to T3T |
| ** When ReaderMode is enabled, When P2P is detected,Switch to T3T |
| ** with Frame RF interface and Poll for T3T |
| ** |
| ** Returns: None. |
| ** |
| **********************************************************************************/ |
| static void* pollT3TThread(void *arg) |
| { |
| ALOGD ("%s: enter", __FUNCTION__); |
| bool status=false; |
| |
| if (sReaderModeEnabled && (sTechMask == NFA_TECHNOLOGY_MASK_F)) |
| { |
| /*Deactivate RF to go to W4_HOST_SELECT state |
| *Send Select Command to Switch to FrameRF interface from NFCDEP interface |
| *After NFC-DEP activation with FrameRF Intf, invoke T3T Polling Cmd*/ |
| { |
| SyncEventGuard g (sRespCbEvent); |
| if (NFA_STATUS_OK != (status = NFA_Deactivate (TRUE))) //deactivate to sleep state |
| { |
| ALOGE ("%s: deactivate failed, status = %d", __FUNCTION__, status); |
| } |
| if (sRespCbEvent.wait (2000) == false) //if timeout occurred |
| { |
| ALOGE ("%s: timeout waiting for deactivate", __FUNCTION__); |
| } |
| } |
| { |
| SyncEventGuard g2 (sRespCbEvent); |
| ALOGD ("Switching RF Interface from NFC-DEP to FrameRF for T3T\n"); |
| if (NFA_STATUS_OK != (status = NFA_Select (*((UINT8*)arg), NFA_PROTOCOL_T3T, NFA_INTERFACE_FRAME))) |
| { |
| ALOGE ("%s: NFA_Select failed, status = %d", __FUNCTION__, status); |
| } |
| if (sRespCbEvent.wait (2000) == false) //if timeout occured |
| { |
| ALOGE ("%s: timeout waiting for select", __FUNCTION__); |
| } |
| } |
| } |
| ALOGD ("%s: exit", __FUNCTION__); |
| pthread_exit(NULL); |
| return NULL; |
| } |
| |
| /********************************************************************************** |
| ** |
| ** Function: switchP2PToT3TRead |
| ** |
| ** Description: Create a thread to change the RF interface by Deactivating to Sleep |
| ** |
| ** Returns: None. |
| ** |
| **********************************************************************************/ |
| static bool switchP2PToT3TRead(UINT8 disc_id) |
| { |
| pthread_t pollT3TThreadId; |
| int irret = -1; |
| ALOGD ("%s:entry", __FUNCTION__); |
| felicaReader_Disc_id = disc_id; |
| |
| /* Transcation is done process the last request*/ |
| pthread_attr_t attr; |
| pthread_attr_init(&attr); |
| pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); |
| irret = pthread_create(&pollT3TThreadId, &attr, pollT3TThread, (void*)&felicaReader_Disc_id); |
| if(irret != 0) |
| { |
| ALOGE("Unable to create the thread"); |
| } |
| pthread_attr_destroy(&attr); |
| ALOGD ("%s:exit", __FUNCTION__); |
| return irret; |
| } |
| |
| static void NxpResponsePropCmd_Cb(UINT8 event, UINT16 param_len, UINT8 *p_param) |
| { |
| ALOGD("NxpResponsePropCmd_Cb Received length data = 0x%x status = 0x%x", param_len, p_param[3]); |
| SyncEventGuard guard (sNfaNxpNtfEvent); |
| sNfaNxpNtfEvent.notifyOne (); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_setProvisionMode |
| ** |
| ** Description: set/reset provision mode |
| ** e: JVM environment. |
| ** o: Java object. |
| ** |
| ** Returns: None. |
| ** |
| *******************************************************************************/ |
| static void nfcManager_setProvisionMode(JNIEnv* e, jobject o, jboolean provisionMode) |
| { |
| ALOGD ("Enter :%s provisionMode = %d", __FUNCTION__,provisionMode); |
| sProvisionMode = provisionMode; |
| NFA_setProvisionMode(provisionMode); |
| // When disabling provisioning mode, make sure configuration of routing table is also updated |
| // this is required to make sure p2p is blocked during locked screen |
| if ( !provisionMode ) |
| { |
| RoutingManager::getInstance().commitRouting(); |
| } |
| } |
| |
| /********************************************************************************** |
| ** |
| ** Function: checkforNfceeBuffer |
| ** |
| ** Description: checking for the Nfcee Buffer (GetConfigs for SWP_INT_SESSION_ID (EA and EB)) |
| ** |
| ** Returns: None . |
| ** |
| **********************************************************************************/ |
| void checkforNfceeBuffer() |
| { |
| int i, count = 0; |
| |
| for(i=4;i<12;i++) |
| { |
| if(sConfig[i] == 0xff) |
| count++; |
| } |
| |
| if(count >= 8) |
| sNfceeConfigured = 1; |
| else |
| sNfceeConfigured = 0; |
| |
| memset (sConfig, 0, sizeof (sConfig)); |
| |
| } |
| /********************************************************************************** |
| ** |
| ** Function: checkforNfceeConfig |
| ** |
| ** Description: checking for the Nfcee is configured or not (GetConfigs for SWP_INT_SESSION_ID (EA and EB)) |
| ** |
| ** Returns: None . |
| ** |
| **********************************************************************************/ |
| void checkforNfceeConfig() |
| { |
| UINT8 uicc_flag = 0,ese_flag = 0; |
| |
| unsigned long timeout_buff_val=0,check_cnt=0,retry_cnt=0; |
| |
| tNFA_STATUS status; |
| tNFA_PMID param_ids_UICC[] = {0xA0, 0xEA}; |
| tNFA_PMID param_ids_eSE[] = {0xA0, 0xEB}; |
| |
| ALOGD ("%s: enter", __FUNCTION__); |
| |
| status = GetNxpNumValue(NAME_NXP_DEFAULT_NFCEE_TIMEOUT, (void*)&timeout_buff_val, sizeof(timeout_buff_val)); |
| |
| if(status == TRUE) |
| { |
| check_cnt = timeout_buff_val*RETRY_COUNT; |
| } |
| else |
| { |
| check_cnt = default_count*RETRY_COUNT; |
| } |
| |
| ALOGD ("NAME_DEFAULT_NFCEE_TIMEOUT = %lu", check_cnt); |
| |
| if(SecureElement::getInstance().getEeStatus(ESE_HANDLE) == NFC_NFCEE_STATUS_ACTIVE) |
| { |
| ese_flag = 0x01; |
| ALOGD("eSE_flag SET"); |
| } |
| if(SecureElement::getInstance().getEeStatus(UICC_HANDLE) == NFC_NFCEE_STATUS_ACTIVE) |
| { |
| uicc_flag = 0x01; |
| ALOGD("uicc_flag SET"); |
| } |
| |
| if((ese_flag == 0x01)||(uicc_flag == 0x01)) |
| { |
| |
| |
| if(uicc_flag) |
| { |
| sCheckNfceeFlag = 1; |
| { |
| SyncEventGuard guard (android::sNfaGetConfigEvent); |
| while(check_cnt > retry_cnt) |
| { |
| status = NFA_GetConfig(0x01,param_ids_UICC); |
| if(status == NFA_STATUS_OK) |
| { |
| android::sNfaGetConfigEvent.wait(); |
| } |
| |
| if(sNfceeConfigured == 1) |
| { |
| ALOGD("UICC Not Configured"); |
| } |
| else |
| { |
| ALOGD("UICC Configured"); |
| #if(NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE) |
| dualUiccInfo.uiccConfigStat = UICC_CONFIGURED; |
| #endif |
| break; |
| } |
| usleep(100000); |
| retry_cnt++; |
| } |
| } |
| |
| if(check_cnt <= retry_cnt) |
| ALOGE("UICC Not Configured"); |
| retry_cnt=0; |
| #if(NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE) |
| sCheckNfceeFlag = 0; |
| getUiccContext(); |
| #endif |
| } |
| |
| if(ese_flag) |
| { |
| sCheckNfceeFlag = 1; |
| { |
| SyncEventGuard guard (android::sNfaGetConfigEvent); |
| while(check_cnt > retry_cnt) |
| { |
| status = NFA_GetConfig(0x01,param_ids_eSE); |
| if(status == NFA_STATUS_OK) |
| { |
| android::sNfaGetConfigEvent.wait(); |
| } |
| |
| if(sNfceeConfigured == 1) |
| { |
| ALOGD("eSE Not Configured"); |
| } |
| else |
| { |
| ALOGD("eSE Configured"); |
| break; |
| } |
| |
| usleep(100000); |
| retry_cnt++; |
| } |
| } |
| if(check_cnt <= retry_cnt) |
| ALOGD("eSE Not Configured"); |
| retry_cnt=0; |
| } |
| } |
| RoutingManager::getInstance().handleSERemovedNtf(); |
| sCheckNfceeFlag = 0; |
| } |
| #endif |
| |
| #if(NXP_EXTNS == TRUE) |
| static void nfaNxpSelfTestNtfTimerCb (union sigval) |
| { |
| ALOGD ("%s", __FUNCTION__); |
| ALOGD("NXP SWP SelfTest : Can't get a notification about SWP Status!!"); |
| SyncEventGuard guard (sNfaNxpNtfEvent); |
| sNfaNxpNtfEvent.notifyOne (); |
| SetCbStatus(NFA_STATUS_FAILED); |
| } |
| |
| #if(NFC_NXP_STAT_DUAL_UICC_EXT_SWITCH == TRUE) |
| /********************************************************************************** |
| ** |
| ** Function: getUiccContext |
| ** |
| ** Description: Read and store UICC context values |
| ** Respective context will be applied during next switching |
| ** |
| ** Returns: None |
| ** |
| **********************************************************************************/ |
| static void getUiccContext() |
| { |
| UINT8 i; |
| tNFA_STATUS status; |
| tNFA_PMID param_ids_UICC_getContext[] = {0xA0, 0xF4}; |
| tNFA_PMID param_ids_UICC_getOtherContext[] = {0xA0, 0xF5}; |
| ALOGD ("%s: Enter", __FUNCTION__); |
| |
| SyncEventGuard guard (android::sNfaGetConfigEvent); |
| status = NFA_GetConfig(0x01,param_ids_UICC_getContext); |
| if(status == NFA_STATUS_OK) |
| { |
| android::sNfaGetConfigEvent.wait(); |
| } |
| |
| ALOGD ("%s: save UICC context Info : Len = %d", __FUNCTION__,sCurrentConfigLen); |
| /*If the session ID is changed or uicc changed*/ |
| if((dualUiccInfo.sUicc1CntxLen != 0)&&(sSelectedUicc == 0x01)) |
| { |
| for(i= 5 ; i < 13; i++) |
| { |
| if(sConfig[i] != dualUiccInfo.sUicc1Cntx[1]) |
| break; |
| } |
| if(i != 13) |
| { |
| memcpy(dualUiccInfo.sUicc1Cntx, sConfig, sCurrentConfigLen); |
| } |
| } |
| /*If the session ID is changed or uicc changed*/ |
| if((dualUiccInfo.sUicc2CntxLen != 0)&&(sSelectedUicc == 0x02)) |
| { |
| for(i= 5 ; i < 13; i++) |
| { |
| if(sConfig[i] != dualUiccInfo.sUicc2Cntx[1]) |
| break; |
| } |
| if(i != 13) |
| { |
| memcpy(dualUiccInfo.sUicc2Cntx, sConfig, sCurrentConfigLen); |
| } |
| } |
| |
| /*For the first power cycle for uicc1*/ |
| if((dualUiccInfo.sUicc1CntxLen == 0)&&(sSelectedUicc == 0x01)) |
| { |
| ALOGD ("%s: power cycle storing UICC1 info",__FUNCTION__); |
| dualUiccInfo.sUicc1CntxLen = sCurrentConfigLen; |
| for(i= 5 ; i < 13; i++) |
| { |
| if(sConfig[i] != (UINT8)0xFF) |
| break; |
| } |
| if(i == 13) |
| { |
| dualUiccInfo.sUicc1CntxLen = 0; |
| } |
| else |
| { |
| memcpy(dualUiccInfo.sUicc1Cntx, sConfig, sCurrentConfigLen); |
| status = NFA_GetConfig(0x01,param_ids_UICC_getOtherContext); |
| if(status == NFA_STATUS_OK) |
| { |
| android::sNfaGetConfigEvent.wait(); |
| } |
| memcpy(dualUiccInfo.sUicc1TechCapblty, sConfig, sCurrentConfigLen); |
| } |
| } |
| /*For the first power cycle for uicc2*/ |
| else if((dualUiccInfo.sUicc2CntxLen == 0)&&(sSelectedUicc == 0x02)) |
| { |
| ALOGD ("%s: power cycle storing UICC2 info",__FUNCTION__); |
| dualUiccInfo.sUicc2CntxLen = sCurrentConfigLen; |
| for(i= 5 ; i < 13; i++) |
| { |
| if(sConfig[i] != (UINT8)0xFF) |
| break; |
| } |
| if(i == 13) |
| { |
| dualUiccInfo.sUicc2CntxLen = 0; |
| } |
| else |
| { |
| memcpy(dualUiccInfo.sUicc2Cntx, sConfig, sCurrentConfigLen); |
| status = NFA_GetConfig(0x01,param_ids_UICC_getOtherContext); |
| if(status == NFA_STATUS_OK) |
| { |
| android::sNfaGetConfigEvent.wait(); |
| } |
| memcpy(dualUiccInfo.sUicc2TechCapblty, sConfig, sCurrentConfigLen); |
| } |
| } |
| else |
| { |
| ALOGD ("%s: UICC info are already stored..",__FUNCTION__); |
| } |
| ALOGD ("%s: Exit", __FUNCTION__); |
| } |
| |
| /********************************************************************************** |
| ** |
| ** Function: notifyUiccEvent |
| ** |
| ** Description: Notifies UICC event sto Service |
| ** Possible values: |
| ** UICC_CONNECTED_0 - 0 UICC connected |
| ** UICC_CONNECTED_1 - 1 UICC connected |
| ** UICC_CONNECTED_2 - 2 UICCs connected |
| ** |
| ** Returns: None |
| ** |
| **********************************************************************************/ |
| static void notifyUiccEvent (union sigval) |
| { |
| ALOGD ("%s", __FUNCTION__); |
| struct nfc_jni_native_data *nat = getNative(NULL, NULL); |
| JNIEnv* e; |
| ScopedAttach attach(nat->vm, &e); |
| if (e == NULL) |
| { |
| ALOGE ("jni env is null"); |
| return; |
| } |
| if(dualUiccInfo.uiccActivStat == 0x00) /*No UICC Detected*/ |
| { |
| e->CallVoidMethod (nat->manager, android::gCachedNfcManagerNotifyUiccStatusEvent, UICC_CONNECTED_0); |
| } |
| else if((dualUiccInfo.uiccActivStat == 0x01)||(dualUiccInfo.uiccActivStat == 0x02)) /*One UICC Detected*/ |
| { |
| e->CallVoidMethod (nat->manager, android::gCachedNfcManagerNotifyUiccStatusEvent, UICC_CONNECTED_1); |
| } |
| else if(dualUiccInfo.uiccActivStat == 0x03) /*Two UICC Detected*/ |
| { |
| e->CallVoidMethod (nat->manager, android::gCachedNfcManagerNotifyUiccStatusEvent, UICC_CONNECTED_2); |
| } |
| |
| } |
| |
| static int nfcManager_staticDualUicc_Precondition(int uiccSlot) |
| { |
| unsigned long uicc_active_state = 0; |
| uint8_t retStat = UICC_NOT_CONFIGURED; |
| |
| if(GetNxpNumValue (NAME_NXP_DUAL_UICC_ENABLE, (void*)&uicc_active_state, sizeof(uicc_active_state))) |
| { |
| ALOGD ("NXP_DUAL_UICC_ENABLE : 0x%02x",uicc_active_state); |
| } |
| else |
| { |
| ALOGE ("NXP_DUAL_UICC_ENABLE Not found taking default value 0x01"); |
| uicc_active_state = 0x00; |
| } |
| |
| if(uicc_active_state != 0x01) |
| { |
| ALOGE("%s:FAIL Dual UICC feature not available", __FUNCTION__); |
| retStat = DUAL_UICC_FEATURE_NOT_AVAILABLE; |
| } |
| else if(sIsDisabling) |
| { |
| ALOGE("%s:FAIL Nfc is Disabling : Switch UICC not allowed", __FUNCTION__); |
| retStat = DUAL_UICC_ERROR_NFC_TURNING_OFF; |
| } |
| else if(SecureElement::getInstance().isBusy()) |
| { |
| ALOGE("%s:FAIL SE wired-mode : busy", __FUNCTION__); |
| retStat = DUAL_UICC_ERROR_NFCC_BUSY; |
| } |
| else if(rfActivation) |
| { |
| ALOGE("%s:FAIL RF session ongoing", __FUNCTION__); |
| retStat = DUAL_UICC_ERROR_NFCC_BUSY; |
| } |
| else if((uiccSlot != 0x01) && (uiccSlot != 0x02)) |
| { |
| ALOGE("%s: Invalid slot id"); |
| retStat = DUAL_UICC_ERROR_INVALID_SLOT; |
| } |
| else if(get_transcation_stat() == true) |
| { |
| ALOGE ("%s: FAIL Transaction in progress", __FUNCTION__); |
| retStat = DUAL_UICC_ERROR_NFCC_BUSY; |
| } |
| else |
| { |
| set_transcation_stat(true); |
| } |
| return retStat; |
| } |
| |
| #endif |
| |
| static void nfaNxpSelfTestNtfCallback(UINT8 event, UINT16 param_len, UINT8 *p_param) |
| { |
| (void)event; |
| ALOGD ("%s", __FUNCTION__); |
| |
| if(param_len == 0x05 && p_param[3] == 00) //p_param[4] 0x00:SWP Link OK 0x03:SWP link dead. |
| { |
| ALOGD("NXP SWP SelfTest : SWP Link OK "); |
| SetCbStatus(NFA_STATUS_OK); |
| } |
| else |
| { |
| if(p_param[3] == 0x03) ALOGD("NXP SWP SelfTest : SWP Link dead "); |
| SetCbStatus(NFA_STATUS_FAILED); |
| } |
| |
| switch(p_param[4]){ //information of PMUVCC. |
| case 0x00 : ALOGD("NXP SWP SelfTest : No PMUVCC ");break; |
| case 0x01 : ALOGD("NXP SWP SelfTest : PMUVCC = 1.8V ");break; |
| case 0x02 : ALOGD("NXP SWP SelfTest : PMUVCC = 3.3V ");break; |
| case 0x03 : ALOGD("NXP SWP SelfTest : PMUVCC = undetermined ");break; |
| default : ALOGD("NXP SWP SelfTest : unknown PMUVCC ");break; |
| } |
| |
| SyncEventGuard guard (sNfaNxpNtfEvent); |
| sNfaNxpNtfEvent.notifyOne (); |
| } |
| |
| static void nfcManager_doPrbsOn(JNIEnv* e, jobject o, jint prbs, jint hw_prbs, jint tech, jint rate) |
| { |
| (void)e; |
| (void)o; |
| ALOGD ("%s: enter", __FUNCTION__); |
| tNFA_STATUS status = NFA_STATUS_FAILED; |
| // bool stat = false; /*commented to eliminate unused variable warning*/ |
| |
| if (!sIsNfaEnabled) { |
| ALOGD("NFC does not enabled!!"); |
| return; |
| } |
| |
| if (sDiscoveryEnabled) { |
| ALOGD("Discovery must not be enabled for SelfTest"); |
| return ; |
| } |
| |
| if(tech < 0 || tech > 2) |
| { |
| ALOGD("Invalid tech! please choose A or B or F"); |
| return; |
| } |
| |
| if(rate < 0 || rate > 3){ |
| ALOGD("Invalid bitrate! please choose 106 or 212 or 424 or 848"); |
| return; |
| } |
| |
| //Technology to stream 0x00:TypeA 0x01:TypeB 0x02:TypeF |
| //Bitrate 0x00:106kbps 0x01:212kbps 0x02:424kbps 0x03:848kbps |
| //prbs and hw_prbs 0x00 or 0x01 two extra parameters included in case of pn548AD |
| #if((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551)) |
| UINT8 param[4]; |
| memset(param, 0x00, sizeof(param)); |
| param[0] = prbs; |
| param[1] = hw_prbs; |
| param[2] = tech; //technology |
| param[3] = rate; //bitrate |
| ALOGD("phNxpNciHal_getPrbsCmd: PRBS = %d HW_PRBS = %d", prbs, hw_prbs); |
| #else |
| UINT8 param[2]; |
| memset(param, 0x00, sizeof(param)); |
| param[0] = tech; |
| param[1] = rate; |
| #endif |
| switch (tech) |
| { |
| case 0x00: |
| ALOGD("phNxpNciHal_getPrbsCmd - NFC_RF_TECHNOLOGY_A"); |
| break; |
| case 0x01: |
| ALOGD("phNxpNciHal_getPrbsCmd - NFC_RF_TECHNOLOGY_B"); |
| break; |
| case 0x02: |
| ALOGD("phNxpNciHal_getPrbsCmd - NFC_RF_TECHNOLOGY_F"); |
| break; |
| default: |
| break; |
| } |
| switch (rate) |
| { |
| case 0x00: |
| ALOGD("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_106"); |
| break; |
| case 0x01: |
| ALOGD("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_212"); |
| break; |
| case 0x02: |
| ALOGD("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_424"); |
| break; |
| case 0x03: |
| ALOGD("phNxpNciHal_getPrbsCmd - NFC_BIT_RATE_848"); |
| break; |
| default: |
| break; |
| } |
| //step2. PRBS Test stop : CORE RESET_CMD |
| status = Nxp_SelfTest(3, param); //CORE_RESET_CMD |
| if(NFA_STATUS_OK != status) |
| { |
| ALOGD("%s: CORE RESET_CMD Fail!", __FUNCTION__); |
| status = NFA_STATUS_FAILED; |
| goto TheEnd; |
| } |
| //step3. PRBS Test stop : CORE_INIT_CMD |
| status = Nxp_SelfTest(4, param); //CORE_INIT_CMD |
| if(NFA_STATUS_OK != status) |
| { |
| ALOGD("%s: CORE_INIT_CMD Fail!", __FUNCTION__); |
| status = NFA_STATUS_FAILED; |
| goto TheEnd; |
| } |
| //step4. : NXP_ACT_PROP_EXTN |
| status = Nxp_SelfTest(5, param); //NXP_ACT_PROP_EXTN |
| if(NFA_STATUS_OK != status) |
| { |
| ALOGD("%s: NXP_ACT_PROP_EXTN Fail!", __FUNCTION__); |
| status = NFA_STATUS_FAILED; |
| goto TheEnd; |
| } |
| |
| status = Nxp_SelfTest(1, param); |
| ALOGD ("%s: exit; status =0x%X", __FUNCTION__,status); |
| |
| TheEnd: |
| //Factory Test Code |
| ALOGD ("%s: exit; status =0x%X", __FUNCTION__,status); |
| return; |
| } |
| |
| static void nfcManager_doPrbsOff(JNIEnv* e, jobject o) |
| { |
| (void)e; |
| (void)o; |
| ALOGD ("%s: enter", __FUNCTION__); |
| tNFA_STATUS status = NFA_STATUS_FAILED; |
| // bool stat = false; /*commented to eliminate unused variable warning*/ |
| UINT8 param; |
| |
| if (!sIsNfaEnabled) { |
| ALOGD("NFC does not enabled!!"); |
| return; |
| } |
| |
| if (sDiscoveryEnabled) { |
| ALOGD("Discovery must not be enabled for SelfTest"); |
| return; |
| } |
| |
| //Factory Test Code |
| //step1. PRBS Test stop : VEN RESET |
| status = Nxp_SelfTest(2, ¶m); //VEN RESET |
| if(NFA_STATUS_OK != status) |
| { |
| ALOGD("step1. PRBS Test stop : VEN RESET Fail!"); |
| status = NFA_STATUS_FAILED; |
| goto TheEnd; |
| } |
| |
| TheEnd: |
| //Factory Test Code |
| ALOGD ("%s: exit; status =0x%X", __FUNCTION__,status); |
| |
| return; |
| } |
| |
| static jint nfcManager_SWPSelfTest(JNIEnv* e, jobject o, jint ch) |
| { |
| (void)e; |
| (void)o; |
| ALOGD ("%s: enter", __FUNCTION__); |
| tNFA_STATUS status = NFA_STATUS_FAILED; |
| tNFA_STATUS regcb_stat = NFA_STATUS_FAILED; |
| UINT8 param[1]; |
| |
| if (!sIsNfaEnabled) { |
| ALOGD("NFC does not enabled!!"); |
| return status; |
| } |
| |
| if (sDiscoveryEnabled) { |
| ALOGD("Discovery must not be enabled for SelfTest"); |
| return status; |
| } |
| |
| if (ch < 0 || ch > 1){ |
| ALOGD("Invalid channel!! please choose 0 or 1"); |
| return status; |
| } |
| |
| |
| //step1. : CORE RESET_CMD |
| status = Nxp_SelfTest(3, param); //CORE_RESET_CMD |
| if(NFA_STATUS_OK != status) |
| { |
| ALOGD("step2. PRBS Test stop : CORE RESET_CMD Fail!"); |
| status = NFA_STATUS_FAILED; |
| goto TheEnd; |
| } |
| |
| //step2. : CORE_INIT_CMD |
| status = Nxp_SelfTest(4, param); //CORE_INIT_CMD |
| if(NFA_STATUS_OK != status) |
| { |
| ALOGD("step3. PRBS Test stop : CORE_INIT_CMD Fail!"); |
| status = NFA_STATUS_FAILED; |
| goto TheEnd; |
| } |
| |
| //step3. : NXP_ACT_PROP_EXTN |
| status = Nxp_SelfTest(5, param); //NXP_ACT_PROP_EXTN |
| if(NFA_STATUS_OK != status) |
| { |
| ALOGD("step: NXP_ACT_PROP_EXTN Fail!"); |
| status = NFA_STATUS_FAILED; |
| goto TheEnd; |
| } |
| |
| regcb_stat = NFA_RegVSCback (true,nfaNxpSelfTestNtfCallback); //Register CallBack for NXP NTF |
| if(NFA_STATUS_OK != regcb_stat) |
| { |
| ALOGD("To Regist Ntf Callback is Fail!"); |
| goto TheEnd; |
| } |
| |
| param[0] = ch; // SWP channel 0x00 : SWP1(UICC) 0x01:SWP2(eSE) |
| status = Nxp_SelfTest(0, param); |
| if(NFA_STATUS_OK != status) |
| { |
| status = NFA_STATUS_FAILED; |
| goto TheEnd; |
| } |
| |
| { |
| ALOGD("NFC NXP SelfTest wait for Notificaiton"); |
| nfaNxpSelfTestNtfTimer.set(1000, nfaNxpSelfTestNtfTimerCb); |
| SyncEventGuard guard (sNfaNxpNtfEvent); |
| sNfaNxpNtfEvent.wait(); //wait for NXP Self NTF to come |
| } |
| |
| status = GetCbStatus(); |
| if(NFA_STATUS_OK != status) |
| { |
| status = NFA_STATUS_FAILED; |
| } |
| |
| TheEnd: |
| if(NFA_STATUS_OK == regcb_stat) { |
| regcb_stat = NFA_RegVSCback (false,nfaNxpSelfTestNtfCallback); //DeRegister CallBack for NXP NTF |
| } |
| nfaNxpSelfTestNtfTimer.kill(); |
| ALOGD ("%s: exit; status =0x%X", __FUNCTION__,status); |
| return status; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doPartialInitialize |
| ** |
| ** Description: Initializes the NFC partially if it is not initialized. |
| ** This will be required for transceive during NFC off. |
| ** |
| ** |
| ** Returns: true/false . |
| ** |
| *******************************************************************************/ |
| static bool nfcManager_doPartialInitialize () |
| { |
| |
| ALOGD("%s enter", __FUNCTION__); |
| tNFA_STATUS stat = NFA_STATUS_OK; |
| if (sIsNfaEnabled || gsNfaPartialEnabled) |
| { |
| ALOGD ("%s: NFC already enabled", __FUNCTION__); |
| return true; |
| } |
| NfcAdaptation& theInstance = NfcAdaptation::GetInstance(); |
| theInstance.MinInitialize(); |
| |
| tHAL_NFC_ENTRY* halFuncEntries = theInstance.GetHalEntryFuncs (); |
| ALOGD("%s: calling nfa init", __FUNCTION__); |
| if(NULL == halFuncEntries) |
| { |
| theInstance.Finalize(); |
| gsNfaPartialEnabled = false; |
| return false; |
| } |
| |
| NFA_SetBootMode(NFA_FAST_BOOT_MODE); |
| NFA_Init (halFuncEntries); |
| ALOGD("%s: calling enable", __FUNCTION__); |
| stat = NFA_Enable (nfaDeviceManagementCallback, nfaConnectionCallback); |
| if (stat == NFA_STATUS_OK) |
| { |
| SyncEventGuard guard (sNfaEnableEvent); |
| sNfaEnableEvent.wait(); //wait for NFA command to finish |
| } |
| |
| if (sIsNfaEnabled) |
| { |
| gsNfaPartialEnabled = true; |
| sIsNfaEnabled = false; |
| } |
| else |
| { |
| NFA_Disable (FALSE /* ungraceful */); |
| theInstance.Finalize(); |
| gsNfaPartialEnabled = false; |
| } |
| |
| ALOGD("%s exit status = 0x%x", __FUNCTION__ ,gsNfaPartialEnabled); |
| return gsNfaPartialEnabled; |
| } |
| /******************************************************************************* |
| ** |
| ** Function: nfcManager_doPartialDeInitialize |
| ** |
| ** Description: DeInitializes the NFC partially if it is partially initialized. |
| ** |
| ** Returns: true/false . |
| ** |
| *******************************************************************************/ |
| static bool nfcManager_doPartialDeInitialize() |
| { |
| tNFA_STATUS stat = NFA_STATUS_OK; |
| if(!gsNfaPartialEnabled) |
| { |
| ALOGD ("%s: cannot deinitialize NFC , not partially initilaized", __FUNCTION__); |
| return true; |
| } |
| ALOGD ("%s:enter", __FUNCTION__); |
| stat = NFA_Disable (TRUE /* graceful */); |
| if (stat == NFA_STATUS_OK) |
| { |
| ALOGD ("%s: wait for completion", __FUNCTION__); |
| SyncEventGuard guard (sNfaDisableEvent); |
| sNfaDisableEvent.wait (); //wait for NFA command to finish |
| } |
| else |
| { |
| ALOGE ("%s: fail disable; error=0x%X", __FUNCTION__, stat); |
| } |
| NfcAdaptation& theInstance = NfcAdaptation::GetInstance(); |
| theInstance.Finalize(); |
| NFA_SetBootMode(NFA_NORMAL_BOOT_MODE); |
| gsNfaPartialEnabled = false; |
| return true; |
| } |
| |
| /********************************************************************************** |
| ** |
| ** Function: nfcManager_getFwVersion |
| ** |
| ** Description: To get the FW Version |
| ** |
| ** Returns: int fw version as below four byte format |
| ** [0x00 0xROM_CODE_V 0xFW_MAJOR_NO 0xFW_MINOR_NO] |
| ** |
| **********************************************************************************/ |
| |
| static jint nfcManager_getFwVersion(JNIEnv* e, jobject o) |
| { |
| (void)e; |
| (void)o; |
| ALOGD ("%s: enter", __FUNCTION__); |
| tNFA_STATUS status = NFA_STATUS_FAILED; |
| // bool stat = false; /*commented to eliminate unused variable warning*/ |
| jint version = 0, temp = 0; |
| tNFC_FW_VERSION nfc_native_fw_version; |
| |
| if (!sIsNfaEnabled) { |
| ALOGD("NFC does not enabled!!"); |
| return status; |
| } |
| memset(&nfc_native_fw_version, 0, sizeof(nfc_native_fw_version)); |
| |
| nfc_native_fw_version = nfc_ncif_getFWVersion(); |
| ALOGD ("FW Version: %x.%x.%x", nfc_native_fw_version.rom_code_version, |
| nfc_native_fw_version.major_version,nfc_native_fw_version.minor_version); |
| |
| temp = nfc_native_fw_version.rom_code_version; |
| version = temp << 16; |
| temp = nfc_native_fw_version.major_version; |
| version |= temp << 8; |
| version |= nfc_native_fw_version.minor_version; |
| |
| ALOGD ("%s: exit; version =0x%X", __FUNCTION__,version); |
| return version; |
| } |
| |
| static void nfcManager_doSetEEPROM(JNIEnv* e, jobject o, jbyteArray val) |
| { |
| (void)e; |
| (void)o; |
| (void)val; |
| ALOGD ("%s: enter", __FUNCTION__); |
| tNFA_STATUS status = NFA_STATUS_FAILED; |
| // bool stat = false; /*commented to eliminate unused variable warning*/ |
| // UINT8 param; /*commented to eliminate unused variable warning*/ |
| |
| if (!sIsNfaEnabled) { |
| ALOGD("NFC does not enabled!!"); |
| return; |
| } |
| |
| ALOGD ("%s: exit; status =0x%X", __FUNCTION__,status); |
| |
| return; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: getUICC_RF_Param_SetSWPBitRate() |
| ** |
| ** Description: Get All UICC Parameters and set SWP bit rate |
| ** |
| ** Returns: success/failure |
| ** |
| *******************************************************************************/ |
| tNFA_STATUS getUICC_RF_Param_SetSWPBitRate() |
| { |
| tNFA_STATUS status = NFA_STATUS_FAILED; |
| tNFA_PMID rf_params_NFCEE_UICC[] = {0xA0, 0xEF}; |
| uint8_t sakValue = 0x00; |
| bool isMifareSupported; |
| |
| ALOGD("%s: enter", __FUNCTION__); |
| |
| SyncEventGuard guard (android::sNfaGetConfigEvent); |
| status = NFA_GetConfig(0x01, rf_params_NFCEE_UICC); |
| if (status != NFA_STATUS_OK) |
| { |
| ALOGE("%s: NFA_GetConfig failed", __FUNCTION__); |
| return status; |
| } |
| android::sNfaGetConfigEvent.wait(); |
| sakValue = sConfig[SAK_VALUE_AT]; |
| ALOGD ("SAK Value =0x%X",sakValue); |
| if((sakValue & 0x08) == 0x00) |
| { |
| isMifareSupported = false; |
| } |
| else |
| { |
| isMifareSupported = true; |
| } |
| status = SetUICC_SWPBitRate(isMifareSupported); |
| |
| return status; |
| } |
| #if((NFC_NXP_CHIP_TYPE == PN548C2) || (NFC_NXP_CHIP_TYPE == PN551)) |
| /******************************************************************************* |
| ** |
| ** Function: nfcManagerEnableAGCDebug |
| ** |
| ** Description: Enable/Disable Dynamic RSSI feature. |
| ** |
| ** Returns: None |
| ** |
| *******************************************************************************/ |
| static void nfcManagerEnableAGCDebug(UINT8 connEvent) |
| { |
| unsigned long enableAGCDebug = 0; |
| int retvalue = 0xFF; |
| GetNxpNumValue (NAME_NXP_AGC_DEBUG_ENABLE, (void*)&enableAGCDebug, sizeof(enableAGCDebug)); |
| menableAGC_debug_t.enableAGC = enableAGCDebug; |
| ALOGD ("%s ,%lu:", __FUNCTION__, enableAGCDebug); |
| if(sIsNfaEnabled != true || sIsDisabling == true) |
| return; |
| if(!menableAGC_debug_t.enableAGC) |
| { |
| ALOGD ("%s AGCDebug not enabled", __FUNCTION__); |
| return; |
| } |
| if(connEvent == NFA_TRANS_DM_RF_FIELD_EVT && |
| menableAGC_debug_t.AGCdebugstarted == false) |
| { |
| pthread_t agcThread; |
| pthread_attr_t attr; |
| pthread_attr_init(&attr); |
| pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); |
| retvalue = pthread_create(&agcThread, &attr, enableAGCThread, NULL); |
| pthread_attr_destroy(&attr); |
| if(retvalue == 0) |
| { |
| menableAGC_debug_t.AGCdebugstarted = true; |
| set_AGC_process_state(true); |
| } |
| } |
| } |
| |
| void *enableAGCThread(void *arg) |
| { |
| tNFA_STATUS status = NFA_STATUS_FAILED; |
| while( menableAGC_debug_t.AGCdebugstarted == true ) |
| { |
| if(get_AGC_process_state() == false) |
| { |
| sleep(10000); |
| continue; |
| } |
| status = SendAGCDebugCommand(); |
| if(status == NFA_STATUS_OK) |
| { |
| ALOGD ("%s: enable success exit", __FUNCTION__); |
| } |
| usleep(500000); |
| } |
| ALOGD ("%s: exit", __FUNCTION__); |
| pthread_exit(NULL); |
| return NULL; |
| } |
| /******************************************************************************* |
| ** |
| ** Function: set_AGC_process_state |
| ** |
| ** Description: sets the AGC process to stop |
| ** |
| ** Returns: None . |
| ** |
| *******************************************************************************/ |
| void set_AGC_process_state(bool state) |
| { |
| menableAGC_debug_t.AGCdebugrunning = state; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function: get_AGC_process_state |
| ** |
| ** Description: returns the AGC process state. |
| ** |
| ** Returns: true/false . |
| ** |
| *******************************************************************************/ |
| bool get_AGC_process_state() |
| { |
| return menableAGC_debug_t.AGCdebugrunning; |
| } |
| #endif |
| /******************************************************************************* |
| ** |
| ** Function: getrfDiscoveryDuration() |
| ** |
| ** Description: gets the current rf discovery duration. |
| ** |
| ** Returns: UINT16 |
| ** |
| *******************************************************************************/ |
| UINT16 getrfDiscoveryDuration() |
| { |
| return discDuration; |
| } |
| #endif |
| |
| } |
| /* namespace android */ |