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