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