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