nfa_dm_act.c revision 8adba7675549bb507514c4f602723aa7d8e43f67
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 case NFC_SET_ROUTING_REVT: /* Configure Routing response */ 348 nfa_ee_proc_evt (event, p_data); 349 break; 350 351 case NFC_EE_DISCOVER_REQ_REVT: /* EE Discover Req notification */ 352 if (nfa_dm_is_active() && 353 (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_DISCOVERY) ) 354 { 355 nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_IDLE); 356 } 357 nfa_ee_proc_evt (event, p_data); 358 break; 359 360 case NFC_GET_ROUTING_REVT: /* Retrieve Routing response */ 361 break; 362#endif 363 364 case NFC_RF_FIELD_REVT: /* RF Field information */ 365 dm_cback_data.rf_field.status = NFA_STATUS_OK; 366 dm_cback_data.rf_field.rf_field_status = p_data->rf_field.rf_field; 367 (*nfa_dm_cb.p_dm_cback) (NFA_DM_RF_FIELD_EVT, &dm_cback_data); 368 break; 369 370 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 nfa_dm_cb.flags |= NFA_DM_FLAGS_RAW_FRAME; 1172 NFC_SetReassemblyFlag (FALSE); 1173 /* If not in exclusive mode, and not activated for LISTEN, then forward raw data to NFA_RW to send */ 1174 if ( !(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) 1175 &&!(nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE) 1176 &&( (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T1T) 1177 ||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T2T) 1178 ||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_T3T) 1179 ||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO_DEP) 1180 ||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO15693) ) ) 1181 { 1182 /* if RW is checking presence then it will put into pending queue */ 1183 status = nfa_rw_send_raw_frame ((BT_HDR*)p_data); 1184 } 1185 else 1186 { 1187 status = NFC_SendData (NFC_RF_CONN_ID, (BT_HDR*) p_data); 1188 if (status != NFC_STATUS_OK) 1189 { 1190 NFC_SetReassemblyFlag (TRUE); 1191 } 1192 /* Already freed or NCI layer will free buffer */ 1193 return FALSE; 1194 } 1195 } 1196 1197 if (status == NFC_STATUS_FAILED) 1198 { 1199 NFC_SetReassemblyFlag (TRUE); 1200 /* free the buffer */ 1201 return TRUE; 1202 } 1203 else 1204 { 1205 /* NCI layer will free buffer */ 1206 return FALSE; 1207 } 1208} 1209 1210/******************************************************************************* 1211** 1212** Function nfa_dm_set_p2p_listen_tech 1213** 1214** Description Notify change of P2P listen technologies to NFA P2P 1215** 1216** Returns TRUE (message buffer to be freed by caller) 1217** 1218*******************************************************************************/ 1219BOOLEAN nfa_dm_set_p2p_listen_tech (tNFA_DM_MSG *p_data) 1220{ 1221 NFA_TRACE_DEBUG1 ("nfa_dm_set_p2p_listen_tech () tech_mask = %d", 1222 p_data->set_p2p_listen_tech.tech_mask); 1223 1224 nfa_p2p_update_listen_tech (p_data->set_p2p_listen_tech.tech_mask); 1225 nfa_dm_conn_cback_event_notify (NFA_SET_P2P_LISTEN_TECH_EVT, NULL); 1226 1227 return (TRUE); 1228} 1229 1230/******************************************************************************* 1231** 1232** Function nfa_dm_act_start_rf_discovery 1233** 1234** Description Process start RF discovery command 1235** 1236** Returns TRUE (message buffer to be freed by caller) 1237** 1238*******************************************************************************/ 1239BOOLEAN nfa_dm_act_start_rf_discovery (tNFA_DM_MSG *p_data) 1240{ 1241 tNFA_CONN_EVT_DATA evt_data; 1242 1243 NFA_TRACE_DEBUG0 ("nfa_dm_act_start_rf_discovery ()"); 1244 1245 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED) 1246 { 1247 evt_data.status = NFA_STATUS_OK; 1248 nfa_dm_conn_cback_event_notify (NFA_RF_DISCOVERY_STARTED_EVT, &evt_data); 1249 } 1250 else if (nfa_dm_cb.disc_cb.disc_state != NFA_DM_RFST_IDLE) 1251 { 1252 evt_data.status = NFA_STATUS_SEMANTIC_ERROR; 1253 nfa_dm_conn_cback_event_notify (NFA_RF_DISCOVERY_STARTED_EVT, &evt_data); 1254 } 1255 else 1256 { 1257 nfa_dm_cb.disc_cb.disc_flags |= (NFA_DM_DISC_FLAGS_ENABLED|NFA_DM_DISC_FLAGS_NOTIFY); 1258 nfa_dm_start_rf_discover (); 1259 } 1260 1261 return (TRUE); 1262} 1263 1264/******************************************************************************* 1265** 1266** Function nfa_dm_act_stop_rf_discovery 1267** 1268** Description Process stop RF discovery command 1269** 1270** Returns TRUE (message buffer to be freed by caller) 1271** 1272*******************************************************************************/ 1273BOOLEAN nfa_dm_act_stop_rf_discovery (tNFA_DM_MSG *p_data) 1274{ 1275 tNFA_CONN_EVT_DATA evt_data; 1276 1277 NFA_TRACE_DEBUG0 ("nfa_dm_act_stop_rf_discovery ()"); 1278 1279 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED) || 1280 (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_IDLE) ) 1281 { 1282 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_ENABLED; 1283 1284 /* if discover command has been sent in IDLE state and waiting for response */ 1285 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP) 1286 { 1287 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_STOPPING; 1288 } 1289 else 1290 { 1291 evt_data.status = NFA_STATUS_OK; 1292 nfa_dm_conn_cback_event_notify (NFA_RF_DISCOVERY_STOPPED_EVT, &evt_data); 1293 } 1294 } 1295 else 1296 { 1297 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_ENABLED; 1298 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_STOPPING; 1299 1300 if (nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_IDLE) == NFA_STATUS_OK) 1301 { 1302 if (nfa_dm_cb.disc_cb.kovio_tle.in_use) 1303 nfa_sys_stop_timer (&nfa_dm_cb.disc_cb.kovio_tle); 1304 nfa_rw_stop_presence_check_timer (); 1305 } 1306 } 1307 return (TRUE); 1308} 1309 1310/******************************************************************************* 1311** 1312** Function nfa_dm_act_set_rf_disc_duration 1313** 1314** Description Set duration for RF discovery 1315** 1316** Returns TRUE (message buffer to be freed by caller) 1317** 1318*******************************************************************************/ 1319BOOLEAN nfa_dm_act_set_rf_disc_duration (tNFA_DM_MSG *p_data) 1320{ 1321 nfa_dm_cb.disc_cb.disc_duration = p_data->disc_duration.rf_disc_dur_ms; 1322 return (TRUE); 1323} 1324 1325/******************************************************************************* 1326** 1327** Function nfa_dm_act_select 1328** 1329** Description Process RF select command 1330** 1331** Returns TRUE (message buffer to be freed by caller) 1332** 1333*******************************************************************************/ 1334BOOLEAN nfa_dm_act_select (tNFA_DM_MSG *p_data) 1335{ 1336 NFA_TRACE_DEBUG0 ("nfa_dm_act_select ()"); 1337 1338 nfa_dm_rf_discover_select (p_data->select.rf_disc_id, 1339 p_data->select.protocol, 1340 p_data->select.rf_interface); 1341 return (TRUE); 1342} 1343 1344/******************************************************************************* 1345** 1346** Function nfa_dm_act_update_rf_params 1347** 1348** Description Process update RF communication parameters command 1349** 1350** Returns TRUE (message buffer to be freed by caller) 1351** 1352*******************************************************************************/ 1353BOOLEAN nfa_dm_act_update_rf_params (tNFA_DM_MSG *p_data) 1354{ 1355 tNFA_CONN_EVT_DATA conn_evt; 1356 1357 NFA_TRACE_DEBUG0 ("nfa_dm_act_update_rf_params ()"); 1358 1359 if (NFC_UpdateRFCommParams (&p_data->update_rf_params.params) != NFC_STATUS_OK) 1360 { 1361 conn_evt.status = NFA_STATUS_FAILED; 1362 nfa_dm_conn_cback_event_notify (NFA_UPDATE_RF_PARAM_RESULT_EVT, &conn_evt); 1363 } 1364 1365 return (TRUE); 1366} 1367 1368/******************************************************************************* 1369** 1370** Function nfa_dm_act_disable_timeout 1371** 1372** Description timeout on disable process. Shutdown immediately 1373** 1374** Returns TRUE (message buffer to be freed by caller) 1375** 1376*******************************************************************************/ 1377BOOLEAN nfa_dm_act_disable_timeout (tNFA_DM_MSG *p_data) 1378{ 1379 tNFA_DM_API_DISABLE disable; 1380 1381 disable.graceful = FALSE; 1382 nfa_dm_disable ((tNFA_DM_MSG *) &disable); 1383 return (TRUE); 1384} 1385 1386/******************************************************************************* 1387** 1388** Function nfa_dm_act_conn_cback_notify 1389** 1390** Description Notify app of reader/writer/ndef events 1391** 1392** Returns nothing 1393** 1394*******************************************************************************/ 1395void nfa_dm_act_conn_cback_notify (UINT8 event, tNFA_CONN_EVT_DATA *p_data) 1396{ 1397 NFA_TRACE_DEBUG1 ("nfa_dm_act_conn_cback_notify (): event:0x%X", event); 1398 1399 /* Notify event using appropriate CONN_CBACK */ 1400 nfa_dm_conn_cback_event_notify (event, p_data); 1401 1402 /* If not in exclusive RF mode, then read NDEF message from tag (if automatic reading is enabled) */ 1403 if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)) 1404 { 1405 if ( (event == NFA_NDEF_DETECT_EVT) 1406 &&(nfa_dm_cb.flags & NFA_DM_FLAGS_AUTO_READING_NDEF) ) 1407 { 1408 /* read NDEF message from tag */ 1409 if (p_data->ndef_detect.status == NFA_STATUS_OK) 1410 { 1411 NFA_RwReadNDef (); 1412 } 1413 else if (p_data->ndef_detect.status == NFA_STATUS_FAILED) 1414 { 1415 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_AUTO_READING_NDEF; 1416 } 1417 /* ignore NFA_STATUS_BUSY */ 1418 } 1419 else if ( (event == NFA_READ_CPLT_EVT) 1420 &&(nfa_dm_cb.flags & NFA_DM_FLAGS_AUTO_READING_NDEF)) 1421 { 1422 /* reading NDEF message is done */ 1423 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_AUTO_READING_NDEF; 1424 } 1425 } 1426} 1427 1428/******************************************************************************* 1429** 1430** Function nfa_dm_act_data_cback 1431** 1432** Description Processing data from RF link 1433** 1434** Returns None 1435** 1436*******************************************************************************/ 1437static void nfa_dm_act_data_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data) 1438{ 1439 BT_HDR *p_msg; 1440 tNFA_CONN_EVT_DATA evt_data; 1441 1442 NFA_TRACE_DEBUG1 ("nfa_dm_act_data_cback (): event = 0x%X", event); 1443 1444 if (event == NFC_DATA_CEVT) 1445 { 1446 p_msg = (BT_HDR *) p_data->data.p_data; 1447 1448 if (p_msg) 1449 { 1450 evt_data.data.status = p_data->data.status; 1451 evt_data.data.p_data = (UINT8 *) (p_msg + 1) + p_msg->offset; 1452 evt_data.data.len = p_msg->len; 1453 1454 nfa_dm_conn_cback_event_notify (NFA_DATA_EVT, &evt_data); 1455 1456 GKI_freebuf (p_msg); 1457 } 1458 else 1459 { 1460 NFA_TRACE_ERROR0 ("nfa_dm_act_data_cback (): received NFC_DATA_CEVT with NULL data pointer"); 1461 } 1462 } 1463 else if (event == NFC_DEACTIVATE_CEVT) 1464 { 1465 NFC_SetStaticRfCback (NULL); 1466 } 1467} 1468 1469/******************************************************************************* 1470** 1471** Function nfa_dm_excl_disc_cback 1472** 1473** Description Processing event from discovery callback 1474** 1475** Returns None 1476** 1477*******************************************************************************/ 1478static void nfa_dm_excl_disc_cback (tNFA_DM_RF_DISC_EVT event, tNFC_DISCOVER *p_data) 1479{ 1480 tNFA_CONN_EVT_DATA evt_data; 1481 1482 NFA_TRACE_DEBUG1 ("nfa_dm_excl_disc_cback (): event:0x%02X", event); 1483 1484 switch (event) 1485 { 1486 case NFA_DM_RF_DISC_START_EVT: 1487 evt_data.status = NFA_STATUS_OK; 1488 nfa_dm_conn_cback_event_notify (NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT, &evt_data); 1489 break; 1490 1491 case NFA_DM_RF_DISC_ACTIVATED_EVT: 1492 if (nfa_dm_cb.disc_cb.activated_tech_mode == NFC_DISCOVERY_TYPE_POLL_A) 1493 { 1494 /* store SEL_RES response */ 1495 nfa_dm_cb.disc_cb.activated_sel_res = p_data->activate.rf_tech_param.param.pa.sel_rsp; 1496 } 1497 1498 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE) 1499 { 1500 /* Set data callback to receive raw frame */ 1501 NFC_SetStaticRfCback (nfa_dm_act_data_cback); 1502 1503 memset (&(evt_data.activated.params), 0x00, sizeof (tNFA_TAG_PARAMS)); 1504 memcpy (&(evt_data.activated.activate_ntf), &(p_data->activate), sizeof (tNFC_ACTIVATE_DEVT)); 1505 1506 nfa_dm_conn_cback_event_notify (NFA_ACTIVATED_EVT, &evt_data); 1507 } 1508 else 1509 { 1510 /* holding activation notification until sub-module is ready */ 1511 nfa_dm_cb.p_activate_ntf = (UINT8*) GKI_getbuf (sizeof (tNFC_ACTIVATE_DEVT)); 1512 1513 if (nfa_dm_cb.p_activate_ntf) 1514 { 1515 memcpy (nfa_dm_cb.p_activate_ntf, 1516 &(p_data->activate), 1517 sizeof (tNFC_ACTIVATE_DEVT)); 1518 1519 if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T1T) 1520 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) 1521 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) 1522 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP) 1523 ||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO15693) 1524 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_KOVIO) ) 1525 { 1526 /* Notify NFA tag sub-system */ 1527 nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data, FALSE); 1528 } 1529 else /* if NFC-DEP, ISO-DEP with frame interface or others */ 1530 { 1531 /* Set data callback to receive raw frame */ 1532 NFC_SetStaticRfCback (nfa_dm_act_data_cback); 1533 nfa_dm_notify_activation_status (NFA_STATUS_OK, NULL); 1534 } 1535 } 1536 else 1537 { 1538 /* deactivate and restart RF discovery */ 1539 nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_DISCOVERY); 1540 } 1541 } 1542 break; 1543 1544 case NFA_DM_RF_DISC_DEACTIVATED_EVT: 1545 1546 /* if deactivated to idle or discovery */ 1547 if ( (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) 1548 ||(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY) ) 1549 { 1550 /* clear stored NFCID/UID/KOVIO bar code */ 1551 nfa_dm_cb.activated_nfcid_len = 0; 1552 } 1553 1554 if (nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_NFC_DEP) 1555 { 1556 /* Notify NFA RW sub-systems */ 1557 nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_DEACTIVATED_EVT, NULL, FALSE); 1558 } 1559 1560 /* if deactivated as sleep mode */ 1561 if ( (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) 1562 ||(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF) ) 1563 { 1564 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_SLEEP; 1565 } 1566 else 1567 { 1568 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE; 1569 } 1570 1571 /* notify deactivation to upper layer */ 1572 nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data); 1573 1574 /* clean up SEL_RES response */ 1575 nfa_dm_cb.disc_cb.activated_sel_res = 0; 1576 break; 1577 1578 default: 1579 NFA_TRACE_ERROR0 ("Unexpected event"); 1580 break; 1581 } 1582} 1583 1584/******************************************************************************* 1585** 1586** Function nfa_dm_poll_disc_cback 1587** 1588** Description Processing event from discovery callback 1589** 1590** Returns None 1591** 1592*******************************************************************************/ 1593static void nfa_dm_poll_disc_cback (tNFA_DM_RF_DISC_EVT event, tNFC_DISCOVER *p_data) 1594{ 1595 tNFA_CONN_EVT_DATA evt_data; 1596 1597 NFA_TRACE_DEBUG1 ("nfa_dm_poll_disc_cback (): event:0x%02X", event); 1598 1599 switch (event) 1600 { 1601 case NFA_DM_RF_DISC_START_EVT: 1602 break; 1603 1604 case NFA_DM_RF_DISC_ACTIVATED_EVT: 1605 1606 if (nfa_dm_cb.disc_cb.activated_tech_mode == NFC_DISCOVERY_TYPE_POLL_A) 1607 { 1608 /* store SEL_RES response */ 1609 nfa_dm_cb.disc_cb.activated_sel_res = p_data->activate.rf_tech_param.param.pa.sel_rsp; 1610 } 1611 1612 /* holding activation notification until sub-module is ready */ 1613 nfa_dm_cb.p_activate_ntf = (UINT8*) GKI_getbuf (sizeof (tNFC_ACTIVATE_DEVT)); 1614 1615 if (nfa_dm_cb.p_activate_ntf) 1616 { 1617 memcpy (nfa_dm_cb.p_activate_ntf, 1618 &(p_data->activate), 1619 sizeof (tNFC_ACTIVATE_DEVT)); 1620 1621 if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP) 1622 &&(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_NFC_DEP) ) 1623 { 1624 if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_P2P_PAUSED)) 1625 { 1626 /* activate LLCP */ 1627 nfa_p2p_activate_llcp (p_data); 1628 } 1629 else 1630 { 1631 NFA_TRACE_DEBUG0 ("P2P is paused"); 1632 nfa_dm_notify_activation_status (NFA_STATUS_OK, NULL); 1633 } 1634 } 1635 else if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T1T) 1636 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) 1637 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) 1638 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP) 1639 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_15693) 1640 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_KOVIO) ) 1641 { 1642 /* Notify NFA tag sub-system */ 1643 nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data, TRUE); 1644 } 1645 else /* if NFC-DEP/ISO-DEP with frame interface */ 1646 { 1647 /* Set data callback to receive raw frame */ 1648 NFC_SetStaticRfCback (nfa_dm_act_data_cback); 1649 nfa_dm_notify_activation_status (NFA_STATUS_OK, NULL); 1650 } 1651 } 1652 else 1653 { 1654 /* deactivate and restart RF discovery */ 1655 nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_DISCOVERY); 1656 } 1657 break; 1658 1659 case NFA_DM_RF_DISC_DEACTIVATED_EVT: 1660 1661 /* if deactivated to idle or discovery */ 1662 if ( (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) 1663 ||(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY) ) 1664 { 1665 /* clear stored NFCID/UID/KOVIO bar code */ 1666 nfa_dm_cb.activated_nfcid_len = 0; 1667 } 1668 1669 if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP) 1670 &&(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_NFC_DEP) ) 1671 { 1672 /* 1673 ** If LLCP link is not deactivated yet, 1674 ** LLCP will receive deactivation ntf through data callback. 1675 ** NFA P2P will receive callback event from LLCP. 1676 */ 1677 } 1678 else 1679 { 1680 /* Notify NFA RW sub-systems */ 1681 nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_DEACTIVATED_EVT, NULL, TRUE); 1682 } 1683 1684 /* if NFA sent NFA_ACTIVATED_EVT earlier */ 1685 if (nfa_dm_cb.flags & NFA_DM_FLAGS_SEND_DEACTIVATED_EVT) 1686 { 1687 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SEND_DEACTIVATED_EVT; 1688 1689 /* if deactivated as sleep mode */ 1690 if ( (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) 1691 ||(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF) ) 1692 { 1693 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_SLEEP; 1694 } 1695 else 1696 { 1697 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE; 1698 } 1699 /* notify deactivation to application */ 1700 nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data); 1701 } 1702 1703 /* clean up SEL_RES response */ 1704 nfa_dm_cb.disc_cb.activated_sel_res = 0; 1705 1706 if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_POLLING_ENABLED)) 1707 { 1708 /* deregister discovery callback from NFA DM Discovery */ 1709 nfa_dm_delete_rf_discover (nfa_dm_cb.poll_disc_handle); 1710 nfa_dm_cb.poll_disc_handle = NFA_HANDLE_INVALID; 1711 1712 /* this is for disable polling */ 1713 if (nfa_dm_cb.flags & NFA_DM_FLAGS_SEND_POLL_STOP_EVT) 1714 { 1715 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SEND_POLL_STOP_EVT; 1716 1717 evt_data.status = NFA_STATUS_OK; 1718 nfa_dm_conn_cback_event_notify (NFA_POLL_DISABLED_EVT, &evt_data); 1719 } 1720 } 1721 break; 1722 } 1723} 1724 1725/******************************************************************************* 1726** 1727** Function nfa_dm_notify_activation_status 1728** 1729** Description Processing activation status from sub-modules 1730** 1731** Returns None 1732** 1733*******************************************************************************/ 1734void nfa_dm_notify_activation_status (tNFA_STATUS status, tNFA_TAG_PARAMS *p_params) 1735{ 1736 tNFA_CONN_EVT_DATA evt_data; 1737 tNFC_RF_TECH_PARAMS *p_tech_params; 1738 UINT8 *p_nfcid = NULL, nfcid_len; 1739 1740 NFA_TRACE_DEBUG1 ("nfa_dm_notify_activation_status (): status:0x%X", status); 1741 1742 if (!nfa_dm_cb.p_activate_ntf) 1743 { 1744 /* this is for NFA P2P listen */ 1745 return; 1746 } 1747 1748 if (status == NFA_STATUS_OK) 1749 { 1750 /* notify NFC link activation */ 1751 memcpy ( &(evt_data.activated.activate_ntf), 1752 nfa_dm_cb.p_activate_ntf, 1753 sizeof (tNFC_ACTIVATE_DEVT)); 1754 1755 p_tech_params = &evt_data.activated.activate_ntf.rf_tech_param; 1756 1757 memset (&(evt_data.activated.params), 0x00, sizeof (tNFA_TAG_PARAMS)); 1758 if (p_params) 1759 { 1760 memcpy (&(evt_data.activated.params), 1761 p_params, 1762 sizeof (tNFA_TAG_PARAMS)); 1763 } 1764 1765 /* get length of NFCID and location */ 1766 if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_A) 1767 { 1768 nfcid_len = p_tech_params->param.pa.nfcid1_len; 1769 p_nfcid = p_tech_params->param.pa.nfcid1; 1770 } 1771 else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_B) 1772 { 1773 nfcid_len = NFC_NFCID0_MAX_LEN; 1774 p_nfcid = p_tech_params->param.pb.nfcid0; 1775 } 1776 else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_F) 1777 { 1778 nfcid_len = NFC_NFCID2_LEN; 1779 p_nfcid = p_tech_params->param.pf.nfcid2; 1780 } 1781 else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_ISO15693) 1782 { 1783 nfcid_len = NFC_ISO15693_UID_LEN; 1784 p_nfcid = p_tech_params->param.pi93.uid; 1785 } 1786 else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_KOVIO) 1787 { 1788 nfcid_len = p_tech_params->param.pk.uid_len; 1789 p_nfcid = p_tech_params->param.pk.uid; 1790 } 1791 else 1792 { 1793 nfcid_len = 0; 1794 } 1795 1796 /* 1797 ** If not in exlusive RF mode, and 1798 ** P2P activation, then push default NDEF message through SNEP 1799 ** TAG activation, then read NDEF message 1800 */ 1801 if (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP) 1802 { 1803 /* 1804 ** Default NDEF message will be put to NFC Forum defualt SNEP server 1805 ** after receiving NFA_LLCP_ACTIVATED_EVT. 1806 */ 1807 } 1808 else if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)) 1809 { 1810 /* 1811 ** if the same tag is activated then do not perform auto NDEF detection. 1812 ** Application may put a tag into sleep mode and reactivate the same tag. 1813 */ 1814 1815 if ( (p_tech_params->mode != nfa_dm_cb.activated_tech_mode) 1816 ||(nfcid_len != nfa_dm_cb.activated_nfcid_len) 1817 ||(memcmp (p_nfcid, nfa_dm_cb.activated_nfcid, nfcid_len))) 1818 { 1819 if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T1T) 1820 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) 1821 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) 1822 ||( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP) 1823 &&(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_ISO_DEP) ) 1824 ||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO15693) ) 1825 { 1826 if (p_nfa_dm_cfg->auto_detect_ndef) 1827 { 1828 if (p_nfa_dm_cfg->auto_read_ndef) 1829 { 1830 nfa_dm_cb.flags |= NFA_DM_FLAGS_AUTO_READING_NDEF; 1831 } 1832 NFA_RwDetectNDef (); 1833 } 1834 else if (p_nfa_dm_cfg->auto_read_ndef) 1835 { 1836 NFA_RwReadNDef (); 1837 } 1838 } 1839 } 1840 } 1841 1842 /* store activated tag information */ 1843 nfa_dm_cb.activated_tech_mode = p_tech_params->mode; 1844 nfa_dm_cb.activated_nfcid_len = nfcid_len; 1845 if (nfcid_len) 1846 memcpy (nfa_dm_cb.activated_nfcid, p_nfcid, nfcid_len); 1847 1848 nfa_dm_cb.flags |= NFA_DM_FLAGS_SEND_DEACTIVATED_EVT; 1849 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING)) 1850 nfa_dm_conn_cback_event_notify (NFA_ACTIVATED_EVT, &evt_data); 1851 } 1852 else 1853 { 1854 /* if NFC_DEP, NFA P2P will deactivate */ 1855 if (nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_NFC_DEP) 1856 { 1857 nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_DISCOVERY); 1858 } 1859 } 1860 1861 GKI_freebuf (nfa_dm_cb.p_activate_ntf); 1862 nfa_dm_cb.p_activate_ntf = NULL; 1863} 1864 1865#if (BT_TRACE_VERBOSE == TRUE) 1866/******************************************************************************* 1867** 1868** Function nfa_dm_nfc_revt_2_str 1869** 1870** Description convert nfc revt to string 1871** 1872*******************************************************************************/ 1873char *nfa_dm_nfc_revt_2_str (tNFC_RESPONSE_EVT event) 1874{ 1875 switch (event) { 1876 case NFC_ENABLE_REVT: 1877 return "NFC_ENABLE_REVT"; 1878 1879 case NFC_DISABLE_REVT: 1880 return "NFC_DISABLE_REVT"; 1881 1882 case NFC_SET_CONFIG_REVT: 1883 return "NFC_SET_CONFIG_REVT"; 1884 1885 case NFC_GET_CONFIG_REVT: 1886 return "NFC_GET_CONFIG_REVT"; 1887 1888 case NFC_NFCEE_DISCOVER_REVT: 1889 return "NFC_NFCEE_DISCOVER_REVT"; 1890 1891 case NFC_NFCEE_INFO_REVT: 1892 return "NFC_NFCEE_INFO_REVT"; 1893 1894 case NFC_NFCEE_MODE_SET_REVT: 1895 return "NFC_NFCEE_MODE_SET_REVT"; 1896 1897 case NFC_RF_FIELD_REVT: 1898 return "NFC_RF_FIELD_REVT"; 1899 1900 case NFC_EE_ACTION_REVT: 1901 return "NFC_EE_ACTION_REVT"; 1902 1903 case NFC_EE_DISCOVER_REQ_REVT: 1904 return "NFC_EE_DISCOVER_REQ_REVT"; 1905 1906 case NFC_SET_ROUTING_REVT: 1907 return "NFC_SET_ROUTING_REVT"; 1908 1909 case NFC_GET_ROUTING_REVT: 1910 return "NFC_GET_ROUTING_REVT"; 1911 1912 case NFC_GEN_ERROR_REVT: 1913 return "NFC_GEN_ERROR_REVT"; 1914 1915 case NFC_NFCC_RESTART_REVT: 1916 return "NFC_NFCC_RESTART_REVT"; 1917 1918 case NFC_NFCC_TIMEOUT_REVT: 1919 return "NFC_NFCC_TIMEOUT_REVT"; 1920 1921 case NFC_NFCC_TRANSPORT_ERR_REVT: 1922 return "NFC_NFCC_TRANSPORT_ERR_REVT"; 1923 1924 case NFC_NFCC_POWER_OFF_REVT: 1925 return "NFC_NFCC_POWER_OFF_REVT"; 1926 1927 default: 1928 return "unknown revt"; 1929 break; 1930 } 1931} 1932#endif /* BT_VERBOSE */ 1933