1 /******************************************************************************
2 *
3 * Copyright (C) 2010-2014 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
19 /******************************************************************************
20 *
21 * This file contains the action functions for device manager state
22 * machine.
23 *
24 ******************************************************************************/
25 #include <android-base/logging.h>
26 #include <android-base/stringprintf.h>
27 #include <string.h>
28
29 #include "nci_hmsgs.h"
30 #include "nfa_api.h"
31 #include "nfa_ce_int.h"
32 #include "nfa_hci_int.h"
33 #include "nfa_rw_api.h"
34 #include "nfa_rw_int.h"
35 #include "nfa_wlc_int.h"
36
37 #if (NFC_NFCEE_INCLUDED == TRUE)
38 #include "nfa_ee_int.h"
39 #endif
40
41 #include "nfa_nfcee_int.h"
42 #include "nfc_int.h"
43
44 #if (NFA_SNEP_INCLUDED == TRUE)
45 #include "nfa_snep_int.h"
46 #endif
47
48 using android::base::StringPrintf;
49
50 /* This is the timeout value to guarantee disable is performed within reasonable
51 * amount of time */
52 #ifndef NFA_DM_DISABLE_TIMEOUT_VAL
53 #define NFA_DM_DISABLE_TIMEOUT_VAL 1000
54 #endif
55
56 extern tNFA_TECHNOLOGY_MASK dm_disc_listen_mask_dfl;
57 extern tNFA_TECHNOLOGY_MASK dm_disc_poll_mask_dfl;
58
59 static void nfa_dm_set_init_nci_params(void);
60 static tNFA_STATUS nfa_dm_start_polling(void);
61 static bool nfa_dm_deactivate_polling(void);
62 static void nfa_dm_excl_disc_cback(tNFA_DM_RF_DISC_EVT event,
63 tNFC_DISCOVER* p_data);
64 static void nfa_dm_poll_disc_cback(tNFA_DM_RF_DISC_EVT event,
65 tNFC_DISCOVER* p_data);
66
67 /*******************************************************************************
68 **
69 ** Function nfa_dm_module_init_cback
70 **
71 ** Description Processing initialization complete event from sub-modules
72 **
73 ** Returns None
74 **
75 *******************************************************************************/
nfa_dm_module_init_cback(void)76 static void nfa_dm_module_init_cback(void) {
77 tNFA_DM_CBACK_DATA dm_cback_data;
78
79 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_ENABLE_EVT_PEND;
80
81 /* All subsystem are initialized */
82 dm_cback_data.status = NFA_STATUS_OK;
83 (*nfa_dm_cb.p_dm_cback)(NFA_DM_ENABLE_EVT, &dm_cback_data);
84 }
85
86 /*******************************************************************************
87 **
88 ** Function nfa_dm_nfcc_power_mode_proc_complete_cback
89 **
90 ** Description Processing complete of processing NFCC power state change
91 ** from all sub-modules
92 **
93 ** Returns None
94 **
95 *******************************************************************************/
nfa_dm_nfcc_power_mode_proc_complete_cback(void)96 static void nfa_dm_nfcc_power_mode_proc_complete_cback(void) {
97 tNFA_DM_PWR_MODE_CHANGE power_mode_change;
98
99 LOG(VERBOSE) << StringPrintf("%s: nfcc_pwr_mode=0x%x", __func__,
100 nfa_dm_cb.nfcc_pwr_mode);
101
102 /* if NFCC power state is change to full power */
103 if (nfa_dm_cb.nfcc_pwr_mode != NFA_DM_PWR_MODE_OFF_SLEEP) {
104 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_NFCC_IS_RESTORING;
105
106 /* reconfigure BRCM NFCC */
107 nfa_dm_disc_sm_execute(NFA_DM_RF_DISCOVER_CMD, nullptr);
108 }
109
110 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SETTING_PWR_MODE;
111
112 power_mode_change.status = NFA_STATUS_OK;
113 power_mode_change.power_mode = nfa_dm_cb.nfcc_pwr_mode;
114 tNFA_DM_CBACK_DATA nfa_dm_cback_data;
115 nfa_dm_cback_data.power_mode = power_mode_change;
116 (*nfa_dm_cb.p_dm_cback)(NFA_DM_PWR_MODE_CHANGE_EVT, &nfa_dm_cback_data);
117 }
118 /*******************************************************************************
119 **
120 ** Function nfa_dm_sys_enable
121 **
122 ** Description This function on enable
123 **
124 ** Returns void
125 **
126 *******************************************************************************/
nfa_dm_sys_enable(void)127 void nfa_dm_sys_enable(void) { nfa_dm_set_init_nci_params(); }
128
129 /*******************************************************************************
130 **
131 ** Function nfa_dm_set_init_nci_params
132 **
133 ** Description Set initial NCI configuration parameters
134 **
135 ** Returns void
136 **
137 *******************************************************************************/
nfa_dm_set_init_nci_params(void)138 static void nfa_dm_set_init_nci_params(void) {
139 uint8_t xx;
140
141 /* set NCI default value if other than zero */
142
143 if (NFC_GetNCIVersion() >= NCI_VERSION_2_0) {
144 /* Default Values: For each identifier
145 * Octet 0-1 = OxFF
146 * Octet 2 = Ox02
147 * Octet 3 = 0xFE
148 * Octet 4-9 = 0x00
149 * Octet 10-17 = 0xFF*/
150 for (xx = 0; xx < NFA_CE_LISTEN_INFO_MAX; xx++) {
151 nfa_dm_cb.params.lf_t3t_id[xx][0] = 0xFF;
152 nfa_dm_cb.params.lf_t3t_id[xx][1] = 0xFF;
153 nfa_dm_cb.params.lf_t3t_id[xx][2] = 0x02;
154 nfa_dm_cb.params.lf_t3t_id[xx][3] = 0xFE;
155 }
156
157 /* LF_T3T_PMM value is added to LF_T3T_IDENTIFIERS_X in NCI2.0. */
158 for (xx = 0; xx < NFA_CE_LISTEN_INFO_MAX; xx++) {
159 for (uint8_t yy = 10; yy < NCI_PARAM_LEN_LF_T3T_ID(NFC_GetNCIVersion());
160 yy++)
161 nfa_dm_cb.params.lf_t3t_id[xx][yy] = 0xFF;
162 }
163 } else {
164 /* LF_T3T_IDENTIFIERS_1/2/.../16 */
165 for (xx = 0; xx < NFA_CE_LISTEN_INFO_MAX; xx++) {
166 nfa_dm_cb.params.lf_t3t_id[xx][0] = 0xFF;
167 nfa_dm_cb.params.lf_t3t_id[xx][1] = 0xFF;
168 nfa_dm_cb.params.lf_t3t_id[xx][2] = 0x02;
169 nfa_dm_cb.params.lf_t3t_id[xx][3] = 0xFE;
170 }
171
172 /* LF_T3T_PMM */
173 for (xx = 0; xx < NCI_PARAM_LEN_LF_T3T_PMM; xx++) {
174 nfa_dm_cb.params.lf_t3t_pmm[xx] = 0xFF;
175 }
176 }
177
178 /* LF_T3T_FLAGS:
179 ** DH needs to set this configuration, even if default value (not listening)
180 ** is used, to let NFCC know of intention (not listening) of DH.
181 */
182
183 /* FWI */
184 nfa_dm_cb.params.fwi[0] = 0x04;
185
186 /* WT */
187 nfa_dm_cb.params.wt[0] = 14;
188
189 /* Set CE default configuration */
190 if (p_nfa_dm_ce_cfg[0] && NFC_GetNCIVersion() < NCI_VERSION_2_0) {
191 nfa_dm_check_set_config(p_nfa_dm_ce_cfg[0], &p_nfa_dm_ce_cfg[1], false);
192 }
193
194 /* Set optional general default configuration */
195 if (p_nfa_dm_gen_cfg && p_nfa_dm_gen_cfg[0]) {
196 nfa_dm_check_set_config(p_nfa_dm_gen_cfg[0], &p_nfa_dm_gen_cfg[1], false);
197 }
198
199 if (p_nfa_dm_interface_mapping && nfa_dm_num_dm_interface_mapping) {
200 NFC_DiscoveryMap(nfa_dm_num_dm_interface_mapping,
201 p_nfa_dm_interface_mapping, nullptr);
202 }
203 }
204
205 /*******************************************************************************
206 **
207 ** Function nfa_dm_proc_nfcc_power_mode
208 **
209 ** Description Processing NFCC power mode changes
210 **
211 ** Returns None
212 **
213 *******************************************************************************/
nfa_dm_proc_nfcc_power_mode(uint8_t nfcc_power_mode)214 void nfa_dm_proc_nfcc_power_mode(uint8_t nfcc_power_mode) {
215 LOG(VERBOSE) << StringPrintf("%s: nfcc_power_mode=%d", __func__,
216 nfcc_power_mode);
217
218 /* if NFCC power mode is change to full power */
219 if (nfcc_power_mode == NFA_DM_PWR_MODE_FULL) {
220 memset(&nfa_dm_cb.params, 0x00, sizeof(tNFA_DM_PARAMS));
221 LOG(VERBOSE) << StringPrintf(
222 "%s: setcfg_pending_mask=0x%x, setcfg_pending_num=%d", __func__,
223 nfa_dm_cb.setcfg_pending_mask, nfa_dm_cb.setcfg_pending_num);
224 nfa_dm_cb.setcfg_pending_mask = 0;
225 nfa_dm_cb.setcfg_pending_num = 0;
226
227 nfa_dm_set_init_nci_params();
228 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_POWER_OFF_SLEEP;
229 } else if (nfcc_power_mode == NFA_DM_PWR_MODE_OFF_SLEEP) {
230 nfa_dm_cb.flags |= NFA_DM_FLAGS_POWER_OFF_SLEEP;
231 }
232
233 nfa_sys_cback_notify_nfcc_power_mode_proc_complete(NFA_ID_DM);
234 }
235
236 /*******************************************************************************
237 **
238 ** Function nfa_dm_disable_event
239 **
240 ** Description report disable event
241 **
242 ** Returns void
243 **
244 *******************************************************************************/
nfa_dm_disable_event(void)245 static void nfa_dm_disable_event(void) {
246 /* Deregister DM from sys */
247 nfa_sys_deregister(NFA_ID_DM);
248
249 /* Notify app */
250 nfa_dm_cb.flags &=
251 ~(NFA_DM_FLAGS_DM_IS_ACTIVE | NFA_DM_FLAGS_DM_DISABLING_NFC |
252 NFA_DM_FLAGS_ENABLE_EVT_PEND);
253 (*nfa_dm_cb.p_dm_cback)(NFA_DM_DISABLE_EVT, nullptr);
254 }
255
256 /*******************************************************************************
257 **
258 ** Function nfa_dm_nfc_response_cback
259 **
260 ** Description Call DM event hanlder with NFC response callback data
261 **
262 ** Returns void
263 **
264 *******************************************************************************/
nfa_dm_nfc_response_cback(tNFC_RESPONSE_EVT event,tNFC_RESPONSE * p_data)265 static void nfa_dm_nfc_response_cback(tNFC_RESPONSE_EVT event,
266 tNFC_RESPONSE* p_data) {
267 tNFA_DM_CBACK_DATA dm_cback_data;
268 tNFA_CONN_EVT_DATA conn_evt;
269 uint8_t dm_cback_evt;
270
271 LOG(VERBOSE) << StringPrintf("%s: event=%s(0x%x)", __func__,
272 nfa_dm_nfc_revt_2_str(event).c_str(), event);
273
274 switch (event) {
275 case NFC_ENABLE_REVT: /* 0 Enable event */
276
277 /* NFC stack enabled. Enable nfa sub-systems */
278 if (p_data->enable.status == NFC_STATUS_OK) {
279 /* Initialize NFA subsystems */
280 nfa_sys_enable_subsystems();
281 } else if (nfa_dm_cb.flags & NFA_DM_FLAGS_ENABLE_EVT_PEND) {
282 /* Notify app */
283 nfa_dm_cb.flags &=
284 ~(NFA_DM_FLAGS_ENABLE_EVT_PEND | NFA_DM_FLAGS_DM_IS_ACTIVE);
285 dm_cback_data.status = p_data->enable.status;
286 (*nfa_dm_cb.p_dm_cback)(NFA_DM_ENABLE_EVT, &dm_cback_data);
287 }
288 break;
289
290 case NFC_DISABLE_REVT: /* 1 Disable event */
291 nfa_dm_disable_event();
292 break;
293
294 case NFC_SET_CONFIG_REVT: /* 2 Set Config Response */
295 /* If this setconfig was due to NFA_SetConfig, then notify the app */
296 /* lsb=whether last NCI_SET_CONFIG was due to NFA_SetConfig */
297 if (nfa_dm_cb.setcfg_pending_mask & 1) {
298 dm_cback_data.set_config.status = p_data->set_config.status;
299 dm_cback_data.set_config.num_param_id = p_data->set_config.num_param_id;
300 memcpy(dm_cback_data.set_config.param_ids, p_data->set_config.param_ids,
301 p_data->set_config.num_param_id);
302 (*nfa_dm_cb.p_dm_cback)(NFA_DM_SET_CONFIG_EVT, &dm_cback_data);
303 }
304
305 /* Update the pending mask */
306 if (nfa_dm_cb.setcfg_pending_num > 0) {
307 nfa_dm_cb.setcfg_pending_mask >>= 1;
308 nfa_dm_cb.setcfg_pending_num--;
309 } else {
310 /* This should not occur (means we got a SET_CONFIG_NTF that's
311 * unaccounted for */
312 LOG(ERROR) << StringPrintf("%s: unexpected NFC_SET_CONFIG_REVT",
313 __func__);
314 }
315 break;
316
317 case NFC_GET_CONFIG_REVT: /* 3 Get Config Response */
318 if (p_data->get_config.status == NFC_STATUS_OK) {
319 tNFA_GET_CONFIG* p_nfa_get_confg = &dm_cback_data.get_config;
320 p_nfa_get_confg->status = NFA_STATUS_OK;
321 p_nfa_get_confg->tlv_size = p_data->get_config.tlv_size;
322 p_nfa_get_confg->param_tlvs = p_data->get_config.p_param_tlvs;
323 (*nfa_dm_cb.p_dm_cback)(NFA_DM_GET_CONFIG_EVT, &dm_cback_data);
324 return;
325 }
326
327 /* Return result of getconfig to the app */
328 dm_cback_data.get_config.status = NFA_STATUS_FAILED;
329 (*nfa_dm_cb.p_dm_cback)(NFA_DM_GET_CONFIG_EVT, &dm_cback_data);
330 break;
331
332 #if (NFC_NFCEE_INCLUDED == TRUE)
333 case NFC_NFCEE_DISCOVER_REVT: /* NFCEE Discover response */
334 case NFC_NFCEE_INFO_REVT: /* NFCEE Discover Notification */
335 case NFC_EE_ACTION_REVT: /* EE Action notification */
336 case NFC_NFCEE_MODE_SET_REVT: /* NFCEE Mode Set response */
337 case NFC_NFCEE_STATUS_REVT: /* NFCEE Status notification*/
338 case NFC_SET_ROUTING_REVT: /* Configure Routing response */
339 case NFC_NFCEE_PL_CONTROL_REVT: /* NFCEE pwr and link ctrl response */
340 nfa_ee_proc_evt(event, p_data);
341 break;
342
343 case NFC_EE_DISCOVER_REQ_REVT: /* EE Discover Req notification */
344 nfa_ee_proc_evt(event, p_data);
345 break;
346
347 case NFC_GET_ROUTING_REVT: /* Retrieve Routing response */
348 break;
349 #endif
350
351 case NFC_SET_POWER_SUB_STATE_REVT:
352 dm_cback_data.power_sub_state.status = p_data->status;
353 dm_cback_data.power_sub_state.power_state = nfa_dm_cb.power_state;
354 (*nfa_dm_cb.p_dm_cback)(NFA_DM_SET_POWER_SUB_STATE_EVT, &dm_cback_data);
355 break;
356
357 case NFC_RF_FIELD_REVT: /* RF Field information */
358 dm_cback_data.rf_field.status = NFA_STATUS_OK;
359 dm_cback_data.rf_field.rf_field_status = p_data->rf_field.rf_field;
360 (*nfa_dm_cb.p_dm_cback)(NFA_DM_RF_FIELD_EVT, &dm_cback_data);
361 break;
362
363 case NFC_GEN_ERROR_REVT: /* generic error command or notification */
364 break;
365
366 case NFC_NFCC_RESTART_REVT: /* NFCC has been re-initialized */
367
368 if (p_data->status == NFC_STATUS_OK) {
369 nfa_dm_cb.nfcc_pwr_mode = NFA_DM_PWR_MODE_FULL;
370 nfa_dm_cb.flags |= NFA_DM_FLAGS_NFCC_IS_RESTORING;
371
372 /* NFCC will start from IDLE when turned on again */
373 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
374 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF;
375 nfa_dm_cb.disc_cb.disc_state = NFA_DM_RFST_IDLE;
376 } else {
377 nfa_dm_cb.nfcc_pwr_mode = NFA_DM_PWR_MODE_OFF_SLEEP;
378 }
379 /* Notify NFA submodules change of NFCC power mode */
380 nfa_sys_cback_reg_nfcc_power_mode_proc_complete(
381 nfa_dm_nfcc_power_mode_proc_complete_cback);
382 nfa_sys_notify_nfcc_power_mode(nfa_dm_cb.nfcc_pwr_mode);
383 break;
384
385 case NFC_NFCC_TIMEOUT_REVT:
386 case NFC_NFCC_TRANSPORT_ERR_REVT:
387 LOG(VERBOSE) << StringPrintf("%s: flags=0x%08x", __func__,
388 nfa_dm_cb.flags);
389 dm_cback_evt = (event == NFC_NFCC_TIMEOUT_REVT)
390 ? NFA_DM_NFCC_TIMEOUT_EVT
391 : NFA_DM_NFCC_TRANSPORT_ERR_EVT;
392 (*nfa_dm_cb.p_dm_cback)(dm_cback_evt, nullptr);
393 break;
394
395 case NFC_NFCC_POWER_OFF_REVT:
396 nfa_dm_cb.nfcc_pwr_mode = NFA_DM_PWR_MODE_OFF_SLEEP;
397
398 /* Notify NFA submodules change of NFCC power mode */
399 nfa_sys_cback_reg_nfcc_power_mode_proc_complete(
400 nfa_dm_nfcc_power_mode_proc_complete_cback);
401 nfa_sys_notify_nfcc_power_mode(NFA_DM_PWR_MODE_OFF_SLEEP);
402 break;
403
404 case NFC_RF_COMM_PARAMS_UPDATE_REVT:
405 conn_evt.status = p_data->status;
406 nfa_dm_conn_cback_event_notify(NFA_UPDATE_RF_PARAM_RESULT_EVT, &conn_evt);
407 break;
408
409 default:
410 break;
411 }
412 }
413
414 /*******************************************************************************
415 **
416 ** Function nfa_dm_enable
417 **
418 ** Description Initialises the NFC device manager
419 **
420 ** Returns TRUE (message buffer to be freed by caller)
421 **
422 *******************************************************************************/
nfa_dm_enable(tNFA_DM_MSG * p_data)423 bool nfa_dm_enable(tNFA_DM_MSG* p_data) {
424 tNFA_DM_CBACK_DATA dm_cback_data;
425 LOG(VERBOSE) << __func__;
426
427 /* Check if NFA is already enabled */
428 if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_DM_IS_ACTIVE)) {
429 /* Initialize BRCM control block, it musb be called before setting any flags
430 */
431 nfa_dm_cb.flags |=
432 (NFA_DM_FLAGS_DM_IS_ACTIVE | NFA_DM_FLAGS_ENABLE_EVT_PEND);
433 nfa_sys_cback_reg_enable_complete(nfa_dm_module_init_cback);
434
435 /* Store Enable parameters */
436 nfa_dm_cb.p_dm_cback = p_data->enable.p_dm_cback;
437 nfa_dm_cb.p_conn_cback = p_data->enable.p_conn_cback;
438
439 /* Enable NFC stack */
440 NFC_Enable(nfa_dm_nfc_response_cback);
441 } else {
442 LOG(ERROR) << StringPrintf("%s: ERROR ALREADY ENABLED.", __func__);
443 dm_cback_data.status = NFA_STATUS_ALREADY_STARTED;
444 (*(p_data->enable.p_dm_cback))(NFA_DM_ENABLE_EVT, &dm_cback_data);
445 }
446
447 return true;
448 }
449
450 /*******************************************************************************
451 **
452 ** Function nfa_dm_disable
453 **
454 ** Description Disables the NFC device manager
455 **
456 ** Returns TRUE (message buffer to be freed by caller)
457 **
458 *******************************************************************************/
nfa_dm_disable(tNFA_DM_MSG * p_data)459 bool nfa_dm_disable(tNFA_DM_MSG* p_data) {
460 LOG(VERBOSE) << StringPrintf("%s: graceful=%d", __func__,
461 p_data->disable.graceful);
462
463 if (p_data->disable.graceful) {
464 /* if RF discovery is enabled */
465 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED) {
466 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_ENABLED;
467
468 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_IDLE) {
469 /* if waiting RSP in idle state */
470 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP) {
471 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_DISABLING;
472 }
473 } else {
474 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_DISABLING;
475 tNFA_DM_RF_DISC_DATA nfa_dm_rf_disc_data;
476 nfa_dm_rf_disc_data.deactivate_type = NFA_DEACTIVATE_TYPE_IDLE;
477
478 nfa_dm_disc_sm_execute(NFA_DM_RF_DEACTIVATE_CMD, &nfa_dm_rf_disc_data);
479 if ((nfa_dm_cb.disc_cb.disc_flags &
480 (NFA_DM_DISC_FLAGS_W4_RSP | NFA_DM_DISC_FLAGS_W4_NTF)) == 0) {
481 /* not waiting to deactivate, clear the flag now */
482 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_DISABLING;
483 }
484 }
485 }
486 /* Start timeout for graceful shutdown. If timer expires, then force an
487 * ungraceful shutdown */
488 nfa_sys_start_timer(&nfa_dm_cb.tle, NFA_DM_TIMEOUT_DISABLE_EVT,
489 NFA_DM_DISABLE_TIMEOUT_VAL);
490 }
491 nfa_t4tnfcee_deinit();
492
493 /* Disable all subsystems other than DM (DM will be disabled after all */
494 /* the other subsystem have been disabled) */
495 nfa_sys_disable_subsystems(p_data->disable.graceful);
496 return true;
497 }
498
499 /*******************************************************************************
500 **
501 ** Function nfa_dm_disable_complete
502 **
503 ** Description Called when all NFA subsytems are disabled.
504 **
505 ** NFC core stack can now be disabled.
506 **
507 ** Returns void
508 **
509 *******************************************************************************/
nfa_dm_disable_complete(void)510 void nfa_dm_disable_complete(void) {
511 LOG(VERBOSE) << __func__;
512
513 if ((nfa_dm_cb.flags & NFA_DM_FLAGS_DM_DISABLING_NFC) == 0) {
514 LOG(VERBOSE) << StringPrintf("%s: proceeding with nfc core shutdown",
515 __func__);
516
517 nfa_dm_cb.flags |= NFA_DM_FLAGS_DM_DISABLING_NFC;
518
519 nfa_sys_stop_timer(&nfa_dm_cb.tle);
520
521 /* Free all buffers for NDEF handlers */
522 nfa_dm_ndef_dereg_all();
523
524 /* Disable nfc core stack */
525 NFC_Disable();
526 }
527 }
528
529 /*******************************************************************************
530 **
531 ** Function nfa_dm_set_config
532 **
533 ** Description Process set config command
534 **
535 ** Returns TRUE (message buffer to be freed by caller)
536 **
537 *******************************************************************************/
nfa_dm_set_config(tNFA_DM_MSG * p_data)538 bool nfa_dm_set_config(tNFA_DM_MSG* p_data) {
539 tNFC_STATUS status;
540 uint8_t buff[255];
541 uint8_t* p = buff;
542
543 tNFA_DM_CBACK_DATA dm_cback_data;
544
545 if (p_data->setconfig.length + 2 > 255) {
546 /* Total length of TLV must be less than 256 (1 byte) */
547 status = NFC_STATUS_FAILED;
548 } else {
549 UINT8_TO_STREAM(p, p_data->setconfig.param_id);
550 UINT8_TO_STREAM(p, p_data->setconfig.length);
551 ARRAY_TO_STREAM(p, p_data->setconfig.p_data, p_data->setconfig.length)
552 status = nfa_dm_check_set_config((uint8_t)(p_data->setconfig.length + 2),
553 buff, true);
554 }
555
556 if (status != NFC_STATUS_OK) {
557 dm_cback_data.set_config.status = NFA_STATUS_INVALID_PARAM;
558 (*nfa_dm_cb.p_dm_cback)(NFA_DM_SET_CONFIG_EVT, &dm_cback_data);
559 }
560
561 return true;
562 }
563
564 /*******************************************************************************
565 **
566 ** Function nfa_dm_get_config
567 **
568 ** Description Process get config command
569 **
570 ** Returns TRUE (message buffer to be freed by caller)
571 **
572 *******************************************************************************/
nfa_dm_get_config(tNFA_DM_MSG * p_data)573 bool nfa_dm_get_config(tNFA_DM_MSG* p_data) {
574 NFC_GetConfig(p_data->getconfig.num_ids, p_data->getconfig.p_pmids);
575
576 return true;
577 }
578 /*******************************************************************************
579 **
580 ** Function nfa_dm_set_power_sub_state
581 **
582 ** Description Process the power sub state command
583 **
584 ** Returns TRUE (message buffer to be freed by caller)
585 **
586 *******************************************************************************/
nfa_dm_set_power_sub_state(tNFA_DM_MSG * p_data)587 bool nfa_dm_set_power_sub_state(tNFA_DM_MSG* p_data) {
588 tNFC_STATUS status;
589 tNFA_DM_CBACK_DATA dm_cback_data;
590
591 LOG(VERBOSE) << __func__;
592
593 nfa_dm_cb.power_state = p_data->set_power_state.screen_state;
594 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE) {
595 LOG(VERBOSE) << StringPrintf("%s: NFA_DM_RFST_LISTEN_ACTIVE", __func__);
596 /* NFCC will give semantic error for power sub state command in Rf listen
597 * active state */
598 nfa_dm_cb.pending_power_state = nfa_dm_cb.power_state;
599 status = NFC_STATUS_SEMANTIC_ERROR;
600 } else {
601 status = NFC_SetPowerSubState(p_data->set_power_state.screen_state);
602 }
603
604 if (status != NFC_STATUS_OK) {
605 dm_cback_data.power_sub_state.status = NFC_STATUS_FAILED;
606 dm_cback_data.power_sub_state.power_state = nfa_dm_cb.power_state;
607 (*nfa_dm_cb.p_dm_cback)(NFA_DM_SET_POWER_SUB_STATE_EVT, &dm_cback_data);
608 }
609 return (true);
610 }
611 /*******************************************************************************
612 **
613 ** Function nfa_dm_conn_cback_event_notify
614 **
615 ** Description Notify application of CONN_CBACK event, using appropriate
616 ** callback
617 **
618 ** Returns nothing
619 **
620 *******************************************************************************/
nfa_dm_conn_cback_event_notify(uint8_t event,tNFA_CONN_EVT_DATA * p_data)621 void nfa_dm_conn_cback_event_notify(uint8_t event, tNFA_CONN_EVT_DATA* p_data) {
622 if (nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) {
623 /* Use exclusive RF mode callback */
624 if (nfa_dm_cb.p_excl_conn_cback)
625 (*nfa_dm_cb.p_excl_conn_cback)(event, p_data);
626 } else {
627 (*nfa_dm_cb.p_conn_cback)(event, p_data);
628 }
629 }
630
631 /*******************************************************************************
632 **
633 ** Function nfa_dm_rel_excl_rf_control_and_notify
634 **
635 ** Description Stop exclusive RF control and notify app of
636 ** NFA_EXCLUSIVE_RF_CONTROL_STOPPED_EVT
637 **
638 ** Returns void
639 **
640 *******************************************************************************/
nfa_dm_rel_excl_rf_control_and_notify(void)641 void nfa_dm_rel_excl_rf_control_and_notify(void) {
642 tNFA_CONN_EVT_DATA conn_evt;
643
644 LOG(VERBOSE) << __func__;
645
646 /* Exclusive RF control stopped. Notify app */
647 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_EXCL_RF_ACTIVE;
648
649 /* Stop exclusive RF discovery for exclusive RF mode */
650 nfa_dm_stop_excl_discovery();
651
652 /* Notify app that exclusive RF control has stopped */
653 conn_evt.status = NFA_STATUS_OK;
654 (*nfa_dm_cb.p_excl_conn_cback)(NFA_EXCLUSIVE_RF_CONTROL_STOPPED_EVT,
655 &conn_evt);
656 nfa_dm_cb.p_excl_conn_cback = nullptr;
657 nfa_dm_cb.p_excl_ndef_cback = nullptr;
658 }
659
660 /*******************************************************************************
661 **
662 ** Function nfa_dm_act_request_excl_rf_ctrl
663 **
664 ** Description Request exclusive RF control
665 **
666 ** Returns TRUE (message buffer to be freed by caller)
667 **
668 *******************************************************************************/
nfa_dm_act_request_excl_rf_ctrl(tNFA_DM_MSG * p_data)669 bool nfa_dm_act_request_excl_rf_ctrl(tNFA_DM_MSG* p_data) {
670 tNFA_CONN_EVT_DATA conn_evt;
671
672 LOG(VERBOSE) << __func__;
673
674 if (!nfa_dm_cb.p_excl_conn_cback) {
675 if (nfa_dm_cb.disc_cb.disc_state != NFA_DM_RFST_IDLE) {
676 conn_evt.status = NFA_STATUS_FAILED;
677 (*p_data->req_excl_rf_ctrl.p_conn_cback)(
678 NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT, &conn_evt);
679 return true;
680 }
681
682 /* Store callbacks */
683 nfa_dm_cb.p_excl_conn_cback = p_data->req_excl_rf_ctrl.p_conn_cback;
684 nfa_dm_cb.p_excl_ndef_cback = p_data->req_excl_rf_ctrl.p_ndef_cback;
685
686 nfa_dm_cb.flags |= NFA_DM_FLAGS_EXCL_RF_ACTIVE;
687
688 /* start exclusive RF discovery */
689 nfa_dm_start_excl_discovery(p_data->req_excl_rf_ctrl.poll_mask,
690 &p_data->req_excl_rf_ctrl.listen_cfg,
691 nfa_dm_excl_disc_cback);
692 } else {
693 LOG(ERROR) << StringPrintf("%s: Exclusive rf control already requested",
694 __func__);
695
696 conn_evt.status = NFA_STATUS_FAILED;
697 (*p_data->req_excl_rf_ctrl.p_conn_cback)(
698 NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT, &conn_evt);
699 }
700
701 return true;
702 }
703
704 /*******************************************************************************
705 **
706 ** Function nfa_dm_act_release_excl_rf_ctrl
707 **
708 ** Description Release exclusive RF control
709 **
710 ** Returns TRUE (message buffer to be freed by caller)
711 **
712 *******************************************************************************/
nfa_dm_act_release_excl_rf_ctrl(tNFA_DM_MSG * p_data)713 bool nfa_dm_act_release_excl_rf_ctrl(__attribute__((unused))
714 tNFA_DM_MSG* p_data) {
715 LOG(VERBOSE) << __func__;
716
717 /* nfa_dm_rel_excl_rf_control_and_notify() is called when discovery state goes
718 * IDLE */
719 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_STOPPING;
720
721 /* if discover command has been sent in IDLE state and waiting for response
722 ** then just wait for responose. Otherwise initiate deactivating.
723 */
724 if (!((nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_IDLE) &&
725 (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP))) {
726 nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_IDLE);
727 }
728
729 if (nfa_dm_cb.disc_cb.kovio_tle.in_use)
730 nfa_sys_stop_timer(&nfa_dm_cb.disc_cb.kovio_tle);
731
732 return true;
733 }
734
735 /*******************************************************************************
736 **
737 ** Function nfa_dm_act_deactivate
738 **
739 ** Description Process deactivate command
740 **
741 ** Returns TRUE (message buffer to be freed by caller)
742 **
743 *******************************************************************************/
nfa_dm_act_deactivate(tNFA_DM_MSG * p_data)744 bool nfa_dm_act_deactivate(tNFA_DM_MSG* p_data) {
745 tNFA_CONN_EVT_DATA conn_evt;
746 tNFA_DEACTIVATE_TYPE deact_type;
747
748 LOG(VERBOSE) << __func__;
749
750 /* Always allow deactivate to IDLE */
751 /* Do not allow deactivate to SLEEP for T1T,NFCDEP, ISO15693 */
752 if (p_data->deactivate.sleep_mode == false ||
753 (nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_T1T &&
754 (nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_NFC_DEP ||
755 appl_dta_mode_flag) &&
756 nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_T5T &&
757 nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_KOVIO)) {
758 deact_type = NFA_DEACTIVATE_TYPE_DISCOVERY;
759 if (p_data->deactivate.sleep_mode) {
760 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_HOST_SELECT) {
761 /* Deactivate to sleep mode not allowed in this state. */
762 deact_type = NFA_DEACTIVATE_TYPE_IDLE;
763 } else if (nfa_dm_cb.disc_cb.disc_state ==
764 NFA_DM_RFST_POLL_REMOVAL_DETECTION) {
765 /* Deactivate to sleep mode not allowed in this state. */
766 deact_type = NFA_DEACTIVATE_TYPE_IDLE;
767 } else if (appl_dta_mode_flag == true &&
768 (nfa_dm_cb.disc_cb.disc_state != NFA_DM_RFST_LISTEN_SLEEP ||
769 nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE)) {
770 deact_type = NFA_DEACTIVATE_TYPE_SLEEP;
771 } else if (nfa_dm_cb.disc_cb.disc_state != NFA_DM_RFST_LISTEN_SLEEP) {
772 deact_type = NFA_DEACTIVATE_TYPE_SLEEP;
773 }
774 }
775 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_ALL_DISCOVERIES) {
776 /* Only deactivate to IDLE is allowed in this state. */
777 deact_type = NFA_DEACTIVATE_TYPE_IDLE;
778 }
779
780 if (nfa_dm_rf_deactivate(deact_type) == NFA_STATUS_OK) {
781 if (nfa_dm_cb.disc_cb.kovio_tle.in_use)
782 nfa_sys_stop_timer(&nfa_dm_cb.disc_cb.kovio_tle);
783 nfa_rw_stop_presence_check_timer();
784 return true;
785 }
786 }
787
788 LOG(ERROR) << StringPrintf("%s: invalid protocol, mode or state", __func__);
789
790 /* Notify error to application */
791 conn_evt.status = NFA_STATUS_FAILED;
792 nfa_dm_conn_cback_event_notify(NFA_DEACTIVATE_FAIL_EVT, &conn_evt);
793
794 return true;
795 }
796
797 /*******************************************************************************
798 **
799 ** Function nfa_dm_act_power_off_sleep
800 **
801 ** Description Process power off sleep mode request
802 **
803 ** Returns TRUE (message buffer to be freed by caller)
804 **
805 *******************************************************************************/
nfa_dm_act_power_off_sleep(tNFA_DM_MSG * p_data)806 bool nfa_dm_act_power_off_sleep(tNFA_DM_MSG* p_data) {
807 LOG(VERBOSE) << __func__;
808
809 NFC_SetPowerOffSleep((bool)(p_data->hdr.layer_specific));
810
811 return true;
812 }
813
814 /*******************************************************************************
815 **
816 ** Function nfa_dm_act_reg_vsc
817 **
818 ** Description Process registers VSC callback
819 **
820 ** Returns TRUE (message buffer to be freed by caller)
821 **
822 *******************************************************************************/
nfa_dm_act_reg_vsc(tNFA_DM_MSG * p_data)823 bool nfa_dm_act_reg_vsc(tNFA_DM_MSG* p_data) {
824 if (NFC_RegVSCback(p_data->reg_vsc.is_register, p_data->reg_vsc.p_cback) !=
825 NFC_STATUS_OK) {
826 LOG(ERROR) << StringPrintf("%s: failed", __func__);
827 }
828 return true;
829 }
830
831 /*******************************************************************************
832 **
833 ** Function nfa_dm_act_send_vsc
834 **
835 ** Description Send the NCI Vendor Specific command to the NCI command
836 ** queue
837 **
838 ** Returns FALSE (message buffer is NOT freed by caller)
839 **
840 *******************************************************************************/
nfa_dm_act_send_vsc(tNFA_DM_MSG * p_data)841 bool nfa_dm_act_send_vsc(tNFA_DM_MSG* p_data) {
842 NFC_HDR* p_cmd = (NFC_HDR*)p_data;
843
844 p_cmd->offset = sizeof(tNFA_DM_API_SEND_VSC) - NFC_HDR_SIZE;
845 p_cmd->len = p_data->send_vsc.cmd_params_len;
846 NFC_SendVsCommand(p_data->send_vsc.oid, p_cmd, p_data->send_vsc.p_cback);
847
848 /* Most dm action functions return TRUE, so nfa-sys frees the GKI buffer
849 * carrying the message, This action function re-use the GKI buffer to
850 * send the VSC, so the GKI buffer can not be freed by nfa-sys */
851
852 return false;
853 }
854
855 /*******************************************************************************
856 **
857 ** Function nfa_dm_act_send_raw_vs
858 **
859 ** Description Send the raw vs command to the NCI command queue
860 **
861 ** Returns FALSE (message buffer is NOT freed by caller)
862 **
863 *******************************************************************************/
nfa_dm_act_send_raw_vs(tNFA_DM_MSG * p_data)864 bool nfa_dm_act_send_raw_vs(tNFA_DM_MSG* p_data) {
865 NFC_HDR* p_cmd = (NFC_HDR*)p_data;
866
867 p_cmd->offset = sizeof(tNFA_DM_API_SEND_VSC) - NFC_HDR_SIZE;
868 p_cmd->len = p_data->send_vsc.cmd_params_len;
869 NFC_SendRawVsCommand(p_cmd, p_data->send_vsc.p_cback);
870
871 /* Most dm action functions return TRUE, so nfa-sys frees the GKI buffer
872 * carrying the message,
873 * This action function re-use the GKI buffer to send the VSC, so the GKI
874 * buffer can not be freed by nfa-sys */
875 return false;
876 }
877
878 /*******************************************************************************
879 **
880 ** Function nfa_dm_start_polling
881 **
882 ** Description Start polling
883 **
884 ** Returns tNFA_STATUS
885 **
886 *******************************************************************************/
nfa_dm_start_polling(void)887 tNFA_STATUS nfa_dm_start_polling(void) {
888 tNFA_STATUS status;
889 tNFA_TECHNOLOGY_MASK poll_tech_mask;
890 tNFA_DM_DISC_TECH_PROTO_MASK poll_disc_mask = 0;
891
892 LOG(VERBOSE) << __func__;
893
894 poll_tech_mask = nfa_dm_cb.poll_mask;
895
896 /* start RF discovery with discovery callback */
897 if (nfa_dm_cb.poll_disc_handle == NFA_HANDLE_INVALID) {
898 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A) {
899 poll_disc_mask |= NFA_DM_DISC_MASK_PA_T1T;
900 poll_disc_mask |= NFA_DM_DISC_MASK_PA_T2T;
901 poll_disc_mask |= NFA_DM_DISC_MASK_PA_ISO_DEP;
902 poll_disc_mask |= NFA_DM_DISC_MASK_PA_NFC_DEP;
903 poll_disc_mask |= NFA_DM_DISC_MASK_P_LEGACY;
904 poll_disc_mask |= NFA_DM_DISC_MASK_PA_MIFARE;
905 }
906 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B) {
907 poll_disc_mask |= NFA_DM_DISC_MASK_PB_ISO_DEP;
908 poll_disc_mask |= NFA_DM_DISC_MASK_PB_CI;
909 }
910 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F) {
911 poll_disc_mask |= NFA_DM_DISC_MASK_PF_T3T;
912 poll_disc_mask |= NFA_DM_DISC_MASK_PF_NFC_DEP;
913 }
914 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_V) {
915 poll_disc_mask |= NFA_DM_DISC_MASK_P_T5T;
916 }
917 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B_PRIME) {
918 poll_disc_mask |= NFA_DM_DISC_MASK_P_B_PRIME;
919 }
920 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_KOVIO) {
921 poll_disc_mask |= NFA_DM_DISC_MASK_P_KOVIO;
922 }
923
924 nfa_dm_cb.poll_disc_handle = nfa_dm_add_rf_discover(
925 poll_disc_mask, NFA_DM_DISC_HOST_ID_DH, nfa_dm_poll_disc_cback);
926
927 if (nfa_dm_cb.poll_disc_handle != NFA_HANDLE_INVALID)
928 status = NFA_STATUS_OK;
929 else
930 status = NFA_STATUS_FAILED;
931 } else {
932 status = NFA_STATUS_OK;
933 }
934
935 return (status);
936 }
937
938 /*******************************************************************************
939 **
940 ** Function nfa_dm_act_enable_polling
941 **
942 ** Description Process enable polling command
943 **
944 ** Returns TRUE (message buffer to be freed by caller)
945 **
946 *******************************************************************************/
nfa_dm_act_enable_polling(tNFA_DM_MSG * p_data)947 bool nfa_dm_act_enable_polling(tNFA_DM_MSG* p_data) {
948 tNFA_CONN_EVT_DATA evt_data;
949
950 LOG(VERBOSE) << __func__;
951
952 if ((!(nfa_dm_cb.flags & NFA_DM_FLAGS_POLLING_ENABLED)) &&
953 (!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE))) {
954 nfa_dm_cb.poll_mask = p_data->enable_poll.poll_mask;
955
956 if (nfa_dm_start_polling() == NFA_STATUS_OK) {
957 nfa_dm_cb.flags |= NFA_DM_FLAGS_POLLING_ENABLED;
958
959 evt_data.status = NFA_STATUS_OK;
960 nfa_dm_conn_cback_event_notify(NFA_POLL_ENABLED_EVT, &evt_data);
961 return true;
962 }
963 } else {
964 LOG(ERROR) << StringPrintf("%s: already started", __func__);
965 }
966
967 /* send NFA_POLL_ENABLED_EVT with NFA_STATUS_FAILED */
968 evt_data.status = NFA_STATUS_FAILED;
969 nfa_dm_conn_cback_event_notify(NFA_POLL_ENABLED_EVT, &evt_data);
970
971 return true;
972 }
973
974 /*******************************************************************************
975 **
976 ** Function nfa_dm_deactivate_polling
977 **
978 ** Description Deactivate any polling state
979 **
980 ** Returns TRUE if need to wait for deactivation
981 **
982 *******************************************************************************/
nfa_dm_deactivate_polling(void)983 static bool nfa_dm_deactivate_polling(void) {
984 LOG(VERBOSE) << __func__;
985
986 if ((nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_ALL_DISCOVERIES) ||
987 (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_HOST_SELECT)) {
988 nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_IDLE);
989 return false;
990 } else if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE) {
991 nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_IDLE);
992 return true;
993 } else {
994 return false;
995 }
996 }
997
998 /*******************************************************************************
999 **
1000 ** Function nfa_dm_act_disable_polling
1001 **
1002 ** Description Process disable polling command
1003 **
1004 ** Returns TRUE (message buffer to be freed by caller)
1005 **
1006 *******************************************************************************/
nfa_dm_act_disable_polling(tNFA_DM_MSG * p_data)1007 bool nfa_dm_act_disable_polling(__attribute__((unused)) tNFA_DM_MSG* p_data) {
1008 tNFA_CONN_EVT_DATA evt_data;
1009
1010 LOG(VERBOSE) << __func__;
1011
1012 if (nfa_dm_cb.poll_disc_handle != NFA_HANDLE_INVALID) {
1013 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_POLLING_ENABLED;
1014
1015 if (nfa_dm_deactivate_polling() == false) {
1016 nfa_dm_delete_rf_discover(nfa_dm_cb.poll_disc_handle);
1017 nfa_dm_cb.poll_disc_handle = NFA_HANDLE_INVALID;
1018
1019 evt_data.status = NFA_STATUS_OK;
1020 nfa_dm_conn_cback_event_notify(NFA_POLL_DISABLED_EVT, &evt_data);
1021 } else {
1022 nfa_dm_cb.flags |= NFA_DM_FLAGS_SEND_POLL_STOP_EVT;
1023 }
1024 } else {
1025 evt_data.status = NFA_STATUS_FAILED;
1026 nfa_dm_conn_cback_event_notify(NFA_POLL_DISABLED_EVT, &evt_data);
1027 }
1028
1029 return true;
1030 }
1031
1032 /*******************************************************************************
1033 **
1034 ** Function nfa_dm_act_enable_listening
1035 **
1036 ** Description Process enable listening command
1037 **
1038 ** Returns TRUE (message buffer to be freed by caller)
1039 **
1040 *******************************************************************************/
nfa_dm_act_enable_listening(tNFA_DM_MSG * p_data)1041 bool nfa_dm_act_enable_listening(__attribute__((unused)) tNFA_DM_MSG* p_data) {
1042 tNFA_CONN_EVT_DATA evt_data;
1043
1044 LOG(VERBOSE) << __func__;
1045
1046 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_LISTEN_DISABLED;
1047 evt_data.status = NFA_STATUS_OK;
1048 nfa_dm_conn_cback_event_notify(NFA_LISTEN_ENABLED_EVT, &evt_data);
1049
1050 return true;
1051 }
1052
1053 /*******************************************************************************
1054 **
1055 ** Function nfa_dm_act_disable_listening
1056 **
1057 ** Description Process disable listening command
1058 **
1059 ** Returns TRUE (message buffer to be freed by caller)
1060 **
1061 *******************************************************************************/
nfa_dm_act_disable_listening(tNFA_DM_MSG * p_data)1062 bool nfa_dm_act_disable_listening(__attribute__((unused)) tNFA_DM_MSG* p_data) {
1063 tNFA_CONN_EVT_DATA evt_data;
1064
1065 LOG(VERBOSE) << __func__;
1066
1067 nfa_dm_cb.flags |= NFA_DM_FLAGS_LISTEN_DISABLED;
1068 evt_data.status = NFA_STATUS_OK;
1069 nfa_dm_conn_cback_event_notify(NFA_LISTEN_DISABLED_EVT, &evt_data);
1070
1071 return true;
1072 }
1073
1074 /*******************************************************************************
1075 **
1076 ** Function nfa_dm_act_send_raw_frame
1077 **
1078 ** Description Send an raw frame on RF link
1079 **
1080 ** Returns TRUE (message buffer to be freed by caller)
1081 **
1082 *******************************************************************************/
nfa_dm_act_send_raw_frame(tNFA_DM_MSG * p_data)1083 bool nfa_dm_act_send_raw_frame(tNFA_DM_MSG* p_data) {
1084 tNFC_STATUS status = NFC_STATUS_FAILED;
1085
1086 LOG(VERBOSE) << __func__;
1087
1088 /* If NFC link is activated */
1089 if ((nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE) ||
1090 (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE)) {
1091 nfa_dm_cb.flags |= NFA_DM_FLAGS_RAW_FRAME;
1092 NFC_SetReassemblyFlag(false);
1093 /* If not in exclusive mode, and not activated for LISTEN, then forward raw
1094 * data to NFA_RW to send */
1095 if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) &&
1096 !(nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE) &&
1097 ((nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T1T) ||
1098 (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T2T) ||
1099 (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T3T) ||
1100 (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO_DEP) ||
1101 (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T5T))) {
1102 /* if RW is checking presence then it will put into pending queue */
1103 status = nfa_rw_send_raw_frame((NFC_HDR*)p_data);
1104 } else {
1105 status = NFC_SendData(NFC_RF_CONN_ID, (NFC_HDR*)p_data);
1106 if (status != NFC_STATUS_OK) {
1107 NFC_SetReassemblyFlag(true);
1108 }
1109 /* Already freed or NCI layer will free buffer */
1110 return false;
1111 }
1112 }
1113
1114 if (status == NFC_STATUS_FAILED) {
1115 NFC_SetReassemblyFlag(true);
1116 /* free the buffer */
1117 return true;
1118 } else {
1119 /* NCI layer will free buffer */
1120 return false;
1121 }
1122 }
1123
1124 /*******************************************************************************
1125 **
1126 ** Function nfa_dm_act_start_rf_discovery
1127 **
1128 ** Description Process start RF discovery command
1129 **
1130 ** Returns TRUE (message buffer to be freed by caller)
1131 **
1132 *******************************************************************************/
nfa_dm_act_start_rf_discovery(tNFA_DM_MSG * p_data)1133 bool nfa_dm_act_start_rf_discovery(__attribute__((unused))
1134 tNFA_DM_MSG* p_data) {
1135 tNFA_CONN_EVT_DATA evt_data;
1136
1137 LOG(VERBOSE) << __func__;
1138
1139 if ((nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED) ||
1140 (nfa_hci_cb.hci_state == NFA_HCI_STATE_EE_RECOVERY)) {
1141 evt_data.status = NFA_STATUS_OK;
1142 nfa_dm_conn_cback_event_notify(NFA_RF_DISCOVERY_STARTED_EVT, &evt_data);
1143 } else if (nfa_dm_cb.disc_cb.disc_state != NFA_DM_RFST_IDLE) {
1144 evt_data.status = NFA_STATUS_SEMANTIC_ERROR;
1145 nfa_dm_conn_cback_event_notify(NFA_RF_DISCOVERY_STARTED_EVT, &evt_data);
1146 } else {
1147 nfa_dm_cb.disc_cb.disc_flags |=
1148 (NFA_DM_DISC_FLAGS_ENABLED | NFA_DM_DISC_FLAGS_NOTIFY);
1149 nfa_dm_start_rf_discover();
1150 }
1151
1152 return true;
1153 }
1154
1155 /*******************************************************************************
1156 **
1157 ** Function nfa_dm_act_stop_rf_discovery
1158 **
1159 ** Description Process stop RF discovery command
1160 **
1161 ** Returns TRUE (message buffer to be freed by caller)
1162 **
1163 *******************************************************************************/
nfa_dm_act_stop_rf_discovery(tNFA_DM_MSG * p_data)1164 bool nfa_dm_act_stop_rf_discovery(__attribute__((unused)) tNFA_DM_MSG* p_data) {
1165 tNFA_CONN_EVT_DATA evt_data;
1166 tNFA_DM_DISC_FLAGS disc_flags = nfa_dm_cb.disc_cb.disc_flags;
1167
1168 LOG(VERBOSE) << __func__;
1169
1170 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED) ||
1171 (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_IDLE)) {
1172 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_ENABLED;
1173
1174 /* if discover command has been sent in IDLE state and waiting for response
1175 */
1176 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP) {
1177 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_STOPPING;
1178 } else {
1179 evt_data.status = NFA_STATUS_OK;
1180 nfa_dm_conn_cback_event_notify(NFA_RF_DISCOVERY_STOPPED_EVT, &evt_data);
1181 }
1182 } else {
1183 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_ENABLED;
1184 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_STOPPING;
1185
1186 if (nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_IDLE) == NFA_STATUS_OK) {
1187 if (nfa_dm_cb.disc_cb.kovio_tle.in_use)
1188 nfa_sys_stop_timer(&nfa_dm_cb.disc_cb.kovio_tle);
1189 nfa_rw_stop_presence_check_timer();
1190 } else {
1191 // Stop RF discovery failed, need to restore flags
1192 nfa_dm_cb.disc_cb.disc_flags = disc_flags;
1193 }
1194 }
1195 return true;
1196 }
1197
1198 /*******************************************************************************
1199 **
1200 ** Function nfa_dm_act_set_rf_disc_duration
1201 **
1202 ** Description Set duration for RF discovery
1203 **
1204 ** Returns TRUE (message buffer to be freed by caller)
1205 **
1206 *******************************************************************************/
nfa_dm_act_set_rf_disc_duration(tNFA_DM_MSG * p_data)1207 bool nfa_dm_act_set_rf_disc_duration(tNFA_DM_MSG* p_data) {
1208 nfa_dm_cb.disc_cb.disc_duration = p_data->disc_duration.rf_disc_dur_ms;
1209 return true;
1210 }
1211
1212 /*******************************************************************************
1213 **
1214 ** Function nfa_dm_act_get_rf_disc_duration
1215 **
1216 ** Description Get duration for RF discovery
1217 **
1218 ** Returns uint16_t
1219 **
1220 *******************************************************************************/
nfa_dm_act_get_rf_disc_duration()1221 uint16_t nfa_dm_act_get_rf_disc_duration() {
1222 return (nfa_dm_cb.disc_cb.disc_duration);
1223 }
1224 /*******************************************************************************
1225 **
1226 ** Function nfa_dm_act_select
1227 **
1228 ** Description Process RF select command
1229 **
1230 ** Returns TRUE (message buffer to be freed by caller)
1231 **
1232 *******************************************************************************/
nfa_dm_act_select(tNFA_DM_MSG * p_data)1233 bool nfa_dm_act_select(tNFA_DM_MSG* p_data) {
1234 LOG(VERBOSE) << __func__;
1235
1236 nfa_dm_rf_discover_select(p_data->select.rf_disc_id, p_data->select.protocol,
1237 p_data->select.rf_interface);
1238 return true;
1239 }
1240
1241 /*******************************************************************************
1242 **
1243 ** Function nfa_dm_act_update_rf_params
1244 **
1245 ** Description Process update RF communication parameters command
1246 **
1247 ** Returns TRUE (message buffer to be freed by caller)
1248 **
1249 *******************************************************************************/
nfa_dm_act_update_rf_params(tNFA_DM_MSG * p_data)1250 bool nfa_dm_act_update_rf_params(tNFA_DM_MSG* p_data) {
1251 tNFA_CONN_EVT_DATA conn_evt;
1252
1253 LOG(VERBOSE) << __func__;
1254
1255 if (NFC_UpdateRFCommParams(&p_data->update_rf_params.params) !=
1256 NFC_STATUS_OK) {
1257 conn_evt.status = NFA_STATUS_FAILED;
1258 nfa_dm_conn_cback_event_notify(NFA_UPDATE_RF_PARAM_RESULT_EVT, &conn_evt);
1259 }
1260
1261 return true;
1262 }
1263
1264 /*******************************************************************************
1265 **
1266 ** Function nfa_dm_act_start_removal_detection
1267 **
1268 ** Description Process start endpoint removal detection command
1269 **
1270 ** Returns TRUE (message buffer to be freed by caller)
1271 **
1272 *******************************************************************************/
nfa_dm_act_start_removal_detection(tNFA_DM_MSG * p_data)1273 bool nfa_dm_act_start_removal_detection(tNFA_DM_MSG* p_data) {
1274 tNFA_CONN_EVT_DATA conn_evt;
1275
1276 LOG(VERBOSE) << __func__;
1277
1278 /* Reject request if NFCC does not support Removal Detection in Poll Mode */
1279 if (!(nfc_cb.nci_features & NCI_POLL_REMOVAL_DETECTION)) {
1280 LOG(ERROR) << StringPrintf(
1281 "%s: NFCC Feature Removal Detection "
1282 "in Poll Mode not supported",
1283 __func__);
1284
1285 conn_evt.status = NFA_STATUS_FAILED;
1286 nfa_dm_conn_cback_event_notify(NFA_DETECT_REMOVAL_STARTED_EVT, &conn_evt);
1287 return false;
1288 } else {
1289 /* Command only applicable to non WLC mode or non-autonomous mode
1290 * if WLC started */
1291 if (!((nfa_wlc_cb.wlc_mode & NFA_WLC_SEMI_AUTONOMOUS) ||
1292 (nfa_wlc_cb.wlc_mode & NFA_WLC_AUTONOMOUS))) {
1293 return nfa_dm_rf_removal_detection(
1294 p_data->detect_removal_params.waiting_time_int);
1295 } else {
1296 LOG(ERROR) << StringPrintf(
1297 "%s: Unexpected command in WLC Semi-autonomous or "
1298 "Autonomous mode",
1299 __func__);
1300 conn_evt.status = NFA_STATUS_FAILED;
1301 nfa_dm_conn_cback_event_notify(NFA_DETECT_REMOVAL_STARTED_EVT, &conn_evt);
1302 return false;
1303 }
1304 }
1305 return true;
1306 }
1307
1308 /*******************************************************************************
1309 **
1310 ** Function nfa_dm_act_disable_timeout
1311 **
1312 ** Description timeout on disable process. Shutdown immediately
1313 **
1314 ** Returns TRUE (message buffer to be freed by caller)
1315 **
1316 *******************************************************************************/
nfa_dm_act_disable_timeout(tNFA_DM_MSG * p_data)1317 bool nfa_dm_act_disable_timeout(__attribute__((unused)) tNFA_DM_MSG* p_data) {
1318 tNFA_DM_MSG nfa_dm_msg;
1319 nfa_dm_msg.disable.graceful = false;
1320 nfa_dm_disable(&nfa_dm_msg);
1321 return true;
1322 }
1323
1324 /*******************************************************************************
1325 **
1326 ** Function nfa_dm_act_conn_cback_notify
1327 **
1328 ** Description Notify app of reader/writer/ndef events
1329 **
1330 ** Returns nothing
1331 **
1332 *******************************************************************************/
nfa_dm_act_conn_cback_notify(uint8_t event,tNFA_CONN_EVT_DATA * p_data)1333 void nfa_dm_act_conn_cback_notify(uint8_t event, tNFA_CONN_EVT_DATA* p_data) {
1334 LOG(VERBOSE) << StringPrintf("%s: event=0x%X", __func__, event);
1335
1336 /* Notify event using appropriate CONN_CBACK */
1337 nfa_dm_conn_cback_event_notify(event, p_data);
1338
1339 /* If not in exclusive RF mode, then read NDEF message from tag (if automatic
1340 * reading is enabled) */
1341 if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)) {
1342 if ((event == NFA_NDEF_DETECT_EVT) &&
1343 (nfa_dm_cb.flags & NFA_DM_FLAGS_AUTO_READING_NDEF)) {
1344 /* read NDEF message from tag */
1345 if (p_data->ndef_detect.status == NFA_STATUS_OK) {
1346 NFA_RwReadNDef();
1347 } else if (p_data->ndef_detect.status == NFA_STATUS_FAILED) {
1348 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_AUTO_READING_NDEF;
1349 }
1350 /* ignore NFA_STATUS_BUSY */
1351 } else if ((event == NFA_READ_CPLT_EVT) &&
1352 (nfa_dm_cb.flags & NFA_DM_FLAGS_AUTO_READING_NDEF)) {
1353 /* reading NDEF message is done */
1354 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_AUTO_READING_NDEF;
1355 }
1356 }
1357 }
1358
1359 /*******************************************************************************
1360 **
1361 ** Function nfa_dm_act_data_cback
1362 **
1363 ** Description Processing data from RF link
1364 **
1365 ** Returns None
1366 **
1367 *******************************************************************************/
nfa_dm_act_data_cback(uint8_t conn_id,tNFC_CONN_EVT event,tNFC_CONN * p_data)1368 static void nfa_dm_act_data_cback(__attribute__((unused)) uint8_t conn_id,
1369 tNFC_CONN_EVT event, tNFC_CONN* p_data) {
1370 NFC_HDR* p_msg;
1371 tNFA_CONN_EVT_DATA evt_data;
1372
1373 LOG(VERBOSE) << StringPrintf("%s: event = 0x%X", __func__, event);
1374
1375 if (event == NFC_DATA_CEVT) {
1376 p_msg = (NFC_HDR*)p_data->data.p_data;
1377
1378 if (p_msg) {
1379 evt_data.data.status = p_data->data.status;
1380 evt_data.data.p_data = (uint8_t*)(p_msg + 1) + p_msg->offset;
1381 evt_data.data.len = p_msg->len;
1382
1383 nfa_dm_conn_cback_event_notify(NFA_DATA_EVT, &evt_data);
1384
1385 GKI_freebuf(p_msg);
1386 } else {
1387 LOG(ERROR) << StringPrintf(
1388 "%s: received NFC_DATA_CEVT with NULL data "
1389 "pointer",
1390 __func__);
1391 }
1392 } else if (event == NFC_DEACTIVATE_CEVT) {
1393 NFC_SetStaticRfCback(nullptr);
1394 }
1395 /* needed if CLF reports timeout, transmission or protocol error to notify DTA
1396 * that may need to resume discovery if DH stays in POLL_ACTIVE state */
1397 else if (appl_dta_mode_flag && (event == NFC_ERROR_CEVT)) {
1398 if (p_data) {
1399 evt_data.data.status = p_data->data.status;
1400 nfa_dm_conn_cback_event_notify(NFA_RW_INTF_ERROR_EVT, &evt_data);
1401 } else {
1402 LOG(ERROR) << StringPrintf(
1403 "%s: received NFC_ERROR_CEVT with NULL data "
1404 "pointer",
1405 __func__);
1406 }
1407 }
1408 }
1409
1410 /*******************************************************************************
1411 **
1412 ** Function nfa_dm_excl_disc_cback
1413 **
1414 ** Description Processing event from discovery callback
1415 **
1416 ** Returns None
1417 **
1418 *******************************************************************************/
nfa_dm_excl_disc_cback(tNFA_DM_RF_DISC_EVT event,tNFC_DISCOVER * p_data)1419 static void nfa_dm_excl_disc_cback(tNFA_DM_RF_DISC_EVT event,
1420 tNFC_DISCOVER* p_data) {
1421 tNFA_CONN_EVT_DATA evt_data;
1422
1423 LOG(VERBOSE) << StringPrintf("%s: event=0x%02X", __func__, event);
1424
1425 switch (event) {
1426 case NFA_DM_RF_DISC_START_EVT:
1427 evt_data.status = NFA_STATUS_OK;
1428 nfa_dm_conn_cback_event_notify(NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT,
1429 &evt_data);
1430 break;
1431
1432 case NFA_DM_RF_DISC_ACTIVATED_EVT:
1433 if (nfa_dm_cb.disc_cb.activated_tech_mode == NFC_DISCOVERY_TYPE_POLL_A) {
1434 /* store SEL_RES response */
1435 nfa_dm_cb.disc_cb.activated_sel_res =
1436 p_data->activate.rf_tech_param.param.pa.sel_rsp;
1437 }
1438
1439 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE) {
1440 /* Set data callback to receive raw frame */
1441 NFC_SetStaticRfCback(nfa_dm_act_data_cback);
1442
1443 memset(&(evt_data.activated.params), 0x00, sizeof(tNFA_TAG_PARAMS));
1444 memcpy(&(evt_data.activated.activate_ntf), &(p_data->activate),
1445 sizeof(tNFC_ACTIVATE_DEVT));
1446
1447 nfa_dm_conn_cback_event_notify(NFA_ACTIVATED_EVT, &evt_data);
1448 } else {
1449 //Free bufffer if it has not yet been done to avoid buffer leak
1450 if (nfa_dm_cb.p_activate_ntf) {
1451 GKI_freebuf(nfa_dm_cb.p_activate_ntf);
1452 nfa_dm_cb.p_activate_ntf = nullptr;
1453 }
1454 /* holding activation notification until sub-module is ready */
1455 nfa_dm_cb.p_activate_ntf =
1456 (uint8_t*)GKI_getbuf(sizeof(tNFC_ACTIVATE_DEVT));
1457
1458 if (nfa_dm_cb.p_activate_ntf) {
1459 memcpy(nfa_dm_cb.p_activate_ntf, &(p_data->activate),
1460 sizeof(tNFC_ACTIVATE_DEVT));
1461
1462 if ((nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T1T) ||
1463 (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) ||
1464 (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) ||
1465 (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP) ||
1466 (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T5T) ||
1467 (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_KOVIO) ||
1468 (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_MIFARE)) {
1469 /* Notify NFA tag sub-system */
1470 nfa_rw_proc_disc_evt(NFA_DM_RF_DISC_ACTIVATED_EVT, p_data, false);
1471 } else /* if NFC-DEP, ISO-DEP with frame interface or others */
1472 {
1473 /* Set data callback to receive raw frame */
1474 NFC_SetStaticRfCback(nfa_dm_act_data_cback);
1475 nfa_dm_notify_activation_status(NFA_STATUS_OK, nullptr);
1476 }
1477 } else {
1478 /* deactivate and restart RF discovery */
1479 nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_DISCOVERY);
1480 }
1481 }
1482 break;
1483
1484 case NFA_DM_RF_DISC_DEACTIVATED_EVT:
1485
1486 /* if deactivated to idle or discovery */
1487 if ((p_data->deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) ||
1488 (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY)) {
1489 /* clear stored NFCID/UID/KOVIO bar code */
1490 nfa_dm_cb.activated_nfcid_len = 0;
1491 }
1492
1493 if (nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_NFC_DEP) {
1494 /* Notify NFA RW sub-systems */
1495 nfa_rw_proc_disc_evt(NFA_DM_RF_DISC_DEACTIVATED_EVT, nullptr, false);
1496 }
1497
1498 /* if deactivated as sleep mode */
1499 if ((p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) ||
1500 (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF)) {
1501 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_SLEEP;
1502 } else {
1503 evt_data.deactivated.type = p_data->deactivate.type;
1504 }
1505
1506 /* notify deactivation to upper layer */
1507 nfa_dm_conn_cback_event_notify(NFA_DEACTIVATED_EVT, &evt_data);
1508
1509 /* clean up SEL_RES response */
1510 nfa_dm_cb.disc_cb.activated_sel_res = 0;
1511 break;
1512
1513 default:
1514 LOG(ERROR) << StringPrintf("%s: Unexpected event", __func__);
1515 break;
1516 }
1517 }
1518
1519 /*******************************************************************************
1520 **
1521 ** Function nfa_dm_poll_disc_cback
1522 **
1523 ** Description Processing event from discovery callback
1524 **
1525 ** Returns None
1526 **
1527 *******************************************************************************/
nfa_dm_poll_disc_cback(tNFA_DM_RF_DISC_EVT event,tNFC_DISCOVER * p_data)1528 static void nfa_dm_poll_disc_cback(tNFA_DM_RF_DISC_EVT event,
1529 tNFC_DISCOVER* p_data) {
1530 tNFA_CONN_EVT_DATA evt_data;
1531
1532 LOG(VERBOSE) << StringPrintf("%s: event=0x%02X", __func__, event);
1533
1534 switch (event) {
1535 case NFA_DM_RF_DISC_START_EVT:
1536 break;
1537
1538 case NFA_DM_RF_DISC_ACTIVATED_EVT:
1539
1540 if (nfa_dm_cb.disc_cb.activated_tech_mode == NFC_DISCOVERY_TYPE_POLL_A) {
1541 /* store SEL_RES response */
1542 nfa_dm_cb.disc_cb.activated_sel_res =
1543 p_data->activate.rf_tech_param.param.pa.sel_rsp;
1544 }
1545
1546 //Free bufffer if it has not yet been done to avoid buffer leak
1547 if (nfa_dm_cb.p_activate_ntf) {
1548 GKI_freebuf(nfa_dm_cb.p_activate_ntf);
1549 nfa_dm_cb.p_activate_ntf = nullptr;
1550 }
1551
1552 /* holding activation notification until sub-module is ready */
1553 nfa_dm_cb.p_activate_ntf =
1554 (uint8_t*)GKI_getbuf(sizeof(tNFC_ACTIVATE_DEVT));
1555
1556 if (nfa_dm_cb.p_activate_ntf) {
1557 memcpy(nfa_dm_cb.p_activate_ntf, &(p_data->activate),
1558 sizeof(tNFC_ACTIVATE_DEVT));
1559 if ((nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T1T) ||
1560 (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) ||
1561 (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) ||
1562 (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP) ||
1563 (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T5T) ||
1564 (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_KOVIO) ||
1565 (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_MIFARE)) {
1566 /* Notify NFA tag sub-system */
1567 nfa_rw_proc_disc_evt(NFA_DM_RF_DISC_ACTIVATED_EVT, p_data, true);
1568 }
1569 // Special case for chinese ID card
1570 else if ((nfa_dm_cb.disc_cb.activated_protocol ==
1571 NFC_PROTOCOL_UNKNOWN) &&
1572 (nfa_dm_cb.disc_cb.activated_rf_interface ==
1573 NFC_DISCOVERY_TYPE_POLL_B)) {
1574 /* Notify NFA tag sub-system */
1575 nfa_rw_proc_disc_evt(NFA_DM_RF_DISC_ACTIVATED_EVT, p_data, true);
1576 } else /* if NFC-DEP/ISO-DEP with frame interface */
1577 {
1578 /* Set data callback to receive raw frame */
1579 NFC_SetStaticRfCback(nfa_dm_act_data_cback);
1580 nfa_dm_notify_activation_status(NFA_STATUS_OK, nullptr);
1581 }
1582 } else {
1583 /* deactivate and restart RF discovery */
1584 nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_DISCOVERY);
1585 }
1586 break;
1587
1588 case NFA_DM_RF_DISC_DEACTIVATED_EVT:
1589
1590 /* if deactivated to idle or discovery */
1591 if ((p_data->deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) ||
1592 (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY)) {
1593 /* clear stored NFCID/UID/KOVIO bar code */
1594 nfa_dm_cb.activated_nfcid_len = 0;
1595 }
1596
1597 /* Notify NFA RW sub-systems */
1598 nfa_rw_proc_disc_evt(NFA_DM_RF_DISC_DEACTIVATED_EVT, nullptr, true);
1599
1600 // TODO: confirm, notification is to be done before NFA_DEACTIVATED_NTF
1601 // and discovery restarted
1602 /* if NFA sent NFA_DETECT_REMOVAL_STARTED_EVT earlier */
1603 if (nfa_dm_cb.flags & NFA_DM_FLAGS_EP_REMOVAL_DETECT_PEND) {
1604 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_EP_REMOVAL_DETECT_PEND;
1605
1606 evt_data.removal_detect.reason = p_data->deactivate.reason;
1607
1608 /* notify removal to application to inform wlc at service level */
1609 nfa_dm_conn_cback_event_notify(NFA_DETECT_REMOVAL_RESULT_EVT,
1610 &evt_data);
1611 }
1612 /* if NFA sent NFA_ACTIVATED_EVT earlier */
1613 if (nfa_dm_cb.flags & NFA_DM_FLAGS_SEND_DEACTIVATED_EVT) {
1614 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SEND_DEACTIVATED_EVT;
1615
1616 /* if deactivated as sleep mode */
1617 if ((p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) ||
1618 (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF)) {
1619 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_SLEEP;
1620 } else {
1621 evt_data.deactivated.type = p_data->deactivate.type;
1622 }
1623 /* notify deactivation to application */
1624 nfa_dm_conn_cback_event_notify(NFA_DEACTIVATED_EVT, &evt_data);
1625 }
1626
1627 /* clean up SEL_RES response */
1628 nfa_dm_cb.disc_cb.activated_sel_res = 0;
1629
1630 if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_POLLING_ENABLED)) {
1631 /* deregister discovery callback from NFA DM Discovery */
1632 nfa_dm_delete_rf_discover(nfa_dm_cb.poll_disc_handle);
1633 nfa_dm_cb.poll_disc_handle = NFA_HANDLE_INVALID;
1634
1635 /* this is for disable polling */
1636 if (nfa_dm_cb.flags & NFA_DM_FLAGS_SEND_POLL_STOP_EVT) {
1637 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SEND_POLL_STOP_EVT;
1638
1639 evt_data.status = NFA_STATUS_OK;
1640 nfa_dm_conn_cback_event_notify(NFA_POLL_DISABLED_EVT, &evt_data);
1641 }
1642 }
1643 break;
1644 }
1645 }
1646
1647 /*******************************************************************************
1648 ** Function nfa_dm_poll_disc_cback_dta_wrapper
1649 **
1650 ** Description Accessing the nfa_dm_poll_disc_cback for DTA wrapper
1651 **
1652 ** Returns None
1653 **
1654 *******************************************************************************/
nfa_dm_poll_disc_cback_dta_wrapper(tNFA_DM_RF_DISC_EVT event,tNFC_DISCOVER * p_data)1655 void nfa_dm_poll_disc_cback_dta_wrapper(tNFA_DM_RF_DISC_EVT event,
1656 tNFC_DISCOVER* p_data) {
1657 nfa_dm_poll_disc_cback(event, p_data);
1658 }
1659
nfa_dm_nfc_response_cback_wrapper(tNFC_RESPONSE_EVT event,tNFC_RESPONSE * p_data)1660 void nfa_dm_nfc_response_cback_wrapper(tNFC_RESPONSE_EVT event,
1661 tNFC_RESPONSE* p_data) {
1662 nfa_dm_nfc_response_cback(event, p_data);
1663 }
1664
1665 /*******************************************************************************
1666 **
1667 ** Function nfa_dm_notify_activation_status
1668 **
1669 ** Description Processing activation status from sub-modules
1670 **
1671 ** Returns None
1672 **
1673 *******************************************************************************/
nfa_dm_notify_activation_status(tNFA_STATUS status,tNFA_TAG_PARAMS * p_params)1674 void nfa_dm_notify_activation_status(tNFA_STATUS status,
1675 tNFA_TAG_PARAMS* p_params) {
1676 tNFA_CONN_EVT_DATA evt_data;
1677 tNFC_RF_TECH_PARAMS* p_tech_params;
1678 uint8_t *p_nfcid = nullptr, nfcid_len;
1679
1680 LOG(VERBOSE) << StringPrintf("%s: status=0x%X", __func__, status);
1681
1682 if (!nfa_dm_cb.p_activate_ntf) {
1683 /* this is for NFA P2P listen */
1684 return;
1685 }
1686
1687 if (status == NFA_STATUS_OK) {
1688 /* notify NFC link activation */
1689 memcpy(&(evt_data.activated.activate_ntf), nfa_dm_cb.p_activate_ntf,
1690 sizeof(tNFC_ACTIVATE_DEVT));
1691
1692 p_tech_params = &evt_data.activated.activate_ntf.rf_tech_param;
1693
1694 memset(&(evt_data.activated.params), 0x00, sizeof(tNFA_TAG_PARAMS));
1695 if (p_params) {
1696 memcpy(&(evt_data.activated.params), p_params, sizeof(tNFA_TAG_PARAMS));
1697 }
1698
1699 /* get length of NFCID and location */
1700 if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_A) {
1701 if ((p_tech_params->param.pa.nfcid1_len == 0) && (p_params != nullptr)) {
1702 nfcid_len = sizeof(p_params->t1t.uid);
1703 p_nfcid = p_params->t1t.uid;
1704 evt_data.activated.activate_ntf.rf_tech_param.param.pa.nfcid1_len =
1705 nfcid_len;
1706 memcpy(evt_data.activated.activate_ntf.rf_tech_param.param.pa.nfcid1,
1707 p_nfcid, nfcid_len);
1708 } else {
1709 nfcid_len = p_tech_params->param.pa.nfcid1_len;
1710 p_nfcid = p_tech_params->param.pa.nfcid1;
1711 }
1712 } else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_B) {
1713 nfcid_len = NFC_NFCID0_MAX_LEN;
1714 p_nfcid = p_tech_params->param.pb.nfcid0;
1715 } else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_F) {
1716 nfcid_len = NFC_NFCID2_LEN;
1717 p_nfcid = p_tech_params->param.pf.nfcid2;
1718 } else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_V) {
1719 nfcid_len = NFC_ISO15693_UID_LEN;
1720 p_nfcid = p_tech_params->param.pi93.uid;
1721 } else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_KOVIO) {
1722 nfcid_len = p_tech_params->param.pk.uid_len;
1723 p_nfcid = p_tech_params->param.pk.uid;
1724 } else {
1725 nfcid_len = 0;
1726 }
1727
1728 if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)) {
1729 /*
1730 ** if the same tag is activated then do not perform auto NDEF
1731 ** detection. Application may put a tag into sleep mode and
1732 ** reactivate the same tag.
1733 */
1734
1735 if ((p_tech_params->mode != nfa_dm_cb.activated_tech_mode) ||
1736 (nfcid_len != nfa_dm_cb.activated_nfcid_len) ||
1737 (memcmp(p_nfcid, nfa_dm_cb.activated_nfcid, nfcid_len))) {
1738 if ((nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T1T) ||
1739 (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) ||
1740 (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) ||
1741 ((nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP) &&
1742 (nfa_dm_cb.disc_cb.activated_rf_interface ==
1743 NFC_INTERFACE_ISO_DEP)) ||
1744 (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T5T)) {
1745 if (p_nfa_dm_cfg->auto_detect_ndef) {
1746 if (p_nfa_dm_cfg->auto_read_ndef) {
1747 nfa_dm_cb.flags |= NFA_DM_FLAGS_AUTO_READING_NDEF;
1748 }
1749 NFA_RwDetectNDef();
1750 } else if (p_nfa_dm_cfg->auto_read_ndef) {
1751 NFA_RwReadNDef();
1752 }
1753 }
1754 }
1755 }
1756
1757 /* store activated tag information */
1758 nfa_dm_cb.activated_tech_mode = p_tech_params->mode;
1759 nfa_dm_cb.activated_nfcid_len = nfcid_len;
1760 if (nfcid_len) memcpy(nfa_dm_cb.activated_nfcid, p_nfcid, nfcid_len);
1761
1762 nfa_dm_cb.flags |= NFA_DM_FLAGS_SEND_DEACTIVATED_EVT;
1763 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING))
1764 nfa_dm_conn_cback_event_notify(NFA_ACTIVATED_EVT, &evt_data);
1765 } else {
1766 /* if NFC_DEP, NFA P2P will deactivate */
1767 if (nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_NFC_DEP) {
1768 nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_DISCOVERY);
1769 }
1770 }
1771
1772 GKI_freebuf(nfa_dm_cb.p_activate_ntf);
1773 nfa_dm_cb.p_activate_ntf = nullptr;
1774 }
1775
1776 /*******************************************************************************
1777 **
1778 ** Function nfa_dm_act_change_discovery_tech
1779 **
1780 ** Description Process change listening command
1781 **
1782 ** Returns TRUE (message buffer to be freed by caller)
1783 **
1784 *******************************************************************************/
nfa_dm_act_change_discovery_tech(tNFA_DM_MSG * p_data)1785 bool nfa_dm_act_change_discovery_tech(tNFA_DM_MSG* p_data) {
1786 tNFA_CONN_EVT_DATA evt_data;
1787
1788 LOG(VERBOSE) << StringPrintf("%s", __func__);
1789
1790 if (p_data->change_discovery_tech.change_default_tech)
1791 nfa_dm_cb.flags |= NFA_DM_FLAGS_DEFAULT_TECH_CHANGED;
1792 else
1793 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_DEFAULT_TECH_CHANGED;
1794
1795 if (p_data->change_discovery_tech.is_revert_poll)
1796 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_POLL_TECH_CHANGED;
1797 else
1798 nfa_dm_cb.flags |= NFA_DM_FLAGS_POLL_TECH_CHANGED;
1799
1800 if (p_data->change_discovery_tech.is_revert_listen)
1801 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_LISTEN_TECH_CHANGED;
1802 else
1803 nfa_dm_cb.flags |= NFA_DM_FLAGS_LISTEN_TECH_CHANGED;
1804
1805 nfa_dm_cb.change_poll_mask = p_data->change_discovery_tech.change_poll_mask;
1806 nfa_dm_cb.change_listen_mask =
1807 p_data->change_discovery_tech.change_listen_mask;
1808
1809 if (nfa_dm_cb.flags & NFA_DM_FLAGS_DEFAULT_TECH_CHANGED) {
1810 if (nfa_dm_cb.flags & NFA_DM_FLAGS_LISTEN_TECH_CHANGED) {
1811 dm_disc_listen_mask_dfl = nfa_dm_cb.change_listen_mask;
1812 } else if (nfa_dm_cb.change_listen_mask == 0xff) {
1813 dm_disc_listen_mask_dfl = 0;
1814 }
1815 LOG(DEBUG) << StringPrintf("%s: dm_disc_listen_mask_dfl=0x%x", __func__,
1816 dm_disc_listen_mask_dfl);
1817 if (nfa_dm_cb.flags & NFA_DM_FLAGS_POLL_TECH_CHANGED) {
1818 dm_disc_poll_mask_dfl = nfa_dm_cb.change_poll_mask;
1819 } else if (nfa_dm_cb.change_poll_mask == 0xff) {
1820 dm_disc_poll_mask_dfl = 0;
1821 }
1822 }
1823
1824 evt_data.status = NFA_STATUS_OK;
1825 nfa_dm_conn_cback_event_notify(NFA_LISTEN_ENABLED_EVT, &evt_data);
1826
1827 return true;
1828 }
1829
1830 /*******************************************************************************
1831 **
1832 ** Function nfa_dm_nfc_revt_2_str
1833 **
1834 ** Description convert nfc revt to string
1835 **
1836 *******************************************************************************/
nfa_dm_nfc_revt_2_str(tNFC_RESPONSE_EVT event)1837 std::string nfa_dm_nfc_revt_2_str(tNFC_RESPONSE_EVT event) {
1838 switch (event) {
1839 case NFC_ENABLE_REVT:
1840 return "NFC_ENABLE_REVT";
1841 case NFC_DISABLE_REVT:
1842 return "NFC_DISABLE_REVT";
1843 case NFC_SET_CONFIG_REVT:
1844 return "NFC_SET_CONFIG_REVT";
1845 case NFC_GET_CONFIG_REVT:
1846 return "NFC_GET_CONFIG_REVT";
1847 case NFC_NFCEE_DISCOVER_REVT:
1848 return "NFC_NFCEE_DISCOVER_REVT";
1849 case NFC_NFCEE_INFO_REVT:
1850 return "NFC_NFCEE_INFO_REVT";
1851 case NFC_NFCEE_MODE_SET_REVT:
1852 return "NFC_NFCEE_MODE_SET_REVT";
1853 case NFC_NFCEE_PL_CONTROL_REVT:
1854 return "NFC_NFCEE_PL_CONTROL_REVT";
1855 case NFC_RF_FIELD_REVT:
1856 return "NFC_RF_FIELD_REVT";
1857 case NFC_EE_ACTION_REVT:
1858 return "NFC_EE_ACTION_REVT";
1859 case NFC_EE_DISCOVER_REQ_REVT:
1860 return "NFC_EE_DISCOVER_REQ_REVT";
1861 case NFC_SET_ROUTING_REVT:
1862 return "NFC_SET_ROUTING_REVT";
1863 case NFC_GET_ROUTING_REVT:
1864 return "NFC_GET_ROUTING_REVT";
1865 case NFC_GEN_ERROR_REVT:
1866 return "NFC_GEN_ERROR_REVT";
1867 case NFC_NFCC_RESTART_REVT:
1868 return "NFC_NFCC_RESTART_REVT";
1869 case NFC_NFCC_TIMEOUT_REVT:
1870 return "NFC_NFCC_TIMEOUT_REVT";
1871 case NFC_NFCC_TRANSPORT_ERR_REVT:
1872 return "NFC_NFCC_TRANSPORT_ERR_REVT";
1873 case NFC_NFCC_POWER_OFF_REVT:
1874 return "NFC_NFCC_POWER_OFF_REVT";
1875 case NFC_NFCEE_STATUS_REVT:
1876 return "NFC_NFCEE_STATUS_REVT";
1877 default:
1878 return "unknown revt";
1879 }
1880 }
1881