nfa_dm_act.c revision 2ef0896fb71d2a3bcde1fff34a8d24c2e74340c2
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_get_rf_disc_duration 1333** 1334** Description Get duration for RF discovery 1335** 1336** Returns UINT16 1337** 1338*******************************************************************************/ 1339UINT16 nfa_dm_act_get_rf_disc_duration ( ) 1340{ 1341 return (nfa_dm_cb.disc_cb.disc_duration); 1342} 1343/******************************************************************************* 1344** 1345** Function nfa_dm_act_select 1346** 1347** Description Process RF select command 1348** 1349** Returns TRUE (message buffer to be freed by caller) 1350** 1351*******************************************************************************/ 1352BOOLEAN nfa_dm_act_select (tNFA_DM_MSG *p_data) 1353{ 1354 NFA_TRACE_DEBUG0 ("nfa_dm_act_select ()"); 1355 1356 nfa_dm_rf_discover_select (p_data->select.rf_disc_id, 1357 p_data->select.protocol, 1358 p_data->select.rf_interface); 1359 return (TRUE); 1360} 1361 1362/******************************************************************************* 1363** 1364** Function nfa_dm_act_update_rf_params 1365** 1366** Description Process update RF communication parameters command 1367** 1368** Returns TRUE (message buffer to be freed by caller) 1369** 1370*******************************************************************************/ 1371BOOLEAN nfa_dm_act_update_rf_params (tNFA_DM_MSG *p_data) 1372{ 1373 tNFA_CONN_EVT_DATA conn_evt; 1374 1375 NFA_TRACE_DEBUG0 ("nfa_dm_act_update_rf_params ()"); 1376 1377 if (NFC_UpdateRFCommParams (&p_data->update_rf_params.params) != NFC_STATUS_OK) 1378 { 1379 conn_evt.status = NFA_STATUS_FAILED; 1380 nfa_dm_conn_cback_event_notify (NFA_UPDATE_RF_PARAM_RESULT_EVT, &conn_evt); 1381 } 1382 1383 return (TRUE); 1384} 1385 1386/******************************************************************************* 1387** 1388** Function nfa_dm_act_disable_timeout 1389** 1390** Description timeout on disable process. Shutdown immediately 1391** 1392** Returns TRUE (message buffer to be freed by caller) 1393** 1394*******************************************************************************/ 1395BOOLEAN nfa_dm_act_disable_timeout (tNFA_DM_MSG *p_data) 1396{ 1397 tNFA_DM_API_DISABLE disable; 1398 1399 disable.graceful = FALSE; 1400 nfa_dm_disable ((tNFA_DM_MSG *) &disable); 1401 return (TRUE); 1402} 1403 1404/******************************************************************************* 1405** 1406** Function nfa_dm_act_conn_cback_notify 1407** 1408** Description Notify app of reader/writer/ndef events 1409** 1410** Returns nothing 1411** 1412*******************************************************************************/ 1413void nfa_dm_act_conn_cback_notify (UINT8 event, tNFA_CONN_EVT_DATA *p_data) 1414{ 1415 NFA_TRACE_DEBUG1 ("nfa_dm_act_conn_cback_notify (): event:0x%X", event); 1416 1417 /* Notify event using appropriate CONN_CBACK */ 1418 nfa_dm_conn_cback_event_notify (event, p_data); 1419 1420 /* If not in exclusive RF mode, then read NDEF message from tag (if automatic reading is enabled) */ 1421 if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)) 1422 { 1423 if ( (event == NFA_NDEF_DETECT_EVT) 1424 &&(nfa_dm_cb.flags & NFA_DM_FLAGS_AUTO_READING_NDEF) ) 1425 { 1426 /* read NDEF message from tag */ 1427 if (p_data->ndef_detect.status == NFA_STATUS_OK) 1428 { 1429 NFA_RwReadNDef (); 1430 } 1431 else if (p_data->ndef_detect.status == NFA_STATUS_FAILED) 1432 { 1433 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_AUTO_READING_NDEF; 1434 } 1435 /* ignore NFA_STATUS_BUSY */ 1436 } 1437 else if ( (event == NFA_READ_CPLT_EVT) 1438 &&(nfa_dm_cb.flags & NFA_DM_FLAGS_AUTO_READING_NDEF)) 1439 { 1440 /* reading NDEF message is done */ 1441 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_AUTO_READING_NDEF; 1442 } 1443 } 1444} 1445 1446/******************************************************************************* 1447** 1448** Function nfa_dm_act_data_cback 1449** 1450** Description Processing data from RF link 1451** 1452** Returns None 1453** 1454*******************************************************************************/ 1455static void nfa_dm_act_data_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data) 1456{ 1457 BT_HDR *p_msg; 1458 tNFA_CONN_EVT_DATA evt_data; 1459 1460 NFA_TRACE_DEBUG1 ("nfa_dm_act_data_cback (): event = 0x%X", event); 1461 1462 if (event == NFC_DATA_CEVT) 1463 { 1464 p_msg = (BT_HDR *) p_data->data.p_data; 1465 1466 if (p_msg) 1467 { 1468 evt_data.data.status = p_data->data.status; 1469 evt_data.data.p_data = (UINT8 *) (p_msg + 1) + p_msg->offset; 1470 evt_data.data.len = p_msg->len; 1471 1472 nfa_dm_conn_cback_event_notify (NFA_DATA_EVT, &evt_data); 1473 1474 GKI_freebuf (p_msg); 1475 } 1476 else 1477 { 1478 NFA_TRACE_ERROR0 ("nfa_dm_act_data_cback (): received NFC_DATA_CEVT with NULL data pointer"); 1479 } 1480 } 1481 else if (event == NFC_DEACTIVATE_CEVT) 1482 { 1483 NFC_SetStaticRfCback (NULL); 1484 } 1485} 1486 1487/******************************************************************************* 1488** 1489** Function nfa_dm_excl_disc_cback 1490** 1491** Description Processing event from discovery callback 1492** 1493** Returns None 1494** 1495*******************************************************************************/ 1496static void nfa_dm_excl_disc_cback (tNFA_DM_RF_DISC_EVT event, tNFC_DISCOVER *p_data) 1497{ 1498 tNFA_CONN_EVT_DATA evt_data; 1499 1500 NFA_TRACE_DEBUG1 ("nfa_dm_excl_disc_cback (): event:0x%02X", event); 1501 1502 switch (event) 1503 { 1504 case NFA_DM_RF_DISC_START_EVT: 1505 evt_data.status = NFA_STATUS_OK; 1506 nfa_dm_conn_cback_event_notify (NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT, &evt_data); 1507 break; 1508 1509 case NFA_DM_RF_DISC_ACTIVATED_EVT: 1510 if (nfa_dm_cb.disc_cb.activated_tech_mode == NFC_DISCOVERY_TYPE_POLL_A) 1511 { 1512 /* store SEL_RES response */ 1513 nfa_dm_cb.disc_cb.activated_sel_res = p_data->activate.rf_tech_param.param.pa.sel_rsp; 1514 } 1515 1516 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_ACTIVE) 1517 { 1518 /* Set data callback to receive raw frame */ 1519 NFC_SetStaticRfCback (nfa_dm_act_data_cback); 1520 1521 memset (&(evt_data.activated.params), 0x00, sizeof (tNFA_TAG_PARAMS)); 1522 memcpy (&(evt_data.activated.activate_ntf), &(p_data->activate), sizeof (tNFC_ACTIVATE_DEVT)); 1523 1524 nfa_dm_conn_cback_event_notify (NFA_ACTIVATED_EVT, &evt_data); 1525 } 1526 else 1527 { 1528 /* holding activation notification until sub-module is ready */ 1529 nfa_dm_cb.p_activate_ntf = (UINT8*) GKI_getbuf (sizeof (tNFC_ACTIVATE_DEVT)); 1530 1531 if (nfa_dm_cb.p_activate_ntf) 1532 { 1533 memcpy (nfa_dm_cb.p_activate_ntf, 1534 &(p_data->activate), 1535 sizeof (tNFC_ACTIVATE_DEVT)); 1536 1537 if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T1T) 1538 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) 1539 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) 1540 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP) 1541 ||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO15693) 1542 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_KOVIO) ) 1543 { 1544 /* Notify NFA tag sub-system */ 1545 nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data, FALSE); 1546 } 1547 else /* if NFC-DEP, ISO-DEP with frame interface or others */ 1548 { 1549 /* Set data callback to receive raw frame */ 1550 NFC_SetStaticRfCback (nfa_dm_act_data_cback); 1551 nfa_dm_notify_activation_status (NFA_STATUS_OK, NULL); 1552 } 1553 } 1554 else 1555 { 1556 /* deactivate and restart RF discovery */ 1557 nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_DISCOVERY); 1558 } 1559 } 1560 break; 1561 1562 case NFA_DM_RF_DISC_DEACTIVATED_EVT: 1563 1564 /* if deactivated to idle or discovery */ 1565 if ( (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) 1566 ||(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY) ) 1567 { 1568 /* clear stored NFCID/UID/KOVIO bar code */ 1569 nfa_dm_cb.activated_nfcid_len = 0; 1570 } 1571 1572 if (nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_NFC_DEP) 1573 { 1574 /* Notify NFA RW sub-systems */ 1575 nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_DEACTIVATED_EVT, NULL, FALSE); 1576 } 1577 1578 /* if deactivated as sleep mode */ 1579 if ( (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) 1580 ||(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF) ) 1581 { 1582 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_SLEEP; 1583 } 1584 else 1585 { 1586 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE; 1587 } 1588 1589 /* notify deactivation to upper layer */ 1590 nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data); 1591 1592 /* clean up SEL_RES response */ 1593 nfa_dm_cb.disc_cb.activated_sel_res = 0; 1594 break; 1595 1596 default: 1597 NFA_TRACE_ERROR0 ("Unexpected event"); 1598 break; 1599 } 1600} 1601 1602/******************************************************************************* 1603** 1604** Function nfa_dm_poll_disc_cback 1605** 1606** Description Processing event from discovery callback 1607** 1608** Returns None 1609** 1610*******************************************************************************/ 1611static void nfa_dm_poll_disc_cback (tNFA_DM_RF_DISC_EVT event, tNFC_DISCOVER *p_data) 1612{ 1613 tNFA_CONN_EVT_DATA evt_data; 1614 1615 NFA_TRACE_DEBUG1 ("nfa_dm_poll_disc_cback (): event:0x%02X", event); 1616 1617 switch (event) 1618 { 1619 case NFA_DM_RF_DISC_START_EVT: 1620 break; 1621 1622 case NFA_DM_RF_DISC_ACTIVATED_EVT: 1623 1624 if (nfa_dm_cb.disc_cb.activated_tech_mode == NFC_DISCOVERY_TYPE_POLL_A) 1625 { 1626 /* store SEL_RES response */ 1627 nfa_dm_cb.disc_cb.activated_sel_res = p_data->activate.rf_tech_param.param.pa.sel_rsp; 1628 } 1629 1630 /* holding activation notification until sub-module is ready */ 1631 nfa_dm_cb.p_activate_ntf = (UINT8*) GKI_getbuf (sizeof (tNFC_ACTIVATE_DEVT)); 1632 1633 if (nfa_dm_cb.p_activate_ntf) 1634 { 1635 memcpy (nfa_dm_cb.p_activate_ntf, 1636 &(p_data->activate), 1637 sizeof (tNFC_ACTIVATE_DEVT)); 1638 1639 if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP) 1640 &&(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_NFC_DEP) ) 1641 { 1642 if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_P2P_PAUSED)) 1643 { 1644 /* activate LLCP */ 1645 nfa_p2p_activate_llcp (p_data); 1646 if (nfa_dm_cb.p_activate_ntf) 1647 { 1648 GKI_freebuf (nfa_dm_cb.p_activate_ntf); 1649 nfa_dm_cb.p_activate_ntf = NULL; 1650 } 1651 } 1652 else 1653 { 1654 NFA_TRACE_DEBUG0 ("P2P is paused"); 1655 nfa_dm_notify_activation_status (NFA_STATUS_OK, NULL); 1656 } 1657 } 1658 else if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T1T) 1659 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) 1660 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) 1661 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP) 1662 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_15693) 1663 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_KOVIO) ) 1664 { 1665 /* Notify NFA tag sub-system */ 1666 nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data, TRUE); 1667 } 1668 else /* if NFC-DEP/ISO-DEP with frame interface */ 1669 { 1670 /* Set data callback to receive raw frame */ 1671 NFC_SetStaticRfCback (nfa_dm_act_data_cback); 1672 nfa_dm_notify_activation_status (NFA_STATUS_OK, NULL); 1673 } 1674 } 1675 else 1676 { 1677 /* deactivate and restart RF discovery */ 1678 nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_DISCOVERY); 1679 } 1680 break; 1681 1682 case NFA_DM_RF_DISC_DEACTIVATED_EVT: 1683 1684 /* if deactivated to idle or discovery */ 1685 if ( (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) 1686 ||(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY) ) 1687 { 1688 /* clear stored NFCID/UID/KOVIO bar code */ 1689 nfa_dm_cb.activated_nfcid_len = 0; 1690 } 1691 1692 if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP) 1693 &&(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_NFC_DEP) ) 1694 { 1695 /* 1696 ** If LLCP link is not deactivated yet, 1697 ** LLCP will receive deactivation ntf through data callback. 1698 ** NFA P2P will receive callback event from LLCP. 1699 */ 1700 } 1701 else 1702 { 1703 /* Notify NFA RW sub-systems */ 1704 nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_DEACTIVATED_EVT, NULL, TRUE); 1705 } 1706 1707 /* if NFA sent NFA_ACTIVATED_EVT earlier */ 1708 if (nfa_dm_cb.flags & NFA_DM_FLAGS_SEND_DEACTIVATED_EVT) 1709 { 1710 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SEND_DEACTIVATED_EVT; 1711 1712 /* if deactivated as sleep mode */ 1713 if ( (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) 1714 ||(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF) ) 1715 { 1716 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_SLEEP; 1717 } 1718 else 1719 { 1720 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE; 1721 } 1722 /* notify deactivation to application */ 1723 nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data); 1724 } 1725 1726 /* clean up SEL_RES response */ 1727 nfa_dm_cb.disc_cb.activated_sel_res = 0; 1728 1729 if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_POLLING_ENABLED)) 1730 { 1731 /* deregister discovery callback from NFA DM Discovery */ 1732 nfa_dm_delete_rf_discover (nfa_dm_cb.poll_disc_handle); 1733 nfa_dm_cb.poll_disc_handle = NFA_HANDLE_INVALID; 1734 1735 /* this is for disable polling */ 1736 if (nfa_dm_cb.flags & NFA_DM_FLAGS_SEND_POLL_STOP_EVT) 1737 { 1738 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SEND_POLL_STOP_EVT; 1739 1740 evt_data.status = NFA_STATUS_OK; 1741 nfa_dm_conn_cback_event_notify (NFA_POLL_DISABLED_EVT, &evt_data); 1742 } 1743 } 1744 break; 1745 } 1746} 1747 1748/******************************************************************************* 1749** 1750** Function nfa_dm_notify_activation_status 1751** 1752** Description Processing activation status from sub-modules 1753** 1754** Returns None 1755** 1756*******************************************************************************/ 1757void nfa_dm_notify_activation_status (tNFA_STATUS status, tNFA_TAG_PARAMS *p_params) 1758{ 1759 tNFA_CONN_EVT_DATA evt_data; 1760 tNFC_RF_TECH_PARAMS *p_tech_params; 1761 UINT8 *p_nfcid = NULL, nfcid_len; 1762 1763 NFA_TRACE_DEBUG1 ("nfa_dm_notify_activation_status (): status:0x%X", status); 1764 1765 if (!nfa_dm_cb.p_activate_ntf) 1766 { 1767 /* this is for NFA P2P listen */ 1768 return; 1769 } 1770 1771 if (status == NFA_STATUS_OK) 1772 { 1773 /* notify NFC link activation */ 1774 memcpy ( &(evt_data.activated.activate_ntf), 1775 nfa_dm_cb.p_activate_ntf, 1776 sizeof (tNFC_ACTIVATE_DEVT)); 1777 1778 p_tech_params = &evt_data.activated.activate_ntf.rf_tech_param; 1779 1780 memset (&(evt_data.activated.params), 0x00, sizeof (tNFA_TAG_PARAMS)); 1781 if (p_params) 1782 { 1783 memcpy (&(evt_data.activated.params), 1784 p_params, 1785 sizeof (tNFA_TAG_PARAMS)); 1786 } 1787 1788 /* get length of NFCID and location */ 1789 if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_A) 1790 { 1791 if ((p_tech_params->param.pa.nfcid1_len == 0) && (p_params != NULL)) 1792 { 1793 nfcid_len = sizeof(p_params->t1t.uid); 1794 p_nfcid = p_params->t1t.uid; 1795 evt_data.activated.activate_ntf.rf_tech_param.param.pa.nfcid1_len = nfcid_len; 1796 memcpy (evt_data.activated.activate_ntf.rf_tech_param.param.pa.nfcid1, p_nfcid, nfcid_len); 1797 } 1798 else 1799 { 1800 nfcid_len = p_tech_params->param.pa.nfcid1_len; 1801 p_nfcid = p_tech_params->param.pa.nfcid1; 1802 } 1803 } 1804 else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_B) 1805 { 1806 nfcid_len = NFC_NFCID0_MAX_LEN; 1807 p_nfcid = p_tech_params->param.pb.nfcid0; 1808 } 1809 else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_F) 1810 { 1811 nfcid_len = NFC_NFCID2_LEN; 1812 p_nfcid = p_tech_params->param.pf.nfcid2; 1813 } 1814 else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_ISO15693) 1815 { 1816 nfcid_len = NFC_ISO15693_UID_LEN; 1817 p_nfcid = p_tech_params->param.pi93.uid; 1818 } 1819 else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_KOVIO) 1820 { 1821 nfcid_len = p_tech_params->param.pk.uid_len; 1822 p_nfcid = p_tech_params->param.pk.uid; 1823 } 1824 else 1825 { 1826 nfcid_len = 0; 1827 } 1828 1829 /* 1830 ** If not in exlusive RF mode, and 1831 ** P2P activation, then push default NDEF message through SNEP 1832 ** TAG activation, then read NDEF message 1833 */ 1834 if (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP) 1835 { 1836 /* 1837 ** Default NDEF message will be put to NFC Forum defualt SNEP server 1838 ** after receiving NFA_LLCP_ACTIVATED_EVT. 1839 */ 1840 } 1841 else if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)) 1842 { 1843 /* 1844 ** if the same tag is activated then do not perform auto NDEF detection. 1845 ** Application may put a tag into sleep mode and reactivate the same tag. 1846 */ 1847 1848 if ( (p_tech_params->mode != nfa_dm_cb.activated_tech_mode) 1849 ||(nfcid_len != nfa_dm_cb.activated_nfcid_len) 1850 ||(memcmp (p_nfcid, nfa_dm_cb.activated_nfcid, nfcid_len))) 1851 { 1852 if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T1T) 1853 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) 1854 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) 1855 ||( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP) 1856 &&(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_ISO_DEP) ) 1857 ||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO15693) ) 1858 { 1859 if (p_nfa_dm_cfg->auto_detect_ndef) 1860 { 1861 if (p_nfa_dm_cfg->auto_read_ndef) 1862 { 1863 nfa_dm_cb.flags |= NFA_DM_FLAGS_AUTO_READING_NDEF; 1864 } 1865 NFA_RwDetectNDef (); 1866 } 1867 else if (p_nfa_dm_cfg->auto_read_ndef) 1868 { 1869 NFA_RwReadNDef (); 1870 } 1871 } 1872 } 1873 } 1874 1875 /* store activated tag information */ 1876 nfa_dm_cb.activated_tech_mode = p_tech_params->mode; 1877 nfa_dm_cb.activated_nfcid_len = nfcid_len; 1878 if (nfcid_len) 1879 memcpy (nfa_dm_cb.activated_nfcid, p_nfcid, nfcid_len); 1880 1881 nfa_dm_cb.flags |= NFA_DM_FLAGS_SEND_DEACTIVATED_EVT; 1882 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING)) 1883 nfa_dm_conn_cback_event_notify (NFA_ACTIVATED_EVT, &evt_data); 1884 } 1885 else 1886 { 1887 /* if NFC_DEP, NFA P2P will deactivate */ 1888 if (nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_NFC_DEP) 1889 { 1890 nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_DISCOVERY); 1891 } 1892 } 1893 1894 GKI_freebuf (nfa_dm_cb.p_activate_ntf); 1895 nfa_dm_cb.p_activate_ntf = NULL; 1896} 1897 1898#if (BT_TRACE_VERBOSE == TRUE) 1899/******************************************************************************* 1900** 1901** Function nfa_dm_nfc_revt_2_str 1902** 1903** Description convert nfc revt to string 1904** 1905*******************************************************************************/ 1906char *nfa_dm_nfc_revt_2_str (tNFC_RESPONSE_EVT event) 1907{ 1908 switch (event) { 1909 case NFC_ENABLE_REVT: 1910 return "NFC_ENABLE_REVT"; 1911 1912 case NFC_DISABLE_REVT: 1913 return "NFC_DISABLE_REVT"; 1914 1915 case NFC_SET_CONFIG_REVT: 1916 return "NFC_SET_CONFIG_REVT"; 1917 1918 case NFC_GET_CONFIG_REVT: 1919 return "NFC_GET_CONFIG_REVT"; 1920 1921 case NFC_NFCEE_DISCOVER_REVT: 1922 return "NFC_NFCEE_DISCOVER_REVT"; 1923 1924 case NFC_NFCEE_INFO_REVT: 1925 return "NFC_NFCEE_INFO_REVT"; 1926 1927 case NFC_NFCEE_MODE_SET_REVT: 1928 return "NFC_NFCEE_MODE_SET_REVT"; 1929 1930 case NFC_RF_FIELD_REVT: 1931 return "NFC_RF_FIELD_REVT"; 1932 1933 case NFC_EE_ACTION_REVT: 1934 return "NFC_EE_ACTION_REVT"; 1935 1936 case NFC_EE_DISCOVER_REQ_REVT: 1937 return "NFC_EE_DISCOVER_REQ_REVT"; 1938 1939 case NFC_SET_ROUTING_REVT: 1940 return "NFC_SET_ROUTING_REVT"; 1941 1942 case NFC_GET_ROUTING_REVT: 1943 return "NFC_GET_ROUTING_REVT"; 1944 1945 case NFC_GEN_ERROR_REVT: 1946 return "NFC_GEN_ERROR_REVT"; 1947 1948 case NFC_NFCC_RESTART_REVT: 1949 return "NFC_NFCC_RESTART_REVT"; 1950 1951 case NFC_NFCC_TIMEOUT_REVT: 1952 return "NFC_NFCC_TIMEOUT_REVT"; 1953 1954 case NFC_NFCC_TRANSPORT_ERR_REVT: 1955 return "NFC_NFCC_TRANSPORT_ERR_REVT"; 1956 1957 case NFC_NFCC_POWER_OFF_REVT: 1958 return "NFC_NFCC_POWER_OFF_REVT"; 1959 1960 default: 1961 return "unknown revt"; 1962 break; 1963 } 1964} 1965#endif /* BT_VERBOSE */ 1966