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