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