/******************************************************************************
*
* Copyright (C) 2010-2014 Broadcom Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
/******************************************************************************
*
* This file contains the action functions for device manager state
* machine.
*
******************************************************************************/
#include <string.h>
#include <android-base/stringprintf.h>
#include <base/logging.h>
#include "nci_hmsgs.h"
#include "nfa_api.h"
#include "nfa_ce_int.h"
#include "nfa_p2p_int.h"
#include "nfa_rw_api.h"
#include "nfa_rw_int.h"
#if (NFC_NFCEE_INCLUDED == TRUE)
#include "nfa_ee_int.h"
#endif
#if (NFA_SNEP_INCLUDED == TRUE)
#include "nfa_snep_int.h"
#endif
using android::base::StringPrintf;
extern bool nfc_debug_enabled;
/* This is the timeout value to guarantee disable is performed within reasonable
* amount of time */
#ifndef NFA_DM_DISABLE_TIMEOUT_VAL
#define NFA_DM_DISABLE_TIMEOUT_VAL 1000
#endif
static void nfa_dm_set_init_nci_params(void);
static tNFA_STATUS nfa_dm_start_polling(void);
static bool nfa_dm_deactivate_polling(void);
static void nfa_dm_excl_disc_cback(tNFA_DM_RF_DISC_EVT event,
tNFC_DISCOVER* p_data);
static void nfa_dm_poll_disc_cback(tNFA_DM_RF_DISC_EVT event,
tNFC_DISCOVER* p_data);
/*******************************************************************************
**
** Function nfa_dm_module_init_cback
**
** Description Processing initialization complete event from sub-modules
**
** Returns None
**
*******************************************************************************/
static void nfa_dm_module_init_cback(void) {
tNFA_DM_CBACK_DATA dm_cback_data;
nfa_dm_cb.flags &= ~NFA_DM_FLAGS_ENABLE_EVT_PEND;
/* All subsystem are initialized */
dm_cback_data.status = NFA_STATUS_OK;
(*nfa_dm_cb.p_dm_cback)(NFA_DM_ENABLE_EVT, &dm_cback_data);
}
/*******************************************************************************
**
** Function nfa_dm_nfcc_power_mode_proc_complete_cback
**
** Description Processing complete of processing NFCC power state change
** from all sub-modules
**
** Returns None
**
*******************************************************************************/
static void nfa_dm_nfcc_power_mode_proc_complete_cback(void) {
tNFA_DM_PWR_MODE_CHANGE power_mode_change;
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("nfcc_pwr_mode = 0x%x", nfa_dm_cb.nfcc_pwr_mode);
/* if NFCC power state is change to full power */
if (nfa_dm_cb.nfcc_pwr_mode != NFA_DM_PWR_MODE_OFF_SLEEP) {
nfa_dm_cb.flags &= ~NFA_DM_FLAGS_NFCC_IS_RESTORING;
/* reconfigure BRCM NFCC */
nfa_dm_disc_sm_execute(NFA_DM_RF_DISCOVER_CMD, NULL);
}
nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SETTING_PWR_MODE;
power_mode_change.status = NFA_STATUS_OK;
power_mode_change.power_mode = nfa_dm_cb.nfcc_pwr_mode;
tNFA_DM_CBACK_DATA nfa_dm_cback_data;
nfa_dm_cback_data.power_mode = power_mode_change;
(*nfa_dm_cb.p_dm_cback)(NFA_DM_PWR_MODE_CHANGE_EVT, &nfa_dm_cback_data);
}
/*******************************************************************************
**
** Function nfa_dm_sys_enable
**
** Description This function on enable
**
** Returns void
**
*******************************************************************************/
void nfa_dm_sys_enable(void) { nfa_dm_set_init_nci_params(); }
/*******************************************************************************
**
** Function nfa_dm_set_init_nci_params
**
** Description Set initial NCI configuration parameters
**
** Returns void
**
*******************************************************************************/
static void nfa_dm_set_init_nci_params(void) {
uint8_t xx;
/* set NCI default value if other than zero */
if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
/* Default Values: For each identifier
* Octet 0-1 = OxFF
* Octet 2 = Ox02
* Octet 3 = 0xFE
* Octet 4-9 = 0x00
* Octet 10-17 = 0xFF*/
for (xx = 0; xx < NFA_CE_LISTEN_INFO_MAX; xx++) {
nfa_dm_cb.params.lf_t3t_id[xx][0] = 0xFF;
nfa_dm_cb.params.lf_t3t_id[xx][1] = 0xFF;
nfa_dm_cb.params.lf_t3t_id[xx][2] = 0x02;
nfa_dm_cb.params.lf_t3t_id[xx][3] = 0xFE;
}
/* LF_T3T_PMM value is added to LF_T3T_IDENTIFIERS_X in NCI2.0. */
for (xx = 0; xx < NFA_CE_LISTEN_INFO_MAX; xx++) {
for (uint8_t yy = 10; yy < NCI_PARAM_LEN_LF_T3T_ID(NCI_VERSION_2_0); yy++)
nfa_dm_cb.params.lf_t3t_id[xx][yy] = 0xFF;
}
} else {
/* LF_T3T_IDENTIFIERS_1/2/.../16 */
for (xx = 0; xx < NFA_CE_LISTEN_INFO_MAX; xx++) {
nfa_dm_cb.params.lf_t3t_id[xx][0] = 0xFF;
nfa_dm_cb.params.lf_t3t_id[xx][1] = 0xFF;
nfa_dm_cb.params.lf_t3t_id[xx][2] = 0x02;
nfa_dm_cb.params.lf_t3t_id[xx][3] = 0xFE;
}
/* LF_T3T_PMM */
for (xx = 0; xx < NCI_PARAM_LEN_LF_T3T_PMM; xx++) {
nfa_dm_cb.params.lf_t3t_pmm[xx] = 0xFF;
}
}
/* LF_T3T_FLAGS:
** DH needs to set this configuration, even if default value (not listening)
** is used, to let NFCC know of intention (not listening) of DH.
*/
/* FWI */
nfa_dm_cb.params.fwi[0] = 0x04;
/* WT */
nfa_dm_cb.params.wt[0] = 14;
/* Set CE default configuration */
if (p_nfa_dm_ce_cfg[0]) {
nfa_dm_check_set_config(p_nfa_dm_ce_cfg[0], &p_nfa_dm_ce_cfg[1], false);
}
/* Set optional general default configuration */
if (p_nfa_dm_gen_cfg && p_nfa_dm_gen_cfg[0]) {
nfa_dm_check_set_config(p_nfa_dm_gen_cfg[0], &p_nfa_dm_gen_cfg[1], false);
}
if (p_nfa_dm_interface_mapping && nfa_dm_num_dm_interface_mapping) {
NFC_DiscoveryMap(nfa_dm_num_dm_interface_mapping,
p_nfa_dm_interface_mapping, NULL);
}
}
/*******************************************************************************
**
** Function nfa_dm_proc_nfcc_power_mode
**
** Description Processing NFCC power mode changes
**
** Returns None
**
*******************************************************************************/
void nfa_dm_proc_nfcc_power_mode(uint8_t nfcc_power_mode) {
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("nfcc_power_mode=%d", nfcc_power_mode);
/* if NFCC power mode is change to full power */
if (nfcc_power_mode == NFA_DM_PWR_MODE_FULL) {
memset(&nfa_dm_cb.params, 0x00, sizeof(tNFA_DM_PARAMS));
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
"setcfg_pending_mask=0x%x, setcfg_pending_num=%d",
nfa_dm_cb.setcfg_pending_mask, nfa_dm_cb.setcfg_pending_num);
nfa_dm_cb.setcfg_pending_mask = 0;
nfa_dm_cb.setcfg_pending_num = 0;
nfa_dm_set_init_nci_params();
nfa_dm_cb.flags &= ~NFA_DM_FLAGS_POWER_OFF_SLEEP;
} else if (nfcc_power_mode == NFA_DM_PWR_MODE_OFF_SLEEP) {
nfa_dm_cb.flags |= NFA_DM_FLAGS_POWER_OFF_SLEEP;
}
nfa_sys_cback_notify_nfcc_power_mode_proc_complete(NFA_ID_DM);
}
/*******************************************************************************
**
** Function nfa_dm_disable_event
**
** Description report disable event
**
** Returns void
**
*******************************************************************************/
static void nfa_dm_disable_event(void) {
/* Deregister DM from sys */
nfa_sys_deregister(NFA_ID_DM);
/* Notify app */
nfa_dm_cb.flags &=
~(NFA_DM_FLAGS_DM_IS_ACTIVE | NFA_DM_FLAGS_DM_DISABLING_NFC |
NFA_DM_FLAGS_ENABLE_EVT_PEND);
(*nfa_dm_cb.p_dm_cback)(NFA_DM_DISABLE_EVT, NULL);
}
/*******************************************************************************
**
** Function nfa_dm_nfc_response_cback
**
** Description Call DM event hanlder with NFC response callback data
**
** Returns void
**
*******************************************************************************/
static void nfa_dm_nfc_response_cback(tNFC_RESPONSE_EVT event,
tNFC_RESPONSE* p_data) {
tNFA_DM_CBACK_DATA dm_cback_data;
tNFA_CONN_EVT_DATA conn_evt;
uint8_t dm_cback_evt;
uint8_t max_ee = 0;
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("%s(0x%x)", nfa_dm_nfc_revt_2_str(event).c_str(), event);
switch (event) {
case NFC_ENABLE_REVT: /* 0 Enable event */
/* NFC stack enabled. Enable nfa sub-systems */
if (p_data->enable.status == NFC_STATUS_OK) {
if (nfa_ee_max_ee_cfg != 0) {
if (nfa_dm_cb.get_max_ee) {
max_ee = nfa_dm_cb.get_max_ee();
if (max_ee) {
nfa_ee_max_ee_cfg = max_ee;
}
}
}
/* Initialize NFA subsystems */
nfa_sys_enable_subsystems();
} else if (nfa_dm_cb.flags & NFA_DM_FLAGS_ENABLE_EVT_PEND) {
/* Notify app */
nfa_dm_cb.flags &=
~(NFA_DM_FLAGS_ENABLE_EVT_PEND | NFA_DM_FLAGS_DM_IS_ACTIVE);
dm_cback_data.status = p_data->enable.status;
(*nfa_dm_cb.p_dm_cback)(NFA_DM_ENABLE_EVT, &dm_cback_data);
}
break;
case NFC_DISABLE_REVT: /* 1 Disable event */
nfa_dm_disable_event();
break;
case NFC_SET_CONFIG_REVT: /* 2 Set Config Response */
/* If this setconfig was due to NFA_SetConfig, then notify the app */
/* lsb=whether last NCI_SET_CONFIG was due to NFA_SetConfig */
if (nfa_dm_cb.setcfg_pending_mask & 1) {
dm_cback_data.set_config.status = p_data->set_config.status;
dm_cback_data.set_config.num_param_id = p_data->set_config.num_param_id;
memcpy(dm_cback_data.set_config.param_ids, p_data->set_config.param_ids,
p_data->set_config.num_param_id);
(*nfa_dm_cb.p_dm_cback)(NFA_DM_SET_CONFIG_EVT, &dm_cback_data);
}
/* Update the pending mask */
if (nfa_dm_cb.setcfg_pending_num > 0) {
nfa_dm_cb.setcfg_pending_mask >>= 1;
nfa_dm_cb.setcfg_pending_num--;
} else {
/* This should not occur (means we got a SET_CONFIG_NTF that's
* unaccounted for */
LOG(ERROR) << StringPrintf(
"NFA received unexpected NFC_SET_CONFIG_REVT");
}
break;
case NFC_GET_CONFIG_REVT: /* 3 Get Config Response */
if (p_data->get_config.status == NFC_STATUS_OK) {
tNFA_GET_CONFIG* p_nfa_get_confg = &dm_cback_data.get_config;
p_nfa_get_confg->status = NFA_STATUS_OK;
p_nfa_get_confg->tlv_size = p_data->get_config.tlv_size;
p_nfa_get_confg->param_tlvs = p_data->get_config.p_param_tlvs;
(*nfa_dm_cb.p_dm_cback)(NFA_DM_GET_CONFIG_EVT, &dm_cback_data);
return;
}
/* Return result of getconfig to the app */
dm_cback_data.get_config.status = NFA_STATUS_FAILED;
(*nfa_dm_cb.p_dm_cback)(NFA_DM_GET_CONFIG_EVT, &dm_cback_data);
break;
#if (NFC_NFCEE_INCLUDED == TRUE)
case NFC_NFCEE_DISCOVER_REVT: /* NFCEE Discover response */
case NFC_NFCEE_INFO_REVT: /* NFCEE Discover Notification */
case NFC_EE_ACTION_REVT: /* EE Action notification */
case NFC_NFCEE_MODE_SET_REVT: /* NFCEE Mode Set response */
case NFC_NFCEE_STATUS_REVT: /* NFCEE Status notification*/
case NFC_SET_ROUTING_REVT: /* Configure Routing response */
nfa_ee_proc_evt(event, p_data);
break;
case NFC_EE_DISCOVER_REQ_REVT: /* EE Discover Req notification */
if (nfa_dm_is_active() &&
(nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_DISCOVERY)) {
nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_IDLE);
}
nfa_ee_proc_evt(event, p_data);
break;
case NFC_GET_ROUTING_REVT: /* Retrieve Routing response */
break;
#endif
case NFC_SET_POWER_SUB_STATE_REVT:
dm_cback_data.power_sub_state.status = p_data->status;
dm_cback_data.power_sub_state.power_state = nfa_dm_cb.power_state;
(*nfa_dm_cb.p_dm_cback)(NFA_DM_SET_POWER_SUB_STATE_EVT, &dm_cback_data);
break;
case NFC_RF_FIELD_REVT: /* RF Field information */
dm_cback_data.rf_field.status = NFA_STATUS_OK;
dm_cback_data.rf_field.rf_field_status = p_data->rf_field.rf_field;
(*nfa_dm_cb.p_dm_cback)(NFA_DM_RF_FIELD_EVT, &dm_cback_data);
break;
case NFC_GEN_ERROR_REVT: /* generic error command or notification */
break;
case NFC_NFCC_RESTART_REVT: /* NFCC has been re-initialized */
if (p_data->status == NFC_STATUS_OK) {
nfa_dm_cb.nfcc_pwr_mode = NFA_DM_PWR_MODE_FULL;
nfa_dm_cb.flags |= NFA_DM_FLAGS_NFCC_IS_RESTORING;
/* NFCC will start from IDLE when turned on again */
nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP;
nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF;
nfa_dm_cb.disc_cb.disc_state = NFA_DM_RFST_IDLE;
} else {
nfa_dm_cb.nfcc_pwr_mode = NFA_DM_PWR_MODE_OFF_SLEEP;
}
/* Notify NFA submodules change of NFCC power mode */
nfa_sys_cback_reg_nfcc_power_mode_proc_complete(
nfa_dm_nfcc_power_mode_proc_complete_cback);
nfa_sys_notify_nfcc_power_mode(nfa_dm_cb.nfcc_pwr_mode);
break;
case NFC_NFCC_TIMEOUT_REVT:
case NFC_NFCC_TRANSPORT_ERR_REVT:
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("flags:0x%08x", nfa_dm_cb.flags);
dm_cback_evt = (event == NFC_NFCC_TIMEOUT_REVT)
? NFA_DM_NFCC_TIMEOUT_EVT
: NFA_DM_NFCC_TRANSPORT_ERR_EVT;
(*nfa_dm_cb.p_dm_cback)(dm_cback_evt, NULL);
break;
case NFC_NFCC_POWER_OFF_REVT:
nfa_dm_cb.nfcc_pwr_mode = NFA_DM_PWR_MODE_OFF_SLEEP;
/* Notify NFA submodules change of NFCC power mode */
nfa_sys_cback_reg_nfcc_power_mode_proc_complete(
nfa_dm_nfcc_power_mode_proc_complete_cback);
nfa_sys_notify_nfcc_power_mode(NFA_DM_PWR_MODE_OFF_SLEEP);
break;
case NFC_RF_COMM_PARAMS_UPDATE_REVT:
conn_evt.status = p_data->status;
nfa_dm_conn_cback_event_notify(NFA_UPDATE_RF_PARAM_RESULT_EVT, &conn_evt);
break;
default:
break;
}
}
/*******************************************************************************
**
** Function nfa_dm_enable
**
** Description Initialises the NFC device manager
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_enable(tNFA_DM_MSG* p_data) {
tNFA_DM_CBACK_DATA dm_cback_data;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
/* Check if NFA is already enabled */
if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_DM_IS_ACTIVE)) {
/* Initialize BRCM control block, it musb be called before setting any flags
*/
nfa_dm_cb.flags |=
(NFA_DM_FLAGS_DM_IS_ACTIVE | NFA_DM_FLAGS_ENABLE_EVT_PEND);
nfa_sys_cback_reg_enable_complete(nfa_dm_module_init_cback);
/* Store Enable parameters */
nfa_dm_cb.p_dm_cback = p_data->enable.p_dm_cback;
nfa_dm_cb.p_conn_cback = p_data->enable.p_conn_cback;
/* Enable NFC stack */
NFC_Enable(nfa_dm_nfc_response_cback);
} else {
LOG(ERROR) << StringPrintf("nfa_dm_enable: ERROR ALREADY ENABLED.");
dm_cback_data.status = NFA_STATUS_ALREADY_STARTED;
(*(p_data->enable.p_dm_cback))(NFA_DM_ENABLE_EVT, &dm_cback_data);
}
return true;
}
/*******************************************************************************
**
** Function nfa_dm_disable
**
** Description Disables the NFC device manager
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_disable(tNFA_DM_MSG* p_data) {
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("graceful:%d", p_data->disable.graceful);
if (p_data->disable.graceful) {
/* if RF discovery is enabled */
if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED) {
nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_ENABLED;
if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_IDLE) {
/* if waiting RSP in idle state */
if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP) {
nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_DISABLING;
}
} else {
nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_DISABLING;
tNFA_DM_RF_DISC_DATA nfa_dm_rf_disc_data;
nfa_dm_rf_disc_data.deactivate_type = NFA_DEACTIVATE_TYPE_IDLE;
nfa_dm_disc_sm_execute(NFA_DM_RF_DEACTIVATE_CMD, &nfa_dm_rf_disc_data);
if ((nfa_dm_cb.disc_cb.disc_flags &
(NFA_DM_DISC_FLAGS_W4_RSP | NFA_DM_DISC_FLAGS_W4_NTF)) == 0) {
/* not waiting to deactivate, clear the flag now */
nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_DISABLING;
}
}
}
/* Start timeout for graceful shutdown. If timer expires, then force an
* ungraceful shutdown */
nfa_sys_start_timer(&nfa_dm_cb.tle, NFA_DM_TIMEOUT_DISABLE_EVT,
NFA_DM_DISABLE_TIMEOUT_VAL);
}
/* Disable all subsystems other than DM (DM will be disabled after all */
/* the other subsystem have been disabled) */
nfa_sys_disable_subsystems(p_data->disable.graceful);
return true;
}
/*******************************************************************************
**
** Function nfa_dm_disable_complete
**
** Description Called when all NFA subsytems are disabled.
**
** NFC core stack can now be disabled.
**
** Returns void
**
*******************************************************************************/
void nfa_dm_disable_complete(void) {
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
if ((nfa_dm_cb.flags & NFA_DM_FLAGS_DM_DISABLING_NFC) == 0) {
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("proceeding with nfc core shutdown.");
nfa_dm_cb.flags |= NFA_DM_FLAGS_DM_DISABLING_NFC;
nfa_sys_stop_timer(&nfa_dm_cb.tle);
/* Free all buffers for NDEF handlers */
nfa_dm_ndef_dereg_all();
/* Disable nfc core stack */
NFC_Disable();
}
}
/*******************************************************************************
**
** Function nfa_dm_set_config
**
** Description Process set config command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_set_config(tNFA_DM_MSG* p_data) {
tNFC_STATUS status;
uint8_t buff[255];
uint8_t* p = buff;
tNFA_DM_CBACK_DATA dm_cback_data;
if (p_data->setconfig.length + 2 > 255) {
/* Total length of TLV must be less than 256 (1 byte) */
status = NFC_STATUS_FAILED;
} else {
UINT8_TO_STREAM(p, p_data->setconfig.param_id);
UINT8_TO_STREAM(p, p_data->setconfig.length);
ARRAY_TO_STREAM(p, p_data->setconfig.p_data, p_data->setconfig.length)
status = nfa_dm_check_set_config((uint8_t)(p_data->setconfig.length + 2),
buff, true);
}
if (status != NFC_STATUS_OK) {
dm_cback_data.set_config.status = NFA_STATUS_INVALID_PARAM;
(*nfa_dm_cb.p_dm_cback)(NFA_DM_SET_CONFIG_EVT, &dm_cback_data);
}
return true;
}
/*******************************************************************************
**
** Function nfa_dm_get_config
**
** Description Process get config command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_get_config(tNFA_DM_MSG* p_data) {
NFC_GetConfig(p_data->getconfig.num_ids, p_data->getconfig.p_pmids);
return true;
}
/*******************************************************************************
**
** Function nfa_dm_set_power_sub_state
**
** Description Process the power sub state command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_set_power_sub_state(tNFA_DM_MSG* p_data) {
tNFC_STATUS status;
tNFA_DM_CBACK_DATA dm_cback_data;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
nfa_dm_cb.power_state = p_data->set_power_state.screen_state;
if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE) {
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("NFA_DM_RFST_LISTEN_ACTIVE");
/* NFCC will give semantic error for power sub state command in Rf listen
* active state */
status = NFC_STATUS_SEMANTIC_ERROR;
} else {
status = NFC_SetPowerSubState(p_data->set_power_state.screen_state);
}
if (status != NFC_STATUS_OK) {
dm_cback_data.power_sub_state.status = NFC_STATUS_FAILED;
dm_cback_data.power_sub_state.power_state = nfa_dm_cb.power_state;
(*nfa_dm_cb.p_dm_cback)(NFA_DM_SET_POWER_SUB_STATE_EVT, &dm_cback_data);
}
return (true);
}
/*******************************************************************************
**
** Function nfa_dm_conn_cback_event_notify
**
** Description Notify application of CONN_CBACK event, using appropriate
** callback
**
** Returns nothing
**
*******************************************************************************/
void nfa_dm_conn_cback_event_notify(uint8_t event, tNFA_CONN_EVT_DATA* p_data) {
if (nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) {
/* Use exclusive RF mode callback */
if (nfa_dm_cb.p_excl_conn_cback)
(*nfa_dm_cb.p_excl_conn_cback)(event, p_data);
} else {
(*nfa_dm_cb.p_conn_cback)(event, p_data);
}
}
/*******************************************************************************
**
** Function nfa_dm_rel_excl_rf_control_and_notify
**
** Description Stop exclusive RF control and notify app of
** NFA_EXCLUSIVE_RF_CONTROL_STOPPED_EVT
**
** Returns void
**
*******************************************************************************/
void nfa_dm_rel_excl_rf_control_and_notify(void) {
tNFA_CONN_EVT_DATA conn_evt;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
/* Exclusive RF control stopped. Notify app */
nfa_dm_cb.flags &= ~NFA_DM_FLAGS_EXCL_RF_ACTIVE;
/* Stop exclusive RF discovery for exclusive RF mode */
nfa_dm_stop_excl_discovery();
/* Notify app that exclusive RF control has stopped */
conn_evt.status = NFA_STATUS_OK;
(*nfa_dm_cb.p_excl_conn_cback)(NFA_EXCLUSIVE_RF_CONTROL_STOPPED_EVT,
&conn_evt);
nfa_dm_cb.p_excl_conn_cback = NULL;
nfa_dm_cb.p_excl_ndef_cback = NULL;
}
/*******************************************************************************
**
** Function nfa_dm_act_request_excl_rf_ctrl
**
** Description Request exclusive RF control
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_request_excl_rf_ctrl(tNFA_DM_MSG* p_data) {
tNFA_CONN_EVT_DATA conn_evt;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
if (!nfa_dm_cb.p_excl_conn_cback) {
if (nfa_dm_cb.disc_cb.disc_state != NFA_DM_RFST_IDLE) {
conn_evt.status = NFA_STATUS_FAILED;
(*p_data->req_excl_rf_ctrl.p_conn_cback)(
NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT, &conn_evt);
return true;
}
/* Store callbacks */
nfa_dm_cb.p_excl_conn_cback = p_data->req_excl_rf_ctrl.p_conn_cback;
nfa_dm_cb.p_excl_ndef_cback = p_data->req_excl_rf_ctrl.p_ndef_cback;
nfa_dm_cb.flags |= NFA_DM_FLAGS_EXCL_RF_ACTIVE;
/* start exclusive RF discovery */
nfa_dm_start_excl_discovery(p_data->req_excl_rf_ctrl.poll_mask,
&p_data->req_excl_rf_ctrl.listen_cfg,
nfa_dm_excl_disc_cback);
} else {
LOG(ERROR) << StringPrintf("Exclusive rf control already requested");
conn_evt.status = NFA_STATUS_FAILED;
(*p_data->req_excl_rf_ctrl.p_conn_cback)(
NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT, &conn_evt);
}
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_release_excl_rf_ctrl
**
** Description Release exclusive RF control
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_release_excl_rf_ctrl(__attribute__((unused))
tNFA_DM_MSG* p_data) {
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
/* nfa_dm_rel_excl_rf_control_and_notify() is called when discovery state goes
* IDLE */
nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_STOPPING;
/* if discover command has been sent in IDLE state and waiting for response
** then just wait for responose. Otherwise initiate deactivating.
*/
if (!((nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_IDLE) &&
(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP))) {
nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_IDLE);
}
if (nfa_dm_cb.disc_cb.kovio_tle.in_use)
nfa_sys_stop_timer(&nfa_dm_cb.disc_cb.kovio_tle);
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_deactivate
**
** Description Process deactivate command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_deactivate(tNFA_DM_MSG* p_data) {
tNFA_CONN_EVT_DATA conn_evt;
tNFA_DEACTIVATE_TYPE deact_type;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
/* Always allow deactivate to IDLE */
/* Do not allow deactivate to SLEEP for T1T,NFCDEP, ISO15693 */
if (p_data->deactivate.sleep_mode == false ||
(nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_T1T &&
(nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_NFC_DEP ||
appl_dta_mode_flag) &&
nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_T5T &&
nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_KOVIO)) {
deact_type = NFA_DEACTIVATE_TYPE_DISCOVERY;
if (p_data->deactivate.sleep_mode) {
if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_HOST_SELECT) {
/* Deactivate to sleep mode not allowed in this state. */
deact_type = NFA_DEACTIVATE_TYPE_IDLE;
} else if (appl_dta_mode_flag == true &&
(nfa_dm_cb.disc_cb.disc_state != NFA_DM_RFST_LISTEN_SLEEP ||
nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE)) {
deact_type = NFA_DEACTIVATE_TYPE_SLEEP;
} else if (nfa_dm_cb.disc_cb.disc_state != NFA_DM_RFST_LISTEN_SLEEP) {
deact_type = NFA_DEACTIVATE_TYPE_SLEEP;
}
}
if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_ALL_DISCOVERIES) {
/* Only deactivate to IDLE is allowed in this state. */
deact_type = NFA_DEACTIVATE_TYPE_IDLE;
}
if ((nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_NFC_DEP) &&
((nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) == 0x00) &&
appl_dta_mode_flag != true) {
/* Exclusive RF control doesn't use NFA P2P */
/* NFA P2P will deactivate NFC link after deactivating LLCP link */
if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_P2P_PAUSED)) {
nfa_p2p_deactivate_llcp();
} else {
nfa_dm_rf_deactivate(deact_type);
}
return true;
} else {
if (nfa_dm_rf_deactivate(deact_type) == NFA_STATUS_OK) {
if (nfa_dm_cb.disc_cb.kovio_tle.in_use)
nfa_sys_stop_timer(&nfa_dm_cb.disc_cb.kovio_tle);
nfa_rw_stop_presence_check_timer();
return true;
}
}
}
LOG(ERROR) << StringPrintf("invalid protocol, mode or state");
/* Notify error to application */
conn_evt.status = NFA_STATUS_FAILED;
nfa_dm_conn_cback_event_notify(NFA_DEACTIVATE_FAIL_EVT, &conn_evt);
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_power_off_sleep
**
** Description Process power off sleep mode request
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_power_off_sleep(tNFA_DM_MSG* p_data) {
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
NFC_SetPowerOffSleep((bool)(p_data->hdr.layer_specific));
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_reg_vsc
**
** Description Process registers VSC callback
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_reg_vsc(tNFA_DM_MSG* p_data) {
if (NFC_RegVSCback(p_data->reg_vsc.is_register, p_data->reg_vsc.p_cback) !=
NFC_STATUS_OK) {
LOG(ERROR) << StringPrintf("NFC_RegVSCback failed");
}
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_send_vsc
**
** Description Send the NCI Vendor Specific command to the NCI command
** queue
**
** Returns FALSE (message buffer is NOT freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_send_vsc(tNFA_DM_MSG* p_data) {
NFC_HDR* p_cmd = (NFC_HDR*)p_data;
p_cmd->offset = sizeof(tNFA_DM_API_SEND_VSC) - NFC_HDR_SIZE;
p_cmd->len = p_data->send_vsc.cmd_params_len;
NFC_SendVsCommand(p_data->send_vsc.oid, p_cmd, p_data->send_vsc.p_cback);
/* Most dm action functions return TRUE, so nfa-sys frees the GKI buffer
* carrying the message, This action function re-use the GKI buffer to
* send the VSC, so the GKI buffer can not be freed by nfa-sys */
return false;
}
/*******************************************************************************
**
** Function nfa_dm_act_send_raw_vs
**
** Description Send the raw vs command to the NCI command queue
**
** Returns FALSE (message buffer is NOT freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_send_raw_vs(tNFA_DM_MSG* p_data) {
NFC_HDR* p_cmd = (NFC_HDR*)p_data;
p_cmd->offset = sizeof(tNFA_DM_API_SEND_VSC) - NFC_HDR_SIZE;
p_cmd->len = p_data->send_vsc.cmd_params_len;
NFC_SendRawVsCommand(p_cmd, p_data->send_vsc.p_cback);
/* Most dm action functions return TRUE, so nfa-sys frees the GKI buffer
* carrying the message,
* This action function re-use the GKI buffer to send the VSC, so the GKI
* buffer can not be freed by nfa-sys */
return false;
}
/*******************************************************************************
**
** Function nfa_dm_start_polling
**
** Description Start polling
**
** Returns tNFA_STATUS
**
*******************************************************************************/
tNFA_STATUS nfa_dm_start_polling(void) {
tNFA_STATUS status;
tNFA_TECHNOLOGY_MASK poll_tech_mask;
tNFA_DM_DISC_TECH_PROTO_MASK poll_disc_mask = 0;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
poll_tech_mask = nfa_dm_cb.poll_mask;
/* start RF discovery with discovery callback */
if (nfa_dm_cb.poll_disc_handle == NFA_HANDLE_INVALID) {
if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A) {
poll_disc_mask |= NFA_DM_DISC_MASK_PA_T1T;
poll_disc_mask |= NFA_DM_DISC_MASK_PA_T2T;
poll_disc_mask |= NFA_DM_DISC_MASK_PA_ISO_DEP;
poll_disc_mask |= NFA_DM_DISC_MASK_PA_NFC_DEP;
poll_disc_mask |= NFA_DM_DISC_MASK_P_LEGACY;
}
if (NFC_GetNCIVersion() == NCI_VERSION_2_0) {
if (poll_tech_mask & NFA_TECHNOLOGY_MASK_ACTIVE) {
poll_disc_mask |= NFA_DM_DISC_MASK_PACM_NFC_DEP;
}
} else {
if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE) {
poll_disc_mask |= NFA_DM_DISC_MASK_PAA_NFC_DEP;
}
if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE) {
poll_disc_mask |= NFA_DM_DISC_MASK_PFA_NFC_DEP;
}
}
if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B) {
poll_disc_mask |= NFA_DM_DISC_MASK_PB_ISO_DEP;
}
if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F) {
poll_disc_mask |= NFA_DM_DISC_MASK_PF_T3T;
poll_disc_mask |= NFA_DM_DISC_MASK_PF_NFC_DEP;
}
if (poll_tech_mask & NFA_TECHNOLOGY_MASK_V) {
poll_disc_mask |= NFA_DM_DISC_MASK_P_T5T;
}
if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B_PRIME) {
poll_disc_mask |= NFA_DM_DISC_MASK_P_B_PRIME;
}
if (poll_tech_mask & NFA_TECHNOLOGY_MASK_KOVIO) {
poll_disc_mask |= NFA_DM_DISC_MASK_P_KOVIO;
}
nfa_dm_cb.poll_disc_handle = nfa_dm_add_rf_discover(
poll_disc_mask, NFA_DM_DISC_HOST_ID_DH, nfa_dm_poll_disc_cback);
if (nfa_dm_cb.poll_disc_handle != NFA_HANDLE_INVALID)
status = NFA_STATUS_OK;
else
status = NFA_STATUS_FAILED;
} else {
status = NFA_STATUS_OK;
}
return (status);
}
/*******************************************************************************
**
** Function nfa_dm_act_enable_polling
**
** Description Process enable polling command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_enable_polling(tNFA_DM_MSG* p_data) {
tNFA_CONN_EVT_DATA evt_data;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
if ((!(nfa_dm_cb.flags & NFA_DM_FLAGS_POLLING_ENABLED)) &&
(!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE))) {
nfa_dm_cb.poll_mask = p_data->enable_poll.poll_mask;
if (nfa_dm_start_polling() == NFA_STATUS_OK) {
nfa_dm_cb.flags |= NFA_DM_FLAGS_POLLING_ENABLED;
evt_data.status = NFA_STATUS_OK;
nfa_dm_conn_cback_event_notify(NFA_POLL_ENABLED_EVT, &evt_data);
return true;
}
} else {
LOG(ERROR) << StringPrintf("already started");
}
/* send NFA_POLL_ENABLED_EVT with NFA_STATUS_FAILED */
evt_data.status = NFA_STATUS_FAILED;
nfa_dm_conn_cback_event_notify(NFA_POLL_ENABLED_EVT, &evt_data);
return true;
}
/*******************************************************************************
**
** Function nfa_dm_deactivate_polling
**
** Description Deactivate any polling state
**
** Returns TRUE if need to wait for deactivation
**
*******************************************************************************/
static bool nfa_dm_deactivate_polling(void) {
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
if ((nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_ALL_DISCOVERIES) ||
(nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_HOST_SELECT)) {
nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_IDLE);
return false;
} else if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE) {
if (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP) {
/* NFA P2P will deactivate NFC link after deactivating LLCP link */
nfa_p2p_deactivate_llcp();
} else {
nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_IDLE);
}
return true;
} else {
return false;
}
}
/*******************************************************************************
**
** Function nfa_dm_act_disable_polling
**
** Description Process disable polling command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_disable_polling(__attribute__((unused)) tNFA_DM_MSG* p_data) {
tNFA_CONN_EVT_DATA evt_data;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
if (nfa_dm_cb.poll_disc_handle != NFA_HANDLE_INVALID) {
nfa_dm_cb.flags &= ~NFA_DM_FLAGS_POLLING_ENABLED;
if (nfa_dm_deactivate_polling() == false) {
nfa_dm_delete_rf_discover(nfa_dm_cb.poll_disc_handle);
nfa_dm_cb.poll_disc_handle = NFA_HANDLE_INVALID;
evt_data.status = NFA_STATUS_OK;
nfa_dm_conn_cback_event_notify(NFA_POLL_DISABLED_EVT, &evt_data);
} else {
nfa_dm_cb.flags |= NFA_DM_FLAGS_SEND_POLL_STOP_EVT;
}
} else {
evt_data.status = NFA_STATUS_FAILED;
nfa_dm_conn_cback_event_notify(NFA_POLL_DISABLED_EVT, &evt_data);
}
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_enable_listening
**
** Description Process enable listening command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_enable_listening(__attribute__((unused)) tNFA_DM_MSG* p_data) {
tNFA_CONN_EVT_DATA evt_data;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
nfa_dm_cb.flags &= ~NFA_DM_FLAGS_LISTEN_DISABLED;
evt_data.status = NFA_STATUS_OK;
nfa_dm_conn_cback_event_notify(NFA_LISTEN_ENABLED_EVT, &evt_data);
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_disable_listening
**
** Description Process disable listening command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_disable_listening(__attribute__((unused)) tNFA_DM_MSG* p_data) {
tNFA_CONN_EVT_DATA evt_data;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
nfa_dm_cb.flags |= NFA_DM_FLAGS_LISTEN_DISABLED;
evt_data.status = NFA_STATUS_OK;
nfa_dm_conn_cback_event_notify(NFA_LISTEN_DISABLED_EVT, &evt_data);
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_pause_p2p
**
** Description Process Pause P2P command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_pause_p2p(__attribute__((unused)) tNFA_DM_MSG* p_data) {
tNFA_CONN_EVT_DATA evt_data;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
nfa_dm_cb.flags |= NFA_DM_FLAGS_P2P_PAUSED;
evt_data.status = NFA_STATUS_OK;
nfa_dm_conn_cback_event_notify(NFA_P2P_PAUSED_EVT, &evt_data);
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_resume_p2p
**
** Description Process resume P2P command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_resume_p2p(__attribute__((unused)) tNFA_DM_MSG* p_data) {
tNFA_CONN_EVT_DATA evt_data;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
nfa_dm_cb.flags &= ~NFA_DM_FLAGS_P2P_PAUSED;
evt_data.status = NFA_STATUS_OK;
nfa_dm_conn_cback_event_notify(NFA_P2P_RESUMED_EVT, &evt_data);
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_send_raw_frame
**
** Description Send an raw frame on RF link
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_send_raw_frame(tNFA_DM_MSG* p_data) {
tNFC_STATUS status = NFC_STATUS_FAILED;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
/* If NFC link is activated */
if ((nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE) ||
(nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE)) {
nfa_dm_cb.flags |= NFA_DM_FLAGS_RAW_FRAME;
NFC_SetReassemblyFlag(false);
/* If not in exclusive mode, and not activated for LISTEN, then forward raw
* data to NFA_RW to send */
if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) &&
!(nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE) &&
((nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T1T) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T2T) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T3T) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO_DEP) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T5T))) {
/* if RW is checking presence then it will put into pending queue */
status = nfa_rw_send_raw_frame((NFC_HDR*)p_data);
} else {
status = NFC_SendData(NFC_RF_CONN_ID, (NFC_HDR*)p_data);
if (status != NFC_STATUS_OK) {
NFC_SetReassemblyFlag(true);
}
/* Already freed or NCI layer will free buffer */
return false;
}
}
if (status == NFC_STATUS_FAILED) {
NFC_SetReassemblyFlag(true);
/* free the buffer */
return true;
} else {
/* NCI layer will free buffer */
return false;
}
}
/*******************************************************************************
**
** Function nfa_dm_set_p2p_listen_tech
**
** Description Notify change of P2P listen technologies to NFA P2P
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_set_p2p_listen_tech(tNFA_DM_MSG* p_data) {
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("tech_mask = %d", p_data->set_p2p_listen_tech.tech_mask);
nfa_p2p_update_listen_tech(p_data->set_p2p_listen_tech.tech_mask);
nfa_dm_conn_cback_event_notify(NFA_SET_P2P_LISTEN_TECH_EVT, NULL);
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_start_rf_discovery
**
** Description Process start RF discovery command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_start_rf_discovery(__attribute__((unused))
tNFA_DM_MSG* p_data) {
tNFA_CONN_EVT_DATA evt_data;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED) {
evt_data.status = NFA_STATUS_OK;
nfa_dm_conn_cback_event_notify(NFA_RF_DISCOVERY_STARTED_EVT, &evt_data);
} else if (nfa_dm_cb.disc_cb.disc_state != NFA_DM_RFST_IDLE) {
evt_data.status = NFA_STATUS_SEMANTIC_ERROR;
nfa_dm_conn_cback_event_notify(NFA_RF_DISCOVERY_STARTED_EVT, &evt_data);
} else {
nfa_dm_cb.disc_cb.disc_flags |=
(NFA_DM_DISC_FLAGS_ENABLED | NFA_DM_DISC_FLAGS_NOTIFY);
nfa_dm_start_rf_discover();
}
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_stop_rf_discovery
**
** Description Process stop RF discovery command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_stop_rf_discovery(__attribute__((unused)) tNFA_DM_MSG* p_data) {
tNFA_CONN_EVT_DATA evt_data;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED) ||
(nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_IDLE)) {
nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_ENABLED;
/* if discover command has been sent in IDLE state and waiting for response
*/
if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP) {
nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_STOPPING;
} else {
evt_data.status = NFA_STATUS_OK;
nfa_dm_conn_cback_event_notify(NFA_RF_DISCOVERY_STOPPED_EVT, &evt_data);
}
} else {
nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_ENABLED;
nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_STOPPING;
if (nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_IDLE) == NFA_STATUS_OK) {
if (nfa_dm_cb.disc_cb.kovio_tle.in_use)
nfa_sys_stop_timer(&nfa_dm_cb.disc_cb.kovio_tle);
nfa_rw_stop_presence_check_timer();
}
}
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_set_rf_disc_duration
**
** Description Set duration for RF discovery
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_set_rf_disc_duration(tNFA_DM_MSG* p_data) {
nfa_dm_cb.disc_cb.disc_duration = p_data->disc_duration.rf_disc_dur_ms;
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_get_rf_disc_duration
**
** Description Get duration for RF discovery
**
** Returns uint16_t
**
*******************************************************************************/
uint16_t nfa_dm_act_get_rf_disc_duration() {
return (nfa_dm_cb.disc_cb.disc_duration);
}
/*******************************************************************************
**
** Function nfa_dm_act_select
**
** Description Process RF select command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_select(tNFA_DM_MSG* p_data) {
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
nfa_dm_rf_discover_select(p_data->select.rf_disc_id, p_data->select.protocol,
p_data->select.rf_interface);
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_update_rf_params
**
** Description Process update RF communication parameters command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_update_rf_params(tNFA_DM_MSG* p_data) {
tNFA_CONN_EVT_DATA conn_evt;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
if (NFC_UpdateRFCommParams(&p_data->update_rf_params.params) !=
NFC_STATUS_OK) {
conn_evt.status = NFA_STATUS_FAILED;
nfa_dm_conn_cback_event_notify(NFA_UPDATE_RF_PARAM_RESULT_EVT, &conn_evt);
}
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_disable_timeout
**
** Description timeout on disable process. Shutdown immediately
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
bool nfa_dm_act_disable_timeout(__attribute__((unused)) tNFA_DM_MSG* p_data) {
tNFA_DM_MSG nfa_dm_msg;
nfa_dm_msg.disable.graceful = false;
nfa_dm_disable(&nfa_dm_msg);
return true;
}
/*******************************************************************************
**
** Function nfa_dm_act_conn_cback_notify
**
** Description Notify app of reader/writer/ndef events
**
** Returns nothing
**
*******************************************************************************/
void nfa_dm_act_conn_cback_notify(uint8_t event, tNFA_CONN_EVT_DATA* p_data) {
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("event:0x%X", event);
/* Notify event using appropriate CONN_CBACK */
nfa_dm_conn_cback_event_notify(event, p_data);
/* If not in exclusive RF mode, then read NDEF message from tag (if automatic
* reading is enabled) */
if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)) {
if ((event == NFA_NDEF_DETECT_EVT) &&
(nfa_dm_cb.flags & NFA_DM_FLAGS_AUTO_READING_NDEF)) {
/* read NDEF message from tag */
if (p_data->ndef_detect.status == NFA_STATUS_OK) {
NFA_RwReadNDef();
} else if (p_data->ndef_detect.status == NFA_STATUS_FAILED) {
nfa_dm_cb.flags &= ~NFA_DM_FLAGS_AUTO_READING_NDEF;
}
/* ignore NFA_STATUS_BUSY */
} else if ((event == NFA_READ_CPLT_EVT) &&
(nfa_dm_cb.flags & NFA_DM_FLAGS_AUTO_READING_NDEF)) {
/* reading NDEF message is done */
nfa_dm_cb.flags &= ~NFA_DM_FLAGS_AUTO_READING_NDEF;
}
}
}
/*******************************************************************************
**
** Function nfa_dm_act_data_cback
**
** Description Processing data from RF link
**
** Returns None
**
*******************************************************************************/
static void nfa_dm_act_data_cback(__attribute__((unused)) uint8_t conn_id,
tNFC_CONN_EVT event, tNFC_CONN* p_data) {
NFC_HDR* p_msg;
tNFA_CONN_EVT_DATA evt_data;
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("event = 0x%X", event);
if (event == NFC_DATA_CEVT) {
p_msg = (NFC_HDR*)p_data->data.p_data;
if (p_msg) {
evt_data.data.status = p_data->data.status;
evt_data.data.p_data = (uint8_t*)(p_msg + 1) + p_msg->offset;
evt_data.data.len = p_msg->len;
nfa_dm_conn_cback_event_notify(NFA_DATA_EVT, &evt_data);
GKI_freebuf(p_msg);
} else {
LOG(ERROR) << StringPrintf(
"received NFC_DATA_CEVT with NULL data "
"pointer");
}
} else if (event == NFC_DEACTIVATE_CEVT) {
NFC_SetStaticRfCback(NULL);
}
}
/*******************************************************************************
**
** Function nfa_dm_excl_disc_cback
**
** Description Processing event from discovery callback
**
** Returns None
**
*******************************************************************************/
static void nfa_dm_excl_disc_cback(tNFA_DM_RF_DISC_EVT event,
tNFC_DISCOVER* p_data) {
tNFA_CONN_EVT_DATA evt_data;
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("event:0x%02X", event);
switch (event) {
case NFA_DM_RF_DISC_START_EVT:
evt_data.status = NFA_STATUS_OK;
nfa_dm_conn_cback_event_notify(NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT,
&evt_data);
break;
case NFA_DM_RF_DISC_ACTIVATED_EVT:
if (nfa_dm_cb.disc_cb.activated_tech_mode == NFC_DISCOVERY_TYPE_POLL_A) {
/* store SEL_RES response */
nfa_dm_cb.disc_cb.activated_sel_res =
p_data->activate.rf_tech_param.param.pa.sel_rsp;
}
if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE) {
/* Set data callback to receive raw frame */
NFC_SetStaticRfCback(nfa_dm_act_data_cback);
memset(&(evt_data.activated.params), 0x00, sizeof(tNFA_TAG_PARAMS));
memcpy(&(evt_data.activated.activate_ntf), &(p_data->activate),
sizeof(tNFC_ACTIVATE_DEVT));
nfa_dm_conn_cback_event_notify(NFA_ACTIVATED_EVT, &evt_data);
} else {
/* holding activation notification until sub-module is ready */
nfa_dm_cb.p_activate_ntf =
(uint8_t*)GKI_getbuf(sizeof(tNFC_ACTIVATE_DEVT));
if (nfa_dm_cb.p_activate_ntf) {
memcpy(nfa_dm_cb.p_activate_ntf, &(p_data->activate),
sizeof(tNFC_ACTIVATE_DEVT));
if ((nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T1T) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T5T) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_KOVIO)) {
/* Notify NFA tag sub-system */
nfa_rw_proc_disc_evt(NFA_DM_RF_DISC_ACTIVATED_EVT, p_data, false);
} else /* if NFC-DEP, ISO-DEP with frame interface or others */
{
/* Set data callback to receive raw frame */
NFC_SetStaticRfCback(nfa_dm_act_data_cback);
nfa_dm_notify_activation_status(NFA_STATUS_OK, NULL);
}
} else {
/* deactivate and restart RF discovery */
nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_DISCOVERY);
}
}
break;
case NFA_DM_RF_DISC_DEACTIVATED_EVT:
/* if deactivated to idle or discovery */
if ((p_data->deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) ||
(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY)) {
/* clear stored NFCID/UID/KOVIO bar code */
nfa_dm_cb.activated_nfcid_len = 0;
}
if (nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_NFC_DEP) {
/* Notify NFA RW sub-systems */
nfa_rw_proc_disc_evt(NFA_DM_RF_DISC_DEACTIVATED_EVT, NULL, false);
}
/* if deactivated as sleep mode */
if ((p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) ||
(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF)) {
evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_SLEEP;
} else {
evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE;
}
/* notify deactivation to upper layer */
nfa_dm_conn_cback_event_notify(NFA_DEACTIVATED_EVT, &evt_data);
/* clean up SEL_RES response */
nfa_dm_cb.disc_cb.activated_sel_res = 0;
break;
default:
LOG(ERROR) << StringPrintf("Unexpected event");
break;
}
}
/*******************************************************************************
**
** Function nfa_dm_poll_disc_cback
**
** Description Processing event from discovery callback
**
** Returns None
**
*******************************************************************************/
static void nfa_dm_poll_disc_cback(tNFA_DM_RF_DISC_EVT event,
tNFC_DISCOVER* p_data) {
tNFA_CONN_EVT_DATA evt_data;
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("event:0x%02X", event);
switch (event) {
case NFA_DM_RF_DISC_START_EVT:
break;
case NFA_DM_RF_DISC_ACTIVATED_EVT:
if (nfa_dm_cb.disc_cb.activated_tech_mode == NFC_DISCOVERY_TYPE_POLL_A) {
/* store SEL_RES response */
nfa_dm_cb.disc_cb.activated_sel_res =
p_data->activate.rf_tech_param.param.pa.sel_rsp;
}
/* holding activation notification until sub-module is ready */
nfa_dm_cb.p_activate_ntf =
(uint8_t*)GKI_getbuf(sizeof(tNFC_ACTIVATE_DEVT));
if (nfa_dm_cb.p_activate_ntf) {
memcpy(nfa_dm_cb.p_activate_ntf, &(p_data->activate),
sizeof(tNFC_ACTIVATE_DEVT));
if ((nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP) &&
(nfa_dm_cb.disc_cb.activated_rf_interface ==
NFC_INTERFACE_NFC_DEP)) {
/* For P2P mode(Default DTA mode) open Raw channel to bypass LLCP
* layer. For LLCP DTA mode activate LLCP */
if ((appl_dta_mode_flag == 1) &&
((nfa_dm_cb.eDtaMode & 0x0F) == NFA_DTA_DEFAULT_MODE)) {
/* Open raw channel in case of p2p for DTA testing */
NFC_SetStaticRfCback(nfa_dm_act_data_cback);
nfa_dm_notify_activation_status(NFA_STATUS_OK, NULL);
} else {
if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_P2P_PAUSED)) {
/* activate LLCP */
nfa_p2p_activate_llcp(p_data);
if (nfa_dm_cb.p_activate_ntf) {
GKI_freebuf(nfa_dm_cb.p_activate_ntf);
nfa_dm_cb.p_activate_ntf = NULL;
}
} else {
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("P2P is paused");
nfa_dm_notify_activation_status(NFA_STATUS_OK, NULL);
}
}
} else if ((nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T1T) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) ||
(nfa_dm_cb.disc_cb.activated_protocol ==
NFC_PROTOCOL_ISO_DEP) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T5T) ||
(nfa_dm_cb.disc_cb.activated_protocol ==
NFC_PROTOCOL_KOVIO) ||
(nfa_dm_cb.disc_cb.activated_protocol ==
NFC_PROTOCOL_MIFARE)) {
/* Notify NFA tag sub-system */
nfa_rw_proc_disc_evt(NFA_DM_RF_DISC_ACTIVATED_EVT, p_data, true);
} else /* if NFC-DEP/ISO-DEP with frame interface */
{
/* Set data callback to receive raw frame */
NFC_SetStaticRfCback(nfa_dm_act_data_cback);
nfa_dm_notify_activation_status(NFA_STATUS_OK, NULL);
}
} else {
/* deactivate and restart RF discovery */
nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_DISCOVERY);
}
break;
case NFA_DM_RF_DISC_DEACTIVATED_EVT:
/* if deactivated to idle or discovery */
if ((p_data->deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) ||
(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY)) {
/* clear stored NFCID/UID/KOVIO bar code */
nfa_dm_cb.activated_nfcid_len = 0;
}
if ((nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP) &&
(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_NFC_DEP)) {
/*
** If LLCP link is not deactivated yet,
** LLCP will receive deactivation ntf through data callback.
** NFA P2P will receive callback event from LLCP.
*/
} else {
/* Notify NFA RW sub-systems */
nfa_rw_proc_disc_evt(NFA_DM_RF_DISC_DEACTIVATED_EVT, NULL, true);
}
/* if NFA sent NFA_ACTIVATED_EVT earlier */
if (nfa_dm_cb.flags & NFA_DM_FLAGS_SEND_DEACTIVATED_EVT) {
nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SEND_DEACTIVATED_EVT;
/* if deactivated as sleep mode */
if ((p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) ||
(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF)) {
evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_SLEEP;
} else {
evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE;
}
/* notify deactivation to application */
nfa_dm_conn_cback_event_notify(NFA_DEACTIVATED_EVT, &evt_data);
}
/* clean up SEL_RES response */
nfa_dm_cb.disc_cb.activated_sel_res = 0;
if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_POLLING_ENABLED)) {
/* deregister discovery callback from NFA DM Discovery */
nfa_dm_delete_rf_discover(nfa_dm_cb.poll_disc_handle);
nfa_dm_cb.poll_disc_handle = NFA_HANDLE_INVALID;
/* this is for disable polling */
if (nfa_dm_cb.flags & NFA_DM_FLAGS_SEND_POLL_STOP_EVT) {
nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SEND_POLL_STOP_EVT;
evt_data.status = NFA_STATUS_OK;
nfa_dm_conn_cback_event_notify(NFA_POLL_DISABLED_EVT, &evt_data);
}
}
break;
}
}
/*******************************************************************************
** Function nfa_dm_poll_disc_cback_dta_wrapper
**
** Description Accessing the nfa_dm_poll_disc_cback for DTA wrapper
**
** Returns None
**
*******************************************************************************/
void nfa_dm_poll_disc_cback_dta_wrapper(tNFA_DM_RF_DISC_EVT event,
tNFC_DISCOVER* p_data) {
nfa_dm_poll_disc_cback(event, p_data);
}
/*******************************************************************************
**
** Function nfa_dm_notify_activation_status
**
** Description Processing activation status from sub-modules
**
** Returns None
**
*******************************************************************************/
void nfa_dm_notify_activation_status(tNFA_STATUS status,
tNFA_TAG_PARAMS* p_params) {
tNFA_CONN_EVT_DATA evt_data;
tNFC_RF_TECH_PARAMS* p_tech_params;
uint8_t *p_nfcid = NULL, nfcid_len;
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("status:0x%X", status);
if (!nfa_dm_cb.p_activate_ntf) {
/* this is for NFA P2P listen */
return;
}
if (status == NFA_STATUS_OK) {
/* notify NFC link activation */
memcpy(&(evt_data.activated.activate_ntf), nfa_dm_cb.p_activate_ntf,
sizeof(tNFC_ACTIVATE_DEVT));
p_tech_params = &evt_data.activated.activate_ntf.rf_tech_param;
memset(&(evt_data.activated.params), 0x00, sizeof(tNFA_TAG_PARAMS));
if (p_params) {
memcpy(&(evt_data.activated.params), p_params, sizeof(tNFA_TAG_PARAMS));
}
/* get length of NFCID and location */
if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_A) {
if ((p_tech_params->param.pa.nfcid1_len == 0) && (p_params != NULL)) {
nfcid_len = sizeof(p_params->t1t.uid);
p_nfcid = p_params->t1t.uid;
evt_data.activated.activate_ntf.rf_tech_param.param.pa.nfcid1_len =
nfcid_len;
memcpy(evt_data.activated.activate_ntf.rf_tech_param.param.pa.nfcid1,
p_nfcid, nfcid_len);
} else {
nfcid_len = p_tech_params->param.pa.nfcid1_len;
p_nfcid = p_tech_params->param.pa.nfcid1;
}
} else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_B) {
nfcid_len = NFC_NFCID0_MAX_LEN;
p_nfcid = p_tech_params->param.pb.nfcid0;
} else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_F) {
nfcid_len = NFC_NFCID2_LEN;
p_nfcid = p_tech_params->param.pf.nfcid2;
} else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_V) {
nfcid_len = NFC_ISO15693_UID_LEN;
p_nfcid = p_tech_params->param.pi93.uid;
} else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_KOVIO) {
nfcid_len = p_tech_params->param.pk.uid_len;
p_nfcid = p_tech_params->param.pk.uid;
} else {
nfcid_len = 0;
}
/*
** If not in exlusive RF mode, and
** P2P activation, then push default NDEF message through SNEP
** TAG activation, then read NDEF message
*/
if (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP) {
/*
** Default NDEF message will be put to NFC Forum defualt SNEP server
** after receiving NFA_LLCP_ACTIVATED_EVT.
*/
} else if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)) {
/*
** if the same tag is activated then do not perform auto NDEF
** detection. Application may put a tag into sleep mode and
** reactivate the same tag.
*/
if ((p_tech_params->mode != nfa_dm_cb.activated_tech_mode) ||
(nfcid_len != nfa_dm_cb.activated_nfcid_len) ||
(memcmp(p_nfcid, nfa_dm_cb.activated_nfcid, nfcid_len))) {
if ((nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T1T) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) ||
((nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP) &&
(nfa_dm_cb.disc_cb.activated_rf_interface ==
NFC_INTERFACE_ISO_DEP)) ||
(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T5T)) {
if (p_nfa_dm_cfg->auto_detect_ndef) {
if (p_nfa_dm_cfg->auto_read_ndef) {
nfa_dm_cb.flags |= NFA_DM_FLAGS_AUTO_READING_NDEF;
}
NFA_RwDetectNDef();
} else if (p_nfa_dm_cfg->auto_read_ndef) {
NFA_RwReadNDef();
}
}
}
}
/* store activated tag information */
nfa_dm_cb.activated_tech_mode = p_tech_params->mode;
nfa_dm_cb.activated_nfcid_len = nfcid_len;
if (nfcid_len) memcpy(nfa_dm_cb.activated_nfcid, p_nfcid, nfcid_len);
nfa_dm_cb.flags |= NFA_DM_FLAGS_SEND_DEACTIVATED_EVT;
if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING))
nfa_dm_conn_cback_event_notify(NFA_ACTIVATED_EVT, &evt_data);
} else {
/* if NFC_DEP, NFA P2P will deactivate */
if (nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_NFC_DEP) {
nfa_dm_rf_deactivate(NFA_DEACTIVATE_TYPE_DISCOVERY);
}
}
GKI_freebuf(nfa_dm_cb.p_activate_ntf);
nfa_dm_cb.p_activate_ntf = NULL;
}
/*******************************************************************************
**
** Function nfa_dm_nfc_revt_2_str
**
** Description convert nfc revt to string
**
*******************************************************************************/
std::string nfa_dm_nfc_revt_2_str(tNFC_RESPONSE_EVT event) {
switch (event) {
case NFC_ENABLE_REVT:
return "NFC_ENABLE_REVT";
case NFC_DISABLE_REVT:
return "NFC_DISABLE_REVT";
case NFC_SET_CONFIG_REVT:
return "NFC_SET_CONFIG_REVT";
case NFC_GET_CONFIG_REVT:
return "NFC_GET_CONFIG_REVT";
case NFC_NFCEE_DISCOVER_REVT:
return "NFC_NFCEE_DISCOVER_REVT";
case NFC_NFCEE_INFO_REVT:
return "NFC_NFCEE_INFO_REVT";
case NFC_NFCEE_MODE_SET_REVT:
return "NFC_NFCEE_MODE_SET_REVT";
case NFC_RF_FIELD_REVT:
return "NFC_RF_FIELD_REVT";
case NFC_EE_ACTION_REVT:
return "NFC_EE_ACTION_REVT";
case NFC_EE_DISCOVER_REQ_REVT:
return "NFC_EE_DISCOVER_REQ_REVT";
case NFC_SET_ROUTING_REVT:
return "NFC_SET_ROUTING_REVT";
case NFC_GET_ROUTING_REVT:
return "NFC_GET_ROUTING_REVT";
case NFC_GEN_ERROR_REVT:
return "NFC_GEN_ERROR_REVT";
case NFC_NFCC_RESTART_REVT:
return "NFC_NFCC_RESTART_REVT";
case NFC_NFCC_TIMEOUT_REVT:
return "NFC_NFCC_TIMEOUT_REVT";
case NFC_NFCC_TRANSPORT_ERR_REVT:
return "NFC_NFCC_TRANSPORT_ERR_REVT";
case NFC_NFCC_POWER_OFF_REVT:
return "NFC_NFCC_POWER_OFF_REVT";
case NFC_NFCEE_STATUS_REVT:
return "NFC_NFCEE_STATUS_REVT";
default:
return "unknown revt";
}
}