1 /******************************************************************************
2 *
3 * Copyright (C) 1999-2012 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18 #include <android-base/stringprintf.h>
19 #include <android/hardware/nfc/1.1/INfc.h>
20 #include <android/hardware/nfc/1.2/INfc.h>
21 #include <base/command_line.h>
22 #include <base/logging.h>
23 #include <cutils/properties.h>
24 #include <hwbinder/ProcessState.h>
25
26 #include "NfcAdaptation.h"
27 #include "debug_nfcsnoop.h"
28 #include "nfa_api.h"
29 #include "nfa_rw_api.h"
30 #include "nfc_config.h"
31 #include "nfc_int.h"
32
33 using android::OK;
34 using android::sp;
35 using android::status_t;
36
37 using android::base::StringPrintf;
38 using android::hardware::ProcessState;
39 using android::hardware::Return;
40 using android::hardware::Void;
41 using android::hardware::nfc::V1_0::INfc;
42 using android::hardware::nfc::V1_1::PresenceCheckAlgorithm;
43 using INfcV1_1 = android::hardware::nfc::V1_1::INfc;
44 using INfcV1_2 = android::hardware::nfc::V1_2::INfc;
45 using NfcVendorConfigV1_1 = android::hardware::nfc::V1_1::NfcConfig;
46 using NfcVendorConfigV1_2 = android::hardware::nfc::V1_2::NfcConfig;
47 using android::hardware::nfc::V1_1::INfcClientCallback;
48 using android::hardware::hidl_vec;
49
50 extern bool nfc_debug_enabled;
51
52 extern void GKI_shutdown();
53 extern void verify_stack_non_volatile_store();
54 extern void delete_stack_non_volatile_store(bool forceDelete);
55
56 NfcAdaptation* NfcAdaptation::mpInstance = nullptr;
57 ThreadMutex NfcAdaptation::sLock;
58 tHAL_NFC_CBACK* NfcAdaptation::mHalCallback = nullptr;
59 tHAL_NFC_DATA_CBACK* NfcAdaptation::mHalDataCallback = nullptr;
60 ThreadCondVar NfcAdaptation::mHalOpenCompletedEvent;
61 ThreadCondVar NfcAdaptation::mHalCloseCompletedEvent;
62 sp<INfc> NfcAdaptation::mHal;
63 sp<INfcV1_1> NfcAdaptation::mHal_1_1;
64 sp<INfcV1_2> NfcAdaptation::mHal_1_2;
65 INfcClientCallback* NfcAdaptation::mCallback;
66
67 bool nfc_debug_enabled = false;
68 std::string nfc_storage_path;
69 uint8_t appl_dta_mode_flag = 0x00;
70 bool isDownloadFirmwareCompleted = false;
71
72 extern tNFA_DM_CFG nfa_dm_cfg;
73 extern tNFA_PROPRIETARY_CFG nfa_proprietary_cfg;
74 extern tNFA_HCI_CFG nfa_hci_cfg;
75 extern uint8_t nfa_ee_max_ee_cfg;
76 extern bool nfa_poll_bail_out_mode;
77
78 // Whitelist for hosts allowed to create a pipe
79 // See ADM_CREATE_PIPE command in the ETSI test specification
80 // ETSI TS 102 622, section 6.1.3.1
81 static std::vector<uint8_t> host_whitelist;
82
83 namespace {
initializeGlobalDebugEnabledFlag()84 void initializeGlobalDebugEnabledFlag() {
85 nfc_debug_enabled =
86 (NfcConfig::getUnsigned(NAME_NFC_DEBUG_ENABLED, 0) != 0) ? true : false;
87
88 char valueStr[PROPERTY_VALUE_MAX] = {0};
89 int len = property_get("nfc.debug_enabled", valueStr, "");
90 if (len > 0) {
91 // let Android property override .conf variable
92 unsigned debug_enabled = 0;
93 sscanf(valueStr, "%u", &debug_enabled);
94 nfc_debug_enabled = (debug_enabled == 0) ? false : true;
95 }
96
97 DLOG_IF(INFO, nfc_debug_enabled)
98 << StringPrintf("%s: level=%u", __func__, nfc_debug_enabled);
99 }
100 } // namespace
101
102 class NfcClientCallback : public INfcClientCallback {
103 public:
NfcClientCallback(tHAL_NFC_CBACK * eventCallback,tHAL_NFC_DATA_CBACK dataCallback)104 NfcClientCallback(tHAL_NFC_CBACK* eventCallback,
105 tHAL_NFC_DATA_CBACK dataCallback) {
106 mEventCallback = eventCallback;
107 mDataCallback = dataCallback;
108 };
109 virtual ~NfcClientCallback() = default;
sendEvent_1_1(::android::hardware::nfc::V1_1::NfcEvent event,::android::hardware::nfc::V1_0::NfcStatus event_status)110 Return<void> sendEvent_1_1(
111 ::android::hardware::nfc::V1_1::NfcEvent event,
112 ::android::hardware::nfc::V1_0::NfcStatus event_status) override {
113 mEventCallback((uint8_t)event, (tHAL_NFC_STATUS)event_status);
114 return Void();
115 };
sendEvent(::android::hardware::nfc::V1_0::NfcEvent event,::android::hardware::nfc::V1_0::NfcStatus event_status)116 Return<void> sendEvent(
117 ::android::hardware::nfc::V1_0::NfcEvent event,
118 ::android::hardware::nfc::V1_0::NfcStatus event_status) override {
119 mEventCallback((uint8_t)event, (tHAL_NFC_STATUS)event_status);
120 return Void();
121 };
sendData(const::android::hardware::nfc::V1_0::NfcData & data)122 Return<void> sendData(
123 const ::android::hardware::nfc::V1_0::NfcData& data) override {
124 ::android::hardware::nfc::V1_0::NfcData copy = data;
125 mDataCallback(copy.size(), ©[0]);
126 return Void();
127 };
128
129 private:
130 tHAL_NFC_CBACK* mEventCallback;
131 tHAL_NFC_DATA_CBACK* mDataCallback;
132 };
133
134 /*******************************************************************************
135 **
136 ** Function: NfcAdaptation::NfcAdaptation()
137 **
138 ** Description: class constructor
139 **
140 ** Returns: none
141 **
142 *******************************************************************************/
NfcAdaptation()143 NfcAdaptation::NfcAdaptation() {
144 memset(&mHalEntryFuncs, 0, sizeof(mHalEntryFuncs));
145 }
146
147 /*******************************************************************************
148 **
149 ** Function: NfcAdaptation::~NfcAdaptation()
150 **
151 ** Description: class destructor
152 **
153 ** Returns: none
154 **
155 *******************************************************************************/
~NfcAdaptation()156 NfcAdaptation::~NfcAdaptation() { mpInstance = nullptr; }
157
158 /*******************************************************************************
159 **
160 ** Function: NfcAdaptation::GetInstance()
161 **
162 ** Description: access class singleton
163 **
164 ** Returns: pointer to the singleton object
165 **
166 *******************************************************************************/
GetInstance()167 NfcAdaptation& NfcAdaptation::GetInstance() {
168 AutoThreadMutex a(sLock);
169
170 if (!mpInstance) {
171 mpInstance = new NfcAdaptation;
172 mpInstance->InitializeHalDeviceContext();
173 }
174 return *mpInstance;
175 }
176
GetVendorConfigs(std::map<std::string,ConfigValue> & configMap)177 void NfcAdaptation::GetVendorConfigs(
178 std::map<std::string, ConfigValue>& configMap) {
179 NfcVendorConfigV1_2 configValue;
180 if (mHal_1_2) {
181 mHal_1_2->getConfig_1_2(
182 [&configValue](NfcVendorConfigV1_2 config) { configValue = config; });
183 } else if (mHal_1_1) {
184 mHal_1_1->getConfig([&configValue](NfcVendorConfigV1_1 config) {
185 configValue.v1_1 = config;
186 configValue.defaultIsoDepRoute = 0x00;
187 });
188 }
189
190 if (mHal_1_1 || mHal_1_2) {
191 std::vector<uint8_t> nfaPropCfg = {
192 configValue.v1_1.nfaProprietaryCfg.protocol18092Active,
193 configValue.v1_1.nfaProprietaryCfg.protocolBPrime,
194 configValue.v1_1.nfaProprietaryCfg.protocolDual,
195 configValue.v1_1.nfaProprietaryCfg.protocol15693,
196 configValue.v1_1.nfaProprietaryCfg.protocolKovio,
197 configValue.v1_1.nfaProprietaryCfg.protocolMifare,
198 configValue.v1_1.nfaProprietaryCfg.discoveryPollKovio,
199 configValue.v1_1.nfaProprietaryCfg.discoveryPollBPrime,
200 configValue.v1_1.nfaProprietaryCfg.discoveryListenBPrime};
201 configMap.emplace(NAME_NFA_PROPRIETARY_CFG, ConfigValue(nfaPropCfg));
202 configMap.emplace(NAME_NFA_POLL_BAIL_OUT_MODE,
203 ConfigValue(configValue.v1_1.nfaPollBailOutMode ? 1 : 0));
204 configMap.emplace(NAME_DEFAULT_OFFHOST_ROUTE,
205 ConfigValue(configValue.v1_1.defaultOffHostRoute));
206 if (configValue.offHostRouteUicc.size() != 0) {
207 configMap.emplace(NAME_OFFHOST_ROUTE_UICC,
208 ConfigValue(configValue.offHostRouteUicc));
209 }
210 if (configValue.offHostRouteEse.size() != 0) {
211 configMap.emplace(NAME_OFFHOST_ROUTE_ESE,
212 ConfigValue(configValue.offHostRouteEse));
213 }
214 configMap.emplace(NAME_DEFAULT_ROUTE,
215 ConfigValue(configValue.v1_1.defaultRoute));
216 configMap.emplace(NAME_DEFAULT_NFCF_ROUTE,
217 ConfigValue(configValue.v1_1.defaultOffHostRouteFelica));
218 configMap.emplace(NAME_DEFAULT_ISODEP_ROUTE,
219 ConfigValue(configValue.defaultIsoDepRoute));
220 configMap.emplace(NAME_DEFAULT_SYS_CODE_ROUTE,
221 ConfigValue(configValue.v1_1.defaultSystemCodeRoute));
222 configMap.emplace(
223 NAME_DEFAULT_SYS_CODE_PWR_STATE,
224 ConfigValue(configValue.v1_1.defaultSystemCodePowerState));
225 configMap.emplace(NAME_OFF_HOST_SIM_PIPE_ID,
226 ConfigValue(configValue.v1_1.offHostSIMPipeId));
227 configMap.emplace(NAME_OFF_HOST_ESE_PIPE_ID,
228 ConfigValue(configValue.v1_1.offHostESEPipeId));
229 configMap.emplace(NAME_ISO_DEP_MAX_TRANSCEIVE,
230 ConfigValue(configValue.v1_1.maxIsoDepTransceiveLength));
231 if (configValue.v1_1.hostWhitelist.size() != 0) {
232 configMap.emplace(NAME_DEVICE_HOST_WHITE_LIST,
233 ConfigValue(configValue.v1_1.hostWhitelist));
234 }
235 /* For Backwards compatibility */
236 if (configValue.v1_1.presenceCheckAlgorithm ==
237 PresenceCheckAlgorithm::ISO_DEP_NAK) {
238 configMap.emplace(NAME_PRESENCE_CHECK_ALGORITHM,
239 ConfigValue((uint32_t)NFA_RW_PRES_CHK_ISO_DEP_NAK));
240 } else {
241 configMap.emplace(
242 NAME_PRESENCE_CHECK_ALGORITHM,
243 ConfigValue((uint32_t)configValue.v1_1.presenceCheckAlgorithm));
244 }
245 }
246 }
247 /*******************************************************************************
248 **
249 ** Function: NfcAdaptation::Initialize()
250 **
251 ** Description: class initializer
252 **
253 ** Returns: none
254 **
255 *******************************************************************************/
Initialize()256 void NfcAdaptation::Initialize() {
257 const char* func = "NfcAdaptation::Initialize";
258 const char* argv[] = {"libnfc_nci"};
259 // Init log tag
260 base::CommandLine::Init(1, argv);
261
262 // Android already logs thread_id, proc_id, timestamp, so disable those.
263 logging::SetLogItems(false, false, false, false);
264
265 initializeGlobalDebugEnabledFlag();
266
267 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", func);
268
269 nfc_storage_path = NfcConfig::getString(NAME_NFA_STORAGE, "/data/nfc");
270
271 if (NfcConfig::hasKey(NAME_NFA_DM_CFG)) {
272 std::vector<uint8_t> dm_config = NfcConfig::getBytes(NAME_NFA_DM_CFG);
273 if (dm_config.size() > 0) nfa_dm_cfg.auto_detect_ndef = dm_config[0];
274 if (dm_config.size() > 1) nfa_dm_cfg.auto_read_ndef = dm_config[1];
275 if (dm_config.size() > 2) nfa_dm_cfg.auto_presence_check = dm_config[2];
276 if (dm_config.size() > 3) nfa_dm_cfg.presence_check_option = dm_config[3];
277 // NOTE: The timeout value is not configurable here because the endianess
278 // of a byte array is ambiguous and needlessly difficult to configure.
279 // If this value needs to be configgurable, a numeric config option should
280 // be used.
281 }
282
283 if (NfcConfig::hasKey(NAME_NFA_MAX_EE_SUPPORTED)) {
284 nfa_ee_max_ee_cfg = NfcConfig::getUnsigned(NAME_NFA_MAX_EE_SUPPORTED);
285 DLOG_IF(INFO, nfc_debug_enabled)
286 << StringPrintf("%s: Overriding NFA_EE_MAX_EE_SUPPORTED to use %d",
287 func, nfa_ee_max_ee_cfg);
288 }
289
290 if (NfcConfig::hasKey(NAME_NFA_POLL_BAIL_OUT_MODE)) {
291 nfa_poll_bail_out_mode =
292 NfcConfig::getUnsigned(NAME_NFA_POLL_BAIL_OUT_MODE);
293 DLOG_IF(INFO, nfc_debug_enabled)
294 << StringPrintf("%s: Overriding NFA_POLL_BAIL_OUT_MODE to use %d", func,
295 nfa_poll_bail_out_mode);
296 }
297
298 if (NfcConfig::hasKey(NAME_NFA_PROPRIETARY_CFG)) {
299 std::vector<uint8_t> p_config =
300 NfcConfig::getBytes(NAME_NFA_PROPRIETARY_CFG);
301 if (p_config.size() > 0)
302 nfa_proprietary_cfg.pro_protocol_18092_active = p_config[0];
303 if (p_config.size() > 1)
304 nfa_proprietary_cfg.pro_protocol_b_prime = p_config[1];
305 if (p_config.size() > 2)
306 nfa_proprietary_cfg.pro_protocol_dual = p_config[2];
307 if (p_config.size() > 3)
308 nfa_proprietary_cfg.pro_protocol_15693 = p_config[3];
309 if (p_config.size() > 4)
310 nfa_proprietary_cfg.pro_protocol_kovio = p_config[4];
311 if (p_config.size() > 5) nfa_proprietary_cfg.pro_protocol_mfc = p_config[5];
312 if (p_config.size() > 6)
313 nfa_proprietary_cfg.pro_discovery_kovio_poll = p_config[6];
314 if (p_config.size() > 7)
315 nfa_proprietary_cfg.pro_discovery_b_prime_poll = p_config[7];
316 if (p_config.size() > 8)
317 nfa_proprietary_cfg.pro_discovery_b_prime_listen = p_config[8];
318 }
319
320 // Configure whitelist of HCI host ID's
321 // See specification: ETSI TS 102 622, section 6.1.3.1
322 if (NfcConfig::hasKey(NAME_DEVICE_HOST_WHITE_LIST)) {
323 host_whitelist = NfcConfig::getBytes(NAME_DEVICE_HOST_WHITE_LIST);
324 nfa_hci_cfg.num_whitelist_host = host_whitelist.size();
325 nfa_hci_cfg.p_whitelist = &host_whitelist[0];
326 }
327
328 verify_stack_non_volatile_store();
329 if (NfcConfig::hasKey(NAME_PRESERVE_STORAGE) &&
330 NfcConfig::getUnsigned(NAME_PRESERVE_STORAGE) == 1) {
331 DLOG_IF(INFO, nfc_debug_enabled)
332 << StringPrintf("%s: preserve stack NV store", __func__);
333 } else {
334 delete_stack_non_volatile_store(FALSE);
335 }
336
337 GKI_init();
338 GKI_enable();
339 GKI_create_task((TASKPTR)NFCA_TASK, BTU_TASK, (int8_t*)"NFCA_TASK", nullptr, 0,
340 (pthread_cond_t*)nullptr, nullptr);
341 {
342 AutoThreadMutex guard(mCondVar);
343 GKI_create_task((TASKPTR)Thread, MMI_TASK, (int8_t*)"NFCA_THREAD", nullptr, 0,
344 (pthread_cond_t*)nullptr, nullptr);
345 mCondVar.wait();
346 }
347
348 debug_nfcsnoop_init();
349 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", func);
350 }
351
352 /*******************************************************************************
353 **
354 ** Function: NfcAdaptation::Finalize()
355 **
356 ** Description: class finalizer
357 **
358 ** Returns: none
359 **
360 *******************************************************************************/
Finalize()361 void NfcAdaptation::Finalize() {
362 const char* func = "NfcAdaptation::Finalize";
363 AutoThreadMutex a(sLock);
364
365 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", func);
366 GKI_shutdown();
367
368 NfcConfig::clear();
369
370 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", func);
371 delete this;
372 }
373
FactoryReset()374 void NfcAdaptation::FactoryReset() {
375 if (mHal_1_2 != nullptr) {
376 mHal_1_2->factoryReset();
377 } else if (mHal_1_1 != nullptr) {
378 mHal_1_1->factoryReset();
379 }
380 }
381
DeviceShutdown()382 void NfcAdaptation::DeviceShutdown() {
383 if (mHal_1_2 != nullptr) {
384 mHal_1_2->closeForPowerOffCase();
385 } else if (mHal_1_1 != nullptr) {
386 mHal_1_1->closeForPowerOffCase();
387 }
388 }
389
390 /*******************************************************************************
391 **
392 ** Function: NfcAdaptation::Dump
393 **
394 ** Description: Native support for dumpsys function.
395 **
396 ** Returns: None.
397 **
398 *******************************************************************************/
Dump(int fd)399 void NfcAdaptation::Dump(int fd) { debug_nfcsnoop_dump(fd); }
400
401 /*******************************************************************************
402 **
403 ** Function: NfcAdaptation::signal()
404 **
405 ** Description: signal the CondVar to release the thread that is waiting
406 **
407 ** Returns: none
408 **
409 *******************************************************************************/
signal()410 void NfcAdaptation::signal() { mCondVar.signal(); }
411
412 /*******************************************************************************
413 **
414 ** Function: NfcAdaptation::NFCA_TASK()
415 **
416 ** Description: NFCA_TASK runs the GKI main task
417 **
418 ** Returns: none
419 **
420 *******************************************************************************/
NFCA_TASK(uint32_t arg)421 uint32_t NfcAdaptation::NFCA_TASK(__attribute__((unused)) uint32_t arg) {
422 const char* func = "NfcAdaptation::NFCA_TASK";
423 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", func);
424 GKI_run(nullptr);
425 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", func);
426 return 0;
427 }
428
429 /*******************************************************************************
430 **
431 ** Function: NfcAdaptation::Thread()
432 **
433 ** Description: Creates work threads
434 **
435 ** Returns: none
436 **
437 *******************************************************************************/
Thread(uint32_t arg)438 uint32_t NfcAdaptation::Thread(__attribute__((unused)) uint32_t arg) {
439 const char* func = "NfcAdaptation::Thread";
440 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", func);
441
442 {
443 ThreadCondVar CondVar;
444 AutoThreadMutex guard(CondVar);
445 GKI_create_task((TASKPTR)nfc_task, NFC_TASK, (int8_t*)"NFC_TASK", nullptr, 0,
446 (pthread_cond_t*)CondVar, (pthread_mutex_t*)CondVar);
447 CondVar.wait();
448 }
449
450 NfcAdaptation::GetInstance().signal();
451
452 GKI_exit_task(GKI_get_taskid());
453 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", func);
454 return 0;
455 }
456
457 /*******************************************************************************
458 **
459 ** Function: NfcAdaptation::GetHalEntryFuncs()
460 **
461 ** Description: Get the set of HAL entry points.
462 **
463 ** Returns: Functions pointers for HAL entry points.
464 **
465 *******************************************************************************/
GetHalEntryFuncs()466 tHAL_NFC_ENTRY* NfcAdaptation::GetHalEntryFuncs() { return &mHalEntryFuncs; }
467
468 /*******************************************************************************
469 **
470 ** Function: NfcAdaptation::InitializeHalDeviceContext
471 **
472 ** Description: Ask the generic Android HAL to find the Broadcom-specific HAL.
473 **
474 ** Returns: None.
475 **
476 *******************************************************************************/
InitializeHalDeviceContext()477 void NfcAdaptation::InitializeHalDeviceContext() {
478 const char* func = "NfcAdaptation::InitializeHalDeviceContext";
479
480 mHalEntryFuncs.initialize = HalInitialize;
481 mHalEntryFuncs.terminate = HalTerminate;
482 mHalEntryFuncs.open = HalOpen;
483 mHalEntryFuncs.close = HalClose;
484 mHalEntryFuncs.core_initialized = HalCoreInitialized;
485 mHalEntryFuncs.write = HalWrite;
486 mHalEntryFuncs.prediscover = HalPrediscover;
487 mHalEntryFuncs.control_granted = HalControlGranted;
488 mHalEntryFuncs.power_cycle = HalPowerCycle;
489 mHalEntryFuncs.get_max_ee = HalGetMaxNfcee;
490 LOG(INFO) << StringPrintf("%s: INfc::getService()", func);
491 mHal = mHal_1_1 = mHal_1_2 = INfcV1_2::getService();
492 if (mHal_1_2 == nullptr) {
493 mHal = mHal_1_1 = INfcV1_1::getService();
494 if (mHal_1_1 == nullptr) {
495 mHal = INfc::getService();
496 }
497 }
498 LOG_FATAL_IF(mHal == nullptr, "Failed to retrieve the NFC HAL!");
499 LOG(INFO) << StringPrintf("%s: INfc::getService() returned %p (%s)", func,
500 mHal.get(),
501 (mHal->isRemote() ? "remote" : "local"));
502 }
503
504 /*******************************************************************************
505 **
506 ** Function: NfcAdaptation::HalInitialize
507 **
508 ** Description: Not implemented because this function is only needed
509 ** within the HAL.
510 **
511 ** Returns: None.
512 **
513 *******************************************************************************/
HalInitialize()514 void NfcAdaptation::HalInitialize() {
515 const char* func = "NfcAdaptation::HalInitialize";
516 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", func);
517 }
518
519 /*******************************************************************************
520 **
521 ** Function: NfcAdaptation::HalTerminate
522 **
523 ** Description: Not implemented because this function is only needed
524 ** within the HAL.
525 **
526 ** Returns: None.
527 **
528 *******************************************************************************/
HalTerminate()529 void NfcAdaptation::HalTerminate() {
530 const char* func = "NfcAdaptation::HalTerminate";
531 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", func);
532 }
533
534 /*******************************************************************************
535 **
536 ** Function: NfcAdaptation::HalOpen
537 **
538 ** Description: Turn on controller, download firmware.
539 **
540 ** Returns: None.
541 **
542 *******************************************************************************/
HalOpen(tHAL_NFC_CBACK * p_hal_cback,tHAL_NFC_DATA_CBACK * p_data_cback)543 void NfcAdaptation::HalOpen(tHAL_NFC_CBACK* p_hal_cback,
544 tHAL_NFC_DATA_CBACK* p_data_cback) {
545 const char* func = "NfcAdaptation::HalOpen";
546 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", func);
547 mCallback = new NfcClientCallback(p_hal_cback, p_data_cback);
548 if (mHal_1_1 != nullptr) {
549 mHal_1_1->open_1_1(mCallback);
550 } else {
551 mHal->open(mCallback);
552 }
553 }
554
555 /*******************************************************************************
556 **
557 ** Function: NfcAdaptation::HalClose
558 **
559 ** Description: Turn off controller.
560 **
561 ** Returns: None.
562 **
563 *******************************************************************************/
HalClose()564 void NfcAdaptation::HalClose() {
565 const char* func = "NfcAdaptation::HalClose";
566 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", func);
567 mHal->close();
568 }
569
570 /*******************************************************************************
571 **
572 ** Function: NfcAdaptation::HalDeviceContextCallback
573 **
574 ** Description: Translate generic Android HAL's callback into Broadcom-specific
575 ** callback function.
576 **
577 ** Returns: None.
578 **
579 *******************************************************************************/
HalDeviceContextCallback(nfc_event_t event,nfc_status_t event_status)580 void NfcAdaptation::HalDeviceContextCallback(nfc_event_t event,
581 nfc_status_t event_status) {
582 const char* func = "NfcAdaptation::HalDeviceContextCallback";
583 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: event=%u", func, event);
584 if (mHalCallback) mHalCallback(event, (tHAL_NFC_STATUS)event_status);
585 }
586
587 /*******************************************************************************
588 **
589 ** Function: NfcAdaptation::HalDeviceContextDataCallback
590 **
591 ** Description: Translate generic Android HAL's callback into Broadcom-specific
592 ** callback function.
593 **
594 ** Returns: None.
595 **
596 *******************************************************************************/
HalDeviceContextDataCallback(uint16_t data_len,uint8_t * p_data)597 void NfcAdaptation::HalDeviceContextDataCallback(uint16_t data_len,
598 uint8_t* p_data) {
599 const char* func = "NfcAdaptation::HalDeviceContextDataCallback";
600 DLOG_IF(INFO, nfc_debug_enabled)
601 << StringPrintf("%s: len=%u", func, data_len);
602 if (mHalDataCallback) mHalDataCallback(data_len, p_data);
603 }
604
605 /*******************************************************************************
606 **
607 ** Function: NfcAdaptation::HalWrite
608 **
609 ** Description: Write NCI message to the controller.
610 **
611 ** Returns: None.
612 **
613 *******************************************************************************/
HalWrite(uint16_t data_len,uint8_t * p_data)614 void NfcAdaptation::HalWrite(uint16_t data_len, uint8_t* p_data) {
615 const char* func = "NfcAdaptation::HalWrite";
616 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", func);
617 ::android::hardware::nfc::V1_0::NfcData data;
618 data.setToExternal(p_data, data_len);
619 mHal->write(data);
620 }
621
622 /*******************************************************************************
623 **
624 ** Function: NfcAdaptation::HalCoreInitialized
625 **
626 ** Description: Adjust the configurable parameters in the controller.
627 **
628 ** Returns: None.
629 **
630 *******************************************************************************/
HalCoreInitialized(uint16_t data_len,uint8_t * p_core_init_rsp_params)631 void NfcAdaptation::HalCoreInitialized(uint16_t data_len,
632 uint8_t* p_core_init_rsp_params) {
633 const char* func = "NfcAdaptation::HalCoreInitialized";
634 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", func);
635 hidl_vec<uint8_t> data;
636 data.setToExternal(p_core_init_rsp_params, data_len);
637
638 mHal->coreInitialized(data);
639 }
640
641 /*******************************************************************************
642 **
643 ** Function: NfcAdaptation::HalPrediscover
644 **
645 ** Description: Perform any vendor-specific pre-discovery actions (if
646 ** needed) If any actions were performed TRUE will be returned,
647 ** and HAL_PRE_DISCOVER_CPLT_EVT will notify when actions are
648 ** completed.
649 **
650 ** Returns: TRUE if vendor-specific pre-discovery actions initialized
651 ** FALSE if no vendor-specific pre-discovery actions are
652 ** needed.
653 **
654 *******************************************************************************/
HalPrediscover()655 bool NfcAdaptation::HalPrediscover() {
656 const char* func = "NfcAdaptation::HalPrediscover";
657 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", func);
658 bool retval = FALSE;
659 mHal->prediscover();
660 return retval;
661 }
662
663 /*******************************************************************************
664 **
665 ** Function: HAL_NfcControlGranted
666 **
667 ** Description: Grant control to HAL control for sending NCI commands.
668 ** Call in response to HAL_REQUEST_CONTROL_EVT.
669 ** Must only be called when there are no NCI commands pending.
670 ** HAL_RELEASE_CONTROL_EVT will notify when HAL no longer
671 ** needs control of NCI.
672 **
673 ** Returns: void
674 **
675 *******************************************************************************/
HalControlGranted()676 void NfcAdaptation::HalControlGranted() {
677 const char* func = "NfcAdaptation::HalControlGranted";
678 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", func);
679 mHal->controlGranted();
680 }
681
682 /*******************************************************************************
683 **
684 ** Function: NfcAdaptation::HalPowerCycle
685 **
686 ** Description: Turn off and turn on the controller.
687 **
688 ** Returns: None.
689 **
690 *******************************************************************************/
HalPowerCycle()691 void NfcAdaptation::HalPowerCycle() {
692 const char* func = "NfcAdaptation::HalPowerCycle";
693 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", func);
694 mHal->powerCycle();
695 }
696
697 /*******************************************************************************
698 **
699 ** Function: NfcAdaptation::HalGetMaxNfcee
700 **
701 ** Description: Turn off and turn on the controller.
702 **
703 ** Returns: None.
704 **
705 *******************************************************************************/
HalGetMaxNfcee()706 uint8_t NfcAdaptation::HalGetMaxNfcee() {
707 const char* func = "NfcAdaptation::HalPowerCycle";
708 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", func);
709
710 return nfa_ee_max_ee_cfg;
711 }
712
713 /*******************************************************************************
714 **
715 ** Function: NfcAdaptation::DownloadFirmware
716 **
717 ** Description: Download firmware patch files.
718 **
719 ** Returns: None.
720 **
721 *******************************************************************************/
DownloadFirmware()722 bool NfcAdaptation::DownloadFirmware() {
723 const char* func = "NfcAdaptation::DownloadFirmware";
724 isDownloadFirmwareCompleted = false;
725 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: enter", func);
726 HalInitialize();
727
728 mHalOpenCompletedEvent.lock();
729 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: try open HAL", func);
730 HalOpen(HalDownloadFirmwareCallback, HalDownloadFirmwareDataCallback);
731 mHalOpenCompletedEvent.wait();
732
733 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: try close HAL", func);
734 HalClose();
735
736 HalTerminate();
737 DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s: exit", func);
738
739 return isDownloadFirmwareCompleted;
740 }
741
742 /*******************************************************************************
743 **
744 ** Function: NfcAdaptation::HalDownloadFirmwareCallback
745 **
746 ** Description: Receive events from the HAL.
747 **
748 ** Returns: None.
749 **
750 *******************************************************************************/
HalDownloadFirmwareCallback(nfc_event_t event,nfc_status_t event_status)751 void NfcAdaptation::HalDownloadFirmwareCallback(nfc_event_t event,
752 __attribute__((unused))
753 nfc_status_t event_status) {
754 const char* func = "NfcAdaptation::HalDownloadFirmwareCallback";
755 DLOG_IF(INFO, nfc_debug_enabled)
756 << StringPrintf("%s: event=0x%X", func, event);
757 switch (event) {
758 case HAL_NFC_OPEN_CPLT_EVT: {
759 DLOG_IF(INFO, nfc_debug_enabled)
760 << StringPrintf("%s: HAL_NFC_OPEN_CPLT_EVT", func);
761 if (event_status == HAL_NFC_STATUS_OK) isDownloadFirmwareCompleted = true;
762 mHalOpenCompletedEvent.signal();
763 break;
764 }
765 case HAL_NFC_CLOSE_CPLT_EVT: {
766 DLOG_IF(INFO, nfc_debug_enabled)
767 << StringPrintf("%s: HAL_NFC_CLOSE_CPLT_EVT", func);
768 break;
769 }
770 }
771 }
772
773 /*******************************************************************************
774 **
775 ** Function: NfcAdaptation::HalDownloadFirmwareDataCallback
776 **
777 ** Description: Receive data events from the HAL.
778 **
779 ** Returns: None.
780 **
781 *******************************************************************************/
HalDownloadFirmwareDataCallback(uint16_t data_len,uint8_t * p_data)782 void NfcAdaptation::HalDownloadFirmwareDataCallback(__attribute__((unused))
783 uint16_t data_len,
784 __attribute__((unused))
785 uint8_t* p_data) {}
786
787 /*******************************************************************************
788 **
789 ** Function: ThreadMutex::ThreadMutex()
790 **
791 ** Description: class constructor
792 **
793 ** Returns: none
794 **
795 *******************************************************************************/
ThreadMutex()796 ThreadMutex::ThreadMutex() {
797 pthread_mutexattr_t mutexAttr;
798
799 pthread_mutexattr_init(&mutexAttr);
800 pthread_mutex_init(&mMutex, &mutexAttr);
801 pthread_mutexattr_destroy(&mutexAttr);
802 }
803
804 /*******************************************************************************
805 **
806 ** Function: ThreadMutex::~ThreadMutex()
807 **
808 ** Description: class destructor
809 **
810 ** Returns: none
811 **
812 *******************************************************************************/
~ThreadMutex()813 ThreadMutex::~ThreadMutex() { pthread_mutex_destroy(&mMutex); }
814
815 /*******************************************************************************
816 **
817 ** Function: ThreadMutex::lock()
818 **
819 ** Description: lock kthe mutex
820 **
821 ** Returns: none
822 **
823 *******************************************************************************/
lock()824 void ThreadMutex::lock() { pthread_mutex_lock(&mMutex); }
825
826 /*******************************************************************************
827 **
828 ** Function: ThreadMutex::unblock()
829 **
830 ** Description: unlock the mutex
831 **
832 ** Returns: none
833 **
834 *******************************************************************************/
unlock()835 void ThreadMutex::unlock() { pthread_mutex_unlock(&mMutex); }
836
837 /*******************************************************************************
838 **
839 ** Function: ThreadCondVar::ThreadCondVar()
840 **
841 ** Description: class constructor
842 **
843 ** Returns: none
844 **
845 *******************************************************************************/
ThreadCondVar()846 ThreadCondVar::ThreadCondVar() {
847 pthread_condattr_t CondAttr;
848
849 pthread_condattr_init(&CondAttr);
850 pthread_cond_init(&mCondVar, &CondAttr);
851
852 pthread_condattr_destroy(&CondAttr);
853 }
854
855 /*******************************************************************************
856 **
857 ** Function: ThreadCondVar::~ThreadCondVar()
858 **
859 ** Description: class destructor
860 **
861 ** Returns: none
862 **
863 *******************************************************************************/
~ThreadCondVar()864 ThreadCondVar::~ThreadCondVar() { pthread_cond_destroy(&mCondVar); }
865
866 /*******************************************************************************
867 **
868 ** Function: ThreadCondVar::wait()
869 **
870 ** Description: wait on the mCondVar
871 **
872 ** Returns: none
873 **
874 *******************************************************************************/
wait()875 void ThreadCondVar::wait() {
876 pthread_cond_wait(&mCondVar, *this);
877 pthread_mutex_unlock(*this);
878 }
879
880 /*******************************************************************************
881 **
882 ** Function: ThreadCondVar::signal()
883 **
884 ** Description: signal the mCondVar
885 **
886 ** Returns: none
887 **
888 *******************************************************************************/
signal()889 void ThreadCondVar::signal() {
890 AutoThreadMutex a(*this);
891 pthread_cond_signal(&mCondVar);
892 }
893
894 /*******************************************************************************
895 **
896 ** Function: AutoThreadMutex::AutoThreadMutex()
897 **
898 ** Description: class constructor, automatically lock the mutex
899 **
900 ** Returns: none
901 **
902 *******************************************************************************/
AutoThreadMutex(ThreadMutex & m)903 AutoThreadMutex::AutoThreadMutex(ThreadMutex& m) : mm(m) { mm.lock(); }
904
905 /*******************************************************************************
906 **
907 ** Function: AutoThreadMutex::~AutoThreadMutex()
908 **
909 ** Description: class destructor, automatically unlock the mutex
910 **
911 ** Returns: none
912 **
913 *******************************************************************************/
~AutoThreadMutex()914 AutoThreadMutex::~AutoThreadMutex() { mm.unlock(); }
915