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