blob: b6bbe275bb356d254bf5a354e0bbb9d647abf11d [file] [log] [blame]
nxpandroid64fd68c2015-09-23 16:45:15 +05301/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16/******************************************************************************
nxf24591dc0bc2c2018-02-21 17:33:08 +053017*
18* The original Work has been changed by NXP.
19*
20* Licensed under the Apache License, Version 2.0 (the "License");
21* you may not use this file except in compliance with the License.
22* You may obtain a copy of the License at
23*
24* http://www.apache.org/licenses/LICENSE-2.0
25*
26* Unless required by applicable law or agreed to in writing, software
27* distributed under the License is distributed on an "AS IS" BASIS,
28* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
29* See the License for the specific language governing permissions and
30* limitations under the License.
31*
32* Copyright 2018 NXP
33*
34******************************************************************************/
35#include <android-base/stringprintf.h>
36#include <base/logging.h>
37#include <cutils/properties.h>
nxpandroid64fd68c2015-09-23 16:45:15 +053038#include <errno.h>
nxf24591dc0bc2c2018-02-21 17:33:08 +053039#include <nativehelper/ScopedLocalRef.h>
40#include <nativehelper/ScopedPrimitiveArray.h>
41#include <nativehelper/ScopedUtfChars.h>
42#include <semaphore.h>
nxpandroid64fd68c2015-09-23 16:45:15 +053043#include "JavaClassConstants.h"
nxf24591dc0bc2c2018-02-21 17:33:08 +053044#include "NfcAdaptation.h"
45#include "NfcJniUtil.h"
46#include "NfcTag.h"
47#include "PeerToPeer.h"
nxpandroid64fd68c2015-09-23 16:45:15 +053048#include "Pn544Interop.h"
nxf24591dc0bc2c2018-02-21 17:33:08 +053049#include "PowerSwitch.h"
50#include "RoutingManager.h"
51#include "SyncEvent.h"
52#include "nfc_config.h"
nxpandroid0f06fde2017-08-14 11:25:28 +053053#if(NXP_EXTNS == TRUE)
nxpandroidecca0112018-06-06 14:41:40 +053054#include "MposManager.h"
Suraj Uday Kotharkare421e3f2018-03-12 12:18:36 +053055#include "nfca_version.h"
nxf24591dc0bc2c2018-02-21 17:33:08 +053056#include "SecureElement.h"
nxpandroid64fd68c2015-09-23 16:45:15 +053057#include "DwpChannel.h"
nxf24591dc0bc2c2018-02-21 17:33:08 +053058#include "JcDnld.h"
59#include "IChannel.h"
nxpandroid5d64ce92016-11-18 19:48:53 +053060#endif
nxpandroid64fd68c2015-09-23 16:45:15 +053061
nxf24591dc0bc2c2018-02-21 17:33:08 +053062#include "ce_api.h"
63#include "nfa_api.h"
64#include "nfa_ee_api.h"
65#include "nfa_p2p_api.h"
66#include "nfc_brcm_defs.h"
67#include "phNxpExtns.h"
68#include "rw_api.h"
69
Suraj Uday Kotharkare421e3f2018-03-12 12:18:36 +053070
71
72
nxf24591dc0bc2c2018-02-21 17:33:08 +053073using android::base::StringPrintf;
74
75extern const uint8_t nfca_version_string[];
76extern const uint8_t nfa_version_string[];
Suraj Uday Kotharkare421e3f2018-03-12 12:18:36 +053077#if(NXP_EXTNS == TRUE)
78extern bool nfc_debug_enabled;
79#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +053080extern tNFA_DM_DISC_FREQ_CFG* p_nfa_dm_rf_disc_freq_cfg; // defined in stack
81namespace android {
82extern bool gIsTagDeactivating;
83extern bool gIsSelectingRfInterface;
84extern void nativeNfcTag_doTransceiveStatus(tNFA_STATUS status, uint8_t* buf,
85 uint32_t buflen);
86extern void nativeNfcTag_notifyRfTimeout();
87extern void nativeNfcTag_doConnectStatus(jboolean is_connect_ok);
88extern void nativeNfcTag_doDeactivateStatus(int status);
89extern void nativeNfcTag_doWriteStatus(jboolean is_write_ok);
90extern void nativeNfcTag_doCheckNdefResult(tNFA_STATUS status,
91 uint32_t max_size,
92 uint32_t current_size,
93 uint8_t flags);
94extern void nativeNfcTag_doMakeReadonlyResult(tNFA_STATUS status);
95extern void nativeNfcTag_doPresenceCheckResult(tNFA_STATUS status);
96extern void nativeNfcTag_formatStatus(bool is_ok);
97extern void nativeNfcTag_resetPresenceCheck();
98extern void nativeNfcTag_doReadCompleted(tNFA_STATUS status);
99extern void nativeNfcTag_setRfInterface(tNFA_INTF_TYPE rfInterface);
100extern void nativeNfcTag_abortWaits();
101extern void nativeLlcpConnectionlessSocket_abortWait();
102extern void nativeNfcTag_registerNdefTypeHandler();
103extern void nativeNfcTag_acquireRfInterfaceMutexLock();
104extern void nativeNfcTag_releaseRfInterfaceMutexLock();
105extern void nativeLlcpConnectionlessSocket_receiveData(uint8_t* data,
106 uint32_t len,
107 uint32_t remote_sap);
108#if(NXP_EXTNS == TRUE)
109static jboolean nfcManager_doCheckJcopDlAtBoot(JNIEnv* e, jobject o);
110static int nfcManager_doJcosDownload(JNIEnv* e, jobject o);
111void DWPChannel_init(IChannel_t *DWP);
112IChannel_t Dwp;
113#endif
114} // namespace android
nxpandroid64fd68c2015-09-23 16:45:15 +0530115
116/*****************************************************************************
117**
118** public variables and functions
119**
120*****************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +0530121bool gActivated = false;
122SyncEvent gDeactivatedEvent;
123SyncEvent sNfaSetPowerSubState;
nxpandroidecca0112018-06-06 14:41:40 +0530124/*Structure to store discovery parameters*/
125typedef struct discovery_Parameters
126{
127 int technologies_mask;
128 bool enable_lptd;
129 bool reader_mode;
130 bool enable_p2p;
131 bool enable_host_routing;
132 bool restart;
133}discovery_Parameters_t;
134discovery_Parameters_t mDiscParams;
nxpandroid64fd68c2015-09-23 16:45:15 +0530135
nxf24591dc0bc2c2018-02-21 17:33:08 +0530136namespace android {
137jmethodID gCachedNfcManagerNotifyNdefMessageListeners;
138jmethodID gCachedNfcManagerNotifyTransactionListeners;
139jmethodID gCachedNfcManagerNotifyLlcpLinkActivation;
140jmethodID gCachedNfcManagerNotifyLlcpLinkDeactivated;
141jmethodID gCachedNfcManagerNotifyLlcpFirstPacketReceived;
142jmethodID gCachedNfcManagerNotifyHostEmuActivated;
143jmethodID gCachedNfcManagerNotifyHostEmuData;
144jmethodID gCachedNfcManagerNotifyHostEmuDeactivated;
145jmethodID gCachedNfcManagerNotifyRfFieldActivated;
146jmethodID gCachedNfcManagerNotifyRfFieldDeactivated;
147const char* gNativeP2pDeviceClassName =
148 "com/android/nfc/dhimpl/NativeP2pDevice";
149const char* gNativeLlcpServiceSocketClassName =
150 "com/android/nfc/dhimpl/NativeLlcpServiceSocket";
151const char* gNativeLlcpConnectionlessSocketClassName =
152 "com/android/nfc/dhimpl/NativeLlcpConnectionlessSocket";
153const char* gNativeLlcpSocketClassName =
154 "com/android/nfc/dhimpl/NativeLlcpSocket";
155const char* gNativeNfcTagClassName = "com/android/nfc/dhimpl/NativeNfcTag";
156const char* gNativeNfcManagerClassName =
157 "com/android/nfc/dhimpl/NativeNfcManager";
158#if (NXP_EXTNS == TRUE)
159const char* gNativeNfcSecureElementClassName =
160 "com/android/nfc/dhimpl/NativeNfcSecureElement";
nxpandroidecca0112018-06-06 14:41:40 +0530161jmethodID gCachedNfcManagerNotifySeListenActivated;
162jmethodID gCachedNfcManagerNotifySeListenDeactivated;
163const char* gNativeNfcMposManagerClassName =
164 "com/android/nfc/dhimpl/NativeNfcMposManager";
165 void enableLastRfDiscovery();
166 void storeLastDiscoveryParams(int technologies_mask, bool enable_lptd,
167 bool reader_mode, bool enable_host_routing ,bool enable_p2p, bool restart);
nxpandroid5d64ce92016-11-18 19:48:53 +0530168#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +0530169void doStartupConfig();
170void startStopPolling(bool isStartPolling);
171void startRfDiscovery(bool isStart);
172bool isDiscoveryStarted();
173} // namespace android
nxpandroid64fd68c2015-09-23 16:45:15 +0530174
175/*****************************************************************************
176**
177** private variables and functions
178**
179*****************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +0530180namespace android {
181static jint sLastError = ERROR_BUFFER_TOO_SMALL;
182static SyncEvent sNfaEnableEvent; // event for NFA_Enable()
183static SyncEvent sNfaDisableEvent; // event for NFA_Disable()
184static SyncEvent sNfaEnableDisablePollingEvent; // event for
185 // NFA_EnablePolling(),
186 // NFA_DisablePolling()
187static SyncEvent sNfaSetConfigEvent; // event for Set_Config....
188static SyncEvent sNfaGetConfigEvent; // event for Get_Config....
189static bool sIsNfaEnabled = false;
190static bool sDiscoveryEnabled = false; // is polling or listening
191static bool sPollingEnabled = false; // is polling for tag?
192static bool sIsDisabling = false;
193static bool sRfEnabled = false; // whether RF discovery is enabled
194static bool sSeRfActive = false; // whether RF with SE is likely active
195static bool sReaderModeEnabled =
196 false; // whether we're only reading tags, not allowing P2p/card emu
197static bool sP2pEnabled = false;
198static bool sP2pActive = false; // whether p2p was last active
199static bool sAbortConnlessWait = false;
200static jint sLfT3tMax = 0;
nxpandroid64fd68c2015-09-23 16:45:15 +0530201
nxf24591dc0bc2c2018-02-21 17:33:08 +0530202#define CONFIG_UPDATE_TECH_MASK (1 << 1)
203#define DEFAULT_TECH_MASK \
204 (NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B | NFA_TECHNOLOGY_MASK_F | \
205 NFA_TECHNOLOGY_MASK_V | NFA_TECHNOLOGY_MASK_B_PRIME | \
206 NFA_TECHNOLOGY_MASK_A_ACTIVE | NFA_TECHNOLOGY_MASK_F_ACTIVE | \
207 NFA_TECHNOLOGY_MASK_KOVIO)
208#define DEFAULT_DISCOVERY_DURATION 500
209#define READER_MODE_DISCOVERY_DURATION 200
nxpandroid34627bd2016-05-27 15:52:30 +0530210
nxf24591dc0bc2c2018-02-21 17:33:08 +0530211static void nfaConnectionCallback(uint8_t event, tNFA_CONN_EVT_DATA* eventData);
212static void nfaDeviceManagementCallback(uint8_t event,
213 tNFA_DM_CBACK_DATA* eventData);
214static bool isPeerToPeer(tNFA_ACTIVATED& activated);
nxpandroid64fd68c2015-09-23 16:45:15 +0530215static bool isListenMode(tNFA_ACTIVATED& activated);
nxf24591dc0bc2c2018-02-21 17:33:08 +0530216static void enableDisableLptd(bool enable);
nxpandroid64fd68c2015-09-23 16:45:15 +0530217static tNFA_STATUS stopPolling_rfDiscoveryDisabled();
nxf24591dc0bc2c2018-02-21 17:33:08 +0530218static tNFA_STATUS startPolling_rfDiscoveryDisabled(
219 tNFA_TECHNOLOGY_MASK tech_mask);
220static void nfcManager_doSetScreenState(JNIEnv* e, jobject o,
221 jint screen_state_mask);
nxpandroid64fd68c2015-09-23 16:45:15 +0530222
nxpandroid6fd9cdb2017-07-12 18:25:41 +0530223static uint16_t sCurrentConfigLen;
224static uint8_t sConfig[256];
nxpandroide66eb092017-07-12 21:36:08 +0530225static int prevScreenState = NFA_SCREEN_STATE_OFF_LOCKED;
nxf24591dc0bc2c2018-02-21 17:33:08 +0530226static int NFA_SCREEN_POLLING_TAG_MASK = 0x10;
227static bool gIsDtaEnabled = false;
nxpandroid64fd68c2015-09-23 16:45:15 +0530228/////////////////////////////////////////////////////////////
229/////////////////////////////////////////////////////////////
Suraj Uday Kotharkare421e3f2018-03-12 12:18:36 +0530230#if (NXP_EXTNS != TRUE)
nxf24591dc0bc2c2018-02-21 17:33:08 +0530231bool nfc_debug_enabled;
Suraj Uday Kotharkare421e3f2018-03-12 12:18:36 +0530232#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +0530233namespace {
234void initializeGlobalDebugEnabledFlag() {
235 nfc_debug_enabled =
236 (NfcConfig::getUnsigned(NAME_NFC_DEBUG_ENABLED, 1) != 0) ? true : false;
237
238 char valueStr[PROPERTY_VALUE_MAX] = {0};
239 int len = property_get("nfc.debug_enabled", valueStr, "");
240 if (len > 0) {
241 unsigned debug_enabled = 1;
242 // let Android property override .conf variable
243 sscanf(valueStr, "%u", &debug_enabled);
244 nfc_debug_enabled = (debug_enabled == 0) ? false : true;
245 }
246
247 DLOG_IF(INFO, nfc_debug_enabled)
248 << StringPrintf("%s: level=%u", __func__, nfc_debug_enabled);
249}
250} // namespace
251
nxpandroid64fd68c2015-09-23 16:45:15 +0530252/*******************************************************************************
253**
254** Function: getNative
255**
256** Description: Get native data
257**
258** Returns: Native data structure.
259**
260*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +0530261nfc_jni_native_data* getNative(JNIEnv* e, jobject o) {
262 static struct nfc_jni_native_data* sCachedNat = NULL;
263 if (e) {
264 sCachedNat = nfc_jni_get_nat(e, o);
265 }
266 return sCachedNat;
nxpandroid64fd68c2015-09-23 16:45:15 +0530267}
268
nxpandroid64fd68c2015-09-23 16:45:15 +0530269/*******************************************************************************
270**
271** Function: handleRfDiscoveryEvent
272**
273** Description: Handle RF-discovery events from the stack.
274** discoveredDevice: Discovered device.
275**
276** Returns: None
277**
278*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +0530279static void handleRfDiscoveryEvent(tNFC_RESULT_DEVT* discoveredDevice) {
280 if (discoveredDevice->more == NCI_DISCOVER_NTF_MORE) {
281 // there is more discovery notification coming
282 return;
283 }
nxpandroidfd746002017-09-14 12:06:45 +0530284
nxf24591dc0bc2c2018-02-21 17:33:08 +0530285 bool isP2p = NfcTag::getInstance().isP2pDiscovered();
286 if (!sReaderModeEnabled && isP2p) {
287 // select the peer that supports P2P
288 NfcTag::getInstance().selectP2p();
289 } else {
290 // select the first of multiple tags that is discovered
291 NfcTag::getInstance().selectFirstTag();
292 }
nxpandroid64fd68c2015-09-23 16:45:15 +0530293}
294
nxpandroid64fd68c2015-09-23 16:45:15 +0530295/*******************************************************************************
296**
297** Function: nfaConnectionCallback
298**
299** Description: Receive connection-related events from stack.
300** connEvent: Event code.
301** eventData: Event data.
302**
303** Returns: None
304**
305*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +0530306static void nfaConnectionCallback(uint8_t connEvent,
307 tNFA_CONN_EVT_DATA* eventData) {
308 tNFA_STATUS status = NFA_STATUS_FAILED;
309 DLOG_IF(INFO, nfc_debug_enabled)
310 << StringPrintf("%s: event= %u", __func__, connEvent);
nxpandroid57869d22017-02-24 16:12:04 +0530311
nxf24591dc0bc2c2018-02-21 17:33:08 +0530312 switch (connEvent) {
313 case NFA_POLL_ENABLED_EVT: // whether polling successfully started
nxpandroid64fd68c2015-09-23 16:45:15 +0530314 {
nxf24591dc0bc2c2018-02-21 17:33:08 +0530315 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
316 "%s: NFA_POLL_ENABLED_EVT: status = %u", __func__, eventData->status);
317
318 SyncEventGuard guard(sNfaEnableDisablePollingEvent);
319 sNfaEnableDisablePollingEvent.notifyOne();
320 } break;
321
322 case NFA_POLL_DISABLED_EVT: // Listening/Polling stopped
323 {
324 DLOG_IF(INFO, nfc_debug_enabled)
325 << StringPrintf("%s: NFA_POLL_DISABLED_EVT: status = %u", __func__,
326 eventData->status);
327
328 SyncEventGuard guard(sNfaEnableDisablePollingEvent);
329 sNfaEnableDisablePollingEvent.notifyOne();
330 } break;
331
332 case NFA_RF_DISCOVERY_STARTED_EVT: // RF Discovery started
333 {
334 DLOG_IF(INFO, nfc_debug_enabled)
335 << StringPrintf("%s: NFA_RF_DISCOVERY_STARTED_EVT: status = %u",
336 __func__, eventData->status);
337
338 SyncEventGuard guard(sNfaEnableDisablePollingEvent);
339 sNfaEnableDisablePollingEvent.notifyOne();
340 } break;
341
342 case NFA_RF_DISCOVERY_STOPPED_EVT: // RF Discovery stopped event
343 {
344 DLOG_IF(INFO, nfc_debug_enabled)
345 << StringPrintf("%s: NFA_RF_DISCOVERY_STOPPED_EVT: status = %u",
346 __func__, eventData->status);
347
348 SyncEventGuard guard(sNfaEnableDisablePollingEvent);
349 sNfaEnableDisablePollingEvent.notifyOne();
350 } break;
351
352 case NFA_DISC_RESULT_EVT: // NFC link/protocol discovery notificaiton
353 status = eventData->disc_result.status;
354 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
355 "%s: NFA_DISC_RESULT_EVT: status = %d", __func__, status);
356 if (status != NFA_STATUS_OK) {
357 LOG(ERROR) << StringPrintf("%s: NFA_DISC_RESULT_EVT error: status = %d",
358 __func__, status);
359 } else {
360 NfcTag::getInstance().connectionEventHandler(connEvent, eventData);
361 handleRfDiscoveryEvent(&eventData->disc_result.discovery_ntf);
362 }
363 break;
364
365 case NFA_SELECT_RESULT_EVT: // NFC link/protocol discovery select response
366 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
367 "%s: NFA_SELECT_RESULT_EVT: status = %d, gIsSelectingRfInterface = "
368 "%d, "
369 "sIsDisabling=%d",
370 __func__, eventData->status, gIsSelectingRfInterface, sIsDisabling);
371
372 if (sIsDisabling) break;
373
374 if (eventData->status != NFA_STATUS_OK) {
375 if (gIsSelectingRfInterface) {
376 nativeNfcTag_doConnectStatus(false);
nxpandroid64fd68c2015-09-23 16:45:15 +0530377 }
nxpandroid64fd68c2015-09-23 16:45:15 +0530378
nxf24591dc0bc2c2018-02-21 17:33:08 +0530379 LOG(ERROR) << StringPrintf(
380 "%s: NFA_SELECT_RESULT_EVT error: status = %d", __func__,
381 eventData->status);
382 NFA_Deactivate(FALSE);
383 }
384 break;
385
386 case NFA_DEACTIVATE_FAIL_EVT:
387 DLOG_IF(INFO, nfc_debug_enabled)
388 << StringPrintf("%s: NFA_DEACTIVATE_FAIL_EVT: status = %d", __func__,
389 eventData->status);
390 break;
391
392 case NFA_ACTIVATED_EVT: // NFC link/protocol activated
393 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
394 "%s: NFA_ACTIVATED_EVT: gIsSelectingRfInterface=%d, sIsDisabling=%d",
395 __func__, gIsSelectingRfInterface, sIsDisabling);
396 if ((eventData->activated.activate_ntf.protocol !=
397 NFA_PROTOCOL_NFC_DEP) &&
398 (!isListenMode(eventData->activated))) {
399 nativeNfcTag_setRfInterface(
400 (tNFA_INTF_TYPE)eventData->activated.activate_ntf.intf_param.type);
401 }
402 if (EXTNS_GetConnectFlag() == TRUE) {
403 NfcTag::getInstance().setActivationState();
404 nativeNfcTag_doConnectStatus(true);
405 break;
406 }
nxpandroidecca0112018-06-06 14:41:40 +0530407#if(NXP_EXTNS == TRUE)
408 if(nfcFL.nfcNxpEse) {
409 if(nfcFL.eseFL._ESE_ETSI_READER_ENABLE) {
410 /*
411 * Handle Reader over SWP START_READER_EVENT
412 * */
413 if(eventData->activated.activate_ntf.intf_param.type == NCI_INTERFACE_UICC_DIRECT ||
414 eventData->activated.activate_ntf.intf_param.type == NCI_INTERFACE_ESE_DIRECT)
415 {
416 MposManager::getInstance().setEtsiReaederState(STATE_SE_RDR_MODE_ACTIVATED);
417 MposManager::getInstance().notifyEEReaderEvent(ETSI_READER_ACTIVATED);
418 break;
419 }
420 }
421 }
422#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +0530423 NfcTag::getInstance().setActive(true);
424 if (sIsDisabling || !sIsNfaEnabled) break;
425 gActivated = true;
426
427 initializeGlobalDebugEnabledFlag();
428
429 NfcTag::getInstance().setActivationState();
430 if (gIsSelectingRfInterface) {
431 nativeNfcTag_doConnectStatus(true);
432 break;
433 }
434
435 nativeNfcTag_resetPresenceCheck();
436 if (isPeerToPeer(eventData->activated)) {
437 if (sReaderModeEnabled) {
438 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
439 "%s: ignoring peer target in reader mode.", __func__);
440 NFA_Deactivate(FALSE);
441 break;
nxpandroid64fd68c2015-09-23 16:45:15 +0530442 }
nxf24591dc0bc2c2018-02-21 17:33:08 +0530443 sP2pActive = true;
444 DLOG_IF(INFO, nfc_debug_enabled)
445 << StringPrintf("%s: NFA_ACTIVATED_EVT; is p2p", __func__);
446 if (NFC_GetNCIVersion() == NCI_VERSION_1_0) {
447 // Disable RF field events in case of p2p
448 uint8_t nfa_disable_rf_events[] = {0x00};
449 DLOG_IF(INFO, nfc_debug_enabled)
450 << StringPrintf("%s: Disabling RF field events", __func__);
451 status = NFA_SetConfig(NCI_PARAM_ID_RF_FIELD_INFO,
452 sizeof(nfa_disable_rf_events),
453 &nfa_disable_rf_events[0]);
454 if (status == NFA_STATUS_OK) {
455 DLOG_IF(INFO, nfc_debug_enabled)
456 << StringPrintf("%s: Disabled RF field events", __func__);
457 } else {
458 LOG(ERROR) << StringPrintf("%s: Failed to disable RF field events",
459 __func__);
460 }
nxpandroid64fd68c2015-09-23 16:45:15 +0530461 }
nxf24591dc0bc2c2018-02-21 17:33:08 +0530462 } else if (pn544InteropIsBusy() == false) {
463 NfcTag::getInstance().connectionEventHandler(connEvent, eventData);
nxpandroid64fd68c2015-09-23 16:45:15 +0530464
nxf24591dc0bc2c2018-02-21 17:33:08 +0530465 // We know it is not activating for P2P. If it activated in
466 // listen mode then it is likely for an SE transaction.
467 // Send the RF Event.
468 if (isListenMode(eventData->activated)) {
Suraj Uday Kotharkar2a0ee9c2018-04-27 03:48:23 +0530469#if(NXP_EXTNS == TRUE)
470 SecureElement::getInstance().notifyListenModeState (true);
471#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +0530472 sSeRfActive = true;
nxpandroid64fd68c2015-09-23 16:45:15 +0530473 }
nxf24591dc0bc2c2018-02-21 17:33:08 +0530474 }
475 break;
nxpandroid64fd68c2015-09-23 16:45:15 +0530476
nxf24591dc0bc2c2018-02-21 17:33:08 +0530477 case NFA_DEACTIVATED_EVT: // NFC link/protocol deactivated
478 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
479 "%s: NFA_DEACTIVATED_EVT Type: %u, gIsTagDeactivating: %d",
480 __func__, eventData->deactivated.type, gIsTagDeactivating);
481 NfcTag::getInstance().setDeactivationState(eventData->deactivated);
482 if (eventData->deactivated.type != NFA_DEACTIVATE_TYPE_SLEEP) {
nxpandroid64fd68c2015-09-23 16:45:15 +0530483 {
nxf24591dc0bc2c2018-02-21 17:33:08 +0530484 SyncEventGuard g(gDeactivatedEvent);
485 gActivated = false; // guard this variable from multi-threaded access
486 gDeactivatedEvent.notifyOne();
nxpandroid57869d22017-02-24 16:12:04 +0530487 }
nxf24591dc0bc2c2018-02-21 17:33:08 +0530488 nativeNfcTag_resetPresenceCheck();
489 NfcTag::getInstance().connectionEventHandler(connEvent, eventData);
490 nativeNfcTag_abortWaits();
491 NfcTag::getInstance().abort();
492 } else if (gIsTagDeactivating) {
493 NfcTag::getInstance().setActive(false);
494 nativeNfcTag_doDeactivateStatus(0);
495 } else if (EXTNS_GetDeactivateFlag() == TRUE) {
496 NfcTag::getInstance().setActive(false);
497 nativeNfcTag_doDeactivateStatus(0);
498 }
nxpandroid57869d22017-02-24 16:12:04 +0530499
nxf24591dc0bc2c2018-02-21 17:33:08 +0530500 // If RF is activated for what we think is a Secure Element transaction
501 // and it is deactivated to either IDLE or DISCOVERY mode, notify w/event.
502 if ((eventData->deactivated.type == NFA_DEACTIVATE_TYPE_IDLE) ||
503 (eventData->deactivated.type == NFA_DEACTIVATE_TYPE_DISCOVERY)) {
504 if (sSeRfActive) {
505 sSeRfActive = false;
Suraj Uday Kotharkar2a0ee9c2018-04-27 03:48:23 +0530506#if(NXP_EXTNS == TRUE)
507 SecureElement::getInstance().notifyListenModeState (false);
508#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +0530509 } else if (sP2pActive) {
510 sP2pActive = false;
511 // Make sure RF field events are re-enabled
512 DLOG_IF(INFO, nfc_debug_enabled)
513 << StringPrintf("%s: NFA_DEACTIVATED_EVT; is p2p", __func__);
514 if (NFC_GetNCIVersion() == NCI_VERSION_1_0) {
515 // Disable RF field events in case of p2p
516 uint8_t nfa_enable_rf_events[] = {0x01};
nxpandroid57869d22017-02-24 16:12:04 +0530517
nxf24591dc0bc2c2018-02-21 17:33:08 +0530518 if (!sIsDisabling && sIsNfaEnabled) {
519 DLOG_IF(INFO, nfc_debug_enabled)
520 << StringPrintf("%s: Enabling RF field events", __func__);
521 status = NFA_SetConfig(NCI_PARAM_ID_RF_FIELD_INFO,
522 sizeof(nfa_enable_rf_events),
523 &nfa_enable_rf_events[0]);
524 if (status == NFA_STATUS_OK) {
525 DLOG_IF(INFO, nfc_debug_enabled)
526 << StringPrintf("%s: Enabled RF field events", __func__);
527 } else {
528 LOG(ERROR) << StringPrintf(
529 "%s: Failed to enable RF field events", __func__);
530 }
nxpandroid64fd68c2015-09-23 16:45:15 +0530531 }
nxf24591dc0bc2c2018-02-21 17:33:08 +0530532 }
nxpandroid64fd68c2015-09-23 16:45:15 +0530533 }
nxf24591dc0bc2c2018-02-21 17:33:08 +0530534 }
nxpandroid64fd68c2015-09-23 16:45:15 +0530535
nxf24591dc0bc2c2018-02-21 17:33:08 +0530536 break;
nxpandroid57869d22017-02-24 16:12:04 +0530537
nxf24591dc0bc2c2018-02-21 17:33:08 +0530538 case NFA_TLV_DETECT_EVT: // TLV Detection complete
539 status = eventData->tlv_detect.status;
540 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
541 "%s: NFA_TLV_DETECT_EVT: status = %d, protocol = %d, num_tlvs = %d, "
542 "num_bytes = %d",
543 __func__, status, eventData->tlv_detect.protocol,
544 eventData->tlv_detect.num_tlvs, eventData->tlv_detect.num_bytes);
545 if (status != NFA_STATUS_OK) {
546 LOG(ERROR) << StringPrintf("%s: NFA_TLV_DETECT_EVT error: status = %d",
547 __func__, status);
548 }
549 break;
nxpandroid57869d22017-02-24 16:12:04 +0530550
nxf24591dc0bc2c2018-02-21 17:33:08 +0530551 case NFA_NDEF_DETECT_EVT: // NDEF Detection complete;
552 // if status is failure, it means the tag does not contain any or valid
553 // NDEF data; pass the failure status to the NFC Service;
554 status = eventData->ndef_detect.status;
555 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
556 "%s: NFA_NDEF_DETECT_EVT: status = 0x%X, protocol = %u, "
557 "max_size = %u, cur_size = %u, flags = 0x%X",
558 __func__, status, eventData->ndef_detect.protocol,
559 eventData->ndef_detect.max_size, eventData->ndef_detect.cur_size,
560 eventData->ndef_detect.flags);
561 NfcTag::getInstance().connectionEventHandler(connEvent, eventData);
562 nativeNfcTag_doCheckNdefResult(status, eventData->ndef_detect.max_size,
563 eventData->ndef_detect.cur_size,
564 eventData->ndef_detect.flags);
565 break;
nxpandroid57869d22017-02-24 16:12:04 +0530566
nxf24591dc0bc2c2018-02-21 17:33:08 +0530567 case NFA_DATA_EVT: // Data message received (for non-NDEF reads)
568 DLOG_IF(INFO, nfc_debug_enabled)
569 << StringPrintf("%s: NFA_DATA_EVT: status = 0x%X, len = %d", __func__,
570 eventData->status, eventData->data.len);
571 nativeNfcTag_doTransceiveStatus(eventData->status, eventData->data.p_data,
572 eventData->data.len);
573 break;
574 case NFA_RW_INTF_ERROR_EVT:
575 DLOG_IF(INFO, nfc_debug_enabled)
576 << StringPrintf("%s: NFC_RW_INTF_ERROR_EVT", __func__);
577 nativeNfcTag_notifyRfTimeout();
578 nativeNfcTag_doReadCompleted(NFA_STATUS_TIMEOUT);
579 break;
580 case NFA_SELECT_CPLT_EVT: // Select completed
581 status = eventData->status;
582 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
583 "%s: NFA_SELECT_CPLT_EVT: status = %d", __func__, status);
584 if (status != NFA_STATUS_OK) {
585 LOG(ERROR) << StringPrintf("%s: NFA_SELECT_CPLT_EVT error: status = %d",
586 __func__, status);
587 }
588 break;
nxpandroid57869d22017-02-24 16:12:04 +0530589
nxf24591dc0bc2c2018-02-21 17:33:08 +0530590 case NFA_READ_CPLT_EVT: // NDEF-read or tag-specific-read completed
591 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
592 "%s: NFA_READ_CPLT_EVT: status = 0x%X", __func__, eventData->status);
593 nativeNfcTag_doReadCompleted(eventData->status);
594 NfcTag::getInstance().connectionEventHandler(connEvent, eventData);
595 break;
nxpandroid6fd9cdb2017-07-12 18:25:41 +0530596
nxf24591dc0bc2c2018-02-21 17:33:08 +0530597 case NFA_WRITE_CPLT_EVT: // Write completed
598 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
599 "%s: NFA_WRITE_CPLT_EVT: status = %d", __func__, eventData->status);
600 nativeNfcTag_doWriteStatus(eventData->status == NFA_STATUS_OK);
601 break;
nxpandroid57869d22017-02-24 16:12:04 +0530602
nxf24591dc0bc2c2018-02-21 17:33:08 +0530603 case NFA_SET_TAG_RO_EVT: // Tag set as Read only
604 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
605 "%s: NFA_SET_TAG_RO_EVT: status = %d", __func__, eventData->status);
606 nativeNfcTag_doMakeReadonlyResult(eventData->status);
607 break;
nxpandroid57869d22017-02-24 16:12:04 +0530608
nxf24591dc0bc2c2018-02-21 17:33:08 +0530609 case NFA_CE_NDEF_WRITE_START_EVT: // NDEF write started
610 DLOG_IF(INFO, nfc_debug_enabled)
611 << StringPrintf("%s: NFA_CE_NDEF_WRITE_START_EVT: status: %d",
612 __func__, eventData->status);
nxpandroid57869d22017-02-24 16:12:04 +0530613
nxf24591dc0bc2c2018-02-21 17:33:08 +0530614 if (eventData->status != NFA_STATUS_OK)
615 LOG(ERROR) << StringPrintf(
616 "%s: NFA_CE_NDEF_WRITE_START_EVT error: status = %d", __func__,
617 eventData->status);
618 break;
nxpandroid57869d22017-02-24 16:12:04 +0530619
nxf24591dc0bc2c2018-02-21 17:33:08 +0530620 case NFA_CE_NDEF_WRITE_CPLT_EVT: // NDEF write completed
621 DLOG_IF(INFO, nfc_debug_enabled)
622 << StringPrintf("%s: FA_CE_NDEF_WRITE_CPLT_EVT: len = %u", __func__,
623 eventData->ndef_write_cplt.len);
624 break;
nxpandroid57869d22017-02-24 16:12:04 +0530625
nxf24591dc0bc2c2018-02-21 17:33:08 +0530626 case NFA_LLCP_ACTIVATED_EVT: // LLCP link is activated
627 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
628 "%s: NFA_LLCP_ACTIVATED_EVT: is_initiator: %d remote_wks: %d, "
629 "remote_lsc: %d, remote_link_miu: %d, local_link_miu: %d",
630 __func__, eventData->llcp_activated.is_initiator,
631 eventData->llcp_activated.remote_wks,
632 eventData->llcp_activated.remote_lsc,
633 eventData->llcp_activated.remote_link_miu,
634 eventData->llcp_activated.local_link_miu);
nxpandroid57869d22017-02-24 16:12:04 +0530635
nxf24591dc0bc2c2018-02-21 17:33:08 +0530636 PeerToPeer::getInstance().llcpActivatedHandler(getNative(0, 0),
637 eventData->llcp_activated);
638 break;
nxpandroid57869d22017-02-24 16:12:04 +0530639
nxf24591dc0bc2c2018-02-21 17:33:08 +0530640 case NFA_LLCP_DEACTIVATED_EVT: // LLCP link is deactivated
641 DLOG_IF(INFO, nfc_debug_enabled)
642 << StringPrintf("%s: NFA_LLCP_DEACTIVATED_EVT", __func__);
643 PeerToPeer::getInstance().llcpDeactivatedHandler(
644 getNative(0, 0), eventData->llcp_deactivated);
645 break;
646 case NFA_LLCP_FIRST_PACKET_RECEIVED_EVT: // Received first packet over llcp
647 DLOG_IF(INFO, nfc_debug_enabled)
648 << StringPrintf("%s: NFA_LLCP_FIRST_PACKET_RECEIVED_EVT", __func__);
649 PeerToPeer::getInstance().llcpFirstPacketHandler(getNative(0, 0));
650 break;
651 case NFA_PRESENCE_CHECK_EVT:
652 DLOG_IF(INFO, nfc_debug_enabled)
653 << StringPrintf("%s: NFA_PRESENCE_CHECK_EVT", __func__);
654 nativeNfcTag_doPresenceCheckResult(eventData->status);
655 break;
656 case NFA_FORMAT_CPLT_EVT:
657 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
658 "%s: NFA_FORMAT_CPLT_EVT: status=0x%X", __func__, eventData->status);
659 nativeNfcTag_formatStatus(eventData->status == NFA_STATUS_OK);
660 break;
nxpandroid57869d22017-02-24 16:12:04 +0530661
nxf24591dc0bc2c2018-02-21 17:33:08 +0530662 case NFA_I93_CMD_CPLT_EVT:
663 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
664 "%s: NFA_I93_CMD_CPLT_EVT: status=0x%X", __func__, eventData->status);
665 break;
nxpandroid0f06fde2017-08-14 11:25:28 +0530666
nxf24591dc0bc2c2018-02-21 17:33:08 +0530667 case NFA_CE_UICC_LISTEN_CONFIGURED_EVT:
668 DLOG_IF(INFO, nfc_debug_enabled)
669 << StringPrintf("%s: NFA_CE_UICC_LISTEN_CONFIGURED_EVT : status=0x%X",
670 __func__, eventData->status);
671 break;
nxpandroid57869d22017-02-24 16:12:04 +0530672
nxf24591dc0bc2c2018-02-21 17:33:08 +0530673 case NFA_SET_P2P_LISTEN_TECH_EVT:
674 DLOG_IF(INFO, nfc_debug_enabled)
675 << StringPrintf("%s: NFA_SET_P2P_LISTEN_TECH_EVT", __func__);
676 PeerToPeer::getInstance().connectionEventHandler(connEvent, eventData);
677 break;
nxpandroid64fd68c2015-09-23 16:45:15 +0530678
nxf24591dc0bc2c2018-02-21 17:33:08 +0530679 default:
680 DLOG_IF(INFO, nfc_debug_enabled)
681 << StringPrintf("%s: unknown event ????", __func__);
682 break;
683 }
nxpandroid64fd68c2015-09-23 16:45:15 +0530684}
685
nxpandroid64fd68c2015-09-23 16:45:15 +0530686/*******************************************************************************
687**
688** Function: nfcManager_initNativeStruc
689**
690** Description: Initialize variables.
691** e: JVM environment.
692** o: Java object.
693**
694** Returns: True if ok.
695**
696*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +0530697static jboolean nfcManager_initNativeStruc(JNIEnv* e, jobject o) {
698 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", __func__);
nxpandroid0f06fde2017-08-14 11:25:28 +0530699
nxf24591dc0bc2c2018-02-21 17:33:08 +0530700 nfc_jni_native_data* nat =
701 (nfc_jni_native_data*)malloc(sizeof(struct nfc_jni_native_data));
702 if (nat == NULL) {
703 LOG(ERROR) << StringPrintf("%s: fail allocate native data", __func__);
704 return JNI_FALSE;
705 }
nxpandroid64fd68c2015-09-23 16:45:15 +0530706
nxf24591dc0bc2c2018-02-21 17:33:08 +0530707 memset(nat, 0, sizeof(*nat));
708 e->GetJavaVM(&(nat->vm));
709 nat->env_version = e->GetVersion();
710 nat->manager = e->NewGlobalRef(o);
nxpandroid64fd68c2015-09-23 16:45:15 +0530711
nxf24591dc0bc2c2018-02-21 17:33:08 +0530712 ScopedLocalRef<jclass> cls(e, e->GetObjectClass(o));
713 jfieldID f = e->GetFieldID(cls.get(), "mNative", "J");
714 e->SetLongField(o, f, (jlong)nat);
nxpandroidecca0112018-06-06 14:41:40 +0530715#if(NXP_EXTNS == TRUE)
716 MposManager::initMposNativeStruct(e, o);
717#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +0530718 /* Initialize native cached references */
719 gCachedNfcManagerNotifyNdefMessageListeners =
720 e->GetMethodID(cls.get(), "notifyNdefMessageListeners",
721 "(Lcom/android/nfc/dhimpl/NativeNfcTag;)V");
722 gCachedNfcManagerNotifyLlcpLinkActivation =
723 e->GetMethodID(cls.get(), "notifyLlcpLinkActivation",
724 "(Lcom/android/nfc/dhimpl/NativeP2pDevice;)V");
725 gCachedNfcManagerNotifyLlcpLinkDeactivated =
726 e->GetMethodID(cls.get(), "notifyLlcpLinkDeactivated",
727 "(Lcom/android/nfc/dhimpl/NativeP2pDevice;)V");
728 gCachedNfcManagerNotifyLlcpFirstPacketReceived =
729 e->GetMethodID(cls.get(), "notifyLlcpLinkFirstPacketReceived",
730 "(Lcom/android/nfc/dhimpl/NativeP2pDevice;)V");
nxpandroid64fd68c2015-09-23 16:45:15 +0530731
nxf24591dc0bc2c2018-02-21 17:33:08 +0530732 gCachedNfcManagerNotifyHostEmuActivated =
733 e->GetMethodID(cls.get(), "notifyHostEmuActivated", "(I)V");
nxpandroid64fd68c2015-09-23 16:45:15 +0530734
nxf24591dc0bc2c2018-02-21 17:33:08 +0530735 gCachedNfcManagerNotifyHostEmuData =
736 e->GetMethodID(cls.get(), "notifyHostEmuData", "(I[B)V");
nxpandroid64fd68c2015-09-23 16:45:15 +0530737
nxf24591dc0bc2c2018-02-21 17:33:08 +0530738 gCachedNfcManagerNotifyHostEmuDeactivated =
739 e->GetMethodID(cls.get(), "notifyHostEmuDeactivated", "(I)V");
nxpandroid64fd68c2015-09-23 16:45:15 +0530740
nxf24591dc0bc2c2018-02-21 17:33:08 +0530741 gCachedNfcManagerNotifyRfFieldActivated =
742 e->GetMethodID(cls.get(), "notifyRfFieldActivated", "()V");
743 gCachedNfcManagerNotifyRfFieldDeactivated =
744 e->GetMethodID(cls.get(), "notifyRfFieldDeactivated", "()V");
nxpandroid64fd68c2015-09-23 16:45:15 +0530745
Suraj Uday Kotharkar2a0ee9c2018-04-27 03:48:23 +0530746 gCachedNfcManagerNotifySeListenActivated =
747 e->GetMethodID(cls.get(),"notifySeListenActivated", "()V");
748 gCachedNfcManagerNotifySeListenDeactivated =
749 e->GetMethodID(cls.get(),"notifySeListenDeactivated", "()V");
nxf24591dc0bc2c2018-02-21 17:33:08 +0530750 if (nfc_jni_cache_object(e, gNativeNfcTagClassName, &(nat->cached_NfcTag)) ==
751 -1) {
752 LOG(ERROR) << StringPrintf("%s: fail cache NativeNfcTag", __func__);
753 return JNI_FALSE;
754 }
nxpandroid64fd68c2015-09-23 16:45:15 +0530755
nxf24591dc0bc2c2018-02-21 17:33:08 +0530756 if (nfc_jni_cache_object(e, gNativeP2pDeviceClassName,
757 &(nat->cached_P2pDevice)) == -1) {
758 LOG(ERROR) << StringPrintf("%s: fail cache NativeP2pDevice", __func__);
759 return JNI_FALSE;
760 }
nxpandroid64fd68c2015-09-23 16:45:15 +0530761
nxf24591dc0bc2c2018-02-21 17:33:08 +0530762 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", __func__);
763 return JNI_TRUE;
nxpandroid64fd68c2015-09-23 16:45:15 +0530764}
765
nxpandroid64fd68c2015-09-23 16:45:15 +0530766/*******************************************************************************
767**
768** Function: nfaDeviceManagementCallback
769**
770** Description: Receive device management events from stack.
771** dmEvent: Device-management event ID.
772** eventData: Data associated with event ID.
773**
774** Returns: None
775**
776*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +0530777void nfaDeviceManagementCallback(uint8_t dmEvent,
778 tNFA_DM_CBACK_DATA* eventData) {
779 DLOG_IF(INFO, nfc_debug_enabled)
780 << StringPrintf("%s: enter; event=0x%X", __func__, dmEvent);
nxpandroid64fd68c2015-09-23 16:45:15 +0530781
nxf24591dc0bc2c2018-02-21 17:33:08 +0530782 switch (dmEvent) {
nxpandroid64fd68c2015-09-23 16:45:15 +0530783 case NFA_DM_ENABLE_EVT: /* Result of NFA_Enable */
nxf24591dc0bc2c2018-02-21 17:33:08 +0530784 {
785 SyncEventGuard guard(sNfaEnableEvent);
786 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
787 "%s: NFA_DM_ENABLE_EVT; status=0x%X", __func__, eventData->status);
788 sIsNfaEnabled = eventData->status == NFA_STATUS_OK;
789 sIsDisabling = false;
790 sNfaEnableEvent.notifyOne();
791 } break;
nxpandroid64fd68c2015-09-23 16:45:15 +0530792
793 case NFA_DM_DISABLE_EVT: /* Result of NFA_Disable */
nxf24591dc0bc2c2018-02-21 17:33:08 +0530794 {
795 SyncEventGuard guard(sNfaDisableEvent);
796 DLOG_IF(INFO, nfc_debug_enabled)
797 << StringPrintf("%s: NFA_DM_DISABLE_EVT", __func__);
798 sIsNfaEnabled = false;
799 sIsDisabling = false;
800 sNfaDisableEvent.notifyOne();
801 } break;
nxpandroid64fd68c2015-09-23 16:45:15 +0530802
nxf24591dc0bc2c2018-02-21 17:33:08 +0530803 case NFA_DM_SET_CONFIG_EVT: // result of NFA_SetConfig
804 DLOG_IF(INFO, nfc_debug_enabled)
805 << StringPrintf("%s: NFA_DM_SET_CONFIG_EVT", __func__);
806 {
807 SyncEventGuard guard(sNfaSetConfigEvent);
808 sNfaSetConfigEvent.notifyOne();
809 }
810 break;
nxpandroid64fd68c2015-09-23 16:45:15 +0530811
812 case NFA_DM_GET_CONFIG_EVT: /* Result of NFA_GetConfig */
nxf24591dc0bc2c2018-02-21 17:33:08 +0530813 DLOG_IF(INFO, nfc_debug_enabled)
814 << StringPrintf("%s: NFA_DM_GET_CONFIG_EVT", __func__);
815 {
816 SyncEventGuard guard(sNfaGetConfigEvent);
817 if (eventData->status == NFA_STATUS_OK &&
818 eventData->get_config.tlv_size <= sizeof(sConfig)) {
819 sCurrentConfigLen = eventData->get_config.tlv_size;
820 memcpy(sConfig, eventData->get_config.param_tlvs,
821 eventData->get_config.tlv_size);
822 } else {
823 LOG(ERROR) << StringPrintf("%s: NFA_DM_GET_CONFIG failed", __func__);
824 sCurrentConfigLen = 0;
nxpandroid64fd68c2015-09-23 16:45:15 +0530825 }
nxf24591dc0bc2c2018-02-21 17:33:08 +0530826 sNfaGetConfigEvent.notifyOne();
827 }
828 break;
nxpandroid64fd68c2015-09-23 16:45:15 +0530829
830 case NFA_DM_RF_FIELD_EVT:
nxf24591dc0bc2c2018-02-21 17:33:08 +0530831 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
832 "%s: NFA_DM_RF_FIELD_EVT; status=0x%X; field status=%u", __func__,
833 eventData->rf_field.status, eventData->rf_field.rf_field_status);
Suraj Uday Kotharkar2a0ee9c2018-04-27 03:48:23 +0530834#if(NXP_EXTNS == TRUE)
835 SecureElement::getInstance().notifyRfFieldEvent (
836 eventData->rf_field.rf_field_status == NFA_DM_RF_FIELD_ON);
837#endif
838if (!sP2pActive && eventData->rf_field.status == NFA_STATUS_OK) {
nxf24591dc0bc2c2018-02-21 17:33:08 +0530839 struct nfc_jni_native_data* nat = getNative(NULL, NULL);
840 JNIEnv* e = NULL;
841 ScopedAttach attach(nat->vm, &e);
842 if (e == NULL) {
843 LOG(ERROR) << StringPrintf("jni env is null");
844 return;
nxpandroid64fd68c2015-09-23 16:45:15 +0530845 }
nxf24591dc0bc2c2018-02-21 17:33:08 +0530846 if (eventData->rf_field.rf_field_status == NFA_DM_RF_FIELD_ON)
847 e->CallVoidMethod(nat->manager,
848 android::gCachedNfcManagerNotifyRfFieldActivated);
849 else
850 e->CallVoidMethod(nat->manager,
851 android::gCachedNfcManagerNotifyRfFieldDeactivated);
852 }
853 break;
nxpandroid64fd68c2015-09-23 16:45:15 +0530854
855 case NFA_DM_NFCC_TRANSPORT_ERR_EVT:
nxf24591dc0bc2c2018-02-21 17:33:08 +0530856 case NFA_DM_NFCC_TIMEOUT_EVT: {
857 if (dmEvent == NFA_DM_NFCC_TIMEOUT_EVT)
858 LOG(ERROR) << StringPrintf("%s: NFA_DM_NFCC_TIMEOUT_EVT; abort",
859 __func__);
860 else if (dmEvent == NFA_DM_NFCC_TRANSPORT_ERR_EVT)
861 LOG(ERROR) << StringPrintf("%s: NFA_DM_NFCC_TRANSPORT_ERR_EVT; abort",
862 __func__);
nxpandroid64fd68c2015-09-23 16:45:15 +0530863
nxf24591dc0bc2c2018-02-21 17:33:08 +0530864 nativeNfcTag_abortWaits();
865 NfcTag::getInstance().abort();
866 sAbortConnlessWait = true;
867 nativeLlcpConnectionlessSocket_abortWait();
868 {
869 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
870 "%s: aborting sNfaEnableDisablePollingEvent", __func__);
871 SyncEventGuard guard(sNfaEnableDisablePollingEvent);
872 sNfaEnableDisablePollingEvent.notifyOne();
873 }
874 {
875 DLOG_IF(INFO, nfc_debug_enabled)
876 << StringPrintf("%s: aborting sNfaEnableEvent", __func__);
877 SyncEventGuard guard(sNfaEnableEvent);
878 sNfaEnableEvent.notifyOne();
879 }
880 {
881 DLOG_IF(INFO, nfc_debug_enabled)
882 << StringPrintf("%s: aborting sNfaDisableEvent", __func__);
883 SyncEventGuard guard(sNfaDisableEvent);
884 sNfaDisableEvent.notifyOne();
885 }
886 sDiscoveryEnabled = false;
887 sPollingEnabled = false;
888 PowerSwitch::getInstance().abort();
889
890 if (!sIsDisabling && sIsNfaEnabled) {
891 EXTNS_Close();
892 NFA_Disable(FALSE);
893 sIsDisabling = true;
894 } else {
895 sIsNfaEnabled = false;
896 sIsDisabling = false;
897 }
898 PowerSwitch::getInstance().initialize(PowerSwitch::UNKNOWN_LEVEL);
899 LOG(ERROR) << StringPrintf("%s: crash NFC service", __func__);
900 //////////////////////////////////////////////
901 // crash the NFC service process so it can restart automatically
902 abort();
903 //////////////////////////////////////////////
904 } break;
nxpandroid64fd68c2015-09-23 16:45:15 +0530905
906 case NFA_DM_PWR_MODE_CHANGE_EVT:
nxf24591dc0bc2c2018-02-21 17:33:08 +0530907 PowerSwitch::getInstance().deviceManagementCallback(dmEvent, eventData);
908 break;
nxpandroid64fd68c2015-09-23 16:45:15 +0530909
nxf24591dc0bc2c2018-02-21 17:33:08 +0530910 case NFA_DM_SET_POWER_SUB_STATE_EVT: {
911 DLOG_IF(INFO, nfc_debug_enabled)
912 << StringPrintf("%s: NFA_DM_SET_POWER_SUB_STATE_EVT; status=0x%X",
913 __FUNCTION__, eventData->power_sub_state.status);
914 SyncEventGuard guard(sNfaSetPowerSubState);
915 sNfaSetPowerSubState.notifyOne();
916 } break;
nxpandroid64fd68c2015-09-23 16:45:15 +0530917 default:
nxf24591dc0bc2c2018-02-21 17:33:08 +0530918 DLOG_IF(INFO, nfc_debug_enabled)
919 << StringPrintf("%s: unhandled event", __func__);
920 break;
921 }
nxpandroid64fd68c2015-09-23 16:45:15 +0530922}
Ayush73d68912018-04-04 21:36:26 +0530923#if(NXP_EXTNS == TRUE)
924static jintArray nfcManager_getActiveSecureElementList(JNIEnv *e, jobject o)
925{
926 (void)e;
927 (void)o;
928 return SecureElement::getInstance().getActiveSecureElementList(e);
929}
930#endif
nxpandroid64fd68c2015-09-23 16:45:15 +0530931/*******************************************************************************
932**
933** Function: nfcManager_sendRawFrame
934**
935** Description: Send a raw frame.
936** e: JVM environment.
937** o: Java object.
938**
939** Returns: True if ok.
940**
941*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +0530942static jboolean nfcManager_sendRawFrame(JNIEnv* e, jobject, jbyteArray data) {
943 ScopedByteArrayRO bytes(e, data);
944 uint8_t* buf =
945 const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0]));
946 size_t bufLen = bytes.size();
947 tNFA_STATUS status = NFA_SendRawFrame(buf, bufLen, 0);
948
949 return (status == NFA_STATUS_OK);
nxpandroid64fd68c2015-09-23 16:45:15 +0530950}
951
952/*******************************************************************************
953**
954** Function: nfcManager_routeAid
955**
956** Description: Route an AID to an EE
957** e: JVM environment.
nxf24591dc0bc2c2018-02-21 17:33:08 +0530958** aid: aid to be added to routing table.
959** route: aid route location. i.e. DH/eSE/UICC
960** aidInfo: prefix or suffix aid.
nxpandroid64fd68c2015-09-23 16:45:15 +0530961**
nxf24591dc0bc2c2018-02-21 17:33:08 +0530962** Returns: True if aid is accpted by NFA Layer.
nxpandroid64fd68c2015-09-23 16:45:15 +0530963**
964*******************************************************************************/
nxpandroid0f06fde2017-08-14 11:25:28 +0530965#if (NXP_EXTNS == TRUE)
nxf24591dc0bc2c2018-02-21 17:33:08 +0530966static jboolean nfcManager_routeAid(JNIEnv* e, jobject, jbyteArray aid,
967 jint route, jint aidInfo, jint power) {
nxpandroid64fd68c2015-09-23 16:45:15 +0530968#else
nxf24591dc0bc2c2018-02-21 17:33:08 +0530969static jboolean nfcManager_routeAid(JNIEnv* e, jobject, jbyteArray aid,
970 jint route, jint aidInfo) {
nxpandroid64fd68c2015-09-23 16:45:15 +0530971#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +0530972 ScopedByteArrayRO bytes(e, aid);
973 uint8_t* buf =
974 const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0]));
975 size_t bufLen = bytes.size();
976#if (NXP_EXTNS == TRUE)
977 return RoutingManager::getInstance().addAidRouting(buf, bufLen, route,
978 aidInfo, power);
979#else
980 return RoutingManager::getInstance().addAidRouting(buf, bufLen, route,
981 aidInfo);
982#endif
nxpandroid64fd68c2015-09-23 16:45:15 +0530983}
984
985/*******************************************************************************
986**
987** Function: nfcManager_unrouteAid
988**
989** Description: Remove a AID routing
990** e: JVM environment.
991** o: Java object.
992**
993** Returns: True if ok.
994**
995*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +0530996static jboolean nfcManager_unrouteAid(JNIEnv* e, jobject, jbyteArray aid) {
997 ScopedByteArrayRO bytes(e, aid);
998 uint8_t* buf =
999 const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0]));
1000 size_t bufLen = bytes.size();
1001 bool result = RoutingManager::getInstance().removeAidRouting(buf, bufLen);
1002 return result;
nxpandroid64fd68c2015-09-23 16:45:15 +05301003}
1004
nxpandroide00bc1a2017-07-12 21:39:16 +05301005/*******************************************************************************
1006**
nxf24591dc0bc2c2018-02-21 17:33:08 +05301007** Function: nfcManager_commitRouting
nxpandroide00bc1a2017-07-12 21:39:16 +05301008**
nxf24591dc0bc2c2018-02-21 17:33:08 +05301009** Description: Sends the AID routing table to the controller
nxpandroide00bc1a2017-07-12 21:39:16 +05301010** e: JVM environment.
1011** o: Java object.
1012**
1013** Returns: True if ok.
1014**
1015*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301016static jboolean nfcManager_commitRouting(JNIEnv* e, jobject) {
1017#if (NXP_EXTNS == TRUE)
1018 bool status = false;
1019 if (sRfEnabled) {
1020 /*Stop RF discovery to reconfigure*/
1021 startRfDiscovery(false);
1022 }
1023 LOG(ERROR) << StringPrintf("commitRouting here");
1024 status = RoutingManager::getInstance().commitRouting();
1025 if (!sRfEnabled) {
1026 /*Stop RF discovery to reconfigure*/
1027 startRfDiscovery(true);
1028 }
1029 return status;
1030#else
1031 return RoutingManager::getInstance().commitRouting();
nxpandroide00bc1a2017-07-12 21:39:16 +05301032#endif
nxpandroide00bc1a2017-07-12 21:39:16 +05301033}
1034
1035/*******************************************************************************
1036**
nxpandroid64fd68c2015-09-23 16:45:15 +05301037** Function: nfcManager_setDefaultRoute
1038**
1039** Description: Set the default route in routing table
1040** e: JVM environment.
1041** o: Java object.
1042**
1043*******************************************************************************/
1044
1045static jboolean nfcManager_setDefaultRoute (JNIEnv*, jobject, jint defaultRouteEntry, jint defaultProtoRouteEntry, jint defaultTechRouteEntry)
1046{
nxpandroid6fd9cdb2017-07-12 18:25:41 +05301047 jboolean result = false;
nxpandroid1e2a13c2017-04-10 18:19:00 +05301048#if (NXP_EXTNS == TRUE)
nxf24591dc0bc2c2018-02-21 17:33:08 +05301049 DLOG_IF(INFO, nfc_debug_enabled)
1050 << StringPrintf("%s: enter", __func__);
nxpandroid34627bd2016-05-27 15:52:30 +05301051 if (sRfEnabled)
1052 {
nxpandroid64fd68c2015-09-23 16:45:15 +05301053 // Stop RF discovery to reconfigure
1054 startRfDiscovery(false);
1055 }
nxpandroid34627bd2016-05-27 15:52:30 +05301056
nxpandroid64fd68c2015-09-23 16:45:15 +05301057 result = RoutingManager::getInstance().setDefaultRoute(defaultRouteEntry, defaultProtoRouteEntry, defaultTechRouteEntry);
nxpandroid34627bd2016-05-27 15:52:30 +05301058 if(result)
1059 result = RoutingManager::getInstance().commitRouting();
1060 else
nxf24591dc0bc2c2018-02-21 17:33:08 +05301061 DLOG_IF(INFO, nfc_debug_enabled)
1062 << StringPrintf("%s: commit routing failed", __func__);
nxpandroida9a68ba2016-01-14 21:12:17 +05301063
nxpandroid64fd68c2015-09-23 16:45:15 +05301064 startRfDiscovery(true);
nxf24591dc0bc2c2018-02-21 17:33:08 +05301065 DLOG_IF(INFO, nfc_debug_enabled)
1066 << StringPrintf("%s: exit", __func__);
nxpandroid1e2a13c2017-04-10 18:19:00 +05301067#endif
nxpandroid64fd68c2015-09-23 16:45:15 +05301068 return result;
1069}
1070
1071/*******************************************************************************
1072**
nxpandroid34627bd2016-05-27 15:52:30 +05301073** Function: nfcManager_doRegisterT3tIdentifier
1074**
1075** Description: Registers LF_T3T_IDENTIFIER for NFC-F.
1076** e: JVM environment.
1077** o: Java object.
1078** t3tIdentifier: LF_T3T_IDENTIFIER value (10 or 18 bytes)
1079**
1080** Returns: Handle retrieve from RoutingManager.
1081**
1082*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301083static jint nfcManager_doRegisterT3tIdentifier(JNIEnv* e, jobject,
1084 jbyteArray t3tIdentifier) {
1085 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", __func__);
1086
1087 ScopedByteArrayRO bytes(e, t3tIdentifier);
1088 uint8_t* buf =
1089 const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&bytes[0]));
1090 size_t bufLen = bytes.size();
1091 int handle = RoutingManager::getInstance().registerT3tIdentifier(buf, bufLen);
1092
1093 DLOG_IF(INFO, nfc_debug_enabled)
1094 << StringPrintf("%s: handle=%d", __func__, handle);
1095 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", __func__);
1096
1097 return handle;
nxpandroid34627bd2016-05-27 15:52:30 +05301098}
1099
1100/*******************************************************************************
1101**
1102** Function: nfcManager_doDeregisterT3tIdentifier
1103**
1104** Description: Deregisters LF_T3T_IDENTIFIER for NFC-F.
1105** e: JVM environment.
1106** o: Java object.
1107** handle: Handle retrieve from libnfc-nci.
1108**
1109** Returns: None
1110**
1111*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301112static void nfcManager_doDeregisterT3tIdentifier(JNIEnv*, jobject,
1113 jint handle) {
1114 DLOG_IF(INFO, nfc_debug_enabled)
1115 << StringPrintf("%s: enter; handle=%d", __func__, handle);
1116
1117 RoutingManager::getInstance().deregisterT3tIdentifier(handle);
1118
1119 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", __func__);
nxpandroid34627bd2016-05-27 15:52:30 +05301120}
1121
1122/*******************************************************************************
1123**
1124** Function: nfcManager_getLfT3tMax
1125**
1126** Description: Returns LF_T3T_MAX value.
1127** e: JVM environment.
1128** o: Java object.
1129**
1130** Returns: LF_T3T_MAX value.
1131**
1132*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301133static jint nfcManager_getLfT3tMax(JNIEnv*, jobject) {
1134 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", __func__);
1135 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("LF_T3T_MAX=%d", sLfT3tMax);
1136 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", __func__);
1137
1138 return sLfT3tMax;
nxpandroid34627bd2016-05-27 15:52:30 +05301139}
nxpandroid64fd68c2015-09-23 16:45:15 +05301140
1141/*******************************************************************************
1142**
1143** Function: nfcManager_doInitialize
1144**
1145** Description: Turn on NFC.
1146** e: JVM environment.
1147** o: Java object.
1148**
1149** Returns: True if ok.
1150**
1151*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301152static jboolean nfcManager_doInitialize(JNIEnv* e, jobject o) {
nxpandroid82f7e9e2018-04-05 14:54:41 +05301153#if (NXP_EXTNS == TRUE)
nxf24591dc0bc2c2018-02-21 17:33:08 +05301154 tNFA_MW_VERSION mwVer;
nxpandroid82f7e9e2018-04-05 14:54:41 +05301155#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +05301156 DLOG_IF(INFO, nfc_debug_enabled)
1157 << StringPrintf("%s: enter; ver=%s nfa=%s NCI_VERSION=0x%02X", __func__,
1158 nfca_version_string, nfa_version_string, NCI_VERSION);
1159 tNFA_STATUS stat = NFA_STATUS_OK;
nxpandroidebf53fb2016-12-22 18:48:59 +05301160
nxf24591dc0bc2c2018-02-21 17:33:08 +05301161 PowerSwitch& powerSwitch = PowerSwitch::getInstance();
nxpandroideeac6422017-09-14 12:09:33 +05301162
nxf24591dc0bc2c2018-02-21 17:33:08 +05301163 if (sIsNfaEnabled) {
1164 DLOG_IF(INFO, nfc_debug_enabled)
1165 << StringPrintf("%s: already enabled", __func__);
1166 goto TheEnd;
1167 }
nxpandroid82f7e9e2018-04-05 14:54:41 +05301168#if (NXP_EXTNS == TRUE)
nxpandroid7d44e572016-08-01 19:11:04 +05301169 mwVer= NFA_GetMwVersion();
nxf24591dc0bc2c2018-02-21 17:33:08 +05301170 LOG(ERROR) << StringPrintf("%s: MW Version: NFC_NCIHALx_AR%X.%x.%x.%x_RC%x",
nxpandroid6fd9cdb2017-07-12 18:25:41 +05301171 __func__, mwVer.validation, mwVer.android_version,
nxf24591dc0bc2c2018-02-21 17:33:08 +05301172 mwVer.major_version,mwVer.minor_version,mwVer.rc_version);
nxpandroid82f7e9e2018-04-05 14:54:41 +05301173#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +05301174 powerSwitch.initialize(PowerSwitch::FULL_POWER);
nxpandroid64fd68c2015-09-23 16:45:15 +05301175
nxf24591dc0bc2c2018-02-21 17:33:08 +05301176 {
nxpandroid5d64ce92016-11-18 19:48:53 +05301177
1178 NfcAdaptation& theInstance = NfcAdaptation::GetInstance();
nxf24591dc0bc2c2018-02-21 17:33:08 +05301179 theInstance.Initialize(); // start GKI, NCI task, NFC task
nxpandroid5d64ce92016-11-18 19:48:53 +05301180
nxpandroid1680a6d2017-01-13 19:13:14 +05301181 {
nxf24591dc0bc2c2018-02-21 17:33:08 +05301182 SyncEventGuard guard(sNfaEnableEvent);
1183 tHAL_NFC_ENTRY* halFuncEntries = theInstance.GetHalEntryFuncs();
1184
1185 NFA_Init(halFuncEntries);
1186
1187 stat = NFA_Enable(nfaDeviceManagementCallback, nfaConnectionCallback);
1188 if (stat == NFA_STATUS_OK) {
1189 sNfaEnableEvent.wait(); // wait for NFA command to finish
1190 }
1191 EXTNS_Init(nfaDeviceManagementCallback, nfaConnectionCallback);
nxpandroid5d64ce92016-11-18 19:48:53 +05301192 }
nxf24591dc0bc2c2018-02-21 17:33:08 +05301193
1194 if (stat == NFA_STATUS_OK) {
1195 // sIsNfaEnabled indicates whether stack started successfully
1196 if (sIsNfaEnabled) {
1197#if (NXP_EXTNS == TRUE)
1198 SecureElement::getInstance().initialize (getNative(e, o));
nxpandroid5d64ce92016-11-18 19:48:53 +05301199#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +05301200 RoutingManager::getInstance().initialize(getNative(e, o));
1201 nativeNfcTag_registerNdefTypeHandler();
1202 NfcTag::getInstance().initialize(getNative(e, o));
1203 PeerToPeer::getInstance().initialize();
1204 PeerToPeer::getInstance().handleNfcOnOff(true);
nxpandroidecca0112018-06-06 14:41:40 +05301205#if(NXP_EXTNS == TRUE)
1206 MposManager::getInstance().initialize(getNative(e, o));
1207#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +05301208 /////////////////////////////////////////////////////////////////////////////////
1209 // Add extra configuration here (work-arounds, etc.)
nxpandroid64fd68c2015-09-23 16:45:15 +05301210
nxf24591dc0bc2c2018-02-21 17:33:08 +05301211 if (gIsDtaEnabled == true) {
1212 uint8_t configData = 0;
1213 configData = 0x01; /* Poll NFC-DEP : Highest Available Bit Rates */
1214 NFA_SetConfig(NCI_PARAM_ID_BITR_NFC_DEP, sizeof(uint8_t),
1215 &configData);
1216 configData = 0x0B; /* Listen NFC-DEP : Waiting Time */
1217 NFA_SetConfig(NFC_PMID_WT, sizeof(uint8_t), &configData);
1218 configData = 0x0F; /* Specific Parameters for NFC-DEP RF Interface */
1219 NFA_SetConfig(NCI_PARAM_ID_NFC_DEP_OP, sizeof(uint8_t), &configData);
nxpandroid1153eb32015-11-06 18:46:58 +05301220 }
nxf24591dc0bc2c2018-02-21 17:33:08 +05301221
1222 struct nfc_jni_native_data* nat = getNative(e, o);
1223 if (nat) {
1224 nat->tech_mask =
1225 NfcConfig::getUnsigned(NAME_POLLING_TECH_MASK, DEFAULT_TECH_MASK);
1226 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
1227 "%s: tag polling tech mask=0x%X", __func__, nat->tech_mask);
1228 }
1229
1230 // if this value exists, set polling interval.
1231 nat->discovery_duration = NfcConfig::getUnsigned(
1232 NAME_NFA_DM_DISC_DURATION_POLL, DEFAULT_DISCOVERY_DURATION);
1233
1234 NFA_SetRfDiscoveryDuration(nat->discovery_duration);
1235
1236 // get LF_T3T_MAX
1237 {
1238 SyncEventGuard guard(sNfaGetConfigEvent);
1239 tNFA_PMID configParam[1] = {NCI_PARAM_ID_LF_T3T_MAX};
1240 stat = NFA_GetConfig(1, configParam);
1241 if (stat == NFA_STATUS_OK) {
1242 sNfaGetConfigEvent.wait();
1243 if (sCurrentConfigLen >= 4 ||
1244 sConfig[1] == NCI_PARAM_ID_LF_T3T_MAX) {
1245 DLOG_IF(INFO, nfc_debug_enabled)
1246 << StringPrintf("%s: lfT3tMax=%d", __func__, sConfig[3]);
1247 sLfT3tMax = sConfig[3];
1248 }
1249 }
1250 }
1251
1252 prevScreenState = NFA_SCREEN_STATE_OFF_LOCKED;
1253
1254 // Do custom NFCA startup configuration.
1255 doStartupConfig();
1256 goto TheEnd;
1257 }
nxpandroid1153eb32015-11-06 18:46:58 +05301258 }
nxf24591dc0bc2c2018-02-21 17:33:08 +05301259
1260 LOG(ERROR) << StringPrintf("%s: fail nfa enable; error=0x%X", __func__,
1261 stat);
1262
1263 if (sIsNfaEnabled) {
1264 EXTNS_Close();
1265 stat = NFA_Disable(FALSE /* ungraceful */);
nxpandroid1153eb32015-11-06 18:46:58 +05301266 }
nxf24591dc0bc2c2018-02-21 17:33:08 +05301267
1268 theInstance.Finalize();
1269 }
1270
1271TheEnd:
1272 if (sIsNfaEnabled)
1273 PowerSwitch::getInstance().setLevel(PowerSwitch::LOW_POWER);
1274 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", __func__);
1275 return sIsNfaEnabled ? JNI_TRUE : JNI_FALSE;
nxpandroid1153eb32015-11-06 18:46:58 +05301276}
nxf24591dc0bc2c2018-02-21 17:33:08 +05301277
1278static void nfcManager_doEnableDtaMode(JNIEnv*, jobject) {
1279 gIsDtaEnabled = true;
1280}
1281
1282static void nfcManager_doDisableDtaMode(JNIEnv*, jobject) {
1283 gIsDtaEnabled = false;
1284}
1285
1286static void nfcManager_doFactoryReset(JNIEnv*, jobject) {
1287 NfcAdaptation& theInstance = NfcAdaptation::GetInstance();
1288 theInstance.FactoryReset();
1289}
1290
1291static void nfcManager_doShutdown(JNIEnv*, jobject) {
1292 NfcAdaptation& theInstance = NfcAdaptation::GetInstance();
1293 theInstance.DeviceShutdown();
1294}
nxpandroid64fd68c2015-09-23 16:45:15 +05301295/*******************************************************************************
1296**
1297** Function: nfcManager_enableDiscovery
1298**
1299** Description: Start polling and listening for devices.
1300** e: JVM environment.
1301** o: Java object.
nxf24591dc0bc2c2018-02-21 17:33:08 +05301302** technologies_mask: the bitmask of technologies for which to
1303*enable discovery
1304** enable_lptd: whether to enable low power polling (default:
1305*false)
nxpandroid64fd68c2015-09-23 16:45:15 +05301306**
1307** Returns: None
1308**
1309*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301310static void nfcManager_enableDiscovery(JNIEnv* e, jobject o,
1311 jint technologies_mask,
1312 jboolean enable_lptd,
1313 jboolean reader_mode,
1314 jboolean enable_host_routing,
1315 jboolean enable_p2p, jboolean restart) {
1316 tNFA_TECHNOLOGY_MASK tech_mask = DEFAULT_TECH_MASK;
1317 struct nfc_jni_native_data* nat = getNative(e, o);
nxpandroidecca0112018-06-06 14:41:40 +05301318#if(NXP_EXTNS == TRUE)
1319 storeLastDiscoveryParams(technologies_mask, enable_lptd,
1320 reader_mode, enable_host_routing ,enable_p2p, restart);
1321 tNFA_STATUS status = NFA_STATUS_OK;
1322 tNFA_TECHNOLOGY_MASK etsi_tech_mask = 0;
1323 if((nfcFL.nfcNxpEse && nfcFL.eseFL._ESE_ETSI_READER_ENABLE) &&
1324 (MposManager::getInstance().getEtsiReaederState() == STATE_SE_RDR_MODE_STARTED)) {
1325 DLOG_IF(INFO, nfc_debug_enabled)
1326 << StringPrintf("%s: enter STATE_SE_RDR_MODE_START_CONFIG", __func__);
1327 Rdr_req_ntf_info_t mSwp_info = MposManager::getInstance().getSwpRrdReqInfo();
1328 {
1329 SyncEventGuard guard (android::sNfaEnableDisablePollingEvent);
1330 DLOG_IF(INFO, nfc_debug_enabled)
1331 << StringPrintf("%s: disable polling", __func__);
1332 status = NFA_DisablePolling ();
1333 if (status == NFA_STATUS_OK)
1334 {
1335 android::sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_DISABLED_EVT
1336 }
1337 else
1338 {
1339 DLOG_IF(INFO, nfc_debug_enabled)
1340 << StringPrintf("%s: fail disable polling; error=0x%X", __func__, status);
1341 }
1342 }
nxpandroidebf53fb2016-12-22 18:48:59 +05301343
nxpandroidecca0112018-06-06 14:41:40 +05301344 if(mSwp_info.swp_rd_req_info.tech_mask & NFA_TECHNOLOGY_MASK_A)
1345 etsi_tech_mask |= NFA_TECHNOLOGY_MASK_A;
1346 if(mSwp_info.swp_rd_req_info.tech_mask & NFA_TECHNOLOGY_MASK_B)
1347 etsi_tech_mask |= NFA_TECHNOLOGY_MASK_B;
1348
1349 {
1350 SyncEventGuard guard (android::sNfaEnableDisablePollingEvent);
1351 status = NFA_EnablePolling (etsi_tech_mask);
1352 if (status == NFA_STATUS_OK)
1353 {
1354 DLOG_IF(INFO, nfc_debug_enabled)
1355 << StringPrintf("%s: wait for enable event", __func__);
1356 android::sNfaEnableDisablePollingEvent.wait (); //wait for NFA_POLL_ENABLED_EVT
1357 }
1358 else
1359 {
1360 DLOG_IF(INFO, nfc_debug_enabled)
1361 << StringPrintf("%s: fail enable polling; error=0x%X", __func__, status);
1362 }
1363 }
1364 startRfDiscovery (true);
1365 return;
1366 }
1367#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +05301368 if (technologies_mask == -1 && nat)
1369 tech_mask = (tNFA_TECHNOLOGY_MASK)nat->tech_mask;
1370 else if (technologies_mask != -1)
1371 tech_mask = (tNFA_TECHNOLOGY_MASK)technologies_mask;
1372 DLOG_IF(INFO, nfc_debug_enabled)
1373 << StringPrintf("%s: enter; tech_mask = %02x", __func__, tech_mask);
nxpandroid64fd68c2015-09-23 16:45:15 +05301374
nxf24591dc0bc2c2018-02-21 17:33:08 +05301375 if (sDiscoveryEnabled && !restart) {
1376 LOG(ERROR) << StringPrintf("%s: already discovering", __func__);
1377 return;
1378 }
1379
1380 PowerSwitch::getInstance().setLevel(PowerSwitch::FULL_POWER);
1381
1382 if (sRfEnabled) {
1383 // Stop RF discovery to reconfigure
1384 startRfDiscovery(false);
1385 }
1386
1387 // Check polling configuration
1388 if (tech_mask != 0) {
1389 stopPolling_rfDiscoveryDisabled();
1390 enableDisableLptd(enable_lptd);
1391 startPolling_rfDiscoveryDisabled(tech_mask);
1392
1393 // Start P2P listening if tag polling was enabled
1394 if (sPollingEnabled) {
1395 DLOG_IF(INFO, nfc_debug_enabled)
1396 << StringPrintf("%s: Enable p2pListening", __func__);
1397
1398 if (enable_p2p && !sP2pEnabled) {
1399 sP2pEnabled = true;
1400 PeerToPeer::getInstance().enableP2pListening(true);
1401 NFA_ResumeP2p();
1402 } else if (!enable_p2p && sP2pEnabled) {
1403 sP2pEnabled = false;
1404 PeerToPeer::getInstance().enableP2pListening(false);
1405 NFA_PauseP2p();
1406 }
1407
1408 if (reader_mode && !sReaderModeEnabled) {
1409 sReaderModeEnabled = true;
1410 NFA_DisableListening();
1411 NFA_SetRfDiscoveryDuration(READER_MODE_DISCOVERY_DURATION);
1412 } else if (!reader_mode && sReaderModeEnabled) {
1413 struct nfc_jni_native_data* nat = getNative(e, o);
1414 sReaderModeEnabled = false;
1415 NFA_EnableListening();
1416 NFA_SetRfDiscoveryDuration(nat->discovery_duration);
1417 }
1418 }
1419 } else {
1420 // No technologies configured, stop polling
1421 stopPolling_rfDiscoveryDisabled();
1422 }
1423
1424 // Check listen configuration
1425
1426#if (NXP_EXTNS != TRUE)
1427 if (enable_host_routing) {
1428 RoutingManager::getInstance().enableRoutingToHost();
1429 RoutingManager::getInstance().commitRouting();
1430 } else {
1431 RoutingManager::getInstance().disableRoutingToHost();
1432 RoutingManager::getInstance().commitRouting();
1433 }
nxpandroid64fd68c2015-09-23 16:45:15 +05301434#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +05301435 // Actually start discovery.
1436 startRfDiscovery(true);
1437 sDiscoveryEnabled = true;
nxpandroid64fd68c2015-09-23 16:45:15 +05301438
nxf24591dc0bc2c2018-02-21 17:33:08 +05301439 PowerSwitch::getInstance().setModeOn(PowerSwitch::DISCOVERY);
nxpandroid64fd68c2015-09-23 16:45:15 +05301440
nxf24591dc0bc2c2018-02-21 17:33:08 +05301441 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", __func__);
nxpandroid64fd68c2015-09-23 16:45:15 +05301442}
1443
nxpandroid64fd68c2015-09-23 16:45:15 +05301444/*******************************************************************************
1445**
1446** Function: nfcManager_disableDiscovery
1447**
1448** Description: Stop polling and listening for devices.
1449** e: JVM environment.
1450** o: Java object.
1451**
1452** Returns: None
1453**
1454*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301455void nfcManager_disableDiscovery(JNIEnv* e, jobject o) {
1456 tNFA_STATUS status = NFA_STATUS_OK;
1457 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter;", __func__);
nxpandroid64fd68c2015-09-23 16:45:15 +05301458
nxf24591dc0bc2c2018-02-21 17:33:08 +05301459 pn544InteropAbortNow();
nxpandroidecca0112018-06-06 14:41:40 +05301460#if(NXP_EXTNS == TRUE)
1461 if(nfcFL.nfcNxpEse && nfcFL.eseFL._ESE_ETSI_READER_ENABLE) {
1462 if(MposManager::getInstance().getEtsiReaederState() == STATE_SE_RDR_MODE_START_IN_PROGRESS)
1463 {
1464 Rdr_req_ntf_info_t mSwp_info = MposManager::getInstance().getSwpRrdReqInfo();
1465 // if(android::isDiscoveryStarted() == true)
1466 android::startRfDiscovery(false);
1467 PeerToPeer::getInstance().enableP2pListening (false);
1468 {
1469 status = NFA_CeConfigureUiccListenTech (mSwp_info.swp_rd_req_info.src, 0x00);
1470 }
1471 goto TheEnd;
1472 }
1473 else if(MposManager::getInstance().getEtsiReaederState() == STATE_SE_RDR_MODE_STOP_IN_PROGRESS)
1474 {
1475 android::startRfDiscovery(false);
1476 goto TheEnd;
1477 }
1478 }
1479#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +05301480 if (sDiscoveryEnabled == false) {
1481 DLOG_IF(INFO, nfc_debug_enabled)
1482 << StringPrintf("%s: already disabled", __func__);
1483 goto TheEnd;
1484 }
nxpandroid64fd68c2015-09-23 16:45:15 +05301485
nxf24591dc0bc2c2018-02-21 17:33:08 +05301486 // Stop RF Discovery.
1487 startRfDiscovery(false);
nxpandroid64fd68c2015-09-23 16:45:15 +05301488
nxf24591dc0bc2c2018-02-21 17:33:08 +05301489 if (sPollingEnabled) status = stopPolling_rfDiscoveryDisabled();
nxpandroid64fd68c2015-09-23 16:45:15 +05301490
nxf24591dc0bc2c2018-02-21 17:33:08 +05301491 PeerToPeer::getInstance().enableP2pListening(false);
1492 sP2pEnabled = false;
1493 sDiscoveryEnabled = false;
1494 // if nothing is active after this, then tell the controller to power down
1495 if (!PowerSwitch::getInstance().setModeOff(PowerSwitch::DISCOVERY))
1496 PowerSwitch::getInstance().setLevel(PowerSwitch::LOW_POWER);
nxpandroid64fd68c2015-09-23 16:45:15 +05301497TheEnd:
nxf24591dc0bc2c2018-02-21 17:33:08 +05301498 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", __func__);
nxpandroid64fd68c2015-09-23 16:45:15 +05301499}
1500
nxf24591dc0bc2c2018-02-21 17:33:08 +05301501void enableDisableLptd(bool enable) {
1502 // This method is *NOT* thread-safe. Right now
1503 // it is only called from the same thread so it's
1504 // not an issue.
1505 static bool sCheckedLptd = false;
1506 static bool sHasLptd = false;
nxpandroid64fd68c2015-09-23 16:45:15 +05301507
nxf24591dc0bc2c2018-02-21 17:33:08 +05301508 tNFA_STATUS stat = NFA_STATUS_OK;
1509 if (!sCheckedLptd) {
1510 sCheckedLptd = true;
1511 SyncEventGuard guard(sNfaGetConfigEvent);
1512 tNFA_PMID configParam[1] = {NCI_PARAM_ID_TAGSNIFF_CFG};
1513 stat = NFA_GetConfig(1, configParam);
1514 if (stat != NFA_STATUS_OK) {
1515 LOG(ERROR) << StringPrintf("%s: NFA_GetConfig failed", __func__);
1516 return;
nxpandroid64fd68c2015-09-23 16:45:15 +05301517 }
nxf24591dc0bc2c2018-02-21 17:33:08 +05301518 sNfaGetConfigEvent.wait();
1519 if (sCurrentConfigLen < 4 || sConfig[1] != NCI_PARAM_ID_TAGSNIFF_CFG) {
1520 LOG(ERROR) << StringPrintf(
1521 "%s: Config TLV length %d returned is too short", __func__,
1522 sCurrentConfigLen);
1523 return;
nxpandroid64fd68c2015-09-23 16:45:15 +05301524 }
nxf24591dc0bc2c2018-02-21 17:33:08 +05301525 if (sConfig[3] == 0) {
1526 LOG(ERROR) << StringPrintf(
1527 "%s: LPTD is disabled, not enabling in current config", __func__);
1528 return;
1529 }
1530 sHasLptd = true;
1531 }
1532 // Bail if we checked and didn't find any LPTD config before
1533 if (!sHasLptd) return;
1534 uint8_t enable_byte = enable ? 0x01 : 0x00;
nxpandroid64fd68c2015-09-23 16:45:15 +05301535
nxf24591dc0bc2c2018-02-21 17:33:08 +05301536 SyncEventGuard guard(sNfaSetConfigEvent);
1537
1538 stat = NFA_SetConfig(NCI_PARAM_ID_TAGSNIFF_CFG, 1, &enable_byte);
1539 if (stat == NFA_STATUS_OK)
1540 sNfaSetConfigEvent.wait();
1541 else
1542 LOG(ERROR) << StringPrintf("%s: Could not configure LPTD feature",
1543 __func__);
1544 return;
nxpandroid64fd68c2015-09-23 16:45:15 +05301545}
1546
nxpandroid64fd68c2015-09-23 16:45:15 +05301547/*******************************************************************************
1548**
1549** Function: nfcManager_doCreateLlcpServiceSocket
1550**
1551** Description: Create a new LLCP server socket.
1552** e: JVM environment.
1553** o: Java object.
1554** nSap: Service access point.
1555** sn: Service name
1556** miu: Maximum information unit.
1557** rw: Receive window size.
1558** linearBufferLength: Max buffer size.
1559**
1560** Returns: NativeLlcpServiceSocket Java object.
1561**
1562*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301563static jobject nfcManager_doCreateLlcpServiceSocket(JNIEnv* e, jobject,
1564 jint nSap, jstring sn,
1565 jint miu, jint rw,
1566 jint linearBufferLength) {
1567 PeerToPeer::tJNI_HANDLE jniHandle =
1568 PeerToPeer::getInstance().getNewJniHandle();
nxpandroid64fd68c2015-09-23 16:45:15 +05301569
nxf24591dc0bc2c2018-02-21 17:33:08 +05301570 ScopedUtfChars serviceName(e, sn);
nxpandroid64fd68c2015-09-23 16:45:15 +05301571
nxf24591dc0bc2c2018-02-21 17:33:08 +05301572 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
1573 "%s: enter: sap=%i; name=%s; miu=%i; rw=%i; buffLen=%i", __func__, nSap,
1574 serviceName.c_str(), miu, rw, linearBufferLength);
nxpandroid64fd68c2015-09-23 16:45:15 +05301575
nxf24591dc0bc2c2018-02-21 17:33:08 +05301576 /* Create new NativeLlcpServiceSocket object */
1577 jobject serviceSocket = NULL;
1578 if (nfc_jni_cache_object_local(e, gNativeLlcpServiceSocketClassName,
1579 &(serviceSocket)) == -1) {
1580 LOG(ERROR) << StringPrintf("%s: Llcp socket object creation error",
1581 __func__);
1582 return NULL;
1583 }
nxpandroid64fd68c2015-09-23 16:45:15 +05301584
nxf24591dc0bc2c2018-02-21 17:33:08 +05301585 /* Get NativeLlcpServiceSocket class object */
1586 ScopedLocalRef<jclass> clsNativeLlcpServiceSocket(
1587 e, e->GetObjectClass(serviceSocket));
1588 if (e->ExceptionCheck()) {
1589 e->ExceptionClear();
1590 LOG(ERROR) << StringPrintf("%s: Llcp Socket get object class error",
1591 __func__);
1592 return NULL;
1593 }
nxpandroid64fd68c2015-09-23 16:45:15 +05301594
nxf24591dc0bc2c2018-02-21 17:33:08 +05301595 if (!PeerToPeer::getInstance().registerServer(jniHandle,
1596 serviceName.c_str())) {
1597 LOG(ERROR) << StringPrintf("%s: RegisterServer error", __func__);
1598 return NULL;
1599 }
nxpandroid64fd68c2015-09-23 16:45:15 +05301600
nxf24591dc0bc2c2018-02-21 17:33:08 +05301601 jfieldID f;
nxpandroid64fd68c2015-09-23 16:45:15 +05301602
nxf24591dc0bc2c2018-02-21 17:33:08 +05301603 /* Set socket handle to be the same as the NfaHandle*/
1604 f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mHandle", "I");
1605 e->SetIntField(serviceSocket, f, (jint)jniHandle);
1606 DLOG_IF(INFO, nfc_debug_enabled)
1607 << StringPrintf("%s: socket Handle = 0x%X", __func__, jniHandle);
nxpandroid64fd68c2015-09-23 16:45:15 +05301608
nxf24591dc0bc2c2018-02-21 17:33:08 +05301609 /* Set socket linear buffer length */
1610 f = e->GetFieldID(clsNativeLlcpServiceSocket.get(),
1611 "mLocalLinearBufferLength", "I");
1612 e->SetIntField(serviceSocket, f, (jint)linearBufferLength);
1613 DLOG_IF(INFO, nfc_debug_enabled)
1614 << StringPrintf("%s: buffer length = %d", __func__, linearBufferLength);
nxpandroid64fd68c2015-09-23 16:45:15 +05301615
nxf24591dc0bc2c2018-02-21 17:33:08 +05301616 /* Set socket MIU */
1617 f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mLocalMiu", "I");
1618 e->SetIntField(serviceSocket, f, (jint)miu);
1619 DLOG_IF(INFO, nfc_debug_enabled)
1620 << StringPrintf("%s: MIU = %d", __func__, miu);
nxpandroid64fd68c2015-09-23 16:45:15 +05301621
nxf24591dc0bc2c2018-02-21 17:33:08 +05301622 /* Set socket RW */
1623 f = e->GetFieldID(clsNativeLlcpServiceSocket.get(), "mLocalRw", "I");
1624 e->SetIntField(serviceSocket, f, (jint)rw);
1625 DLOG_IF(INFO, nfc_debug_enabled)
1626 << StringPrintf("%s: RW = %d", __func__, rw);
nxpandroid64fd68c2015-09-23 16:45:15 +05301627
nxf24591dc0bc2c2018-02-21 17:33:08 +05301628 sLastError = 0;
1629 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", __func__);
1630 return serviceSocket;
nxpandroid64fd68c2015-09-23 16:45:15 +05301631}
1632
nxpandroid64fd68c2015-09-23 16:45:15 +05301633/*******************************************************************************
1634**
1635** Function: nfcManager_doGetLastError
1636**
1637** Description: Get the last error code.
1638** e: JVM environment.
1639** o: Java object.
1640**
1641** Returns: Last error code.
1642**
1643*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301644static jint nfcManager_doGetLastError(JNIEnv*, jobject) {
1645 DLOG_IF(INFO, nfc_debug_enabled)
1646 << StringPrintf("%s: last error=%i", __func__, sLastError);
1647 return sLastError;
nxpandroid64fd68c2015-09-23 16:45:15 +05301648}
1649
nxpandroid64fd68c2015-09-23 16:45:15 +05301650/*******************************************************************************
1651**
1652** Function: nfcManager_doDeinitialize
1653**
1654** Description: Turn off NFC.
1655** e: JVM environment.
1656** o: Java object.
1657**
1658** Returns: True if ok.
1659**
1660*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301661static jboolean nfcManager_doDeinitialize(JNIEnv*, jobject) {
1662 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", __func__);
nxpandroid9acbab22017-07-31 16:09:41 +05301663
nxf24591dc0bc2c2018-02-21 17:33:08 +05301664 sIsDisabling = true;
1665
1666 pn544InteropAbortNow();
1667 RoutingManager::getInstance().onNfccShutdown();
1668 PowerSwitch::getInstance().initialize(PowerSwitch::UNKNOWN_LEVEL);
Sreenivas88ee6aa2018-05-14 13:17:57 +05301669#if (NXP_EXTNS == TRUE)
1670 SecureElement::getInstance().releasePendingTransceive();
1671#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +05301672 if (sIsNfaEnabled) {
1673 SyncEventGuard guard(sNfaDisableEvent);
1674 EXTNS_Close();
1675 tNFA_STATUS stat = NFA_Disable(TRUE /* graceful */);
1676 if (stat == NFA_STATUS_OK) {
1677 DLOG_IF(INFO, nfc_debug_enabled)
1678 << StringPrintf("%s: wait for completion", __func__);
1679 sNfaDisableEvent.wait(); // wait for NFA command to finish
1680 PeerToPeer::getInstance().handleNfcOnOff(false);
1681 } else {
1682 LOG(ERROR) << StringPrintf("%s: fail disable; error=0x%X", __func__,
1683 stat);
1684 }
1685 }
1686 nativeNfcTag_abortWaits();
1687 NfcTag::getInstance().abort();
1688 sAbortConnlessWait = true;
1689 nativeLlcpConnectionlessSocket_abortWait();
1690 sIsNfaEnabled = false;
1691 sDiscoveryEnabled = false;
1692 sPollingEnabled = false;
1693 sIsDisabling = false;
1694 sP2pEnabled = false;
1695 gActivated = false;
1696 sLfT3tMax = 0;
1697
1698 {
1699 // unblock NFA_EnablePolling() and NFA_DisablePolling()
1700 SyncEventGuard guard(sNfaEnableDisablePollingEvent);
1701 sNfaEnableDisablePollingEvent.notifyOne();
1702 }
nxpandroid0f06fde2017-08-14 11:25:28 +05301703#if (NXP_EXTNS == TRUE)
nxf24591dc0bc2c2018-02-21 17:33:08 +05301704 SecureElement::getInstance().finalize ();
nxpandroid7d44e572016-08-01 19:11:04 +05301705#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +05301706 NfcAdaptation& theInstance = NfcAdaptation::GetInstance();
1707 theInstance.Finalize();
nxpandroid64fd68c2015-09-23 16:45:15 +05301708
nxf24591dc0bc2c2018-02-21 17:33:08 +05301709 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", __func__);
1710 return JNI_TRUE;
nxpandroid64fd68c2015-09-23 16:45:15 +05301711}
1712
nxpandroid64fd68c2015-09-23 16:45:15 +05301713/*******************************************************************************
1714**
1715** Function: nfcManager_doCreateLlcpSocket
1716**
1717** Description: Create a LLCP connection-oriented socket.
1718** e: JVM environment.
1719** o: Java object.
1720** nSap: Service access point.
1721** miu: Maximum information unit.
1722** rw: Receive window size.
1723** linearBufferLength: Max buffer size.
1724**
1725** Returns: NativeLlcpSocket Java object.
1726**
1727*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301728static jobject nfcManager_doCreateLlcpSocket(JNIEnv* e, jobject, jint nSap,
1729 jint miu, jint rw,
1730 jint linearBufferLength) {
1731 DLOG_IF(INFO, nfc_debug_enabled)
1732 << StringPrintf("%s: enter; sap=%d; miu=%d; rw=%d; buffer len=%d",
1733 __func__, nSap, miu, rw, linearBufferLength);
nxpandroid64fd68c2015-09-23 16:45:15 +05301734
nxf24591dc0bc2c2018-02-21 17:33:08 +05301735 PeerToPeer::tJNI_HANDLE jniHandle =
1736 PeerToPeer::getInstance().getNewJniHandle();
1737 PeerToPeer::getInstance().createClient(jniHandle, miu, rw);
nxpandroid64fd68c2015-09-23 16:45:15 +05301738
nxf24591dc0bc2c2018-02-21 17:33:08 +05301739 /* Create new NativeLlcpSocket object */
1740 jobject clientSocket = NULL;
1741 if (nfc_jni_cache_object_local(e, gNativeLlcpSocketClassName,
1742 &(clientSocket)) == -1) {
1743 LOG(ERROR) << StringPrintf("%s: fail Llcp socket creation", __func__);
nxpandroid64fd68c2015-09-23 16:45:15 +05301744 return clientSocket;
nxf24591dc0bc2c2018-02-21 17:33:08 +05301745 }
nxpandroid64fd68c2015-09-23 16:45:15 +05301746
nxf24591dc0bc2c2018-02-21 17:33:08 +05301747 /* Get NativeConnectionless class object */
1748 ScopedLocalRef<jclass> clsNativeLlcpSocket(e,
1749 e->GetObjectClass(clientSocket));
1750 if (e->ExceptionCheck()) {
1751 e->ExceptionClear();
1752 LOG(ERROR) << StringPrintf("%s: fail get class object", __func__);
1753 return clientSocket;
1754 }
1755
1756 jfieldID f;
1757
1758 /* Set socket SAP */
1759 f = e->GetFieldID(clsNativeLlcpSocket.get(), "mSap", "I");
1760 e->SetIntField(clientSocket, f, (jint)nSap);
1761
1762 /* Set socket handle */
1763 f = e->GetFieldID(clsNativeLlcpSocket.get(), "mHandle", "I");
1764 e->SetIntField(clientSocket, f, (jint)jniHandle);
1765
1766 /* Set socket MIU */
1767 f = e->GetFieldID(clsNativeLlcpSocket.get(), "mLocalMiu", "I");
1768 e->SetIntField(clientSocket, f, (jint)miu);
1769
1770 /* Set socket RW */
1771 f = e->GetFieldID(clsNativeLlcpSocket.get(), "mLocalRw", "I");
1772 e->SetIntField(clientSocket, f, (jint)rw);
1773
1774 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", __func__);
1775 return clientSocket;
1776}
nxpandroid64fd68c2015-09-23 16:45:15 +05301777
1778/*******************************************************************************
1779**
1780** Function: nfcManager_doCreateLlcpConnectionlessSocket
1781**
1782** Description: Create a connection-less socket.
1783** e: JVM environment.
1784** o: Java object.
1785** nSap: Service access point.
1786** sn: Service name.
1787**
1788** Returns: NativeLlcpConnectionlessSocket Java object.
1789**
1790*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301791static jobject nfcManager_doCreateLlcpConnectionlessSocket(JNIEnv*, jobject,
1792 jint nSap,
1793 jstring /*sn*/) {
1794 DLOG_IF(INFO, nfc_debug_enabled)
1795 << StringPrintf("%s: nSap=0x%X", __func__, nSap);
1796 return NULL;
nxpandroid64fd68c2015-09-23 16:45:15 +05301797}
nxpandroid64fd68c2015-09-23 16:45:15 +05301798/*******************************************************************************
1799**
1800** Function: nfcManager_getDefaultAidRoute
1801**
1802** Description: Get the default Aid Route Entry.
1803** e: JVM environment.
1804** o: Java object.
1805** mode: Not used.
1806**
1807** Returns: None
1808**
1809*******************************************************************************/
1810static jint nfcManager_getDefaultAidRoute (JNIEnv* e, jobject o)
1811{
1812 unsigned long num = 0;
nxpandroid1153eb32015-11-06 18:46:58 +05301813#if(NXP_EXTNS == TRUE)
nxpandroid64fd68c2015-09-23 16:45:15 +05301814 GetNxpNumValue(NAME_DEFAULT_AID_ROUTE, &num, sizeof(num));
1815#endif
1816 return num;
1817}
1818/*******************************************************************************
1819**
1820** Function: nfcManager_getDefaultDesfireRoute
1821**
1822** Description: Get the default Desfire Route Entry.
1823** e: JVM environment.
1824** o: Java object.
1825** mode: Not used.
1826**
1827** Returns: None
1828**
1829*******************************************************************************/
1830static jint nfcManager_getDefaultDesfireRoute (JNIEnv* e, jobject o)
1831{
1832 unsigned long num = 0;
nxpandroid1153eb32015-11-06 18:46:58 +05301833#if(NXP_EXTNS == TRUE)
nxpandroid64fd68c2015-09-23 16:45:15 +05301834 GetNxpNumValue(NAME_DEFAULT_DESFIRE_ROUTE, (void*)&num, sizeof(num));
nxpandroid64fd68c2015-09-23 16:45:15 +05301835#endif
1836 return num;
1837}
1838/*******************************************************************************
1839**
1840** Function: nfcManager_getDefaultMifareCLTRoute
1841**
1842** Description: Get the default mifare CLT Route Entry.
1843** e: JVM environment.
1844** o: Java object.
1845** mode: Not used.
1846**
1847** Returns: None
1848**
1849*******************************************************************************/
1850static jint nfcManager_getDefaultMifareCLTRoute (JNIEnv* e, jobject o)
1851{
1852 unsigned long num = 0;
nxpandroid1153eb32015-11-06 18:46:58 +05301853#if(NXP_EXTNS == TRUE)
nxpandroid64fd68c2015-09-23 16:45:15 +05301854 GetNxpNumValue(NAME_DEFAULT_MIFARE_CLT_ROUTE, &num, sizeof(num));
1855#endif
1856 return num;
1857}
nxf24591dc0bc2c2018-02-21 17:33:08 +05301858
nxpandroid64fd68c2015-09-23 16:45:15 +05301859/*******************************************************************************
1860**
nxpandroida9a68ba2016-01-14 21:12:17 +05301861** Function: nfcManager_getDefaultAidPowerState
1862**
1863** Description: Get the default Desfire Power States.
1864** e: JVM environment.
1865** o: Java object.
1866**
1867** Returns: Power State
1868**
1869*******************************************************************************/
1870static jint nfcManager_getDefaultAidPowerState (JNIEnv* e, jobject o)
1871{
1872 unsigned long num = 0;
nxf24591dc0bc2c2018-02-21 17:33:08 +05301873 #if(NXP_EXTNS == TRUE)
nxpandroida9a68ba2016-01-14 21:12:17 +05301874 GetNxpNumValue(NAME_DEFAULT_AID_PWR_STATE, &num, sizeof(num));
nxf24591dc0bc2c2018-02-21 17:33:08 +05301875 #endif
nxpandroida9a68ba2016-01-14 21:12:17 +05301876 return num;
1877}
1878
1879/*******************************************************************************
1880**
1881** Function: nfcManager_getDefaultDesfirePowerState
1882**
1883** Description: Get the default Desfire Power States.
1884** e: JVM environment.
1885** o: Java object.
1886**
1887** Returns: Power State
1888**
1889*******************************************************************************/
1890static jint nfcManager_getDefaultDesfirePowerState (JNIEnv* e, jobject o)
1891{
1892 unsigned long num = 0;
nxf24591dc0bc2c2018-02-21 17:33:08 +05301893 #if(NXP_EXTNS == TRUE)
nxpandroida9a68ba2016-01-14 21:12:17 +05301894 GetNxpNumValue(NAME_DEFAULT_DESFIRE_PWR_STATE, &num, sizeof(num));
nxf24591dc0bc2c2018-02-21 17:33:08 +05301895 #endif
nxpandroida9a68ba2016-01-14 21:12:17 +05301896 return num;
1897}
1898/*******************************************************************************
1899**
1900** Function: nfcManager_getDefaultMifareCLTPowerState
1901**
1902** Description: Get the default mifare CLT Power States.
1903** e: JVM environment.
1904** o: Java object.
1905**
1906** Returns: Power State
1907**
1908*******************************************************************************/
1909static jint nfcManager_getDefaultMifareCLTPowerState (JNIEnv* e, jobject o)
1910{
1911 unsigned long num = 0;
nxf24591dc0bc2c2018-02-21 17:33:08 +05301912 #if(NXP_EXTNS == TRUE)
nxpandroida9a68ba2016-01-14 21:12:17 +05301913 GetNxpNumValue(NAME_DEFAULT_MIFARE_CLT_PWR_STATE, &num, sizeof(num));
nxf24591dc0bc2c2018-02-21 17:33:08 +05301914 #endif
nxpandroida9a68ba2016-01-14 21:12:17 +05301915 return num;
1916}
1917/*******************************************************************************
1918**
nxpandroid64fd68c2015-09-23 16:45:15 +05301919** Function: isPeerToPeer
1920**
nxf24591dc0bc2c2018-02-21 17:33:08 +05301921** Description: Whether the activation data indicates the peer supports
1922*NFC-DEP.
nxpandroid64fd68c2015-09-23 16:45:15 +05301923** activated: Activation data.
1924**
1925** Returns: True if the peer supports NFC-DEP.
1926**
1927*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301928static bool isPeerToPeer(tNFA_ACTIVATED& activated) {
1929 return activated.activate_ntf.protocol == NFA_PROTOCOL_NFC_DEP;
nxpandroid64fd68c2015-09-23 16:45:15 +05301930}
1931
1932/*******************************************************************************
1933**
1934** Function: isListenMode
1935**
1936** Description: Indicates whether the activation data indicates it is
1937** listen mode.
1938**
1939** Returns: True if this listen mode.
1940**
1941*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301942static bool isListenMode(tNFA_ACTIVATED& activated) {
1943 return ((NFC_DISCOVERY_TYPE_LISTEN_A ==
1944 activated.activate_ntf.rf_tech_param.mode) ||
1945 (NFC_DISCOVERY_TYPE_LISTEN_B ==
1946 activated.activate_ntf.rf_tech_param.mode) ||
1947 (NFC_DISCOVERY_TYPE_LISTEN_F ==
1948 activated.activate_ntf.rf_tech_param.mode) ||
1949 (NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE ==
1950 activated.activate_ntf.rf_tech_param.mode) ||
1951 (NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE ==
1952 activated.activate_ntf.rf_tech_param.mode) ||
1953 (NFC_DISCOVERY_TYPE_LISTEN_ISO15693 ==
1954 activated.activate_ntf.rf_tech_param.mode) ||
1955 (NFC_DISCOVERY_TYPE_LISTEN_B_PRIME ==
1956 activated.activate_ntf.rf_tech_param.mode));
nxpandroid64fd68c2015-09-23 16:45:15 +05301957}
1958
1959/*******************************************************************************
1960**
1961** Function: nfcManager_doCheckLlcp
1962**
1963** Description: Not used.
1964**
1965** Returns: True
1966**
1967*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301968static jboolean nfcManager_doCheckLlcp(JNIEnv*, jobject) {
1969 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", __func__);
1970 return JNI_TRUE;
nxpandroid64fd68c2015-09-23 16:45:15 +05301971}
1972
nxpandroid64fd68c2015-09-23 16:45:15 +05301973/*******************************************************************************
1974**
1975** Function: nfcManager_doActivateLlcp
1976**
1977** Description: Not used.
1978**
1979** Returns: True
1980**
1981*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301982static jboolean nfcManager_doActivateLlcp(JNIEnv*, jobject) {
1983 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", __func__);
1984 return JNI_TRUE;
nxpandroid64fd68c2015-09-23 16:45:15 +05301985}
1986
nxpandroid64fd68c2015-09-23 16:45:15 +05301987/*******************************************************************************
1988**
1989** Function: nfcManager_doAbort
1990**
1991** Description: Not used.
1992**
1993** Returns: None
1994**
1995*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05301996static void nfcManager_doAbort(JNIEnv* e, jobject, jstring msg) {
1997 ScopedUtfChars message = {e, msg};
1998 e->FatalError(message.c_str());
1999 abort(); // <-- Unreachable
nxpandroid64fd68c2015-09-23 16:45:15 +05302000}
2001
nxpandroid64fd68c2015-09-23 16:45:15 +05302002/*******************************************************************************
2003**
2004** Function: nfcManager_doDownload
2005**
2006** Description: Download firmware patch files. Do not turn on NFC.
2007**
2008** Returns: True if ok.
2009**
2010*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302011static jboolean nfcManager_doDownload(JNIEnv*, jobject) {
2012 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", __func__);
2013 NfcAdaptation& theInstance = NfcAdaptation::GetInstance();
nxpandroid64fd68c2015-09-23 16:45:15 +05302014
nxf24591dc0bc2c2018-02-21 17:33:08 +05302015 theInstance.Initialize(); // start GKI, NCI task, NFC task
2016 theInstance.DownloadFirmware();
2017 theInstance.Finalize();
2018 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", __func__);
2019 return JNI_TRUE;
nxpandroid64fd68c2015-09-23 16:45:15 +05302020}
2021
nxpandroid64fd68c2015-09-23 16:45:15 +05302022/*******************************************************************************
2023**
2024** Function: nfcManager_doResetTimeouts
2025**
2026** Description: Not used.
2027**
2028** Returns: None
2029**
2030*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302031static void nfcManager_doResetTimeouts(JNIEnv*, jobject) {
2032 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", __func__);
2033 NfcTag::getInstance().resetAllTransceiveTimeouts();
nxpandroid64fd68c2015-09-23 16:45:15 +05302034}
2035
nxpandroid64fd68c2015-09-23 16:45:15 +05302036/*******************************************************************************
2037**
2038** Function: nfcManager_doSetTimeout
2039**
2040** Description: Set timeout value.
2041** e: JVM environment.
2042** o: Java object.
2043** tech: technology ID.
2044** timeout: Timeout value.
2045**
2046** Returns: True if ok.
2047**
2048*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302049static bool nfcManager_doSetTimeout(JNIEnv*, jobject, jint tech, jint timeout) {
2050 if (timeout <= 0) {
2051 LOG(ERROR) << StringPrintf("%s: Timeout must be positive.", __func__);
2052 return false;
2053 }
2054 DLOG_IF(INFO, nfc_debug_enabled)
2055 << StringPrintf("%s: tech=%d, timeout=%d", __func__, tech, timeout);
2056 NfcTag::getInstance().setTransceiveTimeout(tech, timeout);
2057 return true;
nxpandroid64fd68c2015-09-23 16:45:15 +05302058}
2059
nxpandroid64fd68c2015-09-23 16:45:15 +05302060/*******************************************************************************
2061**
2062** Function: nfcManager_doGetTimeout
2063**
2064** Description: Get timeout value.
2065** e: JVM environment.
2066** o: Java object.
2067** tech: technology ID.
2068**
2069** Returns: Timeout value.
2070**
2071*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302072static jint nfcManager_doGetTimeout(JNIEnv*, jobject, jint tech) {
2073 int timeout = NfcTag::getInstance().getTransceiveTimeout(tech);
2074 DLOG_IF(INFO, nfc_debug_enabled)
2075 << StringPrintf("%s: tech=%d, timeout=%d", __func__, tech, timeout);
2076 return timeout;
nxpandroid64fd68c2015-09-23 16:45:15 +05302077}
2078
nxpandroid64fd68c2015-09-23 16:45:15 +05302079/*******************************************************************************
2080**
2081** Function: nfcManager_doDump
2082**
nxf24591dc0bc2c2018-02-21 17:33:08 +05302083** Description: Get libnfc-nci dump
nxpandroid64fd68c2015-09-23 16:45:15 +05302084** e: JVM environment.
nxf24591dc0bc2c2018-02-21 17:33:08 +05302085** obj: Java object.
2086** fdobj: File descriptor to be used
nxpandroid64fd68c2015-09-23 16:45:15 +05302087**
nxf24591dc0bc2c2018-02-21 17:33:08 +05302088** Returns: Void
nxpandroid64fd68c2015-09-23 16:45:15 +05302089**
2090*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302091static void nfcManager_doDump(JNIEnv* e, jobject obj, jobject fdobj) {
2092 int fd = jniGetFDFromFileDescriptor(e, fdobj);
2093 if (fd < 0) return;
2094
2095 NfcAdaptation& theInstance = NfcAdaptation::GetInstance();
2096 theInstance.Dump(fd);
nxpandroid64fd68c2015-09-23 16:45:15 +05302097}
2098
nxf24591dc0bc2c2018-02-21 17:33:08 +05302099static jint nfcManager_doGetNciVersion(JNIEnv*, jobject) {
2100 return NFC_GetNCIVersion();
2101}
nxpandroid64fd68c2015-09-23 16:45:15 +05302102
nxf24591dc0bc2c2018-02-21 17:33:08 +05302103static void nfcManager_doSetScreenState(JNIEnv* e, jobject o,
2104 jint screen_state_mask) {
2105 tNFA_STATUS status = NFA_STATUS_OK;
2106 uint8_t state = (screen_state_mask & NFA_SCREEN_STATE_MASK);
2107 uint8_t discovry_param =
2108 NCI_LISTEN_DH_NFCEE_ENABLE_MASK | NCI_POLLING_DH_ENABLE_MASK;
2109
2110 DLOG_IF(INFO, nfc_debug_enabled)
2111 << StringPrintf("%s: state = %d discovry_param = %d", __FUNCTION__, state,
2112 discovry_param);
2113
2114 if (sIsDisabling || !sIsNfaEnabled ||
2115 (NFC_GetNCIVersion() != NCI_VERSION_2_0))
2116 return;
2117 if (prevScreenState == NFA_SCREEN_STATE_OFF_LOCKED ||
2118 prevScreenState == NFA_SCREEN_STATE_OFF_UNLOCKED ||
2119 prevScreenState == NFA_SCREEN_STATE_ON_LOCKED) {
2120 SyncEventGuard guard(sNfaSetPowerSubState);
2121 status = NFA_SetPowerSubStateForScreenState(state);
2122 if (status != NFA_STATUS_OK) {
2123 LOG(ERROR) << StringPrintf("%s: fail enable SetScreenState; error=0x%X",
2124 __FUNCTION__, status);
2125 return;
2126 } else {
2127 sNfaSetPowerSubState.wait();
2128 }
2129 }
2130
2131 if (state == NFA_SCREEN_STATE_OFF_LOCKED ||
2132 state == NFA_SCREEN_STATE_OFF_UNLOCKED) {
2133 // disable both poll and listen on DH 0x02
2134 discovry_param =
2135 NCI_POLLING_DH_DISABLE_MASK
2136#if (NXP_EXTNS == TRUE)
2137 | NCI_LISTEN_DH_NFCEE_ENABLE_MASK;
2138#else
2139 | NCI_LISTEN_DH_NFCEE_DISABLE_MASK;
2140#endif
2141 }
2142
2143 if (state == NFA_SCREEN_STATE_ON_LOCKED) {
2144 // disable poll and enable listen on DH 0x00
2145 discovry_param =
2146 (screen_state_mask & NFA_SCREEN_POLLING_TAG_MASK)
2147 ? (NCI_LISTEN_DH_NFCEE_ENABLE_MASK | NCI_POLLING_DH_ENABLE_MASK)
2148 : (NCI_POLLING_DH_DISABLE_MASK | NCI_LISTEN_DH_NFCEE_ENABLE_MASK);
2149 }
2150
2151 if (state == NFA_SCREEN_STATE_ON_UNLOCKED) {
2152 // enable both poll and listen on DH 0x01
2153 discovry_param =
2154 NCI_LISTEN_DH_NFCEE_ENABLE_MASK | NCI_POLLING_DH_ENABLE_MASK;
2155 }
2156
2157 SyncEventGuard guard(sNfaSetConfigEvent);
2158 status = NFA_SetConfig(NCI_PARAM_ID_CON_DISCOVERY_PARAM,
2159 NCI_PARAM_LEN_CON_DISCOVERY_PARAM, &discovry_param);
2160 if (status == NFA_STATUS_OK) {
2161 sNfaSetConfigEvent.wait();
2162 } else {
2163 LOG(ERROR) << StringPrintf("%s: Failed to update CON_DISCOVER_PARAM",
2164 __FUNCTION__);
2165 return;
2166 }
2167
2168 if (prevScreenState == NFA_SCREEN_STATE_ON_UNLOCKED) {
2169 SyncEventGuard guard(sNfaSetPowerSubState);
2170 status = NFA_SetPowerSubStateForScreenState(state);
2171 if (status != NFA_STATUS_OK) {
2172 LOG(ERROR) << StringPrintf("%s: fail enable SetScreenState; error=0x%X",
2173 __FUNCTION__, status);
2174 } else {
2175 sNfaSetPowerSubState.wait();
2176 }
2177 }
2178 prevScreenState = state;
2179}
nxpandroid64fd68c2015-09-23 16:45:15 +05302180/*******************************************************************************
2181**
2182** Function: nfcManager_doSetP2pInitiatorModes
2183**
2184** Description: Set P2P initiator's activation modes.
2185** e: JVM environment.
2186** o: Java object.
nxf24591dc0bc2c2018-02-21 17:33:08 +05302187** modes: Active and/or passive modes. The values are
2188*specified
nxpandroid64fd68c2015-09-23 16:45:15 +05302189** in external/libnfc-nxp/inc/phNfcTypes.h. See
2190** enum phNfc_eP2PMode_t.
2191**
2192** Returns: None.
2193**
2194*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302195static void nfcManager_doSetP2pInitiatorModes(JNIEnv* e, jobject o,
2196 jint modes) {
2197 DLOG_IF(INFO, nfc_debug_enabled)
2198 << StringPrintf("%s: modes=0x%X", __func__, modes);
2199 struct nfc_jni_native_data* nat = getNative(e, o);
nxpandroid64fd68c2015-09-23 16:45:15 +05302200
nxf24591dc0bc2c2018-02-21 17:33:08 +05302201 tNFA_TECHNOLOGY_MASK mask = 0;
2202 if (modes & 0x01) mask |= NFA_TECHNOLOGY_MASK_A;
2203 if (modes & 0x02) mask |= NFA_TECHNOLOGY_MASK_F;
2204 if (modes & 0x04) mask |= NFA_TECHNOLOGY_MASK_F;
2205 if (modes & 0x08) mask |= NFA_TECHNOLOGY_MASK_A_ACTIVE;
2206 if (modes & 0x10) mask |= NFA_TECHNOLOGY_MASK_F_ACTIVE;
2207 if (modes & 0x20) mask |= NFA_TECHNOLOGY_MASK_F_ACTIVE;
2208 nat->tech_mask = mask;
nxpandroid64fd68c2015-09-23 16:45:15 +05302209}
2210
nxpandroid64fd68c2015-09-23 16:45:15 +05302211/*******************************************************************************
2212**
2213** Function: nfcManager_doSetP2pTargetModes
2214**
2215** Description: Set P2P target's activation modes.
2216** e: JVM environment.
2217** o: Java object.
2218** modes: Active and/or passive modes.
2219**
2220** Returns: None.
2221**
2222*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302223static void nfcManager_doSetP2pTargetModes(JNIEnv*, jobject, jint modes) {
2224 DLOG_IF(INFO, nfc_debug_enabled)
2225 << StringPrintf("%s: modes=0x%X", __func__, modes);
2226 // Map in the right modes
2227 tNFA_TECHNOLOGY_MASK mask = 0;
2228 if (modes & 0x01) mask |= NFA_TECHNOLOGY_MASK_A;
2229 if (modes & 0x02) mask |= NFA_TECHNOLOGY_MASK_F;
2230 if (modes & 0x04) mask |= NFA_TECHNOLOGY_MASK_F;
2231 if (modes & 0x08)
2232 mask |= NFA_TECHNOLOGY_MASK_A_ACTIVE | NFA_TECHNOLOGY_MASK_F_ACTIVE;
nxpandroid64fd68c2015-09-23 16:45:15 +05302233
nxf24591dc0bc2c2018-02-21 17:33:08 +05302234 PeerToPeer::getInstance().setP2pListenMask(mask);
nxpandroid64fd68c2015-09-23 16:45:15 +05302235}
2236
nxf24591dc0bc2c2018-02-21 17:33:08 +05302237static void nfcManager_doEnableScreenOffSuspend(JNIEnv* e, jobject o) {
2238 PowerSwitch::getInstance().setScreenOffPowerState(
2239 PowerSwitch::POWER_STATE_FULL);
2240}
2241
2242static void nfcManager_doDisableScreenOffSuspend(JNIEnv* e, jobject o) {
2243 PowerSwitch::getInstance().setScreenOffPowerState(
2244 PowerSwitch::POWER_STATE_OFF);
2245}
2246
nxpandroid64fd68c2015-09-23 16:45:15 +05302247/*******************************************************************************
2248**
nxf24591dc0bc2c2018-02-21 17:33:08 +05302249** Function: nfcManager_getIsoDepMaxTransceiveLength
nxpandroid64fd68c2015-09-23 16:45:15 +05302250**
nxf24591dc0bc2c2018-02-21 17:33:08 +05302251** Description: Get maximum ISO DEP Transceive Length supported by the NFC
2252** chip. Returns default 261 bytes if the property is not set.
nxpandroid64fd68c2015-09-23 16:45:15 +05302253**
nxf24591dc0bc2c2018-02-21 17:33:08 +05302254** Returns: max value.
nxpandroid64fd68c2015-09-23 16:45:15 +05302255**
2256*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302257static jint nfcManager_getIsoDepMaxTransceiveLength(JNIEnv*, jobject) {
2258 /* Check if extended APDU is supported by the chip.
2259 * If not, default value is returned.
2260 * The maximum length of a default IsoDep frame consists of:
2261 * CLA, INS, P1, P2, LC, LE + 255 payload bytes = 261 bytes
2262 */
2263 return NfcConfig::getUnsigned(NAME_ISO_DEP_MAX_TRANSCEIVE, 261);
nxpandroid64fd68c2015-09-23 16:45:15 +05302264}
2265
nxpandroid64fd68c2015-09-23 16:45:15 +05302266/*****************************************************************************
2267**
2268** JNI functions for android-4.0.1_r1
2269**
2270*****************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302271static JNINativeMethod gMethods[] = {
2272 {"doDownload", "()Z", (void*)nfcManager_doDownload},
nxpandroid64fd68c2015-09-23 16:45:15 +05302273
nxf24591dc0bc2c2018-02-21 17:33:08 +05302274 {"initializeNativeStructure", "()Z", (void*)nfcManager_initNativeStruc},
nxpandroid64fd68c2015-09-23 16:45:15 +05302275
nxf24591dc0bc2c2018-02-21 17:33:08 +05302276 {"doInitialize", "()Z", (void*)nfcManager_doInitialize},
nxpandroid64fd68c2015-09-23 16:45:15 +05302277
nxf24591dc0bc2c2018-02-21 17:33:08 +05302278 {"doDeinitialize", "()Z", (void*)nfcManager_doDeinitialize},
nxpandroid64fd68c2015-09-23 16:45:15 +05302279
nxf24591dc0bc2c2018-02-21 17:33:08 +05302280 {"sendRawFrame", "([B)Z", (void*)nfcManager_sendRawFrame},
nxpandroid64fd68c2015-09-23 16:45:15 +05302281
nxf24591dc0bc2c2018-02-21 17:33:08 +05302282 {"routeAid", "([BIII)Z", (void*)nfcManager_routeAid},
nxpandroid64fd68c2015-09-23 16:45:15 +05302283
nxf24591dc0bc2c2018-02-21 17:33:08 +05302284 {"unrouteAid", "([B)Z", (void*)nfcManager_unrouteAid},
nxpandroid64fd68c2015-09-23 16:45:15 +05302285
nxf24591dc0bc2c2018-02-21 17:33:08 +05302286 {"commitRouting", "()Z", (void*)nfcManager_commitRouting},
nxpandroid64fd68c2015-09-23 16:45:15 +05302287
nxf24591dc0bc2c2018-02-21 17:33:08 +05302288 {"doRegisterT3tIdentifier", "([B)I",
2289 (void*)nfcManager_doRegisterT3tIdentifier},
nxpandroid64fd68c2015-09-23 16:45:15 +05302290
nxf24591dc0bc2c2018-02-21 17:33:08 +05302291 {"doDeregisterT3tIdentifier", "(I)V",
2292 (void*)nfcManager_doDeregisterT3tIdentifier},
nxpandroid64fd68c2015-09-23 16:45:15 +05302293
nxf24591dc0bc2c2018-02-21 17:33:08 +05302294 {"getLfT3tMax", "()I", (void*)nfcManager_getLfT3tMax},
nxpandroid64fd68c2015-09-23 16:45:15 +05302295
nxf24591dc0bc2c2018-02-21 17:33:08 +05302296 {"doEnableDiscovery", "(IZZZZZ)V", (void*)nfcManager_enableDiscovery},
nxpandroid64fd68c2015-09-23 16:45:15 +05302297
nxf24591dc0bc2c2018-02-21 17:33:08 +05302298 {"doCheckLlcp", "()Z", (void*)nfcManager_doCheckLlcp},
2299
2300 {"doActivateLlcp", "()Z", (void*)nfcManager_doActivateLlcp},
2301
2302 {"doCreateLlcpConnectionlessSocket",
2303 "(ILjava/lang/String;)Lcom/android/nfc/dhimpl/"
2304 "NativeLlcpConnectionlessSocket;",
2305 (void*)nfcManager_doCreateLlcpConnectionlessSocket},
2306
2307 {"doCreateLlcpServiceSocket",
2308 "(ILjava/lang/String;III)Lcom/android/nfc/dhimpl/NativeLlcpServiceSocket;",
2309 (void*)nfcManager_doCreateLlcpServiceSocket},
2310
2311 {"doCreateLlcpSocket", "(IIII)Lcom/android/nfc/dhimpl/NativeLlcpSocket;",
2312 (void*)nfcManager_doCreateLlcpSocket},
2313
2314 {"doGetLastError", "()I", (void*)nfcManager_doGetLastError},
2315
2316 {"disableDiscovery", "()V", (void*)nfcManager_disableDiscovery},
2317
2318 {"doSetTimeout", "(II)Z", (void*)nfcManager_doSetTimeout},
2319
2320 {"doGetTimeout", "(I)I", (void*)nfcManager_doGetTimeout},
2321
2322 {"doResetTimeouts", "()V", (void*)nfcManager_doResetTimeouts},
2323
2324 {"doAbort", "(Ljava/lang/String;)V", (void*)nfcManager_doAbort},
2325
2326 {"doSetP2pInitiatorModes", "(I)V",
2327 (void*)nfcManager_doSetP2pInitiatorModes},
2328
2329 {"doSetP2pTargetModes", "(I)V", (void*)nfcManager_doSetP2pTargetModes},
2330
2331 {"doEnableScreenOffSuspend", "()V",
2332 (void*)nfcManager_doEnableScreenOffSuspend},
2333
2334 {"doSetScreenState", "(I)V", (void*)nfcManager_doSetScreenState},
2335
2336 {"doDisableScreenOffSuspend", "()V",
2337 (void*)nfcManager_doDisableScreenOffSuspend},
2338
2339 {"doDump", "(Ljava/io/FileDescriptor;)V", (void*)nfcManager_doDump},
2340
2341 {"getNciVersion", "()I", (void*)nfcManager_doGetNciVersion},
2342 {"doEnableDtaMode", "()V", (void*)nfcManager_doEnableDtaMode},
2343 {"doDisableDtaMode", "()V", (void*)nfcManager_doDisableDtaMode},
2344 {"doFactoryReset", "()V", (void*)nfcManager_doFactoryReset},
2345 {"doShutdown", "()V", (void*)nfcManager_doShutdown},
2346
2347 {"getIsoDepMaxTransceiveLength", "()I",
2348 (void*)nfcManager_getIsoDepMaxTransceiveLength},
nxpandroid64fd68c2015-09-23 16:45:15 +05302349
2350 {"getDefaultAidRoute", "()I",
2351 (void*) nfcManager_getDefaultAidRoute},
2352
2353 {"getDefaultDesfireRoute", "()I",
2354 (void*) nfcManager_getDefaultDesfireRoute},
2355
2356 {"getDefaultMifareCLTRoute", "()I",
2357 (void*) nfcManager_getDefaultMifareCLTRoute},
nxf24591dc0bc2c2018-02-21 17:33:08 +05302358
nxpandroida9a68ba2016-01-14 21:12:17 +05302359 {"getDefaultAidPowerState", "()I",
2360 (void*) nfcManager_getDefaultAidPowerState},
2361
2362 {"getDefaultDesfirePowerState", "()I",
2363 (void*) nfcManager_getDefaultDesfirePowerState},
2364
2365 {"getDefaultMifareCLTPowerState", "()I",
2366 (void*) nfcManager_getDefaultMifareCLTPowerState},
nxf24591dc0bc2c2018-02-21 17:33:08 +05302367 {"setDefaultRoute", "(III)Z",
2368 (void*) nfcManager_setDefaultRoute}
nxpandroida9a68ba2016-01-14 21:12:17 +05302369#if(NXP_EXTNS == TRUE)
nxf24591dc0bc2c2018-02-21 17:33:08 +05302370 ,{"doCheckJcopDlAtBoot", "()Z",
nxpandroid64fd68c2015-09-23 16:45:15 +05302371 (void *)nfcManager_doCheckJcopDlAtBoot},
nxf24591dc0bc2c2018-02-21 17:33:08 +05302372 {"JCOSDownload", "()I",
2373 (void *)nfcManager_doJcosDownload},
Ayush73d68912018-04-04 21:36:26 +05302374 {"doGetActiveSecureElementList", "()[I",
2375 (void *)nfcManager_getActiveSecureElementList},
nxpandroid34627bd2016-05-27 15:52:30 +05302376#endif
nxf24591dc0bc2c2018-02-21 17:33:08 +05302377};
nxpandroid64fd68c2015-09-23 16:45:15 +05302378
2379/*******************************************************************************
2380**
2381** Function: register_com_android_nfc_NativeNfcManager
2382**
2383** Description: Regisgter JNI functions with Java Virtual Machine.
2384** e: Environment of JVM.
2385**
2386** Returns: Status of registration.
2387**
2388*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302389int register_com_android_nfc_NativeNfcManager(JNIEnv* e) {
2390 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", __func__);
2391 PowerSwitch::getInstance().initialize(PowerSwitch::UNKNOWN_LEVEL);
2392 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", __func__);
2393 return jniRegisterNativeMethods(e, gNativeNfcManagerClassName, gMethods,
2394 NELEM(gMethods));
nxpandroid64fd68c2015-09-23 16:45:15 +05302395}
2396
nxpandroid64fd68c2015-09-23 16:45:15 +05302397/*******************************************************************************
2398**
2399** Function: startRfDiscovery
2400**
2401** Description: Ask stack to start polling and listening for devices.
2402** isStart: Whether to start.
2403**
2404** Returns: None
2405**
2406*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302407void startRfDiscovery(bool isStart) {
2408 tNFA_STATUS status = NFA_STATUS_FAILED;
2409
2410 DLOG_IF(INFO, nfc_debug_enabled)
2411 << StringPrintf("%s: is start=%d", __func__, isStart);
2412 nativeNfcTag_acquireRfInterfaceMutexLock();
2413 SyncEventGuard guard(sNfaEnableDisablePollingEvent);
2414 status = isStart ? NFA_StartRfDiscovery() : NFA_StopRfDiscovery();
2415 if (status == NFA_STATUS_OK) {
nxpandroidecca0112018-06-06 14:41:40 +05302416 sNfaEnableDisablePollingEvent.wait (); //wait for NFA_RF_DISCOVERY_xxxx_EVT
nxf24591dc0bc2c2018-02-21 17:33:08 +05302417 sRfEnabled = isStart;
2418 } else {
2419 LOG(ERROR) << StringPrintf(
2420 "%s: Failed to start/stop RF discovery; error=0x%X", __func__, status);
2421 }
2422 nativeNfcTag_releaseRfInterfaceMutexLock();
nxpandroid64fd68c2015-09-23 16:45:15 +05302423}
2424
2425/*******************************************************************************
nxf24591dc0bc2c2018-02-21 17:33:08 +05302426**
nxpandroid34627bd2016-05-27 15:52:30 +05302427** Function: isDiscoveryStarted
2428**
2429** Description: Indicates whether the discovery is started.
2430**
2431** Returns: True if discovery is started
2432**
2433*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302434bool isDiscoveryStarted() { return sRfEnabled; }
nxpandroid64fd68c2015-09-23 16:45:15 +05302435
2436/*******************************************************************************
2437**
2438** Function: doStartupConfig
2439**
2440** Description: Configure the NFC controller.
2441**
2442** Returns: None
2443**
2444*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302445void doStartupConfig() {
2446 struct nfc_jni_native_data* nat = getNative(0, 0);
2447 tNFA_STATUS stat = NFA_STATUS_FAILED;
nxpandroid64fd68c2015-09-23 16:45:15 +05302448
nxf24591dc0bc2c2018-02-21 17:33:08 +05302449 // If polling for Active mode, set the ordering so that we choose Active over
2450 // Passive mode first.
2451 if (nat && (nat->tech_mask &
2452 (NFA_TECHNOLOGY_MASK_A_ACTIVE | NFA_TECHNOLOGY_MASK_F_ACTIVE))) {
2453 uint8_t act_mode_order_param[] = {0x01};
2454 SyncEventGuard guard(sNfaSetConfigEvent);
2455 stat = NFA_SetConfig(NCI_PARAM_ID_ACT_ORDER, sizeof(act_mode_order_param),
2456 &act_mode_order_param[0]);
2457 if (stat == NFA_STATUS_OK) sNfaSetConfigEvent.wait();
2458 }
nxpandroid64fd68c2015-09-23 16:45:15 +05302459
nxf24591dc0bc2c2018-02-21 17:33:08 +05302460 // configure RF polling frequency for each technology
2461 static tNFA_DM_DISC_FREQ_CFG nfa_dm_disc_freq_cfg;
2462 // values in the polling_frequency[] map to members of nfa_dm_disc_freq_cfg
2463 std::vector<uint8_t> polling_frequency;
2464 if (NfcConfig::hasKey(NAME_POLL_FREQUENCY))
2465 polling_frequency = NfcConfig::getBytes(NAME_POLL_FREQUENCY);
2466 if (polling_frequency.size() == 8) {
2467 DLOG_IF(INFO, nfc_debug_enabled)
2468 << StringPrintf("%s: polling frequency", __func__);
2469 memset(&nfa_dm_disc_freq_cfg, 0, sizeof(nfa_dm_disc_freq_cfg));
2470 nfa_dm_disc_freq_cfg.pa = polling_frequency[0];
2471 nfa_dm_disc_freq_cfg.pb = polling_frequency[1];
2472 nfa_dm_disc_freq_cfg.pf = polling_frequency[2];
2473 nfa_dm_disc_freq_cfg.pi93 = polling_frequency[3];
2474 nfa_dm_disc_freq_cfg.pbp = polling_frequency[4];
2475 nfa_dm_disc_freq_cfg.pk = polling_frequency[5];
2476 nfa_dm_disc_freq_cfg.paa = polling_frequency[6];
2477 nfa_dm_disc_freq_cfg.pfa = polling_frequency[7];
2478 p_nfa_dm_rf_disc_freq_cfg = &nfa_dm_disc_freq_cfg;
2479 }
nxpandroid64fd68c2015-09-23 16:45:15 +05302480}
2481
nxpandroid64fd68c2015-09-23 16:45:15 +05302482/*******************************************************************************
2483**
2484** Function: nfcManager_isNfcActive
2485**
2486** Description: Used externaly to determine if NFC is active or not.
2487**
2488** Returns: 'true' if the NFC stack is running, else 'false'.
2489**
2490*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302491bool nfcManager_isNfcActive() { return sIsNfaEnabled; }
nxpandroid9acbab22017-07-31 16:09:41 +05302492
nxpandroid64fd68c2015-09-23 16:45:15 +05302493/*******************************************************************************
2494**
2495** Function: startStopPolling
2496**
2497** Description: Start or stop polling.
nxf24591dc0bc2c2018-02-21 17:33:08 +05302498** isStartPolling: true to start polling; false to stop
2499*polling.
nxpandroid64fd68c2015-09-23 16:45:15 +05302500**
2501** Returns: None.
2502**
2503*******************************************************************************/
nxf24591dc0bc2c2018-02-21 17:33:08 +05302504void startStopPolling(bool isStartPolling) {
2505 DLOG_IF(INFO, nfc_debug_enabled)
2506 << StringPrintf("%s: enter; isStart=%u", __func__, isStartPolling);
2507 startRfDiscovery(false);
nxpandroid64fd68c2015-09-23 16:45:15 +05302508
nxf24591dc0bc2c2018-02-21 17:33:08 +05302509 if (isStartPolling)
2510 startPolling_rfDiscoveryDisabled(0);
2511 else
2512 stopPolling_rfDiscoveryDisabled();
nxpandroid64fd68c2015-09-23 16:45:15 +05302513
nxf24591dc0bc2c2018-02-21 17:33:08 +05302514 startRfDiscovery(true);
2515 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", __func__);
nxpandroid64fd68c2015-09-23 16:45:15 +05302516}
2517
nxf24591dc0bc2c2018-02-21 17:33:08 +05302518static tNFA_STATUS startPolling_rfDiscoveryDisabled(
2519 tNFA_TECHNOLOGY_MASK tech_mask) {
2520 tNFA_STATUS stat = NFA_STATUS_FAILED;
nxpandroid64fd68c2015-09-23 16:45:15 +05302521
nxf24591dc0bc2c2018-02-21 17:33:08 +05302522 if (tech_mask == 0)
2523 tech_mask =
2524 NfcConfig::getUnsigned(NAME_POLLING_TECH_MASK, DEFAULT_TECH_MASK);
nxpandroid64fd68c2015-09-23 16:45:15 +05302525
nxf24591dc0bc2c2018-02-21 17:33:08 +05302526 nativeNfcTag_acquireRfInterfaceMutexLock();
2527 SyncEventGuard guard(sNfaEnableDisablePollingEvent);
2528 DLOG_IF(INFO, nfc_debug_enabled)
2529 << StringPrintf("%s: enable polling", __func__);
2530 stat = NFA_EnablePolling(tech_mask);
2531 if (stat == NFA_STATUS_OK) {
2532 DLOG_IF(INFO, nfc_debug_enabled)
2533 << StringPrintf("%s: wait for enable event", __func__);
2534 sPollingEnabled = true;
2535 sNfaEnableDisablePollingEvent.wait(); // wait for NFA_POLL_ENABLED_EVT
2536 } else {
2537 LOG(ERROR) << StringPrintf("%s: fail enable polling; error=0x%X", __func__,
2538 stat);
2539 }
2540 nativeNfcTag_releaseRfInterfaceMutexLock();
nxpandroid64fd68c2015-09-23 16:45:15 +05302541
nxf24591dc0bc2c2018-02-21 17:33:08 +05302542 return stat;
nxpandroid64fd68c2015-09-23 16:45:15 +05302543}
2544
2545static tNFA_STATUS stopPolling_rfDiscoveryDisabled() {
nxf24591dc0bc2c2018-02-21 17:33:08 +05302546 tNFA_STATUS stat = NFA_STATUS_FAILED;
nxpandroid64fd68c2015-09-23 16:45:15 +05302547
nxf24591dc0bc2c2018-02-21 17:33:08 +05302548 nativeNfcTag_acquireRfInterfaceMutexLock();
2549 SyncEventGuard guard(sNfaEnableDisablePollingEvent);
2550 DLOG_IF(INFO, nfc_debug_enabled)
2551 << StringPrintf("%s: disable polling", __func__);
2552 stat = NFA_DisablePolling();
2553 if (stat == NFA_STATUS_OK) {
2554 sPollingEnabled = false;
2555 sNfaEnableDisablePollingEvent.wait(); // wait for NFA_POLL_DISABLED_EVT
2556 } else {
2557 LOG(ERROR) << StringPrintf("%s: fail disable polling; error=0x%X", __func__,
2558 stat);
2559 }
2560 nativeNfcTag_releaseRfInterfaceMutexLock();
nxpandroid64fd68c2015-09-23 16:45:15 +05302561
nxf24591dc0bc2c2018-02-21 17:33:08 +05302562 return stat;
nxpandroid64fd68c2015-09-23 16:45:15 +05302563}
2564
nxf24591dc0bc2c2018-02-21 17:33:08 +05302565#if(NXP_EXTNS == TRUE)
2566static jboolean nfcManager_doCheckJcopDlAtBoot(JNIEnv* e, jobject o) {
2567 unsigned int num = 0;
2568 DLOG_IF(INFO, nfc_debug_enabled)
2569 << StringPrintf("%s", __func__);
2570 if(GetNxpNumValue(NAME_NXP_JCOPDL_AT_BOOT_ENABLE,(void*)&num,sizeof(num))) {
2571 if(num == 0x01) {
2572 return JNI_TRUE;
2573 }
2574 else {
2575 return JNI_FALSE;
2576 }
2577 }
2578 else {
2579 return JNI_FALSE;
2580 }
2581}
nxpandroid64fd68c2015-09-23 16:45:15 +05302582/*******************************************************************************
nxf24591dc0bc2c2018-02-21 17:33:08 +05302583 **
2584 ** Function: nfcManager_checkNfcStateBusy()
2585 **
2586 ** Description This function returns whether NFC process is busy or not.
2587 **
2588 ** Returns if Nfc state busy return true otherwise false.
2589 **
2590 *******************************************************************************/
2591bool nfcManager_checkNfcStateBusy()
nxpandroid64fd68c2015-09-23 16:45:15 +05302592{
nxf24591dc0bc2c2018-02-21 17:33:08 +05302593 bool status = false;
nxpandroid64fd68c2015-09-23 16:45:15 +05302594
nxf24591dc0bc2c2018-02-21 17:33:08 +05302595 if(NFA_checkNfcStateBusy() == true)
2596 status = true;
2597
2598 return status;
nxpandroid64fd68c2015-09-23 16:45:15 +05302599}
nxpandroid64fd68c2015-09-23 16:45:15 +05302600/*******************************************************************************
2601**
2602** Function: DWPChannel_init
2603**
2604** Description: Initializes the DWP channel functions.
2605**
2606** Returns: True if ok.
2607**
2608*******************************************************************************/
nxpandroid64fd68c2015-09-23 16:45:15 +05302609void DWPChannel_init(IChannel_t *DWP)
2610{
nxf24591dc0bc2c2018-02-21 17:33:08 +05302611 LOG(INFO) << StringPrintf("%s: enter", __func__);
nxpandroid0f06fde2017-08-14 11:25:28 +05302612 if(nfcFL.nfcNxpEse) {
2613 DWP->open = open;
2614 DWP->close = close;
2615 DWP->transceive = transceive;
2616 DWP->doeSE_Reset = doeSE_Reset;
2617 DWP->doeSE_JcopDownLoadReset = doeSE_JcopDownLoadReset;
2618 }
nxpandroid64fd68c2015-09-23 16:45:15 +05302619}
nxpandroid64fd68c2015-09-23 16:45:15 +05302620/*******************************************************************************
2621**
2622** Function: nfcManager_doJcosDownload
2623**
2624** Description: start jcos download.
2625** e: JVM environment.
2626** o: Java object.
2627**
2628** Returns: True if ok.
2629**
2630*******************************************************************************/
2631static int nfcManager_doJcosDownload(JNIEnv* e, jobject o)
2632{
2633 (void)e;
2634 (void)o;
nxpandroid5d64ce92016-11-18 19:48:53 +05302635 tNFA_STATUS status = NFA_STATUS_FAILED;
nxf24591dc0bc2c2018-02-21 17:33:08 +05302636 if(nfcFL.nfcNxpEse)
2637 {
2638 LOG(INFO) << StringPrintf("%s: enter", __func__);
nxpandroid0f06fde2017-08-14 11:25:28 +05302639 bool stat = false;
nxf24591dc0bc2c2018-02-21 17:33:08 +05302640 if (sIsDisabling || !sIsNfaEnabled || nfcManager_checkNfcStateBusy())
2641 {
2642 LOG(INFO) << StringPrintf("%s: STATUS FAILED", __func__);
2643 return NFA_STATUS_FAILED;
nxpandroid36fa15e2017-09-14 12:34:11 +05302644 }
nxf24591dc0bc2c2018-02-21 17:33:08 +05302645 if (sRfEnabled) {
2646 /*Stop RF Discovery if we were polling*/
2647 startRfDiscovery (false);
Manjunatha Venkatesh2af0fa32017-10-31 18:25:18 +05302648 }
nxf24591dc0bc2c2018-02-21 17:33:08 +05302649 DWPChannel_init(&Dwp);
2650 status = JCDNLD_Init(&Dwp);
2651 if(status != NFA_STATUS_OK)
2652 {
2653 LOG(ERROR) << StringPrintf("%s: JCDND initialization failed", __func__);
2654 }
2655 else
2656 {
2657 LOG(INFO) << StringPrintf("%s: start JcopOs_Download", __func__);
2658 status = JCDNLD_StartDownload();
2659 if(status != NFA_STATUS_OK)
2660 {
2661 DLOG_IF(INFO, nfc_debug_enabled)<< StringPrintf(
2662 "%s:JCDNLD_StartDownload failed =0x%X", __func__,status);
2663 }
2664 stat = JCDNLD_DeInit();
2665 if(stat != TRUE)
2666 {
2667 DLOG_IF(INFO, nfc_debug_enabled)<< StringPrintf(
2668 "%s: exit; JCDNLD_DeInit failed =0x%X", __func__,stat);
2669 }
2670 }
nxpandroid0f06fde2017-08-14 11:25:28 +05302671 startRfDiscovery (true);
nxpandroid64fd68c2015-09-23 16:45:15 +05302672 }
nxf24591dc0bc2c2018-02-21 17:33:08 +05302673 return status;
nxpandroid1680a6d2017-01-13 19:13:14 +05302674}
nxpandroidecca0112018-06-06 14:41:40 +05302675
2676void enableLastRfDiscovery()
2677{
2678 DLOG_IF(INFO, nfc_debug_enabled)
2679 << StringPrintf("%s: enter", __FUNCTION__);
2680 nfcManager_enableDiscovery(NULL, NULL,
2681 mDiscParams.technologies_mask,
2682 mDiscParams.enable_lptd,
2683 mDiscParams.reader_mode,
2684 mDiscParams.enable_host_routing,
2685 mDiscParams.enable_p2p,
2686 true);
2687}
2688
2689void storeLastDiscoveryParams(int technologies_mask, bool enable_lptd,
2690 bool reader_mode, bool enable_host_routing ,bool enable_p2p, bool restart)
2691{
2692 DLOG_IF(INFO, nfc_debug_enabled)
2693 << StringPrintf("%s: enter", __FUNCTION__);
2694 mDiscParams.technologies_mask = technologies_mask;
2695 mDiscParams.enable_lptd = enable_lptd;
2696 mDiscParams.reader_mode = reader_mode;
2697 mDiscParams.enable_p2p = enable_p2p;
2698 mDiscParams.enable_host_routing = enable_host_routing;
2699 mDiscParams.restart = restart;
2700}
nxpandroid1680a6d2017-01-13 19:13:14 +05302701#endif
2702
nxf24591dc0bc2c2018-02-21 17:33:08 +05302703} /* namespace android */