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