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