• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /******************************************************************************
2  *
3  *  Copyright (C) 2010-2012 Broadcom Corporation
4  *
5  *  Licensed under the Apache License, Version 2.0 (the "License");
6  *  you may not use this file except in compliance with the License.
7  *  You may obtain a copy of the License at:
8  *
9  *  http://www.apache.org/licenses/LICENSE-2.0
10  *
11  *  Unless required by applicable law or agreed to in writing, software
12  *  distributed under the License is distributed on an "AS IS" BASIS,
13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  *  See the License for the specific language governing permissions and
15  *  limitations under the License.
16  *
17  ******************************************************************************/
18 
19 /******************************************************************************
20  *
21  *  This file contains the action functions for device manager discovery
22  *  function.
23  *
24  ******************************************************************************/
25 #include <string.h>
26 #include "nfa_sys.h"
27 #include "nfa_api.h"
28 #include "nfa_dm_int.h"
29 #include "nfa_p2p_int.h"
30 #include "nfa_sys_int.h"
31 #if (NFC_NFCEE_INCLUDED == TRUE)
32 #include "nfa_ee_api.h"
33 #include "nfa_ee_int.h"
34 #endif
35 #include "nfa_rw_int.h"
36 
37 /*
38 **  static functions
39 */
40 
41 static UINT8 nfa_dm_get_rf_discover_config (tNFA_DM_DISC_TECH_PROTO_MASK dm_disc_mask,
42                                             tNFC_DISCOVER_PARAMS disc_params[],
43                                             UINT8 max_params);
44 static tNFA_STATUS nfa_dm_set_rf_listen_mode_config (tNFA_DM_DISC_TECH_PROTO_MASK tech_proto_mask);
45 static void nfa_dm_set_rf_listen_mode_raw_config (tNFA_DM_DISC_TECH_PROTO_MASK *p_disc_mask);
46 static tNFA_DM_DISC_TECH_PROTO_MASK nfa_dm_disc_get_disc_mask (tNFC_RF_TECH_N_MODE tech_n_mode,
47                                                                tNFC_PROTOCOL       protocol);
48 static void nfa_dm_notify_discovery (tNFA_DM_RF_DISC_DATA *p_data);
49 static tNFA_STATUS nfa_dm_disc_notify_activation (tNFC_DISCOVER *p_data);
50 static void nfa_dm_disc_notify_deactivation (tNFA_DM_RF_DISC_SM_EVENT sm_event, tNFC_DISCOVER *p_data);
51 static void nfa_dm_disc_data_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data);
52 
53 #if (BT_TRACE_VERBOSE == TRUE)
54 static char *nfa_dm_disc_state_2_str (UINT8 state);
55 static char *nfa_dm_disc_event_2_str (UINT8 event);
56 #endif
57 
58 
59 /*******************************************************************************
60 **
61 ** Function         nfa_dm_get_rf_discover_config
62 **
63 ** Description      Build RF discovery configurations from tNFA_DM_DISC_TECH_PROTO_MASK
64 **
65 ** Returns          number of RF discovery configurations
66 **
67 *******************************************************************************/
nfa_dm_get_rf_discover_config(tNFA_DM_DISC_TECH_PROTO_MASK dm_disc_mask,tNFC_DISCOVER_PARAMS disc_params[],UINT8 max_params)68 static UINT8 nfa_dm_get_rf_discover_config (tNFA_DM_DISC_TECH_PROTO_MASK dm_disc_mask,
69                                             tNFC_DISCOVER_PARAMS         disc_params[],
70                                             UINT8 max_params)
71 {
72     UINT8 num_params = 0;
73 
74     /* Check polling A */
75     if (dm_disc_mask & ( NFA_DM_DISC_MASK_PA_T1T
76                         |NFA_DM_DISC_MASK_PA_T2T
77                         |NFA_DM_DISC_MASK_PA_ISO_DEP
78                         |NFA_DM_DISC_MASK_PA_NFC_DEP
79                         |NFA_DM_DISC_MASK_P_LEGACY) )
80     {
81         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_POLL_A;
82         disc_params[num_params].frequency = 1;
83         num_params++;
84 
85         if (num_params >= max_params)
86             return num_params;
87     }
88 
89     /* Check polling B */
90     if (dm_disc_mask & NFA_DM_DISC_MASK_PB_ISO_DEP)
91     {
92         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_POLL_B;
93         disc_params[num_params].frequency = 1;
94         num_params++;
95 
96         if (num_params >= max_params)
97             return num_params;
98     }
99 
100     /* Check polling F */
101     if (dm_disc_mask & ( NFA_DM_DISC_MASK_PF_T3T
102                         |NFA_DM_DISC_MASK_PF_NFC_DEP) )
103     {
104         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_POLL_F;
105         disc_params[num_params].frequency = 1;
106         num_params++;
107 
108         if (num_params >= max_params)
109             return num_params;
110     }
111 
112     /* Check polling A Active mode  */
113     if (dm_disc_mask & NFA_DM_DISC_MASK_PAA_NFC_DEP)
114     {
115         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_POLL_A_ACTIVE;
116         disc_params[num_params].frequency = 1;
117         num_params++;
118 
119         if (num_params >= max_params)
120             return num_params;
121     }
122 
123     /* Check polling F Active mode  */
124     if (dm_disc_mask & NFA_DM_DISC_MASK_PFA_NFC_DEP)
125     {
126         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_POLL_F_ACTIVE;
127         disc_params[num_params].frequency = 1;
128         num_params++;
129 
130         if (num_params >= max_params)
131             return num_params;
132     }
133 
134     /* Check listening A */
135     if (dm_disc_mask & ( NFA_DM_DISC_MASK_LA_T1T
136                         |NFA_DM_DISC_MASK_LA_T2T
137                         |NFA_DM_DISC_MASK_LA_ISO_DEP
138                         |NFA_DM_DISC_MASK_LA_NFC_DEP) )
139     {
140         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_LISTEN_A;
141         disc_params[num_params].frequency = 1;
142         num_params++;
143 
144         if (num_params >= max_params)
145             return num_params;
146     }
147 
148     /* Check listening B */
149     if (dm_disc_mask & NFA_DM_DISC_MASK_LB_ISO_DEP)
150     {
151         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_LISTEN_B;
152         disc_params[num_params].frequency = 1;
153         num_params++;
154 
155         if (num_params >= max_params)
156             return num_params;
157     }
158 
159     /* Check listening F */
160     if (dm_disc_mask & ( NFA_DM_DISC_MASK_LF_T3T
161                         |NFA_DM_DISC_MASK_LF_NFC_DEP) )
162     {
163         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_LISTEN_F;
164         disc_params[num_params].frequency = 1;
165         num_params++;
166 
167         if (num_params >= max_params)
168             return num_params;
169     }
170 
171     /* Check listening A Active mode */
172     if (dm_disc_mask & NFA_DM_DISC_MASK_LAA_NFC_DEP)
173     {
174         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE;
175         disc_params[num_params].frequency = 1;
176         num_params++;
177 
178         if (num_params >= max_params)
179             return num_params;
180     }
181 
182     /* Check listening F Active mode */
183     if (dm_disc_mask & NFA_DM_DISC_MASK_LFA_NFC_DEP)
184     {
185         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE;
186         disc_params[num_params].frequency = 1;
187         num_params++;
188 
189         if (num_params >= max_params)
190             return num_params;
191     }
192 
193     /* Check polling ISO 15693 */
194     if (dm_disc_mask & NFA_DM_DISC_MASK_P_ISO15693)
195     {
196         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_POLL_ISO15693;
197         disc_params[num_params].frequency = 1;
198         num_params++;
199 
200         if (num_params >= max_params)
201             return num_params;
202     }
203 
204     /* Check polling B' */
205     if (dm_disc_mask & NFA_DM_DISC_MASK_P_B_PRIME)
206     {
207         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_POLL_B_PRIME;
208         disc_params[num_params].frequency = 1;
209         num_params++;
210 
211         if (num_params >= max_params)
212             return num_params;
213     }
214 
215     /* Check polling KOVIO */
216     if (dm_disc_mask & NFA_DM_DISC_MASK_P_KOVIO)
217     {
218         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_POLL_KOVIO;
219         disc_params[num_params].frequency = 1;
220         num_params++;
221 
222         if (num_params >= max_params)
223             return num_params;
224     }
225 
226     /* Check listening ISO 15693 */
227     if (dm_disc_mask & NFA_DM_DISC_MASK_L_ISO15693)
228     {
229         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_LISTEN_ISO15693;
230         disc_params[num_params].frequency = 1;
231         num_params++;
232 
233         if (num_params >= max_params)
234             return num_params;
235     }
236 
237     /* Check listening B' */
238     if (dm_disc_mask & NFA_DM_DISC_MASK_L_B_PRIME)
239     {
240         disc_params[num_params].type      = NFC_DISCOVERY_TYPE_LISTEN_B_PRIME;
241         disc_params[num_params].frequency = 1;
242         num_params++;
243 
244         if (num_params >= max_params)
245             return num_params;
246     }
247 
248     return num_params;
249 }
250 
251 /*******************************************************************************
252 **
253 ** Function         nfa_dm_set_rf_listen_mode_config
254 **
255 ** Description      Update listening protocol to NFCC
256 **
257 ** Returns          NFA_STATUS_OK if success
258 **
259 *******************************************************************************/
nfa_dm_set_rf_listen_mode_config(tNFA_DM_DISC_TECH_PROTO_MASK tech_proto_mask)260 static tNFA_STATUS nfa_dm_set_rf_listen_mode_config (tNFA_DM_DISC_TECH_PROTO_MASK tech_proto_mask)
261 {
262     UINT8 params[40], *p;
263     UINT8 platform  = 0;
264     UINT8 sens_info = 0;
265 
266     NFA_TRACE_DEBUG1 ("nfa_dm_set_rf_listen_mode_config () tech_proto_mask = 0x%08X",
267                        tech_proto_mask);
268 
269     /*
270     ** T1T listen     LA_PROT 0x80, LA_SENS_RES byte1:0x00 byte2:0x0C
271     ** T2T listen     LA_PROT 0x00
272     ** T3T listen     No bit for T3T in LF_PROT (CE T3T set listen parameters, system code, NFCID2, etc.)
273     ** ISO-DEP listen LA_PROT 0x01, LB_PROT 0x01
274     ** NFC-DEP listen LA_PROT 0x02, LF_PROT 0x02
275     */
276 
277     if (tech_proto_mask & NFA_DM_DISC_MASK_LA_T1T)
278     {
279         platform = NCI_PARAM_PLATFORM_T1T;
280     }
281     else if (tech_proto_mask & NFA_DM_DISC_MASK_LA_T2T)
282     {
283         /* platform = 0 and sens_info = 0 */
284     }
285     else
286     {
287         if (tech_proto_mask & NFA_DM_DISC_MASK_LA_ISO_DEP)
288         {
289             sens_info |= NCI_PARAM_SEL_INFO_ISODEP;
290         }
291 
292         if (tech_proto_mask & NFA_DM_DISC_MASK_LA_NFC_DEP)
293         {
294             sens_info |= NCI_PARAM_SEL_INFO_NFCDEP;
295         }
296     }
297 
298     p = params;
299 
300     /*
301     ** for Listen A
302     **
303     ** Set ATQA 0x0C00 for T1T listen
304     ** If the ATQA values are 0x0000, then the FW will use 0x0400
305     ** which works for ISODEP, T2T and NFCDEP.
306     */
307     if (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A] == NFA_DM_DISC_HOST_ID_DH)
308     {
309         UINT8_TO_STREAM (p, NFC_PMID_LA_BIT_FRAME_SDD);
310         UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_BIT_FRAME_SDD);
311         UINT8_TO_STREAM (p, 0x04);
312         UINT8_TO_STREAM (p, NFC_PMID_LA_PLATFORM_CONFIG);
313         UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_PLATFORM_CONFIG);
314         UINT8_TO_STREAM (p, platform);
315         UINT8_TO_STREAM (p, NFC_PMID_LA_SEL_INFO);
316         UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_SEL_INFO);
317         UINT8_TO_STREAM (p, sens_info);
318     }
319     else /* Let NFCC use UICC configuration by configuring with length = 0 */
320     {
321         UINT8_TO_STREAM (p, NFC_PMID_LA_BIT_FRAME_SDD);
322         UINT8_TO_STREAM (p, 0);
323         UINT8_TO_STREAM (p, NFC_PMID_LA_PLATFORM_CONFIG);
324         UINT8_TO_STREAM (p, 0);
325         UINT8_TO_STREAM (p, NFC_PMID_LA_SEL_INFO);
326         UINT8_TO_STREAM (p, 0);
327         UINT8_TO_STREAM (p, NFC_PMID_LA_NFCID1);
328         UINT8_TO_STREAM (p, 0);
329         UINT8_TO_STREAM (p, NFC_PMID_LA_HIST_BY);
330         UINT8_TO_STREAM (p, 0);
331     }
332 
333     /* for Listen B */
334     if (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_B] == NFA_DM_DISC_HOST_ID_DH)
335     {
336         UINT8_TO_STREAM (p, NFC_PMID_LB_SENSB_INFO);
337         UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_SENSB_INFO);
338         if (tech_proto_mask & NFA_DM_DISC_MASK_LB_ISO_DEP)
339         {
340             UINT8_TO_STREAM (p, NCI_LISTEN_PROTOCOL_ISO_DEP);
341         }
342         else
343         {
344             UINT8_TO_STREAM (p,  0x00);
345         }
346     }
347     else /* Let NFCC use UICC configuration by configuring with length = 0 */
348     {
349         UINT8_TO_STREAM (p, NFC_PMID_LB_SENSB_INFO);
350         UINT8_TO_STREAM (p, 0);
351         UINT8_TO_STREAM (p, NFC_PMID_LB_NFCID0);
352         UINT8_TO_STREAM (p, 0);
353         UINT8_TO_STREAM (p, NFC_PMID_LB_APPDATA);
354         UINT8_TO_STREAM (p, 0);
355         UINT8_TO_STREAM (p, NFC_PMID_LB_ADC_FO);
356         UINT8_TO_STREAM (p, 0);
357         UINT8_TO_STREAM (p, NFC_PMID_LB_H_INFO);
358         UINT8_TO_STREAM (p, 0);
359     }
360 
361     /* for Listen F */
362     if (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_F] == NFA_DM_DISC_HOST_ID_DH)
363     {
364         UINT8_TO_STREAM (p, NFC_PMID_LF_PROTOCOL);
365         UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_PROTOCOL);
366         if (tech_proto_mask & NFA_DM_DISC_MASK_LF_NFC_DEP)
367         {
368             UINT8_TO_STREAM (p, NCI_LISTEN_PROTOCOL_NFC_DEP);
369         }
370         else
371         {
372             UINT8_TO_STREAM (p, 0x00);
373         }
374     }
375     else
376     {
377         /* If DH is not listening on T3T, let NFCC use UICC configuration by configuring with length = 0 */
378         if ((tech_proto_mask & NFA_DM_DISC_MASK_LF_T3T) == 0)
379         {
380             UINT8_TO_STREAM (p, NFC_PMID_LF_PROTOCOL);
381             UINT8_TO_STREAM (p, 0);
382             UINT8_TO_STREAM (p, NFC_PMID_LF_T3T_FLAGS2);
383             UINT8_TO_STREAM (p, 0);
384         }
385     }
386 
387     if (p > params)
388     {
389         nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE);
390     }
391 
392     return NFA_STATUS_OK;
393 }
394 
395 /*******************************************************************************
396 **
397 ** Function         nfa_dm_set_total_duration
398 **
399 ** Description      Update total duration to NFCC
400 **
401 ** Returns          void
402 **
403 *******************************************************************************/
nfa_dm_set_total_duration(void)404 static void nfa_dm_set_total_duration (void)
405 {
406     UINT8 params[10], *p;
407 
408     NFA_TRACE_DEBUG0 ("nfa_dm_set_total_duration ()");
409 
410     p = params;
411 
412     /* for total duration */
413     UINT8_TO_STREAM (p, NFC_PMID_TOTAL_DURATION);
414     UINT8_TO_STREAM (p, NCI_PARAM_LEN_TOTAL_DURATION);
415     UINT16_TO_STREAM (p, nfa_dm_cb.disc_cb.disc_duration);
416 
417     if (p > params)
418     {
419         nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE);
420     }
421 }
422 
423 /*******************************************************************************
424 **
425 ** Function         nfa_dm_set_rf_listen_mode_raw_config
426 **
427 ** Description      Set raw listen parameters
428 **
429 ** Returns          void
430 **
431 *******************************************************************************/
nfa_dm_set_rf_listen_mode_raw_config(tNFA_DM_DISC_TECH_PROTO_MASK * p_disc_mask)432 static void nfa_dm_set_rf_listen_mode_raw_config (tNFA_DM_DISC_TECH_PROTO_MASK *p_disc_mask)
433 {
434     tNFA_DM_DISC_TECH_PROTO_MASK disc_mask = 0;
435     tNFA_LISTEN_CFG  *p_cfg = &nfa_dm_cb.disc_cb.excl_listen_config;
436     UINT8 params[250], *p, xx;
437 
438     NFA_TRACE_DEBUG0 ("nfa_dm_set_rf_listen_mode_raw_config ()");
439 
440     /*
441     ** Discovery Configuration Parameters for Listen A
442     */
443     if (  (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A] == NFA_DM_DISC_HOST_ID_DH)
444         &&(p_cfg->la_enable)  )
445     {
446         p = params;
447 
448         UINT8_TO_STREAM (p, NFC_PMID_LA_BIT_FRAME_SDD);
449         UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_BIT_FRAME_SDD);
450         UINT8_TO_STREAM (p, p_cfg->la_bit_frame_sdd);
451 
452         UINT8_TO_STREAM (p, NFC_PMID_LA_PLATFORM_CONFIG);
453         UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_PLATFORM_CONFIG);
454         UINT8_TO_STREAM (p, p_cfg->la_platform_config);
455 
456         UINT8_TO_STREAM (p, NFC_PMID_LA_SEL_INFO);
457         UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_SEL_INFO);
458         UINT8_TO_STREAM (p, p_cfg->la_sel_info);
459 
460         if (p_cfg->la_platform_config == NCI_PARAM_PLATFORM_T1T)
461         {
462             disc_mask |= NFA_DM_DISC_MASK_LA_T1T;
463         }
464         else
465         {
466             /* If T4T or NFCDEP */
467             if (p_cfg->la_sel_info & NCI_PARAM_SEL_INFO_ISODEP)
468             {
469                 disc_mask |= NFA_DM_DISC_MASK_LA_ISO_DEP;
470             }
471 
472             if (p_cfg->la_sel_info & NCI_PARAM_SEL_INFO_NFCDEP)
473             {
474                 disc_mask |= NFA_DM_DISC_MASK_LA_NFC_DEP;
475             }
476 
477             /* If neither, T4T nor NFCDEP, then its T2T */
478             if (disc_mask == 0)
479             {
480                 disc_mask |= NFA_DM_DISC_MASK_LA_T2T;
481             }
482         }
483 
484         UINT8_TO_STREAM (p, NFC_PMID_LA_NFCID1);
485         UINT8_TO_STREAM (p, p_cfg->la_nfcid1_len);
486         ARRAY_TO_STREAM (p, p_cfg->la_nfcid1, p_cfg->la_nfcid1_len);
487 
488         nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE);
489     }
490 
491     /*
492     ** Discovery Configuration Parameters for Listen B
493     */
494     if (  (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_B] == NFA_DM_DISC_HOST_ID_DH)
495         &&(p_cfg->lb_enable)  )
496     {
497         p = params;
498 
499         UINT8_TO_STREAM (p, NFC_PMID_LB_SENSB_INFO);
500         UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_SENSB_INFO);
501         UINT8_TO_STREAM (p, p_cfg->lb_sensb_info);
502 
503         UINT8_TO_STREAM (p, NFC_PMID_LB_NFCID0);
504         UINT8_TO_STREAM (p, p_cfg->lb_nfcid0_len);
505         ARRAY_TO_STREAM (p, p_cfg->lb_nfcid0, p_cfg->lb_nfcid0_len);
506 
507         UINT8_TO_STREAM (p, NFC_PMID_LB_APPDATA);
508         UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_APPDATA);
509         ARRAY_TO_STREAM (p, p_cfg->lb_app_data, NCI_PARAM_LEN_LB_APPDATA);
510 
511         UINT8_TO_STREAM (p, NFC_PMID_LB_SFGI);
512         UINT8_TO_STREAM (p, 1);
513         UINT8_TO_STREAM (p, p_cfg->lb_adc_fo);
514 
515         UINT8_TO_STREAM (p, NFC_PMID_LB_ADC_FO);
516         UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_ADC_FO);
517         UINT8_TO_STREAM (p, p_cfg->lb_adc_fo);
518 
519         nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE);
520 
521         if (p_cfg->lb_sensb_info & NCI_LISTEN_PROTOCOL_ISO_DEP)
522         {
523             disc_mask |= NFA_DM_DISC_MASK_LB_ISO_DEP;
524         }
525     }
526 
527     /*
528     ** Discovery Configuration Parameters for Listen F
529     */
530     if (  (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_F] == NFA_DM_DISC_HOST_ID_DH)
531         &&(p_cfg->lf_enable)  )
532     {
533         p = params;
534 
535         UINT8_TO_STREAM (p, NFC_PMID_LF_CON_BITR_F);
536         UINT8_TO_STREAM (p, 1);
537         UINT8_TO_STREAM (p, p_cfg->lf_con_bitr_f);
538 
539         UINT8_TO_STREAM (p, NFC_PMID_LF_PROTOCOL);
540         UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_PROTOCOL);
541         UINT8_TO_STREAM (p, p_cfg->lf_protocol_type);
542 
543         UINT8_TO_STREAM (p, NFC_PMID_LF_T3T_FLAGS2);
544         UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_T3T_FLAGS2);
545         UINT16_TO_STREAM(p, p_cfg->lf_t3t_flags);
546 
547         /* if the bit at position X is set to 0, SC/NFCID2 with index X shall be ignored */
548         for (xx = 0; xx < NFA_LF_MAX_SC_NFCID2; xx++)
549         {
550             if ((p_cfg->lf_t3t_flags & (0x0001 << xx)) != 0x0000)
551             {
552                 UINT8_TO_STREAM (p, NFC_PMID_LF_T3T_ID1 + xx);
553                 UINT8_TO_STREAM (p, NCI_SYSTEMCODE_LEN + NCI_NFCID2_LEN);
554                 ARRAY_TO_STREAM (p, p_cfg->lf_t3t_identifier[xx], NCI_SYSTEMCODE_LEN + NCI_NFCID2_LEN);
555             }
556         }
557 
558         UINT8_TO_STREAM (p,  NFC_PMID_LF_T3T_PMM);
559         UINT8_TO_STREAM (p,  NCI_PARAM_LEN_LF_T3T_PMM);
560         ARRAY_TO_STREAM (p,  p_cfg->lf_t3t_pmm, NCI_PARAM_LEN_LF_T3T_PMM);
561 
562         nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE);
563 
564         if (p_cfg->lf_t3t_flags != NCI_LF_T3T_FLAGS2_ALL_DISABLED)
565         {
566             disc_mask |= NFA_DM_DISC_MASK_LF_T3T;
567         }
568         if (p_cfg->lf_protocol_type & NCI_LISTEN_PROTOCOL_NFC_DEP)
569         {
570             disc_mask |= NFA_DM_DISC_MASK_LF_NFC_DEP;
571         }
572     }
573 
574     /*
575     ** Discovery Configuration Parameters for Listen ISO-DEP
576     */
577     if ((disc_mask & (NFA_DM_DISC_MASK_LA_ISO_DEP|NFA_DM_DISC_MASK_LB_ISO_DEP))
578       &&(p_cfg->li_enable))
579     {
580         p = params;
581 
582         UINT8_TO_STREAM (p, NFC_PMID_FWI);
583         UINT8_TO_STREAM (p, NCI_PARAM_LEN_FWI);
584         UINT8_TO_STREAM (p, p_cfg->li_fwi);
585 
586         if (disc_mask & NFA_DM_DISC_MASK_LA_ISO_DEP)
587         {
588             UINT8_TO_STREAM (p, NFC_PMID_LA_HIST_BY);
589             UINT8_TO_STREAM (p, p_cfg->la_hist_bytes_len);
590             ARRAY_TO_STREAM (p, p_cfg->la_hist_bytes, p_cfg->la_hist_bytes_len);
591         }
592 
593         if (disc_mask & NFA_DM_DISC_MASK_LB_ISO_DEP)
594         {
595             UINT8_TO_STREAM (p, NFC_PMID_LB_H_INFO);
596             UINT8_TO_STREAM (p, p_cfg->lb_h_info_resp_len);
597             ARRAY_TO_STREAM (p, p_cfg->lb_h_info_resp, p_cfg->lb_h_info_resp_len);
598         }
599 
600         nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE);
601     }
602 
603     /*
604     ** Discovery Configuration Parameters for Listen NFC-DEP
605     */
606     if (  (disc_mask & (NFA_DM_DISC_MASK_LA_NFC_DEP|NFA_DM_DISC_MASK_LF_NFC_DEP))
607         &&(p_cfg->ln_enable))
608     {
609         p = params;
610 
611         UINT8_TO_STREAM (p, NFC_PMID_WT);
612         UINT8_TO_STREAM (p, NCI_PARAM_LEN_WT);
613         UINT8_TO_STREAM (p, p_cfg->ln_wt);
614 
615         UINT8_TO_STREAM (p, NFC_PMID_ATR_RES_GEN_BYTES);
616         UINT8_TO_STREAM (p, p_cfg->ln_atr_res_gen_bytes_len);
617         ARRAY_TO_STREAM (p, p_cfg->ln_atr_res_gen_bytes, p_cfg->ln_atr_res_gen_bytes_len);
618 
619         UINT8_TO_STREAM (p, NFC_PMID_ATR_RSP_CONFIG);
620         UINT8_TO_STREAM (p, 1);
621         UINT8_TO_STREAM (p, p_cfg->ln_atr_res_config);
622 
623         nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE);
624     }
625 
626     *p_disc_mask = disc_mask;
627 
628     NFA_TRACE_DEBUG1 ("nfa_dm_set_rf_listen_mode_raw_config () disc_mask = 0x%x", disc_mask);
629 }
630 
631 /*******************************************************************************
632 **
633 ** Function         nfa_dm_disc_get_disc_mask
634 **
635 ** Description      Convert RF technology, mode and protocol to bit mask
636 **
637 ** Returns          tNFA_DM_DISC_TECH_PROTO_MASK
638 **
639 *******************************************************************************/
nfa_dm_disc_get_disc_mask(tNFC_RF_TECH_N_MODE tech_n_mode,tNFC_PROTOCOL protocol)640 static tNFA_DM_DISC_TECH_PROTO_MASK nfa_dm_disc_get_disc_mask (tNFC_RF_TECH_N_MODE tech_n_mode,
641                                                                tNFC_PROTOCOL       protocol)
642 {
643     /* Set initial disc_mask to legacy poll or listen */
644     tNFA_DM_DISC_TECH_PROTO_MASK disc_mask = ((tech_n_mode & 0x80) ? NFA_DM_DISC_MASK_L_LEGACY : NFA_DM_DISC_MASK_P_LEGACY);
645 
646     switch (tech_n_mode)
647     {
648     case NFC_DISCOVERY_TYPE_POLL_A:
649         switch (protocol)
650         {
651         case NFC_PROTOCOL_T1T:
652             disc_mask = NFA_DM_DISC_MASK_PA_T1T;
653             break;
654         case NFC_PROTOCOL_T2T:
655             disc_mask = NFA_DM_DISC_MASK_PA_T2T;
656             break;
657         case NFC_PROTOCOL_ISO_DEP:
658             disc_mask = NFA_DM_DISC_MASK_PA_ISO_DEP;
659             break;
660         case NFC_PROTOCOL_NFC_DEP:
661             disc_mask = NFA_DM_DISC_MASK_PA_NFC_DEP;
662             break;
663         }
664         break;
665     case NFC_DISCOVERY_TYPE_POLL_B:
666         if (protocol == NFC_PROTOCOL_ISO_DEP)
667             disc_mask = NFA_DM_DISC_MASK_PB_ISO_DEP;
668         break;
669     case NFC_DISCOVERY_TYPE_POLL_F:
670         if (protocol == NFC_PROTOCOL_T3T)
671             disc_mask = NFA_DM_DISC_MASK_PF_T3T;
672         else if (protocol == NFC_PROTOCOL_NFC_DEP)
673             disc_mask = NFA_DM_DISC_MASK_PF_NFC_DEP;
674         break;
675     case NFC_DISCOVERY_TYPE_POLL_ISO15693:
676         disc_mask = NFA_DM_DISC_MASK_P_ISO15693;
677         break;
678     case NFC_DISCOVERY_TYPE_POLL_B_PRIME:
679         disc_mask = NFA_DM_DISC_MASK_P_B_PRIME;
680         break;
681     case NFC_DISCOVERY_TYPE_POLL_KOVIO:
682         disc_mask = NFA_DM_DISC_MASK_P_KOVIO;
683         break;
684     case NFC_DISCOVERY_TYPE_POLL_A_ACTIVE:
685         disc_mask = NFA_DM_DISC_MASK_PAA_NFC_DEP;
686         break;
687     case NFC_DISCOVERY_TYPE_POLL_F_ACTIVE:
688         disc_mask = NFA_DM_DISC_MASK_PFA_NFC_DEP;
689         break;
690 
691     case NFC_DISCOVERY_TYPE_LISTEN_A:
692         switch (protocol)
693         {
694         case NFC_PROTOCOL_T1T:
695             disc_mask = NFA_DM_DISC_MASK_LA_T1T;
696             break;
697         case NFC_PROTOCOL_T2T:
698             disc_mask = NFA_DM_DISC_MASK_LA_T2T;
699             break;
700         case NFC_PROTOCOL_ISO_DEP:
701             disc_mask = NFA_DM_DISC_MASK_LA_ISO_DEP;
702             break;
703         case NFC_PROTOCOL_NFC_DEP:
704             disc_mask = NFA_DM_DISC_MASK_LA_NFC_DEP;
705             break;
706         }
707         break;
708     case NFC_DISCOVERY_TYPE_LISTEN_B:
709         if (protocol == NFC_PROTOCOL_ISO_DEP)
710             disc_mask = NFA_DM_DISC_MASK_LB_ISO_DEP;
711         break;
712     case NFC_DISCOVERY_TYPE_LISTEN_F:
713         if (protocol == NFC_PROTOCOL_T3T)
714             disc_mask = NFA_DM_DISC_MASK_LF_T3T;
715         else if (protocol == NFC_PROTOCOL_NFC_DEP)
716             disc_mask = NFA_DM_DISC_MASK_LF_NFC_DEP;
717         break;
718     case NFC_DISCOVERY_TYPE_LISTEN_ISO15693:
719         disc_mask = NFA_DM_DISC_MASK_L_ISO15693;
720         break;
721     case NFC_DISCOVERY_TYPE_LISTEN_B_PRIME:
722         disc_mask = NFA_DM_DISC_MASK_L_B_PRIME;
723         break;
724     case NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE:
725         disc_mask = NFA_DM_DISC_MASK_LAA_NFC_DEP;
726         break;
727     case NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE:
728         disc_mask = NFA_DM_DISC_MASK_LFA_NFC_DEP;
729         break;
730     }
731 
732     NFA_TRACE_DEBUG3 ("nfa_dm_disc_get_disc_mask (): tech_n_mode:0x%X, protocol:0x%X, disc_mask:0x%X",
733                        tech_n_mode, protocol, disc_mask);
734     return (disc_mask);
735 }
736 
737 /*******************************************************************************
738 **
739 ** Function         nfa_dm_disc_discovery_cback
740 **
741 ** Description      Discovery callback event from NFC
742 **
743 ** Returns          void
744 **
745 *******************************************************************************/
nfa_dm_disc_discovery_cback(tNFC_DISCOVER_EVT event,tNFC_DISCOVER * p_data)746 static void nfa_dm_disc_discovery_cback (tNFC_DISCOVER_EVT event, tNFC_DISCOVER *p_data)
747 {
748     tNFA_DM_RF_DISC_SM_EVENT dm_disc_event = NFA_DM_DISC_SM_MAX_EVENT;
749 
750     NFA_TRACE_DEBUG1 ("nfa_dm_disc_discovery_cback (): event:0x%X", event);
751 
752     switch (event)
753     {
754     case NFC_START_DEVT:
755         dm_disc_event = NFA_DM_RF_DISCOVER_RSP;
756         break;
757     case NFC_RESULT_DEVT:
758         dm_disc_event = NFA_DM_RF_DISCOVER_NTF;
759         break;
760     case NFC_SELECT_DEVT:
761         dm_disc_event = NFA_DM_RF_DISCOVER_SELECT_RSP;
762         break;
763     case NFC_ACTIVATE_DEVT:
764         dm_disc_event = NFA_DM_RF_INTF_ACTIVATED_NTF;
765         break;
766     case NFC_DEACTIVATE_DEVT:
767         if (p_data->deactivate.is_ntf)
768             dm_disc_event = NFA_DM_RF_DEACTIVATE_NTF;
769         else
770             dm_disc_event = NFA_DM_RF_DEACTIVATE_RSP;
771         break;
772     default:
773         NFA_TRACE_ERROR0 ("Unexpected event");
774         return;
775     }
776 
777     nfa_dm_disc_sm_execute (dm_disc_event, (tNFA_DM_RF_DISC_DATA *) p_data);
778 }
779 
780 /*******************************************************************************
781 **
782 ** Function         nfa_dm_disc_notify_started
783 **
784 ** Description      Report NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT or
785 **                  NFA_RF_DISCOVERY_STARTED_EVT, if needed
786 **
787 ** Returns          void
788 **
789 *******************************************************************************/
nfa_dm_disc_notify_started(tNFA_STATUS status)790 static void nfa_dm_disc_notify_started (tNFA_STATUS status)
791 {
792     tNFA_CONN_EVT_DATA      evt_data;
793 
794     if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_NOTIFY)
795     {
796         nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY;
797 
798         evt_data.status = status;
799 
800         if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use)
801             nfa_dm_conn_cback_event_notify (NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT, &evt_data);
802         else
803             nfa_dm_conn_cback_event_notify (NFA_RF_DISCOVERY_STARTED_EVT, &evt_data);
804     }
805 }
806 
807 /*******************************************************************************
808 **
809 ** Function         nfa_dm_disc_conn_event_notify
810 **
811 ** Description      Notify application of CONN_CBACK event, using appropriate
812 **                  callback
813 **
814 ** Returns          nothing
815 **
816 *******************************************************************************/
nfa_dm_disc_conn_event_notify(UINT8 event,tNFA_STATUS status)817 void nfa_dm_disc_conn_event_notify (UINT8 event, tNFA_STATUS status)
818 {
819     tNFA_CONN_EVT_DATA      evt_data;
820 
821     if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_NOTIFY)
822     {
823         nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY;
824         evt_data.status               = status;
825 
826         if (nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)
827         {
828             /* Use exclusive RF mode callback */
829             if (nfa_dm_cb.p_excl_conn_cback)
830                 (*nfa_dm_cb.p_excl_conn_cback) (event, &evt_data);
831         }
832         else
833         {
834             (*nfa_dm_cb.p_conn_cback) (event, &evt_data);
835         }
836     }
837 }
838 
839 /*******************************************************************************
840 **
841 ** Function         nfa_dm_send_deactivate_cmd
842 **
843 ** Description      Send deactivate command to NFCC, if needed.
844 **
845 ** Returns          NFC_STATUS_OK             - deactivate cmd is sent
846 **                  NCI_STATUS_FAILED         - no buffers
847 **                  NFC_STATUS_SEMANTIC_ERROR - this function does not attempt
848 **                                              to send deactivate cmd
849 **
850 *******************************************************************************/
nfa_dm_send_deactivate_cmd(tNFC_DEACT_TYPE deactivate_type)851 static tNFC_STATUS nfa_dm_send_deactivate_cmd (tNFC_DEACT_TYPE deactivate_type)
852 {
853     tNFC_STATUS status = NFC_STATUS_SEMANTIC_ERROR;
854     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);
855 
856     if (!w4_flags)
857     {
858         /* if deactivate CMD was not sent to NFCC */
859         nfa_dm_cb.disc_cb.disc_flags |= (NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF);
860 
861         status = NFC_Deactivate (deactivate_type);
862     }
863     else if ((w4_flags == NFA_DM_DISC_FLAGS_W4_NTF) && (deactivate_type == NFC_DEACTIVATE_TYPE_IDLE))
864     {
865         nfa_dm_cb.disc_cb.disc_flags &= ~(NFA_DM_DISC_FLAGS_W4_NTF);
866         nfa_dm_cb.disc_cb.disc_flags |= (NFA_DM_DISC_FLAGS_W4_RSP);
867         nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY);
868         status = NFC_Deactivate (deactivate_type);
869     }
870 
871     return status;
872 }
873 
874 /*******************************************************************************
875 **
876 ** Function         nfa_dm_start_rf_discover
877 **
878 ** Description      Start RF discovery
879 **
880 ** Returns          void
881 **
882 *******************************************************************************/
nfa_dm_start_rf_discover(void)883 void nfa_dm_start_rf_discover (void)
884 {
885     tNFC_DISCOVER_PARAMS    disc_params[NFA_DM_MAX_DISC_PARAMS];
886     tNFA_DM_DISC_TECH_PROTO_MASK dm_disc_mask = 0, poll_mask, listen_mask;
887     UINT8                   num_params, xx;
888 
889     NFA_TRACE_DEBUG0 ("nfa_dm_start_rf_discover ()");
890     /* Make sure that RF discovery was enabled, or some app has exclusive control */
891     if (  (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED))
892         &&(nfa_dm_cb.disc_cb.excl_disc_entry.in_use == FALSE)  )
893     {
894         return;
895     }
896 
897     /* get listen mode routing table for technology */
898     nfa_ee_get_tech_route (NFA_EE_PWR_STATE_ON, nfa_dm_cb.disc_cb.listen_RT);
899 
900     if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use)
901     {
902         nfa_dm_set_rf_listen_mode_raw_config (&dm_disc_mask);
903         dm_disc_mask |= (nfa_dm_cb.disc_cb.excl_disc_entry.requested_disc_mask & NFA_DM_DISC_MASK_POLL);
904         nfa_dm_cb.disc_cb.excl_disc_entry.selected_disc_mask = dm_disc_mask;
905     }
906     else
907     {
908         /* Collect RF discovery request from sub-modules */
909         for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++)
910         {
911             if (nfa_dm_cb.disc_cb.entry[xx].in_use)
912             {
913                 poll_mask = (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask & NFA_DM_DISC_MASK_POLL);
914 
915                 /* clear poll mode technolgies and protocols which are already used by others */
916                 poll_mask &= ~(dm_disc_mask & NFA_DM_DISC_MASK_POLL);
917 
918                 listen_mask = 0;
919 
920                 /*
921                 ** add listen mode technolgies and protocols if host ID is matched to listen mode routing table
922                 */
923 
924                 /* NFC-A */
925                 if (nfa_dm_cb.disc_cb.entry[xx].host_id == nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A])
926                 {
927                     listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask
928                                    & ( NFA_DM_DISC_MASK_LA_T1T
929                                       |NFA_DM_DISC_MASK_LA_T2T
930                                       |NFA_DM_DISC_MASK_LA_ISO_DEP
931                                       |NFA_DM_DISC_MASK_LA_NFC_DEP
932                                       |NFA_DM_DISC_MASK_LAA_NFC_DEP );
933                 }
934                 else
935                 {
936                     /* host can listen ISO-DEP based on AID routing */
937                     listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask  & NFA_DM_DISC_MASK_LA_ISO_DEP);
938                     listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask  & NFA_DM_DISC_MASK_LA_NFC_DEP);
939                     listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask  & NFA_DM_DISC_MASK_LAA_NFC_DEP);
940                 }
941 
942                 /* NFC-B */
943                 /* multiple hosts can listen ISO-DEP based on AID routing */
944                 listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask
945                                & NFA_DM_DISC_MASK_LB_ISO_DEP;
946 
947                 /* NFC-F */
948                 if (nfa_dm_cb.disc_cb.entry[xx].host_id == nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_F])
949                 {
950                     listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask
951                                    & ( NFA_DM_DISC_MASK_LF_T3T
952                                       |NFA_DM_DISC_MASK_LF_NFC_DEP
953                                       |NFA_DM_DISC_MASK_LFA_NFC_DEP );
954                 }
955                 else
956                 {
957                     /* NFCC can listen T3T based on NFCID routing */
958                     listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask  & NFA_DM_DISC_MASK_LF_T3T);
959                 }
960 
961                 /* NFC-B Prime */
962                 if (nfa_dm_cb.disc_cb.entry[xx].host_id == nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_BP])
963                 {
964                     listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask
965                                    & NFA_DM_DISC_MASK_L_B_PRIME;
966                 }
967 
968                 /*
969                 ** clear listen mode technolgies and protocols which are already used by others
970                 */
971 
972                 /* Check if other modules are listening T1T or T2T */
973                 if (dm_disc_mask & (NFA_DM_DISC_MASK_LA_T1T|NFA_DM_DISC_MASK_LA_T2T))
974                 {
975                     listen_mask &= ~( NFA_DM_DISC_MASK_LA_T1T
976                                      |NFA_DM_DISC_MASK_LA_T2T
977                                      |NFA_DM_DISC_MASK_LA_ISO_DEP
978                                      |NFA_DM_DISC_MASK_LA_NFC_DEP );
979                 }
980 
981                 /* T1T/T2T has priority on NFC-A */
982                 if (  (dm_disc_mask & (NFA_DM_DISC_MASK_LA_ISO_DEP|NFA_DM_DISC_MASK_LA_NFC_DEP))
983                     &&(listen_mask & (NFA_DM_DISC_MASK_LA_T1T|NFA_DM_DISC_MASK_LA_T2T)))
984                 {
985                     dm_disc_mask &= ~( NFA_DM_DISC_MASK_LA_ISO_DEP
986                                       |NFA_DM_DISC_MASK_LA_NFC_DEP );
987                 }
988 
989                 /* Don't remove ISO-DEP because multiple hosts can listen ISO-DEP based on AID routing */
990 
991                 /* Check if other modules are listening NFC-DEP */
992                 if (dm_disc_mask & (NFA_DM_DISC_MASK_LA_NFC_DEP | NFA_DM_DISC_MASK_LAA_NFC_DEP))
993                 {
994                     listen_mask &= ~( NFA_DM_DISC_MASK_LA_NFC_DEP
995                                      |NFA_DM_DISC_MASK_LAA_NFC_DEP );
996                 }
997 
998                 nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask = poll_mask | listen_mask;
999 
1000                 NFA_TRACE_DEBUG2 ("nfa_dm_cb.disc_cb.entry[%d].selected_disc_mask = 0x%x",
1001                                    xx, nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask);
1002 
1003                 dm_disc_mask |= nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask;
1004             }
1005         }
1006 
1007         /* Let P2P set GEN bytes for LLCP to NFCC */
1008         if (dm_disc_mask & ( NFA_DM_DISC_MASK_PA_NFC_DEP
1009                             |NFA_DM_DISC_MASK_PF_NFC_DEP
1010                             |NFA_DM_DISC_MASK_LA_NFC_DEP
1011                             |NFA_DM_DISC_MASK_LF_NFC_DEP
1012                             |NFA_DM_DISC_MASK_PAA_NFC_DEP
1013                             |NFA_DM_DISC_MASK_PFA_NFC_DEP
1014                             |NFA_DM_DISC_MASK_LAA_NFC_DEP
1015                             |NFA_DM_DISC_MASK_LFA_NFC_DEP ))
1016         {
1017             nfa_p2p_set_config (dm_disc_mask);
1018         }
1019     }
1020 
1021     NFA_TRACE_DEBUG1 ("dm_disc_mask = 0x%x", dm_disc_mask);
1022 
1023     /* Get Discovery Technology parameters */
1024     num_params = nfa_dm_get_rf_discover_config (dm_disc_mask, disc_params, NFA_DM_MAX_DISC_PARAMS);
1025 
1026     if (num_params)
1027     {
1028         /*
1029         ** NFCC will abort programming personality slots if not available.
1030         ** NFCC programs the personality slots in the following order of RF technologies:
1031         **      NFC-A, NFC-B, NFC-BP, NFC-I93
1032         */
1033 
1034         /* if this is not for exclusive control */
1035         if (!nfa_dm_cb.disc_cb.excl_disc_entry.in_use)
1036         {
1037             /* update listening protocols in each NFC technology */
1038             nfa_dm_set_rf_listen_mode_config (dm_disc_mask);
1039         }
1040 
1041         /* Set polling duty cycle */
1042         nfa_dm_set_total_duration ();
1043         nfa_dm_cb.disc_cb.dm_disc_mask = dm_disc_mask;
1044 
1045         NFC_DiscoveryStart (num_params, disc_params, nfa_dm_disc_discovery_cback);
1046         /* set flag about waiting for response in IDLE state */
1047         nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP;
1048 
1049         /* register callback to get interface error NTF */
1050         NFC_SetStaticRfCback (nfa_dm_disc_data_cback);
1051     }
1052     else
1053     {
1054         /* RF discovery is started but there is no valid technology or protocol to discover */
1055         nfa_dm_disc_notify_started (NFA_STATUS_OK);
1056     }
1057 }
1058 
1059 /*******************************************************************************
1060 **
1061 ** Function         nfa_dm_notify_discovery
1062 **
1063 ** Description      Send RF discovery notification to upper layer
1064 **
1065 ** Returns          void
1066 **
1067 *******************************************************************************/
nfa_dm_notify_discovery(tNFA_DM_RF_DISC_DATA * p_data)1068 static void nfa_dm_notify_discovery (tNFA_DM_RF_DISC_DATA *p_data)
1069 {
1070     tNFA_CONN_EVT_DATA conn_evt;
1071 
1072     /* let application select a device */
1073     conn_evt.disc_result.status = NFA_STATUS_OK;
1074     memcpy (&(conn_evt.disc_result.discovery_ntf),
1075             &(p_data->nfc_discover.result),
1076             sizeof (tNFC_RESULT_DEVT));
1077 
1078     nfa_dm_conn_cback_event_notify (NFA_DISC_RESULT_EVT, &conn_evt);
1079 }
1080 
1081 /*******************************************************************************
1082 **
1083 ** Function         nfa_dm_disc_notify_activation
1084 **
1085 ** Description      Send RF activation notification to sub-module
1086 **
1087 ** Returns          NFA_STATUS_OK if success
1088 **
1089 *******************************************************************************/
nfa_dm_disc_notify_activation(tNFC_DISCOVER * p_data)1090 static tNFA_STATUS nfa_dm_disc_notify_activation (tNFC_DISCOVER *p_data)
1091 {
1092     UINT8   xx, host_id_in_LRT;
1093     UINT8   iso_dep_t3t__listen = NFA_DM_DISC_NUM_ENTRIES;
1094 
1095     tNFC_RF_TECH_N_MODE tech_n_mode = p_data->activate.rf_tech_param.mode;
1096     tNFC_PROTOCOL       protocol    = p_data->activate.protocol;
1097 
1098     tNFA_DM_DISC_TECH_PROTO_MASK activated_disc_mask;
1099 
1100     NFA_TRACE_DEBUG2 ("nfa_dm_disc_notify_activation (): tech_n_mode:0x%X, proto:0x%X",
1101                        tech_n_mode, protocol);
1102 
1103     if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use)
1104     {
1105         nfa_dm_cb.disc_cb.activated_tech_mode    = tech_n_mode;
1106         nfa_dm_cb.disc_cb.activated_rf_disc_id   = p_data->activate.rf_disc_id;
1107         nfa_dm_cb.disc_cb.activated_rf_interface = p_data->activate.intf_param.type;
1108         nfa_dm_cb.disc_cb.activated_protocol     = protocol;
1109         nfa_dm_cb.disc_cb.activated_handle       = NFA_HANDLE_INVALID;
1110 
1111         if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)
1112             (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data);
1113 
1114         return (NFA_STATUS_OK);
1115     }
1116 
1117     /* if this is NFCEE direct RF interface, notify activation to whoever listening UICC */
1118     if (p_data->activate.intf_param.type == NFC_INTERFACE_EE_DIRECT_RF)
1119     {
1120         for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++)
1121         {
1122             if (  (nfa_dm_cb.disc_cb.entry[xx].in_use)
1123                 &&(nfa_dm_cb.disc_cb.entry[xx].host_id != NFA_DM_DISC_HOST_ID_DH))
1124             {
1125                 nfa_dm_cb.disc_cb.activated_rf_disc_id   = p_data->activate.rf_disc_id;
1126                 nfa_dm_cb.disc_cb.activated_rf_interface = p_data->activate.intf_param.type;
1127                 nfa_dm_cb.disc_cb.activated_protocol     = NFC_PROTOCOL_UNKNOWN;
1128                 nfa_dm_cb.disc_cb.activated_handle       = xx;
1129 
1130                 NFA_TRACE_DEBUG2 ("activated_rf_interface:0x%x, activated_handle: 0x%x",
1131                                    nfa_dm_cb.disc_cb.activated_rf_interface,
1132                                    nfa_dm_cb.disc_cb.activated_handle);
1133 
1134                 if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)
1135                     (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data);
1136 
1137                 return (NFA_STATUS_OK);
1138             }
1139         }
1140         return (NFA_STATUS_FAILED);
1141     }
1142 
1143     /* get bit mask of technolgies/mode and protocol */
1144     activated_disc_mask = nfa_dm_disc_get_disc_mask (tech_n_mode, protocol);
1145 
1146     /* get host ID of technology from listen mode routing table */
1147     if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_A)
1148     {
1149         host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A];
1150     }
1151     else if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_B)
1152     {
1153         host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_B];
1154     }
1155     else if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_F)
1156     {
1157         host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_F];
1158     }
1159     else if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_B_PRIME)
1160     {
1161         host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_BP];
1162     }
1163     else    /* DH only */
1164     {
1165         host_id_in_LRT = NFA_DM_DISC_HOST_ID_DH;
1166     }
1167 
1168     if (protocol == NFC_PROTOCOL_NFC_DEP) {
1169         // Force NFC-DEP to the host
1170         host_id_in_LRT = NFA_DM_DISC_HOST_ID_DH;
1171     }
1172 
1173     for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++)
1174     {
1175         /* if any matching NFC technology and protocol */
1176         if (nfa_dm_cb.disc_cb.entry[xx].in_use)
1177         {
1178             if (nfa_dm_cb.disc_cb.entry[xx].host_id == host_id_in_LRT)
1179             {
1180                 if (nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & activated_disc_mask)
1181                     break;
1182             }
1183             else
1184             {
1185                 /* check ISO-DEP listening even if host in LRT is not matched */
1186                 if (protocol == NFC_PROTOCOL_ISO_DEP)
1187                 {
1188                     if (  (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_A)
1189                         &&(nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & NFA_DM_DISC_MASK_LA_ISO_DEP))
1190                     {
1191                         iso_dep_t3t__listen = xx;
1192                     }
1193                     else if (  (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_B)
1194                              &&(nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & NFA_DM_DISC_MASK_LB_ISO_DEP))
1195                     {
1196                         iso_dep_t3t__listen = xx;
1197                     }
1198                 }
1199                 /* check T3T listening even if host in LRT is not matched */
1200                 else if (protocol == NFC_PROTOCOL_T3T)
1201                 {
1202                     if (  (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_F)
1203                         &&(nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & NFA_DM_DISC_MASK_LF_T3T))
1204                     {
1205                         iso_dep_t3t__listen = xx;
1206                     }
1207                 }
1208             }
1209         }
1210     }
1211 
1212     if (xx >= NFA_DM_DISC_NUM_ENTRIES)
1213     {
1214         /* if any ISO-DEP or T3T listening even if host in LRT is not matched */
1215         xx = iso_dep_t3t__listen;
1216     }
1217 
1218     if (xx < NFA_DM_DISC_NUM_ENTRIES)
1219     {
1220         nfa_dm_cb.disc_cb.activated_tech_mode    = tech_n_mode;
1221         nfa_dm_cb.disc_cb.activated_rf_disc_id   = p_data->activate.rf_disc_id;
1222         nfa_dm_cb.disc_cb.activated_rf_interface = p_data->activate.intf_param.type;
1223         nfa_dm_cb.disc_cb.activated_protocol     = protocol;
1224         nfa_dm_cb.disc_cb.activated_handle       = xx;
1225 
1226         NFA_TRACE_DEBUG2 ("activated_protocol:0x%x, activated_handle: 0x%x",
1227                            nfa_dm_cb.disc_cb.activated_protocol,
1228                            nfa_dm_cb.disc_cb.activated_handle);
1229 
1230         if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)
1231             (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data);
1232 
1233         return (NFA_STATUS_OK);
1234     }
1235     else
1236     {
1237         nfa_dm_cb.disc_cb.activated_protocol = NFA_PROTOCOL_INVALID;
1238         nfa_dm_cb.disc_cb.activated_handle   = NFA_HANDLE_INVALID;
1239         return (NFA_STATUS_FAILED);
1240     }
1241 }
1242 
1243 /*******************************************************************************
1244 **
1245 ** Function         nfa_dm_disc_notify_deactivation
1246 **
1247 ** Description      Send deactivation notification to sub-module
1248 **
1249 ** Returns          None
1250 **
1251 *******************************************************************************/
nfa_dm_disc_notify_deactivation(tNFA_DM_RF_DISC_SM_EVENT sm_event,tNFC_DISCOVER * p_data)1252 static void nfa_dm_disc_notify_deactivation (tNFA_DM_RF_DISC_SM_EVENT sm_event,
1253                                              tNFC_DISCOVER *p_data)
1254 {
1255     tNFA_HANDLE         xx;
1256     tNFA_DM_RF_DISC_EVT disc_evt;
1257 
1258     NFA_TRACE_DEBUG1 ("nfa_dm_disc_notify_deactivation (): activated_handle=%d",
1259                        nfa_dm_cb.disc_cb.activated_handle);
1260 
1261     if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING)
1262     {
1263         NFA_TRACE_DEBUG0 ("nfa_dm_disc_notify_deactivation (): for presence check");
1264         return;
1265     }
1266 
1267     if (sm_event == NFA_DM_RF_DEACTIVATE_RSP)
1268     {
1269         /*
1270         ** Activation has been aborted by upper layer in NFA_DM_RFST_W4_HOST_SELECT
1271         ** or NFA_DM_RFST_LISTEN_SLEEP
1272         */
1273         disc_evt = NFA_DM_RF_DISC_CMD_IDLE_CMPL_EVT;
1274     }
1275     else
1276     {
1277         /* Received deactivation NTF */
1278         disc_evt = NFA_DM_RF_DISC_DEACTIVATED_EVT;
1279     }
1280 
1281     if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use)
1282     {
1283         if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)
1284             (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (disc_evt, p_data);
1285     }
1286     else
1287     {
1288         /* notify event to activated module */
1289         xx = nfa_dm_cb.disc_cb.activated_handle;
1290 
1291         if (  (sm_event == NFA_DM_RF_DEACTIVATE_RSP)
1292             ||(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_IDLE)  )
1293         {
1294             /* Don't remove handle in NFA_DM_RFST_W4_HOST_SELECT or NFA_DM_RFST_LISTEN_SLEEP */
1295             nfa_dm_cb.disc_cb.activated_handle = NFA_HANDLE_INVALID;
1296         }
1297 
1298         if ((xx < NFA_DM_DISC_NUM_ENTRIES) && (nfa_dm_cb.disc_cb.entry[xx].in_use))
1299         {
1300             if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)
1301                 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (disc_evt, p_data);
1302         }
1303     }
1304 
1305     /* clear activated information */
1306     nfa_dm_cb.disc_cb.activated_tech_mode    = 0;
1307     nfa_dm_cb.disc_cb.activated_rf_disc_id   = 0;
1308     nfa_dm_cb.disc_cb.activated_rf_interface = 0;
1309     nfa_dm_cb.disc_cb.activated_protocol     = NFA_PROTOCOL_INVALID;
1310 }
1311 
1312 /*******************************************************************************
1313 **
1314 ** Function         nfa_dm_disc_presence_check
1315 **
1316 ** Description      Perform legacy presence check (put tag to sleep, then
1317 **                  wake it up to see if tag is present)
1318 **
1319 ** Returns          TRUE if operation started
1320 **
1321 *******************************************************************************/
nfa_dm_disc_presence_check(void)1322 tNFC_STATUS nfa_dm_disc_presence_check (void)
1323 {
1324     tNFC_STATUS status = NFC_STATUS_FAILED;
1325 
1326     if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE)
1327     {
1328         /* Deactivate to sleep mode */
1329         status = nfa_dm_send_deactivate_cmd(NFC_DEACTIVATE_TYPE_SLEEP);
1330         if (status == NFC_STATUS_OK)
1331         {
1332             /* deactivate to sleep is sent on behave of presence check.
1333              * set the presence check information in control block */
1334             nfa_dm_cb.disc_cb.disc_flags          |= NFA_DM_DISC_FLAGS_CHECKING;
1335             nfa_dm_cb.presence_check_deact_pending = FALSE;
1336         }
1337     }
1338 
1339     return (status);
1340 }
1341 
1342 /*******************************************************************************
1343 **
1344 ** Function         nfa_dm_disc_end_presence_check
1345 **
1346 ** Description      Perform legacy presence check (put tag to sleep, then
1347 **                  wake it up to see if tag is present)
1348 **
1349 ** Returns          TRUE if operation started
1350 **
1351 *******************************************************************************/
nfa_dm_disc_end_presence_check(tNFC_STATUS status)1352 static void nfa_dm_disc_end_presence_check (tNFC_STATUS status)
1353 {
1354     if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING)
1355     {
1356         /* notify RW module that presence checking is finished */
1357         nfa_rw_handle_presence_check_rsp (status);
1358         nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_CHECKING;
1359         if (nfa_dm_cb.presence_check_deact_pending)
1360         {
1361             nfa_dm_cb.presence_check_deact_pending = FALSE;
1362             nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD,
1363                                           (tNFA_DM_RF_DISC_DATA *) &nfa_dm_cb.presence_check_deact_type);
1364         }
1365     }
1366 }
1367 
1368 /*******************************************************************************
1369 **
1370 ** Function         nfa_dm_disc_data_cback
1371 **
1372 ** Description      Monitoring interface error through data callback
1373 **
1374 ** Returns          void
1375 **
1376 *******************************************************************************/
nfa_dm_disc_data_cback(UINT8 conn_id,tNFC_CONN_EVT event,tNFC_CONN * p_data)1377 static void nfa_dm_disc_data_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data)
1378 {
1379     NFA_TRACE_DEBUG0 ("nfa_dm_disc_data_cback ()");
1380 
1381     /* if selection failed */
1382     if (event == NFC_ERROR_CEVT)
1383     {
1384         nfa_dm_disc_sm_execute (NFA_DM_CORE_INTF_ERROR_NTF, NULL);
1385     }
1386     else if (event == NFC_DATA_CEVT)
1387     {
1388         GKI_freebuf (p_data->data.p_data);
1389     }
1390 }
1391 
1392 /*******************************************************************************
1393 **
1394 ** Function         nfa_dm_disc_new_state
1395 **
1396 ** Description      Processing discovery events in NFA_DM_RFST_IDLE state
1397 **
1398 ** Returns          void
1399 **
1400 *******************************************************************************/
nfa_dm_disc_new_state(tNFA_DM_RF_DISC_STATE new_state)1401 void nfa_dm_disc_new_state (tNFA_DM_RF_DISC_STATE new_state)
1402 {
1403     tNFA_CONN_EVT_DATA      evt_data;
1404     tNFA_DM_RF_DISC_STATE   old_state = nfa_dm_cb.disc_cb.disc_state;
1405 
1406 #if (BT_TRACE_VERBOSE == TRUE)
1407     NFA_TRACE_DEBUG5 ("nfa_dm_disc_new_state (): old_state: %s (%d), new_state: %s (%d) disc_flags: 0x%x",
1408                        nfa_dm_disc_state_2_str (nfa_dm_cb.disc_cb.disc_state), nfa_dm_cb.disc_cb.disc_state,
1409                        nfa_dm_disc_state_2_str (new_state), new_state, nfa_dm_cb.disc_cb.disc_flags);
1410 #else
1411     NFA_TRACE_DEBUG3 ("nfa_dm_disc_new_state(): old_state: %d, new_state: %d disc_flags: 0x%x",
1412                        nfa_dm_cb.disc_cb.disc_state, new_state, nfa_dm_cb.disc_cb.disc_flags);
1413 #endif
1414     nfa_dm_cb.disc_cb.disc_state = new_state;
1415     if (new_state == NFA_DM_RFST_IDLE)
1416     {
1417         if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_STOPPING)
1418         {
1419             nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_STOPPING;
1420 
1421             /* if exclusive RF control is stopping */
1422             if (nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)
1423             {
1424                 if (old_state > NFA_DM_RFST_DISCOVERY)
1425                 {
1426                     /* notify deactivation to application */
1427                     evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE;
1428                     nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data);
1429                 }
1430 
1431                 nfa_dm_rel_excl_rf_control_and_notify ();
1432             }
1433             else
1434             {
1435                 evt_data.status = NFA_STATUS_OK;
1436                 nfa_dm_conn_cback_event_notify (NFA_RF_DISCOVERY_STOPPED_EVT, &evt_data);
1437             }
1438         }
1439         if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_DISABLING)
1440         {
1441             nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_DISABLING;
1442             nfa_sys_check_disabled ();
1443         }
1444     }
1445 }
1446 
1447 /*******************************************************************************
1448 **
1449 ** Function         nfa_dm_disc_sm_idle
1450 **
1451 ** Description      Processing discovery events in NFA_DM_RFST_IDLE state
1452 **
1453 ** Returns          void
1454 **
1455 *******************************************************************************/
nfa_dm_disc_sm_idle(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)1456 static void nfa_dm_disc_sm_idle (tNFA_DM_RF_DISC_SM_EVENT event,
1457                                  tNFA_DM_RF_DISC_DATA *p_data)
1458 {
1459     UINT8              xx;
1460 
1461     switch (event)
1462     {
1463     case NFA_DM_RF_DISCOVER_CMD:
1464         nfa_dm_start_rf_discover ();
1465         break;
1466 
1467     case NFA_DM_RF_DISCOVER_RSP:
1468         nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
1469 
1470         if (p_data->nfc_discover.status == NFC_STATUS_OK)
1471         {
1472             nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY);
1473 
1474             /* if RF discovery was stopped while waiting for response */
1475             if (nfa_dm_cb.disc_cb.disc_flags & (NFA_DM_DISC_FLAGS_STOPPING|NFA_DM_DISC_FLAGS_DISABLING))
1476             {
1477                 /* stop discovery */
1478                 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP;
1479                 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
1480                 break;
1481             }
1482 
1483             if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use)
1484             {
1485                 if (nfa_dm_cb.disc_cb.excl_disc_entry.disc_flags & NFA_DM_DISC_FLAGS_NOTIFY)
1486                 {
1487                     nfa_dm_cb.disc_cb.excl_disc_entry.disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY;
1488 
1489                     if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)
1490                         (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (NFA_DM_RF_DISC_START_EVT, (tNFC_DISCOVER*) p_data);
1491                 }
1492             }
1493             else
1494             {
1495                 /* notify event to each module which is waiting for start */
1496                 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++)
1497                 {
1498                     /* if registered module is waiting for starting discovery */
1499                     if (  (nfa_dm_cb.disc_cb.entry[xx].in_use)
1500                         &&(nfa_dm_cb.disc_cb.dm_disc_mask & nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask)
1501                         &&(nfa_dm_cb.disc_cb.entry[xx].disc_flags & NFA_DM_DISC_FLAGS_NOTIFY)  )
1502                     {
1503                         nfa_dm_cb.disc_cb.entry[xx].disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY;
1504 
1505                         if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)
1506                             (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_START_EVT, (tNFC_DISCOVER*) p_data);
1507                     }
1508                 }
1509 
1510             }
1511             nfa_dm_disc_notify_started (p_data->nfc_discover.status);
1512         }
1513         else
1514         {
1515             /* in rare case that the discovery states of NFCC and DH mismatch and NFCC rejects Discover Cmd
1516              * deactivate idle and then start disvocery when got deactivate rsp */
1517             nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP;
1518             NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
1519         }
1520         break;
1521 
1522     case NFA_DM_RF_DEACTIVATE_RSP:
1523         /* restart discovery */
1524         nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
1525         if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_DISABLING)
1526         {
1527             nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_DISABLING;
1528             nfa_sys_check_disabled ();
1529         }
1530         else
1531             nfa_dm_start_rf_discover ();
1532         break;
1533 
1534     case NFA_DM_LP_LISTEN_CMD:
1535         nfa_dm_disc_new_state (NFA_DM_RFST_LP_LISTEN);
1536         break;
1537 
1538     default:
1539         NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_idle (): Unexpected discovery event");
1540         break;
1541     }
1542 }
1543 
1544 /*******************************************************************************
1545 **
1546 ** Function         nfa_dm_disc_sm_discovery
1547 **
1548 ** Description      Processing discovery events in NFA_DM_RFST_DISCOVERY state
1549 **
1550 ** Returns          void
1551 **
1552 *******************************************************************************/
nfa_dm_disc_sm_discovery(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)1553 static void nfa_dm_disc_sm_discovery (tNFA_DM_RF_DISC_SM_EVENT event,
1554                                       tNFA_DM_RF_DISC_DATA *p_data)
1555 {
1556     switch (event)
1557     {
1558     case NFA_DM_RF_DEACTIVATE_CMD:
1559         /* if deactivate CMD was not sent to NFCC */
1560         if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP))
1561         {
1562             nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP;
1563             NFC_Deactivate (p_data->deactivate_type);
1564         }
1565         break;
1566     case NFA_DM_RF_DEACTIVATE_RSP:
1567         nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
1568         nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
1569         nfa_dm_start_rf_discover ();
1570         break;
1571     case NFA_DM_RF_DISCOVER_NTF:
1572         nfa_dm_disc_new_state (NFA_DM_RFST_W4_ALL_DISCOVERIES);
1573         nfa_dm_notify_discovery (p_data);
1574         break;
1575     case NFA_DM_RF_INTF_ACTIVATED_NTF:
1576         if (p_data->nfc_discover.activate.intf_param.type == NFC_INTERFACE_EE_DIRECT_RF)
1577         {
1578             nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_ACTIVE);
1579         }
1580         else if (p_data->nfc_discover.activate.rf_tech_param.mode & 0x80)
1581         {
1582             /* Listen mode */
1583             nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_ACTIVE);
1584         }
1585         else
1586         {
1587             /* Poll mode */
1588             nfa_dm_disc_new_state (NFA_DM_RFST_POLL_ACTIVE);
1589         }
1590 
1591         if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED)
1592         {
1593             NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf");
1594 
1595             /* after receiving deactivate event, restart discovery */
1596             NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
1597         }
1598         break;
1599 
1600     case NFA_DM_LP_LISTEN_CMD:
1601         break;
1602     case NFA_DM_CORE_INTF_ERROR_NTF:
1603         break;
1604     default:
1605         NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_discovery (): Unexpected discovery event");
1606         break;
1607     }
1608 }
1609 
1610 /*******************************************************************************
1611 **
1612 ** Function         nfa_dm_disc_sm_w4_all_discoveries
1613 **
1614 ** Description      Processing discovery events in NFA_DM_RFST_W4_ALL_DISCOVERIES state
1615 **
1616 ** Returns          void
1617 **
1618 *******************************************************************************/
nfa_dm_disc_sm_w4_all_discoveries(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)1619 static void nfa_dm_disc_sm_w4_all_discoveries (tNFA_DM_RF_DISC_SM_EVENT event,
1620                                                tNFA_DM_RF_DISC_DATA *p_data)
1621 {
1622     switch (event)
1623     {
1624     case NFA_DM_RF_DEACTIVATE_CMD:
1625         /* if deactivate CMD was not sent to NFCC */
1626         if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP))
1627         {
1628             nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP;
1629             /* only IDLE mode is allowed */
1630             NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
1631         }
1632         break;
1633     case NFA_DM_RF_DEACTIVATE_RSP:
1634         nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
1635         nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
1636         nfa_dm_start_rf_discover ();
1637         break;
1638     case NFA_DM_RF_DISCOVER_NTF:
1639         /* Notification Type = NCI_DISCOVER_NTF_LAST or NCI_DISCOVER_NTF_LAST_ABORT */
1640         if (p_data->nfc_discover.result.more != NCI_DISCOVER_NTF_MORE)
1641         {
1642             nfa_dm_disc_new_state (NFA_DM_RFST_W4_HOST_SELECT);
1643         }
1644         nfa_dm_notify_discovery (p_data);
1645         break;
1646     case NFA_DM_RF_INTF_ACTIVATED_NTF:
1647         /*
1648         ** This is only for ISO15693.
1649         ** FW sends activation NTF when all responses are received from tags without host selecting.
1650         */
1651         nfa_dm_disc_new_state (NFA_DM_RFST_POLL_ACTIVE);
1652 
1653         if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED)
1654         {
1655             NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf");
1656 
1657             /* after receiving deactivate event, restart discovery */
1658             NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
1659         }
1660         break;
1661     default:
1662         NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_w4_all_discoveries (): Unexpected discovery event");
1663         break;
1664     }
1665 }
1666 
1667 /*******************************************************************************
1668 **
1669 ** Function         nfa_dm_disc_sm_w4_host_select
1670 **
1671 ** Description      Processing discovery events in NFA_DM_RFST_W4_HOST_SELECT state
1672 **
1673 ** Returns          void
1674 **
1675 *******************************************************************************/
nfa_dm_disc_sm_w4_host_select(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)1676 static void nfa_dm_disc_sm_w4_host_select (tNFA_DM_RF_DISC_SM_EVENT event,
1677                                            tNFA_DM_RF_DISC_DATA *p_data)
1678 {
1679     tNFA_CONN_EVT_DATA conn_evt;
1680     tNFA_DM_DISC_FLAGS  old_pres_check_flag = (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING);
1681     BOOLEAN             pres_check_event = FALSE;
1682     BOOLEAN             pres_check_event_processed = FALSE;
1683 
1684     switch (event)
1685     {
1686     case NFA_DM_RF_DISCOVER_SELECT_CMD:
1687         /* if not waiting to deactivate */
1688         if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP))
1689         {
1690             NFC_DiscoverySelect (p_data->select.rf_disc_id,
1691                                  p_data->select.protocol,
1692                                  p_data->select.rf_interface);
1693         }
1694         else
1695         {
1696             nfa_dm_disc_conn_event_notify (NFA_SELECT_RESULT_EVT, NFA_STATUS_FAILED);
1697         }
1698         break;
1699 
1700     case NFA_DM_RF_DISCOVER_SELECT_RSP:
1701         pres_check_event = TRUE;
1702         /* notify application status of selection */
1703         if (p_data->nfc_discover.status == NFC_STATUS_OK)
1704         {
1705             pres_check_event_processed = TRUE;
1706             conn_evt.status = NFA_STATUS_OK;
1707             /* register callback to get interface error NTF */
1708             NFC_SetStaticRfCback (nfa_dm_disc_data_cback);
1709         }
1710         else
1711             conn_evt.status = NFA_STATUS_FAILED;
1712 
1713         if (!old_pres_check_flag)
1714         {
1715             nfa_dm_disc_conn_event_notify (NFA_SELECT_RESULT_EVT, p_data->nfc_discover.status);
1716         }
1717         break;
1718     case NFA_DM_RF_INTF_ACTIVATED_NTF:
1719         nfa_dm_disc_new_state (NFA_DM_RFST_POLL_ACTIVE);
1720         if (old_pres_check_flag)
1721         {
1722             /* notify RW module of presence of tag */
1723             nfa_rw_handle_presence_check_rsp (NFC_STATUS_OK);
1724             if (nfa_dm_cb.presence_check_deact_pending)
1725             {
1726                 nfa_dm_cb.presence_check_deact_pending = FALSE;
1727                 nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD,
1728                                        (tNFA_DM_RF_DISC_DATA *) &nfa_dm_cb.presence_check_deact_type);
1729             }
1730         }
1731 
1732         else if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED)
1733         {
1734             NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf");
1735 
1736             /* after receiving deactivate event, restart discovery */
1737             NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
1738         }
1739         break;
1740     case NFA_DM_RF_DEACTIVATE_CMD:
1741         if (old_pres_check_flag)
1742         {
1743             nfa_dm_cb.presence_check_deact_pending = TRUE;
1744             nfa_dm_cb.presence_check_deact_type    = p_data->deactivate_type;
1745         }
1746         /* if deactivate CMD was not sent to NFCC */
1747         else if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP))
1748         {
1749             nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP;
1750             /* only IDLE mode is allowed */
1751             NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
1752         }
1753         break;
1754     case NFA_DM_RF_DEACTIVATE_RSP:
1755         nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
1756         nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
1757         nfa_dm_start_rf_discover ();
1758         /* notify exiting from host select state */
1759         nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_RSP, &(p_data->nfc_discover));
1760         break;
1761 
1762     case NFA_DM_CORE_INTF_ERROR_NTF:
1763         pres_check_event    = TRUE;
1764         if (!old_pres_check_flag)
1765         {
1766             /* target activation failed, upper layer may deactivate or select again */
1767             conn_evt.status = NFA_STATUS_FAILED;
1768             nfa_dm_conn_cback_event_notify (NFA_SELECT_RESULT_EVT, &conn_evt);
1769         }
1770         break;
1771     default:
1772         NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_w4_host_select (): Unexpected discovery event");
1773         break;
1774     }
1775 
1776     if (old_pres_check_flag && pres_check_event && !pres_check_event_processed)
1777     {
1778         /* performing presence check for unknow protocol and exception conditions happened
1779          * clear presence check information and report failure */
1780         nfa_dm_disc_end_presence_check (NFC_STATUS_FAILED);
1781         if (nfa_dm_cb.presence_check_deact_pending)
1782         {
1783             nfa_dm_cb.presence_check_deact_pending = FALSE;
1784 
1785             NFC_Deactivate (nfa_dm_cb.presence_check_deact_type);
1786         }
1787     }
1788 }
1789 
1790 /*******************************************************************************
1791 **
1792 ** Function         nfa_dm_disc_sm_poll_active
1793 **
1794 ** Description      Processing discovery events in NFA_DM_RFST_POLL_ACTIVE state
1795 **
1796 ** Returns          void
1797 **
1798 *******************************************************************************/
nfa_dm_disc_sm_poll_active(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)1799 static void nfa_dm_disc_sm_poll_active (tNFA_DM_RF_DISC_SM_EVENT event,
1800                                         tNFA_DM_RF_DISC_DATA *p_data)
1801 {
1802     tNFC_STATUS status;
1803     tNFA_DM_DISC_FLAGS  old_pres_check_flag = (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING);
1804     BOOLEAN             pres_check_event = FALSE;
1805     BOOLEAN             pres_check_event_processed = FALSE;
1806 
1807     switch (event)
1808     {
1809     case NFA_DM_RF_DEACTIVATE_CMD:
1810         if (old_pres_check_flag)
1811         {
1812             /* presence check is already enabled when deactivate cmd is requested,
1813              * keep the information in control block to issue it later */
1814             nfa_dm_cb.presence_check_deact_pending = TRUE;
1815             nfa_dm_cb.presence_check_deact_type    = p_data->deactivate_type;
1816         }
1817         else
1818         {
1819             status = nfa_dm_send_deactivate_cmd(p_data->deactivate_type);
1820         }
1821 
1822         break;
1823     case NFA_DM_RF_DEACTIVATE_RSP:
1824         nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
1825         /* register callback to get interface error NTF */
1826         NFC_SetStaticRfCback (nfa_dm_disc_data_cback);
1827         break;
1828     case NFA_DM_RF_DEACTIVATE_NTF:
1829         pres_check_event    = TRUE;
1830         nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF;
1831         if (  (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP)
1832             ||(p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF)  )
1833         {
1834             nfa_dm_disc_new_state (NFA_DM_RFST_W4_HOST_SELECT);
1835             if (old_pres_check_flag)
1836             {
1837                 pres_check_event_processed  = TRUE;
1838                 /* process pending deactivate request */
1839                 if (nfa_dm_cb.presence_check_deact_pending)
1840                 {
1841                     nfa_dm_cb.presence_check_deact_pending = FALSE;
1842                     /* notify RW module that presence checking is finished */
1843                     nfa_dm_disc_end_presence_check (NFC_STATUS_OK);
1844 
1845                     if (nfa_dm_cb.presence_check_deact_type == NFC_DEACTIVATE_TYPE_IDLE)
1846                         NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
1847                     else
1848                         nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover));
1849                 }
1850                 else
1851                 {
1852                     /* Successfully went to sleep mode for presence check */
1853                     /* Now wake up the tag to see if it is present */
1854                     NFC_DiscoverySelect (nfa_dm_cb.disc_cb.activated_rf_disc_id,
1855                                          nfa_dm_cb.disc_cb.activated_protocol,
1856                                          nfa_dm_cb.disc_cb.activated_rf_interface);
1857                 }
1858 
1859             }
1860         }
1861         else if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_IDLE)
1862         {
1863             nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
1864             nfa_dm_start_rf_discover ();
1865         }
1866         else if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY)
1867         {
1868             nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY);
1869             if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_STOPPING)
1870             {
1871                 /* stop discovery */
1872                 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
1873             }
1874         }
1875         nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover));
1876         break;
1877 
1878     case NFA_DM_CORE_INTF_ERROR_NTF:
1879         pres_check_event    = TRUE;
1880         NFC_Deactivate (NFC_DEACTIVATE_TYPE_DISCOVERY);
1881         break;
1882 
1883     default:
1884         NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_poll_active (): Unexpected discovery event");
1885         break;
1886     }
1887 
1888     if (old_pres_check_flag && pres_check_event && !pres_check_event_processed)
1889     {
1890         /* performing presence check for unknow protocol and exception conditions happened
1891          * clear presence check information and report failure */
1892         nfa_dm_disc_end_presence_check (NFC_STATUS_FAILED);
1893         if (nfa_dm_cb.presence_check_deact_pending)
1894         {
1895             nfa_dm_cb.presence_check_deact_pending = FALSE;
1896 
1897             NFC_Deactivate (nfa_dm_cb.presence_check_deact_type);
1898         }
1899     }
1900 }
1901 
1902 /*******************************************************************************
1903 **
1904 ** Function         nfa_dm_disc_sm_listen_active
1905 **
1906 ** Description      Processing discovery events in NFA_DM_RFST_LISTEN_ACTIVE state
1907 **
1908 ** Returns          void
1909 **
1910 *******************************************************************************/
nfa_dm_disc_sm_listen_active(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)1911 static void nfa_dm_disc_sm_listen_active (tNFA_DM_RF_DISC_SM_EVENT event,
1912                                           tNFA_DM_RF_DISC_DATA     *p_data)
1913 {
1914     switch (event)
1915     {
1916     case NFA_DM_RF_DEACTIVATE_CMD:
1917         nfa_dm_send_deactivate_cmd(p_data->deactivate_type);
1918         break;
1919     case NFA_DM_RF_DEACTIVATE_RSP:
1920         nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
1921         break;
1922     case NFA_DM_RF_DEACTIVATE_NTF:
1923         /* clear both W4_RSP and W4_NTF because of race condition between deactivat CMD and link loss */
1924         nfa_dm_cb.disc_cb.disc_flags &= ~(NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF);
1925 
1926         if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_IDLE)
1927         {
1928             nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
1929             nfa_dm_start_rf_discover ();
1930         }
1931         else if (  (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP)
1932                  ||(p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF)  )
1933         {
1934             nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_SLEEP);
1935         }
1936         else if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY)
1937         {
1938             /* Discovery */
1939             nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY);
1940             if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_STOPPING)
1941             {
1942                 /* stop discovery */
1943                 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
1944             }
1945         }
1946         nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover));
1947         break;
1948 
1949     case NFA_DM_CORE_INTF_ERROR_NTF:
1950         break;
1951     default:
1952         NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_listen_active (): Unexpected discovery event");
1953         break;
1954     }
1955 }
1956 
1957 /*******************************************************************************
1958 **
1959 ** Function         nfa_dm_disc_sm_listen_sleep
1960 **
1961 ** Description      Processing discovery events in NFA_DM_RFST_LISTEN_SLEEP state
1962 **
1963 ** Returns          void
1964 **
1965 *******************************************************************************/
nfa_dm_disc_sm_listen_sleep(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)1966 static void nfa_dm_disc_sm_listen_sleep (tNFA_DM_RF_DISC_SM_EVENT event,
1967                                          tNFA_DM_RF_DISC_DATA *p_data)
1968 {
1969     switch (event)
1970     {
1971     case NFA_DM_RF_DEACTIVATE_CMD:
1972         nfa_dm_send_deactivate_cmd (p_data->deactivate_type);
1973         break;
1974     case NFA_DM_RF_DEACTIVATE_RSP:
1975         nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
1976         /* if deactivate type in CMD was IDLE */
1977         if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF))
1978         {
1979             nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
1980             nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_RSP, &(p_data->nfc_discover));
1981         }
1982         break;
1983     case NFA_DM_RF_DEACTIVATE_NTF:
1984         /* clear both W4_RSP and W4_NTF because of race condition between deactivat CMD and link loss */
1985         nfa_dm_cb.disc_cb.disc_flags &= ~(NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF);
1986         if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_IDLE)
1987         {
1988             nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
1989             nfa_dm_start_rf_discover ();
1990         }
1991         else if (p_data->nfc_discover.deactivate.type == NFA_DEACTIVATE_TYPE_DISCOVERY)
1992         {
1993             nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY);
1994         }
1995         else
1996         {
1997             NFA_TRACE_ERROR0 ("Unexpected deactivation type");
1998             nfa_dm_disc_new_state (NFA_DM_RFST_IDLE);
1999             nfa_dm_start_rf_discover ();
2000         }
2001         nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover));
2002         break;
2003     case NFA_DM_RF_INTF_ACTIVATED_NTF:
2004         nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_ACTIVE);
2005         if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED)
2006         {
2007             NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf");
2008 
2009             /* after receiving deactivate event, restart discovery */
2010             NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE);
2011         }
2012         break;
2013     default:
2014         NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_listen_sleep (): Unexpected discovery event");
2015         break;
2016     }
2017 }
2018 
2019 /*******************************************************************************
2020 **
2021 ** Function         nfa_dm_disc_sm_lp_listen
2022 **
2023 ** Description      Processing discovery events in NFA_DM_RFST_LP_LISTEN state
2024 **
2025 ** Returns          void
2026 **
2027 *******************************************************************************/
nfa_dm_disc_sm_lp_listen(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)2028 static void nfa_dm_disc_sm_lp_listen (tNFA_DM_RF_DISC_SM_EVENT event,
2029                                            tNFA_DM_RF_DISC_DATA *p_data)
2030 {
2031     switch (event)
2032     {
2033     case NFA_DM_RF_INTF_ACTIVATED_NTF:
2034         nfa_dm_disc_new_state (NFA_DM_RFST_LP_ACTIVE);
2035         nfa_dm_disc_notify_activation (&(p_data->nfc_discover));
2036         break;
2037 
2038     default:
2039         NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_lp_listen (): Unexpected discovery event");
2040         break;
2041     }
2042 }
2043 
2044 /*******************************************************************************
2045 **
2046 ** Function         nfa_dm_disc_sm_lp_active
2047 **
2048 ** Description      Processing discovery events in NFA_DM_RFST_LP_ACTIVE state
2049 **
2050 ** Returns          void
2051 **
2052 *******************************************************************************/
nfa_dm_disc_sm_lp_active(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)2053 static void nfa_dm_disc_sm_lp_active (tNFA_DM_RF_DISC_SM_EVENT event,
2054                                            tNFA_DM_RF_DISC_DATA *p_data)
2055 {
2056     switch (event)
2057     {
2058     case NFA_DM_RF_DEACTIVATE_NTF:
2059         nfa_dm_disc_new_state (NFA_DM_RFST_LP_LISTEN);
2060         nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover));
2061         break;
2062     default:
2063         NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_lp_active (): Unexpected discovery event");
2064         break;
2065     }
2066 }
2067 
2068 /*******************************************************************************
2069 **
2070 ** Function         nfa_dm_disc_sm_execute
2071 **
2072 ** Description      Processing discovery related events
2073 **
2074 ** Returns          void
2075 **
2076 *******************************************************************************/
nfa_dm_disc_sm_execute(tNFA_DM_RF_DISC_SM_EVENT event,tNFA_DM_RF_DISC_DATA * p_data)2077 void nfa_dm_disc_sm_execute (tNFA_DM_RF_DISC_SM_EVENT event, tNFA_DM_RF_DISC_DATA *p_data)
2078 {
2079 #if (BT_TRACE_VERBOSE == TRUE)
2080     NFA_TRACE_DEBUG5 ("nfa_dm_disc_sm_execute (): state: %s (%d), event: %s(%d) disc_flags: 0x%x",
2081                        nfa_dm_disc_state_2_str (nfa_dm_cb.disc_cb.disc_state), nfa_dm_cb.disc_cb.disc_state,
2082                        nfa_dm_disc_event_2_str (event), event, nfa_dm_cb.disc_cb.disc_flags);
2083 #else
2084     NFA_TRACE_DEBUG3 ("nfa_dm_disc_sm_execute(): state: %d, event:%d disc_flags: 0x%x",
2085                        nfa_dm_cb.disc_cb.disc_state, event, nfa_dm_cb.disc_cb.disc_flags);
2086 #endif
2087 
2088     switch (nfa_dm_cb.disc_cb.disc_state)
2089     {
2090     /*  RF Discovery State - Idle */
2091     case NFA_DM_RFST_IDLE:
2092         nfa_dm_disc_sm_idle (event, p_data);
2093         break;
2094 
2095     /* RF Discovery State - Discovery */
2096     case NFA_DM_RFST_DISCOVERY:
2097         nfa_dm_disc_sm_discovery (event, p_data);
2098         break;
2099 
2100     /*RF Discovery State - Wait for all discoveries */
2101     case NFA_DM_RFST_W4_ALL_DISCOVERIES:
2102         nfa_dm_disc_sm_w4_all_discoveries (event, p_data);
2103         break;
2104 
2105     /* RF Discovery State - Wait for host selection */
2106     case NFA_DM_RFST_W4_HOST_SELECT:
2107         nfa_dm_disc_sm_w4_host_select (event, p_data);
2108         break;
2109 
2110     /* RF Discovery State - Poll mode activated */
2111     case NFA_DM_RFST_POLL_ACTIVE:
2112         nfa_dm_disc_sm_poll_active (event, p_data);
2113         break;
2114 
2115     /* RF Discovery State - listen mode activated */
2116     case NFA_DM_RFST_LISTEN_ACTIVE:
2117         nfa_dm_disc_sm_listen_active (event, p_data);
2118         break;
2119 
2120     /* RF Discovery State - listen mode sleep */
2121     case NFA_DM_RFST_LISTEN_SLEEP:
2122         nfa_dm_disc_sm_listen_sleep (event, p_data);
2123         break;
2124 
2125     /* Listening in Low Power mode    */
2126     case NFA_DM_RFST_LP_LISTEN:
2127         nfa_dm_disc_sm_lp_listen (event, p_data);
2128         break;
2129 
2130     /* Activated in Low Power mode    */
2131     case NFA_DM_RFST_LP_ACTIVE:
2132         nfa_dm_disc_sm_lp_active (event, p_data);
2133         break;
2134     }
2135 #if (BT_TRACE_VERBOSE == TRUE)
2136     NFA_TRACE_DEBUG3 ("nfa_dm_disc_sm_execute (): new state: %s (%d), disc_flags: 0x%x",
2137                        nfa_dm_disc_state_2_str (nfa_dm_cb.disc_cb.disc_state), nfa_dm_cb.disc_cb.disc_state,
2138                        nfa_dm_cb.disc_cb.disc_flags);
2139 #else
2140     NFA_TRACE_DEBUG2 ("nfa_dm_disc_sm_execute(): new state: %d,  disc_flags: 0x%x",
2141                        nfa_dm_cb.disc_cb.disc_state, nfa_dm_cb.disc_cb.disc_flags);
2142 #endif
2143 }
2144 
2145 /*******************************************************************************
2146 **
2147 ** Function         nfa_dm_add_rf_discover
2148 **
2149 ** Description      Add discovery configuration and callback function
2150 **
2151 ** Returns          valid handle if success
2152 **
2153 *******************************************************************************/
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)2154 tNFA_HANDLE nfa_dm_add_rf_discover (tNFA_DM_DISC_TECH_PROTO_MASK disc_mask,
2155                                     tNFA_DM_DISC_HOST_ID         host_id,
2156                                     tNFA_DISCOVER_CBACK         *p_disc_cback)
2157 {
2158     UINT8       xx;
2159 
2160     NFA_TRACE_DEBUG1 ("nfa_dm_add_rf_discover () disc_mask=0x%x", disc_mask);
2161 
2162     for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++)
2163     {
2164         if (!nfa_dm_cb.disc_cb.entry[xx].in_use)
2165         {
2166             nfa_dm_cb.disc_cb.entry[xx].in_use              = TRUE;
2167             nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask = disc_mask;
2168             nfa_dm_cb.disc_cb.entry[xx].host_id             = host_id;
2169             nfa_dm_cb.disc_cb.entry[xx].p_disc_cback        = p_disc_cback;
2170             nfa_dm_cb.disc_cb.entry[xx].disc_flags          = NFA_DM_DISC_FLAGS_NOTIFY;
2171             return xx;
2172         }
2173     }
2174 
2175     return NFA_HANDLE_INVALID;
2176 }
2177 
2178 /*******************************************************************************
2179 **
2180 ** Function         nfa_dm_start_excl_discovery
2181 **
2182 ** Description      Start exclusive RF discovery
2183 **
2184 ** Returns          void
2185 **
2186 *******************************************************************************/
nfa_dm_start_excl_discovery(tNFA_TECHNOLOGY_MASK poll_tech_mask,tNFA_LISTEN_CFG * p_listen_cfg,tNFA_DISCOVER_CBACK * p_disc_cback)2187 void nfa_dm_start_excl_discovery (tNFA_TECHNOLOGY_MASK poll_tech_mask,
2188                                   tNFA_LISTEN_CFG *p_listen_cfg,
2189                                   tNFA_DISCOVER_CBACK  *p_disc_cback)
2190 {
2191     tNFA_DM_DISC_TECH_PROTO_MASK poll_disc_mask = 0;
2192 
2193     NFA_TRACE_DEBUG0 ("nfa_dm_start_excl_discovery ()");
2194 
2195     if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A)
2196     {
2197         poll_disc_mask |= NFA_DM_DISC_MASK_PA_T1T;
2198         poll_disc_mask |= NFA_DM_DISC_MASK_PA_T2T;
2199         poll_disc_mask |= NFA_DM_DISC_MASK_PA_ISO_DEP;
2200         poll_disc_mask |= NFA_DM_DISC_MASK_PA_NFC_DEP;
2201         poll_disc_mask |= NFA_DM_DISC_MASK_P_LEGACY;
2202     }
2203     if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE)
2204     {
2205         poll_disc_mask |= NFA_DM_DISC_MASK_PAA_NFC_DEP;
2206     }
2207     if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B)
2208     {
2209         poll_disc_mask |= NFA_DM_DISC_MASK_PB_ISO_DEP;
2210     }
2211     if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F)
2212     {
2213         poll_disc_mask |= NFA_DM_DISC_MASK_PF_T3T;
2214         poll_disc_mask |= NFA_DM_DISC_MASK_PF_NFC_DEP;
2215     }
2216     if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE)
2217     {
2218         poll_disc_mask |= NFA_DM_DISC_MASK_PFA_NFC_DEP;
2219     }
2220     if (poll_tech_mask & NFA_TECHNOLOGY_MASK_ISO15693)
2221     {
2222         poll_disc_mask |= NFA_DM_DISC_MASK_P_ISO15693;
2223     }
2224     if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B_PRIME)
2225     {
2226         poll_disc_mask |= NFA_DM_DISC_MASK_P_B_PRIME;
2227     }
2228     if (poll_tech_mask & NFA_TECHNOLOGY_MASK_KOVIO)
2229     {
2230         poll_disc_mask |= NFA_DM_DISC_MASK_P_KOVIO;
2231     }
2232 
2233     nfa_dm_cb.disc_cb.excl_disc_entry.in_use              = TRUE;
2234     nfa_dm_cb.disc_cb.excl_disc_entry.requested_disc_mask = poll_disc_mask;
2235     nfa_dm_cb.disc_cb.excl_disc_entry.host_id             = NFA_DM_DISC_HOST_ID_DH;
2236     nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback        = p_disc_cback;
2237     nfa_dm_cb.disc_cb.excl_disc_entry.disc_flags          = NFA_DM_DISC_FLAGS_NOTIFY;
2238 
2239     memcpy (&nfa_dm_cb.disc_cb.excl_listen_config, p_listen_cfg, sizeof (tNFA_LISTEN_CFG));
2240 
2241     nfa_dm_disc_sm_execute (NFA_DM_RF_DISCOVER_CMD, NULL);
2242 }
2243 
2244 /*******************************************************************************
2245 **
2246 ** Function         nfa_dm_stop_excl_discovery
2247 **
2248 ** Description      Stop exclusive RF discovery
2249 **
2250 ** Returns          void
2251 **
2252 *******************************************************************************/
nfa_dm_stop_excl_discovery(void)2253 void nfa_dm_stop_excl_discovery (void)
2254 {
2255     NFA_TRACE_DEBUG0 ("nfa_dm_stop_excl_discovery ()");
2256 
2257     nfa_dm_cb.disc_cb.excl_disc_entry.in_use       = FALSE;
2258     nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback = NULL;
2259 }
2260 
2261 /*******************************************************************************
2262 **
2263 ** Function         nfa_dm_delete_rf_discover
2264 **
2265 ** Description      Remove discovery configuration and callback function
2266 **
2267 ** Returns          void
2268 **
2269 *******************************************************************************/
nfa_dm_delete_rf_discover(tNFA_HANDLE handle)2270 void nfa_dm_delete_rf_discover (tNFA_HANDLE handle)
2271 {
2272     NFA_TRACE_DEBUG1 ("nfa_dm_delete_rf_discover () handle=0x%x", handle);
2273 
2274     if (handle < NFA_DM_DISC_NUM_ENTRIES)
2275     {
2276         nfa_dm_cb.disc_cb.entry[handle].in_use = FALSE;
2277     }
2278     else
2279     {
2280         NFA_TRACE_ERROR0 ("Invalid discovery handle");
2281     }
2282 }
2283 
2284 /*******************************************************************************
2285 **
2286 ** Function         nfa_dm_rf_discover_select
2287 **
2288 ** Description      Select target, protocol and RF interface
2289 **
2290 ** Returns          void
2291 **
2292 *******************************************************************************/
nfa_dm_rf_discover_select(UINT8 rf_disc_id,tNFA_NFC_PROTOCOL protocol,tNFA_INTF_TYPE rf_interface)2293 void nfa_dm_rf_discover_select (UINT8             rf_disc_id,
2294                                        tNFA_NFC_PROTOCOL protocol,
2295                                        tNFA_INTF_TYPE    rf_interface)
2296 {
2297     tNFA_DM_DISC_SELECT_PARAMS select_params;
2298     tNFA_CONN_EVT_DATA conn_evt;
2299 
2300     NFA_TRACE_DEBUG3 ("nfa_dm_disc_select () rf_disc_id:0x%X, protocol:0x%X, rf_interface:0x%X",
2301                        rf_disc_id, protocol, rf_interface);
2302 
2303     if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_HOST_SELECT)
2304     {
2305         /* state is OK: notify the status when the response is received from NFCC */
2306         select_params.rf_disc_id   = rf_disc_id;
2307         select_params.protocol     = protocol;
2308         select_params.rf_interface = rf_interface;
2309 
2310         nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_NOTIFY;
2311         nfa_dm_disc_sm_execute (NFA_DM_RF_DISCOVER_SELECT_CMD, (tNFA_DM_RF_DISC_DATA *) &select_params);
2312     }
2313     else
2314     {
2315         /* Wrong state: notify failed status right away */
2316         conn_evt.status = NFA_STATUS_FAILED;
2317         nfa_dm_conn_cback_event_notify (NFA_SELECT_RESULT_EVT, &conn_evt);
2318     }
2319 }
2320 
2321 /*******************************************************************************
2322 **
2323 ** Function         nfa_dm_rf_deactivate
2324 **
2325 ** Description      Deactivate NFC link
2326 **
2327 ** Returns          NFA_STATUS_OK if success
2328 **
2329 *******************************************************************************/
nfa_dm_rf_deactivate(tNFA_DEACTIVATE_TYPE deactivate_type)2330 tNFA_STATUS nfa_dm_rf_deactivate (tNFA_DEACTIVATE_TYPE deactivate_type)
2331 {
2332     NFA_TRACE_DEBUG1 ("nfa_dm_rf_deactivate () deactivate_type:0x%X", deactivate_type);
2333 
2334     if (deactivate_type == NFA_DEACTIVATE_TYPE_SLEEP)
2335     {
2336         if (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_NFC_DEP)
2337             deactivate_type = NFC_DEACTIVATE_TYPE_SLEEP_AF;
2338         else
2339             deactivate_type = NFC_DEACTIVATE_TYPE_SLEEP;
2340     }
2341 
2342     if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_IDLE)
2343     {
2344         return NFA_STATUS_FAILED;
2345     }
2346     else
2347     {
2348         nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD, (tNFA_DM_RF_DISC_DATA *) &deactivate_type);
2349         return NFA_STATUS_OK;
2350     }
2351 }
2352 
2353 #if (BT_TRACE_VERBOSE == TRUE)
2354 /*******************************************************************************
2355 **
2356 ** Function         nfa_dm_disc_state_2_str
2357 **
2358 ** Description      convert nfc discovery state to string
2359 **
2360 *******************************************************************************/
nfa_dm_disc_state_2_str(UINT8 state)2361 static char *nfa_dm_disc_state_2_str (UINT8 state)
2362 {
2363     switch (state)
2364     {
2365     case NFA_DM_RFST_IDLE:
2366         return "IDLE";
2367 
2368     case NFA_DM_RFST_DISCOVERY:
2369         return "DISCOVERY";
2370 
2371     case NFA_DM_RFST_W4_ALL_DISCOVERIES:
2372         return "W4_ALL_DISCOVERIES";
2373 
2374     case NFA_DM_RFST_W4_HOST_SELECT:
2375         return "W4_HOST_SELECT";
2376 
2377     case NFA_DM_RFST_POLL_ACTIVE:
2378         return "POLL_ACTIVE";
2379 
2380     case NFA_DM_RFST_LISTEN_ACTIVE:
2381         return "LISTEN_ACTIVE";
2382 
2383     case NFA_DM_RFST_LISTEN_SLEEP:
2384         return "LISTEN_SLEEP";
2385 
2386     case NFA_DM_RFST_LP_LISTEN:
2387         return "LP_LISTEN";
2388 
2389     case NFA_DM_RFST_LP_ACTIVE:
2390         return "LP_ACTIVE";
2391     }
2392     return "Unknown";
2393 }
2394 
2395 /*******************************************************************************
2396 **
2397 ** Function         nfa_dm_disc_event_2_str
2398 **
2399 ** Description      convert nfc discovery RSP/NTF to string
2400 **
2401 *******************************************************************************/
nfa_dm_disc_event_2_str(UINT8 event)2402 static char *nfa_dm_disc_event_2_str (UINT8 event)
2403 {
2404     switch (event)
2405     {
2406     case NFA_DM_RF_DISCOVER_CMD:
2407         return "DISCOVER_CMD";
2408 
2409     case NFA_DM_RF_DISCOVER_RSP:
2410         return "DISCOVER_RSP";
2411 
2412     case NFA_DM_RF_DISCOVER_NTF:
2413         return "DISCOVER_NTF";
2414 
2415     case NFA_DM_RF_DISCOVER_SELECT_CMD:
2416         return "SELECT_CMD";
2417 
2418     case NFA_DM_RF_DISCOVER_SELECT_RSP:
2419         return "SELECT_RSP";
2420 
2421     case NFA_DM_RF_INTF_ACTIVATED_NTF:
2422         return "ACTIVATED_NTF";
2423 
2424     case NFA_DM_RF_DEACTIVATE_CMD:
2425         return "DEACTIVATE_CMD";
2426 
2427     case NFA_DM_RF_DEACTIVATE_RSP:
2428         return "DEACTIVATE_RSP";
2429 
2430     case NFA_DM_RF_DEACTIVATE_NTF:
2431         return "DEACTIVATE_NTF";
2432 
2433     case NFA_DM_LP_LISTEN_CMD:
2434         return "NFA_DM_LP_LISTEN_CMD";
2435 
2436     case NFA_DM_CORE_INTF_ERROR_NTF:
2437         return "INTF_ERROR_NTF";
2438 
2439     }
2440     return "Unknown";
2441 }
2442 #endif /* BT_TRACE_VERBOSE */
2443