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