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