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 discovery
23 * function.
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_p2p_int.h"
31 #include "nfa_sys_int.h"
32 #include "nci_hmsgs.h"
33 #if (NFC_NFCEE_INCLUDED == TRUE)
34 #include "nfa_ee_api.h"
35 #include "nfa_ee_int.h"
36 #endif
37 #include "nfa_rw_int.h"
38
39 #include "nfc_int.h"
40 /*
41 ** static functions
42 */
43
44 static UINT8 nfa_dm_get_rf_discover_config (tNFA_DM_DISC_TECH_PROTO_MASK dm_disc_mask,
45 tNFC_DISCOVER_PARAMS disc_params[],
46 UINT8 max_params);
47 static tNFA_STATUS nfa_dm_set_rf_listen_mode_config (tNFA_DM_DISC_TECH_PROTO_MASK tech_proto_mask);
48 static void nfa_dm_set_rf_listen_mode_raw_config (tNFA_DM_DISC_TECH_PROTO_MASK *p_disc_mask);
49 static tNFA_DM_DISC_TECH_PROTO_MASK nfa_dm_disc_get_disc_mask (tNFC_RF_TECH_N_MODE tech_n_mode,
50 tNFC_PROTOCOL protocol);
51 static void nfa_dm_notify_discovery (tNFA_DM_RF_DISC_DATA *p_data);
52 static tNFA_STATUS nfa_dm_disc_notify_activation (tNFC_DISCOVER *p_data);
53 static void nfa_dm_disc_notify_deactivation (tNFA_DM_RF_DISC_SM_EVENT sm_event, tNFC_DISCOVER *p_data);
54 static void nfa_dm_disc_data_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data);
55 static void nfa_dm_disc_kovio_timeout_cback (TIMER_LIST_ENT *p_tle);
56 static void nfa_dm_disc_report_kovio_presence_check (tNFC_STATUS status);
57
58 #if (BT_TRACE_VERBOSE == TRUE)
59 static char *nfa_dm_disc_state_2_str (UINT8 state);
60 static char *nfa_dm_disc_event_2_str (UINT8 event);
61 #endif
62
63 typedef struct nfa_dm_p2p_prio_logic
64 {
65 BOOLEAN isodep_detected; /* flag to check if ISO-DEP is detected */
66 BOOLEAN timer_expired; /* flag to check whether timer is expired */
67 TIMER_LIST_ENT timer_list; /*timer structure pointer */
68 UINT8 first_tech_mode;
69 }nfa_dm_p2p_prio_logic_t;
70
71 static nfa_dm_p2p_prio_logic_t p2p_prio_logic_data;
72
73 /*******************************************************************************
74 **
75 ** Function nfa_dm_get_rf_discover_config
76 **
77 ** Description Build RF discovery configurations from tNFA_DM_DISC_TECH_PROTO_MASK
78 **
79 ** Returns number of RF discovery configurations
80 **
81 *******************************************************************************/
nfa_dm_get_rf_discover_config(tNFA_DM_DISC_TECH_PROTO_MASK dm_disc_mask,tNFC_DISCOVER_PARAMS disc_params[],UINT8 max_params)82 static UINT8 nfa_dm_get_rf_discover_config (tNFA_DM_DISC_TECH_PROTO_MASK dm_disc_mask,
83 tNFC_DISCOVER_PARAMS disc_params[],
84 UINT8 max_params)
85 {
86 UINT8 num_params = 0;
87
88 if (nfa_dm_cb.flags & NFA_DM_FLAGS_LISTEN_DISABLED)
89 {
90 NFA_TRACE_DEBUG1 ("nfa_dm_get_rf_discover_config () listen disabled, rm listen from 0x%x", dm_disc_mask);
91 dm_disc_mask &= NFA_DM_DISC_MASK_POLL;
92 }
93 if (nfa_dm_is_p2p_paused ())
94 {
95 dm_disc_mask &= ~NFA_DM_DISC_MASK_NFC_DEP;
96 }
97
98 /* Check polling A */
99 if (dm_disc_mask & ( NFA_DM_DISC_MASK_PA_T1T
100 |NFA_DM_DISC_MASK_PA_T2T
101 |NFA_DM_DISC_MASK_PA_ISO_DEP
102 |NFA_DM_DISC_MASK_PA_NFC_DEP
103 |NFA_DM_DISC_MASK_P_LEGACY) )
104 {
105 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_A;
106 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pa;
107 num_params++;
108
109 if (num_params >= max_params)
110 return num_params;
111 }
112
113 /* Check polling B */
114 if (dm_disc_mask & NFA_DM_DISC_MASK_PB_ISO_DEP)
115 {
116 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_B;
117 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pb;
118 num_params++;
119
120 if (num_params >= max_params)
121 return num_params;
122 }
123
124 /* Check polling F */
125 if (dm_disc_mask & ( NFA_DM_DISC_MASK_PF_T3T
126 |NFA_DM_DISC_MASK_PF_NFC_DEP) )
127 {
128 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_F;
129 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pf;
130 num_params++;
131
132 if (num_params >= max_params)
133 return num_params;
134 }
135
136 /* Check polling A Active mode */
137 if (dm_disc_mask & NFA_DM_DISC_MASK_PAA_NFC_DEP)
138 {
139 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_A_ACTIVE;
140 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->paa;
141 num_params++;
142
143 if (num_params >= max_params)
144 return num_params;
145 }
146
147 /* Check polling F Active mode */
148 if (dm_disc_mask & NFA_DM_DISC_MASK_PFA_NFC_DEP)
149 {
150 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_F_ACTIVE;
151 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pfa;
152 num_params++;
153
154 if (num_params >= max_params)
155 return num_params;
156 }
157
158 /* Check listening A */
159 if (dm_disc_mask & ( NFA_DM_DISC_MASK_LA_T1T
160 |NFA_DM_DISC_MASK_LA_T2T
161 |NFA_DM_DISC_MASK_LA_ISO_DEP
162 |NFA_DM_DISC_MASK_LA_NFC_DEP) )
163 {
164 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_A;
165 disc_params[num_params].frequency = 1;
166 num_params++;
167
168 if (num_params >= max_params)
169 return num_params;
170 }
171
172 /* Check listening B */
173 if (dm_disc_mask & NFA_DM_DISC_MASK_LB_ISO_DEP)
174 {
175 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_B;
176 disc_params[num_params].frequency = 1;
177 num_params++;
178
179 if (num_params >= max_params)
180 return num_params;
181 }
182
183 /* Check listening F */
184 if (dm_disc_mask & ( NFA_DM_DISC_MASK_LF_T3T
185 |NFA_DM_DISC_MASK_LF_NFC_DEP) )
186 {
187 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_F;
188 disc_params[num_params].frequency = 1;
189 num_params++;
190
191 if (num_params >= max_params)
192 return num_params;
193 }
194
195 /* Check listening A Active mode */
196 if (dm_disc_mask & NFA_DM_DISC_MASK_LAA_NFC_DEP)
197 {
198 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE;
199 disc_params[num_params].frequency = 1;
200 num_params++;
201
202 if (num_params >= max_params)
203 return num_params;
204 }
205
206 /* Check listening F Active mode */
207 if (dm_disc_mask & NFA_DM_DISC_MASK_LFA_NFC_DEP)
208 {
209 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE;
210 disc_params[num_params].frequency = 1;
211 num_params++;
212
213 if (num_params >= max_params)
214 return num_params;
215 }
216
217 /* Check polling ISO 15693 */
218 if (dm_disc_mask & NFA_DM_DISC_MASK_P_ISO15693)
219 {
220 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_ISO15693;
221 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pi93;
222 num_params++;
223
224 if (num_params >= max_params)
225 return num_params;
226 }
227
228 /* Check polling B' */
229 if (dm_disc_mask & NFA_DM_DISC_MASK_P_B_PRIME)
230 {
231 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_B_PRIME;
232 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pbp;
233 num_params++;
234
235 if (num_params >= max_params)
236 return num_params;
237 }
238
239 /* Check polling KOVIO */
240 if (dm_disc_mask & NFA_DM_DISC_MASK_P_KOVIO)
241 {
242 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_KOVIO;
243 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pk;
244 num_params++;
245
246 if (num_params >= max_params)
247 return num_params;
248 }
249
250 /* Check listening ISO 15693 */
251 if (dm_disc_mask & NFA_DM_DISC_MASK_L_ISO15693)
252 {
253 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_ISO15693;
254 disc_params[num_params].frequency = 1;
255 num_params++;
256
257 if (num_params >= max_params)
258 return num_params;
259 }
260
261 /* Check listening B' */
262 if (dm_disc_mask & NFA_DM_DISC_MASK_L_B_PRIME)
263 {
264 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_B_PRIME;
265 disc_params[num_params].frequency = 1;
266 num_params++;
267
268 if (num_params >= max_params)
269 return num_params;
270 }
271
272 return num_params;
273 }
274
275 /*******************************************************************************
276 **
277 ** Function nfa_dm_set_rf_listen_mode_config
278 **
279 ** Description Update listening protocol to NFCC
280 **
281 ** Returns NFA_STATUS_OK if success
282 **
283 *******************************************************************************/
nfa_dm_set_rf_listen_mode_config(tNFA_DM_DISC_TECH_PROTO_MASK tech_proto_mask)284 static tNFA_STATUS nfa_dm_set_rf_listen_mode_config (tNFA_DM_DISC_TECH_PROTO_MASK tech_proto_mask)
285 {
286 UINT8 params[40], *p;
287 UINT8 platform = 0;
288 UINT8 sens_info = 0;
289
290 NFA_TRACE_DEBUG1 ("nfa_dm_set_rf_listen_mode_config () tech_proto_mask = 0x%08X",
291 tech_proto_mask);
292
293 /*
294 ** T1T listen LA_PROT 0x80, LA_SENS_RES byte1:0x00 byte2:0x0C
295 ** T2T listen LA_PROT 0x00
296 ** T3T listen No bit for T3T in LF_PROT (CE T3T set listen parameters, system code, NFCID2, etc.)
297 ** ISO-DEP listen LA_PROT 0x01, LB_PROT 0x01
298 ** NFC-DEP listen LA_PROT 0x02, LF_PROT 0x02
299 */
300
301 if (tech_proto_mask & NFA_DM_DISC_MASK_LA_T1T)
302 {
303 platform = NCI_PARAM_PLATFORM_T1T;
304 }
305 else if (tech_proto_mask & NFA_DM_DISC_MASK_LA_T2T)
306 {
307 /* platform = 0 and sens_info = 0 */
308 }
309 else
310 {
311 if (tech_proto_mask & NFA_DM_DISC_MASK_LA_ISO_DEP)
312 {
313 sens_info |= NCI_PARAM_SEL_INFO_ISODEP;
314 }
315
316 if (tech_proto_mask & NFA_DM_DISC_MASK_LA_NFC_DEP)
317 {
318 sens_info |= NCI_PARAM_SEL_INFO_NFCDEP;
319 }
320 }
321
322 p = params;
323
324 /*
325 ** for Listen A
326 **
327 ** Set ATQA 0x0C00 for T1T listen
328 ** If the ATQA values are 0x0000, then the FW will use 0x0400
329 ** which works for ISODEP, T2T and NFCDEP.
330 */
331 if (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A] == NFA_DM_DISC_HOST_ID_DH)
332 {
333 UINT8_TO_STREAM (p, NFC_PMID_LA_BIT_FRAME_SDD);
334 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_BIT_FRAME_SDD);
335 UINT8_TO_STREAM (p, 0x04);
336 UINT8_TO_STREAM (p, NFC_PMID_LA_PLATFORM_CONFIG);
337 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_PLATFORM_CONFIG);
338 UINT8_TO_STREAM (p, platform);
339 UINT8_TO_STREAM (p, NFC_PMID_LA_SEL_INFO);
340 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_SEL_INFO);
341 UINT8_TO_STREAM (p, sens_info);
342 }
343 else /* Let NFCC use UICC configuration by configuring with length = 0 */
344 {
345 UINT8_TO_STREAM (p, NFC_PMID_LA_BIT_FRAME_SDD);
346 UINT8_TO_STREAM (p, 0);
347 UINT8_TO_STREAM (p, NFC_PMID_LA_PLATFORM_CONFIG);
348 UINT8_TO_STREAM (p, 0);
349 UINT8_TO_STREAM (p, NFC_PMID_LA_SEL_INFO);
350 UINT8_TO_STREAM (p, 0);
351 UINT8_TO_STREAM (p, NFC_PMID_LA_NFCID1);
352 UINT8_TO_STREAM (p, 0);
353 UINT8_TO_STREAM (p, NFC_PMID_LA_HIST_BY);
354 UINT8_TO_STREAM (p, 0);
355 }
356
357 /* for Listen B */
358 if (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_B] == NFA_DM_DISC_HOST_ID_DH)
359 {
360 UINT8_TO_STREAM (p, NFC_PMID_LB_SENSB_INFO);
361 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_SENSB_INFO);
362 if (tech_proto_mask & NFA_DM_DISC_MASK_LB_ISO_DEP)
363 {
364 UINT8_TO_STREAM (p, NCI_LISTEN_PROTOCOL_ISO_DEP);
365 }
366 else
367 {
368 UINT8_TO_STREAM (p, 0x00);
369 }
370 }
371 else /* Let NFCC use UICC configuration by configuring with length = 0 */
372 {
373 UINT8_TO_STREAM (p, NFC_PMID_LB_SENSB_INFO);
374 UINT8_TO_STREAM (p, 0);
375 UINT8_TO_STREAM (p, NFC_PMID_LB_NFCID0);
376 UINT8_TO_STREAM (p, 0);
377 UINT8_TO_STREAM (p, NFC_PMID_LB_APPDATA);
378 UINT8_TO_STREAM (p, 0);
379 UINT8_TO_STREAM (p, NFC_PMID_LB_ADC_FO);
380 UINT8_TO_STREAM (p, 0);
381 UINT8_TO_STREAM (p, NFC_PMID_LB_H_INFO);
382 UINT8_TO_STREAM (p, 0);
383 }
384
385 /* for Listen F */
386 /* NFCC can support NFC-DEP and T3T listening based on NFCID routing regardless of NFC-F tech routing */
387 UINT8_TO_STREAM (p, NFC_PMID_LF_PROTOCOL);
388 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_PROTOCOL);
389 if ((tech_proto_mask & NFA_DM_DISC_MASK_LF_NFC_DEP) &&
390 !nfa_dm_is_p2p_paused() )
391 {
392 UINT8_TO_STREAM (p, NCI_LISTEN_PROTOCOL_NFC_DEP);
393 }
394 else
395 {
396 UINT8_TO_STREAM (p, 0x00);
397 }
398
399 if (p > params)
400 {
401 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE);
402 }
403
404 return NFA_STATUS_OK;
405 }
406
407 /*******************************************************************************
408 **
409 ** Function nfa_dm_set_total_duration
410 **
411 ** Description Update total duration to NFCC
412 **
413 ** Returns void
414 **
415 *******************************************************************************/
nfa_dm_set_total_duration(void)416 static void nfa_dm_set_total_duration (void)
417 {
418 UINT8 params[10], *p;
419
420 NFA_TRACE_DEBUG0 ("nfa_dm_set_total_duration ()");
421
422 p = params;
423
424 /* for total duration */
425 UINT8_TO_STREAM (p, NFC_PMID_TOTAL_DURATION);
426 UINT8_TO_STREAM (p, NCI_PARAM_LEN_TOTAL_DURATION);
427 UINT16_TO_STREAM (p, nfa_dm_cb.disc_cb.disc_duration);
428
429 if (p > params)
430 {
431 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE);
432 }
433 }
434
435 /*******************************************************************************
436 **
437 ** Function nfa_dm_set_rf_listen_mode_raw_config
438 **
439 ** Description Set raw listen parameters
440 **
441 ** Returns void
442 **
443 *******************************************************************************/
nfa_dm_set_rf_listen_mode_raw_config(tNFA_DM_DISC_TECH_PROTO_MASK * p_disc_mask)444 static void nfa_dm_set_rf_listen_mode_raw_config (tNFA_DM_DISC_TECH_PROTO_MASK *p_disc_mask)
445 {
446 tNFA_DM_DISC_TECH_PROTO_MASK disc_mask = 0;
447 tNFA_LISTEN_CFG *p_cfg = &nfa_dm_cb.disc_cb.excl_listen_config;
448 UINT8 params[250], *p, xx;
449
450 NFA_TRACE_DEBUG0 ("nfa_dm_set_rf_listen_mode_raw_config ()");
451
452 /*
453 ** Discovery Configuration Parameters for Listen A
454 */
455 if ( (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A] == NFA_DM_DISC_HOST_ID_DH)
456 &&(p_cfg->la_enable) )
457 {
458 p = params;
459
460 UINT8_TO_STREAM (p, NFC_PMID_LA_BIT_FRAME_SDD);
461 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_BIT_FRAME_SDD);
462 UINT8_TO_STREAM (p, p_cfg->la_bit_frame_sdd);
463
464 UINT8_TO_STREAM (p, NFC_PMID_LA_PLATFORM_CONFIG);
465 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_PLATFORM_CONFIG);
466 UINT8_TO_STREAM (p, p_cfg->la_platform_config);
467
468 UINT8_TO_STREAM (p, NFC_PMID_LA_SEL_INFO);
469 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_SEL_INFO);
470 UINT8_TO_STREAM (p, p_cfg->la_sel_info);
471
472 if (p_cfg->la_platform_config == NCI_PARAM_PLATFORM_T1T)
473 {
474 disc_mask |= NFA_DM_DISC_MASK_LA_T1T;
475 }
476 else
477 {
478 /* If T4T or NFCDEP */
479 if (p_cfg->la_sel_info & NCI_PARAM_SEL_INFO_ISODEP)
480 {
481 disc_mask |= NFA_DM_DISC_MASK_LA_ISO_DEP;
482 }
483
484 if (p_cfg->la_sel_info & NCI_PARAM_SEL_INFO_NFCDEP)
485 {
486 disc_mask |= NFA_DM_DISC_MASK_LA_NFC_DEP;
487 }
488
489 /* If neither, T4T nor NFCDEP, then its T2T */
490 if (disc_mask == 0)
491 {
492 disc_mask |= NFA_DM_DISC_MASK_LA_T2T;
493 }
494 }
495
496 UINT8_TO_STREAM (p, NFC_PMID_LA_NFCID1);
497 UINT8_TO_STREAM (p, p_cfg->la_nfcid1_len);
498 ARRAY_TO_STREAM (p, p_cfg->la_nfcid1, p_cfg->la_nfcid1_len);
499
500 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE);
501 }
502
503 /*
504 ** Discovery Configuration Parameters for Listen B
505 */
506 if ( (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_B] == NFA_DM_DISC_HOST_ID_DH)
507 &&(p_cfg->lb_enable) )
508 {
509 p = params;
510
511 UINT8_TO_STREAM (p, NFC_PMID_LB_SENSB_INFO);
512 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_SENSB_INFO);
513 UINT8_TO_STREAM (p, p_cfg->lb_sensb_info);
514
515 UINT8_TO_STREAM (p, NFC_PMID_LB_NFCID0);
516 UINT8_TO_STREAM (p, p_cfg->lb_nfcid0_len);
517 ARRAY_TO_STREAM (p, p_cfg->lb_nfcid0, p_cfg->lb_nfcid0_len);
518
519 UINT8_TO_STREAM (p, NFC_PMID_LB_APPDATA);
520 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_APPDATA);
521 ARRAY_TO_STREAM (p, p_cfg->lb_app_data, NCI_PARAM_LEN_LB_APPDATA);
522
523 UINT8_TO_STREAM (p, NFC_PMID_LB_SFGI);
524 UINT8_TO_STREAM (p, 1);
525 UINT8_TO_STREAM (p, p_cfg->lb_adc_fo);
526
527 UINT8_TO_STREAM (p, NFC_PMID_LB_ADC_FO);
528 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_ADC_FO);
529 UINT8_TO_STREAM (p, p_cfg->lb_adc_fo);
530
531 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE);
532
533 if (p_cfg->lb_sensb_info & NCI_LISTEN_PROTOCOL_ISO_DEP)
534 {
535 disc_mask |= NFA_DM_DISC_MASK_LB_ISO_DEP;
536 }
537 }
538
539 /*
540 ** Discovery Configuration Parameters for Listen F
541 */
542 if ( (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_F] == NFA_DM_DISC_HOST_ID_DH)
543 &&(p_cfg->lf_enable) )
544 {
545 p = params;
546
547 UINT8_TO_STREAM (p, NFC_PMID_LF_CON_BITR_F);
548 UINT8_TO_STREAM (p, 1);
549 UINT8_TO_STREAM (p, p_cfg->lf_con_bitr_f);
550
551 UINT8_TO_STREAM (p, NFC_PMID_LF_PROTOCOL);
552 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_PROTOCOL);
553 UINT8_TO_STREAM (p, p_cfg->lf_protocol_type);
554
555 UINT8_TO_STREAM (p, NFC_PMID_LF_T3T_FLAGS2);
556 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_T3T_FLAGS2);
557 UINT16_TO_STREAM(p, p_cfg->lf_t3t_flags);
558
559 /* if the bit at position X is set to 0, SC/NFCID2 with index X shall be ignored */
560 for (xx = 0; xx < NFA_LF_MAX_SC_NFCID2; xx++)
561 {
562 if ((p_cfg->lf_t3t_flags & (0x0001 << xx)) != 0x0000)
563 {
564 UINT8_TO_STREAM (p, NFC_PMID_LF_T3T_ID1 + xx);
565 UINT8_TO_STREAM (p, NCI_SYSTEMCODE_LEN + NCI_NFCID2_LEN);
566 ARRAY_TO_STREAM (p, p_cfg->lf_t3t_identifier[xx], NCI_SYSTEMCODE_LEN + NCI_NFCID2_LEN);
567 }
568 }
569
570 UINT8_TO_STREAM (p, NFC_PMID_LF_T3T_PMM);
571 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_T3T_PMM);
572 ARRAY_TO_STREAM (p, p_cfg->lf_t3t_pmm, NCI_PARAM_LEN_LF_T3T_PMM);
573
574 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE);
575
576 if (p_cfg->lf_t3t_flags != NCI_LF_T3T_FLAGS2_ALL_DISABLED)
577 {
578 disc_mask |= NFA_DM_DISC_MASK_LF_T3T;
579 }
580 if (p_cfg->lf_protocol_type & NCI_LISTEN_PROTOCOL_NFC_DEP)
581 {
582 disc_mask |= NFA_DM_DISC_MASK_LF_NFC_DEP;
583 }
584 }
585
586 /*
587 ** Discovery Configuration Parameters for Listen ISO-DEP
588 */
589 if ((disc_mask & (NFA_DM_DISC_MASK_LA_ISO_DEP|NFA_DM_DISC_MASK_LB_ISO_DEP))
590 &&(p_cfg->li_enable))
591 {
592 p = params;
593
594 UINT8_TO_STREAM (p, NFC_PMID_FWI);
595 UINT8_TO_STREAM (p, NCI_PARAM_LEN_FWI);
596 UINT8_TO_STREAM (p, p_cfg->li_fwi);
597
598 if (disc_mask & NFA_DM_DISC_MASK_LA_ISO_DEP)
599 {
600 UINT8_TO_STREAM (p, NFC_PMID_LA_HIST_BY);
601 UINT8_TO_STREAM (p, p_cfg->la_hist_bytes_len);
602 ARRAY_TO_STREAM (p, p_cfg->la_hist_bytes, p_cfg->la_hist_bytes_len);
603 }
604
605 if (disc_mask & NFA_DM_DISC_MASK_LB_ISO_DEP)
606 {
607 UINT8_TO_STREAM (p, NFC_PMID_LB_H_INFO);
608 UINT8_TO_STREAM (p, p_cfg->lb_h_info_resp_len);
609 ARRAY_TO_STREAM (p, p_cfg->lb_h_info_resp, p_cfg->lb_h_info_resp_len);
610 }
611
612 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE);
613 }
614
615 /*
616 ** Discovery Configuration Parameters for Listen NFC-DEP
617 */
618 if ( (disc_mask & (NFA_DM_DISC_MASK_LA_NFC_DEP|NFA_DM_DISC_MASK_LF_NFC_DEP))
619 &&(p_cfg->ln_enable))
620 {
621 p = params;
622
623 UINT8_TO_STREAM (p, NFC_PMID_WT);
624 UINT8_TO_STREAM (p, NCI_PARAM_LEN_WT);
625 UINT8_TO_STREAM (p, p_cfg->ln_wt);
626
627 UINT8_TO_STREAM (p, NFC_PMID_ATR_RES_GEN_BYTES);
628 UINT8_TO_STREAM (p, p_cfg->ln_atr_res_gen_bytes_len);
629 ARRAY_TO_STREAM (p, p_cfg->ln_atr_res_gen_bytes, p_cfg->ln_atr_res_gen_bytes_len);
630
631 UINT8_TO_STREAM (p, NFC_PMID_ATR_RSP_CONFIG);
632 UINT8_TO_STREAM (p, 1);
633 UINT8_TO_STREAM (p, p_cfg->ln_atr_res_config);
634
635 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE);
636 }
637
638 *p_disc_mask = disc_mask;
639
640 NFA_TRACE_DEBUG1 ("nfa_dm_set_rf_listen_mode_raw_config () disc_mask = 0x%x", disc_mask);
641 }
642
643 /*******************************************************************************
644 **
645 ** Function nfa_dm_disc_get_disc_mask
646 **
647 ** Description Convert RF technology, mode and protocol to bit mask
648 **
649 ** Returns tNFA_DM_DISC_TECH_PROTO_MASK
650 **
651 *******************************************************************************/
nfa_dm_disc_get_disc_mask(tNFC_RF_TECH_N_MODE tech_n_mode,tNFC_PROTOCOL protocol)652 static tNFA_DM_DISC_TECH_PROTO_MASK nfa_dm_disc_get_disc_mask (tNFC_RF_TECH_N_MODE tech_n_mode,
653 tNFC_PROTOCOL protocol)
654 {
655 /* Set initial disc_mask to legacy poll or listen */
656 tNFA_DM_DISC_TECH_PROTO_MASK disc_mask = ((tech_n_mode & 0x80) ? NFA_DM_DISC_MASK_L_LEGACY : NFA_DM_DISC_MASK_P_LEGACY);
657
658 if (NFC_DISCOVERY_TYPE_POLL_A == tech_n_mode)
659 {
660 switch (protocol)
661 {
662 case NFC_PROTOCOL_T1T:
663 disc_mask = NFA_DM_DISC_MASK_PA_T1T;
664 break;
665 case NFC_PROTOCOL_T2T:
666 disc_mask = NFA_DM_DISC_MASK_PA_T2T;
667 break;
668 case NFC_PROTOCOL_ISO_DEP:
669 disc_mask = NFA_DM_DISC_MASK_PA_ISO_DEP;
670 break;
671 case NFC_PROTOCOL_NFC_DEP:
672 disc_mask = NFA_DM_DISC_MASK_PA_NFC_DEP;
673 break;
674 }
675 }
676 else if (NFC_DISCOVERY_TYPE_POLL_B == tech_n_mode)
677 {
678 if (protocol == NFC_PROTOCOL_ISO_DEP)
679 disc_mask = NFA_DM_DISC_MASK_PB_ISO_DEP;
680 }
681 else if (NFC_DISCOVERY_TYPE_POLL_F == tech_n_mode)
682 {
683 if (protocol == NFC_PROTOCOL_T3T)
684 disc_mask = NFA_DM_DISC_MASK_PF_T3T;
685 else if (protocol == NFC_PROTOCOL_NFC_DEP)
686 disc_mask = NFA_DM_DISC_MASK_PF_NFC_DEP;
687 }
688 else if (NFC_DISCOVERY_TYPE_POLL_ISO15693 == tech_n_mode)
689 {
690 disc_mask = NFA_DM_DISC_MASK_P_ISO15693;
691 }
692 else if (NFC_DISCOVERY_TYPE_POLL_B_PRIME == tech_n_mode)
693 {
694 disc_mask = NFA_DM_DISC_MASK_P_B_PRIME;
695 }
696 else if (NFC_DISCOVERY_TYPE_POLL_KOVIO == tech_n_mode)
697 {
698 disc_mask = NFA_DM_DISC_MASK_P_KOVIO;
699 }
700 else if (NFC_DISCOVERY_TYPE_POLL_A_ACTIVE == tech_n_mode)
701 {
702 disc_mask = NFA_DM_DISC_MASK_PAA_NFC_DEP;
703 }
704 else if (NFC_DISCOVERY_TYPE_POLL_F_ACTIVE == tech_n_mode)
705 {
706 disc_mask = NFA_DM_DISC_MASK_PFA_NFC_DEP;
707 }
708 else if (NFC_DISCOVERY_TYPE_LISTEN_A == tech_n_mode)
709 {
710 switch (protocol)
711 {
712 case NFC_PROTOCOL_T1T:
713 disc_mask = NFA_DM_DISC_MASK_LA_T1T;
714 break;
715 case NFC_PROTOCOL_T2T:
716 disc_mask = NFA_DM_DISC_MASK_LA_T2T;
717 break;
718 case NFC_PROTOCOL_ISO_DEP:
719 disc_mask = NFA_DM_DISC_MASK_LA_ISO_DEP;
720 break;
721 case NFC_PROTOCOL_NFC_DEP:
722 disc_mask = NFA_DM_DISC_MASK_LA_NFC_DEP;
723 break;
724 }
725 }
726 else if (NFC_DISCOVERY_TYPE_LISTEN_B == tech_n_mode)
727 {
728 if (protocol == NFC_PROTOCOL_ISO_DEP)
729 disc_mask = NFA_DM_DISC_MASK_LB_ISO_DEP;
730 }
731 else if (NFC_DISCOVERY_TYPE_LISTEN_F == tech_n_mode)
732 {
733 if (protocol == NFC_PROTOCOL_T3T)
734 disc_mask = NFA_DM_DISC_MASK_LF_T3T;
735 else if (protocol == NFC_PROTOCOL_NFC_DEP)
736 disc_mask = NFA_DM_DISC_MASK_LF_NFC_DEP;
737 }
738 else if (NFC_DISCOVERY_TYPE_LISTEN_ISO15693 == tech_n_mode)
739 {
740 disc_mask = NFA_DM_DISC_MASK_L_ISO15693;
741 }
742 else if (NFC_DISCOVERY_TYPE_LISTEN_B_PRIME == tech_n_mode)
743 {
744 disc_mask = NFA_DM_DISC_MASK_L_B_PRIME;
745 }
746 else if (NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE == tech_n_mode)
747 {
748 disc_mask = NFA_DM_DISC_MASK_LAA_NFC_DEP;
749 }
750 else if (NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE == tech_n_mode)
751 {
752 disc_mask = NFA_DM_DISC_MASK_LFA_NFC_DEP;
753 }
754
755 NFA_TRACE_DEBUG3 ("nfa_dm_disc_get_disc_mask (): tech_n_mode:0x%X, protocol:0x%X, disc_mask:0x%X",
756 tech_n_mode, protocol, disc_mask);
757 return (disc_mask);
758 }
759
760 /*******************************************************************************
761 **
762 ** Function nfa_dm_disc_discovery_cback
763 **
764 ** Description Discovery callback event from NFC
765 **
766 ** Returns void
767 **
768 *******************************************************************************/
nfa_dm_disc_discovery_cback(tNFC_DISCOVER_EVT event,tNFC_DISCOVER * p_data)769 static void nfa_dm_disc_discovery_cback (tNFC_DISCOVER_EVT event, tNFC_DISCOVER *p_data)
770 {
771 tNFA_DM_RF_DISC_SM_EVENT dm_disc_event = NFA_DM_DISC_SM_MAX_EVENT;
772
773 NFA_TRACE_DEBUG1 ("nfa_dm_disc_discovery_cback (): event:0x%X", event);
774
775 switch (event)
776 {
777 case NFC_START_DEVT:
778 dm_disc_event = NFA_DM_RF_DISCOVER_RSP;
779 break;
780 case NFC_RESULT_DEVT:
781 dm_disc_event = NFA_DM_RF_DISCOVER_NTF;
782 break;
783 case NFC_SELECT_DEVT:
784 dm_disc_event = NFA_DM_RF_DISCOVER_SELECT_RSP;
785 break;
786 case NFC_ACTIVATE_DEVT:
787 dm_disc_event = NFA_DM_RF_INTF_ACTIVATED_NTF;
788 break;
789 case NFC_DEACTIVATE_DEVT:
790 if (p_data->deactivate.is_ntf)
791 {
792 dm_disc_event = NFA_DM_RF_DEACTIVATE_NTF;
793 if ((p_data->deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) || (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY))
794 {
795 NFC_SetReassemblyFlag (TRUE);
796 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_RAW_FRAME;
797 }
798 }
799 else
800 dm_disc_event = NFA_DM_RF_DEACTIVATE_RSP;
801 break;
802 default:
803 NFA_TRACE_ERROR0 ("Unexpected event");
804 return;
805 }
806
807 nfa_dm_disc_sm_execute (dm_disc_event, (tNFA_DM_RF_DISC_DATA *) p_data);
808 }
809
810 /*******************************************************************************
811 **
812 ** Function nfa_dm_disc_notify_started
813 **
814 ** Description Report NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT or
815 ** NFA_RF_DISCOVERY_STARTED_EVT, if needed
816 **
817 ** Returns void
818 **
819 *******************************************************************************/
nfa_dm_disc_notify_started(tNFA_STATUS status)820 static void nfa_dm_disc_notify_started (tNFA_STATUS status)
821 {
822 tNFA_CONN_EVT_DATA evt_data;
823
824 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_NOTIFY)
825 {
826 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY;
827
828 evt_data.status = status;
829
830 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use)
831 nfa_dm_conn_cback_event_notify (NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT, &evt_data);
832 else
833 nfa_dm_conn_cback_event_notify (NFA_RF_DISCOVERY_STARTED_EVT, &evt_data);
834 }
835 }
836
837 /*******************************************************************************
838 **
839 ** Function nfa_dm_disc_conn_event_notify
840 **
841 ** Description Notify application of CONN_CBACK event, using appropriate
842 ** callback
843 **
844 ** Returns nothing
845 **
846 *******************************************************************************/
nfa_dm_disc_conn_event_notify(UINT8 event,tNFA_STATUS status)847 void nfa_dm_disc_conn_event_notify (UINT8 event, tNFA_STATUS status)
848 {
849 tNFA_CONN_EVT_DATA evt_data;
850
851 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_NOTIFY)
852 {
853 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY;
854 evt_data.status = status;
855
856 if (nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)
857 {
858 /* Use exclusive RF mode callback */
859 if (nfa_dm_cb.p_excl_conn_cback)
860 (*nfa_dm_cb.p_excl_conn_cback) (event, &evt_data);
861 }
862 else
863 {
864 (*nfa_dm_cb.p_conn_cback) (event, &evt_data);
865 }
866 }
867 }
868
869 /*******************************************************************************
870 **
871 ** Function nfa_dm_disc_force_to_idle
872 **
873 ** Description Force NFCC to idle state while waiting for deactivation NTF
874 **
875 ** Returns tNFC_STATUS
876 **
877 *******************************************************************************/
nfa_dm_disc_force_to_idle(void)878 static tNFC_STATUS nfa_dm_disc_force_to_idle (void)
879 {
880 tNFC_STATUS status = NFC_STATUS_SEMANTIC_ERROR;
881
882 NFA_TRACE_DEBUG1 ("nfa_dm_disc_force_to_idle() disc_flags = 0x%x", nfa_dm_cb.disc_cb.disc_flags);
883
884 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF) /* do not execute more than one */
885 {
886 nfa_dm_cb.disc_cb.disc_flags &= ~(NFA_DM_DISC_FLAGS_W4_NTF);
887 nfa_dm_cb.disc_cb.disc_flags |= (NFA_DM_DISC_FLAGS_W4_RSP);
888 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
889 status = NFC_Deactivate (NFC_DEACTIVATE_TYPE_IDLE);
890 }
891
892 return (status);
893 }
894
895 /*******************************************************************************
896 **
897 ** Function nfa_dm_disc_deact_ntf_timeout_cback
898 **
899 ** Description Timeout while waiting for deactivation NTF
900 **
901 ** Returns void
902 **
903 *******************************************************************************/
nfa_dm_disc_deact_ntf_timeout_cback(TIMER_LIST_ENT * p_tle)904 static void nfa_dm_disc_deact_ntf_timeout_cback (TIMER_LIST_ENT *p_tle)
905 {
906 NFA_TRACE_ERROR0 ("nfa_dm_disc_deact_ntf_timeout_cback()");
907
908 nfa_dm_disc_force_to_idle();
909 }
910
911 /*******************************************************************************
912 **
913 ** Function nfa_dm_send_deactivate_cmd
914 **
915 ** Description Send deactivate command to NFCC, if needed.
916 **
917 ** Returns NFC_STATUS_OK - deactivate cmd is sent
918 ** NCI_STATUS_FAILED - no buffers
919 ** NFC_STATUS_SEMANTIC_ERROR - this function does not attempt
920 ** to send deactivate cmd
921 **
922 *******************************************************************************/
nfa_dm_send_deactivate_cmd(tNFC_DEACT_TYPE deactivate_type)923 static tNFC_STATUS nfa_dm_send_deactivate_cmd (tNFC_DEACT_TYPE deactivate_type)
924 {
925 tNFC_STATUS status = NFC_STATUS_SEMANTIC_ERROR;
926 tNFA_DM_DISC_FLAGS w4_flags = nfa_dm_cb.disc_cb.disc_flags & (NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF);
927
928 if (!w4_flags)
929 {
930 /* if deactivate CMD was not sent to NFCC */
931 nfa_dm_cb.disc_cb.disc_flags |= (NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF);
932
933 status = NFC_Deactivate (deactivate_type);
934
935 if (!nfa_dm_cb.disc_cb.tle.in_use)
936 {
937 nfa_dm_cb.disc_cb.tle.p_cback = (TIMER_CBACK *)nfa_dm_disc_deact_ntf_timeout_cback;
938 nfa_sys_start_timer (&nfa_dm_cb.disc_cb.tle, 0, NFA_DM_DISC_TIMEOUT_W4_DEACT_NTF);
939 }
940 }
941 else
942 {
943 if (deactivate_type == NFC_DEACTIVATE_TYPE_SLEEP)
944 {
945 status = NFC_STATUS_SEMANTIC_ERROR;
946 }
947 else if (nfa_dm_cb.disc_cb.tle.in_use)
948 {
949 status = NFC_STATUS_OK;
950 }
951 else
952 {
953 status = nfa_dm_disc_force_to_idle ();
954 }
955 }
956
957 return status;
958 }
959
960 /*******************************************************************************
961 **
962 ** Function nfa_dm_start_rf_discover
963 **
964 ** Description Start RF discovery
965 **
966 ** Returns void
967 **
968 *******************************************************************************/
nfa_dm_start_rf_discover(void)969 void nfa_dm_start_rf_discover (void)
970 {
971 tNFC_DISCOVER_PARAMS disc_params[NFA_DM_MAX_DISC_PARAMS];
972 tNFA_DM_DISC_TECH_PROTO_MASK dm_disc_mask = 0, poll_mask, listen_mask;
973 UINT8 num_params, xx;
974
975 NFA_TRACE_DEBUG0 ("nfa_dm_start_rf_discover ()");
976 /* Make sure that RF discovery was enabled, or some app has exclusive control */
977 if ( (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED))
978 &&(nfa_dm_cb.disc_cb.excl_disc_entry.in_use == FALSE) )
979 {
980 return;
981 }
982
983 /* get listen mode routing table for technology */
984 nfa_ee_get_tech_route (NFA_EE_PWR_STATE_ON, nfa_dm_cb.disc_cb.listen_RT);
985
986 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use)
987 {
988 nfa_dm_set_rf_listen_mode_raw_config (&dm_disc_mask);
989 dm_disc_mask |= (nfa_dm_cb.disc_cb.excl_disc_entry.requested_disc_mask & NFA_DM_DISC_MASK_POLL);
990 nfa_dm_cb.disc_cb.excl_disc_entry.selected_disc_mask = dm_disc_mask;
991 }
992 else
993 {
994 /* Collect RF discovery request from sub-modules */
995 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++)
996 {
997 if (nfa_dm_cb.disc_cb.entry[xx].in_use)
998 {
999 poll_mask = (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask & NFA_DM_DISC_MASK_POLL);
1000
1001 /* clear poll mode technolgies and protocols which are already used by others */
1002 poll_mask &= ~(dm_disc_mask & NFA_DM_DISC_MASK_POLL);
1003
1004 listen_mask = 0;
1005
1006 /*
1007 ** add listen mode technolgies and protocols if host ID is matched to listen mode routing table
1008 */
1009
1010 /* NFC-A */
1011 if (nfa_dm_cb.disc_cb.entry[xx].host_id == nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A])
1012 {
1013 listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask
1014 & ( NFA_DM_DISC_MASK_LA_T1T
1015 |NFA_DM_DISC_MASK_LA_T2T
1016 |NFA_DM_DISC_MASK_LA_ISO_DEP
1017 |NFA_DM_DISC_MASK_LA_NFC_DEP
1018 |NFA_DM_DISC_MASK_LAA_NFC_DEP );
1019 }
1020 else
1021 {
1022 /* host can listen ISO-DEP based on AID routing */
1023 listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask & NFA_DM_DISC_MASK_LA_ISO_DEP);
1024
1025 /* host can listen NFC-DEP based on protocol routing */
1026 listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask & NFA_DM_DISC_MASK_LA_NFC_DEP);
1027 listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask & NFA_DM_DISC_MASK_LAA_NFC_DEP);
1028 }
1029
1030 /* NFC-B */
1031 /* multiple hosts can listen ISO-DEP based on AID routing */
1032 listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask
1033 & NFA_DM_DISC_MASK_LB_ISO_DEP;
1034
1035 /* NFC-F */
1036 /* NFCC can support NFC-DEP and T3T listening based on NFCID routing regardless of NFC-F tech routing */
1037 listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask
1038 & ( NFA_DM_DISC_MASK_LF_T3T
1039 |NFA_DM_DISC_MASK_LF_NFC_DEP
1040 |NFA_DM_DISC_MASK_LFA_NFC_DEP );
1041
1042 /* NFC-B Prime */
1043 if (nfa_dm_cb.disc_cb.entry[xx].host_id == nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_BP])
1044 {
1045 listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask
1046 & NFA_DM_DISC_MASK_L_B_PRIME;
1047 }
1048
1049 /*
1050 ** clear listen mode technolgies and protocols which are already used by others
1051 */
1052
1053 /* Check if other modules are listening T1T or T2T */
1054 if (dm_disc_mask & (NFA_DM_DISC_MASK_LA_T1T|NFA_DM_DISC_MASK_LA_T2T))
1055 {
1056 listen_mask &= ~( NFA_DM_DISC_MASK_LA_T1T
1057 |NFA_DM_DISC_MASK_LA_T2T
1058 |NFA_DM_DISC_MASK_LA_ISO_DEP
1059 |NFA_DM_DISC_MASK_LA_NFC_DEP );
1060 }
1061
1062 /* T1T/T2T has priority on NFC-A */
1063 if ( (dm_disc_mask & (NFA_DM_DISC_MASK_LA_ISO_DEP|NFA_DM_DISC_MASK_LA_NFC_DEP))
1064 &&(listen_mask & (NFA_DM_DISC_MASK_LA_T1T|NFA_DM_DISC_MASK_LA_T2T)))
1065 {
1066 dm_disc_mask &= ~( NFA_DM_DISC_MASK_LA_ISO_DEP
1067 |NFA_DM_DISC_MASK_LA_NFC_DEP );
1068 }
1069
1070 /* Don't remove ISO-DEP because multiple hosts can listen ISO-DEP based on AID routing */
1071
1072 /* Check if other modules are listening NFC-DEP */
1073 if (dm_disc_mask & (NFA_DM_DISC_MASK_LA_NFC_DEP | NFA_DM_DISC_MASK_LAA_NFC_DEP))
1074 {
1075 listen_mask &= ~( NFA_DM_DISC_MASK_LA_NFC_DEP
1076 |NFA_DM_DISC_MASK_LAA_NFC_DEP );
1077 }
1078
1079 nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask = poll_mask | listen_mask;
1080
1081 NFA_TRACE_DEBUG2 ("nfa_dm_cb.disc_cb.entry[%d].selected_disc_mask = 0x%x",
1082 xx, nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask);
1083
1084 dm_disc_mask |= nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask;
1085 }
1086 }
1087
1088 /* Let P2P set GEN bytes for LLCP to NFCC */
1089 if (dm_disc_mask & NFA_DM_DISC_MASK_NFC_DEP)
1090 {
1091 nfa_p2p_set_config (dm_disc_mask);
1092 }
1093 }
1094
1095 NFA_TRACE_DEBUG1 ("dm_disc_mask = 0x%x", dm_disc_mask);
1096
1097 /* Get Discovery Technology parameters */
1098 num_params = nfa_dm_get_rf_discover_config (dm_disc_mask, disc_params, NFA_DM_MAX_DISC_PARAMS);
1099
1100 if (num_params)
1101 {
1102 /*
1103 ** NFCC will abort programming personality slots if not available.
1104 ** NFCC programs the personality slots in the following order of RF technologies:
1105 ** NFC-A, NFC-B, NFC-BP, NFC-I93
1106 */
1107
1108 /* if this is not for exclusive control */
1109 if (!nfa_dm_cb.disc_cb.excl_disc_entry.in_use)
1110 {
1111 /* update listening protocols in each NFC technology */
1112 nfa_dm_set_rf_listen_mode_config (dm_disc_mask);
1113 }
1114
1115 /* Set polling duty cycle */
1116 nfa_dm_set_total_duration ();
1117 nfa_dm_cb.disc_cb.dm_disc_mask = dm_disc_mask;
1118
1119 NFC_DiscoveryStart (num_params, disc_params, nfa_dm_disc_discovery_cback);
1120 /* set flag about waiting for response in IDLE state */
1121 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP;
1122
1123 /* register callback to get interface error NTF */
1124 NFC_SetStaticRfCback (nfa_dm_disc_data_cback);
1125 }
1126 else
1127 {
1128 /* RF discovery is started but there is no valid technology or protocol to discover */
1129 nfa_dm_disc_notify_started (NFA_STATUS_OK);
1130 }
1131
1132 /* if Kovio presence check timer is running, timeout callback will reset the activation information */
1133 if ( (nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_KOVIO)
1134 ||(!nfa_dm_cb.disc_cb.kovio_tle.in_use) )
1135 {
1136 /* reset protocol and hanlde of activated sub-module */
1137 nfa_dm_cb.disc_cb.activated_protocol = NFA_PROTOCOL_INVALID;
1138 nfa_dm_cb.disc_cb.activated_handle = NFA_HANDLE_INVALID;
1139 }
1140 }
1141
1142 /*******************************************************************************
1143 **
1144 ** Function nfa_dm_notify_discovery
1145 **
1146 ** Description Send RF discovery notification to upper layer
1147 **
1148 ** Returns void
1149 **
1150 *******************************************************************************/
nfa_dm_notify_discovery(tNFA_DM_RF_DISC_DATA * p_data)1151 static void nfa_dm_notify_discovery (tNFA_DM_RF_DISC_DATA *p_data)
1152 {
1153 tNFA_CONN_EVT_DATA conn_evt;
1154
1155 /* let application select a device */
1156 conn_evt.disc_result.status = NFA_STATUS_OK;
1157 memcpy (&(conn_evt.disc_result.discovery_ntf),
1158 &(p_data->nfc_discover.result),
1159 sizeof (tNFC_RESULT_DEVT));
1160
1161 nfa_dm_conn_cback_event_notify (NFA_DISC_RESULT_EVT, &conn_evt);
1162 }
1163
1164
1165 /*******************************************************************************
1166 **
1167 ** Function nfa_dm_disc_handle_kovio_activation
1168 **
1169 ** Description Handle Kovio activation; whether it's new or repeated activation
1170 **
1171 ** Returns TRUE if repeated activation. No need to notify activated event to upper layer
1172 **
1173 *******************************************************************************/
nfa_dm_disc_handle_kovio_activation(tNFC_DISCOVER * p_data,tNFA_DISCOVER_CBACK * p_disc_cback)1174 BOOLEAN nfa_dm_disc_handle_kovio_activation (tNFC_DISCOVER *p_data, tNFA_DISCOVER_CBACK *p_disc_cback)
1175 {
1176 tNFC_DISCOVER disc_data;
1177
1178 if (nfa_dm_cb.disc_cb.kovio_tle.in_use)
1179 {
1180 /* if this is new Kovio bar code tag */
1181 if ( (nfa_dm_cb.activated_nfcid_len != p_data->activate.rf_tech_param.param.pk.uid_len)
1182 ||(memcmp (p_data->activate.rf_tech_param.param.pk.uid,
1183 nfa_dm_cb.activated_nfcid, nfa_dm_cb.activated_nfcid_len)))
1184 {
1185 NFA_TRACE_DEBUG0 ("new Kovio tag is detected");
1186
1187 /* notify presence check failure for previous tag, if presence check is pending */
1188 nfa_dm_disc_report_kovio_presence_check (NFA_STATUS_FAILED);
1189
1190 /* notify deactivation of previous activation before notifying new activation */
1191 if (p_disc_cback)
1192 {
1193 disc_data.deactivate.type = NFA_DEACTIVATE_TYPE_IDLE;
1194 (*(p_disc_cback)) (NFA_DM_RF_DISC_DEACTIVATED_EVT, &disc_data);
1195 }
1196
1197 /* restart timer */
1198 nfa_sys_start_timer (&nfa_dm_cb.disc_cb.kovio_tle, 0, NFA_DM_DISC_TIMEOUT_KOVIO_PRESENCE_CHECK);
1199 }
1200 else
1201 {
1202 /* notify presence check ok, if presence check is pending */
1203 nfa_dm_disc_report_kovio_presence_check (NFC_STATUS_OK);
1204
1205 /* restart timer and do not notify upper layer */
1206 nfa_sys_start_timer (&nfa_dm_cb.disc_cb.kovio_tle, 0, NFA_DM_DISC_TIMEOUT_KOVIO_PRESENCE_CHECK);
1207 return (TRUE);
1208 }
1209 }
1210 else
1211 {
1212 /* this is the first activation, so start timer and notify upper layer */
1213 nfa_dm_cb.disc_cb.kovio_tle.p_cback = (TIMER_CBACK *)nfa_dm_disc_kovio_timeout_cback;
1214 nfa_sys_start_timer (&nfa_dm_cb.disc_cb.kovio_tle, 0, NFA_DM_DISC_TIMEOUT_KOVIO_PRESENCE_CHECK);
1215 }
1216
1217 return (FALSE);
1218 }
1219
1220 /*******************************************************************************
1221 **
1222 ** Function nfa_dm_disc_notify_activation
1223 **
1224 ** Description Send RF activation notification to sub-module
1225 **
1226 ** Returns NFA_STATUS_OK if success
1227 **
1228 *******************************************************************************/
nfa_dm_disc_notify_activation(tNFC_DISCOVER * p_data)1229 static tNFA_STATUS nfa_dm_disc_notify_activation (tNFC_DISCOVER *p_data)
1230 {
1231 UINT8 xx, host_id_in_LRT;
1232 UINT8 iso_dep_t3t__listen = NFA_DM_DISC_NUM_ENTRIES;
1233
1234 tNFC_RF_TECH_N_MODE tech_n_mode = p_data->activate.rf_tech_param.mode;
1235 tNFC_PROTOCOL protocol = p_data->activate.protocol;
1236
1237 tNFA_DM_DISC_TECH_PROTO_MASK activated_disc_mask;
1238
1239 NFA_TRACE_DEBUG2 ("nfa_dm_disc_notify_activation (): tech_n_mode:0x%X, proto:0x%X",
1240 tech_n_mode, protocol);
1241
1242 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use)
1243 {
1244 nfa_dm_cb.disc_cb.activated_tech_mode = tech_n_mode;
1245 nfa_dm_cb.disc_cb.activated_rf_disc_id = p_data->activate.rf_disc_id;
1246 nfa_dm_cb.disc_cb.activated_rf_interface = p_data->activate.intf_param.type;
1247 nfa_dm_cb.disc_cb.activated_protocol = protocol;
1248 nfa_dm_cb.disc_cb.activated_handle = NFA_HANDLE_INVALID;
1249
1250 if (protocol == NFC_PROTOCOL_KOVIO)
1251 {
1252 /* check whether it's new or repeated activation */
1253 if (nfa_dm_disc_handle_kovio_activation (p_data, nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback))
1254 {
1255 /* do not notify activation of Kovio to upper layer */
1256 return (NFA_STATUS_OK);
1257 }
1258 }
1259
1260 if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)
1261 (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data);
1262
1263 return (NFA_STATUS_OK);
1264 }
1265
1266 /* if this is NFCEE direct RF interface, notify activation to whoever listening UICC */
1267 if (p_data->activate.intf_param.type == NFC_INTERFACE_EE_DIRECT_RF)
1268 {
1269 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++)
1270 {
1271 if ( (nfa_dm_cb.disc_cb.entry[xx].in_use)
1272 &&(nfa_dm_cb.disc_cb.entry[xx].host_id != NFA_DM_DISC_HOST_ID_DH))
1273 {
1274 nfa_dm_cb.disc_cb.activated_rf_disc_id = p_data->activate.rf_disc_id;
1275 nfa_dm_cb.disc_cb.activated_rf_interface = p_data->activate.intf_param.type;
1276 nfa_dm_cb.disc_cb.activated_protocol = NFC_PROTOCOL_UNKNOWN;
1277 nfa_dm_cb.disc_cb.activated_handle = xx;
1278
1279 NFA_TRACE_DEBUG2 ("activated_rf_interface:0x%x, activated_handle: 0x%x",
1280 nfa_dm_cb.disc_cb.activated_rf_interface,
1281 nfa_dm_cb.disc_cb.activated_handle);
1282
1283 if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)
1284 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data);
1285
1286 return (NFA_STATUS_OK);
1287 }
1288 }
1289 return (NFA_STATUS_FAILED);
1290 }
1291
1292 /* get bit mask of technolgies/mode and protocol */
1293 activated_disc_mask = nfa_dm_disc_get_disc_mask (tech_n_mode, protocol);
1294
1295 /* get host ID of technology from listen mode routing table */
1296 if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_A)
1297 {
1298 host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A];
1299 }
1300 else if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_B)
1301 {
1302 host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_B];
1303 }
1304 else if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_F)
1305 {
1306 host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_F];
1307 }
1308 else if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_B_PRIME)
1309 {
1310 host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_BP];
1311 }
1312 else /* DH only */
1313 {
1314 host_id_in_LRT = NFA_DM_DISC_HOST_ID_DH;
1315 }
1316
1317 if (protocol == NFC_PROTOCOL_NFC_DEP)
1318 {
1319 /* Force NFC-DEP to the host */
1320 host_id_in_LRT = NFA_DM_DISC_HOST_ID_DH;
1321 }
1322
1323 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++)
1324 {
1325 /* if any matching NFC technology and protocol */
1326 if (nfa_dm_cb.disc_cb.entry[xx].in_use)
1327 {
1328 if (nfa_dm_cb.disc_cb.entry[xx].host_id == host_id_in_LRT)
1329 {
1330 if (nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & activated_disc_mask)
1331 break;
1332 }
1333 else
1334 {
1335 /* check ISO-DEP listening even if host in LRT is not matched */
1336 if (protocol == NFC_PROTOCOL_ISO_DEP)
1337 {
1338 if ( (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_A)
1339 &&(nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & NFA_DM_DISC_MASK_LA_ISO_DEP))
1340 {
1341 iso_dep_t3t__listen = xx;
1342 }
1343 else if ( (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_B)
1344 &&(nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & NFA_DM_DISC_MASK_LB_ISO_DEP))
1345 {
1346 iso_dep_t3t__listen = xx;
1347 }
1348 }
1349 /* check T3T listening even if host in LRT is not matched */
1350 else if (protocol == NFC_PROTOCOL_T3T)
1351 {
1352 if ( (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_F)
1353 &&(nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & NFA_DM_DISC_MASK_LF_T3T))
1354 {
1355 iso_dep_t3t__listen = xx;
1356 }
1357 }
1358 }
1359 }
1360 }
1361
1362 if (xx >= NFA_DM_DISC_NUM_ENTRIES)
1363 {
1364 /* if any ISO-DEP or T3T listening even if host in LRT is not matched */
1365 xx = iso_dep_t3t__listen;
1366 }
1367
1368 if (xx < NFA_DM_DISC_NUM_ENTRIES)
1369 {
1370 nfa_dm_cb.disc_cb.activated_tech_mode = tech_n_mode;
1371 nfa_dm_cb.disc_cb.activated_rf_disc_id = p_data->activate.rf_disc_id;
1372 nfa_dm_cb.disc_cb.activated_rf_interface = p_data->activate.intf_param.type;
1373 nfa_dm_cb.disc_cb.activated_protocol = protocol;
1374 nfa_dm_cb.disc_cb.activated_handle = xx;
1375
1376 NFA_TRACE_DEBUG2 ("activated_protocol:0x%x, activated_handle: 0x%x",
1377 nfa_dm_cb.disc_cb.activated_protocol,
1378 nfa_dm_cb.disc_cb.activated_handle);
1379
1380 if (protocol == NFC_PROTOCOL_KOVIO)
1381 {
1382 /* check whether it's new or repeated activation */
1383 if (nfa_dm_disc_handle_kovio_activation (p_data, nfa_dm_cb.disc_cb.entry[xx].p_disc_cback))
1384 {
1385 /* do not notify activation of Kovio to upper layer */
1386 return (NFA_STATUS_OK);
1387 }
1388 }
1389
1390 if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)
1391 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data);
1392
1393 return (NFA_STATUS_OK);
1394 }
1395 else
1396 {
1397 nfa_dm_cb.disc_cb.activated_protocol = NFA_PROTOCOL_INVALID;
1398 nfa_dm_cb.disc_cb.activated_handle = NFA_HANDLE_INVALID;
1399 return (NFA_STATUS_FAILED);
1400 }
1401 }
1402
1403 /*******************************************************************************
1404 **
1405 ** Function nfa_dm_disc_notify_deactivation
1406 **
1407 ** Description Send deactivation notification to sub-module
1408 **
1409 ** Returns None
1410 **
1411 *******************************************************************************/
nfa_dm_disc_notify_deactivation(tNFA_DM_RF_DISC_SM_EVENT sm_event,tNFC_DISCOVER * p_data)1412 static void nfa_dm_disc_notify_deactivation (tNFA_DM_RF_DISC_SM_EVENT sm_event,
1413 tNFC_DISCOVER *p_data)
1414 {
1415 tNFA_HANDLE xx;
1416 tNFA_CONN_EVT_DATA evt_data;
1417 tNFC_DISCOVER disc_data;
1418
1419 NFA_TRACE_DEBUG1 ("nfa_dm_disc_notify_deactivation (): activated_handle=%d",
1420 nfa_dm_cb.disc_cb.activated_handle);
1421
1422 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING)
1423 {
1424 NFA_TRACE_DEBUG0 ("nfa_dm_disc_notify_deactivation (): for sleep wakeup");
1425 return;
1426 }
1427
1428 if (sm_event == NFA_DM_RF_DEACTIVATE_RSP)
1429 {
1430 /*
1431 ** Activation has been aborted by upper layer in NFA_DM_RFST_W4_ALL_DISCOVERIES or NFA_DM_RFST_W4_HOST_SELECT
1432 ** Deactivation by upper layer or RF link loss in NFA_DM_RFST_LISTEN_SLEEP
1433 ** No sub-module is activated at this state.
1434 */
1435
1436 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_SLEEP)
1437 {
1438 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use)
1439 {
1440 if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)
1441 {
1442 disc_data.deactivate.type = NFA_DEACTIVATE_TYPE_IDLE;
1443 (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (NFA_DM_RF_DISC_DEACTIVATED_EVT, &disc_data);
1444 }
1445 }
1446 else
1447 {
1448 /* let each sub-module handle deactivation */
1449 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++)
1450 {
1451 if ( (nfa_dm_cb.disc_cb.entry[xx].in_use)
1452 &&(nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & NFA_DM_DISC_MASK_LISTEN) )
1453 {
1454 disc_data.deactivate.type = NFA_DEACTIVATE_TYPE_IDLE;
1455 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_DEACTIVATED_EVT, &disc_data);
1456 }
1457 }
1458 }
1459 }
1460 else if ( (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_STOPPING))
1461 ||(nfa_dm_cb.disc_cb.deact_notify_pending) )
1462 {
1463 xx = nfa_dm_cb.disc_cb.activated_handle;
1464
1465 /* notify event to activated module if failed while reactivation */
1466 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use)
1467 {
1468 if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)
1469 {
1470 disc_data.deactivate.type = NFA_DEACTIVATE_TYPE_IDLE;
1471 (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (NFA_DM_RF_DISC_DEACTIVATED_EVT, p_data);
1472 }
1473 }
1474 else if ( (xx < NFA_DM_DISC_NUM_ENTRIES)
1475 &&(nfa_dm_cb.disc_cb.entry[xx].in_use)
1476 &&(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback) )
1477 {
1478 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_DEACTIVATED_EVT, p_data);
1479 }
1480 else
1481 {
1482 /* notify deactivation to application if there is no activated module */
1483 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE;
1484 nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data);
1485 }
1486 }
1487 }
1488 else
1489 {
1490 if (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_KOVIO)
1491 {
1492 if (nfa_dm_cb.disc_cb.kovio_tle.in_use)
1493 {
1494 /* restart timer and do not notify upper layer */
1495 nfa_sys_start_timer (&nfa_dm_cb.disc_cb.kovio_tle, 0, NFA_DM_DISC_TIMEOUT_KOVIO_PRESENCE_CHECK);
1496 return;
1497 }
1498 /* Otherwise, upper layer initiated deactivation. */
1499 }
1500
1501 /* notify event to activated module */
1502 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use)
1503 {
1504 if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)
1505 {
1506 disc_data.deactivate.type = NFA_DEACTIVATE_TYPE_IDLE;
1507 (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (NFA_DM_RF_DISC_DEACTIVATED_EVT, p_data);
1508 }
1509 }
1510 else
1511 {
1512 xx = nfa_dm_cb.disc_cb.activated_handle;
1513
1514 if ((xx < NFA_DM_DISC_NUM_ENTRIES) && (nfa_dm_cb.disc_cb.entry[xx].in_use))
1515 {
1516 if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)
1517 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_DEACTIVATED_EVT, p_data);
1518 }
1519 }
1520 }
1521
1522 /* clear activated information */
1523 nfa_dm_cb.disc_cb.activated_tech_mode = 0;
1524 nfa_dm_cb.disc_cb.activated_rf_disc_id = 0;
1525 nfa_dm_cb.disc_cb.activated_rf_interface = 0;
1526 nfa_dm_cb.disc_cb.activated_protocol = NFA_PROTOCOL_INVALID;
1527 nfa_dm_cb.disc_cb.activated_handle = NFA_HANDLE_INVALID;
1528 nfa_dm_cb.disc_cb.deact_notify_pending = FALSE;
1529 }
1530
1531 /*******************************************************************************
1532 **
1533 ** Function nfa_dm_disc_sleep_wakeup
1534 **
1535 ** Description Put tag to sleep, then wake it up. Can be used Perform
1536 ** legacy presence check or to wake up tag that went to HALT
1537 ** state
1538 **
1539 ** Returns TRUE if operation started
1540 **
1541 *******************************************************************************/
nfa_dm_disc_sleep_wakeup(void)1542 tNFC_STATUS nfa_dm_disc_sleep_wakeup (void)
1543 {
1544 tNFC_STATUS status = NFC_STATUS_FAILED;
1545
1546 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE)
1547 {
1548 /* Deactivate to sleep mode */
1549 status = nfa_dm_send_deactivate_cmd(NFC_DEACTIVATE_TYPE_SLEEP);
1550 if (status == NFC_STATUS_OK)
1551 {
1552 /* deactivate to sleep is sent on behalf of sleep wakeup.
1553 * set the sleep wakeup information in control block */
1554 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_CHECKING;
1555 nfa_dm_cb.disc_cb.deact_pending = FALSE;
1556 }
1557 }
1558
1559 return (status);
1560 }
1561
1562 /*******************************************************************************
1563 **
1564 ** Function nfa_dm_is_raw_frame_session
1565 **
1566 ** Description If NFA_SendRawFrame is called since RF activation,
1567 ** this function returns TRUE.
1568 **
1569 ** Returns TRUE if NFA_SendRawFrame is called
1570 **
1571 *******************************************************************************/
nfa_dm_is_raw_frame_session(void)1572 BOOLEAN nfa_dm_is_raw_frame_session (void)
1573 {
1574 return ((nfa_dm_cb.flags & NFA_DM_FLAGS_RAW_FRAME) ? TRUE : FALSE);
1575 }
1576
1577 /*******************************************************************************
1578 **
1579 ** Function nfa_dm_is_p2p_paused
1580 **
1581 ** Description If NFA_PauseP2p is called sand still effective,
1582 ** this function returns TRUE.
1583 **
1584 ** Returns TRUE if NFA_SendRawFrame is called
1585 **
1586 *******************************************************************************/
nfa_dm_is_p2p_paused(void)1587 BOOLEAN nfa_dm_is_p2p_paused (void)
1588 {
1589 return ((nfa_dm_cb.flags & NFA_DM_FLAGS_P2P_PAUSED) ? TRUE : FALSE);
1590 }
1591
1592 /*******************************************************************************
1593 **
1594 ** Function nfa_dm_disc_end_sleep_wakeup
1595 **
1596 ** Description Sleep Wakeup is complete
1597 **
1598 ** Returns None
1599 **
1600 *******************************************************************************/
nfa_dm_disc_end_sleep_wakeup(tNFC_STATUS status)1601 static void nfa_dm_disc_end_sleep_wakeup (tNFC_STATUS status)
1602 {
1603 if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_KOVIO)
1604 &&(nfa_dm_cb.disc_cb.kovio_tle.in_use) )
1605 {
1606 /* ignore it while doing Kovio presence check */
1607 return;
1608 }
1609
1610 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING)
1611 {
1612 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_CHECKING;
1613
1614 /* notify RW module that sleep wakeup is finished */
1615 nfa_rw_handle_sleep_wakeup_rsp (status);
1616
1617 if (nfa_dm_cb.disc_cb.deact_pending)
1618 {
1619 nfa_dm_cb.disc_cb.deact_pending = FALSE;
1620 /* Perform pending deactivate command and on response notfiy deactivation */
1621 nfa_dm_cb.disc_cb.deact_notify_pending = TRUE;
1622 nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD,
1623 (tNFA_DM_RF_DISC_DATA *) &nfa_dm_cb.disc_cb.pending_deact_type);
1624 }
1625 }
1626 }
1627
1628 /*******************************************************************************
1629 **
1630 ** Function nfa_dm_disc_kovio_timeout_cback
1631 **
1632 ** Description Timeout for Kovio bar code tag presence check
1633 **
1634 ** Returns void
1635 **
1636 *******************************************************************************/
nfa_dm_disc_kovio_timeout_cback(TIMER_LIST_ENT * p_tle)1637 static void nfa_dm_disc_kovio_timeout_cback (TIMER_LIST_ENT *p_tle)
1638 {
1639 tNFC_DEACTIVATE_DEVT deact;
1640
1641 NFA_TRACE_DEBUG0 ("nfa_dm_disc_kovio_timeout_cback()");
1642
1643 /* notify presence check failure, if presence check is pending */
1644 nfa_dm_disc_report_kovio_presence_check (NFC_STATUS_FAILED);
1645
1646 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE)
1647 {
1648 /* restart timer in case that upper layer's presence check interval is too long */
1649 nfa_sys_start_timer (&nfa_dm_cb.disc_cb.kovio_tle, 0, NFA_DM_DISC_TIMEOUT_KOVIO_PRESENCE_CHECK);
1650 }
1651 else
1652 {
1653 /* notify upper layer deactivated event */
1654 deact.status = NFC_STATUS_OK;
1655 deact.type = NFC_DEACTIVATE_TYPE_DISCOVERY;
1656 deact.is_ntf = TRUE;
1657 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, (tNFC_DISCOVER*)&deact);
1658 }
1659 }
1660
1661 /*******************************************************************************
1662 **
1663 ** Function nfa_dm_disc_start_kovio_presence_check
1664 **
1665 ** Description Deactivate to discovery mode and wait for activation
1666 **
1667 ** Returns TRUE if operation started
1668 **
1669 *******************************************************************************/
nfa_dm_disc_start_kovio_presence_check(void)1670 tNFC_STATUS nfa_dm_disc_start_kovio_presence_check (void)
1671 {
1672 tNFC_STATUS status = NFC_STATUS_FAILED;
1673
1674 NFA_TRACE_DEBUG0 ("nfa_dm_disc_start_kovio_presence_check ()");
1675
1676 if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_KOVIO)
1677 &&(nfa_dm_cb.disc_cb.kovio_tle.in_use) )
1678 {
1679 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE)
1680 {
1681 /* restart timer */
1682 nfa_sys_start_timer (&nfa_dm_cb.disc_cb.kovio_tle, 0, NFA_DM_DISC_TIMEOUT_KOVIO_PRESENCE_CHECK);
1683
1684 /* Deactivate to discovery mode */
1685 status = nfa_dm_send_deactivate_cmd (NFC_DEACTIVATE_TYPE_DISCOVERY);
1686
1687 if (status == NFC_STATUS_OK)
1688 {
1689 /* deactivate to sleep is sent on behalf of sleep wakeup.
1690 * set the sleep wakeup information in control block */
1691 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_CHECKING;
1692 nfa_dm_cb.disc_cb.deact_pending = FALSE;
1693 }
1694 }
1695 else
1696 {
1697 /* wait for next activation */
1698 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_CHECKING;
1699 nfa_dm_cb.disc_cb.deact_pending = FALSE;
1700 status = NFC_STATUS_OK;
1701 }
1702 }
1703
1704 return (status);
1705 }
1706
1707 /*******************************************************************************
1708 **
1709 ** Function nfa_dm_disc_report_kovio_presence_check
1710 **
1711 ** Description Report Kovio presence check status
1712 **
1713 ** Returns None
1714 **
1715 *******************************************************************************/
nfa_dm_disc_report_kovio_presence_check(tNFC_STATUS status)1716 static void nfa_dm_disc_report_kovio_presence_check (tNFC_STATUS status)
1717 {
1718 NFA_TRACE_DEBUG0 ("nfa_dm_disc_report_kovio_presence_check ()");
1719
1720 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING)
1721 {
1722 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_CHECKING;
1723
1724 /* notify RW module that sleep wakeup is finished */
1725 nfa_rw_handle_presence_check_rsp (status);
1726
1727 if (nfa_dm_cb.disc_cb.deact_pending)
1728 {
1729 nfa_dm_cb.disc_cb.deact_pending = FALSE;
1730 nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD,
1731 (tNFA_DM_RF_DISC_DATA *) &nfa_dm_cb.disc_cb.pending_deact_type);
1732 }
1733 }
1734 }
1735
1736 /*******************************************************************************
1737 **
1738 ** Function nfa_dm_disc_data_cback
1739 **
1740 ** Description Monitoring interface error through data callback
1741 **
1742 ** Returns void
1743 **
1744 *******************************************************************************/
nfa_dm_disc_data_cback(UINT8 conn_id,tNFC_CONN_EVT event,tNFC_CONN * p_data)1745 static void nfa_dm_disc_data_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data)
1746 {
1747 NFA_TRACE_DEBUG0 ("nfa_dm_disc_data_cback ()");
1748
1749 /* if selection failed */
1750 if (event == NFC_ERROR_CEVT)
1751 {
1752 nfa_dm_disc_sm_execute (NFA_DM_CORE_INTF_ERROR_NTF, NULL);
1753 }
1754 else if (event == NFC_DATA_CEVT)
1755 {
1756 GKI_freebuf (p_data->data.p_data);
1757 }
1758 }
1759
1760 /*******************************************************************************
1761 **
1762 ** Function nfa_dm_disc_new_state
1763 **
1764 ** Description Processing discovery events in NFA_DM_RFST_IDLE state
1765 **
1766 ** Returns void
1767 **
1768 *******************************************************************************/
nfa_dm_disc_new_state(tNFA_DM_RF_DISC_STATE new_state)1769 void nfa_dm_disc_new_state (tNFA_DM_RF_DISC_STATE new_state)
1770 {
1771 tNFA_CONN_EVT_DATA evt_data;
1772 tNFA_DM_RF_DISC_STATE old_state = nfa_dm_cb.disc_cb.disc_state;
1773
1774 #if (BT_TRACE_VERBOSE == TRUE)
1775 NFA_TRACE_DEBUG5 ("nfa_dm_disc_new_state (): old_state: %s (%d), new_state: %s (%d) disc_flags: 0x%x",
1776 nfa_dm_disc_state_2_str (nfa_dm_cb.disc_cb.disc_state), nfa_dm_cb.disc_cb.disc_state,
1777 nfa_dm_disc_state_2_str (new_state), new_state, nfa_dm_cb.disc_cb.disc_flags);
1778 #else
1779 NFA_TRACE_DEBUG3 ("nfa_dm_disc_new_state(): old_state: %d, new_state: %d disc_flags: 0x%x",
1780 nfa_dm_cb.disc_cb.disc_state, new_state, nfa_dm_cb.disc_cb.disc_flags);
1781 #endif
1782
1783 nfa_dm_cb.disc_cb.disc_state = new_state;
1784
1785 if ( (new_state == NFA_DM_RFST_IDLE)
1786 &&(!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)) ) /* not error recovering */
1787 {
1788 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_STOPPING)
1789 {
1790 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_STOPPING;
1791
1792 /* if exclusive RF control is stopping */
1793 if (nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)
1794 {
1795 if (old_state > NFA_DM_RFST_DISCOVERY)
1796 {
1797 /* notify deactivation to application */
1798 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE;
1799 nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data);
1800 }
1801
1802 nfa_dm_rel_excl_rf_control_and_notify ();
1803 }
1804 else
1805 {
1806 evt_data.status = NFA_STATUS_OK;
1807 nfa_dm_conn_cback_event_notify (NFA_RF_DISCOVERY_STOPPED_EVT, &evt_data);
1808 }
1809 }
1810 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_DISABLING)
1811 {
1812 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_DISABLING;
1813 nfa_sys_check_disabled ();
1814 }
1815 }
1816 }
1817
1818 /*******************************************************************************
1819 **
1820 ** Function nfa_dm_disc_sm_idle
1821 **
1822 ** Description Processing discovery events in NFA_DM_RFST_IDLE state
1823 **
1824 ** Returns void
1825 **
1826 *******************************************************************************/
nfa_dm_disc_sm_idle(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)1827 static void nfa_dm_disc_sm_idle (tNFA_DM_RF_DISC_SM_EVENT event,
1828 tNFA_DM_RF_DISC_DATA *p_data)
1829 {
1830 UINT8 xx;
1831
1832 switch (event)
1833 {
1834 case NFA_DM_RF_DISCOVER_CMD:
1835 nfa_dm_start_rf_discover ();
1836 break;
1837
1838 case NFA_DM_RF_DISCOVER_RSP:
1839 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
1840
1841 if (p_data->nfc_discover.status == NFC_STATUS_OK)
1842 {
1843 nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY);
1844
1845 /* if RF discovery was stopped while waiting for response */
1846 if (nfa_dm_cb.disc_cb.disc_flags & (NFA_DM_DISC_FLAGS_STOPPING|NFA_DM_DISC_FLAGS_DISABLING))
1847 {
1848 /* stop discovery */
1849 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP;
1850 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
1851 break;
1852 }
1853
1854 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use)
1855 {
1856 if (nfa_dm_cb.disc_cb.excl_disc_entry.disc_flags & NFA_DM_DISC_FLAGS_NOTIFY)
1857 {
1858 nfa_dm_cb.disc_cb.excl_disc_entry.disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY;
1859
1860 if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)
1861 (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (NFA_DM_RF_DISC_START_EVT, (tNFC_DISCOVER*) p_data);
1862 }
1863 }
1864 else
1865 {
1866 /* notify event to each module which is waiting for start */
1867 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++)
1868 {
1869 /* if registered module is waiting for starting discovery */
1870 if ( (nfa_dm_cb.disc_cb.entry[xx].in_use)
1871 &&(nfa_dm_cb.disc_cb.dm_disc_mask & nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask)
1872 &&(nfa_dm_cb.disc_cb.entry[xx].disc_flags & NFA_DM_DISC_FLAGS_NOTIFY) )
1873 {
1874 nfa_dm_cb.disc_cb.entry[xx].disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY;
1875
1876 if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)
1877 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_START_EVT, (tNFC_DISCOVER*) p_data);
1878 }
1879 }
1880
1881 }
1882 nfa_dm_disc_notify_started (p_data->nfc_discover.status);
1883 }
1884 else
1885 {
1886 /* in rare case that the discovery states of NFCC and DH mismatch and NFCC rejects Discover Cmd
1887 * deactivate idle and then start disvocery when got deactivate rsp */
1888 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP;
1889 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
1890 }
1891 break;
1892
1893 case NFA_DM_RF_DEACTIVATE_RSP:
1894 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
1895
1896 /* if NFCC goes to idle successfully */
1897 if (p_data->nfc_discover.status == NFC_STATUS_OK)
1898 {
1899 /* if DH forced to go idle while waiting for deactivation NTF */
1900 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF))
1901 {
1902 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover));
1903
1904 /* check any pending flags like NFA_DM_DISC_FLAGS_STOPPING or NFA_DM_DISC_FLAGS_DISABLING */
1905 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
1906 /* check if need to restart discovery after resync discovery state with NFCC */
1907 nfa_dm_start_rf_discover ();
1908 }
1909 /* Otherwise, deactivating when getting unexpected activation */
1910 }
1911 /* Otherwise, wait for deactivation NTF */
1912 break;
1913
1914 case NFA_DM_RF_DEACTIVATE_NTF:
1915 /* if NFCC sent this after NFCC had rejected deactivate CMD to idle while deactivating */
1916 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF))
1917 {
1918 if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY)
1919 {
1920 /* stop discovery */
1921 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP;
1922 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
1923 }
1924 else
1925 {
1926 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover));
1927 /* check any pending flags like NFA_DM_DISC_FLAGS_STOPPING or NFA_DM_DISC_FLAGS_DISABLING */
1928 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
1929 /* check if need to restart discovery after resync discovery state with NFCC */
1930 nfa_dm_start_rf_discover ();
1931 }
1932 }
1933 /* Otherwise, deactivated when received unexpected activation in idle state */
1934 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF;
1935 break;
1936
1937 case NFA_DM_RF_INTF_ACTIVATED_NTF:
1938 /* unexpected activation, deactivate to idle */
1939 nfa_dm_cb.disc_cb.disc_flags |= (NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF);
1940 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
1941 break;
1942
1943 case NFA_DM_LP_LISTEN_CMD:
1944 nfa_dm_disc_new_state (NFA_DM_RFST_LP_LISTEN);
1945 break;
1946
1947 default:
1948 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_idle (): Unexpected discovery event");
1949 break;
1950 }
1951 }
1952
1953 /*******************************************************************************
1954 **
1955 ** Function nfa_dm_disc_sm_discovery
1956 **
1957 ** Description Processing discovery events in NFA_DM_RFST_DISCOVERY state
1958 **
1959 ** Returns void
1960 **
1961 *******************************************************************************/
nfa_dm_disc_sm_discovery(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)1962 static void nfa_dm_disc_sm_discovery (tNFA_DM_RF_DISC_SM_EVENT event,
1963 tNFA_DM_RF_DISC_DATA *p_data)
1964 {
1965 switch (event)
1966 {
1967 case NFA_DM_RF_DEACTIVATE_CMD:
1968 /* if deactivate CMD was not sent to NFCC */
1969 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP))
1970 {
1971 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP;
1972 NFC_Deactivate (p_data->deactivate_type);
1973 }
1974 break;
1975 case NFA_DM_RF_DEACTIVATE_RSP:
1976 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
1977
1978 /* if it's not race condition between deactivate CMD and activate NTF */
1979 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF))
1980 {
1981 /* do not notify deactivated to idle in RF discovery state
1982 ** because it is internal or stopping RF discovery
1983 */
1984
1985 /* there was no activation while waiting for deactivation RSP */
1986 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
1987 nfa_dm_start_rf_discover ();
1988 }
1989 break;
1990 case NFA_DM_RF_DISCOVER_NTF:
1991 nfa_dm_disc_new_state (NFA_DM_RFST_W4_ALL_DISCOVERIES);
1992 nfa_dm_notify_discovery (p_data);
1993 break;
1994 case NFA_DM_RF_INTF_ACTIVATED_NTF:
1995 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)
1996 {
1997 NFA_TRACE_DEBUG0 ("RF Activated while waiting for deactivation RSP");
1998 /* it's race condition. DH has to wait for deactivation NTF */
1999 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_NTF;
2000 }
2001 else
2002 {
2003 if (p_data->nfc_discover.activate.intf_param.type == NFC_INTERFACE_EE_DIRECT_RF)
2004 {
2005 nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_ACTIVE);
2006 }
2007 else if (p_data->nfc_discover.activate.rf_tech_param.mode & 0x80)
2008 {
2009 /* Listen mode */
2010 nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_ACTIVE);
2011 }
2012 else
2013 {
2014 /* Poll mode */
2015 nfa_dm_disc_new_state (NFA_DM_RFST_POLL_ACTIVE);
2016 }
2017
2018 if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED)
2019 {
2020 NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf");
2021
2022 /* after receiving deactivate event, restart discovery */
2023 nfa_dm_cb.disc_cb.disc_flags |= (NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF);
2024 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
2025 }
2026 }
2027 break;
2028
2029 case NFA_DM_RF_DEACTIVATE_NTF:
2030 /* if there was race condition between deactivate CMD and activate NTF */
2031 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF)
2032 {
2033 /* race condition is resolved */
2034 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF;
2035
2036 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP))
2037 {
2038 /* do not notify deactivated to idle in RF discovery state
2039 ** because it is internal or stopping RF discovery
2040 */
2041
2042 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
2043 nfa_dm_start_rf_discover ();
2044 }
2045 }
2046 break;
2047 case NFA_DM_LP_LISTEN_CMD:
2048 break;
2049 case NFA_DM_CORE_INTF_ERROR_NTF:
2050 break;
2051 default:
2052 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_discovery (): Unexpected discovery event");
2053 break;
2054 }
2055 }
2056
2057 /*******************************************************************************
2058 **
2059 ** Function nfa_dm_disc_sm_w4_all_discoveries
2060 **
2061 ** Description Processing discovery events in NFA_DM_RFST_W4_ALL_DISCOVERIES state
2062 **
2063 ** Returns void
2064 **
2065 *******************************************************************************/
nfa_dm_disc_sm_w4_all_discoveries(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)2066 static void nfa_dm_disc_sm_w4_all_discoveries (tNFA_DM_RF_DISC_SM_EVENT event,
2067 tNFA_DM_RF_DISC_DATA *p_data)
2068 {
2069 switch (event)
2070 {
2071 case NFA_DM_RF_DEACTIVATE_CMD:
2072 /* if deactivate CMD was not sent to NFCC */
2073 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP))
2074 {
2075 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP;
2076 /* only IDLE mode is allowed */
2077 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
2078 }
2079 break;
2080 case NFA_DM_RF_DEACTIVATE_RSP:
2081 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
2082 /* notify exiting from w4 all discoverie state */
2083 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_RSP, &(p_data->nfc_discover));
2084
2085 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
2086 nfa_dm_start_rf_discover ();
2087 break;
2088 case NFA_DM_RF_DISCOVER_NTF:
2089 /* if deactivate CMD is already sent then ignore discover NTF */
2090 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP))
2091 {
2092 /* Notification Type = NCI_DISCOVER_NTF_LAST or NCI_DISCOVER_NTF_LAST_ABORT */
2093 if (p_data->nfc_discover.result.more != NCI_DISCOVER_NTF_MORE)
2094 {
2095 nfa_dm_disc_new_state (NFA_DM_RFST_W4_HOST_SELECT);
2096 }
2097 nfa_dm_notify_discovery (p_data);
2098 }
2099 break;
2100 case NFA_DM_RF_INTF_ACTIVATED_NTF:
2101 /*
2102 ** This is only for ISO15693.
2103 ** FW sends activation NTF when all responses are received from tags without host selecting.
2104 */
2105 nfa_dm_disc_new_state (NFA_DM_RFST_POLL_ACTIVE);
2106
2107 if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED)
2108 {
2109 NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf");
2110
2111 /* after receiving deactivate event, restart discovery */
2112 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
2113 }
2114 break;
2115 default:
2116 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_w4_all_discoveries (): Unexpected discovery event");
2117 break;
2118 }
2119 }
2120
2121 /*******************************************************************************
2122 **
2123 ** Function nfa_dm_disc_sm_w4_host_select
2124 **
2125 ** Description Processing discovery events in NFA_DM_RFST_W4_HOST_SELECT state
2126 **
2127 ** Returns void
2128 **
2129 *******************************************************************************/
nfa_dm_disc_sm_w4_host_select(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)2130 static void nfa_dm_disc_sm_w4_host_select (tNFA_DM_RF_DISC_SM_EVENT event,
2131 tNFA_DM_RF_DISC_DATA *p_data)
2132 {
2133 tNFA_CONN_EVT_DATA conn_evt;
2134 tNFA_DM_DISC_FLAGS old_sleep_wakeup_flag = (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING);
2135 BOOLEAN sleep_wakeup_event = FALSE;
2136 BOOLEAN sleep_wakeup_event_processed = FALSE;
2137 tNFA_STATUS status;
2138
2139 switch (event)
2140 {
2141 case NFA_DM_RF_DISCOVER_SELECT_CMD:
2142 /* if not waiting to deactivate */
2143 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP))
2144 {
2145 NFC_DiscoverySelect (p_data->select.rf_disc_id,
2146 p_data->select.protocol,
2147 p_data->select.rf_interface);
2148 }
2149 else
2150 {
2151 nfa_dm_disc_conn_event_notify (NFA_SELECT_RESULT_EVT, NFA_STATUS_FAILED);
2152 }
2153 break;
2154
2155 case NFA_DM_RF_DISCOVER_SELECT_RSP:
2156 sleep_wakeup_event = TRUE;
2157 /* notify application status of selection */
2158 if (p_data->nfc_discover.status == NFC_STATUS_OK)
2159 {
2160 sleep_wakeup_event_processed = TRUE;
2161 conn_evt.status = NFA_STATUS_OK;
2162 /* register callback to get interface error NTF */
2163 NFC_SetStaticRfCback (nfa_dm_disc_data_cback);
2164 }
2165 else
2166 conn_evt.status = NFA_STATUS_FAILED;
2167
2168 if (!old_sleep_wakeup_flag)
2169 {
2170 nfa_dm_disc_conn_event_notify (NFA_SELECT_RESULT_EVT, p_data->nfc_discover.status);
2171 }
2172 break;
2173 case NFA_DM_RF_INTF_ACTIVATED_NTF:
2174 nfa_dm_disc_new_state (NFA_DM_RFST_POLL_ACTIVE);
2175 /* always call nfa_dm_disc_notify_activation to update protocol/interface information in NFA control blocks */
2176 status = nfa_dm_disc_notify_activation (&(p_data->nfc_discover));
2177 if (old_sleep_wakeup_flag)
2178 {
2179 /* Handle sleep wakeup success: notify RW module of sleep wakeup of tag; if deactivation is pending then deactivate */
2180 nfa_dm_disc_end_sleep_wakeup (NFC_STATUS_OK);
2181 }
2182 else if (status == NFA_STATUS_FAILED)
2183 {
2184 NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf");
2185
2186 /* after receiving deactivate event, restart discovery */
2187 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
2188 }
2189 break;
2190 case NFA_DM_RF_DEACTIVATE_CMD:
2191 if (old_sleep_wakeup_flag)
2192 {
2193 nfa_dm_cb.disc_cb.deact_pending = TRUE;
2194 nfa_dm_cb.disc_cb.pending_deact_type = p_data->deactivate_type;
2195 }
2196 /* if deactivate CMD was not sent to NFCC */
2197 else if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP))
2198 {
2199 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP;
2200 /* only IDLE mode is allowed */
2201 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
2202 }
2203 break;
2204 case NFA_DM_RF_DEACTIVATE_RSP:
2205 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
2206 /* notify exiting from host select state */
2207 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_RSP, &(p_data->nfc_discover));
2208
2209 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
2210 nfa_dm_start_rf_discover ();
2211 break;
2212
2213 case NFA_DM_CORE_INTF_ERROR_NTF:
2214 sleep_wakeup_event = TRUE;
2215 if (!old_sleep_wakeup_flag)
2216 {
2217 /* target activation failed, upper layer may deactivate or select again */
2218 conn_evt.status = NFA_STATUS_FAILED;
2219 nfa_dm_conn_cback_event_notify (NFA_SELECT_RESULT_EVT, &conn_evt);
2220 }
2221 break;
2222 default:
2223 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_w4_host_select (): Unexpected discovery event");
2224 break;
2225 }
2226
2227 if (old_sleep_wakeup_flag && sleep_wakeup_event && !sleep_wakeup_event_processed)
2228 {
2229 /* performing sleep wakeup and exception conditions happened
2230 * clear sleep wakeup information and report failure */
2231 nfa_dm_disc_end_sleep_wakeup (NFC_STATUS_FAILED);
2232 }
2233 }
2234
2235 /*******************************************************************************
2236 **
2237 ** Function nfa_dm_disc_sm_poll_active
2238 **
2239 ** Description Processing discovery events in NFA_DM_RFST_POLL_ACTIVE state
2240 **
2241 ** Returns void
2242 **
2243 *******************************************************************************/
nfa_dm_disc_sm_poll_active(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)2244 static void nfa_dm_disc_sm_poll_active (tNFA_DM_RF_DISC_SM_EVENT event,
2245 tNFA_DM_RF_DISC_DATA *p_data)
2246 {
2247 tNFC_STATUS status;
2248 tNFA_DM_DISC_FLAGS old_sleep_wakeup_flag = (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING);
2249 BOOLEAN sleep_wakeup_event = FALSE;
2250 BOOLEAN sleep_wakeup_event_processed = FALSE;
2251 tNFC_DEACTIVATE_DEVT deact;
2252
2253 switch (event)
2254 {
2255 case NFA_DM_RF_DEACTIVATE_CMD:
2256 if (nfa_dm_cb.disc_cb.activated_protocol == NCI_PROTOCOL_MIFARE)
2257 {
2258 nfa_dm_cb.disc_cb.deact_pending = TRUE;
2259 nfa_dm_cb.disc_cb.pending_deact_type = p_data->deactivate_type;
2260 status = nfa_dm_send_deactivate_cmd (p_data->deactivate_type);
2261 break;
2262 }
2263
2264 if (old_sleep_wakeup_flag)
2265 {
2266 /* sleep wakeup is already enabled when deactivate cmd is requested,
2267 * keep the information in control block to issue it later */
2268 nfa_dm_cb.disc_cb.deact_pending = TRUE;
2269 nfa_dm_cb.disc_cb.pending_deact_type = p_data->deactivate_type;
2270 }
2271 else
2272 {
2273 status = nfa_dm_send_deactivate_cmd(p_data->deactivate_type);
2274 }
2275
2276 break;
2277 case NFA_DM_RF_DEACTIVATE_RSP:
2278 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
2279 /* register callback to get interface error NTF */
2280 NFC_SetStaticRfCback (nfa_dm_disc_data_cback);
2281
2282 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF))
2283 {
2284 /* it's race condition. received deactivate NTF before receiving RSP */
2285
2286 deact.status = NFC_STATUS_OK;
2287 deact.type = NFC_DEACTIVATE_TYPE_IDLE;
2288 deact.is_ntf = TRUE;
2289 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, (tNFC_DISCOVER*)&deact);
2290
2291 /* NFCC is in IDLE state */
2292 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
2293 nfa_dm_start_rf_discover ();
2294 }
2295 break;
2296 case NFA_DM_RF_DEACTIVATE_NTF:
2297 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF;
2298
2299 nfa_sys_stop_timer (&nfa_dm_cb.disc_cb.tle);
2300
2301 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)
2302 {
2303 /* it's race condition. received deactivate NTF before receiving RSP */
2304 /* notify deactivation after receiving deactivate RSP */
2305 NFA_TRACE_DEBUG0 ("Rx deactivate NTF while waiting for deactivate RSP");
2306 break;
2307 }
2308
2309 sleep_wakeup_event = TRUE;
2310
2311 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover));
2312
2313 if ( (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP)
2314 ||(p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF) )
2315 {
2316 nfa_dm_disc_new_state (NFA_DM_RFST_W4_HOST_SELECT);
2317 if (old_sleep_wakeup_flag)
2318 {
2319 sleep_wakeup_event_processed = TRUE;
2320 /* process pending deactivate request */
2321 if (nfa_dm_cb.disc_cb.deact_pending)
2322 {
2323 /* notify RW module that sleep wakeup is finished */
2324 /* if deactivation is pending then deactivate */
2325 nfa_dm_disc_end_sleep_wakeup (NFC_STATUS_OK);
2326
2327 /* Notify NFA RW sub-systems because NFA_DM_RF_DEACTIVATE_RSP will not call this function */
2328 nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_DEACTIVATED_EVT, NULL, TRUE);
2329 }
2330 else
2331 {
2332 /* Successfully went to sleep mode for sleep wakeup */
2333 /* Now wake up the tag to complete the operation */
2334 NFC_DiscoverySelect (nfa_dm_cb.disc_cb.activated_rf_disc_id,
2335 nfa_dm_cb.disc_cb.activated_protocol,
2336 nfa_dm_cb.disc_cb.activated_rf_interface);
2337 }
2338
2339 }
2340 }
2341 else if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_IDLE)
2342 {
2343 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
2344 nfa_dm_start_rf_discover ();
2345 }
2346 else if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY)
2347 {
2348 nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY);
2349 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_STOPPING)
2350 {
2351 /* stop discovery */
2352 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
2353 }
2354 }
2355 break;
2356
2357 case NFA_DM_CORE_INTF_ERROR_NTF:
2358 sleep_wakeup_event = TRUE;
2359 if ( (!old_sleep_wakeup_flag)
2360 ||(!nfa_dm_cb.disc_cb.deact_pending) )
2361 {
2362 nfa_dm_send_deactivate_cmd (NFA_DEACTIVATE_TYPE_DISCOVERY);
2363 }
2364 break;
2365
2366 default:
2367 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_poll_active (): Unexpected discovery event");
2368 break;
2369 }
2370
2371 if (old_sleep_wakeup_flag && sleep_wakeup_event && !sleep_wakeup_event_processed)
2372 {
2373 /* performing sleep wakeup and exception conditions happened
2374 * clear sleep wakeup information and report failure */
2375 nfa_dm_disc_end_sleep_wakeup (NFC_STATUS_FAILED);
2376 }
2377 }
2378
2379 /*******************************************************************************
2380 **
2381 ** Function nfa_dm_disc_sm_listen_active
2382 **
2383 ** Description Processing discovery events in NFA_DM_RFST_LISTEN_ACTIVE state
2384 **
2385 ** Returns void
2386 **
2387 *******************************************************************************/
nfa_dm_disc_sm_listen_active(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)2388 static void nfa_dm_disc_sm_listen_active (tNFA_DM_RF_DISC_SM_EVENT event,
2389 tNFA_DM_RF_DISC_DATA *p_data)
2390 {
2391 tNFC_DEACTIVATE_DEVT deact;
2392
2393 switch (event)
2394 {
2395 case NFA_DM_RF_DEACTIVATE_CMD:
2396 nfa_dm_send_deactivate_cmd(p_data->deactivate_type);
2397 break;
2398 case NFA_DM_RF_DEACTIVATE_RSP:
2399 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
2400 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF))
2401 {
2402 /* it's race condition. received deactivate NTF before receiving RSP */
2403
2404 deact.status = NFC_STATUS_OK;
2405 deact.type = NFC_DEACTIVATE_TYPE_IDLE;
2406 deact.is_ntf = TRUE;
2407 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, (tNFC_DISCOVER*)&deact);
2408
2409 /* NFCC is in IDLE state */
2410 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
2411 nfa_dm_start_rf_discover ();
2412 }
2413 break;
2414 case NFA_DM_RF_DEACTIVATE_NTF:
2415 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF;
2416
2417 nfa_sys_stop_timer (&nfa_dm_cb.disc_cb.tle);
2418
2419 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)
2420 {
2421 /* it's race condition. received deactivate NTF before receiving RSP */
2422 /* notify deactivation after receiving deactivate RSP */
2423 NFA_TRACE_DEBUG0 ("Rx deactivate NTF while waiting for deactivate RSP");
2424 }
2425 else
2426 {
2427 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover));
2428
2429 if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_IDLE)
2430 {
2431 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
2432 nfa_dm_start_rf_discover ();
2433 }
2434 else if ( (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP)
2435 ||(p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF) )
2436 {
2437 nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_SLEEP);
2438 }
2439 else if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY)
2440 {
2441 /* Discovery */
2442 nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY);
2443 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_STOPPING)
2444 {
2445 /* stop discovery */
2446 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
2447 }
2448 }
2449 }
2450 break;
2451
2452 case NFA_DM_CORE_INTF_ERROR_NTF:
2453 break;
2454 default:
2455 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_listen_active (): Unexpected discovery event");
2456 break;
2457 }
2458 }
2459
2460 /*******************************************************************************
2461 **
2462 ** Function nfa_dm_disc_sm_listen_sleep
2463 **
2464 ** Description Processing discovery events in NFA_DM_RFST_LISTEN_SLEEP state
2465 **
2466 ** Returns void
2467 **
2468 *******************************************************************************/
nfa_dm_disc_sm_listen_sleep(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)2469 static void nfa_dm_disc_sm_listen_sleep (tNFA_DM_RF_DISC_SM_EVENT event,
2470 tNFA_DM_RF_DISC_DATA *p_data)
2471 {
2472 switch (event)
2473 {
2474 case NFA_DM_RF_DEACTIVATE_CMD:
2475 nfa_dm_send_deactivate_cmd (p_data->deactivate_type);
2476
2477 /* if deactivate type is not discovery then NFCC will not sent deactivation NTF */
2478 if (p_data->deactivate_type != NFA_DEACTIVATE_TYPE_DISCOVERY)
2479 {
2480 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF;
2481 nfa_sys_stop_timer (&nfa_dm_cb.disc_cb.tle);
2482 }
2483 break;
2484 case NFA_DM_RF_DEACTIVATE_RSP:
2485 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
2486 /* if deactivate type in CMD was IDLE */
2487 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF))
2488 {
2489 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_RSP, &(p_data->nfc_discover));
2490
2491 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
2492 nfa_dm_start_rf_discover ();
2493 }
2494 break;
2495 case NFA_DM_RF_DEACTIVATE_NTF:
2496 /* clear both W4_RSP and W4_NTF because of race condition between deactivat CMD and link loss */
2497 nfa_dm_cb.disc_cb.disc_flags &= ~(NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF);
2498 nfa_sys_stop_timer (&nfa_dm_cb.disc_cb.tle);
2499
2500 /* there is no active protocol in this state, so broadcast to all by using NFA_DM_RF_DEACTIVATE_RSP */
2501 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_RSP, &(p_data->nfc_discover));
2502
2503 if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_IDLE)
2504 {
2505 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
2506 nfa_dm_start_rf_discover ();
2507 }
2508 else if (p_data->nfc_discover.deactivate.type == NFA_DEACTIVATE_TYPE_DISCOVERY)
2509 {
2510 nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY);
2511 }
2512 else
2513 {
2514 NFA_TRACE_ERROR0 ("Unexpected deactivation type");
2515 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
2516 nfa_dm_start_rf_discover ();
2517 }
2518 break;
2519 case NFA_DM_RF_INTF_ACTIVATED_NTF:
2520 nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_ACTIVE);
2521 if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED)
2522 {
2523 NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf");
2524
2525 /* after receiving deactivate event, restart discovery */
2526 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
2527 }
2528 break;
2529 default:
2530 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_listen_sleep (): Unexpected discovery event");
2531 break;
2532 }
2533 }
2534
2535 /*******************************************************************************
2536 **
2537 ** Function nfa_dm_disc_sm_lp_listen
2538 **
2539 ** Description Processing discovery events in NFA_DM_RFST_LP_LISTEN state
2540 **
2541 ** Returns void
2542 **
2543 *******************************************************************************/
nfa_dm_disc_sm_lp_listen(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)2544 static void nfa_dm_disc_sm_lp_listen (tNFA_DM_RF_DISC_SM_EVENT event,
2545 tNFA_DM_RF_DISC_DATA *p_data)
2546 {
2547 switch (event)
2548 {
2549 case NFA_DM_RF_INTF_ACTIVATED_NTF:
2550 nfa_dm_disc_new_state (NFA_DM_RFST_LP_ACTIVE);
2551 nfa_dm_disc_notify_activation (&(p_data->nfc_discover));
2552 if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED)
2553 {
2554 NFA_TRACE_DEBUG0 ("Not matched, unexpected activation");
2555 }
2556 break;
2557
2558 default:
2559 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_lp_listen (): Unexpected discovery event");
2560 break;
2561 }
2562 }
2563
2564 /*******************************************************************************
2565 **
2566 ** Function nfa_dm_disc_sm_lp_active
2567 **
2568 ** Description Processing discovery events in NFA_DM_RFST_LP_ACTIVE state
2569 **
2570 ** Returns void
2571 **
2572 *******************************************************************************/
nfa_dm_disc_sm_lp_active(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)2573 static void nfa_dm_disc_sm_lp_active (tNFA_DM_RF_DISC_SM_EVENT event,
2574 tNFA_DM_RF_DISC_DATA *p_data)
2575 {
2576 switch (event)
2577 {
2578 case NFA_DM_RF_DEACTIVATE_NTF:
2579 nfa_dm_disc_new_state (NFA_DM_RFST_LP_LISTEN);
2580 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover));
2581 break;
2582 default:
2583 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_lp_active (): Unexpected discovery event");
2584 break;
2585 }
2586 }
2587
2588 /*******************************************************************************
2589 **
2590 ** Function nfa_dm_disc_sm_execute
2591 **
2592 ** Description Processing discovery related events
2593 **
2594 ** Returns void
2595 **
2596 *******************************************************************************/
nfa_dm_disc_sm_execute(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)2597 void nfa_dm_disc_sm_execute (tNFA_DM_RF_DISC_SM_EVENT event, tNFA_DM_RF_DISC_DATA *p_data)
2598 {
2599 #if (BT_TRACE_VERBOSE == TRUE)
2600 NFA_TRACE_DEBUG5 ("nfa_dm_disc_sm_execute (): state: %s (%d), event: %s(%d) disc_flags: 0x%x",
2601 nfa_dm_disc_state_2_str (nfa_dm_cb.disc_cb.disc_state), nfa_dm_cb.disc_cb.disc_state,
2602 nfa_dm_disc_event_2_str (event), event, nfa_dm_cb.disc_cb.disc_flags);
2603 #else
2604 NFA_TRACE_DEBUG3 ("nfa_dm_disc_sm_execute(): state: %d, event:%d disc_flags: 0x%x",
2605 nfa_dm_cb.disc_cb.disc_state, event, nfa_dm_cb.disc_cb.disc_flags);
2606 #endif
2607
2608 switch (nfa_dm_cb.disc_cb.disc_state)
2609 {
2610 /* RF Discovery State - Idle */
2611 case NFA_DM_RFST_IDLE:
2612 nfa_dm_disc_sm_idle (event, p_data);
2613 break;
2614
2615 /* RF Discovery State - Discovery */
2616 case NFA_DM_RFST_DISCOVERY:
2617 nfa_dm_disc_sm_discovery (event, p_data);
2618 break;
2619
2620 /*RF Discovery State - Wait for all discoveries */
2621 case NFA_DM_RFST_W4_ALL_DISCOVERIES:
2622 nfa_dm_disc_sm_w4_all_discoveries (event, p_data);
2623 break;
2624
2625 /* RF Discovery State - Wait for host selection */
2626 case NFA_DM_RFST_W4_HOST_SELECT:
2627 nfa_dm_disc_sm_w4_host_select (event, p_data);
2628 break;
2629
2630 /* RF Discovery State - Poll mode activated */
2631 case NFA_DM_RFST_POLL_ACTIVE:
2632 nfa_dm_disc_sm_poll_active (event, p_data);
2633 break;
2634
2635 /* RF Discovery State - listen mode activated */
2636 case NFA_DM_RFST_LISTEN_ACTIVE:
2637 nfa_dm_disc_sm_listen_active (event, p_data);
2638 break;
2639
2640 /* RF Discovery State - listen mode sleep */
2641 case NFA_DM_RFST_LISTEN_SLEEP:
2642 nfa_dm_disc_sm_listen_sleep (event, p_data);
2643 break;
2644
2645 /* Listening in Low Power mode */
2646 case NFA_DM_RFST_LP_LISTEN:
2647 nfa_dm_disc_sm_lp_listen (event, p_data);
2648 break;
2649
2650 /* Activated in Low Power mode */
2651 case NFA_DM_RFST_LP_ACTIVE:
2652 nfa_dm_disc_sm_lp_active (event, p_data);
2653 break;
2654 }
2655 #if (BT_TRACE_VERBOSE == TRUE)
2656 NFA_TRACE_DEBUG3 ("nfa_dm_disc_sm_execute (): new state: %s (%d), disc_flags: 0x%x",
2657 nfa_dm_disc_state_2_str (nfa_dm_cb.disc_cb.disc_state), nfa_dm_cb.disc_cb.disc_state,
2658 nfa_dm_cb.disc_cb.disc_flags);
2659 #else
2660 NFA_TRACE_DEBUG2 ("nfa_dm_disc_sm_execute(): new state: %d, disc_flags: 0x%x",
2661 nfa_dm_cb.disc_cb.disc_state, nfa_dm_cb.disc_cb.disc_flags);
2662 #endif
2663 }
2664
2665 /*******************************************************************************
2666 **
2667 ** Function nfa_dm_add_rf_discover
2668 **
2669 ** Description Add discovery configuration and callback function
2670 **
2671 ** Returns valid handle if success
2672 **
2673 *******************************************************************************/
nfa_dm_add_rf_discover(tNFA_DM_DISC_TECH_PROTO_MASK disc_mask,tNFA_DM_DISC_HOST_ID host_id,tNFA_DISCOVER_CBACK * p_disc_cback)2674 tNFA_HANDLE nfa_dm_add_rf_discover (tNFA_DM_DISC_TECH_PROTO_MASK disc_mask,
2675 tNFA_DM_DISC_HOST_ID host_id,
2676 tNFA_DISCOVER_CBACK *p_disc_cback)
2677 {
2678 UINT8 xx;
2679
2680 NFA_TRACE_DEBUG1 ("nfa_dm_add_rf_discover () disc_mask=0x%x", disc_mask);
2681
2682 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++)
2683 {
2684 if (!nfa_dm_cb.disc_cb.entry[xx].in_use)
2685 {
2686 nfa_dm_cb.disc_cb.entry[xx].in_use = TRUE;
2687 nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask = disc_mask;
2688 nfa_dm_cb.disc_cb.entry[xx].host_id = host_id;
2689 nfa_dm_cb.disc_cb.entry[xx].p_disc_cback = p_disc_cback;
2690 nfa_dm_cb.disc_cb.entry[xx].disc_flags = NFA_DM_DISC_FLAGS_NOTIFY;
2691 return xx;
2692 }
2693 }
2694
2695 return NFA_HANDLE_INVALID;
2696 }
2697
2698 /*******************************************************************************
2699 **
2700 ** Function nfa_dm_start_excl_discovery
2701 **
2702 ** Description Start exclusive RF discovery
2703 **
2704 ** Returns void
2705 **
2706 *******************************************************************************/
nfa_dm_start_excl_discovery(tNFA_TECHNOLOGY_MASK poll_tech_mask,tNFA_LISTEN_CFG * p_listen_cfg,tNFA_DISCOVER_CBACK * p_disc_cback)2707 void nfa_dm_start_excl_discovery (tNFA_TECHNOLOGY_MASK poll_tech_mask,
2708 tNFA_LISTEN_CFG *p_listen_cfg,
2709 tNFA_DISCOVER_CBACK *p_disc_cback)
2710 {
2711 tNFA_DM_DISC_TECH_PROTO_MASK poll_disc_mask = 0;
2712
2713 NFA_TRACE_DEBUG0 ("nfa_dm_start_excl_discovery ()");
2714
2715 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A)
2716 {
2717 poll_disc_mask |= NFA_DM_DISC_MASK_PA_T1T;
2718 poll_disc_mask |= NFA_DM_DISC_MASK_PA_T2T;
2719 poll_disc_mask |= NFA_DM_DISC_MASK_PA_ISO_DEP;
2720 poll_disc_mask |= NFA_DM_DISC_MASK_PA_NFC_DEP;
2721 poll_disc_mask |= NFA_DM_DISC_MASK_P_LEGACY;
2722 }
2723 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE)
2724 {
2725 poll_disc_mask |= NFA_DM_DISC_MASK_PAA_NFC_DEP;
2726 }
2727 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B)
2728 {
2729 poll_disc_mask |= NFA_DM_DISC_MASK_PB_ISO_DEP;
2730 }
2731 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F)
2732 {
2733 poll_disc_mask |= NFA_DM_DISC_MASK_PF_T3T;
2734 poll_disc_mask |= NFA_DM_DISC_MASK_PF_NFC_DEP;
2735 }
2736 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE)
2737 {
2738 poll_disc_mask |= NFA_DM_DISC_MASK_PFA_NFC_DEP;
2739 }
2740 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_ISO15693)
2741 {
2742 poll_disc_mask |= NFA_DM_DISC_MASK_P_ISO15693;
2743 }
2744 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B_PRIME)
2745 {
2746 poll_disc_mask |= NFA_DM_DISC_MASK_P_B_PRIME;
2747 }
2748 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_KOVIO)
2749 {
2750 poll_disc_mask |= NFA_DM_DISC_MASK_P_KOVIO;
2751 }
2752
2753 nfa_dm_cb.disc_cb.excl_disc_entry.in_use = TRUE;
2754 nfa_dm_cb.disc_cb.excl_disc_entry.requested_disc_mask = poll_disc_mask;
2755 nfa_dm_cb.disc_cb.excl_disc_entry.host_id = NFA_DM_DISC_HOST_ID_DH;
2756 nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback = p_disc_cback;
2757 nfa_dm_cb.disc_cb.excl_disc_entry.disc_flags = NFA_DM_DISC_FLAGS_NOTIFY;
2758
2759 memcpy (&nfa_dm_cb.disc_cb.excl_listen_config, p_listen_cfg, sizeof (tNFA_LISTEN_CFG));
2760
2761 nfa_dm_disc_sm_execute (NFA_DM_RF_DISCOVER_CMD, NULL);
2762 }
2763
2764 /*******************************************************************************
2765 **
2766 ** Function nfa_dm_stop_excl_discovery
2767 **
2768 ** Description Stop exclusive RF discovery
2769 **
2770 ** Returns void
2771 **
2772 *******************************************************************************/
nfa_dm_stop_excl_discovery(void)2773 void nfa_dm_stop_excl_discovery (void)
2774 {
2775 NFA_TRACE_DEBUG0 ("nfa_dm_stop_excl_discovery ()");
2776
2777 nfa_dm_cb.disc_cb.excl_disc_entry.in_use = FALSE;
2778 nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback = NULL;
2779 }
2780
2781 /*******************************************************************************
2782 **
2783 ** Function nfa_dm_delete_rf_discover
2784 **
2785 ** Description Remove discovery configuration and callback function
2786 **
2787 ** Returns void
2788 **
2789 *******************************************************************************/
nfa_dm_delete_rf_discover(tNFA_HANDLE handle)2790 void nfa_dm_delete_rf_discover (tNFA_HANDLE handle)
2791 {
2792 NFA_TRACE_DEBUG1 ("nfa_dm_delete_rf_discover () handle=0x%x", handle);
2793
2794 if (handle < NFA_DM_DISC_NUM_ENTRIES)
2795 {
2796 nfa_dm_cb.disc_cb.entry[handle].in_use = FALSE;
2797 }
2798 else
2799 {
2800 NFA_TRACE_ERROR0 ("Invalid discovery handle");
2801 }
2802 }
2803
2804 /*******************************************************************************
2805 **
2806 ** Function nfa_dm_rf_discover_select
2807 **
2808 ** Description Select target, protocol and RF interface
2809 **
2810 ** Returns void
2811 **
2812 *******************************************************************************/
nfa_dm_rf_discover_select(UINT8 rf_disc_id,tNFA_NFC_PROTOCOL protocol,tNFA_INTF_TYPE rf_interface)2813 void nfa_dm_rf_discover_select (UINT8 rf_disc_id,
2814 tNFA_NFC_PROTOCOL protocol,
2815 tNFA_INTF_TYPE rf_interface)
2816 {
2817 tNFA_DM_DISC_SELECT_PARAMS select_params;
2818 tNFA_CONN_EVT_DATA conn_evt;
2819
2820 NFA_TRACE_DEBUG3 ("nfa_dm_disc_select () rf_disc_id:0x%X, protocol:0x%X, rf_interface:0x%X",
2821 rf_disc_id, protocol, rf_interface);
2822
2823 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_HOST_SELECT)
2824 {
2825 /* state is OK: notify the status when the response is received from NFCC */
2826 select_params.rf_disc_id = rf_disc_id;
2827 select_params.protocol = protocol;
2828 select_params.rf_interface = rf_interface;
2829
2830 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_NOTIFY;
2831 nfa_dm_disc_sm_execute (NFA_DM_RF_DISCOVER_SELECT_CMD, (tNFA_DM_RF_DISC_DATA *) &select_params);
2832 }
2833 else
2834 {
2835 /* Wrong state: notify failed status right away */
2836 conn_evt.status = NFA_STATUS_FAILED;
2837 nfa_dm_conn_cback_event_notify (NFA_SELECT_RESULT_EVT, &conn_evt);
2838 }
2839 }
2840
2841 /*******************************************************************************
2842 **
2843 ** Function nfa_dm_rf_deactivate
2844 **
2845 ** Description Deactivate NFC link
2846 **
2847 ** Returns NFA_STATUS_OK if success
2848 **
2849 *******************************************************************************/
nfa_dm_rf_deactivate(tNFA_DEACTIVATE_TYPE deactivate_type)2850 tNFA_STATUS nfa_dm_rf_deactivate (tNFA_DEACTIVATE_TYPE deactivate_type)
2851 {
2852 NFA_TRACE_DEBUG1 ("nfa_dm_rf_deactivate () deactivate_type:0x%X", deactivate_type);
2853
2854 if (deactivate_type == NFA_DEACTIVATE_TYPE_SLEEP)
2855 {
2856 if (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_NFC_DEP)
2857 deactivate_type = NFC_DEACTIVATE_TYPE_SLEEP_AF;
2858 else
2859 deactivate_type = NFC_DEACTIVATE_TYPE_SLEEP;
2860 }
2861
2862 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_IDLE)
2863 {
2864 return NFA_STATUS_FAILED;
2865 }
2866 else if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_DISCOVERY)
2867 {
2868 if (deactivate_type == NFA_DEACTIVATE_TYPE_DISCOVERY)
2869 {
2870 if (nfa_dm_cb.disc_cb.kovio_tle.in_use)
2871 {
2872 nfa_sys_stop_timer (&nfa_dm_cb.disc_cb.kovio_tle);
2873 nfa_dm_disc_kovio_timeout_cback (&nfa_dm_cb.disc_cb.kovio_tle);
2874 return NFA_STATUS_OK;
2875 }
2876 else
2877 {
2878 /* it could be race condition. */
2879 NFA_TRACE_DEBUG0 ("nfa_dm_rf_deactivate (): already in discovery state");
2880 return NFA_STATUS_FAILED;
2881 }
2882 }
2883 else if (deactivate_type == NFA_DEACTIVATE_TYPE_IDLE)
2884 {
2885 if (nfa_dm_cb.disc_cb.kovio_tle.in_use)
2886 {
2887 nfa_sys_stop_timer (&nfa_dm_cb.disc_cb.kovio_tle);
2888 nfa_dm_disc_kovio_timeout_cback (&nfa_dm_cb.disc_cb.kovio_tle);
2889 }
2890 nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD, (tNFA_DM_RF_DISC_DATA *) &deactivate_type);
2891 return NFA_STATUS_OK;
2892 }
2893 else
2894 {
2895 return NFA_STATUS_FAILED;
2896 }
2897 }
2898 else
2899 {
2900 nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD, (tNFA_DM_RF_DISC_DATA *) &deactivate_type);
2901 return NFA_STATUS_OK;
2902 }
2903 }
2904
2905 #if (BT_TRACE_VERBOSE == TRUE)
2906 /*******************************************************************************
2907 **
2908 ** Function nfa_dm_disc_state_2_str
2909 **
2910 ** Description convert nfc discovery state to string
2911 **
2912 *******************************************************************************/
nfa_dm_disc_state_2_str(UINT8 state)2913 static char *nfa_dm_disc_state_2_str (UINT8 state)
2914 {
2915 switch (state)
2916 {
2917 case NFA_DM_RFST_IDLE:
2918 return "IDLE";
2919
2920 case NFA_DM_RFST_DISCOVERY:
2921 return "DISCOVERY";
2922
2923 case NFA_DM_RFST_W4_ALL_DISCOVERIES:
2924 return "W4_ALL_DISCOVERIES";
2925
2926 case NFA_DM_RFST_W4_HOST_SELECT:
2927 return "W4_HOST_SELECT";
2928
2929 case NFA_DM_RFST_POLL_ACTIVE:
2930 return "POLL_ACTIVE";
2931
2932 case NFA_DM_RFST_LISTEN_ACTIVE:
2933 return "LISTEN_ACTIVE";
2934
2935 case NFA_DM_RFST_LISTEN_SLEEP:
2936 return "LISTEN_SLEEP";
2937
2938 case NFA_DM_RFST_LP_LISTEN:
2939 return "LP_LISTEN";
2940
2941 case NFA_DM_RFST_LP_ACTIVE:
2942 return "LP_ACTIVE";
2943 }
2944 return "Unknown";
2945 }
2946
2947 /*******************************************************************************
2948 **
2949 ** Function nfa_dm_disc_event_2_str
2950 **
2951 ** Description convert nfc discovery RSP/NTF to string
2952 **
2953 *******************************************************************************/
nfa_dm_disc_event_2_str(UINT8 event)2954 static char *nfa_dm_disc_event_2_str (UINT8 event)
2955 {
2956 switch (event)
2957 {
2958 case NFA_DM_RF_DISCOVER_CMD:
2959 return "DISCOVER_CMD";
2960
2961 case NFA_DM_RF_DISCOVER_RSP:
2962 return "DISCOVER_RSP";
2963
2964 case NFA_DM_RF_DISCOVER_NTF:
2965 return "DISCOVER_NTF";
2966
2967 case NFA_DM_RF_DISCOVER_SELECT_CMD:
2968 return "SELECT_CMD";
2969
2970 case NFA_DM_RF_DISCOVER_SELECT_RSP:
2971 return "SELECT_RSP";
2972
2973 case NFA_DM_RF_INTF_ACTIVATED_NTF:
2974 return "ACTIVATED_NTF";
2975
2976 case NFA_DM_RF_DEACTIVATE_CMD:
2977 return "DEACTIVATE_CMD";
2978
2979 case NFA_DM_RF_DEACTIVATE_RSP:
2980 return "DEACTIVATE_RSP";
2981
2982 case NFA_DM_RF_DEACTIVATE_NTF:
2983 return "DEACTIVATE_NTF";
2984
2985 case NFA_DM_LP_LISTEN_CMD:
2986 return "NFA_DM_LP_LISTEN_CMD";
2987
2988 case NFA_DM_CORE_INTF_ERROR_NTF:
2989 return "INTF_ERROR_NTF";
2990
2991 }
2992 return "Unknown";
2993 }
2994 #endif /* BT_TRACE_VERBOSE */
2995
2996 /*******************************************************************************
2997 **
2998 ** Function P2P_Prio_Logic
2999 **
3000 ** Description Implements algorithm for NFC-DEP protocol priority over
3001 ** ISO-DEP protocol.
3002 **
3003 ** Returns True if success
3004 **
3005 *******************************************************************************/
nfa_dm_p2p_prio_logic(UINT8 event,UINT8 * p,UINT8 event_type)3006 BOOLEAN nfa_dm_p2p_prio_logic (UINT8 event, UINT8 *p, UINT8 event_type)
3007 {
3008 if (!nfa_poll_bail_out_mode)
3009 {
3010 NFA_TRACE_DEBUG0 ("p2p priority is running under bail out mode ONLY.");
3011 return TRUE;
3012 }
3013
3014 if ((nfa_dm_cb.flags & NFA_DM_FLAGS_P2P_PAUSED) &&
3015 (nfa_dm_cb.flags & NFA_DM_FLAGS_LISTEN_DISABLED))
3016 {
3017 NFA_TRACE_DEBUG0 ("returning from nfa_dm_p2p_prio_logic Disable p2p_prio_logic");
3018 return TRUE;
3019 }
3020
3021 if (event == NCI_MSG_RF_DISCOVER && p2p_prio_logic_data.timer_expired == TRUE && event_type == NFA_DM_P2P_PRIO_RSP)
3022 {
3023 NFA_TRACE_DEBUG0 ("nfa_dm_p2p_prio_logic starting a timer for next rf intf activated ntf");
3024 nfc_start_quick_timer (&p2p_prio_logic_data.timer_list,
3025 NFC_TTYPE_P2P_PRIO_LOGIC_CLEANUP,
3026 ((UINT32) nfa_dm_act_get_rf_disc_duration() * QUICK_TIMER_TICKS_PER_SEC) / 1000);
3027 return TRUE;
3028 }
3029
3030 if (event == NCI_MSG_RF_INTF_ACTIVATED && p2p_prio_logic_data.timer_expired == TRUE)
3031 {
3032 NFA_TRACE_DEBUG0 ("nfa_dm_p2p_prio_logic stopping a timer for next rf intf activated ntf");
3033 nfc_stop_quick_timer (&p2p_prio_logic_data.timer_list);
3034 }
3035
3036 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_DISCOVERY)
3037 {
3038 UINT8 rf_disc_id = 0xFF;
3039 UINT8 type = 0xFF;
3040 UINT8 protocol = 0xFF;
3041 UINT8 tech_mode = 0xFF;
3042
3043 NFA_TRACE_DEBUG0 ("P2P_Prio_Logic");
3044
3045 if (event == NCI_MSG_RF_INTF_ACTIVATED )
3046 {
3047 rf_disc_id = *p++;
3048 type = *p++;
3049 protocol = *p++;
3050 tech_mode = *p++;
3051 }
3052 NFA_TRACE_DEBUG1 ("nfa_dm_p2p_prio_logic event_type = 0x%x", event_type);
3053
3054 if (event == NCI_MSG_RF_INTF_ACTIVATED && tech_mode >= 0x80)
3055 {
3056 NFA_TRACE_DEBUG0 ("nfa_dm_p2p_prio_logic listen mode activated reset all the nfa_dm_p2p_prio_logic variables ");
3057 nfa_dm_p2p_prio_logic_cleanup ();
3058 }
3059
3060 if ((tech_mode < 0x80) &&
3061 event == NCI_MSG_RF_INTF_ACTIVATED &&
3062 protocol == NCI_PROTOCOL_ISO_DEP &&
3063 p2p_prio_logic_data.isodep_detected == FALSE)
3064 {
3065 nfa_dm_p2p_prio_logic_cleanup ();
3066 p2p_prio_logic_data.isodep_detected = TRUE;
3067 p2p_prio_logic_data.first_tech_mode = tech_mode;
3068 NFA_TRACE_DEBUG0 ("ISO-DEP Detected First Time Resume the Polling Loop");
3069 nci_snd_deactivate_cmd (NFA_DEACTIVATE_TYPE_DISCOVERY);
3070 return FALSE;
3071 }
3072
3073 else if (event == NCI_MSG_RF_INTF_ACTIVATED &&
3074 protocol == NCI_PROTOCOL_ISO_DEP &&
3075 p2p_prio_logic_data.isodep_detected == TRUE &&
3076 p2p_prio_logic_data.first_tech_mode != tech_mode)
3077 {
3078 p2p_prio_logic_data.isodep_detected = TRUE;
3079 p2p_prio_logic_data.timer_expired = FALSE;
3080 NFA_TRACE_DEBUG0 ("ISO-DEP Detected Second Time Other Techmode Resume the Polling Loop");
3081 nfc_stop_quick_timer (&p2p_prio_logic_data.timer_list);
3082 nci_snd_deactivate_cmd (NFA_DEACTIVATE_TYPE_DISCOVERY);
3083 return FALSE;
3084 }
3085
3086 else if (event == NCI_MSG_RF_INTF_ACTIVATED &&
3087 protocol == NCI_PROTOCOL_ISO_DEP &&
3088 p2p_prio_logic_data.isodep_detected == TRUE &&
3089 p2p_prio_logic_data.timer_expired == TRUE)
3090 {
3091 NFA_TRACE_DEBUG0 ("ISO-DEP Detected TimerExpired, Final Notifying the Event");
3092 nfc_stop_quick_timer (&p2p_prio_logic_data.timer_list);
3093 nfa_dm_p2p_prio_logic_cleanup ();
3094 }
3095
3096 else if (event == NCI_MSG_RF_INTF_ACTIVATED &&
3097 protocol == NCI_PROTOCOL_ISO_DEP &&
3098 p2p_prio_logic_data.isodep_detected == TRUE &&
3099 p2p_prio_logic_data.first_tech_mode == tech_mode)
3100 {
3101 NFA_TRACE_DEBUG0 ("ISO-DEP Detected Same Techmode, Final Notifying the Event");
3102 nfc_stop_quick_timer (&p2p_prio_logic_data.timer_list);
3103 NFA_TRACE_DEBUG0 ("P2P_Stop_Timer");
3104 nfa_dm_p2p_prio_logic_cleanup ();
3105 }
3106
3107 else if (event == NCI_MSG_RF_INTF_ACTIVATED &&
3108 protocol != NCI_PROTOCOL_ISO_DEP &&
3109 p2p_prio_logic_data.isodep_detected == TRUE)
3110 {
3111 NFA_TRACE_DEBUG0 ("ISO-DEP Not Detected Giving Priority for other Technology");
3112 nfc_stop_quick_timer (&p2p_prio_logic_data.timer_list);
3113 NFA_TRACE_DEBUG0 ("P2P_Stop_Timer");
3114 nfa_dm_p2p_prio_logic_cleanup ();
3115 }
3116
3117 else if (event == NCI_MSG_RF_DEACTIVATE &&
3118 p2p_prio_logic_data.isodep_detected == TRUE &&
3119 p2p_prio_logic_data.timer_expired == FALSE &&
3120 event_type == NFA_DM_P2P_PRIO_RSP)
3121 {
3122 NFA_TRACE_DEBUG0 ("NFA_DM_RF_DEACTIVATE_RSP");
3123 return FALSE;
3124 }
3125
3126 else if (event == NCI_MSG_RF_DEACTIVATE &&
3127 p2p_prio_logic_data.isodep_detected == TRUE &&
3128 p2p_prio_logic_data.timer_expired == FALSE &&
3129 event_type == NFA_DM_P2P_PRIO_NTF)
3130 {
3131 NFA_TRACE_DEBUG0 ("NFA_DM_RF_DEACTIVATE_NTF");
3132
3133 nfc_start_quick_timer (&p2p_prio_logic_data.timer_list,
3134 NFC_TTYPE_P2P_PRIO_RESPONSE,
3135 ((UINT32) 160 * QUICK_TIMER_TICKS_PER_SEC) / 1000 );
3136
3137 NFA_TRACE_DEBUG0 ("P2P_Start_Timer");
3138
3139 return FALSE;
3140 }
3141 }
3142
3143 NFA_TRACE_DEBUG0 ("returning TRUE");
3144 return TRUE;
3145 }
3146
3147 /*******************************************************************************
3148 **
3149 ** Function p2p_prio_logic_timeout
3150 **
3151 ** Description Callback function for p2p timer
3152 **
3153 ** Returns void
3154 **
3155 *******************************************************************************/
nfa_dm_p2p_timer_event()3156 void nfa_dm_p2p_timer_event ()
3157 {
3158 NFA_TRACE_DEBUG0 ("P2P_Timer_timeout NFC-DEP Not Discovered!!");
3159
3160 p2p_prio_logic_data.timer_expired = TRUE;
3161
3162 if (p2p_prio_logic_data.isodep_detected == TRUE)
3163 {
3164 NFA_TRACE_DEBUG0 ("Deactivate and Restart RF discovery");
3165 nci_snd_deactivate_cmd (NFC_DEACTIVATE_TYPE_IDLE);
3166 }
3167 }
3168
3169 /*******************************************************************************
3170 **
3171 ** Function nfa_dm_p2p_prio_logic_cleanup
3172 **
3173 ** Description Callback function for p2p prio logic cleanup timer
3174 **
3175 ** Returns void
3176 **
3177 *******************************************************************************/
nfa_dm_p2p_prio_logic_cleanup()3178 void nfa_dm_p2p_prio_logic_cleanup ()
3179 {
3180 memset (&p2p_prio_logic_data, 0x00, sizeof(nfa_dm_p2p_prio_logic_t));
3181 }
3182