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