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