nfa_dm_discover.c revision b58ba0e89a3767e6174c42d3e90540d1eae10f81
1/****************************************************************************** 2 * 3 * Copyright (C) 2010-2012 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 discovery 22 * function. 23 * 24 ******************************************************************************/ 25#include <string.h> 26#include "nfa_sys.h" 27#include "nfa_api.h" 28#include "nfa_dm_int.h" 29#include "nfa_p2p_int.h" 30#include "nfa_sys_int.h" 31#if (NFC_NFCEE_INCLUDED == TRUE) 32#include "nfa_ee_api.h" 33#include "nfa_ee_int.h" 34#endif 35#include "nfa_rw_int.h" 36 37/* 38** static functions 39*/ 40 41static UINT8 nfa_dm_get_rf_discover_config (tNFA_DM_DISC_TECH_PROTO_MASK dm_disc_mask, 42 tNFC_DISCOVER_PARAMS disc_params[], 43 UINT8 max_params); 44static tNFA_STATUS nfa_dm_set_rf_listen_mode_config (tNFA_DM_DISC_TECH_PROTO_MASK tech_proto_mask); 45static void nfa_dm_set_rf_listen_mode_raw_config (tNFA_DM_DISC_TECH_PROTO_MASK *p_disc_mask); 46static tNFA_DM_DISC_TECH_PROTO_MASK nfa_dm_disc_get_disc_mask (tNFC_RF_TECH_N_MODE tech_n_mode, 47 tNFC_PROTOCOL protocol); 48static void nfa_dm_notify_discovery (tNFA_DM_RF_DISC_DATA *p_data); 49static tNFA_STATUS nfa_dm_disc_notify_activation (tNFC_DISCOVER *p_data); 50static void nfa_dm_disc_notify_deactivation (tNFA_DM_RF_DISC_SM_EVENT sm_event, tNFC_DISCOVER *p_data); 51static void nfa_dm_disc_data_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data); 52 53#if (BT_TRACE_VERBOSE == TRUE) 54static char *nfa_dm_disc_state_2_str (UINT8 state); 55static char *nfa_dm_disc_event_2_str (UINT8 event); 56#endif 57 58 59/******************************************************************************* 60** 61** Function nfa_dm_get_rf_discover_config 62** 63** Description Build RF discovery configurations from tNFA_DM_DISC_TECH_PROTO_MASK 64** 65** Returns number of RF discovery configurations 66** 67*******************************************************************************/ 68static UINT8 nfa_dm_get_rf_discover_config (tNFA_DM_DISC_TECH_PROTO_MASK dm_disc_mask, 69 tNFC_DISCOVER_PARAMS disc_params[], 70 UINT8 max_params) 71{ 72 UINT8 num_params = 0; 73 74 /* Check polling A */ 75 if (dm_disc_mask & ( NFA_DM_DISC_MASK_PA_T1T 76 |NFA_DM_DISC_MASK_PA_T2T 77 |NFA_DM_DISC_MASK_PA_ISO_DEP 78 |NFA_DM_DISC_MASK_PA_NFC_DEP 79 |NFA_DM_DISC_MASK_P_LEGACY) ) 80 { 81 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_A; 82 disc_params[num_params].frequency = 1; 83 num_params++; 84 85 if (num_params >= max_params) 86 return num_params; 87 } 88 89 /* Check polling B */ 90 if (dm_disc_mask & NFA_DM_DISC_MASK_PB_ISO_DEP) 91 { 92 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_B; 93 disc_params[num_params].frequency = 1; 94 num_params++; 95 96 if (num_params >= max_params) 97 return num_params; 98 } 99 100 /* Check polling F */ 101 if (dm_disc_mask & ( NFA_DM_DISC_MASK_PF_T3T 102 |NFA_DM_DISC_MASK_PF_NFC_DEP) ) 103 { 104 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_F; 105 disc_params[num_params].frequency = 1; 106 num_params++; 107 108 if (num_params >= max_params) 109 return num_params; 110 } 111 112 /* Check polling A Active mode */ 113 if (dm_disc_mask & NFA_DM_DISC_MASK_PAA_NFC_DEP) 114 { 115 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_A_ACTIVE; 116 disc_params[num_params].frequency = 1; 117 num_params++; 118 119 if (num_params >= max_params) 120 return num_params; 121 } 122 123 /* Check polling F Active mode */ 124 if (dm_disc_mask & NFA_DM_DISC_MASK_PFA_NFC_DEP) 125 { 126 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_F_ACTIVE; 127 disc_params[num_params].frequency = 1; 128 num_params++; 129 130 if (num_params >= max_params) 131 return num_params; 132 } 133 134 /* Check listening A */ 135 if (dm_disc_mask & ( NFA_DM_DISC_MASK_LA_T1T 136 |NFA_DM_DISC_MASK_LA_T2T 137 |NFA_DM_DISC_MASK_LA_ISO_DEP 138 |NFA_DM_DISC_MASK_LA_NFC_DEP) ) 139 { 140 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_A; 141 disc_params[num_params].frequency = 1; 142 num_params++; 143 144 if (num_params >= max_params) 145 return num_params; 146 } 147 148 /* Check listening B */ 149 if (dm_disc_mask & NFA_DM_DISC_MASK_LB_ISO_DEP) 150 { 151 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_B; 152 disc_params[num_params].frequency = 1; 153 num_params++; 154 155 if (num_params >= max_params) 156 return num_params; 157 } 158 159 /* Check listening F */ 160 if (dm_disc_mask & ( NFA_DM_DISC_MASK_LF_T3T 161 |NFA_DM_DISC_MASK_LF_NFC_DEP) ) 162 { 163 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_F; 164 disc_params[num_params].frequency = 1; 165 num_params++; 166 167 if (num_params >= max_params) 168 return num_params; 169 } 170 171 /* Check listening A Active mode */ 172 if (dm_disc_mask & NFA_DM_DISC_MASK_LAA_NFC_DEP) 173 { 174 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE; 175 disc_params[num_params].frequency = 1; 176 num_params++; 177 178 if (num_params >= max_params) 179 return num_params; 180 } 181 182 /* Check listening F Active mode */ 183 if (dm_disc_mask & NFA_DM_DISC_MASK_LFA_NFC_DEP) 184 { 185 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE; 186 disc_params[num_params].frequency = 1; 187 num_params++; 188 189 if (num_params >= max_params) 190 return num_params; 191 } 192 193 /* Check polling ISO 15693 */ 194 if (dm_disc_mask & NFA_DM_DISC_MASK_P_ISO15693) 195 { 196 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_ISO15693; 197 disc_params[num_params].frequency = 1; 198 num_params++; 199 200 if (num_params >= max_params) 201 return num_params; 202 } 203 204 /* Check polling B' */ 205 if (dm_disc_mask & NFA_DM_DISC_MASK_P_B_PRIME) 206 { 207 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_B_PRIME; 208 disc_params[num_params].frequency = 1; 209 num_params++; 210 211 if (num_params >= max_params) 212 return num_params; 213 } 214 215 /* Check polling KOVIO */ 216 if (dm_disc_mask & NFA_DM_DISC_MASK_P_KOVIO) 217 { 218 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_KOVIO; 219 disc_params[num_params].frequency = 1; 220 num_params++; 221 222 if (num_params >= max_params) 223 return num_params; 224 } 225 226 /* Check listening ISO 15693 */ 227 if (dm_disc_mask & NFA_DM_DISC_MASK_L_ISO15693) 228 { 229 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_ISO15693; 230 disc_params[num_params].frequency = 1; 231 num_params++; 232 233 if (num_params >= max_params) 234 return num_params; 235 } 236 237 /* Check listening B' */ 238 if (dm_disc_mask & NFA_DM_DISC_MASK_L_B_PRIME) 239 { 240 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_B_PRIME; 241 disc_params[num_params].frequency = 1; 242 num_params++; 243 244 if (num_params >= max_params) 245 return num_params; 246 } 247 248 return num_params; 249} 250 251/******************************************************************************* 252** 253** Function nfa_dm_set_rf_listen_mode_config 254** 255** Description Update listening protocol to NFCC 256** 257** Returns NFA_STATUS_OK if success 258** 259*******************************************************************************/ 260static tNFA_STATUS nfa_dm_set_rf_listen_mode_config (tNFA_DM_DISC_TECH_PROTO_MASK tech_proto_mask) 261{ 262 UINT8 params[40], *p; 263 UINT8 platform = 0; 264 UINT8 sens_info = 0; 265 266 NFA_TRACE_DEBUG1 ("nfa_dm_set_rf_listen_mode_config () tech_proto_mask = 0x%08X", 267 tech_proto_mask); 268 269 /* 270 ** T1T listen LA_PROT 0x80, LA_SENS_RES byte1:0x00 byte2:0x0C 271 ** T2T listen LA_PROT 0x00 272 ** T3T listen No bit for T3T in LF_PROT (CE T3T set listen parameters, system code, NFCID2, etc.) 273 ** ISO-DEP listen LA_PROT 0x01, LB_PROT 0x01 274 ** NFC-DEP listen LA_PROT 0x02, LF_PROT 0x02 275 */ 276 277 if (tech_proto_mask & NFA_DM_DISC_MASK_LA_T1T) 278 { 279 platform = NCI_PARAM_PLATFORM_T1T; 280 } 281 else if (tech_proto_mask & NFA_DM_DISC_MASK_LA_T2T) 282 { 283 /* platform = 0 and sens_info = 0 */ 284 } 285 else 286 { 287 if (tech_proto_mask & NFA_DM_DISC_MASK_LA_ISO_DEP) 288 { 289 sens_info |= NCI_PARAM_SEL_INFO_ISODEP; 290 } 291 292 if (tech_proto_mask & NFA_DM_DISC_MASK_LA_NFC_DEP) 293 { 294 sens_info |= NCI_PARAM_SEL_INFO_NFCDEP; 295 } 296 } 297 298 p = params; 299 300 /* 301 ** for Listen A 302 ** 303 ** Set ATQA 0x0C00 for T1T listen 304 ** If the ATQA values are 0x0000, then the FW will use 0x0400 305 ** which works for ISODEP, T2T and NFCDEP. 306 */ 307 if (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A] == NFA_DM_DISC_HOST_ID_DH) 308 { 309 UINT8_TO_STREAM (p, NFC_PMID_LA_BIT_FRAME_SDD); 310 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_BIT_FRAME_SDD); 311 UINT8_TO_STREAM (p, 0x04); 312 UINT8_TO_STREAM (p, NFC_PMID_LA_PLATFORM_CONFIG); 313 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_PLATFORM_CONFIG); 314 UINT8_TO_STREAM (p, platform); 315 UINT8_TO_STREAM (p, NFC_PMID_LA_SEL_INFO); 316 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_SEL_INFO); 317 UINT8_TO_STREAM (p, sens_info); 318 } 319 else /* Let NFCC use UICC configuration by configuring with length = 0 */ 320 { 321 UINT8_TO_STREAM (p, NFC_PMID_LA_BIT_FRAME_SDD); 322 UINT8_TO_STREAM (p, 0); 323 UINT8_TO_STREAM (p, NFC_PMID_LA_PLATFORM_CONFIG); 324 UINT8_TO_STREAM (p, 0); 325 UINT8_TO_STREAM (p, NFC_PMID_LA_SEL_INFO); 326 UINT8_TO_STREAM (p, 0); 327 UINT8_TO_STREAM (p, NFC_PMID_LA_NFCID1); 328 UINT8_TO_STREAM (p, 0); 329 UINT8_TO_STREAM (p, NFC_PMID_LA_HIST_BY); 330 UINT8_TO_STREAM (p, 0); 331 } 332 333 /* for Listen B */ 334 if (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_B] == NFA_DM_DISC_HOST_ID_DH) 335 { 336 UINT8_TO_STREAM (p, NFC_PMID_LB_SENSB_INFO); 337 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_SENSB_INFO); 338 if (tech_proto_mask & NFA_DM_DISC_MASK_LB_ISO_DEP) 339 { 340 UINT8_TO_STREAM (p, NCI_LISTEN_PROTOCOL_ISO_DEP); 341 } 342 else 343 { 344 UINT8_TO_STREAM (p, 0x00); 345 } 346 } 347 else /* Let NFCC use UICC configuration by configuring with length = 0 */ 348 { 349 UINT8_TO_STREAM (p, NFC_PMID_LB_SENSB_INFO); 350 UINT8_TO_STREAM (p, 0); 351 UINT8_TO_STREAM (p, NFC_PMID_LB_NFCID0); 352 UINT8_TO_STREAM (p, 0); 353 UINT8_TO_STREAM (p, NFC_PMID_LB_APPDATA); 354 UINT8_TO_STREAM (p, 0); 355 UINT8_TO_STREAM (p, NFC_PMID_LB_ADC_FO); 356 UINT8_TO_STREAM (p, 0); 357 UINT8_TO_STREAM (p, NFC_PMID_LB_H_INFO); 358 UINT8_TO_STREAM (p, 0); 359 } 360 361 /* for Listen F */ 362 if (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_F] == NFA_DM_DISC_HOST_ID_DH) 363 { 364 UINT8_TO_STREAM (p, NFC_PMID_LF_PROTOCOL); 365 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_PROTOCOL); 366 if (tech_proto_mask & NFA_DM_DISC_MASK_LF_NFC_DEP) 367 { 368 UINT8_TO_STREAM (p, NCI_LISTEN_PROTOCOL_NFC_DEP); 369 } 370 else 371 { 372 UINT8_TO_STREAM (p, 0x00); 373 } 374 } 375 else 376 { 377 /* If DH is not listening on T3T, let NFCC use UICC configuration by configuring with length = 0 */ 378 if ((tech_proto_mask & NFA_DM_DISC_MASK_LF_T3T) == 0) 379 { 380 UINT8_TO_STREAM (p, NFC_PMID_LF_PROTOCOL); 381 UINT8_TO_STREAM (p, 0); 382 UINT8_TO_STREAM (p, NFC_PMID_LF_T3T_FLAGS2); 383 UINT8_TO_STREAM (p, 0); 384 } 385 } 386 387 if (p > params) 388 { 389 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE); 390 } 391 392 return NFA_STATUS_OK; 393} 394 395/******************************************************************************* 396** 397** Function nfa_dm_set_total_duration 398** 399** Description Update total duration to NFCC 400** 401** Returns void 402** 403*******************************************************************************/ 404static void nfa_dm_set_total_duration (void) 405{ 406 UINT8 params[10], *p; 407 408 NFA_TRACE_DEBUG0 ("nfa_dm_set_total_duration ()"); 409 410 p = params; 411 412 /* for total duration */ 413 UINT8_TO_STREAM (p, NFC_PMID_TOTAL_DURATION); 414 UINT8_TO_STREAM (p, NCI_PARAM_LEN_TOTAL_DURATION); 415 UINT16_TO_STREAM (p, nfa_dm_cb.disc_cb.disc_duration); 416 417 if (p > params) 418 { 419 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE); 420 } 421} 422 423/******************************************************************************* 424** 425** Function nfa_dm_set_rf_listen_mode_raw_config 426** 427** Description Set raw listen parameters 428** 429** Returns void 430** 431*******************************************************************************/ 432static void nfa_dm_set_rf_listen_mode_raw_config (tNFA_DM_DISC_TECH_PROTO_MASK *p_disc_mask) 433{ 434 tNFA_DM_DISC_TECH_PROTO_MASK disc_mask = 0; 435 tNFA_LISTEN_CFG *p_cfg = &nfa_dm_cb.disc_cb.excl_listen_config; 436 UINT8 params[250], *p, xx; 437 438 NFA_TRACE_DEBUG0 ("nfa_dm_set_rf_listen_mode_raw_config ()"); 439 440 /* 441 ** Discovery Configuration Parameters for Listen A 442 */ 443 if ( (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A] == NFA_DM_DISC_HOST_ID_DH) 444 &&(p_cfg->la_enable) ) 445 { 446 p = params; 447 448 UINT8_TO_STREAM (p, NFC_PMID_LA_BIT_FRAME_SDD); 449 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_BIT_FRAME_SDD); 450 UINT8_TO_STREAM (p, p_cfg->la_bit_frame_sdd); 451 452 UINT8_TO_STREAM (p, NFC_PMID_LA_PLATFORM_CONFIG); 453 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_PLATFORM_CONFIG); 454 UINT8_TO_STREAM (p, p_cfg->la_platform_config); 455 456 UINT8_TO_STREAM (p, NFC_PMID_LA_SEL_INFO); 457 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_SEL_INFO); 458 UINT8_TO_STREAM (p, p_cfg->la_sel_info); 459 460 if (p_cfg->la_platform_config == NCI_PARAM_PLATFORM_T1T) 461 { 462 disc_mask |= NFA_DM_DISC_MASK_LA_T1T; 463 } 464 else 465 { 466 /* If T4T or NFCDEP */ 467 if (p_cfg->la_sel_info & NCI_PARAM_SEL_INFO_ISODEP) 468 { 469 disc_mask |= NFA_DM_DISC_MASK_LA_ISO_DEP; 470 } 471 472 if (p_cfg->la_sel_info & NCI_PARAM_SEL_INFO_NFCDEP) 473 { 474 disc_mask |= NFA_DM_DISC_MASK_LA_NFC_DEP; 475 } 476 477 /* If neither, T4T nor NFCDEP, then its T2T */ 478 if (disc_mask == 0) 479 { 480 disc_mask |= NFA_DM_DISC_MASK_LA_T2T; 481 } 482 } 483 484 UINT8_TO_STREAM (p, NFC_PMID_LA_NFCID1); 485 UINT8_TO_STREAM (p, p_cfg->la_nfcid1_len); 486 ARRAY_TO_STREAM (p, p_cfg->la_nfcid1, p_cfg->la_nfcid1_len); 487 488 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE); 489 } 490 491 /* 492 ** Discovery Configuration Parameters for Listen B 493 */ 494 if ( (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_B] == NFA_DM_DISC_HOST_ID_DH) 495 &&(p_cfg->lb_enable) ) 496 { 497 p = params; 498 499 UINT8_TO_STREAM (p, NFC_PMID_LB_SENSB_INFO); 500 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_SENSB_INFO); 501 UINT8_TO_STREAM (p, p_cfg->lb_sensb_info); 502 503 UINT8_TO_STREAM (p, NFC_PMID_LB_NFCID0); 504 UINT8_TO_STREAM (p, p_cfg->lb_nfcid0_len); 505 ARRAY_TO_STREAM (p, p_cfg->lb_nfcid0, p_cfg->lb_nfcid0_len); 506 507 UINT8_TO_STREAM (p, NFC_PMID_LB_APPDATA); 508 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_APPDATA); 509 ARRAY_TO_STREAM (p, p_cfg->lb_app_data, NCI_PARAM_LEN_LB_APPDATA); 510 511 UINT8_TO_STREAM (p, NFC_PMID_LB_SFGI); 512 UINT8_TO_STREAM (p, 1); 513 UINT8_TO_STREAM (p, p_cfg->lb_adc_fo); 514 515 UINT8_TO_STREAM (p, NFC_PMID_LB_ADC_FO); 516 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_ADC_FO); 517 UINT8_TO_STREAM (p, p_cfg->lb_adc_fo); 518 519 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE); 520 521 if (p_cfg->lb_sensb_info & NCI_LISTEN_PROTOCOL_ISO_DEP) 522 { 523 disc_mask |= NFA_DM_DISC_MASK_LB_ISO_DEP; 524 } 525 } 526 527 /* 528 ** Discovery Configuration Parameters for Listen F 529 */ 530 if ( (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_F] == NFA_DM_DISC_HOST_ID_DH) 531 &&(p_cfg->lf_enable) ) 532 { 533 p = params; 534 535 UINT8_TO_STREAM (p, NFC_PMID_LF_CON_BITR_F); 536 UINT8_TO_STREAM (p, 1); 537 UINT8_TO_STREAM (p, p_cfg->lf_con_bitr_f); 538 539 UINT8_TO_STREAM (p, NFC_PMID_LF_PROTOCOL); 540 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_PROTOCOL); 541 UINT8_TO_STREAM (p, p_cfg->lf_protocol_type); 542 543 UINT8_TO_STREAM (p, NFC_PMID_LF_T3T_FLAGS2); 544 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_T3T_FLAGS2); 545 UINT16_TO_STREAM(p, p_cfg->lf_t3t_flags); 546 547 /* if the bit at position X is set to 0, SC/NFCID2 with index X shall be ignored */ 548 for (xx = 0; xx < NFA_LF_MAX_SC_NFCID2; xx++) 549 { 550 if ((p_cfg->lf_t3t_flags & (0x0001 << xx)) != 0x0000) 551 { 552 UINT8_TO_STREAM (p, NFC_PMID_LF_T3T_ID1 + xx); 553 UINT8_TO_STREAM (p, NCI_SYSTEMCODE_LEN + NCI_NFCID2_LEN); 554 ARRAY_TO_STREAM (p, p_cfg->lf_t3t_identifier[xx], NCI_SYSTEMCODE_LEN + NCI_NFCID2_LEN); 555 } 556 } 557 558 UINT8_TO_STREAM (p, NFC_PMID_LF_T3T_PMM); 559 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_T3T_PMM); 560 ARRAY_TO_STREAM (p, p_cfg->lf_t3t_pmm, NCI_PARAM_LEN_LF_T3T_PMM); 561 562 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE); 563 564 if (p_cfg->lf_t3t_flags != NCI_LF_T3T_FLAGS2_ALL_DISABLED) 565 { 566 disc_mask |= NFA_DM_DISC_MASK_LF_T3T; 567 } 568 if (p_cfg->lf_protocol_type & NCI_LISTEN_PROTOCOL_NFC_DEP) 569 { 570 disc_mask |= NFA_DM_DISC_MASK_LF_NFC_DEP; 571 } 572 } 573 574 /* 575 ** Discovery Configuration Parameters for Listen ISO-DEP 576 */ 577 if ((disc_mask & (NFA_DM_DISC_MASK_LA_ISO_DEP|NFA_DM_DISC_MASK_LB_ISO_DEP)) 578 &&(p_cfg->li_enable)) 579 { 580 p = params; 581 582 UINT8_TO_STREAM (p, NFC_PMID_FWI); 583 UINT8_TO_STREAM (p, NCI_PARAM_LEN_FWI); 584 UINT8_TO_STREAM (p, p_cfg->li_fwi); 585 586 if (disc_mask & NFA_DM_DISC_MASK_LA_ISO_DEP) 587 { 588 UINT8_TO_STREAM (p, NFC_PMID_LA_HIST_BY); 589 UINT8_TO_STREAM (p, p_cfg->la_hist_bytes_len); 590 ARRAY_TO_STREAM (p, p_cfg->la_hist_bytes, p_cfg->la_hist_bytes_len); 591 } 592 593 if (disc_mask & NFA_DM_DISC_MASK_LB_ISO_DEP) 594 { 595 UINT8_TO_STREAM (p, NFC_PMID_LB_H_INFO); 596 UINT8_TO_STREAM (p, p_cfg->lb_h_info_resp_len); 597 ARRAY_TO_STREAM (p, p_cfg->lb_h_info_resp, p_cfg->lb_h_info_resp_len); 598 } 599 600 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE); 601 } 602 603 /* 604 ** Discovery Configuration Parameters for Listen NFC-DEP 605 */ 606 if ( (disc_mask & (NFA_DM_DISC_MASK_LA_NFC_DEP|NFA_DM_DISC_MASK_LF_NFC_DEP)) 607 &&(p_cfg->ln_enable)) 608 { 609 p = params; 610 611 UINT8_TO_STREAM (p, NFC_PMID_WT); 612 UINT8_TO_STREAM (p, NCI_PARAM_LEN_WT); 613 UINT8_TO_STREAM (p, p_cfg->ln_wt); 614 615 UINT8_TO_STREAM (p, NFC_PMID_ATR_RES_GEN_BYTES); 616 UINT8_TO_STREAM (p, p_cfg->ln_atr_res_gen_bytes_len); 617 ARRAY_TO_STREAM (p, p_cfg->ln_atr_res_gen_bytes, p_cfg->ln_atr_res_gen_bytes_len); 618 619 UINT8_TO_STREAM (p, NFC_PMID_ATR_RSP_CONFIG); 620 UINT8_TO_STREAM (p, 1); 621 UINT8_TO_STREAM (p, p_cfg->ln_atr_res_config); 622 623 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE); 624 } 625 626 *p_disc_mask = disc_mask; 627 628 NFA_TRACE_DEBUG1 ("nfa_dm_set_rf_listen_mode_raw_config () disc_mask = 0x%x", disc_mask); 629} 630 631/******************************************************************************* 632** 633** Function nfa_dm_disc_get_disc_mask 634** 635** Description Convert RF technology, mode and protocol to bit mask 636** 637** Returns tNFA_DM_DISC_TECH_PROTO_MASK 638** 639*******************************************************************************/ 640static tNFA_DM_DISC_TECH_PROTO_MASK nfa_dm_disc_get_disc_mask (tNFC_RF_TECH_N_MODE tech_n_mode, 641 tNFC_PROTOCOL protocol) 642{ 643 /* Set initial disc_mask to legacy poll or listen */ 644 tNFA_DM_DISC_TECH_PROTO_MASK disc_mask = ((tech_n_mode & 0x80) ? NFA_DM_DISC_MASK_L_LEGACY : NFA_DM_DISC_MASK_P_LEGACY); 645 646 switch (tech_n_mode) 647 { 648 case NFC_DISCOVERY_TYPE_POLL_A: 649 switch (protocol) 650 { 651 case NFC_PROTOCOL_T1T: 652 disc_mask = NFA_DM_DISC_MASK_PA_T1T; 653 break; 654 case NFC_PROTOCOL_T2T: 655 disc_mask = NFA_DM_DISC_MASK_PA_T2T; 656 break; 657 case NFC_PROTOCOL_ISO_DEP: 658 disc_mask = NFA_DM_DISC_MASK_PA_ISO_DEP; 659 break; 660 case NFC_PROTOCOL_NFC_DEP: 661 disc_mask = NFA_DM_DISC_MASK_PA_NFC_DEP; 662 break; 663 } 664 break; 665 case NFC_DISCOVERY_TYPE_POLL_B: 666 if (protocol == NFC_PROTOCOL_ISO_DEP) 667 disc_mask = NFA_DM_DISC_MASK_PB_ISO_DEP; 668 break; 669 case NFC_DISCOVERY_TYPE_POLL_F: 670 if (protocol == NFC_PROTOCOL_T3T) 671 disc_mask = NFA_DM_DISC_MASK_PF_T3T; 672 else if (protocol == NFC_PROTOCOL_NFC_DEP) 673 disc_mask = NFA_DM_DISC_MASK_PF_NFC_DEP; 674 break; 675 case NFC_DISCOVERY_TYPE_POLL_ISO15693: 676 disc_mask = NFA_DM_DISC_MASK_P_ISO15693; 677 break; 678 case NFC_DISCOVERY_TYPE_POLL_B_PRIME: 679 disc_mask = NFA_DM_DISC_MASK_P_B_PRIME; 680 break; 681 case NFC_DISCOVERY_TYPE_POLL_KOVIO: 682 disc_mask = NFA_DM_DISC_MASK_P_KOVIO; 683 break; 684 case NFC_DISCOVERY_TYPE_POLL_A_ACTIVE: 685 disc_mask = NFA_DM_DISC_MASK_PAA_NFC_DEP; 686 break; 687 case NFC_DISCOVERY_TYPE_POLL_F_ACTIVE: 688 disc_mask = NFA_DM_DISC_MASK_PFA_NFC_DEP; 689 break; 690 691 case NFC_DISCOVERY_TYPE_LISTEN_A: 692 switch (protocol) 693 { 694 case NFC_PROTOCOL_T1T: 695 disc_mask = NFA_DM_DISC_MASK_LA_T1T; 696 break; 697 case NFC_PROTOCOL_T2T: 698 disc_mask = NFA_DM_DISC_MASK_LA_T2T; 699 break; 700 case NFC_PROTOCOL_ISO_DEP: 701 disc_mask = NFA_DM_DISC_MASK_LA_ISO_DEP; 702 break; 703 case NFC_PROTOCOL_NFC_DEP: 704 disc_mask = NFA_DM_DISC_MASK_LA_NFC_DEP; 705 break; 706 } 707 break; 708 case NFC_DISCOVERY_TYPE_LISTEN_B: 709 if (protocol == NFC_PROTOCOL_ISO_DEP) 710 disc_mask = NFA_DM_DISC_MASK_LB_ISO_DEP; 711 break; 712 case NFC_DISCOVERY_TYPE_LISTEN_F: 713 if (protocol == NFC_PROTOCOL_T3T) 714 disc_mask = NFA_DM_DISC_MASK_LF_T3T; 715 else if (protocol == NFC_PROTOCOL_NFC_DEP) 716 disc_mask = NFA_DM_DISC_MASK_LF_NFC_DEP; 717 break; 718 case NFC_DISCOVERY_TYPE_LISTEN_ISO15693: 719 disc_mask = NFA_DM_DISC_MASK_L_ISO15693; 720 break; 721 case NFC_DISCOVERY_TYPE_LISTEN_B_PRIME: 722 disc_mask = NFA_DM_DISC_MASK_L_B_PRIME; 723 break; 724 case NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE: 725 disc_mask = NFA_DM_DISC_MASK_LAA_NFC_DEP; 726 break; 727 case NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE: 728 disc_mask = NFA_DM_DISC_MASK_LFA_NFC_DEP; 729 break; 730 } 731 732 NFA_TRACE_DEBUG3 ("nfa_dm_disc_get_disc_mask (): tech_n_mode:0x%X, protocol:0x%X, disc_mask:0x%X", 733 tech_n_mode, protocol, disc_mask); 734 return (disc_mask); 735} 736 737/******************************************************************************* 738** 739** Function nfa_dm_disc_discovery_cback 740** 741** Description Discovery callback event from NFC 742** 743** Returns void 744** 745*******************************************************************************/ 746static void nfa_dm_disc_discovery_cback (tNFC_DISCOVER_EVT event, tNFC_DISCOVER *p_data) 747{ 748 tNFA_DM_RF_DISC_SM_EVENT dm_disc_event = NFA_DM_DISC_SM_MAX_EVENT; 749 750 NFA_TRACE_DEBUG1 ("nfa_dm_disc_discovery_cback (): event:0x%X", event); 751 752 switch (event) 753 { 754 case NFC_START_DEVT: 755 dm_disc_event = NFA_DM_RF_DISCOVER_RSP; 756 break; 757 case NFC_RESULT_DEVT: 758 dm_disc_event = NFA_DM_RF_DISCOVER_NTF; 759 break; 760 case NFC_SELECT_DEVT: 761 dm_disc_event = NFA_DM_RF_DISCOVER_SELECT_RSP; 762 break; 763 case NFC_ACTIVATE_DEVT: 764 dm_disc_event = NFA_DM_RF_INTF_ACTIVATED_NTF; 765 break; 766 case NFC_DEACTIVATE_DEVT: 767 if (p_data->deactivate.is_ntf) 768 dm_disc_event = NFA_DM_RF_DEACTIVATE_NTF; 769 else 770 dm_disc_event = NFA_DM_RF_DEACTIVATE_RSP; 771 break; 772 default: 773 NFA_TRACE_ERROR0 ("Unexpected event"); 774 return; 775 } 776 777 nfa_dm_disc_sm_execute (dm_disc_event, (tNFA_DM_RF_DISC_DATA *) p_data); 778} 779 780/******************************************************************************* 781** 782** Function nfa_dm_disc_notify_started 783** 784** Description Report NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT or 785** NFA_RF_DISCOVERY_STARTED_EVT, if needed 786** 787** Returns void 788** 789*******************************************************************************/ 790static void nfa_dm_disc_notify_started (tNFA_STATUS status) 791{ 792 tNFA_CONN_EVT_DATA evt_data; 793 794 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_NOTIFY) 795 { 796 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY; 797 798 evt_data.status = status; 799 800 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use) 801 nfa_dm_conn_cback_event_notify (NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT, &evt_data); 802 else 803 nfa_dm_conn_cback_event_notify (NFA_RF_DISCOVERY_STARTED_EVT, &evt_data); 804 } 805} 806 807/******************************************************************************* 808** 809** Function nfa_dm_disc_conn_event_notify 810** 811** Description Notify application of CONN_CBACK event, using appropriate 812** callback 813** 814** Returns nothing 815** 816*******************************************************************************/ 817void nfa_dm_disc_conn_event_notify (UINT8 event, tNFA_STATUS status) 818{ 819 tNFA_CONN_EVT_DATA evt_data; 820 821 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_NOTIFY) 822 { 823 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY; 824 evt_data.status = status; 825 826 if (nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) 827 { 828 /* Use exclusive RF mode callback */ 829 if (nfa_dm_cb.p_excl_conn_cback) 830 (*nfa_dm_cb.p_excl_conn_cback) (event, &evt_data); 831 } 832 else 833 { 834 (*nfa_dm_cb.p_conn_cback) (event, &evt_data); 835 } 836 } 837} 838 839/******************************************************************************* 840** 841** Function nfa_dm_send_deactivate_cmd 842** 843** Description Send deactivate command to NFCC, if needed. 844** 845** Returns NFC_STATUS_OK - deactivate cmd is sent 846** NCI_STATUS_FAILED - no buffers 847** NFC_STATUS_SEMANTIC_ERROR - this function does not attempt 848** to send deactivate cmd 849** 850*******************************************************************************/ 851static tNFC_STATUS nfa_dm_send_deactivate_cmd (tNFC_DEACT_TYPE deactivate_type) 852{ 853 tNFC_STATUS status = NFC_STATUS_SEMANTIC_ERROR; 854 tNFA_DM_DISC_FLAGS w4_flags = nfa_dm_cb.disc_cb.disc_flags & (NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF); 855 856 if (!w4_flags) 857 { 858 /* if deactivate CMD was not sent to NFCC */ 859 nfa_dm_cb.disc_cb.disc_flags |= (NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF); 860 861 status = NFC_Deactivate (deactivate_type); 862 } 863 else if ((w4_flags == NFA_DM_DISC_FLAGS_W4_NTF) && (deactivate_type == NFC_DEACTIVATE_TYPE_IDLE)) 864 { 865 nfa_dm_cb.disc_cb.disc_flags &= ~(NFA_DM_DISC_FLAGS_W4_NTF); 866 nfa_dm_cb.disc_cb.disc_flags |= (NFA_DM_DISC_FLAGS_W4_RSP); 867 nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY); 868 status = NFC_Deactivate (deactivate_type); 869 } 870 871 return status; 872} 873 874/******************************************************************************* 875** 876** Function nfa_dm_start_rf_discover 877** 878** Description Start RF discovery 879** 880** Returns void 881** 882*******************************************************************************/ 883void nfa_dm_start_rf_discover (void) 884{ 885 tNFC_DISCOVER_PARAMS disc_params[NFA_DM_MAX_DISC_PARAMS]; 886 tNFA_DM_DISC_TECH_PROTO_MASK dm_disc_mask = 0, poll_mask, listen_mask; 887 UINT8 num_params, xx; 888 889 NFA_TRACE_DEBUG0 ("nfa_dm_start_rf_discover ()"); 890 /* Make sure that RF discovery was enabled, or some app has exclusive control */ 891 if ( (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED)) 892 &&(nfa_dm_cb.disc_cb.excl_disc_entry.in_use == FALSE) ) 893 { 894 return; 895 } 896 897 /* get listen mode routing table for technology */ 898 nfa_ee_get_tech_route (NFA_EE_PWR_STATE_ON, nfa_dm_cb.disc_cb.listen_RT); 899 900 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use) 901 { 902 nfa_dm_set_rf_listen_mode_raw_config (&dm_disc_mask); 903 dm_disc_mask |= (nfa_dm_cb.disc_cb.excl_disc_entry.requested_disc_mask & NFA_DM_DISC_MASK_POLL); 904 nfa_dm_cb.disc_cb.excl_disc_entry.selected_disc_mask = dm_disc_mask; 905 } 906 else 907 { 908 /* Collect RF discovery request from sub-modules */ 909 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++) 910 { 911 if (nfa_dm_cb.disc_cb.entry[xx].in_use) 912 { 913 poll_mask = (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask & NFA_DM_DISC_MASK_POLL); 914 915 /* clear poll mode technolgies and protocols which are already used by others */ 916 poll_mask &= ~(dm_disc_mask & NFA_DM_DISC_MASK_POLL); 917 918 listen_mask = 0; 919 920 /* 921 ** add listen mode technolgies and protocols if host ID is matched to listen mode routing table 922 */ 923 924 /* NFC-A */ 925 if (nfa_dm_cb.disc_cb.entry[xx].host_id == nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A]) 926 { 927 listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask 928 & ( NFA_DM_DISC_MASK_LA_T1T 929 |NFA_DM_DISC_MASK_LA_T2T 930 |NFA_DM_DISC_MASK_LA_ISO_DEP 931 |NFA_DM_DISC_MASK_LA_NFC_DEP 932 |NFA_DM_DISC_MASK_LAA_NFC_DEP ); 933 } 934 else 935 { 936 /* host can listen ISO-DEP based on AID routing */ 937 listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask & NFA_DM_DISC_MASK_LA_ISO_DEP); 938 } 939 940 /* NFC-B */ 941 /* multiple hosts can listen ISO-DEP based on AID routing */ 942 listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask 943 & NFA_DM_DISC_MASK_LB_ISO_DEP; 944 945 /* NFC-F */ 946 if (nfa_dm_cb.disc_cb.entry[xx].host_id == nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_F]) 947 { 948 listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask 949 & ( NFA_DM_DISC_MASK_LF_T3T 950 |NFA_DM_DISC_MASK_LF_NFC_DEP 951 |NFA_DM_DISC_MASK_LFA_NFC_DEP ); 952 } 953 else 954 { 955 /* NFCC can listen T3T based on NFCID routing */ 956 listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask & NFA_DM_DISC_MASK_LF_T3T); 957 } 958 959 /* NFC-B Prime */ 960 if (nfa_dm_cb.disc_cb.entry[xx].host_id == nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_BP]) 961 { 962 listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask 963 & NFA_DM_DISC_MASK_L_B_PRIME; 964 } 965 966 /* 967 ** clear listen mode technolgies and protocols which are already used by others 968 */ 969 970 /* Check if other modules are listening T1T or T2T */ 971 if (dm_disc_mask & (NFA_DM_DISC_MASK_LA_T1T|NFA_DM_DISC_MASK_LA_T2T)) 972 { 973 listen_mask &= ~( NFA_DM_DISC_MASK_LA_T1T 974 |NFA_DM_DISC_MASK_LA_T2T 975 |NFA_DM_DISC_MASK_LA_ISO_DEP 976 |NFA_DM_DISC_MASK_LA_NFC_DEP ); 977 } 978 979 /* T1T/T2T has priority on NFC-A */ 980 if ( (dm_disc_mask & (NFA_DM_DISC_MASK_LA_ISO_DEP|NFA_DM_DISC_MASK_LA_NFC_DEP)) 981 &&(listen_mask & (NFA_DM_DISC_MASK_LA_T1T|NFA_DM_DISC_MASK_LA_T2T))) 982 { 983 dm_disc_mask &= ~( NFA_DM_DISC_MASK_LA_ISO_DEP 984 |NFA_DM_DISC_MASK_LA_NFC_DEP ); 985 } 986 987 /* Don't remove ISO-DEP because multiple hosts can listen ISO-DEP based on AID routing */ 988 989 /* Check if other modules are listening NFC-DEP */ 990 if (dm_disc_mask & (NFA_DM_DISC_MASK_LA_NFC_DEP | NFA_DM_DISC_MASK_LAA_NFC_DEP)) 991 { 992 listen_mask &= ~( NFA_DM_DISC_MASK_LA_NFC_DEP 993 |NFA_DM_DISC_MASK_LAA_NFC_DEP ); 994 } 995 996 nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask = poll_mask | listen_mask; 997 998 NFA_TRACE_DEBUG2 ("nfa_dm_cb.disc_cb.entry[%d].selected_disc_mask = 0x%x", 999 xx, nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask); 1000 1001 dm_disc_mask |= nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask; 1002 } 1003 } 1004 1005 /* Let P2P set GEN bytes for LLCP to NFCC */ 1006 if (dm_disc_mask & ( NFA_DM_DISC_MASK_PA_NFC_DEP 1007 |NFA_DM_DISC_MASK_PF_NFC_DEP 1008 |NFA_DM_DISC_MASK_LA_NFC_DEP 1009 |NFA_DM_DISC_MASK_LF_NFC_DEP 1010 |NFA_DM_DISC_MASK_PAA_NFC_DEP 1011 |NFA_DM_DISC_MASK_PFA_NFC_DEP 1012 |NFA_DM_DISC_MASK_LAA_NFC_DEP 1013 |NFA_DM_DISC_MASK_LFA_NFC_DEP )) 1014 { 1015 nfa_p2p_set_config (dm_disc_mask); 1016 } 1017 } 1018 1019 NFA_TRACE_DEBUG1 ("dm_disc_mask = 0x%x", dm_disc_mask); 1020 1021 /* Get Discovery Technology parameters */ 1022 num_params = nfa_dm_get_rf_discover_config (dm_disc_mask, disc_params, NFA_DM_MAX_DISC_PARAMS); 1023 1024 if (num_params) 1025 { 1026 /* 1027 ** NFCC will abort programming personality slots if not available. 1028 ** NFCC programs the personality slots in the following order of RF technologies: 1029 ** NFC-A, NFC-B, NFC-BP, NFC-I93 1030 */ 1031 1032 /* if this is not for exclusive control */ 1033 if (!nfa_dm_cb.disc_cb.excl_disc_entry.in_use) 1034 { 1035 /* update listening protocols in each NFC technology */ 1036 nfa_dm_set_rf_listen_mode_config (dm_disc_mask); 1037 } 1038 1039 /* Set polling duty cycle */ 1040 nfa_dm_set_total_duration (); 1041 nfa_dm_cb.disc_cb.dm_disc_mask = dm_disc_mask; 1042 1043 NFC_DiscoveryStart (num_params, disc_params, nfa_dm_disc_discovery_cback); 1044 /* set flag about waiting for response in IDLE state */ 1045 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP; 1046 1047 /* register callback to get interface error NTF */ 1048 NFC_SetStaticRfCback (nfa_dm_disc_data_cback); 1049 } 1050 else 1051 { 1052 /* RF discovery is started but there is no valid technology or protocol to discover */ 1053 nfa_dm_disc_notify_started (NFA_STATUS_OK); 1054 } 1055} 1056 1057/******************************************************************************* 1058** 1059** Function nfa_dm_notify_discovery 1060** 1061** Description Send RF discovery notification to upper layer 1062** 1063** Returns void 1064** 1065*******************************************************************************/ 1066static void nfa_dm_notify_discovery (tNFA_DM_RF_DISC_DATA *p_data) 1067{ 1068 tNFA_CONN_EVT_DATA conn_evt; 1069 1070 /* let application select a device */ 1071 conn_evt.disc_result.status = NFA_STATUS_OK; 1072 memcpy (&(conn_evt.disc_result.discovery_ntf), 1073 &(p_data->nfc_discover.result), 1074 sizeof (tNFC_RESULT_DEVT)); 1075 1076 nfa_dm_conn_cback_event_notify (NFA_DISC_RESULT_EVT, &conn_evt); 1077} 1078 1079/******************************************************************************* 1080** 1081** Function nfa_dm_disc_notify_activation 1082** 1083** Description Send RF activation notification to sub-module 1084** 1085** Returns NFA_STATUS_OK if success 1086** 1087*******************************************************************************/ 1088static tNFA_STATUS nfa_dm_disc_notify_activation (tNFC_DISCOVER *p_data) 1089{ 1090 UINT8 xx, host_id_in_LRT; 1091 UINT8 iso_dep_t3t__listen = NFA_DM_DISC_NUM_ENTRIES; 1092 1093 tNFC_RF_TECH_N_MODE tech_n_mode = p_data->activate.rf_tech_param.mode; 1094 tNFC_PROTOCOL protocol = p_data->activate.protocol; 1095 1096 tNFA_DM_DISC_TECH_PROTO_MASK activated_disc_mask; 1097 1098 NFA_TRACE_DEBUG2 ("nfa_dm_disc_notify_activation (): tech_n_mode:0x%X, proto:0x%X", 1099 tech_n_mode, protocol); 1100 1101 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use) 1102 { 1103 nfa_dm_cb.disc_cb.activated_tech_mode = tech_n_mode; 1104 nfa_dm_cb.disc_cb.activated_rf_disc_id = p_data->activate.rf_disc_id; 1105 nfa_dm_cb.disc_cb.activated_rf_interface = p_data->activate.intf_param.type; 1106 nfa_dm_cb.disc_cb.activated_protocol = protocol; 1107 nfa_dm_cb.disc_cb.activated_handle = NFA_HANDLE_INVALID; 1108 1109 if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback) 1110 (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data); 1111 1112 return (NFA_STATUS_OK); 1113 } 1114 1115 /* if this is NFCEE direct RF interface, notify activation to whoever listening UICC */ 1116 if (p_data->activate.intf_param.type == NFC_INTERFACE_EE_DIRECT_RF) 1117 { 1118 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++) 1119 { 1120 if ( (nfa_dm_cb.disc_cb.entry[xx].in_use) 1121 &&(nfa_dm_cb.disc_cb.entry[xx].host_id != NFA_DM_DISC_HOST_ID_DH)) 1122 { 1123 nfa_dm_cb.disc_cb.activated_rf_disc_id = p_data->activate.rf_disc_id; 1124 nfa_dm_cb.disc_cb.activated_rf_interface = p_data->activate.intf_param.type; 1125 nfa_dm_cb.disc_cb.activated_protocol = NFC_PROTOCOL_UNKNOWN; 1126 nfa_dm_cb.disc_cb.activated_handle = xx; 1127 1128 NFA_TRACE_DEBUG2 ("activated_rf_interface:0x%x, activated_handle: 0x%x", 1129 nfa_dm_cb.disc_cb.activated_rf_interface, 1130 nfa_dm_cb.disc_cb.activated_handle); 1131 1132 if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback) 1133 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data); 1134 1135 return (NFA_STATUS_OK); 1136 } 1137 } 1138 return (NFA_STATUS_FAILED); 1139 } 1140 1141 /* get bit mask of technolgies/mode and protocol */ 1142 activated_disc_mask = nfa_dm_disc_get_disc_mask (tech_n_mode, protocol); 1143 1144 /* get host ID of technology from listen mode routing table */ 1145 if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_A) 1146 { 1147 host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A]; 1148 } 1149 else if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_B) 1150 { 1151 host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_B]; 1152 } 1153 else if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_F) 1154 { 1155 host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_F]; 1156 } 1157 else if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_B_PRIME) 1158 { 1159 host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_BP]; 1160 } 1161 else /* DH only */ 1162 { 1163 host_id_in_LRT = NFA_DM_DISC_HOST_ID_DH; 1164 } 1165 1166 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++) 1167 { 1168 /* if any matching NFC technology and protocol */ 1169 if (nfa_dm_cb.disc_cb.entry[xx].in_use) 1170 { 1171 if (nfa_dm_cb.disc_cb.entry[xx].host_id == host_id_in_LRT) 1172 { 1173 if (nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & activated_disc_mask) 1174 break; 1175 } 1176 else 1177 { 1178 /* check ISO-DEP listening even if host in LRT is not matched */ 1179 if (protocol == NFC_PROTOCOL_ISO_DEP) 1180 { 1181 if ( (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_A) 1182 &&(nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & NFA_DM_DISC_MASK_LA_ISO_DEP)) 1183 { 1184 iso_dep_t3t__listen = xx; 1185 } 1186 else if ( (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_B) 1187 &&(nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & NFA_DM_DISC_MASK_LB_ISO_DEP)) 1188 { 1189 iso_dep_t3t__listen = xx; 1190 } 1191 } 1192 /* check T3T listening even if host in LRT is not matched */ 1193 else if (protocol == NFC_PROTOCOL_T3T) 1194 { 1195 if ( (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_F) 1196 &&(nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & NFA_DM_DISC_MASK_LF_T3T)) 1197 { 1198 iso_dep_t3t__listen = xx; 1199 } 1200 } 1201 } 1202 } 1203 } 1204 1205 if (xx >= NFA_DM_DISC_NUM_ENTRIES) 1206 { 1207 /* if any ISO-DEP or T3T listening even if host in LRT is not matched */ 1208 xx = iso_dep_t3t__listen; 1209 } 1210 1211 if (xx < NFA_DM_DISC_NUM_ENTRIES) 1212 { 1213 nfa_dm_cb.disc_cb.activated_tech_mode = tech_n_mode; 1214 nfa_dm_cb.disc_cb.activated_rf_disc_id = p_data->activate.rf_disc_id; 1215 nfa_dm_cb.disc_cb.activated_rf_interface = p_data->activate.intf_param.type; 1216 nfa_dm_cb.disc_cb.activated_protocol = protocol; 1217 nfa_dm_cb.disc_cb.activated_handle = xx; 1218 1219 NFA_TRACE_DEBUG2 ("activated_protocol:0x%x, activated_handle: 0x%x", 1220 nfa_dm_cb.disc_cb.activated_protocol, 1221 nfa_dm_cb.disc_cb.activated_handle); 1222 1223 if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback) 1224 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data); 1225 1226 return (NFA_STATUS_OK); 1227 } 1228 else 1229 { 1230 nfa_dm_cb.disc_cb.activated_protocol = NFA_PROTOCOL_INVALID; 1231 nfa_dm_cb.disc_cb.activated_handle = NFA_HANDLE_INVALID; 1232 return (NFA_STATUS_FAILED); 1233 } 1234} 1235 1236/******************************************************************************* 1237** 1238** Function nfa_dm_disc_notify_deactivation 1239** 1240** Description Send deactivation notification to sub-module 1241** 1242** Returns None 1243** 1244*******************************************************************************/ 1245static void nfa_dm_disc_notify_deactivation (tNFA_DM_RF_DISC_SM_EVENT sm_event, 1246 tNFC_DISCOVER *p_data) 1247{ 1248 tNFA_HANDLE xx; 1249 tNFA_DM_RF_DISC_EVT disc_evt; 1250 1251 NFA_TRACE_DEBUG1 ("nfa_dm_disc_notify_deactivation (): activated_handle=%d", 1252 nfa_dm_cb.disc_cb.activated_handle); 1253 1254 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING) 1255 { 1256 NFA_TRACE_DEBUG0 ("nfa_dm_disc_notify_deactivation (): for presence check"); 1257 return; 1258 } 1259 1260 if (sm_event == NFA_DM_RF_DEACTIVATE_RSP) 1261 { 1262 /* 1263 ** Activation has been aborted by upper layer in NFA_DM_RFST_W4_HOST_SELECT 1264 ** or NFA_DM_RFST_LISTEN_SLEEP 1265 */ 1266 disc_evt = NFA_DM_RF_DISC_CMD_IDLE_CMPL_EVT; 1267 } 1268 else 1269 { 1270 /* Received deactivation NTF */ 1271 disc_evt = NFA_DM_RF_DISC_DEACTIVATED_EVT; 1272 } 1273 1274 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use) 1275 { 1276 if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback) 1277 (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (disc_evt, p_data); 1278 } 1279 else 1280 { 1281 /* notify event to activated module */ 1282 xx = nfa_dm_cb.disc_cb.activated_handle; 1283 1284 if ( (sm_event == NFA_DM_RF_DEACTIVATE_RSP) 1285 ||(p_data->deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) ) 1286 { 1287 /* Don't remove handle in NFA_DM_RFST_W4_HOST_SELECT or NFA_DM_RFST_LISTEN_SLEEP */ 1288 nfa_dm_cb.disc_cb.activated_handle = NFA_HANDLE_INVALID; 1289 } 1290 1291 if ((xx < NFA_DM_DISC_NUM_ENTRIES) && (nfa_dm_cb.disc_cb.entry[xx].in_use)) 1292 { 1293 if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback) 1294 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (disc_evt, p_data); 1295 } 1296 } 1297 1298 /* clear activated information */ 1299 nfa_dm_cb.disc_cb.activated_tech_mode = 0; 1300 nfa_dm_cb.disc_cb.activated_rf_disc_id = 0; 1301 nfa_dm_cb.disc_cb.activated_rf_interface = 0; 1302 nfa_dm_cb.disc_cb.activated_protocol = NFA_PROTOCOL_INVALID; 1303} 1304 1305/******************************************************************************* 1306** 1307** Function nfa_dm_disc_presence_check 1308** 1309** Description Perform legacy presence check (put tag to sleep, then 1310** wake it up to see if tag is present) 1311** 1312** Returns TRUE if operation started 1313** 1314*******************************************************************************/ 1315tNFC_STATUS nfa_dm_disc_presence_check (void) 1316{ 1317 tNFC_STATUS status = NFC_STATUS_FAILED; 1318 1319 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE) 1320 { 1321 /* Deactivate to sleep mode */ 1322 status = nfa_dm_send_deactivate_cmd(NFC_DEACTIVATE_TYPE_SLEEP); 1323 if (status == NFC_STATUS_OK) 1324 { 1325 /* deactivate to sleep is sent on behave of presence check. 1326 * set the presence check information in control block */ 1327 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_CHECKING; 1328 nfa_dm_cb.presence_check_deact_pending = FALSE; 1329 } 1330 } 1331 1332 return (status); 1333} 1334 1335/******************************************************************************* 1336** 1337** Function nfa_dm_disc_end_presence_check 1338** 1339** Description Perform legacy presence check (put tag to sleep, then 1340** wake it up to see if tag is present) 1341** 1342** Returns TRUE if operation started 1343** 1344*******************************************************************************/ 1345static void nfa_dm_disc_end_presence_check (tNFC_STATUS status) 1346{ 1347 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING) 1348 { 1349 /* notify RW module that presence checking is finished */ 1350 nfa_rw_handle_presence_check_rsp (status); 1351 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_CHECKING; 1352 if (nfa_dm_cb.presence_check_deact_pending) 1353 { 1354 nfa_dm_cb.presence_check_deact_pending = FALSE; 1355 nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD, 1356 (tNFA_DM_RF_DISC_DATA *) &nfa_dm_cb.presence_check_deact_type); 1357 } 1358 } 1359} 1360 1361/******************************************************************************* 1362** 1363** Function nfa_dm_disc_data_cback 1364** 1365** Description Monitoring interface error through data callback 1366** 1367** Returns void 1368** 1369*******************************************************************************/ 1370static void nfa_dm_disc_data_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data) 1371{ 1372 NFA_TRACE_DEBUG0 ("nfa_dm_disc_data_cback ()"); 1373 1374 /* if selection failed */ 1375 if (event == NFC_ERROR_CEVT) 1376 { 1377 nfa_dm_disc_sm_execute (NFA_DM_CORE_INTF_ERROR_NTF, NULL); 1378 } 1379 else if (event == NFC_DATA_CEVT) 1380 { 1381 GKI_freebuf (p_data->data.p_data); 1382 } 1383} 1384 1385/******************************************************************************* 1386** 1387** Function nfa_dm_disc_new_state 1388** 1389** Description Processing discovery events in NFA_DM_RFST_IDLE state 1390** 1391** Returns void 1392** 1393*******************************************************************************/ 1394void nfa_dm_disc_new_state (tNFA_DM_RF_DISC_STATE new_state) 1395{ 1396 tNFA_CONN_EVT_DATA evt_data; 1397 tNFA_DM_RF_DISC_STATE old_state = nfa_dm_cb.disc_cb.disc_state; 1398 1399#if (BT_TRACE_VERBOSE == TRUE) 1400 NFA_TRACE_DEBUG5 ("nfa_dm_disc_new_state (): old_state: %s (%d), new_state: %s (%d) disc_flags: 0x%x", 1401 nfa_dm_disc_state_2_str (nfa_dm_cb.disc_cb.disc_state), nfa_dm_cb.disc_cb.disc_state, 1402 nfa_dm_disc_state_2_str (new_state), new_state, nfa_dm_cb.disc_cb.disc_flags); 1403#else 1404 NFA_TRACE_DEBUG3 ("nfa_dm_disc_new_state(): old_state: %d, new_state: %d disc_flags: 0x%x", 1405 nfa_dm_cb.disc_cb.disc_state, new_state, nfa_dm_cb.disc_cb.disc_flags); 1406#endif 1407 nfa_dm_cb.disc_cb.disc_state = new_state; 1408 if (new_state == NFA_DM_RFST_IDLE) 1409 { 1410 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_STOPPING) 1411 { 1412 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_STOPPING; 1413 1414 /* if exclusive RF control is stopping */ 1415 if (nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) 1416 { 1417 if (old_state > NFA_DM_RFST_DISCOVERY) 1418 { 1419 /* notify deactivation to application */ 1420 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE; 1421 nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data); 1422 } 1423 1424 nfa_dm_rel_excl_rf_control_and_notify (); 1425 } 1426 else 1427 { 1428 evt_data.status = NFA_STATUS_OK; 1429 nfa_dm_conn_cback_event_notify (NFA_RF_DISCOVERY_STOPPED_EVT, &evt_data); 1430 } 1431 } 1432 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_DISABLING) 1433 { 1434 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_DISABLING; 1435 nfa_sys_check_disabled (); 1436 } 1437 } 1438} 1439 1440/******************************************************************************* 1441** 1442** Function nfa_dm_disc_sm_idle 1443** 1444** Description Processing discovery events in NFA_DM_RFST_IDLE state 1445** 1446** Returns void 1447** 1448*******************************************************************************/ 1449static void nfa_dm_disc_sm_idle (tNFA_DM_RF_DISC_SM_EVENT event, 1450 tNFA_DM_RF_DISC_DATA *p_data) 1451{ 1452 UINT8 xx; 1453 1454 switch (event) 1455 { 1456 case NFA_DM_RF_DISCOVER_CMD: 1457 nfa_dm_start_rf_discover (); 1458 break; 1459 1460 case NFA_DM_RF_DISCOVER_RSP: 1461 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 1462 1463 if (p_data->nfc_discover.status == NFC_STATUS_OK) 1464 { 1465 nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY); 1466 1467 /* if RF discovery was stopped while waiting for response */ 1468 if (nfa_dm_cb.disc_cb.disc_flags & (NFA_DM_DISC_FLAGS_STOPPING|NFA_DM_DISC_FLAGS_DISABLING)) 1469 { 1470 /* stop discovery */ 1471 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP; 1472 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 1473 break; 1474 } 1475 1476 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use) 1477 { 1478 if (nfa_dm_cb.disc_cb.excl_disc_entry.disc_flags & NFA_DM_DISC_FLAGS_NOTIFY) 1479 { 1480 nfa_dm_cb.disc_cb.excl_disc_entry.disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY; 1481 1482 if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback) 1483 (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (NFA_DM_RF_DISC_START_EVT, (tNFC_DISCOVER*) p_data); 1484 } 1485 } 1486 else 1487 { 1488 /* notify event to each module which is waiting for start */ 1489 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++) 1490 { 1491 /* if registered module is waiting for starting discovery */ 1492 if ( (nfa_dm_cb.disc_cb.entry[xx].in_use) 1493 &&(nfa_dm_cb.disc_cb.dm_disc_mask & nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask) 1494 &&(nfa_dm_cb.disc_cb.entry[xx].disc_flags & NFA_DM_DISC_FLAGS_NOTIFY) ) 1495 { 1496 nfa_dm_cb.disc_cb.entry[xx].disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY; 1497 1498 if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback) 1499 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_START_EVT, (tNFC_DISCOVER*) p_data); 1500 } 1501 } 1502 1503 } 1504 nfa_dm_disc_notify_started (p_data->nfc_discover.status); 1505 } 1506 else 1507 { 1508 /* in rare case that the discovery states of NFCC and DH mismatch and NFCC rejects Discover Cmd 1509 * deactivate idle and then start disvocery when got deactivate rsp */ 1510 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP; 1511 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 1512 } 1513 break; 1514 1515 case NFA_DM_RF_DEACTIVATE_RSP: 1516 /* restart discovery */ 1517 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 1518 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_DISABLING) 1519 { 1520 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_DISABLING; 1521 nfa_sys_check_disabled (); 1522 } 1523 else 1524 nfa_dm_start_rf_discover (); 1525 break; 1526 1527 case NFA_DM_LP_LISTEN_CMD: 1528 nfa_dm_disc_new_state (NFA_DM_RFST_LP_LISTEN); 1529 break; 1530 1531 default: 1532 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_idle (): Unexpected discovery event"); 1533 break; 1534 } 1535} 1536 1537/******************************************************************************* 1538** 1539** Function nfa_dm_disc_sm_discovery 1540** 1541** Description Processing discovery events in NFA_DM_RFST_DISCOVERY state 1542** 1543** Returns void 1544** 1545*******************************************************************************/ 1546static void nfa_dm_disc_sm_discovery (tNFA_DM_RF_DISC_SM_EVENT event, 1547 tNFA_DM_RF_DISC_DATA *p_data) 1548{ 1549 switch (event) 1550 { 1551 case NFA_DM_RF_DEACTIVATE_CMD: 1552 /* if deactivate CMD was not sent to NFCC */ 1553 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)) 1554 { 1555 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP; 1556 NFC_Deactivate (p_data->deactivate_type); 1557 } 1558 break; 1559 case NFA_DM_RF_DEACTIVATE_RSP: 1560 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 1561 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 1562 nfa_dm_start_rf_discover (); 1563 break; 1564 case NFA_DM_RF_DISCOVER_NTF: 1565 nfa_dm_disc_new_state (NFA_DM_RFST_W4_ALL_DISCOVERIES); 1566 nfa_dm_notify_discovery (p_data); 1567 break; 1568 case NFA_DM_RF_INTF_ACTIVATED_NTF: 1569 if (p_data->nfc_discover.activate.intf_param.type == NFC_INTERFACE_EE_DIRECT_RF) 1570 { 1571 nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_ACTIVE); 1572 } 1573 else if (p_data->nfc_discover.activate.rf_tech_param.mode & 0x80) 1574 { 1575 /* Listen mode */ 1576 nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_ACTIVE); 1577 } 1578 else 1579 { 1580 /* Poll mode */ 1581 nfa_dm_disc_new_state (NFA_DM_RFST_POLL_ACTIVE); 1582 } 1583 1584 if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED) 1585 { 1586 NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf"); 1587 1588 /* after receiving deactivate event, restart discovery */ 1589 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 1590 } 1591 break; 1592 1593 case NFA_DM_LP_LISTEN_CMD: 1594 break; 1595 case NFA_DM_CORE_INTF_ERROR_NTF: 1596 break; 1597 default: 1598 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_discovery (): Unexpected discovery event"); 1599 break; 1600 } 1601} 1602 1603/******************************************************************************* 1604** 1605** Function nfa_dm_disc_sm_w4_all_discoveries 1606** 1607** Description Processing discovery events in NFA_DM_RFST_W4_ALL_DISCOVERIES state 1608** 1609** Returns void 1610** 1611*******************************************************************************/ 1612static void nfa_dm_disc_sm_w4_all_discoveries (tNFA_DM_RF_DISC_SM_EVENT event, 1613 tNFA_DM_RF_DISC_DATA *p_data) 1614{ 1615 switch (event) 1616 { 1617 case NFA_DM_RF_DEACTIVATE_CMD: 1618 /* if deactivate CMD was not sent to NFCC */ 1619 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)) 1620 { 1621 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP; 1622 /* only IDLE mode is allowed */ 1623 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 1624 } 1625 break; 1626 case NFA_DM_RF_DEACTIVATE_RSP: 1627 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 1628 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 1629 nfa_dm_start_rf_discover (); 1630 break; 1631 case NFA_DM_RF_DISCOVER_NTF: 1632 /* Notification Type = NCI_DISCOVER_NTF_LAST or NCI_DISCOVER_NTF_LAST_ABORT */ 1633 if (p_data->nfc_discover.result.more != NCI_DISCOVER_NTF_MORE) 1634 { 1635 nfa_dm_disc_new_state (NFA_DM_RFST_W4_HOST_SELECT); 1636 } 1637 nfa_dm_notify_discovery (p_data); 1638 break; 1639 case NFA_DM_RF_INTF_ACTIVATED_NTF: 1640 /* 1641 ** This is only for ISO15693. 1642 ** FW sends activation NTF when all responses are received from tags without host selecting. 1643 */ 1644 nfa_dm_disc_new_state (NFA_DM_RFST_POLL_ACTIVE); 1645 1646 if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED) 1647 { 1648 NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf"); 1649 1650 /* after receiving deactivate event, restart discovery */ 1651 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 1652 } 1653 break; 1654 default: 1655 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_w4_all_discoveries (): Unexpected discovery event"); 1656 break; 1657 } 1658} 1659 1660/******************************************************************************* 1661** 1662** Function nfa_dm_disc_sm_w4_host_select 1663** 1664** Description Processing discovery events in NFA_DM_RFST_W4_HOST_SELECT state 1665** 1666** Returns void 1667** 1668*******************************************************************************/ 1669static void nfa_dm_disc_sm_w4_host_select (tNFA_DM_RF_DISC_SM_EVENT event, 1670 tNFA_DM_RF_DISC_DATA *p_data) 1671{ 1672 tNFA_CONN_EVT_DATA conn_evt; 1673 tNFA_DM_DISC_FLAGS old_pres_check_flag = (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING); 1674 BOOLEAN pres_check_event = FALSE; 1675 BOOLEAN pres_check_event_processed = FALSE; 1676 1677 switch (event) 1678 { 1679 case NFA_DM_RF_DISCOVER_SELECT_CMD: 1680 /* if not waiting to deactivate */ 1681 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)) 1682 { 1683 NFC_DiscoverySelect (p_data->select.rf_disc_id, 1684 p_data->select.protocol, 1685 p_data->select.rf_interface); 1686 } 1687 else 1688 { 1689 nfa_dm_disc_conn_event_notify (NFA_SELECT_RESULT_EVT, NFA_STATUS_FAILED); 1690 } 1691 break; 1692 1693 case NFA_DM_RF_DISCOVER_SELECT_RSP: 1694 pres_check_event = TRUE; 1695 /* notify application status of selection */ 1696 if (p_data->nfc_discover.status == NFC_STATUS_OK) 1697 { 1698 pres_check_event_processed = TRUE; 1699 conn_evt.status = NFA_STATUS_OK; 1700 /* register callback to get interface error NTF */ 1701 NFC_SetStaticRfCback (nfa_dm_disc_data_cback); 1702 } 1703 else 1704 conn_evt.status = NFA_STATUS_FAILED; 1705 1706 if (!old_pres_check_flag) 1707 { 1708 nfa_dm_disc_conn_event_notify (NFA_SELECT_RESULT_EVT, p_data->nfc_discover.status); 1709 } 1710 break; 1711 case NFA_DM_RF_INTF_ACTIVATED_NTF: 1712 nfa_dm_disc_new_state (NFA_DM_RFST_POLL_ACTIVE); 1713 if (old_pres_check_flag) 1714 { 1715 /* notify RW module of presence of tag */ 1716 nfa_rw_handle_presence_check_rsp (NFC_STATUS_OK); 1717 if (nfa_dm_cb.presence_check_deact_pending) 1718 { 1719 nfa_dm_cb.presence_check_deact_pending = FALSE; 1720 nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD, 1721 (tNFA_DM_RF_DISC_DATA *) &nfa_dm_cb.presence_check_deact_type); 1722 } 1723 } 1724 1725 else if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED) 1726 { 1727 NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf"); 1728 1729 /* after receiving deactivate event, restart discovery */ 1730 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 1731 } 1732 break; 1733 case NFA_DM_RF_DEACTIVATE_CMD: 1734 if (old_pres_check_flag) 1735 { 1736 nfa_dm_cb.presence_check_deact_pending = TRUE; 1737 nfa_dm_cb.presence_check_deact_type = p_data->deactivate_type; 1738 } 1739 /* if deactivate CMD was not sent to NFCC */ 1740 else if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)) 1741 { 1742 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP; 1743 /* only IDLE mode is allowed */ 1744 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 1745 } 1746 break; 1747 case NFA_DM_RF_DEACTIVATE_RSP: 1748 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 1749 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 1750 nfa_dm_start_rf_discover (); 1751 /* notify exiting from host select state */ 1752 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_RSP, &(p_data->nfc_discover)); 1753 break; 1754 1755 case NFA_DM_CORE_INTF_ERROR_NTF: 1756 pres_check_event = TRUE; 1757 if (!old_pres_check_flag) 1758 { 1759 /* target activation failed, upper layer may deactivate or select again */ 1760 conn_evt.status = NFA_STATUS_FAILED; 1761 nfa_dm_conn_cback_event_notify (NFA_SELECT_RESULT_EVT, &conn_evt); 1762 } 1763 break; 1764 default: 1765 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_w4_host_select (): Unexpected discovery event"); 1766 break; 1767 } 1768 1769 if (old_pres_check_flag && pres_check_event && !pres_check_event_processed) 1770 { 1771 /* performing presence check for unknow protocol and exception conditions happened 1772 * clear presence check information and report failure */ 1773 nfa_dm_disc_end_presence_check (NFC_STATUS_FAILED); 1774 if (nfa_dm_cb.presence_check_deact_pending) 1775 { 1776 nfa_dm_cb.presence_check_deact_pending = FALSE; 1777 1778 NFC_Deactivate (nfa_dm_cb.presence_check_deact_type); 1779 } 1780 } 1781} 1782 1783/******************************************************************************* 1784** 1785** Function nfa_dm_disc_sm_poll_active 1786** 1787** Description Processing discovery events in NFA_DM_RFST_POLL_ACTIVE state 1788** 1789** Returns void 1790** 1791*******************************************************************************/ 1792static void nfa_dm_disc_sm_poll_active (tNFA_DM_RF_DISC_SM_EVENT event, 1793 tNFA_DM_RF_DISC_DATA *p_data) 1794{ 1795 tNFC_STATUS status; 1796 tNFA_DM_DISC_FLAGS old_pres_check_flag = (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING); 1797 BOOLEAN pres_check_event = FALSE; 1798 BOOLEAN pres_check_event_processed = FALSE; 1799 1800 switch (event) 1801 { 1802 case NFA_DM_RF_DEACTIVATE_CMD: 1803 if (old_pres_check_flag) 1804 { 1805 /* presence check is already enabled when deactivate cmd is requested, 1806 * keep the information in control block to issue it later */ 1807 nfa_dm_cb.presence_check_deact_pending = TRUE; 1808 nfa_dm_cb.presence_check_deact_type = p_data->deactivate_type; 1809 } 1810 else 1811 { 1812 status = nfa_dm_send_deactivate_cmd(p_data->deactivate_type); 1813 } 1814 1815 break; 1816 case NFA_DM_RF_DEACTIVATE_RSP: 1817 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 1818 /* register callback to get interface error NTF */ 1819 NFC_SetStaticRfCback (nfa_dm_disc_data_cback); 1820 break; 1821 case NFA_DM_RF_DEACTIVATE_NTF: 1822 pres_check_event = TRUE; 1823 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF; 1824 if ( (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) 1825 ||(p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF) ) 1826 { 1827 nfa_dm_disc_new_state (NFA_DM_RFST_W4_HOST_SELECT); 1828 if (old_pres_check_flag) 1829 { 1830 pres_check_event_processed = TRUE; 1831 /* process pending deactivate request */ 1832 if (nfa_dm_cb.presence_check_deact_pending) 1833 { 1834 nfa_dm_cb.presence_check_deact_pending = FALSE; 1835 /* notify RW module that presence checking is finished */ 1836 nfa_dm_disc_end_presence_check (NFC_STATUS_OK); 1837 1838 if (nfa_dm_cb.presence_check_deact_type == NFC_DEACTIVATE_TYPE_IDLE) 1839 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 1840 else 1841 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover)); 1842 } 1843 else 1844 { 1845 /* Successfully went to sleep mode for presence check */ 1846 /* Now wake up the tag to see if it is present */ 1847 NFC_DiscoverySelect (nfa_dm_cb.disc_cb.activated_rf_disc_id, 1848 nfa_dm_cb.disc_cb.activated_protocol, 1849 nfa_dm_cb.disc_cb.activated_rf_interface); 1850 } 1851 1852 } 1853 } 1854 else if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) 1855 { 1856 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 1857 nfa_dm_start_rf_discover (); 1858 } 1859 else if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY) 1860 { 1861 nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY); 1862 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_STOPPING) 1863 { 1864 /* stop discovery */ 1865 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 1866 } 1867 } 1868 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover)); 1869 break; 1870 1871 case NFA_DM_CORE_INTF_ERROR_NTF: 1872 pres_check_event = TRUE; 1873 NFC_Deactivate (NFC_DEACTIVATE_TYPE_DISCOVERY); 1874 break; 1875 1876 default: 1877 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_poll_active (): Unexpected discovery event"); 1878 break; 1879 } 1880 1881 if (old_pres_check_flag && pres_check_event && !pres_check_event_processed) 1882 { 1883 /* performing presence check for unknow protocol and exception conditions happened 1884 * clear presence check information and report failure */ 1885 nfa_dm_disc_end_presence_check (NFC_STATUS_FAILED); 1886 if (nfa_dm_cb.presence_check_deact_pending) 1887 { 1888 nfa_dm_cb.presence_check_deact_pending = FALSE; 1889 1890 NFC_Deactivate (nfa_dm_cb.presence_check_deact_type); 1891 } 1892 } 1893} 1894 1895/******************************************************************************* 1896** 1897** Function nfa_dm_disc_sm_listen_active 1898** 1899** Description Processing discovery events in NFA_DM_RFST_LISTEN_ACTIVE state 1900** 1901** Returns void 1902** 1903*******************************************************************************/ 1904static void nfa_dm_disc_sm_listen_active (tNFA_DM_RF_DISC_SM_EVENT event, 1905 tNFA_DM_RF_DISC_DATA *p_data) 1906{ 1907 switch (event) 1908 { 1909 case NFA_DM_RF_DEACTIVATE_CMD: 1910 nfa_dm_send_deactivate_cmd(p_data->deactivate_type); 1911 break; 1912 case NFA_DM_RF_DEACTIVATE_RSP: 1913 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 1914 break; 1915 case NFA_DM_RF_DEACTIVATE_NTF: 1916 /* clear both W4_RSP and W4_NTF because of race condition between deactivat CMD and link loss */ 1917 nfa_dm_cb.disc_cb.disc_flags &= ~(NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF); 1918 1919 if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) 1920 { 1921 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 1922 nfa_dm_start_rf_discover (); 1923 } 1924 else if ( (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) 1925 ||(p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF) ) 1926 { 1927 nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_SLEEP); 1928 } 1929 else if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY) 1930 { 1931 /* Discovery */ 1932 nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY); 1933 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_STOPPING) 1934 { 1935 /* stop discovery */ 1936 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 1937 } 1938 } 1939 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover)); 1940 break; 1941 1942 case NFA_DM_CORE_INTF_ERROR_NTF: 1943 break; 1944 default: 1945 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_listen_active (): Unexpected discovery event"); 1946 break; 1947 } 1948} 1949 1950/******************************************************************************* 1951** 1952** Function nfa_dm_disc_sm_listen_sleep 1953** 1954** Description Processing discovery events in NFA_DM_RFST_LISTEN_SLEEP state 1955** 1956** Returns void 1957** 1958*******************************************************************************/ 1959static void nfa_dm_disc_sm_listen_sleep (tNFA_DM_RF_DISC_SM_EVENT event, 1960 tNFA_DM_RF_DISC_DATA *p_data) 1961{ 1962 switch (event) 1963 { 1964 case NFA_DM_RF_DEACTIVATE_CMD: 1965 nfa_dm_send_deactivate_cmd (p_data->deactivate_type); 1966 break; 1967 case NFA_DM_RF_DEACTIVATE_RSP: 1968 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 1969 /* if deactivate type in CMD was IDLE */ 1970 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF)) 1971 { 1972 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 1973 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_RSP, &(p_data->nfc_discover)); 1974 } 1975 break; 1976 case NFA_DM_RF_DEACTIVATE_NTF: 1977 /* clear both W4_RSP and W4_NTF because of race condition between deactivat CMD and link loss */ 1978 nfa_dm_cb.disc_cb.disc_flags &= ~(NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF); 1979 if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) 1980 { 1981 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 1982 nfa_dm_start_rf_discover (); 1983 } 1984 else if (p_data->nfc_discover.deactivate.type == NFA_DEACTIVATE_TYPE_DISCOVERY) 1985 { 1986 nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY); 1987 } 1988 else 1989 { 1990 NFA_TRACE_ERROR0 ("Unexpected deactivation type"); 1991 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 1992 nfa_dm_start_rf_discover (); 1993 } 1994 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover)); 1995 break; 1996 case NFA_DM_RF_INTF_ACTIVATED_NTF: 1997 nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_ACTIVE); 1998 if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED) 1999 { 2000 NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf"); 2001 2002 /* after receiving deactivate event, restart discovery */ 2003 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 2004 } 2005 break; 2006 default: 2007 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_listen_sleep (): Unexpected discovery event"); 2008 break; 2009 } 2010} 2011 2012/******************************************************************************* 2013** 2014** Function nfa_dm_disc_sm_lp_listen 2015** 2016** Description Processing discovery events in NFA_DM_RFST_LP_LISTEN state 2017** 2018** Returns void 2019** 2020*******************************************************************************/ 2021static void nfa_dm_disc_sm_lp_listen (tNFA_DM_RF_DISC_SM_EVENT event, 2022 tNFA_DM_RF_DISC_DATA *p_data) 2023{ 2024 switch (event) 2025 { 2026 case NFA_DM_RF_INTF_ACTIVATED_NTF: 2027 nfa_dm_disc_new_state (NFA_DM_RFST_LP_ACTIVE); 2028 nfa_dm_disc_notify_activation (&(p_data->nfc_discover)); 2029 break; 2030 2031 default: 2032 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_lp_listen (): Unexpected discovery event"); 2033 break; 2034 } 2035} 2036 2037/******************************************************************************* 2038** 2039** Function nfa_dm_disc_sm_lp_active 2040** 2041** Description Processing discovery events in NFA_DM_RFST_LP_ACTIVE state 2042** 2043** Returns void 2044** 2045*******************************************************************************/ 2046static void nfa_dm_disc_sm_lp_active (tNFA_DM_RF_DISC_SM_EVENT event, 2047 tNFA_DM_RF_DISC_DATA *p_data) 2048{ 2049 switch (event) 2050 { 2051 case NFA_DM_RF_DEACTIVATE_NTF: 2052 nfa_dm_disc_new_state (NFA_DM_RFST_LP_LISTEN); 2053 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover)); 2054 break; 2055 default: 2056 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_lp_active (): Unexpected discovery event"); 2057 break; 2058 } 2059} 2060 2061/******************************************************************************* 2062** 2063** Function nfa_dm_disc_sm_execute 2064** 2065** Description Processing discovery related events 2066** 2067** Returns void 2068** 2069*******************************************************************************/ 2070void nfa_dm_disc_sm_execute (tNFA_DM_RF_DISC_SM_EVENT event, tNFA_DM_RF_DISC_DATA *p_data) 2071{ 2072#if (BT_TRACE_VERBOSE == TRUE) 2073 NFA_TRACE_DEBUG5 ("nfa_dm_disc_sm_execute (): state: %s (%d), event: %s(%d) disc_flags: 0x%x", 2074 nfa_dm_disc_state_2_str (nfa_dm_cb.disc_cb.disc_state), nfa_dm_cb.disc_cb.disc_state, 2075 nfa_dm_disc_event_2_str (event), event, nfa_dm_cb.disc_cb.disc_flags); 2076#else 2077 NFA_TRACE_DEBUG3 ("nfa_dm_disc_sm_execute(): state: %d, event:%d disc_flags: 0x%x", 2078 nfa_dm_cb.disc_cb.disc_state, event, nfa_dm_cb.disc_cb.disc_flags); 2079#endif 2080 2081 switch (nfa_dm_cb.disc_cb.disc_state) 2082 { 2083 /* RF Discovery State - Idle */ 2084 case NFA_DM_RFST_IDLE: 2085 nfa_dm_disc_sm_idle (event, p_data); 2086 break; 2087 2088 /* RF Discovery State - Discovery */ 2089 case NFA_DM_RFST_DISCOVERY: 2090 nfa_dm_disc_sm_discovery (event, p_data); 2091 break; 2092 2093 /*RF Discovery State - Wait for all discoveries */ 2094 case NFA_DM_RFST_W4_ALL_DISCOVERIES: 2095 nfa_dm_disc_sm_w4_all_discoveries (event, p_data); 2096 break; 2097 2098 /* RF Discovery State - Wait for host selection */ 2099 case NFA_DM_RFST_W4_HOST_SELECT: 2100 nfa_dm_disc_sm_w4_host_select (event, p_data); 2101 break; 2102 2103 /* RF Discovery State - Poll mode activated */ 2104 case NFA_DM_RFST_POLL_ACTIVE: 2105 nfa_dm_disc_sm_poll_active (event, p_data); 2106 break; 2107 2108 /* RF Discovery State - listen mode activated */ 2109 case NFA_DM_RFST_LISTEN_ACTIVE: 2110 nfa_dm_disc_sm_listen_active (event, p_data); 2111 break; 2112 2113 /* RF Discovery State - listen mode sleep */ 2114 case NFA_DM_RFST_LISTEN_SLEEP: 2115 nfa_dm_disc_sm_listen_sleep (event, p_data); 2116 break; 2117 2118 /* Listening in Low Power mode */ 2119 case NFA_DM_RFST_LP_LISTEN: 2120 nfa_dm_disc_sm_lp_listen (event, p_data); 2121 break; 2122 2123 /* Activated in Low Power mode */ 2124 case NFA_DM_RFST_LP_ACTIVE: 2125 nfa_dm_disc_sm_lp_active (event, p_data); 2126 break; 2127 } 2128#if (BT_TRACE_VERBOSE == TRUE) 2129 NFA_TRACE_DEBUG3 ("nfa_dm_disc_sm_execute (): new state: %s (%d), disc_flags: 0x%x", 2130 nfa_dm_disc_state_2_str (nfa_dm_cb.disc_cb.disc_state), nfa_dm_cb.disc_cb.disc_state, 2131 nfa_dm_cb.disc_cb.disc_flags); 2132#else 2133 NFA_TRACE_DEBUG2 ("nfa_dm_disc_sm_execute(): new state: %d, disc_flags: 0x%x", 2134 nfa_dm_cb.disc_cb.disc_state, nfa_dm_cb.disc_cb.disc_flags); 2135#endif 2136} 2137 2138/******************************************************************************* 2139** 2140** Function nfa_dm_add_rf_discover 2141** 2142** Description Add discovery configuration and callback function 2143** 2144** Returns valid handle if success 2145** 2146*******************************************************************************/ 2147tNFA_HANDLE nfa_dm_add_rf_discover (tNFA_DM_DISC_TECH_PROTO_MASK disc_mask, 2148 tNFA_DM_DISC_HOST_ID host_id, 2149 tNFA_DISCOVER_CBACK *p_disc_cback) 2150{ 2151 UINT8 xx; 2152 2153 NFA_TRACE_DEBUG1 ("nfa_dm_add_rf_discover () disc_mask=0x%x", disc_mask); 2154 2155 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++) 2156 { 2157 if (!nfa_dm_cb.disc_cb.entry[xx].in_use) 2158 { 2159 nfa_dm_cb.disc_cb.entry[xx].in_use = TRUE; 2160 nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask = disc_mask; 2161 nfa_dm_cb.disc_cb.entry[xx].host_id = host_id; 2162 nfa_dm_cb.disc_cb.entry[xx].p_disc_cback = p_disc_cback; 2163 nfa_dm_cb.disc_cb.entry[xx].disc_flags = NFA_DM_DISC_FLAGS_NOTIFY; 2164 return xx; 2165 } 2166 } 2167 2168 return NFA_HANDLE_INVALID; 2169} 2170 2171/******************************************************************************* 2172** 2173** Function nfa_dm_start_excl_discovery 2174** 2175** Description Start exclusive RF discovery 2176** 2177** Returns void 2178** 2179*******************************************************************************/ 2180void nfa_dm_start_excl_discovery (tNFA_TECHNOLOGY_MASK poll_tech_mask, 2181 tNFA_LISTEN_CFG *p_listen_cfg, 2182 tNFA_DISCOVER_CBACK *p_disc_cback) 2183{ 2184 tNFA_DM_DISC_TECH_PROTO_MASK poll_disc_mask = 0; 2185 2186 NFA_TRACE_DEBUG0 ("nfa_dm_start_excl_discovery ()"); 2187 2188 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A) 2189 { 2190 poll_disc_mask |= NFA_DM_DISC_MASK_PA_T1T; 2191 poll_disc_mask |= NFA_DM_DISC_MASK_PA_T2T; 2192 poll_disc_mask |= NFA_DM_DISC_MASK_PA_ISO_DEP; 2193 poll_disc_mask |= NFA_DM_DISC_MASK_PA_NFC_DEP; 2194 poll_disc_mask |= NFA_DM_DISC_MASK_P_LEGACY; 2195 } 2196 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE) 2197 { 2198 poll_disc_mask |= NFA_DM_DISC_MASK_PAA_NFC_DEP; 2199 } 2200 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B) 2201 { 2202 poll_disc_mask |= NFA_DM_DISC_MASK_PB_ISO_DEP; 2203 } 2204 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F) 2205 { 2206 poll_disc_mask |= NFA_DM_DISC_MASK_PF_T3T; 2207 poll_disc_mask |= NFA_DM_DISC_MASK_PF_NFC_DEP; 2208 } 2209 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE) 2210 { 2211 poll_disc_mask |= NFA_DM_DISC_MASK_PFA_NFC_DEP; 2212 } 2213 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_ISO15693) 2214 { 2215 poll_disc_mask |= NFA_DM_DISC_MASK_P_ISO15693; 2216 } 2217 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B_PRIME) 2218 { 2219 poll_disc_mask |= NFA_DM_DISC_MASK_P_B_PRIME; 2220 } 2221 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_KOVIO) 2222 { 2223 poll_disc_mask |= NFA_DM_DISC_MASK_P_KOVIO; 2224 } 2225 2226 nfa_dm_cb.disc_cb.excl_disc_entry.in_use = TRUE; 2227 nfa_dm_cb.disc_cb.excl_disc_entry.requested_disc_mask = poll_disc_mask; 2228 nfa_dm_cb.disc_cb.excl_disc_entry.host_id = NFA_DM_DISC_HOST_ID_DH; 2229 nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback = p_disc_cback; 2230 nfa_dm_cb.disc_cb.excl_disc_entry.disc_flags = NFA_DM_DISC_FLAGS_NOTIFY; 2231 2232 memcpy (&nfa_dm_cb.disc_cb.excl_listen_config, p_listen_cfg, sizeof (tNFA_LISTEN_CFG)); 2233 2234 nfa_dm_disc_sm_execute (NFA_DM_RF_DISCOVER_CMD, NULL); 2235} 2236 2237/******************************************************************************* 2238** 2239** Function nfa_dm_stop_excl_discovery 2240** 2241** Description Stop exclusive RF discovery 2242** 2243** Returns void 2244** 2245*******************************************************************************/ 2246void nfa_dm_stop_excl_discovery (void) 2247{ 2248 NFA_TRACE_DEBUG0 ("nfa_dm_stop_excl_discovery ()"); 2249 2250 nfa_dm_cb.disc_cb.excl_disc_entry.in_use = FALSE; 2251 nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback = NULL; 2252} 2253 2254/******************************************************************************* 2255** 2256** Function nfa_dm_delete_rf_discover 2257** 2258** Description Remove discovery configuration and callback function 2259** 2260** Returns void 2261** 2262*******************************************************************************/ 2263void nfa_dm_delete_rf_discover (tNFA_HANDLE handle) 2264{ 2265 NFA_TRACE_DEBUG1 ("nfa_dm_delete_rf_discover () handle=0x%x", handle); 2266 2267 if (handle < NFA_DM_DISC_NUM_ENTRIES) 2268 { 2269 nfa_dm_cb.disc_cb.entry[handle].in_use = FALSE; 2270 } 2271 else 2272 { 2273 NFA_TRACE_ERROR0 ("Invalid discovery handle"); 2274 } 2275} 2276 2277/******************************************************************************* 2278** 2279** Function nfa_dm_rf_discover_select 2280** 2281** Description Select target, protocol and RF interface 2282** 2283** Returns void 2284** 2285*******************************************************************************/ 2286void nfa_dm_rf_discover_select (UINT8 rf_disc_id, 2287 tNFA_NFC_PROTOCOL protocol, 2288 tNFA_INTF_TYPE rf_interface) 2289{ 2290 tNFA_DM_DISC_SELECT_PARAMS select_params; 2291 tNFA_CONN_EVT_DATA conn_evt; 2292 2293 NFA_TRACE_DEBUG3 ("nfa_dm_disc_select () rf_disc_id:0x%X, protocol:0x%X, rf_interface:0x%X", 2294 rf_disc_id, protocol, rf_interface); 2295 2296 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_HOST_SELECT) 2297 { 2298 /* state is OK: notify the status when the response is received from NFCC */ 2299 select_params.rf_disc_id = rf_disc_id; 2300 select_params.protocol = protocol; 2301 select_params.rf_interface = rf_interface; 2302 2303 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_NOTIFY; 2304 nfa_dm_disc_sm_execute (NFA_DM_RF_DISCOVER_SELECT_CMD, (tNFA_DM_RF_DISC_DATA *) &select_params); 2305 } 2306 else 2307 { 2308 /* Wrong state: notify failed status right away */ 2309 conn_evt.status = NFA_STATUS_FAILED; 2310 nfa_dm_conn_cback_event_notify (NFA_SELECT_RESULT_EVT, &conn_evt); 2311 } 2312} 2313 2314/******************************************************************************* 2315** 2316** Function nfa_dm_rf_deactivate 2317** 2318** Description Deactivate NFC link 2319** 2320** Returns NFA_STATUS_OK if success 2321** 2322*******************************************************************************/ 2323tNFA_STATUS nfa_dm_rf_deactivate (tNFA_DEACTIVATE_TYPE deactivate_type) 2324{ 2325 NFA_TRACE_DEBUG1 ("nfa_dm_rf_deactivate () deactivate_type:0x%X", deactivate_type); 2326 2327 if (deactivate_type == NFA_DEACTIVATE_TYPE_SLEEP) 2328 { 2329 if (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_NFC_DEP) 2330 deactivate_type = NFC_DEACTIVATE_TYPE_SLEEP_AF; 2331 else 2332 deactivate_type = NFC_DEACTIVATE_TYPE_SLEEP; 2333 } 2334 2335 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_IDLE) 2336 { 2337 return NFA_STATUS_FAILED; 2338 } 2339 else 2340 { 2341 nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD, (tNFA_DM_RF_DISC_DATA *) &deactivate_type); 2342 return NFA_STATUS_OK; 2343 } 2344} 2345 2346#if (BT_TRACE_VERBOSE == TRUE) 2347/******************************************************************************* 2348** 2349** Function nfa_dm_disc_state_2_str 2350** 2351** Description convert nfc discovery state to string 2352** 2353*******************************************************************************/ 2354static char *nfa_dm_disc_state_2_str (UINT8 state) 2355{ 2356 switch (state) 2357 { 2358 case NFA_DM_RFST_IDLE: 2359 return "IDLE"; 2360 2361 case NFA_DM_RFST_DISCOVERY: 2362 return "DISCOVERY"; 2363 2364 case NFA_DM_RFST_W4_ALL_DISCOVERIES: 2365 return "W4_ALL_DISCOVERIES"; 2366 2367 case NFA_DM_RFST_W4_HOST_SELECT: 2368 return "W4_HOST_SELECT"; 2369 2370 case NFA_DM_RFST_POLL_ACTIVE: 2371 return "POLL_ACTIVE"; 2372 2373 case NFA_DM_RFST_LISTEN_ACTIVE: 2374 return "LISTEN_ACTIVE"; 2375 2376 case NFA_DM_RFST_LISTEN_SLEEP: 2377 return "LISTEN_SLEEP"; 2378 2379 case NFA_DM_RFST_LP_LISTEN: 2380 return "LP_LISTEN"; 2381 2382 case NFA_DM_RFST_LP_ACTIVE: 2383 return "LP_ACTIVE"; 2384 } 2385 return "Unknown"; 2386} 2387 2388/******************************************************************************* 2389** 2390** Function nfa_dm_disc_event_2_str 2391** 2392** Description convert nfc discovery RSP/NTF to string 2393** 2394*******************************************************************************/ 2395static char *nfa_dm_disc_event_2_str (UINT8 event) 2396{ 2397 switch (event) 2398 { 2399 case NFA_DM_RF_DISCOVER_CMD: 2400 return "DISCOVER_CMD"; 2401 2402 case NFA_DM_RF_DISCOVER_RSP: 2403 return "DISCOVER_RSP"; 2404 2405 case NFA_DM_RF_DISCOVER_NTF: 2406 return "DISCOVER_NTF"; 2407 2408 case NFA_DM_RF_DISCOVER_SELECT_CMD: 2409 return "SELECT_CMD"; 2410 2411 case NFA_DM_RF_DISCOVER_SELECT_RSP: 2412 return "SELECT_RSP"; 2413 2414 case NFA_DM_RF_INTF_ACTIVATED_NTF: 2415 return "ACTIVATED_NTF"; 2416 2417 case NFA_DM_RF_DEACTIVATE_CMD: 2418 return "DEACTIVATE_CMD"; 2419 2420 case NFA_DM_RF_DEACTIVATE_RSP: 2421 return "DEACTIVATE_RSP"; 2422 2423 case NFA_DM_RF_DEACTIVATE_NTF: 2424 return "DEACTIVATE_NTF"; 2425 2426 case NFA_DM_LP_LISTEN_CMD: 2427 return "NFA_DM_LP_LISTEN_CMD"; 2428 2429 case NFA_DM_CORE_INTF_ERROR_NTF: 2430 return "INTF_ERROR_NTF"; 2431 2432 } 2433 return "Unknown"; 2434} 2435#endif /* BT_TRACE_VERBOSE */ 2436