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 56 static void nfa_dm_set_init_nci_params (void); 57 static tNFA_STATUS nfa_dm_start_polling (void); 58 static BOOLEAN nfa_dm_deactivate_polling (void); 59 static void nfa_dm_excl_disc_cback (tNFA_DM_RF_DISC_EVT event, tNFC_DISCOVER *p_data); 60 static 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 *******************************************************************************/ 72 static 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 *******************************************************************************/ 93 static 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 *******************************************************************************/ 124 void 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 *******************************************************************************/ 138 static 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][3] = 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 *******************************************************************************/ 197 void 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 *******************************************************************************/ 231 static 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 *******************************************************************************/ 252 static 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 *******************************************************************************/ 437 BOOLEAN 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 *******************************************************************************/ 476 BOOLEAN 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 *******************************************************************************/ 530 void 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 *******************************************************************************/ 559 BOOLEAN 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 *******************************************************************************/ 598 BOOLEAN 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 *******************************************************************************/ 615 void 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 *******************************************************************************/ 639 void 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 *******************************************************************************/ 667 BOOLEAN 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 *******************************************************************************/ 714 BOOLEAN 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 *******************************************************************************/ 745 BOOLEAN 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 *******************************************************************************/ 823 BOOLEAN 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 *******************************************************************************/ 841 BOOLEAN 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 *******************************************************************************/ 859 BOOLEAN 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 *******************************************************************************/ 881 tNFA_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 *******************************************************************************/ 958 BOOLEAN 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 *******************************************************************************/ 999 static 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 *******************************************************************************/ 1037 BOOLEAN 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 *******************************************************************************/ 1078 BOOLEAN 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 *******************************************************************************/ 1100 BOOLEAN 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 *******************************************************************************/ 1122 BOOLEAN 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 *******************************************************************************/ 1144 BOOLEAN 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 *******************************************************************************/ 1166 BOOLEAN 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 *******************************************************************************/ 1224 BOOLEAN 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 *******************************************************************************/ 1244 BOOLEAN 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 *******************************************************************************/ 1278 BOOLEAN 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 *******************************************************************************/ 1324 BOOLEAN 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 *******************************************************************************/ 1339 UINT16 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 *******************************************************************************/ 1352 BOOLEAN 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 *******************************************************************************/ 1371 BOOLEAN 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 *******************************************************************************/ 1395 BOOLEAN 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 *******************************************************************************/ 1413 void 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 *******************************************************************************/ 1455 static 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 *******************************************************************************/ 1496 static 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 *******************************************************************************/ 1611 static 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 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_MIFARE) ) 1665 { 1666 /* Notify NFA tag sub-system */ 1667 nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data, TRUE); 1668 } 1669 else /* if NFC-DEP/ISO-DEP with frame interface */ 1670 { 1671 /* Set data callback to receive raw frame */ 1672 NFC_SetStaticRfCback (nfa_dm_act_data_cback); 1673 nfa_dm_notify_activation_status (NFA_STATUS_OK, NULL); 1674 } 1675 } 1676 else 1677 { 1678 /* deactivate and restart RF discovery */ 1679 nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_DISCOVERY); 1680 } 1681 break; 1682 1683 case NFA_DM_RF_DISC_DEACTIVATED_EVT: 1684 1685 /* if deactivated to idle or discovery */ 1686 if ( (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) 1687 ||(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY) ) 1688 { 1689 /* clear stored NFCID/UID/KOVIO bar code */ 1690 nfa_dm_cb.activated_nfcid_len = 0; 1691 } 1692 1693 if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP) 1694 &&(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_NFC_DEP) ) 1695 { 1696 /* 1697 ** If LLCP link is not deactivated yet, 1698 ** LLCP will receive deactivation ntf through data callback. 1699 ** NFA P2P will receive callback event from LLCP. 1700 */ 1701 } 1702 else 1703 { 1704 /* Notify NFA RW sub-systems */ 1705 nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_DEACTIVATED_EVT, NULL, TRUE); 1706 } 1707 1708 /* if NFA sent NFA_ACTIVATED_EVT earlier */ 1709 if (nfa_dm_cb.flags & NFA_DM_FLAGS_SEND_DEACTIVATED_EVT) 1710 { 1711 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SEND_DEACTIVATED_EVT; 1712 1713 /* if deactivated as sleep mode */ 1714 if ( (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) 1715 ||(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF) ) 1716 { 1717 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_SLEEP; 1718 } 1719 else 1720 { 1721 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE; 1722 } 1723 /* notify deactivation to application */ 1724 nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data); 1725 } 1726 1727 /* clean up SEL_RES response */ 1728 nfa_dm_cb.disc_cb.activated_sel_res = 0; 1729 1730 if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_POLLING_ENABLED)) 1731 { 1732 /* deregister discovery callback from NFA DM Discovery */ 1733 nfa_dm_delete_rf_discover (nfa_dm_cb.poll_disc_handle); 1734 nfa_dm_cb.poll_disc_handle = NFA_HANDLE_INVALID; 1735 1736 /* this is for disable polling */ 1737 if (nfa_dm_cb.flags & NFA_DM_FLAGS_SEND_POLL_STOP_EVT) 1738 { 1739 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_SEND_POLL_STOP_EVT; 1740 1741 evt_data.status = NFA_STATUS_OK; 1742 nfa_dm_conn_cback_event_notify (NFA_POLL_DISABLED_EVT, &evt_data); 1743 } 1744 } 1745 break; 1746 } 1747 } 1748 1749 /******************************************************************************* 1750 ** 1751 ** Function nfa_dm_notify_activation_status 1752 ** 1753 ** Description Processing activation status from sub-modules 1754 ** 1755 ** Returns None 1756 ** 1757 *******************************************************************************/ 1758 void nfa_dm_notify_activation_status (tNFA_STATUS status, tNFA_TAG_PARAMS *p_params) 1759 { 1760 tNFA_CONN_EVT_DATA evt_data; 1761 tNFC_RF_TECH_PARAMS *p_tech_params; 1762 UINT8 *p_nfcid = NULL, nfcid_len; 1763 1764 NFA_TRACE_DEBUG1 ("nfa_dm_notify_activation_status (): status:0x%X", status); 1765 1766 if (!nfa_dm_cb.p_activate_ntf) 1767 { 1768 /* this is for NFA P2P listen */ 1769 return; 1770 } 1771 1772 if (status == NFA_STATUS_OK) 1773 { 1774 /* notify NFC link activation */ 1775 memcpy ( &(evt_data.activated.activate_ntf), 1776 nfa_dm_cb.p_activate_ntf, 1777 sizeof (tNFC_ACTIVATE_DEVT)); 1778 1779 p_tech_params = &evt_data.activated.activate_ntf.rf_tech_param; 1780 1781 memset (&(evt_data.activated.params), 0x00, sizeof (tNFA_TAG_PARAMS)); 1782 if (p_params) 1783 { 1784 memcpy (&(evt_data.activated.params), 1785 p_params, 1786 sizeof (tNFA_TAG_PARAMS)); 1787 } 1788 1789 /* get length of NFCID and location */ 1790 if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_A) 1791 { 1792 if ((p_tech_params->param.pa.nfcid1_len == 0) && (p_params != NULL)) 1793 { 1794 nfcid_len = sizeof(p_params->t1t.uid); 1795 p_nfcid = p_params->t1t.uid; 1796 evt_data.activated.activate_ntf.rf_tech_param.param.pa.nfcid1_len = nfcid_len; 1797 memcpy (evt_data.activated.activate_ntf.rf_tech_param.param.pa.nfcid1, p_nfcid, nfcid_len); 1798 } 1799 else 1800 { 1801 nfcid_len = p_tech_params->param.pa.nfcid1_len; 1802 p_nfcid = p_tech_params->param.pa.nfcid1; 1803 } 1804 } 1805 else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_B) 1806 { 1807 nfcid_len = NFC_NFCID0_MAX_LEN; 1808 p_nfcid = p_tech_params->param.pb.nfcid0; 1809 } 1810 else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_F) 1811 { 1812 nfcid_len = NFC_NFCID2_LEN; 1813 p_nfcid = p_tech_params->param.pf.nfcid2; 1814 } 1815 else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_ISO15693) 1816 { 1817 nfcid_len = NFC_ISO15693_UID_LEN; 1818 p_nfcid = p_tech_params->param.pi93.uid; 1819 } 1820 else if (p_tech_params->mode == NFC_DISCOVERY_TYPE_POLL_KOVIO) 1821 { 1822 nfcid_len = p_tech_params->param.pk.uid_len; 1823 p_nfcid = p_tech_params->param.pk.uid; 1824 } 1825 else 1826 { 1827 nfcid_len = 0; 1828 } 1829 1830 /* 1831 ** If not in exlusive RF mode, and 1832 ** P2P activation, then push default NDEF message through SNEP 1833 ** TAG activation, then read NDEF message 1834 */ 1835 if (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_NFC_DEP) 1836 { 1837 /* 1838 ** Default NDEF message will be put to NFC Forum defualt SNEP server 1839 ** after receiving NFA_LLCP_ACTIVATED_EVT. 1840 */ 1841 } 1842 else if (!(nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE)) 1843 { 1844 /* 1845 ** if the same tag is activated then do not perform auto NDEF detection. 1846 ** Application may put a tag into sleep mode and reactivate the same tag. 1847 */ 1848 1849 if ( (p_tech_params->mode != nfa_dm_cb.activated_tech_mode) 1850 ||(nfcid_len != nfa_dm_cb.activated_nfcid_len) 1851 ||(memcmp (p_nfcid, nfa_dm_cb.activated_nfcid, nfcid_len))) 1852 { 1853 if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T1T) 1854 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T2T) 1855 ||(nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_T3T) 1856 ||( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_ISO_DEP) 1857 &&(nfa_dm_cb.disc_cb.activated_rf_interface == NFC_INTERFACE_ISO_DEP) ) 1858 ||(nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_ISO15693) ) 1859 { 1860 if (p_nfa_dm_cfg->auto_detect_ndef) 1861 { 1862 if (p_nfa_dm_cfg->auto_read_ndef) 1863 { 1864 nfa_dm_cb.flags |= NFA_DM_FLAGS_AUTO_READING_NDEF; 1865 } 1866 NFA_RwDetectNDef (); 1867 } 1868 else if (p_nfa_dm_cfg->auto_read_ndef) 1869 { 1870 NFA_RwReadNDef (); 1871 } 1872 } 1873 } 1874 } 1875 1876 /* store activated tag information */ 1877 nfa_dm_cb.activated_tech_mode = p_tech_params->mode; 1878 nfa_dm_cb.activated_nfcid_len = nfcid_len; 1879 if (nfcid_len) 1880 memcpy (nfa_dm_cb.activated_nfcid, p_nfcid, nfcid_len); 1881 1882 nfa_dm_cb.flags |= NFA_DM_FLAGS_SEND_DEACTIVATED_EVT; 1883 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING)) 1884 nfa_dm_conn_cback_event_notify (NFA_ACTIVATED_EVT, &evt_data); 1885 } 1886 else 1887 { 1888 /* if NFC_DEP, NFA P2P will deactivate */ 1889 if (nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_NFC_DEP) 1890 { 1891 nfa_dm_rf_deactivate (NFA_DEACTIVATE_TYPE_DISCOVERY); 1892 } 1893 } 1894 1895 GKI_freebuf (nfa_dm_cb.p_activate_ntf); 1896 nfa_dm_cb.p_activate_ntf = NULL; 1897 } 1898 1899 #if (BT_TRACE_VERBOSE == TRUE) 1900 /******************************************************************************* 1901 ** 1902 ** Function nfa_dm_nfc_revt_2_str 1903 ** 1904 ** Description convert nfc revt to string 1905 ** 1906 *******************************************************************************/ 1907 char *nfa_dm_nfc_revt_2_str (tNFC_RESPONSE_EVT event) 1908 { 1909 switch (event) { 1910 case NFC_ENABLE_REVT: 1911 return "NFC_ENABLE_REVT"; 1912 1913 case NFC_DISABLE_REVT: 1914 return "NFC_DISABLE_REVT"; 1915 1916 case NFC_SET_CONFIG_REVT: 1917 return "NFC_SET_CONFIG_REVT"; 1918 1919 case NFC_GET_CONFIG_REVT: 1920 return "NFC_GET_CONFIG_REVT"; 1921 1922 case NFC_NFCEE_DISCOVER_REVT: 1923 return "NFC_NFCEE_DISCOVER_REVT"; 1924 1925 case NFC_NFCEE_INFO_REVT: 1926 return "NFC_NFCEE_INFO_REVT"; 1927 1928 case NFC_NFCEE_MODE_SET_REVT: 1929 return "NFC_NFCEE_MODE_SET_REVT"; 1930 1931 case NFC_RF_FIELD_REVT: 1932 return "NFC_RF_FIELD_REVT"; 1933 1934 case NFC_EE_ACTION_REVT: 1935 return "NFC_EE_ACTION_REVT"; 1936 1937 case NFC_EE_DISCOVER_REQ_REVT: 1938 return "NFC_EE_DISCOVER_REQ_REVT"; 1939 1940 case NFC_SET_ROUTING_REVT: 1941 return "NFC_SET_ROUTING_REVT"; 1942 1943 case NFC_GET_ROUTING_REVT: 1944 return "NFC_GET_ROUTING_REVT"; 1945 1946 case NFC_GEN_ERROR_REVT: 1947 return "NFC_GEN_ERROR_REVT"; 1948 1949 case NFC_NFCC_RESTART_REVT: 1950 return "NFC_NFCC_RESTART_REVT"; 1951 1952 case NFC_NFCC_TIMEOUT_REVT: 1953 return "NFC_NFCC_TIMEOUT_REVT"; 1954 1955 case NFC_NFCC_TRANSPORT_ERR_REVT: 1956 return "NFC_NFCC_TRANSPORT_ERR_REVT"; 1957 1958 case NFC_NFCC_POWER_OFF_REVT: 1959 return "NFC_NFCC_POWER_OFF_REVT"; 1960 1961 default: 1962 return "unknown revt"; 1963 break; 1964 } 1965 } 1966 #endif /* BT_VERBOSE */ 1967
