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