Google Git
Sign in
ara-mdk / platform / external / libnfc-nci / e9df6ba5a8fcccf306a80b1670b423be8fe7746a / . / src / nfa / dm / nfa_dm_act.c
blob: c4b5250c0fce17d29fae7ca7c3ca70816c9c7ad8 [file] [log] [blame]
/******************************************************************************
*
* Copyright (C) 2010-2012 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 "nfa_sys.h"
#include "nfa_api.h"
#include "nfa_dm_int.h"
#include "nfa_sys_int.h"
#include "nfa_ce_int.h"
#include "nfc_api.h"
#include "nfa_rw_int.h"
#include "nfa_rw_api.h"
#include "nfa_p2p_int.h"
#include "nfa_cho_int.h"
#include "nci_hmsgs.h"
#if (NFC_NFCEE_INCLUDED == TRUE)
#include "nfa_ee_int.h"
#include "nfa_hci_int.h"
#endif
#if (defined (NFA_SNEP_INCLUDED) && (NFA_SNEP_INCLUDED==TRUE))
#include "nfa_snep_int.h"
#else
#define nfa_snep_init ()
#endif
/* 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 BOOLEAN 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;
NFA_TRACE_DEBUG1 ("nfa_dm_nfcc_power_mode_proc_complete_cback () 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;
(*nfa_dm_cb.p_dm_cback) (NFA_DM_PWR_MODE_CHANGE_EVT, (tNFA_DM_CBACK_DATA*) &power_mode_change);
}
/*******************************************************************************
**
** 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 xx;
/* set NCI default value if other than zero */
/* 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][2] = 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 nfcc_power_mode)
{
NFA_TRACE_DEBUG1 ("nfa_dm_proc_nfcc_power_mode (): 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));
nfa_dm_cb.setcfg_pending_mask = 0;
nfa_dm_cb.setcfg_pending_num = 0;
nfa_dm_set_init_nci_params ();
}
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_GET_CONFIG *p_nfa_get_confg;
tNFA_CONN_EVT_DATA conn_evt;
UINT8 dm_cback_evt;
#if (BT_TRACE_VERBOSE == TRUE)
NFA_TRACE_DEBUG2 ("nfa_dm_nfc_response_cback () %s(0x%x)", nfa_dm_nfc_revt_2_str (event), event);
#else
NFA_TRACE_DEBUG1 ("nfa_dm_nfc_response_cback () event=0x%x", event);
#endif
switch (event)
{
case NFC_ENABLE_REVT: /* 0 Enable event */
/* NFC stack enabled. Enable nfa sub-systems */
if (p_data->enable.status == NFC_STATUS_OK)
{
nfa_dm_set_init_nci_params ();
/* 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 */
if (nfa_dm_cb.setcfg_pending_mask & 1) /* lsb=whether last NCI_SET_CONFIG was due to NFA_SetConfig */
{
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 */
NFA_TRACE_ERROR0 ("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)
{
if ((p_nfa_get_confg = (tNFA_GET_CONFIG *) GKI_getbuf ((UINT16) (sizeof (tNFA_GET_CONFIG) + p_data->get_config.tlv_size))) != NULL)
{
p_nfa_get_confg->status = NFA_STATUS_OK;
p_nfa_get_confg->tlv_size = p_data->get_config.tlv_size;
memcpy (p_nfa_get_confg->param_tlvs, p_data->get_config.p_param_tlvs, p_data->get_config.tlv_size);
(*nfa_dm_cb.p_dm_cback) (NFA_DM_GET_CONFIG_EVT, (tNFA_DM_CBACK_DATA *) p_nfa_get_confg);
GKI_freebuf (p_nfa_get_confg);
return;
}
else
{
NFA_TRACE_DEBUG0 ("nfa_dm_nfc_response_cback unable to allocate buffer");
}
}
/* 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_EE_DISCOVER_REQ_REVT: /* EE Discover Req notification */
nfa_ee_proc_evt (event, p_data);
break;
#endif
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_SET_ROUTING_REVT: /* Configure Routing response */
break;
case NFC_GET_ROUTING_REVT: /* Retrieve Routing response */
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:
NFA_TRACE_DEBUG1 ("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)
**
*******************************************************************************/
BOOLEAN nfa_dm_enable (tNFA_DM_MSG *p_data)
{
tNFA_DM_CBACK_DATA dm_cback_data;
NFA_TRACE_DEBUG0 ("nfa_dm_enable ()");
/* 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
{
NFA_TRACE_ERROR0 ("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)
**
*******************************************************************************/
BOOLEAN nfa_dm_disable (tNFA_DM_MSG *p_data)
{
tNFC_DEACT_TYPE deactivate_type = NFA_DEACTIVATE_TYPE_IDLE;
NFA_TRACE_DEBUG1 ("nfa_dm_disable (): 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;
nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD, (tNFA_DM_RF_DISC_DATA *) &deactivate_type);
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)
{
NFA_TRACE_DEBUG0 ("nfa_dm_disable_complete ()");
if ((nfa_dm_cb.flags & NFA_DM_FLAGS_DM_DISABLING_NFC) == 0)
{
NFA_TRACE_DEBUG0 ("nfa_dm_disable_complete (): 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)
**
*******************************************************************************/
BOOLEAN nfa_dm_set_config (tNFA_DM_MSG *p_data)
{
tNFC_STATUS status;
UINT8 buff[255];
UINT8 *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) (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)
**
*******************************************************************************/
BOOLEAN 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_conn_cback_event_notify
**
** Description Notify application of CONN_CBACK event, using appropriate
** callback
**
** Returns nothing
**
*******************************************************************************/
void nfa_dm_conn_cback_event_notify (UINT8 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;
NFA_TRACE_DEBUG0 ("nfa_dm_rel_excl_rf_control_and_notify ()");
/* 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)
**
*******************************************************************************/
BOOLEAN nfa_dm_act_request_excl_rf_ctrl (tNFA_DM_MSG *p_data)
{
tNFA_CONN_EVT_DATA conn_evt;
NFA_TRACE_DEBUG0 ("nfa_dm_act_request_excl_rf_ctrl ()");
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
{
NFA_TRACE_ERROR0 ("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)
**
*******************************************************************************/
BOOLEAN nfa_dm_act_release_excl_rf_ctrl (tNFA_DM_MSG *p_data)
{
NFA_TRACE_DEBUG0 ("nfa_dm_act_release_excl_rf_ctrl ()");
/* 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);
}
return TRUE;
}
/*******************************************************************************
**
** Function nfa_dm_act_deactivate
**
** Description Process deactivate command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
BOOLEAN nfa_dm_act_deactivate (tNFA_DM_MSG *p_data)
{
tNFA_CONN_EVT_DATA conn_evt;
tNFA_DEACTIVATE_TYPE deact_type;
NFA_TRACE_DEBUG0 ("nfa_dm_act_deactivate ()");
if ( (p_data->deactivate.sleep_mode == FALSE) /* Always allow deactivate to IDLE */
||( (nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_T1T) /* Do not allow deactivate to SLEEP for T1T,NFCDEP, ISO15693 */
&&(nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_NFC_DEP)
&&(nfa_dm_cb.disc_cb.activated_protocol != NFA_PROTOCOL_ISO15693) ) )
{
if ( (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_NFC_DEP)
&&((nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) == 0x00) )
{
/* Exclusive RF control doesn't use NFA P2P */
/* NFA P2P will deactivate NFC link after deactivating LLCP link */
nfa_p2p_deactivate_llcp ();
return (TRUE);
}
else
{
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 (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_rf_deactivate (deact_type) == NFA_STATUS_OK)
{
nfa_rw_stop_presence_check_timer ();
return (TRUE);
}
}
}
NFA_TRACE_ERROR0 ("nfa_dm_act_deactivate (): invalid protocol or mode");
/* 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)
**
*******************************************************************************/
BOOLEAN nfa_dm_act_power_off_sleep (tNFA_DM_MSG *p_data)
{
NFA_TRACE_DEBUG0 ("nfa_dm_act_power_off_sleep ()");
NFC_SetPowerOffSleep ((BOOLEAN) (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)
**
*******************************************************************************/
BOOLEAN 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)
{
NFA_TRACE_ERROR0 ("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)
**
*******************************************************************************/
BOOLEAN nfa_dm_act_send_vsc(tNFA_DM_MSG *p_data)
{
BT_HDR *p_cmd = (BT_HDR *)p_data;
p_cmd->offset = sizeof (tNFA_DM_API_SEND_VSC) - BT_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_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;
NFA_TRACE_DEBUG0 ("nfa_dm_start_polling ()");
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 (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_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_F_ACTIVE)
{
poll_disc_mask |= NFA_DM_DISC_MASK_PFA_NFC_DEP;
}
if (poll_tech_mask & NFA_TECHNOLOGY_MASK_ISO15693)
{
poll_disc_mask |= NFA_DM_DISC_MASK_P_ISO15693;
}
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)
**
*******************************************************************************/
BOOLEAN nfa_dm_act_enable_polling (tNFA_DM_MSG *p_data)
{
tNFA_CONN_EVT_DATA evt_data;
NFA_TRACE_DEBUG0 ("nfa_dm_act_enable_polling ()");
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
{
NFA_TRACE_ERROR0 ("nfa_dm_act_enable_polling (): 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 BOOLEAN nfa_dm_deactivate_polling (void)
{
NFA_TRACE_DEBUG0 ("nfa_dm_deactivate_polling ()");
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)
**
*******************************************************************************/
BOOLEAN nfa_dm_act_disable_polling (tNFA_DM_MSG *p_data)
{
tNFA_CONN_EVT_DATA evt_data;
NFA_TRACE_DEBUG0 ("nfa_dm_act_disable_polling ()");
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_send_raw_frame
**
** Description Send an raw frame on RF link
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
BOOLEAN nfa_dm_act_send_raw_frame (tNFA_DM_MSG *p_data)
{
tNFC_STATUS status = NFC_STATUS_FAILED;
NFA_TRACE_DEBUG0 ("nfa_dm_act_send_raw_frame ()");
/* 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) )
{
/* 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_rf_interface == NFC_INTERFACE_ISO_DEP) )
||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO15693) ) )
{
/* if RW is checking presence then it will put into pending queue */
status = nfa_rw_send_raw_frame ((BT_HDR*)p_data);
}
else
{
status = NFC_SendData (NFC_RF_CONN_ID, (BT_HDR*) p_data);
}
}
if (status == NFC_STATUS_FAILED)
{
/* 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)
**
*******************************************************************************/
BOOLEAN nfa_dm_set_p2p_listen_tech (tNFA_DM_MSG *p_data)
{
NFA_TRACE_DEBUG1 ("nfa_dm_set_p2p_listen_tech () 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)
**
*******************************************************************************/
BOOLEAN nfa_dm_act_start_rf_discovery (tNFA_DM_MSG *p_data)
{
tNFA_CONN_EVT_DATA evt_data;
NFA_TRACE_DEBUG0 ("nfa_dm_act_start_rf_discovery ()");
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)
**
*******************************************************************************/
BOOLEAN nfa_dm_act_stop_rf_discovery (tNFA_DM_MSG *p_data)
{
tNFA_CONN_EVT_DATA evt_data;
NFA_TRACE_DEBUG0 ("nfa_dm_act_stop_rf_discovery ()");
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;
nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_IDLE);
}
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)
**
*******************************************************************************/
BOOLEAN 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_select
**
** Description Process RF select command
**
** Returns TRUE (message buffer to be freed by caller)
**
*******************************************************************************/
BOOLEAN nfa_dm_act_select (tNFA_DM_MSG *p_data)
{
NFA_TRACE_DEBUG0 ("nfa_dm_act_select ()");
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)
**
*******************************************************************************/
BOOLEAN nfa_dm_act_update_rf_params (tNFA_DM_MSG *p_data)
{
tNFA_CONN_EVT_DATA conn_evt;
NFA_TRACE_DEBUG0 ("nfa_dm_act_update_rf_params ()");
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)
**
*******************************************************************************/
BOOLEAN nfa_dm_act_disable_timeout (tNFA_DM_MSG *p_data)
{
tNFA_DM_API_DISABLE disable;
disable.graceful = FALSE;
nfa_dm_disable ((tNFA_DM_MSG *) &disable);
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 event, tNFA_CONN_EVT_DATA *p_data)
{
NFA_TRACE_DEBUG1 ("nfa_dm_act_conn_cback_notify (): 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 (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data)
{
BT_HDR *p_msg = (BT_HDR *) p_data->data.p_data;
tNFA_CONN_EVT_DATA evt_data;
NFA_TRACE_DEBUG1 ("nfa_dm_act_data_cback (): event = 0x%X", event);
if (event == NFC_DATA_CEVT)
{
if (p_msg)
{
evt_data.data.p_data = (UINT8 *) (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
{
NFA_TRACE_ERROR0 ("nfa_dm_act_data_cback (): 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;
NFA_TRACE_DEBUG1 ("nfa_dm_excl_disc_cback (): 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*) 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_rf_interface == NFC_INTERFACE_ISO_DEP) )
||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO15693) )
{
/* 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:
/* clear stored NFCID/UID */
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;
case NFA_DM_RF_DISC_CMD_IDLE_CMPL_EVT:
/* DH initiated deactivation in NFA_DM_RFST_W4_HOST_SELECT */
/* No need to notify NFA RW sub-systems */
evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE;
/* notify deactivation to application */
nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data);
break;
default:
NFA_TRACE_ERROR0 ("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;
NFA_TRACE_DEBUG1 ("nfa_dm_poll_disc_cback (): 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*) 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) )
{
/* activate LLCP */
nfa_p2p_activate_llcp (p_data);
}
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_rf_interface == NFC_INTERFACE_ISO_DEP) )
||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO15693) )
{
/* 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:
/* clear stored NFCID/UID */
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;
case NFA_DM_RF_DISC_CMD_IDLE_CMPL_EVT:
/* DH initiated deactivation in NFA_DM_RFST_W4_HOST_SELECT */
/* No need to notify NFA RW sub-systems */
/* clear stored NFCID/UID */
nfa_dm_cb.activated_nfcid_len = 0;
/* clean up SEL_RES response */
nfa_dm_cb.disc_cb.activated_sel_res = 0;
evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE;
/* notify deactivation to application */
nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data);
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_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 *p_nfcid = NULL, nfcid_len;
NFA_TRACE_DEBUG1 ("nfa_dm_notify_activation_status (): 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;
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)
{
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_ISO15693)
{
nfcid_len = NFC_ISO15693_UID_LEN;
p_nfcid = p_tech_params->param.pi93.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.
*/
}
/* Do not perform NDEF operations on KOVIO */
else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_KOVIO)
{
NFA_TRACE_DEBUG1 ("Not an NFC-Forum tag, bypassing NDEF detection", nfa_dm_cb.disc_cb.activated_protocol);
}
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.disc_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_ISO15693) )
{
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_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;
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;
}
#if (BT_TRACE_VERBOSE == TRUE)
/*******************************************************************************
**
** Function nfa_dm_nfc_revt_2_str
**
** Description convert nfc revt to string
**
*******************************************************************************/
char *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";
default:
return "unknown revt";
break;
}
}
#endif /* BT_VERBOSE */