nfa_dm_discover.c revision 5cbce03e4a73a6950873b1a2b55cd09997b67a96
1/****************************************************************************** 2 * 3 * Copyright (C) 2010-2014 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19 20/****************************************************************************** 21 * 22 * This file contains the action functions for device manager discovery 23 * function. 24 * 25 ******************************************************************************/ 26#include <string.h> 27#include "nfa_sys.h" 28#include "nfa_api.h" 29#include "nfa_dm_int.h" 30#include "nfa_p2p_int.h" 31#include "nfa_sys_int.h" 32#include "nci_hmsgs.h" 33#if (NFC_NFCEE_INCLUDED == TRUE) 34#include "nfa_ee_api.h" 35#include "nfa_ee_int.h" 36#endif 37#include "nfa_rw_int.h" 38 39#include "nfc_int.h" 40/* 41** static functions 42*/ 43 44static UINT8 nfa_dm_get_rf_discover_config (tNFA_DM_DISC_TECH_PROTO_MASK dm_disc_mask, 45 tNFC_DISCOVER_PARAMS disc_params[], 46 UINT8 max_params); 47static tNFA_STATUS nfa_dm_set_rf_listen_mode_config (tNFA_DM_DISC_TECH_PROTO_MASK tech_proto_mask); 48static void nfa_dm_set_rf_listen_mode_raw_config (tNFA_DM_DISC_TECH_PROTO_MASK *p_disc_mask); 49static tNFA_DM_DISC_TECH_PROTO_MASK nfa_dm_disc_get_disc_mask (tNFC_RF_TECH_N_MODE tech_n_mode, 50 tNFC_PROTOCOL protocol); 51static void nfa_dm_notify_discovery (tNFA_DM_RF_DISC_DATA *p_data); 52static tNFA_STATUS nfa_dm_disc_notify_activation (tNFC_DISCOVER *p_data); 53static void nfa_dm_disc_notify_deactivation (tNFA_DM_RF_DISC_SM_EVENT sm_event, tNFC_DISCOVER *p_data); 54static void nfa_dm_disc_data_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data); 55static void nfa_dm_disc_kovio_timeout_cback (TIMER_LIST_ENT *p_tle); 56static void nfa_dm_disc_report_kovio_presence_check (tNFC_STATUS status); 57 58#if (BT_TRACE_VERBOSE == TRUE) 59static char *nfa_dm_disc_state_2_str (UINT8 state); 60static char *nfa_dm_disc_event_2_str (UINT8 event); 61#endif 62 63typedef struct nfa_dm_p2p_prio_logic 64{ 65 BOOLEAN isodep_detected; /* flag to check if ISO-DEP is detected */ 66 BOOLEAN timer_expired; /* flag to check whether timer is expired */ 67 TIMER_LIST_ENT timer_list; /*timer structure pointer */ 68 UINT8 first_tech_mode; 69}nfa_dm_p2p_prio_logic_t; 70 71static nfa_dm_p2p_prio_logic_t p2p_prio_logic_data; 72 73/******************************************************************************* 74** 75** Function nfa_dm_get_rf_discover_config 76** 77** Description Build RF discovery configurations from tNFA_DM_DISC_TECH_PROTO_MASK 78** 79** Returns number of RF discovery configurations 80** 81*******************************************************************************/ 82static UINT8 nfa_dm_get_rf_discover_config (tNFA_DM_DISC_TECH_PROTO_MASK dm_disc_mask, 83 tNFC_DISCOVER_PARAMS disc_params[], 84 UINT8 max_params) 85{ 86 UINT8 num_params = 0; 87 88 if (nfa_dm_cb.flags & NFA_DM_FLAGS_LISTEN_DISABLED) 89 { 90 NFA_TRACE_DEBUG1 ("nfa_dm_get_rf_discover_config () listen disabled, rm listen from 0x%x", dm_disc_mask); 91 dm_disc_mask &= NFA_DM_DISC_MASK_POLL; 92 } 93 if (nfa_dm_is_p2p_paused ()) 94 { 95 dm_disc_mask &= ~NFA_DM_DISC_MASK_NFC_DEP; 96 } 97 98 /* Check polling A */ 99 if (dm_disc_mask & ( NFA_DM_DISC_MASK_PA_T1T 100 |NFA_DM_DISC_MASK_PA_T2T 101 |NFA_DM_DISC_MASK_PA_ISO_DEP 102 |NFA_DM_DISC_MASK_PA_NFC_DEP 103 |NFA_DM_DISC_MASK_P_LEGACY) ) 104 { 105 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_A; 106 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pa; 107 num_params++; 108 109 if (num_params >= max_params) 110 return num_params; 111 } 112 113 /* Check polling B */ 114 if (dm_disc_mask & NFA_DM_DISC_MASK_PB_ISO_DEP) 115 { 116 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_B; 117 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pb; 118 num_params++; 119 120 if (num_params >= max_params) 121 return num_params; 122 } 123 124 /* Check polling F */ 125 if (dm_disc_mask & ( NFA_DM_DISC_MASK_PF_T3T 126 |NFA_DM_DISC_MASK_PF_NFC_DEP) ) 127 { 128 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_F; 129 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pf; 130 num_params++; 131 132 if (num_params >= max_params) 133 return num_params; 134 } 135 136 /* Check polling A Active mode */ 137 if (dm_disc_mask & NFA_DM_DISC_MASK_PAA_NFC_DEP) 138 { 139 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_A_ACTIVE; 140 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->paa; 141 num_params++; 142 143 if (num_params >= max_params) 144 return num_params; 145 } 146 147 /* Check polling F Active mode */ 148 if (dm_disc_mask & NFA_DM_DISC_MASK_PFA_NFC_DEP) 149 { 150 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_F_ACTIVE; 151 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pfa; 152 num_params++; 153 154 if (num_params >= max_params) 155 return num_params; 156 } 157 158 /* Check listening A */ 159 if (dm_disc_mask & ( NFA_DM_DISC_MASK_LA_T1T 160 |NFA_DM_DISC_MASK_LA_T2T 161 |NFA_DM_DISC_MASK_LA_ISO_DEP 162 |NFA_DM_DISC_MASK_LA_NFC_DEP) ) 163 { 164 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_A; 165 disc_params[num_params].frequency = 1; 166 num_params++; 167 168 if (num_params >= max_params) 169 return num_params; 170 } 171 172 /* Check listening B */ 173 if (dm_disc_mask & NFA_DM_DISC_MASK_LB_ISO_DEP) 174 { 175 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_B; 176 disc_params[num_params].frequency = 1; 177 num_params++; 178 179 if (num_params >= max_params) 180 return num_params; 181 } 182 183 /* Check listening F */ 184 if (dm_disc_mask & ( NFA_DM_DISC_MASK_LF_T3T 185 |NFA_DM_DISC_MASK_LF_NFC_DEP) ) 186 { 187 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_F; 188 disc_params[num_params].frequency = 1; 189 num_params++; 190 191 if (num_params >= max_params) 192 return num_params; 193 } 194 195 /* Check listening A Active mode */ 196 if (dm_disc_mask & NFA_DM_DISC_MASK_LAA_NFC_DEP) 197 { 198 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE; 199 disc_params[num_params].frequency = 1; 200 num_params++; 201 202 if (num_params >= max_params) 203 return num_params; 204 } 205 206 /* Check listening F Active mode */ 207 if (dm_disc_mask & NFA_DM_DISC_MASK_LFA_NFC_DEP) 208 { 209 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE; 210 disc_params[num_params].frequency = 1; 211 num_params++; 212 213 if (num_params >= max_params) 214 return num_params; 215 } 216 217 /* Check polling ISO 15693 */ 218 if (dm_disc_mask & NFA_DM_DISC_MASK_P_ISO15693) 219 { 220 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_ISO15693; 221 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pi93; 222 num_params++; 223 224 if (num_params >= max_params) 225 return num_params; 226 } 227 228 /* Check polling B' */ 229 if (dm_disc_mask & NFA_DM_DISC_MASK_P_B_PRIME) 230 { 231 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_B_PRIME; 232 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pbp; 233 num_params++; 234 235 if (num_params >= max_params) 236 return num_params; 237 } 238 239 /* Check polling KOVIO */ 240 if (dm_disc_mask & NFA_DM_DISC_MASK_P_KOVIO) 241 { 242 disc_params[num_params].type = NFC_DISCOVERY_TYPE_POLL_KOVIO; 243 disc_params[num_params].frequency = p_nfa_dm_rf_disc_freq_cfg->pk; 244 num_params++; 245 246 if (num_params >= max_params) 247 return num_params; 248 } 249 250 /* Check listening ISO 15693 */ 251 if (dm_disc_mask & NFA_DM_DISC_MASK_L_ISO15693) 252 { 253 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_ISO15693; 254 disc_params[num_params].frequency = 1; 255 num_params++; 256 257 if (num_params >= max_params) 258 return num_params; 259 } 260 261 /* Check listening B' */ 262 if (dm_disc_mask & NFA_DM_DISC_MASK_L_B_PRIME) 263 { 264 disc_params[num_params].type = NFC_DISCOVERY_TYPE_LISTEN_B_PRIME; 265 disc_params[num_params].frequency = 1; 266 num_params++; 267 268 if (num_params >= max_params) 269 return num_params; 270 } 271 272 return num_params; 273} 274 275/******************************************************************************* 276** 277** Function nfa_dm_set_rf_listen_mode_config 278** 279** Description Update listening protocol to NFCC 280** 281** Returns NFA_STATUS_OK if success 282** 283*******************************************************************************/ 284static tNFA_STATUS nfa_dm_set_rf_listen_mode_config (tNFA_DM_DISC_TECH_PROTO_MASK tech_proto_mask) 285{ 286 UINT8 params[40], *p; 287 UINT8 platform = 0; 288 UINT8 sens_info = 0; 289 290 NFA_TRACE_DEBUG1 ("nfa_dm_set_rf_listen_mode_config () tech_proto_mask = 0x%08X", 291 tech_proto_mask); 292 293 /* 294 ** T1T listen LA_PROT 0x80, LA_SENS_RES byte1:0x00 byte2:0x0C 295 ** T2T listen LA_PROT 0x00 296 ** T3T listen No bit for T3T in LF_PROT (CE T3T set listen parameters, system code, NFCID2, etc.) 297 ** ISO-DEP listen LA_PROT 0x01, LB_PROT 0x01 298 ** NFC-DEP listen LA_PROT 0x02, LF_PROT 0x02 299 */ 300 301 if (tech_proto_mask & NFA_DM_DISC_MASK_LA_T1T) 302 { 303 platform = NCI_PARAM_PLATFORM_T1T; 304 } 305 else if (tech_proto_mask & NFA_DM_DISC_MASK_LA_T2T) 306 { 307 /* platform = 0 and sens_info = 0 */ 308 } 309 else 310 { 311 if (tech_proto_mask & NFA_DM_DISC_MASK_LA_ISO_DEP) 312 { 313 sens_info |= NCI_PARAM_SEL_INFO_ISODEP; 314 } 315 316 if (tech_proto_mask & NFA_DM_DISC_MASK_LA_NFC_DEP) 317 { 318 sens_info |= NCI_PARAM_SEL_INFO_NFCDEP; 319 } 320 } 321 322 p = params; 323 324 /* 325 ** for Listen A 326 ** 327 ** Set ATQA 0x0C00 for T1T listen 328 ** If the ATQA values are 0x0000, then the FW will use 0x0400 329 ** which works for ISODEP, T2T and NFCDEP. 330 */ 331 if (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A] == NFA_DM_DISC_HOST_ID_DH) 332 { 333 UINT8_TO_STREAM (p, NFC_PMID_LA_BIT_FRAME_SDD); 334 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_BIT_FRAME_SDD); 335 UINT8_TO_STREAM (p, 0x04); 336 UINT8_TO_STREAM (p, NFC_PMID_LA_PLATFORM_CONFIG); 337 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_PLATFORM_CONFIG); 338 UINT8_TO_STREAM (p, platform); 339 UINT8_TO_STREAM (p, NFC_PMID_LA_SEL_INFO); 340 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_SEL_INFO); 341 UINT8_TO_STREAM (p, sens_info); 342 } 343 else /* Let NFCC use UICC configuration by configuring with length = 0 */ 344 { 345 UINT8_TO_STREAM (p, NFC_PMID_LA_BIT_FRAME_SDD); 346 UINT8_TO_STREAM (p, 0); 347 UINT8_TO_STREAM (p, NFC_PMID_LA_PLATFORM_CONFIG); 348 UINT8_TO_STREAM (p, 0); 349 UINT8_TO_STREAM (p, NFC_PMID_LA_SEL_INFO); 350 UINT8_TO_STREAM (p, 0); 351 UINT8_TO_STREAM (p, NFC_PMID_LA_NFCID1); 352 UINT8_TO_STREAM (p, 0); 353 UINT8_TO_STREAM (p, NFC_PMID_LA_HIST_BY); 354 UINT8_TO_STREAM (p, 0); 355 } 356 357 /* for Listen B */ 358 if (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_B] == NFA_DM_DISC_HOST_ID_DH) 359 { 360 UINT8_TO_STREAM (p, NFC_PMID_LB_SENSB_INFO); 361 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_SENSB_INFO); 362 if (tech_proto_mask & NFA_DM_DISC_MASK_LB_ISO_DEP) 363 { 364 UINT8_TO_STREAM (p, NCI_LISTEN_PROTOCOL_ISO_DEP); 365 } 366 else 367 { 368 UINT8_TO_STREAM (p, 0x00); 369 } 370 } 371 else /* Let NFCC use UICC configuration by configuring with length = 0 */ 372 { 373 UINT8_TO_STREAM (p, NFC_PMID_LB_SENSB_INFO); 374 UINT8_TO_STREAM (p, 0); 375 UINT8_TO_STREAM (p, NFC_PMID_LB_NFCID0); 376 UINT8_TO_STREAM (p, 0); 377 UINT8_TO_STREAM (p, NFC_PMID_LB_APPDATA); 378 UINT8_TO_STREAM (p, 0); 379 UINT8_TO_STREAM (p, NFC_PMID_LB_ADC_FO); 380 UINT8_TO_STREAM (p, 0); 381 UINT8_TO_STREAM (p, NFC_PMID_LB_H_INFO); 382 UINT8_TO_STREAM (p, 0); 383 } 384 385 /* for Listen F */ 386 /* NFCC can support NFC-DEP and T3T listening based on NFCID routing regardless of NFC-F tech routing */ 387 UINT8_TO_STREAM (p, NFC_PMID_LF_PROTOCOL); 388 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_PROTOCOL); 389 if ((tech_proto_mask & NFA_DM_DISC_MASK_LF_NFC_DEP) && 390 !nfa_dm_is_p2p_paused() ) 391 { 392 UINT8_TO_STREAM (p, NCI_LISTEN_PROTOCOL_NFC_DEP); 393 } 394 else 395 { 396 UINT8_TO_STREAM (p, 0x00); 397 } 398 399 if (p > params) 400 { 401 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE); 402 } 403 404 return NFA_STATUS_OK; 405} 406 407/******************************************************************************* 408** 409** Function nfa_dm_set_total_duration 410** 411** Description Update total duration to NFCC 412** 413** Returns void 414** 415*******************************************************************************/ 416static void nfa_dm_set_total_duration (void) 417{ 418 UINT8 params[10], *p; 419 420 NFA_TRACE_DEBUG0 ("nfa_dm_set_total_duration ()"); 421 422 p = params; 423 424 /* for total duration */ 425 UINT8_TO_STREAM (p, NFC_PMID_TOTAL_DURATION); 426 UINT8_TO_STREAM (p, NCI_PARAM_LEN_TOTAL_DURATION); 427 UINT16_TO_STREAM (p, nfa_dm_cb.disc_cb.disc_duration); 428 429 if (p > params) 430 { 431 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE); 432 } 433} 434 435/******************************************************************************* 436** 437** Function nfa_dm_set_rf_listen_mode_raw_config 438** 439** Description Set raw listen parameters 440** 441** Returns void 442** 443*******************************************************************************/ 444static void nfa_dm_set_rf_listen_mode_raw_config (tNFA_DM_DISC_TECH_PROTO_MASK *p_disc_mask) 445{ 446 tNFA_DM_DISC_TECH_PROTO_MASK disc_mask = 0; 447 tNFA_LISTEN_CFG *p_cfg = &nfa_dm_cb.disc_cb.excl_listen_config; 448 UINT8 params[250], *p, xx; 449 450 NFA_TRACE_DEBUG0 ("nfa_dm_set_rf_listen_mode_raw_config ()"); 451 452 /* 453 ** Discovery Configuration Parameters for Listen A 454 */ 455 if ( (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A] == NFA_DM_DISC_HOST_ID_DH) 456 &&(p_cfg->la_enable) ) 457 { 458 p = params; 459 460 UINT8_TO_STREAM (p, NFC_PMID_LA_BIT_FRAME_SDD); 461 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_BIT_FRAME_SDD); 462 UINT8_TO_STREAM (p, p_cfg->la_bit_frame_sdd); 463 464 UINT8_TO_STREAM (p, NFC_PMID_LA_PLATFORM_CONFIG); 465 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_PLATFORM_CONFIG); 466 UINT8_TO_STREAM (p, p_cfg->la_platform_config); 467 468 UINT8_TO_STREAM (p, NFC_PMID_LA_SEL_INFO); 469 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LA_SEL_INFO); 470 UINT8_TO_STREAM (p, p_cfg->la_sel_info); 471 472 if (p_cfg->la_platform_config == NCI_PARAM_PLATFORM_T1T) 473 { 474 disc_mask |= NFA_DM_DISC_MASK_LA_T1T; 475 } 476 else 477 { 478 /* If T4T or NFCDEP */ 479 if (p_cfg->la_sel_info & NCI_PARAM_SEL_INFO_ISODEP) 480 { 481 disc_mask |= NFA_DM_DISC_MASK_LA_ISO_DEP; 482 } 483 484 if (p_cfg->la_sel_info & NCI_PARAM_SEL_INFO_NFCDEP) 485 { 486 disc_mask |= NFA_DM_DISC_MASK_LA_NFC_DEP; 487 } 488 489 /* If neither, T4T nor NFCDEP, then its T2T */ 490 if (disc_mask == 0) 491 { 492 disc_mask |= NFA_DM_DISC_MASK_LA_T2T; 493 } 494 } 495 496 UINT8_TO_STREAM (p, NFC_PMID_LA_NFCID1); 497 UINT8_TO_STREAM (p, p_cfg->la_nfcid1_len); 498 ARRAY_TO_STREAM (p, p_cfg->la_nfcid1, p_cfg->la_nfcid1_len); 499 500 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE); 501 } 502 503 /* 504 ** Discovery Configuration Parameters for Listen B 505 */ 506 if ( (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_B] == NFA_DM_DISC_HOST_ID_DH) 507 &&(p_cfg->lb_enable) ) 508 { 509 p = params; 510 511 UINT8_TO_STREAM (p, NFC_PMID_LB_SENSB_INFO); 512 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_SENSB_INFO); 513 UINT8_TO_STREAM (p, p_cfg->lb_sensb_info); 514 515 UINT8_TO_STREAM (p, NFC_PMID_LB_NFCID0); 516 UINT8_TO_STREAM (p, p_cfg->lb_nfcid0_len); 517 ARRAY_TO_STREAM (p, p_cfg->lb_nfcid0, p_cfg->lb_nfcid0_len); 518 519 UINT8_TO_STREAM (p, NFC_PMID_LB_APPDATA); 520 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_APPDATA); 521 ARRAY_TO_STREAM (p, p_cfg->lb_app_data, NCI_PARAM_LEN_LB_APPDATA); 522 523 UINT8_TO_STREAM (p, NFC_PMID_LB_SFGI); 524 UINT8_TO_STREAM (p, 1); 525 UINT8_TO_STREAM (p, p_cfg->lb_adc_fo); 526 527 UINT8_TO_STREAM (p, NFC_PMID_LB_ADC_FO); 528 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LB_ADC_FO); 529 UINT8_TO_STREAM (p, p_cfg->lb_adc_fo); 530 531 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE); 532 533 if (p_cfg->lb_sensb_info & NCI_LISTEN_PROTOCOL_ISO_DEP) 534 { 535 disc_mask |= NFA_DM_DISC_MASK_LB_ISO_DEP; 536 } 537 } 538 539 /* 540 ** Discovery Configuration Parameters for Listen F 541 */ 542 if ( (nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_F] == NFA_DM_DISC_HOST_ID_DH) 543 &&(p_cfg->lf_enable) ) 544 { 545 p = params; 546 547 UINT8_TO_STREAM (p, NFC_PMID_LF_CON_BITR_F); 548 UINT8_TO_STREAM (p, 1); 549 UINT8_TO_STREAM (p, p_cfg->lf_con_bitr_f); 550 551 UINT8_TO_STREAM (p, NFC_PMID_LF_PROTOCOL); 552 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_PROTOCOL); 553 UINT8_TO_STREAM (p, p_cfg->lf_protocol_type); 554 555 UINT8_TO_STREAM (p, NFC_PMID_LF_T3T_FLAGS2); 556 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_T3T_FLAGS2); 557 UINT16_TO_STREAM(p, p_cfg->lf_t3t_flags); 558 559 /* if the bit at position X is set to 0, SC/NFCID2 with index X shall be ignored */ 560 for (xx = 0; xx < NFA_LF_MAX_SC_NFCID2; xx++) 561 { 562 if ((p_cfg->lf_t3t_flags & (0x0001 << xx)) != 0x0000) 563 { 564 UINT8_TO_STREAM (p, NFC_PMID_LF_T3T_ID1 + xx); 565 UINT8_TO_STREAM (p, NCI_SYSTEMCODE_LEN + NCI_NFCID2_LEN); 566 ARRAY_TO_STREAM (p, p_cfg->lf_t3t_identifier[xx], NCI_SYSTEMCODE_LEN + NCI_NFCID2_LEN); 567 } 568 } 569 570 UINT8_TO_STREAM (p, NFC_PMID_LF_T3T_PMM); 571 UINT8_TO_STREAM (p, NCI_PARAM_LEN_LF_T3T_PMM); 572 ARRAY_TO_STREAM (p, p_cfg->lf_t3t_pmm, NCI_PARAM_LEN_LF_T3T_PMM); 573 574 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE); 575 576 if (p_cfg->lf_t3t_flags != NCI_LF_T3T_FLAGS2_ALL_DISABLED) 577 { 578 disc_mask |= NFA_DM_DISC_MASK_LF_T3T; 579 } 580 if (p_cfg->lf_protocol_type & NCI_LISTEN_PROTOCOL_NFC_DEP) 581 { 582 disc_mask |= NFA_DM_DISC_MASK_LF_NFC_DEP; 583 } 584 } 585 586 /* 587 ** Discovery Configuration Parameters for Listen ISO-DEP 588 */ 589 if ((disc_mask & (NFA_DM_DISC_MASK_LA_ISO_DEP|NFA_DM_DISC_MASK_LB_ISO_DEP)) 590 &&(p_cfg->li_enable)) 591 { 592 p = params; 593 594 UINT8_TO_STREAM (p, NFC_PMID_FWI); 595 UINT8_TO_STREAM (p, NCI_PARAM_LEN_FWI); 596 UINT8_TO_STREAM (p, p_cfg->li_fwi); 597 598 if (disc_mask & NFA_DM_DISC_MASK_LA_ISO_DEP) 599 { 600 UINT8_TO_STREAM (p, NFC_PMID_LA_HIST_BY); 601 UINT8_TO_STREAM (p, p_cfg->la_hist_bytes_len); 602 ARRAY_TO_STREAM (p, p_cfg->la_hist_bytes, p_cfg->la_hist_bytes_len); 603 } 604 605 if (disc_mask & NFA_DM_DISC_MASK_LB_ISO_DEP) 606 { 607 UINT8_TO_STREAM (p, NFC_PMID_LB_H_INFO); 608 UINT8_TO_STREAM (p, p_cfg->lb_h_info_resp_len); 609 ARRAY_TO_STREAM (p, p_cfg->lb_h_info_resp, p_cfg->lb_h_info_resp_len); 610 } 611 612 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE); 613 } 614 615 /* 616 ** Discovery Configuration Parameters for Listen NFC-DEP 617 */ 618 if ( (disc_mask & (NFA_DM_DISC_MASK_LA_NFC_DEP|NFA_DM_DISC_MASK_LF_NFC_DEP)) 619 &&(p_cfg->ln_enable)) 620 { 621 p = params; 622 623 UINT8_TO_STREAM (p, NFC_PMID_WT); 624 UINT8_TO_STREAM (p, NCI_PARAM_LEN_WT); 625 UINT8_TO_STREAM (p, p_cfg->ln_wt); 626 627 UINT8_TO_STREAM (p, NFC_PMID_ATR_RES_GEN_BYTES); 628 UINT8_TO_STREAM (p, p_cfg->ln_atr_res_gen_bytes_len); 629 ARRAY_TO_STREAM (p, p_cfg->ln_atr_res_gen_bytes, p_cfg->ln_atr_res_gen_bytes_len); 630 631 UINT8_TO_STREAM (p, NFC_PMID_ATR_RSP_CONFIG); 632 UINT8_TO_STREAM (p, 1); 633 UINT8_TO_STREAM (p, p_cfg->ln_atr_res_config); 634 635 nfa_dm_check_set_config ((UINT8) (p - params), params, FALSE); 636 } 637 638 *p_disc_mask = disc_mask; 639 640 NFA_TRACE_DEBUG1 ("nfa_dm_set_rf_listen_mode_raw_config () disc_mask = 0x%x", disc_mask); 641} 642 643/******************************************************************************* 644** 645** Function nfa_dm_disc_get_disc_mask 646** 647** Description Convert RF technology, mode and protocol to bit mask 648** 649** Returns tNFA_DM_DISC_TECH_PROTO_MASK 650** 651*******************************************************************************/ 652static tNFA_DM_DISC_TECH_PROTO_MASK nfa_dm_disc_get_disc_mask (tNFC_RF_TECH_N_MODE tech_n_mode, 653 tNFC_PROTOCOL protocol) 654{ 655 /* Set initial disc_mask to legacy poll or listen */ 656 tNFA_DM_DISC_TECH_PROTO_MASK disc_mask = ((tech_n_mode & 0x80) ? NFA_DM_DISC_MASK_L_LEGACY : NFA_DM_DISC_MASK_P_LEGACY); 657 658 if (NFC_DISCOVERY_TYPE_POLL_A == tech_n_mode) 659 { 660 switch (protocol) 661 { 662 case NFC_PROTOCOL_T1T: 663 disc_mask = NFA_DM_DISC_MASK_PA_T1T; 664 break; 665 case NFC_PROTOCOL_T2T: 666 disc_mask = NFA_DM_DISC_MASK_PA_T2T; 667 break; 668 case NFC_PROTOCOL_ISO_DEP: 669 disc_mask = NFA_DM_DISC_MASK_PA_ISO_DEP; 670 break; 671 case NFC_PROTOCOL_NFC_DEP: 672 disc_mask = NFA_DM_DISC_MASK_PA_NFC_DEP; 673 break; 674 } 675 } 676 else if (NFC_DISCOVERY_TYPE_POLL_B == tech_n_mode) 677 { 678 if (protocol == NFC_PROTOCOL_ISO_DEP) 679 disc_mask = NFA_DM_DISC_MASK_PB_ISO_DEP; 680 } 681 else if (NFC_DISCOVERY_TYPE_POLL_F == tech_n_mode) 682 { 683 if (protocol == NFC_PROTOCOL_T3T) 684 disc_mask = NFA_DM_DISC_MASK_PF_T3T; 685 else if (protocol == NFC_PROTOCOL_NFC_DEP) 686 disc_mask = NFA_DM_DISC_MASK_PF_NFC_DEP; 687 } 688 else if (NFC_DISCOVERY_TYPE_POLL_ISO15693 == tech_n_mode) 689 { 690 disc_mask = NFA_DM_DISC_MASK_P_ISO15693; 691 } 692 else if (NFC_DISCOVERY_TYPE_POLL_B_PRIME == tech_n_mode) 693 { 694 disc_mask = NFA_DM_DISC_MASK_P_B_PRIME; 695 } 696 else if (NFC_DISCOVERY_TYPE_POLL_KOVIO == tech_n_mode) 697 { 698 disc_mask = NFA_DM_DISC_MASK_P_KOVIO; 699 } 700 else if (NFC_DISCOVERY_TYPE_POLL_A_ACTIVE == tech_n_mode) 701 { 702 disc_mask = NFA_DM_DISC_MASK_PAA_NFC_DEP; 703 } 704 else if (NFC_DISCOVERY_TYPE_POLL_F_ACTIVE == tech_n_mode) 705 { 706 disc_mask = NFA_DM_DISC_MASK_PFA_NFC_DEP; 707 } 708 else if (NFC_DISCOVERY_TYPE_LISTEN_A == tech_n_mode) 709 { 710 switch (protocol) 711 { 712 case NFC_PROTOCOL_T1T: 713 disc_mask = NFA_DM_DISC_MASK_LA_T1T; 714 break; 715 case NFC_PROTOCOL_T2T: 716 disc_mask = NFA_DM_DISC_MASK_LA_T2T; 717 break; 718 case NFC_PROTOCOL_ISO_DEP: 719 disc_mask = NFA_DM_DISC_MASK_LA_ISO_DEP; 720 break; 721 case NFC_PROTOCOL_NFC_DEP: 722 disc_mask = NFA_DM_DISC_MASK_LA_NFC_DEP; 723 break; 724 } 725 } 726 else if (NFC_DISCOVERY_TYPE_LISTEN_B == tech_n_mode) 727 { 728 if (protocol == NFC_PROTOCOL_ISO_DEP) 729 disc_mask = NFA_DM_DISC_MASK_LB_ISO_DEP; 730 } 731 else if (NFC_DISCOVERY_TYPE_LISTEN_F == tech_n_mode) 732 { 733 if (protocol == NFC_PROTOCOL_T3T) 734 disc_mask = NFA_DM_DISC_MASK_LF_T3T; 735 else if (protocol == NFC_PROTOCOL_NFC_DEP) 736 disc_mask = NFA_DM_DISC_MASK_LF_NFC_DEP; 737 } 738 else if (NFC_DISCOVERY_TYPE_LISTEN_ISO15693 == tech_n_mode) 739 { 740 disc_mask = NFA_DM_DISC_MASK_L_ISO15693; 741 } 742 else if (NFC_DISCOVERY_TYPE_LISTEN_B_PRIME == tech_n_mode) 743 { 744 disc_mask = NFA_DM_DISC_MASK_L_B_PRIME; 745 } 746 else if (NFC_DISCOVERY_TYPE_LISTEN_A_ACTIVE == tech_n_mode) 747 { 748 disc_mask = NFA_DM_DISC_MASK_LAA_NFC_DEP; 749 } 750 else if (NFC_DISCOVERY_TYPE_LISTEN_F_ACTIVE == tech_n_mode) 751 { 752 disc_mask = NFA_DM_DISC_MASK_LFA_NFC_DEP; 753 } 754 755 NFA_TRACE_DEBUG3 ("nfa_dm_disc_get_disc_mask (): tech_n_mode:0x%X, protocol:0x%X, disc_mask:0x%X", 756 tech_n_mode, protocol, disc_mask); 757 return (disc_mask); 758} 759 760/******************************************************************************* 761** 762** Function nfa_dm_disc_discovery_cback 763** 764** Description Discovery callback event from NFC 765** 766** Returns void 767** 768*******************************************************************************/ 769static void nfa_dm_disc_discovery_cback (tNFC_DISCOVER_EVT event, tNFC_DISCOVER *p_data) 770{ 771 tNFA_DM_RF_DISC_SM_EVENT dm_disc_event = NFA_DM_DISC_SM_MAX_EVENT; 772 773 NFA_TRACE_DEBUG1 ("nfa_dm_disc_discovery_cback (): event:0x%X", event); 774 775 switch (event) 776 { 777 case NFC_START_DEVT: 778 dm_disc_event = NFA_DM_RF_DISCOVER_RSP; 779 break; 780 case NFC_RESULT_DEVT: 781 dm_disc_event = NFA_DM_RF_DISCOVER_NTF; 782 break; 783 case NFC_SELECT_DEVT: 784 dm_disc_event = NFA_DM_RF_DISCOVER_SELECT_RSP; 785 break; 786 case NFC_ACTIVATE_DEVT: 787 dm_disc_event = NFA_DM_RF_INTF_ACTIVATED_NTF; 788 break; 789 case NFC_DEACTIVATE_DEVT: 790 if (p_data->deactivate.is_ntf) 791 { 792 dm_disc_event = NFA_DM_RF_DEACTIVATE_NTF; 793 if ((p_data->deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) || (p_data->deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY)) 794 { 795 NFC_SetReassemblyFlag (TRUE); 796 nfa_dm_cb.flags &= ~NFA_DM_FLAGS_RAW_FRAME; 797 } 798 } 799 else 800 dm_disc_event = NFA_DM_RF_DEACTIVATE_RSP; 801 break; 802 default: 803 NFA_TRACE_ERROR0 ("Unexpected event"); 804 return; 805 } 806 807 nfa_dm_disc_sm_execute (dm_disc_event, (tNFA_DM_RF_DISC_DATA *) p_data); 808} 809 810/******************************************************************************* 811** 812** Function nfa_dm_disc_notify_started 813** 814** Description Report NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT or 815** NFA_RF_DISCOVERY_STARTED_EVT, if needed 816** 817** Returns void 818** 819*******************************************************************************/ 820static void nfa_dm_disc_notify_started (tNFA_STATUS status) 821{ 822 tNFA_CONN_EVT_DATA evt_data; 823 824 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_NOTIFY) 825 { 826 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY; 827 828 evt_data.status = status; 829 830 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use) 831 nfa_dm_conn_cback_event_notify (NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT, &evt_data); 832 else 833 nfa_dm_conn_cback_event_notify (NFA_RF_DISCOVERY_STARTED_EVT, &evt_data); 834 } 835} 836 837/******************************************************************************* 838** 839** Function nfa_dm_disc_conn_event_notify 840** 841** Description Notify application of CONN_CBACK event, using appropriate 842** callback 843** 844** Returns nothing 845** 846*******************************************************************************/ 847void nfa_dm_disc_conn_event_notify (UINT8 event, tNFA_STATUS status) 848{ 849 tNFA_CONN_EVT_DATA evt_data; 850 851 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_NOTIFY) 852 { 853 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY; 854 evt_data.status = status; 855 856 if (nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) 857 { 858 /* Use exclusive RF mode callback */ 859 if (nfa_dm_cb.p_excl_conn_cback) 860 (*nfa_dm_cb.p_excl_conn_cback) (event, &evt_data); 861 } 862 else 863 { 864 (*nfa_dm_cb.p_conn_cback) (event, &evt_data); 865 } 866 } 867} 868 869/******************************************************************************* 870** 871** Function nfa_dm_disc_force_to_idle 872** 873** Description Force NFCC to idle state while waiting for deactivation NTF 874** 875** Returns tNFC_STATUS 876** 877*******************************************************************************/ 878static tNFC_STATUS nfa_dm_disc_force_to_idle (void) 879{ 880 tNFC_STATUS status = NFC_STATUS_SEMANTIC_ERROR; 881 882 NFA_TRACE_DEBUG1 ("nfa_dm_disc_force_to_idle() disc_flags = 0x%x", nfa_dm_cb.disc_cb.disc_flags); 883 884 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF) /* do not execute more than one */ 885 { 886 nfa_dm_cb.disc_cb.disc_flags &= ~(NFA_DM_DISC_FLAGS_W4_NTF); 887 nfa_dm_cb.disc_cb.disc_flags |= (NFA_DM_DISC_FLAGS_W4_RSP); 888 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 889 status = NFC_Deactivate (NFC_DEACTIVATE_TYPE_IDLE); 890 } 891 892 return (status); 893} 894 895/******************************************************************************* 896** 897** Function nfa_dm_disc_deact_ntf_timeout_cback 898** 899** Description Timeout while waiting for deactivation NTF 900** 901** Returns void 902** 903*******************************************************************************/ 904static void nfa_dm_disc_deact_ntf_timeout_cback (TIMER_LIST_ENT *p_tle) 905{ 906 NFA_TRACE_ERROR0 ("nfa_dm_disc_deact_ntf_timeout_cback()"); 907 908 nfa_dm_disc_force_to_idle(); 909} 910 911/******************************************************************************* 912** 913** Function nfa_dm_send_deactivate_cmd 914** 915** Description Send deactivate command to NFCC, if needed. 916** 917** Returns NFC_STATUS_OK - deactivate cmd is sent 918** NCI_STATUS_FAILED - no buffers 919** NFC_STATUS_SEMANTIC_ERROR - this function does not attempt 920** to send deactivate cmd 921** 922*******************************************************************************/ 923static tNFC_STATUS nfa_dm_send_deactivate_cmd (tNFC_DEACT_TYPE deactivate_type) 924{ 925 tNFC_STATUS status = NFC_STATUS_SEMANTIC_ERROR; 926 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); 927 928 if (!w4_flags) 929 { 930 /* if deactivate CMD was not sent to NFCC */ 931 nfa_dm_cb.disc_cb.disc_flags |= (NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF); 932 933 status = NFC_Deactivate (deactivate_type); 934 935 if (!nfa_dm_cb.disc_cb.tle.in_use) 936 { 937 nfa_dm_cb.disc_cb.tle.p_cback = (TIMER_CBACK *)nfa_dm_disc_deact_ntf_timeout_cback; 938 nfa_sys_start_timer (&nfa_dm_cb.disc_cb.tle, 0, NFA_DM_DISC_TIMEOUT_W4_DEACT_NTF); 939 } 940 } 941 else 942 { 943 if (deactivate_type == NFC_DEACTIVATE_TYPE_SLEEP) 944 { 945 status = NFC_STATUS_SEMANTIC_ERROR; 946 } 947 else if (nfa_dm_cb.disc_cb.tle.in_use) 948 { 949 status = NFC_STATUS_OK; 950 } 951 else 952 { 953 status = nfa_dm_disc_force_to_idle (); 954 } 955 } 956 957 return status; 958} 959 960/******************************************************************************* 961** 962** Function nfa_dm_start_rf_discover 963** 964** Description Start RF discovery 965** 966** Returns void 967** 968*******************************************************************************/ 969void nfa_dm_start_rf_discover (void) 970{ 971 tNFC_DISCOVER_PARAMS disc_params[NFA_DM_MAX_DISC_PARAMS]; 972 tNFA_DM_DISC_TECH_PROTO_MASK dm_disc_mask = 0, poll_mask, listen_mask; 973 UINT8 num_params, xx; 974 975 NFA_TRACE_DEBUG0 ("nfa_dm_start_rf_discover ()"); 976 /* Make sure that RF discovery was enabled, or some app has exclusive control */ 977 if ( (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_ENABLED)) 978 &&(nfa_dm_cb.disc_cb.excl_disc_entry.in_use == FALSE) ) 979 { 980 return; 981 } 982 983 /* get listen mode routing table for technology */ 984 nfa_ee_get_tech_route (NFA_EE_PWR_STATE_ON, nfa_dm_cb.disc_cb.listen_RT); 985 986 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use) 987 { 988 nfa_dm_set_rf_listen_mode_raw_config (&dm_disc_mask); 989 dm_disc_mask |= (nfa_dm_cb.disc_cb.excl_disc_entry.requested_disc_mask & NFA_DM_DISC_MASK_POLL); 990 nfa_dm_cb.disc_cb.excl_disc_entry.selected_disc_mask = dm_disc_mask; 991 } 992 else 993 { 994 /* Collect RF discovery request from sub-modules */ 995 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++) 996 { 997 if (nfa_dm_cb.disc_cb.entry[xx].in_use) 998 { 999 poll_mask = (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask & NFA_DM_DISC_MASK_POLL); 1000 1001 /* clear poll mode technolgies and protocols which are already used by others */ 1002 poll_mask &= ~(dm_disc_mask & NFA_DM_DISC_MASK_POLL); 1003 1004 listen_mask = 0; 1005 1006 /* 1007 ** add listen mode technolgies and protocols if host ID is matched to listen mode routing table 1008 */ 1009 1010 /* NFC-A */ 1011 if (nfa_dm_cb.disc_cb.entry[xx].host_id == nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A]) 1012 { 1013 listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask 1014 & ( NFA_DM_DISC_MASK_LA_T1T 1015 |NFA_DM_DISC_MASK_LA_T2T 1016 |NFA_DM_DISC_MASK_LA_ISO_DEP 1017 |NFA_DM_DISC_MASK_LA_NFC_DEP 1018 |NFA_DM_DISC_MASK_LAA_NFC_DEP ); 1019 } 1020 else 1021 { 1022 /* host can listen ISO-DEP based on AID routing */ 1023 listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask & NFA_DM_DISC_MASK_LA_ISO_DEP); 1024 1025 /* host can listen NFC-DEP based on protocol routing */ 1026 listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask & NFA_DM_DISC_MASK_LA_NFC_DEP); 1027 listen_mask |= (nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask & NFA_DM_DISC_MASK_LAA_NFC_DEP); 1028 } 1029 1030 /* NFC-B */ 1031 /* multiple hosts can listen ISO-DEP based on AID routing */ 1032 listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask 1033 & NFA_DM_DISC_MASK_LB_ISO_DEP; 1034 1035 /* NFC-F */ 1036 /* NFCC can support NFC-DEP and T3T listening based on NFCID routing regardless of NFC-F tech routing */ 1037 listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask 1038 & ( NFA_DM_DISC_MASK_LF_T3T 1039 |NFA_DM_DISC_MASK_LF_NFC_DEP 1040 |NFA_DM_DISC_MASK_LFA_NFC_DEP ); 1041 1042 /* NFC-B Prime */ 1043 if (nfa_dm_cb.disc_cb.entry[xx].host_id == nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_BP]) 1044 { 1045 listen_mask |= nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask 1046 & NFA_DM_DISC_MASK_L_B_PRIME; 1047 } 1048 1049 /* 1050 ** clear listen mode technolgies and protocols which are already used by others 1051 */ 1052 1053 /* Check if other modules are listening T1T or T2T */ 1054 if (dm_disc_mask & (NFA_DM_DISC_MASK_LA_T1T|NFA_DM_DISC_MASK_LA_T2T)) 1055 { 1056 listen_mask &= ~( NFA_DM_DISC_MASK_LA_T1T 1057 |NFA_DM_DISC_MASK_LA_T2T 1058 |NFA_DM_DISC_MASK_LA_ISO_DEP 1059 |NFA_DM_DISC_MASK_LA_NFC_DEP ); 1060 } 1061 1062 /* T1T/T2T has priority on NFC-A */ 1063 if ( (dm_disc_mask & (NFA_DM_DISC_MASK_LA_ISO_DEP|NFA_DM_DISC_MASK_LA_NFC_DEP)) 1064 &&(listen_mask & (NFA_DM_DISC_MASK_LA_T1T|NFA_DM_DISC_MASK_LA_T2T))) 1065 { 1066 dm_disc_mask &= ~( NFA_DM_DISC_MASK_LA_ISO_DEP 1067 |NFA_DM_DISC_MASK_LA_NFC_DEP ); 1068 } 1069 1070 /* Don't remove ISO-DEP because multiple hosts can listen ISO-DEP based on AID routing */ 1071 1072 /* Check if other modules are listening NFC-DEP */ 1073 if (dm_disc_mask & (NFA_DM_DISC_MASK_LA_NFC_DEP | NFA_DM_DISC_MASK_LAA_NFC_DEP)) 1074 { 1075 listen_mask &= ~( NFA_DM_DISC_MASK_LA_NFC_DEP 1076 |NFA_DM_DISC_MASK_LAA_NFC_DEP ); 1077 } 1078 1079 nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask = poll_mask | listen_mask; 1080 1081 NFA_TRACE_DEBUG2 ("nfa_dm_cb.disc_cb.entry[%d].selected_disc_mask = 0x%x", 1082 xx, nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask); 1083 1084 dm_disc_mask |= nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask; 1085 } 1086 } 1087 1088 /* Let P2P set GEN bytes for LLCP to NFCC */ 1089 if (dm_disc_mask & NFA_DM_DISC_MASK_NFC_DEP) 1090 { 1091 nfa_p2p_set_config (dm_disc_mask); 1092 } 1093 } 1094 1095 NFA_TRACE_DEBUG1 ("dm_disc_mask = 0x%x", dm_disc_mask); 1096 1097 /* Get Discovery Technology parameters */ 1098 num_params = nfa_dm_get_rf_discover_config (dm_disc_mask, disc_params, NFA_DM_MAX_DISC_PARAMS); 1099 1100 if (num_params) 1101 { 1102 /* 1103 ** NFCC will abort programming personality slots if not available. 1104 ** NFCC programs the personality slots in the following order of RF technologies: 1105 ** NFC-A, NFC-B, NFC-BP, NFC-I93 1106 */ 1107 1108 /* if this is not for exclusive control */ 1109 if (!nfa_dm_cb.disc_cb.excl_disc_entry.in_use) 1110 { 1111 /* update listening protocols in each NFC technology */ 1112 nfa_dm_set_rf_listen_mode_config (dm_disc_mask); 1113 } 1114 1115 /* Set polling duty cycle */ 1116 nfa_dm_set_total_duration (); 1117 nfa_dm_cb.disc_cb.dm_disc_mask = dm_disc_mask; 1118 1119 NFC_DiscoveryStart (num_params, disc_params, nfa_dm_disc_discovery_cback); 1120 /* set flag about waiting for response in IDLE state */ 1121 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP; 1122 1123 /* register callback to get interface error NTF */ 1124 NFC_SetStaticRfCback (nfa_dm_disc_data_cback); 1125 } 1126 else 1127 { 1128 /* RF discovery is started but there is no valid technology or protocol to discover */ 1129 nfa_dm_disc_notify_started (NFA_STATUS_OK); 1130 } 1131 1132 /* if Kovio presence check timer is running, timeout callback will reset the activation information */ 1133 if ( (nfa_dm_cb.disc_cb.activated_protocol != NFC_PROTOCOL_KOVIO) 1134 ||(!nfa_dm_cb.disc_cb.kovio_tle.in_use) ) 1135 { 1136 /* reset protocol and hanlde of activated sub-module */ 1137 nfa_dm_cb.disc_cb.activated_protocol = NFA_PROTOCOL_INVALID; 1138 nfa_dm_cb.disc_cb.activated_handle = NFA_HANDLE_INVALID; 1139 } 1140} 1141 1142/******************************************************************************* 1143** 1144** Function nfa_dm_notify_discovery 1145** 1146** Description Send RF discovery notification to upper layer 1147** 1148** Returns void 1149** 1150*******************************************************************************/ 1151static void nfa_dm_notify_discovery (tNFA_DM_RF_DISC_DATA *p_data) 1152{ 1153 tNFA_CONN_EVT_DATA conn_evt; 1154 1155 /* let application select a device */ 1156 conn_evt.disc_result.status = NFA_STATUS_OK; 1157 memcpy (&(conn_evt.disc_result.discovery_ntf), 1158 &(p_data->nfc_discover.result), 1159 sizeof (tNFC_RESULT_DEVT)); 1160 1161 nfa_dm_conn_cback_event_notify (NFA_DISC_RESULT_EVT, &conn_evt); 1162} 1163 1164 1165/******************************************************************************* 1166** 1167** Function nfa_dm_disc_handle_kovio_activation 1168** 1169** Description Handle Kovio activation; whether it's new or repeated activation 1170** 1171** Returns TRUE if repeated activation. No need to notify activated event to upper layer 1172** 1173*******************************************************************************/ 1174BOOLEAN nfa_dm_disc_handle_kovio_activation (tNFC_DISCOVER *p_data, tNFA_DISCOVER_CBACK *p_disc_cback) 1175{ 1176 tNFC_DISCOVER disc_data; 1177 1178 if (nfa_dm_cb.disc_cb.kovio_tle.in_use) 1179 { 1180 /* if this is new Kovio bar code tag */ 1181 if ( (nfa_dm_cb.activated_nfcid_len != p_data->activate.rf_tech_param.param.pk.uid_len) 1182 ||(memcmp (p_data->activate.rf_tech_param.param.pk.uid, 1183 nfa_dm_cb.activated_nfcid, nfa_dm_cb.activated_nfcid_len))) 1184 { 1185 NFA_TRACE_DEBUG0 ("new Kovio tag is detected"); 1186 1187 /* notify presence check failure for previous tag, if presence check is pending */ 1188 nfa_dm_disc_report_kovio_presence_check (NFA_STATUS_FAILED); 1189 1190 /* notify deactivation of previous activation before notifying new activation */ 1191 if (p_disc_cback) 1192 { 1193 disc_data.deactivate.type = NFA_DEACTIVATE_TYPE_IDLE; 1194 (*(p_disc_cback)) (NFA_DM_RF_DISC_DEACTIVATED_EVT, &disc_data); 1195 } 1196 1197 /* restart timer */ 1198 nfa_sys_start_timer (&nfa_dm_cb.disc_cb.kovio_tle, 0, NFA_DM_DISC_TIMEOUT_KOVIO_PRESENCE_CHECK); 1199 } 1200 else 1201 { 1202 /* notify presence check ok, if presence check is pending */ 1203 nfa_dm_disc_report_kovio_presence_check (NFC_STATUS_OK); 1204 1205 /* restart timer and do not notify upper layer */ 1206 nfa_sys_start_timer (&nfa_dm_cb.disc_cb.kovio_tle, 0, NFA_DM_DISC_TIMEOUT_KOVIO_PRESENCE_CHECK); 1207 return (TRUE); 1208 } 1209 } 1210 else 1211 { 1212 /* this is the first activation, so start timer and notify upper layer */ 1213 nfa_dm_cb.disc_cb.kovio_tle.p_cback = (TIMER_CBACK *)nfa_dm_disc_kovio_timeout_cback; 1214 nfa_sys_start_timer (&nfa_dm_cb.disc_cb.kovio_tle, 0, NFA_DM_DISC_TIMEOUT_KOVIO_PRESENCE_CHECK); 1215 } 1216 1217 return (FALSE); 1218} 1219 1220/******************************************************************************* 1221** 1222** Function nfa_dm_disc_notify_activation 1223** 1224** Description Send RF activation notification to sub-module 1225** 1226** Returns NFA_STATUS_OK if success 1227** 1228*******************************************************************************/ 1229static tNFA_STATUS nfa_dm_disc_notify_activation (tNFC_DISCOVER *p_data) 1230{ 1231 UINT8 xx, host_id_in_LRT; 1232 UINT8 iso_dep_t3t__listen = NFA_DM_DISC_NUM_ENTRIES; 1233 1234 tNFC_RF_TECH_N_MODE tech_n_mode = p_data->activate.rf_tech_param.mode; 1235 tNFC_PROTOCOL protocol = p_data->activate.protocol; 1236 1237 tNFA_DM_DISC_TECH_PROTO_MASK activated_disc_mask; 1238 1239 NFA_TRACE_DEBUG2 ("nfa_dm_disc_notify_activation (): tech_n_mode:0x%X, proto:0x%X", 1240 tech_n_mode, protocol); 1241 1242 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use) 1243 { 1244 nfa_dm_cb.disc_cb.activated_tech_mode = tech_n_mode; 1245 nfa_dm_cb.disc_cb.activated_rf_disc_id = p_data->activate.rf_disc_id; 1246 nfa_dm_cb.disc_cb.activated_rf_interface = p_data->activate.intf_param.type; 1247 nfa_dm_cb.disc_cb.activated_protocol = protocol; 1248 nfa_dm_cb.disc_cb.activated_handle = NFA_HANDLE_INVALID; 1249 1250 if (protocol == NFC_PROTOCOL_KOVIO) 1251 { 1252 /* check whether it's new or repeated activation */ 1253 if (nfa_dm_disc_handle_kovio_activation (p_data, nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) 1254 { 1255 /* do not notify activation of Kovio to upper layer */ 1256 return (NFA_STATUS_OK); 1257 } 1258 } 1259 1260 if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback) 1261 (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data); 1262 1263 return (NFA_STATUS_OK); 1264 } 1265 1266 /* if this is NFCEE direct RF interface, notify activation to whoever listening UICC */ 1267 if (p_data->activate.intf_param.type == NFC_INTERFACE_EE_DIRECT_RF) 1268 { 1269 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++) 1270 { 1271 if ( (nfa_dm_cb.disc_cb.entry[xx].in_use) 1272 &&(nfa_dm_cb.disc_cb.entry[xx].host_id != NFA_DM_DISC_HOST_ID_DH)) 1273 { 1274 nfa_dm_cb.disc_cb.activated_rf_disc_id = p_data->activate.rf_disc_id; 1275 nfa_dm_cb.disc_cb.activated_rf_interface = p_data->activate.intf_param.type; 1276 nfa_dm_cb.disc_cb.activated_protocol = NFC_PROTOCOL_UNKNOWN; 1277 nfa_dm_cb.disc_cb.activated_handle = xx; 1278 1279 NFA_TRACE_DEBUG2 ("activated_rf_interface:0x%x, activated_handle: 0x%x", 1280 nfa_dm_cb.disc_cb.activated_rf_interface, 1281 nfa_dm_cb.disc_cb.activated_handle); 1282 1283 if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback) 1284 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data); 1285 1286 return (NFA_STATUS_OK); 1287 } 1288 } 1289 return (NFA_STATUS_FAILED); 1290 } 1291 1292 /* get bit mask of technolgies/mode and protocol */ 1293 activated_disc_mask = nfa_dm_disc_get_disc_mask (tech_n_mode, protocol); 1294 1295 /* get host ID of technology from listen mode routing table */ 1296 if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_A) 1297 { 1298 host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_A]; 1299 } 1300 else if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_B) 1301 { 1302 host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_B]; 1303 } 1304 else if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_F) 1305 { 1306 host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_F]; 1307 } 1308 else if (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_B_PRIME) 1309 { 1310 host_id_in_LRT = nfa_dm_cb.disc_cb.listen_RT[NFA_DM_DISC_LRT_NFC_BP]; 1311 } 1312 else /* DH only */ 1313 { 1314 host_id_in_LRT = NFA_DM_DISC_HOST_ID_DH; 1315 } 1316 1317 if (protocol == NFC_PROTOCOL_NFC_DEP) 1318 { 1319 /* Force NFC-DEP to the host */ 1320 host_id_in_LRT = NFA_DM_DISC_HOST_ID_DH; 1321 } 1322 1323 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++) 1324 { 1325 /* if any matching NFC technology and protocol */ 1326 if (nfa_dm_cb.disc_cb.entry[xx].in_use) 1327 { 1328 if (nfa_dm_cb.disc_cb.entry[xx].host_id == host_id_in_LRT) 1329 { 1330 if (nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & activated_disc_mask) 1331 break; 1332 } 1333 else 1334 { 1335 /* check ISO-DEP listening even if host in LRT is not matched */ 1336 if (protocol == NFC_PROTOCOL_ISO_DEP) 1337 { 1338 if ( (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_A) 1339 &&(nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & NFA_DM_DISC_MASK_LA_ISO_DEP)) 1340 { 1341 iso_dep_t3t__listen = xx; 1342 } 1343 else if ( (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_B) 1344 &&(nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & NFA_DM_DISC_MASK_LB_ISO_DEP)) 1345 { 1346 iso_dep_t3t__listen = xx; 1347 } 1348 } 1349 /* check T3T listening even if host in LRT is not matched */ 1350 else if (protocol == NFC_PROTOCOL_T3T) 1351 { 1352 if ( (tech_n_mode == NFC_DISCOVERY_TYPE_LISTEN_F) 1353 &&(nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & NFA_DM_DISC_MASK_LF_T3T)) 1354 { 1355 iso_dep_t3t__listen = xx; 1356 } 1357 } 1358 } 1359 } 1360 } 1361 1362 if (xx >= NFA_DM_DISC_NUM_ENTRIES) 1363 { 1364 /* if any ISO-DEP or T3T listening even if host in LRT is not matched */ 1365 xx = iso_dep_t3t__listen; 1366 } 1367 1368 if (xx < NFA_DM_DISC_NUM_ENTRIES) 1369 { 1370 nfa_dm_cb.disc_cb.activated_tech_mode = tech_n_mode; 1371 nfa_dm_cb.disc_cb.activated_rf_disc_id = p_data->activate.rf_disc_id; 1372 nfa_dm_cb.disc_cb.activated_rf_interface = p_data->activate.intf_param.type; 1373 nfa_dm_cb.disc_cb.activated_protocol = protocol; 1374 nfa_dm_cb.disc_cb.activated_handle = xx; 1375 1376 NFA_TRACE_DEBUG2 ("activated_protocol:0x%x, activated_handle: 0x%x", 1377 nfa_dm_cb.disc_cb.activated_protocol, 1378 nfa_dm_cb.disc_cb.activated_handle); 1379 1380 if (protocol == NFC_PROTOCOL_KOVIO) 1381 { 1382 /* check whether it's new or repeated activation */ 1383 if (nfa_dm_disc_handle_kovio_activation (p_data, nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) 1384 { 1385 /* do not notify activation of Kovio to upper layer */ 1386 return (NFA_STATUS_OK); 1387 } 1388 } 1389 1390 if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback) 1391 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_ACTIVATED_EVT, p_data); 1392 1393 return (NFA_STATUS_OK); 1394 } 1395 else 1396 { 1397 nfa_dm_cb.disc_cb.activated_protocol = NFA_PROTOCOL_INVALID; 1398 nfa_dm_cb.disc_cb.activated_handle = NFA_HANDLE_INVALID; 1399 return (NFA_STATUS_FAILED); 1400 } 1401} 1402 1403/******************************************************************************* 1404** 1405** Function nfa_dm_disc_notify_deactivation 1406** 1407** Description Send deactivation notification to sub-module 1408** 1409** Returns None 1410** 1411*******************************************************************************/ 1412static void nfa_dm_disc_notify_deactivation (tNFA_DM_RF_DISC_SM_EVENT sm_event, 1413 tNFC_DISCOVER *p_data) 1414{ 1415 tNFA_HANDLE xx; 1416 tNFA_CONN_EVT_DATA evt_data; 1417 tNFC_DISCOVER disc_data; 1418 1419 NFA_TRACE_DEBUG1 ("nfa_dm_disc_notify_deactivation (): activated_handle=%d", 1420 nfa_dm_cb.disc_cb.activated_handle); 1421 1422 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING) 1423 { 1424 NFA_TRACE_DEBUG0 ("nfa_dm_disc_notify_deactivation (): for sleep wakeup"); 1425 return; 1426 } 1427 1428 if (sm_event == NFA_DM_RF_DEACTIVATE_RSP) 1429 { 1430 /* 1431 ** Activation has been aborted by upper layer in NFA_DM_RFST_W4_ALL_DISCOVERIES or NFA_DM_RFST_W4_HOST_SELECT 1432 ** Deactivation by upper layer or RF link loss in NFA_DM_RFST_LISTEN_SLEEP 1433 ** No sub-module is activated at this state. 1434 */ 1435 1436 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_LISTEN_SLEEP) 1437 { 1438 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use) 1439 { 1440 if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback) 1441 { 1442 disc_data.deactivate.type = NFA_DEACTIVATE_TYPE_IDLE; 1443 (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (NFA_DM_RF_DISC_DEACTIVATED_EVT, &disc_data); 1444 } 1445 } 1446 else 1447 { 1448 /* let each sub-module handle deactivation */ 1449 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++) 1450 { 1451 if ( (nfa_dm_cb.disc_cb.entry[xx].in_use) 1452 &&(nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask & NFA_DM_DISC_MASK_LISTEN) ) 1453 { 1454 disc_data.deactivate.type = NFA_DEACTIVATE_TYPE_IDLE; 1455 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_DEACTIVATED_EVT, &disc_data); 1456 } 1457 } 1458 } 1459 } 1460 else if ( (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_STOPPING)) 1461 ||(nfa_dm_cb.disc_cb.deact_notify_pending) ) 1462 { 1463 xx = nfa_dm_cb.disc_cb.activated_handle; 1464 1465 /* notify event to activated module if failed while reactivation */ 1466 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use) 1467 { 1468 if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback) 1469 { 1470 disc_data.deactivate.type = NFA_DEACTIVATE_TYPE_IDLE; 1471 (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (NFA_DM_RF_DISC_DEACTIVATED_EVT, p_data); 1472 } 1473 } 1474 else if ( (xx < NFA_DM_DISC_NUM_ENTRIES) 1475 &&(nfa_dm_cb.disc_cb.entry[xx].in_use) 1476 &&(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback) ) 1477 { 1478 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_DEACTIVATED_EVT, p_data); 1479 } 1480 else 1481 { 1482 /* notify deactivation to application if there is no activated module */ 1483 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE; 1484 nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data); 1485 } 1486 } 1487 } 1488 else 1489 { 1490 if (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_KOVIO) 1491 { 1492 if (nfa_dm_cb.disc_cb.kovio_tle.in_use) 1493 { 1494 /* restart timer and do not notify upper layer */ 1495 nfa_sys_start_timer (&nfa_dm_cb.disc_cb.kovio_tle, 0, NFA_DM_DISC_TIMEOUT_KOVIO_PRESENCE_CHECK); 1496 return; 1497 } 1498 /* Otherwise, upper layer initiated deactivation. */ 1499 } 1500 1501 /* notify event to activated module */ 1502 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use) 1503 { 1504 if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback) 1505 { 1506 disc_data.deactivate.type = NFA_DEACTIVATE_TYPE_IDLE; 1507 (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (NFA_DM_RF_DISC_DEACTIVATED_EVT, p_data); 1508 } 1509 } 1510 else 1511 { 1512 xx = nfa_dm_cb.disc_cb.activated_handle; 1513 1514 if ((xx < NFA_DM_DISC_NUM_ENTRIES) && (nfa_dm_cb.disc_cb.entry[xx].in_use)) 1515 { 1516 if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback) 1517 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_DEACTIVATED_EVT, p_data); 1518 } 1519 } 1520 } 1521 1522 /* clear activated information */ 1523 nfa_dm_cb.disc_cb.activated_tech_mode = 0; 1524 nfa_dm_cb.disc_cb.activated_rf_disc_id = 0; 1525 nfa_dm_cb.disc_cb.activated_rf_interface = 0; 1526 nfa_dm_cb.disc_cb.activated_protocol = NFA_PROTOCOL_INVALID; 1527 nfa_dm_cb.disc_cb.activated_handle = NFA_HANDLE_INVALID; 1528 nfa_dm_cb.disc_cb.deact_notify_pending = FALSE; 1529} 1530 1531/******************************************************************************* 1532** 1533** Function nfa_dm_disc_sleep_wakeup 1534** 1535** Description Put tag to sleep, then wake it up. Can be used Perform 1536** legacy presence check or to wake up tag that went to HALT 1537** state 1538** 1539** Returns TRUE if operation started 1540** 1541*******************************************************************************/ 1542tNFC_STATUS nfa_dm_disc_sleep_wakeup (void) 1543{ 1544 tNFC_STATUS status = NFC_STATUS_FAILED; 1545 1546 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE) 1547 { 1548 /* Deactivate to sleep mode */ 1549 status = nfa_dm_send_deactivate_cmd(NFC_DEACTIVATE_TYPE_SLEEP); 1550 if (status == NFC_STATUS_OK) 1551 { 1552 /* deactivate to sleep is sent on behalf of sleep wakeup. 1553 * set the sleep wakeup information in control block */ 1554 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_CHECKING; 1555 nfa_dm_cb.disc_cb.deact_pending = FALSE; 1556 } 1557 } 1558 1559 return (status); 1560} 1561 1562/******************************************************************************* 1563** 1564** Function nfa_dm_is_raw_frame_session 1565** 1566** Description If NFA_SendRawFrame is called since RF activation, 1567** this function returns TRUE. 1568** 1569** Returns TRUE if NFA_SendRawFrame is called 1570** 1571*******************************************************************************/ 1572BOOLEAN nfa_dm_is_raw_frame_session (void) 1573{ 1574 return ((nfa_dm_cb.flags & NFA_DM_FLAGS_RAW_FRAME) ? TRUE : FALSE); 1575} 1576 1577/******************************************************************************* 1578** 1579** Function nfa_dm_is_p2p_paused 1580** 1581** Description If NFA_PauseP2p is called sand still effective, 1582** this function returns TRUE. 1583** 1584** Returns TRUE if NFA_SendRawFrame is called 1585** 1586*******************************************************************************/ 1587BOOLEAN nfa_dm_is_p2p_paused (void) 1588{ 1589 return ((nfa_dm_cb.flags & NFA_DM_FLAGS_P2P_PAUSED) ? TRUE : FALSE); 1590} 1591 1592/******************************************************************************* 1593** 1594** Function nfa_dm_disc_end_sleep_wakeup 1595** 1596** Description Sleep Wakeup is complete 1597** 1598** Returns None 1599** 1600*******************************************************************************/ 1601static void nfa_dm_disc_end_sleep_wakeup (tNFC_STATUS status) 1602{ 1603 if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_KOVIO) 1604 &&(nfa_dm_cb.disc_cb.kovio_tle.in_use) ) 1605 { 1606 /* ignore it while doing Kovio presence check */ 1607 return; 1608 } 1609 1610 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING) 1611 { 1612 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_CHECKING; 1613 1614 /* notify RW module that sleep wakeup is finished */ 1615 nfa_rw_handle_sleep_wakeup_rsp (status); 1616 1617 if (nfa_dm_cb.disc_cb.deact_pending) 1618 { 1619 nfa_dm_cb.disc_cb.deact_pending = FALSE; 1620 /* Perform pending deactivate command and on response notfiy deactivation */ 1621 nfa_dm_cb.disc_cb.deact_notify_pending = TRUE; 1622 nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD, 1623 (tNFA_DM_RF_DISC_DATA *) &nfa_dm_cb.disc_cb.pending_deact_type); 1624 } 1625 } 1626} 1627 1628/******************************************************************************* 1629** 1630** Function nfa_dm_disc_kovio_timeout_cback 1631** 1632** Description Timeout for Kovio bar code tag presence check 1633** 1634** Returns void 1635** 1636*******************************************************************************/ 1637static void nfa_dm_disc_kovio_timeout_cback (TIMER_LIST_ENT *p_tle) 1638{ 1639 tNFC_DEACTIVATE_DEVT deact; 1640 1641 NFA_TRACE_DEBUG0 ("nfa_dm_disc_kovio_timeout_cback()"); 1642 1643 /* notify presence check failure, if presence check is pending */ 1644 nfa_dm_disc_report_kovio_presence_check (NFC_STATUS_FAILED); 1645 1646 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE) 1647 { 1648 /* restart timer in case that upper layer's presence check interval is too long */ 1649 nfa_sys_start_timer (&nfa_dm_cb.disc_cb.kovio_tle, 0, NFA_DM_DISC_TIMEOUT_KOVIO_PRESENCE_CHECK); 1650 } 1651 else 1652 { 1653 /* notify upper layer deactivated event */ 1654 deact.status = NFC_STATUS_OK; 1655 deact.type = NFC_DEACTIVATE_TYPE_DISCOVERY; 1656 deact.is_ntf = TRUE; 1657 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, (tNFC_DISCOVER*)&deact); 1658 } 1659} 1660 1661/******************************************************************************* 1662** 1663** Function nfa_dm_disc_start_kovio_presence_check 1664** 1665** Description Deactivate to discovery mode and wait for activation 1666** 1667** Returns TRUE if operation started 1668** 1669*******************************************************************************/ 1670tNFC_STATUS nfa_dm_disc_start_kovio_presence_check (void) 1671{ 1672 tNFC_STATUS status = NFC_STATUS_FAILED; 1673 1674 NFA_TRACE_DEBUG0 ("nfa_dm_disc_start_kovio_presence_check ()"); 1675 1676 if ( (nfa_dm_cb.disc_cb.activated_protocol == NFC_PROTOCOL_KOVIO) 1677 &&(nfa_dm_cb.disc_cb.kovio_tle.in_use) ) 1678 { 1679 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_POLL_ACTIVE) 1680 { 1681 /* restart timer */ 1682 nfa_sys_start_timer (&nfa_dm_cb.disc_cb.kovio_tle, 0, NFA_DM_DISC_TIMEOUT_KOVIO_PRESENCE_CHECK); 1683 1684 /* Deactivate to discovery mode */ 1685 status = nfa_dm_send_deactivate_cmd (NFC_DEACTIVATE_TYPE_DISCOVERY); 1686 1687 if (status == NFC_STATUS_OK) 1688 { 1689 /* deactivate to sleep is sent on behalf of sleep wakeup. 1690 * set the sleep wakeup information in control block */ 1691 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_CHECKING; 1692 nfa_dm_cb.disc_cb.deact_pending = FALSE; 1693 } 1694 } 1695 else 1696 { 1697 /* wait for next activation */ 1698 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_CHECKING; 1699 nfa_dm_cb.disc_cb.deact_pending = FALSE; 1700 status = NFC_STATUS_OK; 1701 } 1702 } 1703 1704 return (status); 1705} 1706 1707/******************************************************************************* 1708** 1709** Function nfa_dm_disc_report_kovio_presence_check 1710** 1711** Description Report Kovio presence check status 1712** 1713** Returns None 1714** 1715*******************************************************************************/ 1716static void nfa_dm_disc_report_kovio_presence_check (tNFC_STATUS status) 1717{ 1718 NFA_TRACE_DEBUG0 ("nfa_dm_disc_report_kovio_presence_check ()"); 1719 1720 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING) 1721 { 1722 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_CHECKING; 1723 1724 /* notify RW module that sleep wakeup is finished */ 1725 nfa_rw_handle_presence_check_rsp (status); 1726 1727 if (nfa_dm_cb.disc_cb.deact_pending) 1728 { 1729 nfa_dm_cb.disc_cb.deact_pending = FALSE; 1730 nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD, 1731 (tNFA_DM_RF_DISC_DATA *) &nfa_dm_cb.disc_cb.pending_deact_type); 1732 } 1733 } 1734} 1735 1736/******************************************************************************* 1737** 1738** Function nfa_dm_disc_data_cback 1739** 1740** Description Monitoring interface error through data callback 1741** 1742** Returns void 1743** 1744*******************************************************************************/ 1745static void nfa_dm_disc_data_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data) 1746{ 1747 NFA_TRACE_DEBUG0 ("nfa_dm_disc_data_cback ()"); 1748 1749 /* if selection failed */ 1750 if (event == NFC_ERROR_CEVT) 1751 { 1752 nfa_dm_disc_sm_execute (NFA_DM_CORE_INTF_ERROR_NTF, NULL); 1753 } 1754 else if (event == NFC_DATA_CEVT) 1755 { 1756 GKI_freebuf (p_data->data.p_data); 1757 } 1758} 1759 1760/******************************************************************************* 1761** 1762** Function nfa_dm_disc_new_state 1763** 1764** Description Processing discovery events in NFA_DM_RFST_IDLE state 1765** 1766** Returns void 1767** 1768*******************************************************************************/ 1769void nfa_dm_disc_new_state (tNFA_DM_RF_DISC_STATE new_state) 1770{ 1771 tNFA_CONN_EVT_DATA evt_data; 1772 tNFA_DM_RF_DISC_STATE old_state = nfa_dm_cb.disc_cb.disc_state; 1773 1774#if (BT_TRACE_VERBOSE == TRUE) 1775 NFA_TRACE_DEBUG5 ("nfa_dm_disc_new_state (): old_state: %s (%d), new_state: %s (%d) disc_flags: 0x%x", 1776 nfa_dm_disc_state_2_str (nfa_dm_cb.disc_cb.disc_state), nfa_dm_cb.disc_cb.disc_state, 1777 nfa_dm_disc_state_2_str (new_state), new_state, nfa_dm_cb.disc_cb.disc_flags); 1778#else 1779 NFA_TRACE_DEBUG3 ("nfa_dm_disc_new_state(): old_state: %d, new_state: %d disc_flags: 0x%x", 1780 nfa_dm_cb.disc_cb.disc_state, new_state, nfa_dm_cb.disc_cb.disc_flags); 1781#endif 1782 1783 nfa_dm_cb.disc_cb.disc_state = new_state; 1784 1785 if ( (new_state == NFA_DM_RFST_IDLE) 1786 &&(!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)) ) /* not error recovering */ 1787 { 1788 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_STOPPING) 1789 { 1790 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_STOPPING; 1791 1792 /* if exclusive RF control is stopping */ 1793 if (nfa_dm_cb.flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) 1794 { 1795 if (old_state > NFA_DM_RFST_DISCOVERY) 1796 { 1797 /* notify deactivation to application */ 1798 evt_data.deactivated.type = NFA_DEACTIVATE_TYPE_IDLE; 1799 nfa_dm_conn_cback_event_notify (NFA_DEACTIVATED_EVT, &evt_data); 1800 } 1801 1802 nfa_dm_rel_excl_rf_control_and_notify (); 1803 } 1804 else 1805 { 1806 evt_data.status = NFA_STATUS_OK; 1807 nfa_dm_conn_cback_event_notify (NFA_RF_DISCOVERY_STOPPED_EVT, &evt_data); 1808 } 1809 } 1810 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_DISABLING) 1811 { 1812 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_DISABLING; 1813 nfa_sys_check_disabled (); 1814 } 1815 } 1816} 1817 1818/******************************************************************************* 1819** 1820** Function nfa_dm_disc_sm_idle 1821** 1822** Description Processing discovery events in NFA_DM_RFST_IDLE state 1823** 1824** Returns void 1825** 1826*******************************************************************************/ 1827static void nfa_dm_disc_sm_idle (tNFA_DM_RF_DISC_SM_EVENT event, 1828 tNFA_DM_RF_DISC_DATA *p_data) 1829{ 1830 UINT8 xx; 1831 1832 switch (event) 1833 { 1834 case NFA_DM_RF_DISCOVER_CMD: 1835 nfa_dm_start_rf_discover (); 1836 break; 1837 1838 case NFA_DM_RF_DISCOVER_RSP: 1839 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 1840 1841 if (p_data->nfc_discover.status == NFC_STATUS_OK) 1842 { 1843 nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY); 1844 1845 /* if RF discovery was stopped while waiting for response */ 1846 if (nfa_dm_cb.disc_cb.disc_flags & (NFA_DM_DISC_FLAGS_STOPPING|NFA_DM_DISC_FLAGS_DISABLING)) 1847 { 1848 /* stop discovery */ 1849 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP; 1850 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 1851 break; 1852 } 1853 1854 if (nfa_dm_cb.disc_cb.excl_disc_entry.in_use) 1855 { 1856 if (nfa_dm_cb.disc_cb.excl_disc_entry.disc_flags & NFA_DM_DISC_FLAGS_NOTIFY) 1857 { 1858 nfa_dm_cb.disc_cb.excl_disc_entry.disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY; 1859 1860 if (nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback) 1861 (*(nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback)) (NFA_DM_RF_DISC_START_EVT, (tNFC_DISCOVER*) p_data); 1862 } 1863 } 1864 else 1865 { 1866 /* notify event to each module which is waiting for start */ 1867 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++) 1868 { 1869 /* if registered module is waiting for starting discovery */ 1870 if ( (nfa_dm_cb.disc_cb.entry[xx].in_use) 1871 &&(nfa_dm_cb.disc_cb.dm_disc_mask & nfa_dm_cb.disc_cb.entry[xx].selected_disc_mask) 1872 &&(nfa_dm_cb.disc_cb.entry[xx].disc_flags & NFA_DM_DISC_FLAGS_NOTIFY) ) 1873 { 1874 nfa_dm_cb.disc_cb.entry[xx].disc_flags &= ~NFA_DM_DISC_FLAGS_NOTIFY; 1875 1876 if (nfa_dm_cb.disc_cb.entry[xx].p_disc_cback) 1877 (*(nfa_dm_cb.disc_cb.entry[xx].p_disc_cback)) (NFA_DM_RF_DISC_START_EVT, (tNFC_DISCOVER*) p_data); 1878 } 1879 } 1880 1881 } 1882 nfa_dm_disc_notify_started (p_data->nfc_discover.status); 1883 } 1884 else 1885 { 1886 /* in rare case that the discovery states of NFCC and DH mismatch and NFCC rejects Discover Cmd 1887 * deactivate idle and then start disvocery when got deactivate rsp */ 1888 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP; 1889 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 1890 } 1891 break; 1892 1893 case NFA_DM_RF_DEACTIVATE_RSP: 1894 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 1895 1896 /* if NFCC goes to idle successfully */ 1897 if (p_data->nfc_discover.status == NFC_STATUS_OK) 1898 { 1899 /* if DH forced to go idle while waiting for deactivation NTF */ 1900 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF)) 1901 { 1902 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover)); 1903 1904 /* check any pending flags like NFA_DM_DISC_FLAGS_STOPPING or NFA_DM_DISC_FLAGS_DISABLING */ 1905 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 1906 /* check if need to restart discovery after resync discovery state with NFCC */ 1907 nfa_dm_start_rf_discover (); 1908 } 1909 /* Otherwise, deactivating when getting unexpected activation */ 1910 } 1911 /* Otherwise, wait for deactivation NTF */ 1912 break; 1913 1914 case NFA_DM_RF_DEACTIVATE_NTF: 1915 /* if NFCC sent this after NFCC had rejected deactivate CMD to idle while deactivating */ 1916 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF)) 1917 { 1918 if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY) 1919 { 1920 /* stop discovery */ 1921 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP; 1922 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 1923 } 1924 else 1925 { 1926 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover)); 1927 /* check any pending flags like NFA_DM_DISC_FLAGS_STOPPING or NFA_DM_DISC_FLAGS_DISABLING */ 1928 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 1929 /* check if need to restart discovery after resync discovery state with NFCC */ 1930 nfa_dm_start_rf_discover (); 1931 } 1932 } 1933 /* Otherwise, deactivated when received unexpected activation in idle state */ 1934 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF; 1935 break; 1936 1937 case NFA_DM_RF_INTF_ACTIVATED_NTF: 1938 /* unexpected activation, deactivate to idle */ 1939 nfa_dm_cb.disc_cb.disc_flags |= (NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF); 1940 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 1941 break; 1942 1943 case NFA_DM_LP_LISTEN_CMD: 1944 nfa_dm_disc_new_state (NFA_DM_RFST_LP_LISTEN); 1945 break; 1946 1947 default: 1948 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_idle (): Unexpected discovery event"); 1949 break; 1950 } 1951} 1952 1953/******************************************************************************* 1954** 1955** Function nfa_dm_disc_sm_discovery 1956** 1957** Description Processing discovery events in NFA_DM_RFST_DISCOVERY state 1958** 1959** Returns void 1960** 1961*******************************************************************************/ 1962static void nfa_dm_disc_sm_discovery (tNFA_DM_RF_DISC_SM_EVENT event, 1963 tNFA_DM_RF_DISC_DATA *p_data) 1964{ 1965 switch (event) 1966 { 1967 case NFA_DM_RF_DEACTIVATE_CMD: 1968 /* if deactivate CMD was not sent to NFCC */ 1969 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)) 1970 { 1971 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP; 1972 NFC_Deactivate (p_data->deactivate_type); 1973 } 1974 break; 1975 case NFA_DM_RF_DEACTIVATE_RSP: 1976 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 1977 1978 /* if it's not race condition between deactivate CMD and activate NTF */ 1979 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF)) 1980 { 1981 /* do not notify deactivated to idle in RF discovery state 1982 ** because it is internal or stopping RF discovery 1983 */ 1984 1985 /* there was no activation while waiting for deactivation RSP */ 1986 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 1987 nfa_dm_start_rf_discover (); 1988 } 1989 break; 1990 case NFA_DM_RF_DISCOVER_NTF: 1991 nfa_dm_disc_new_state (NFA_DM_RFST_W4_ALL_DISCOVERIES); 1992 nfa_dm_notify_discovery (p_data); 1993 break; 1994 case NFA_DM_RF_INTF_ACTIVATED_NTF: 1995 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP) 1996 { 1997 NFA_TRACE_DEBUG0 ("RF Activated while waiting for deactivation RSP"); 1998 /* it's race condition. DH has to wait for deactivation NTF */ 1999 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_NTF; 2000 } 2001 else 2002 { 2003 if (p_data->nfc_discover.activate.intf_param.type == NFC_INTERFACE_EE_DIRECT_RF) 2004 { 2005 nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_ACTIVE); 2006 } 2007 else if (p_data->nfc_discover.activate.rf_tech_param.mode & 0x80) 2008 { 2009 /* Listen mode */ 2010 nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_ACTIVE); 2011 } 2012 else 2013 { 2014 /* Poll mode */ 2015 nfa_dm_disc_new_state (NFA_DM_RFST_POLL_ACTIVE); 2016 } 2017 2018 if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED) 2019 { 2020 NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf"); 2021 2022 /* after receiving deactivate event, restart discovery */ 2023 nfa_dm_cb.disc_cb.disc_flags |= (NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF); 2024 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 2025 } 2026 } 2027 break; 2028 2029 case NFA_DM_RF_DEACTIVATE_NTF: 2030 /* if there was race condition between deactivate CMD and activate NTF */ 2031 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF) 2032 { 2033 /* race condition is resolved */ 2034 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF; 2035 2036 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)) 2037 { 2038 /* do not notify deactivated to idle in RF discovery state 2039 ** because it is internal or stopping RF discovery 2040 */ 2041 2042 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 2043 nfa_dm_start_rf_discover (); 2044 } 2045 } 2046 break; 2047 case NFA_DM_LP_LISTEN_CMD: 2048 break; 2049 case NFA_DM_CORE_INTF_ERROR_NTF: 2050 break; 2051 default: 2052 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_discovery (): Unexpected discovery event"); 2053 break; 2054 } 2055} 2056 2057/******************************************************************************* 2058** 2059** Function nfa_dm_disc_sm_w4_all_discoveries 2060** 2061** Description Processing discovery events in NFA_DM_RFST_W4_ALL_DISCOVERIES state 2062** 2063** Returns void 2064** 2065*******************************************************************************/ 2066static void nfa_dm_disc_sm_w4_all_discoveries (tNFA_DM_RF_DISC_SM_EVENT event, 2067 tNFA_DM_RF_DISC_DATA *p_data) 2068{ 2069 switch (event) 2070 { 2071 case NFA_DM_RF_DEACTIVATE_CMD: 2072 /* if deactivate CMD was not sent to NFCC */ 2073 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)) 2074 { 2075 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP; 2076 /* only IDLE mode is allowed */ 2077 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 2078 } 2079 break; 2080 case NFA_DM_RF_DEACTIVATE_RSP: 2081 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 2082 /* notify exiting from w4 all discoverie state */ 2083 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_RSP, &(p_data->nfc_discover)); 2084 2085 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 2086 nfa_dm_start_rf_discover (); 2087 break; 2088 case NFA_DM_RF_DISCOVER_NTF: 2089 /* if deactivate CMD is already sent then ignore discover NTF */ 2090 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)) 2091 { 2092 /* Notification Type = NCI_DISCOVER_NTF_LAST or NCI_DISCOVER_NTF_LAST_ABORT */ 2093 if (p_data->nfc_discover.result.more != NCI_DISCOVER_NTF_MORE) 2094 { 2095 nfa_dm_disc_new_state (NFA_DM_RFST_W4_HOST_SELECT); 2096 } 2097 nfa_dm_notify_discovery (p_data); 2098 } 2099 break; 2100 case NFA_DM_RF_INTF_ACTIVATED_NTF: 2101 /* 2102 ** This is only for ISO15693. 2103 ** FW sends activation NTF when all responses are received from tags without host selecting. 2104 */ 2105 nfa_dm_disc_new_state (NFA_DM_RFST_POLL_ACTIVE); 2106 2107 if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED) 2108 { 2109 NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf"); 2110 2111 /* after receiving deactivate event, restart discovery */ 2112 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 2113 } 2114 break; 2115 default: 2116 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_w4_all_discoveries (): Unexpected discovery event"); 2117 break; 2118 } 2119} 2120 2121/******************************************************************************* 2122** 2123** Function nfa_dm_disc_sm_w4_host_select 2124** 2125** Description Processing discovery events in NFA_DM_RFST_W4_HOST_SELECT state 2126** 2127** Returns void 2128** 2129*******************************************************************************/ 2130static void nfa_dm_disc_sm_w4_host_select (tNFA_DM_RF_DISC_SM_EVENT event, 2131 tNFA_DM_RF_DISC_DATA *p_data) 2132{ 2133 tNFA_CONN_EVT_DATA conn_evt; 2134 tNFA_DM_DISC_FLAGS old_sleep_wakeup_flag = (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING); 2135 BOOLEAN sleep_wakeup_event = FALSE; 2136 BOOLEAN sleep_wakeup_event_processed = FALSE; 2137 tNFA_STATUS status; 2138 2139 switch (event) 2140 { 2141 case NFA_DM_RF_DISCOVER_SELECT_CMD: 2142 /* if not waiting to deactivate */ 2143 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)) 2144 { 2145 NFC_DiscoverySelect (p_data->select.rf_disc_id, 2146 p_data->select.protocol, 2147 p_data->select.rf_interface); 2148 } 2149 else 2150 { 2151 nfa_dm_disc_conn_event_notify (NFA_SELECT_RESULT_EVT, NFA_STATUS_FAILED); 2152 } 2153 break; 2154 2155 case NFA_DM_RF_DISCOVER_SELECT_RSP: 2156 sleep_wakeup_event = TRUE; 2157 /* notify application status of selection */ 2158 if (p_data->nfc_discover.status == NFC_STATUS_OK) 2159 { 2160 sleep_wakeup_event_processed = TRUE; 2161 conn_evt.status = NFA_STATUS_OK; 2162 /* register callback to get interface error NTF */ 2163 NFC_SetStaticRfCback (nfa_dm_disc_data_cback); 2164 } 2165 else 2166 conn_evt.status = NFA_STATUS_FAILED; 2167 2168 if (!old_sleep_wakeup_flag) 2169 { 2170 nfa_dm_disc_conn_event_notify (NFA_SELECT_RESULT_EVT, p_data->nfc_discover.status); 2171 } 2172 break; 2173 case NFA_DM_RF_INTF_ACTIVATED_NTF: 2174 nfa_dm_disc_new_state (NFA_DM_RFST_POLL_ACTIVE); 2175 /* always call nfa_dm_disc_notify_activation to update protocol/interface information in NFA control blocks */ 2176 status = nfa_dm_disc_notify_activation (&(p_data->nfc_discover)); 2177 if (old_sleep_wakeup_flag) 2178 { 2179 /* Handle sleep wakeup success: notify RW module of sleep wakeup of tag; if deactivation is pending then deactivate */ 2180 nfa_dm_disc_end_sleep_wakeup (NFC_STATUS_OK); 2181 } 2182 else if (status == NFA_STATUS_FAILED) 2183 { 2184 NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf"); 2185 2186 /* after receiving deactivate event, restart discovery */ 2187 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 2188 } 2189 break; 2190 case NFA_DM_RF_DEACTIVATE_CMD: 2191 if (old_sleep_wakeup_flag) 2192 { 2193 nfa_dm_cb.disc_cb.deact_pending = TRUE; 2194 nfa_dm_cb.disc_cb.pending_deact_type = p_data->deactivate_type; 2195 } 2196 /* if deactivate CMD was not sent to NFCC */ 2197 else if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP)) 2198 { 2199 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_W4_RSP; 2200 /* only IDLE mode is allowed */ 2201 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 2202 } 2203 break; 2204 case NFA_DM_RF_DEACTIVATE_RSP: 2205 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 2206 /* notify exiting from host select state */ 2207 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_RSP, &(p_data->nfc_discover)); 2208 2209 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 2210 nfa_dm_start_rf_discover (); 2211 break; 2212 2213 case NFA_DM_CORE_INTF_ERROR_NTF: 2214 sleep_wakeup_event = TRUE; 2215 if (!old_sleep_wakeup_flag) 2216 { 2217 /* target activation failed, upper layer may deactivate or select again */ 2218 conn_evt.status = NFA_STATUS_FAILED; 2219 nfa_dm_conn_cback_event_notify (NFA_SELECT_RESULT_EVT, &conn_evt); 2220 } 2221 break; 2222 default: 2223 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_w4_host_select (): Unexpected discovery event"); 2224 break; 2225 } 2226 2227 if (old_sleep_wakeup_flag && sleep_wakeup_event && !sleep_wakeup_event_processed) 2228 { 2229 /* performing sleep wakeup and exception conditions happened 2230 * clear sleep wakeup information and report failure */ 2231 nfa_dm_disc_end_sleep_wakeup (NFC_STATUS_FAILED); 2232 } 2233} 2234 2235/******************************************************************************* 2236** 2237** Function nfa_dm_disc_sm_poll_active 2238** 2239** Description Processing discovery events in NFA_DM_RFST_POLL_ACTIVE state 2240** 2241** Returns void 2242** 2243*******************************************************************************/ 2244static void nfa_dm_disc_sm_poll_active (tNFA_DM_RF_DISC_SM_EVENT event, 2245 tNFA_DM_RF_DISC_DATA *p_data) 2246{ 2247 tNFC_STATUS status; 2248 tNFA_DM_DISC_FLAGS old_sleep_wakeup_flag = (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_CHECKING); 2249 BOOLEAN sleep_wakeup_event = FALSE; 2250 BOOLEAN sleep_wakeup_event_processed = FALSE; 2251 tNFC_DEACTIVATE_DEVT deact; 2252 2253 switch (event) 2254 { 2255 case NFA_DM_RF_DEACTIVATE_CMD: 2256 if (nfa_dm_cb.disc_cb.activated_protocol == NCI_PROTOCOL_MIFARE) 2257 { 2258 nfa_dm_cb.disc_cb.deact_pending = TRUE; 2259 nfa_dm_cb.disc_cb.pending_deact_type = p_data->deactivate_type; 2260 status = nfa_dm_send_deactivate_cmd (p_data->deactivate_type); 2261 break; 2262 } 2263 2264 if (old_sleep_wakeup_flag) 2265 { 2266 /* sleep wakeup is already enabled when deactivate cmd is requested, 2267 * keep the information in control block to issue it later */ 2268 nfa_dm_cb.disc_cb.deact_pending = TRUE; 2269 nfa_dm_cb.disc_cb.pending_deact_type = p_data->deactivate_type; 2270 } 2271 else 2272 { 2273 status = nfa_dm_send_deactivate_cmd(p_data->deactivate_type); 2274 } 2275 2276 break; 2277 case NFA_DM_RF_DEACTIVATE_RSP: 2278 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 2279 /* register callback to get interface error NTF */ 2280 NFC_SetStaticRfCback (nfa_dm_disc_data_cback); 2281 2282 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF)) 2283 { 2284 /* it's race condition. received deactivate NTF before receiving RSP */ 2285 2286 deact.status = NFC_STATUS_OK; 2287 deact.type = NFC_DEACTIVATE_TYPE_IDLE; 2288 deact.is_ntf = TRUE; 2289 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, (tNFC_DISCOVER*)&deact); 2290 2291 /* NFCC is in IDLE state */ 2292 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 2293 nfa_dm_start_rf_discover (); 2294 } 2295 break; 2296 case NFA_DM_RF_DEACTIVATE_NTF: 2297 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF; 2298 2299 nfa_sys_stop_timer (&nfa_dm_cb.disc_cb.tle); 2300 2301 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP) 2302 { 2303 /* it's race condition. received deactivate NTF before receiving RSP */ 2304 /* notify deactivation after receiving deactivate RSP */ 2305 NFA_TRACE_DEBUG0 ("Rx deactivate NTF while waiting for deactivate RSP"); 2306 break; 2307 } 2308 2309 sleep_wakeup_event = TRUE; 2310 2311 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover)); 2312 2313 if ( (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) 2314 ||(p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF) ) 2315 { 2316 nfa_dm_disc_new_state (NFA_DM_RFST_W4_HOST_SELECT); 2317 if (old_sleep_wakeup_flag) 2318 { 2319 sleep_wakeup_event_processed = TRUE; 2320 /* process pending deactivate request */ 2321 if (nfa_dm_cb.disc_cb.deact_pending) 2322 { 2323 /* notify RW module that sleep wakeup is finished */ 2324 /* if deactivation is pending then deactivate */ 2325 nfa_dm_disc_end_sleep_wakeup (NFC_STATUS_OK); 2326 2327 /* Notify NFA RW sub-systems because NFA_DM_RF_DEACTIVATE_RSP will not call this function */ 2328 nfa_rw_proc_disc_evt (NFA_DM_RF_DISC_DEACTIVATED_EVT, NULL, TRUE); 2329 } 2330 else 2331 { 2332 /* Successfully went to sleep mode for sleep wakeup */ 2333 /* Now wake up the tag to complete the operation */ 2334 NFC_DiscoverySelect (nfa_dm_cb.disc_cb.activated_rf_disc_id, 2335 nfa_dm_cb.disc_cb.activated_protocol, 2336 nfa_dm_cb.disc_cb.activated_rf_interface); 2337 } 2338 2339 } 2340 } 2341 else if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) 2342 { 2343 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 2344 nfa_dm_start_rf_discover (); 2345 } 2346 else if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY) 2347 { 2348 nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY); 2349 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_STOPPING) 2350 { 2351 /* stop discovery */ 2352 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 2353 } 2354 } 2355 break; 2356 2357 case NFA_DM_CORE_INTF_ERROR_NTF: 2358 sleep_wakeup_event = TRUE; 2359 if ( (!old_sleep_wakeup_flag) 2360 ||(!nfa_dm_cb.disc_cb.deact_pending) ) 2361 { 2362 nfa_dm_send_deactivate_cmd (NFA_DEACTIVATE_TYPE_DISCOVERY); 2363 } 2364 break; 2365 2366 default: 2367 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_poll_active (): Unexpected discovery event"); 2368 break; 2369 } 2370 2371 if (old_sleep_wakeup_flag && sleep_wakeup_event && !sleep_wakeup_event_processed) 2372 { 2373 /* performing sleep wakeup and exception conditions happened 2374 * clear sleep wakeup information and report failure */ 2375 nfa_dm_disc_end_sleep_wakeup (NFC_STATUS_FAILED); 2376 } 2377} 2378 2379/******************************************************************************* 2380** 2381** Function nfa_dm_disc_sm_listen_active 2382** 2383** Description Processing discovery events in NFA_DM_RFST_LISTEN_ACTIVE state 2384** 2385** Returns void 2386** 2387*******************************************************************************/ 2388static void nfa_dm_disc_sm_listen_active (tNFA_DM_RF_DISC_SM_EVENT event, 2389 tNFA_DM_RF_DISC_DATA *p_data) 2390{ 2391 tNFC_DEACTIVATE_DEVT deact; 2392 2393 switch (event) 2394 { 2395 case NFA_DM_RF_DEACTIVATE_CMD: 2396 nfa_dm_send_deactivate_cmd(p_data->deactivate_type); 2397 break; 2398 case NFA_DM_RF_DEACTIVATE_RSP: 2399 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 2400 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF)) 2401 { 2402 /* it's race condition. received deactivate NTF before receiving RSP */ 2403 2404 deact.status = NFC_STATUS_OK; 2405 deact.type = NFC_DEACTIVATE_TYPE_IDLE; 2406 deact.is_ntf = TRUE; 2407 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, (tNFC_DISCOVER*)&deact); 2408 2409 /* NFCC is in IDLE state */ 2410 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 2411 nfa_dm_start_rf_discover (); 2412 } 2413 break; 2414 case NFA_DM_RF_DEACTIVATE_NTF: 2415 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF; 2416 2417 nfa_sys_stop_timer (&nfa_dm_cb.disc_cb.tle); 2418 2419 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_RSP) 2420 { 2421 /* it's race condition. received deactivate NTF before receiving RSP */ 2422 /* notify deactivation after receiving deactivate RSP */ 2423 NFA_TRACE_DEBUG0 ("Rx deactivate NTF while waiting for deactivate RSP"); 2424 } 2425 else 2426 { 2427 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover)); 2428 2429 if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) 2430 { 2431 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 2432 nfa_dm_start_rf_discover (); 2433 } 2434 else if ( (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP) 2435 ||(p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_SLEEP_AF) ) 2436 { 2437 nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_SLEEP); 2438 } 2439 else if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_DISCOVERY) 2440 { 2441 /* Discovery */ 2442 nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY); 2443 if (nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_STOPPING) 2444 { 2445 /* stop discovery */ 2446 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 2447 } 2448 } 2449 } 2450 break; 2451 2452 case NFA_DM_CORE_INTF_ERROR_NTF: 2453 break; 2454 default: 2455 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_listen_active (): Unexpected discovery event"); 2456 break; 2457 } 2458} 2459 2460/******************************************************************************* 2461** 2462** Function nfa_dm_disc_sm_listen_sleep 2463** 2464** Description Processing discovery events in NFA_DM_RFST_LISTEN_SLEEP state 2465** 2466** Returns void 2467** 2468*******************************************************************************/ 2469static void nfa_dm_disc_sm_listen_sleep (tNFA_DM_RF_DISC_SM_EVENT event, 2470 tNFA_DM_RF_DISC_DATA *p_data) 2471{ 2472 switch (event) 2473 { 2474 case NFA_DM_RF_DEACTIVATE_CMD: 2475 nfa_dm_send_deactivate_cmd (p_data->deactivate_type); 2476 2477 /* if deactivate type is not discovery then NFCC will not sent deactivation NTF */ 2478 if (p_data->deactivate_type != NFA_DEACTIVATE_TYPE_DISCOVERY) 2479 { 2480 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_NTF; 2481 nfa_sys_stop_timer (&nfa_dm_cb.disc_cb.tle); 2482 } 2483 break; 2484 case NFA_DM_RF_DEACTIVATE_RSP: 2485 nfa_dm_cb.disc_cb.disc_flags &= ~NFA_DM_DISC_FLAGS_W4_RSP; 2486 /* if deactivate type in CMD was IDLE */ 2487 if (!(nfa_dm_cb.disc_cb.disc_flags & NFA_DM_DISC_FLAGS_W4_NTF)) 2488 { 2489 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_RSP, &(p_data->nfc_discover)); 2490 2491 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 2492 nfa_dm_start_rf_discover (); 2493 } 2494 break; 2495 case NFA_DM_RF_DEACTIVATE_NTF: 2496 /* clear both W4_RSP and W4_NTF because of race condition between deactivat CMD and link loss */ 2497 nfa_dm_cb.disc_cb.disc_flags &= ~(NFA_DM_DISC_FLAGS_W4_RSP|NFA_DM_DISC_FLAGS_W4_NTF); 2498 nfa_sys_stop_timer (&nfa_dm_cb.disc_cb.tle); 2499 2500 /* there is no active protocol in this state, so broadcast to all by using NFA_DM_RF_DEACTIVATE_RSP */ 2501 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_RSP, &(p_data->nfc_discover)); 2502 2503 if (p_data->nfc_discover.deactivate.type == NFC_DEACTIVATE_TYPE_IDLE) 2504 { 2505 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 2506 nfa_dm_start_rf_discover (); 2507 } 2508 else if (p_data->nfc_discover.deactivate.type == NFA_DEACTIVATE_TYPE_DISCOVERY) 2509 { 2510 nfa_dm_disc_new_state (NFA_DM_RFST_DISCOVERY); 2511 } 2512 else 2513 { 2514 NFA_TRACE_ERROR0 ("Unexpected deactivation type"); 2515 nfa_dm_disc_new_state (NFA_DM_RFST_IDLE); 2516 nfa_dm_start_rf_discover (); 2517 } 2518 break; 2519 case NFA_DM_RF_INTF_ACTIVATED_NTF: 2520 nfa_dm_disc_new_state (NFA_DM_RFST_LISTEN_ACTIVE); 2521 if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED) 2522 { 2523 NFA_TRACE_DEBUG0 ("Not matched, restart discovery after receiving deactivate ntf"); 2524 2525 /* after receiving deactivate event, restart discovery */ 2526 NFC_Deactivate (NFA_DEACTIVATE_TYPE_IDLE); 2527 } 2528 break; 2529 default: 2530 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_listen_sleep (): Unexpected discovery event"); 2531 break; 2532 } 2533} 2534 2535/******************************************************************************* 2536** 2537** Function nfa_dm_disc_sm_lp_listen 2538** 2539** Description Processing discovery events in NFA_DM_RFST_LP_LISTEN state 2540** 2541** Returns void 2542** 2543*******************************************************************************/ 2544static void nfa_dm_disc_sm_lp_listen (tNFA_DM_RF_DISC_SM_EVENT event, 2545 tNFA_DM_RF_DISC_DATA *p_data) 2546{ 2547 switch (event) 2548 { 2549 case NFA_DM_RF_INTF_ACTIVATED_NTF: 2550 nfa_dm_disc_new_state (NFA_DM_RFST_LP_ACTIVE); 2551 nfa_dm_disc_notify_activation (&(p_data->nfc_discover)); 2552 if (nfa_dm_disc_notify_activation (&(p_data->nfc_discover)) == NFA_STATUS_FAILED) 2553 { 2554 NFA_TRACE_DEBUG0 ("Not matched, unexpected activation"); 2555 } 2556 break; 2557 2558 default: 2559 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_lp_listen (): Unexpected discovery event"); 2560 break; 2561 } 2562} 2563 2564/******************************************************************************* 2565** 2566** Function nfa_dm_disc_sm_lp_active 2567** 2568** Description Processing discovery events in NFA_DM_RFST_LP_ACTIVE state 2569** 2570** Returns void 2571** 2572*******************************************************************************/ 2573static void nfa_dm_disc_sm_lp_active (tNFA_DM_RF_DISC_SM_EVENT event, 2574 tNFA_DM_RF_DISC_DATA *p_data) 2575{ 2576 switch (event) 2577 { 2578 case NFA_DM_RF_DEACTIVATE_NTF: 2579 nfa_dm_disc_new_state (NFA_DM_RFST_LP_LISTEN); 2580 nfa_dm_disc_notify_deactivation (NFA_DM_RF_DEACTIVATE_NTF, &(p_data->nfc_discover)); 2581 break; 2582 default: 2583 NFA_TRACE_ERROR0 ("nfa_dm_disc_sm_lp_active (): Unexpected discovery event"); 2584 break; 2585 } 2586} 2587 2588/******************************************************************************* 2589** 2590** Function nfa_dm_disc_sm_execute 2591** 2592** Description Processing discovery related events 2593** 2594** Returns void 2595** 2596*******************************************************************************/ 2597void nfa_dm_disc_sm_execute (tNFA_DM_RF_DISC_SM_EVENT event, tNFA_DM_RF_DISC_DATA *p_data) 2598{ 2599#if (BT_TRACE_VERBOSE == TRUE) 2600 NFA_TRACE_DEBUG5 ("nfa_dm_disc_sm_execute (): state: %s (%d), event: %s(%d) disc_flags: 0x%x", 2601 nfa_dm_disc_state_2_str (nfa_dm_cb.disc_cb.disc_state), nfa_dm_cb.disc_cb.disc_state, 2602 nfa_dm_disc_event_2_str (event), event, nfa_dm_cb.disc_cb.disc_flags); 2603#else 2604 NFA_TRACE_DEBUG3 ("nfa_dm_disc_sm_execute(): state: %d, event:%d disc_flags: 0x%x", 2605 nfa_dm_cb.disc_cb.disc_state, event, nfa_dm_cb.disc_cb.disc_flags); 2606#endif 2607 2608 switch (nfa_dm_cb.disc_cb.disc_state) 2609 { 2610 /* RF Discovery State - Idle */ 2611 case NFA_DM_RFST_IDLE: 2612 nfa_dm_disc_sm_idle (event, p_data); 2613 break; 2614 2615 /* RF Discovery State - Discovery */ 2616 case NFA_DM_RFST_DISCOVERY: 2617 nfa_dm_disc_sm_discovery (event, p_data); 2618 break; 2619 2620 /*RF Discovery State - Wait for all discoveries */ 2621 case NFA_DM_RFST_W4_ALL_DISCOVERIES: 2622 nfa_dm_disc_sm_w4_all_discoveries (event, p_data); 2623 break; 2624 2625 /* RF Discovery State - Wait for host selection */ 2626 case NFA_DM_RFST_W4_HOST_SELECT: 2627 nfa_dm_disc_sm_w4_host_select (event, p_data); 2628 break; 2629 2630 /* RF Discovery State - Poll mode activated */ 2631 case NFA_DM_RFST_POLL_ACTIVE: 2632 nfa_dm_disc_sm_poll_active (event, p_data); 2633 break; 2634 2635 /* RF Discovery State - listen mode activated */ 2636 case NFA_DM_RFST_LISTEN_ACTIVE: 2637 nfa_dm_disc_sm_listen_active (event, p_data); 2638 break; 2639 2640 /* RF Discovery State - listen mode sleep */ 2641 case NFA_DM_RFST_LISTEN_SLEEP: 2642 nfa_dm_disc_sm_listen_sleep (event, p_data); 2643 break; 2644 2645 /* Listening in Low Power mode */ 2646 case NFA_DM_RFST_LP_LISTEN: 2647 nfa_dm_disc_sm_lp_listen (event, p_data); 2648 break; 2649 2650 /* Activated in Low Power mode */ 2651 case NFA_DM_RFST_LP_ACTIVE: 2652 nfa_dm_disc_sm_lp_active (event, p_data); 2653 break; 2654 } 2655#if (BT_TRACE_VERBOSE == TRUE) 2656 NFA_TRACE_DEBUG3 ("nfa_dm_disc_sm_execute (): new state: %s (%d), disc_flags: 0x%x", 2657 nfa_dm_disc_state_2_str (nfa_dm_cb.disc_cb.disc_state), nfa_dm_cb.disc_cb.disc_state, 2658 nfa_dm_cb.disc_cb.disc_flags); 2659#else 2660 NFA_TRACE_DEBUG2 ("nfa_dm_disc_sm_execute(): new state: %d, disc_flags: 0x%x", 2661 nfa_dm_cb.disc_cb.disc_state, nfa_dm_cb.disc_cb.disc_flags); 2662#endif 2663} 2664 2665/******************************************************************************* 2666** 2667** Function nfa_dm_add_rf_discover 2668** 2669** Description Add discovery configuration and callback function 2670** 2671** Returns valid handle if success 2672** 2673*******************************************************************************/ 2674tNFA_HANDLE nfa_dm_add_rf_discover (tNFA_DM_DISC_TECH_PROTO_MASK disc_mask, 2675 tNFA_DM_DISC_HOST_ID host_id, 2676 tNFA_DISCOVER_CBACK *p_disc_cback) 2677{ 2678 UINT8 xx; 2679 2680 NFA_TRACE_DEBUG1 ("nfa_dm_add_rf_discover () disc_mask=0x%x", disc_mask); 2681 2682 for (xx = 0; xx < NFA_DM_DISC_NUM_ENTRIES; xx++) 2683 { 2684 if (!nfa_dm_cb.disc_cb.entry[xx].in_use) 2685 { 2686 nfa_dm_cb.disc_cb.entry[xx].in_use = TRUE; 2687 nfa_dm_cb.disc_cb.entry[xx].requested_disc_mask = disc_mask; 2688 nfa_dm_cb.disc_cb.entry[xx].host_id = host_id; 2689 nfa_dm_cb.disc_cb.entry[xx].p_disc_cback = p_disc_cback; 2690 nfa_dm_cb.disc_cb.entry[xx].disc_flags = NFA_DM_DISC_FLAGS_NOTIFY; 2691 return xx; 2692 } 2693 } 2694 2695 return NFA_HANDLE_INVALID; 2696} 2697 2698/******************************************************************************* 2699** 2700** Function nfa_dm_start_excl_discovery 2701** 2702** Description Start exclusive RF discovery 2703** 2704** Returns void 2705** 2706*******************************************************************************/ 2707void nfa_dm_start_excl_discovery (tNFA_TECHNOLOGY_MASK poll_tech_mask, 2708 tNFA_LISTEN_CFG *p_listen_cfg, 2709 tNFA_DISCOVER_CBACK *p_disc_cback) 2710{ 2711 tNFA_DM_DISC_TECH_PROTO_MASK poll_disc_mask = 0; 2712 2713 NFA_TRACE_DEBUG0 ("nfa_dm_start_excl_discovery ()"); 2714 2715 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A) 2716 { 2717 poll_disc_mask |= NFA_DM_DISC_MASK_PA_T1T; 2718 poll_disc_mask |= NFA_DM_DISC_MASK_PA_T2T; 2719 poll_disc_mask |= NFA_DM_DISC_MASK_PA_ISO_DEP; 2720 poll_disc_mask |= NFA_DM_DISC_MASK_PA_NFC_DEP; 2721 poll_disc_mask |= NFA_DM_DISC_MASK_P_LEGACY; 2722 } 2723 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_A_ACTIVE) 2724 { 2725 poll_disc_mask |= NFA_DM_DISC_MASK_PAA_NFC_DEP; 2726 } 2727 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B) 2728 { 2729 poll_disc_mask |= NFA_DM_DISC_MASK_PB_ISO_DEP; 2730 } 2731 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F) 2732 { 2733 poll_disc_mask |= NFA_DM_DISC_MASK_PF_T3T; 2734 poll_disc_mask |= NFA_DM_DISC_MASK_PF_NFC_DEP; 2735 } 2736 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_F_ACTIVE) 2737 { 2738 poll_disc_mask |= NFA_DM_DISC_MASK_PFA_NFC_DEP; 2739 } 2740 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_ISO15693) 2741 { 2742 poll_disc_mask |= NFA_DM_DISC_MASK_P_ISO15693; 2743 } 2744 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_B_PRIME) 2745 { 2746 poll_disc_mask |= NFA_DM_DISC_MASK_P_B_PRIME; 2747 } 2748 if (poll_tech_mask & NFA_TECHNOLOGY_MASK_KOVIO) 2749 { 2750 poll_disc_mask |= NFA_DM_DISC_MASK_P_KOVIO; 2751 } 2752 2753 nfa_dm_cb.disc_cb.excl_disc_entry.in_use = TRUE; 2754 nfa_dm_cb.disc_cb.excl_disc_entry.requested_disc_mask = poll_disc_mask; 2755 nfa_dm_cb.disc_cb.excl_disc_entry.host_id = NFA_DM_DISC_HOST_ID_DH; 2756 nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback = p_disc_cback; 2757 nfa_dm_cb.disc_cb.excl_disc_entry.disc_flags = NFA_DM_DISC_FLAGS_NOTIFY; 2758 2759 memcpy (&nfa_dm_cb.disc_cb.excl_listen_config, p_listen_cfg, sizeof (tNFA_LISTEN_CFG)); 2760 2761 nfa_dm_disc_sm_execute (NFA_DM_RF_DISCOVER_CMD, NULL); 2762} 2763 2764/******************************************************************************* 2765** 2766** Function nfa_dm_stop_excl_discovery 2767** 2768** Description Stop exclusive RF discovery 2769** 2770** Returns void 2771** 2772*******************************************************************************/ 2773void nfa_dm_stop_excl_discovery (void) 2774{ 2775 NFA_TRACE_DEBUG0 ("nfa_dm_stop_excl_discovery ()"); 2776 2777 nfa_dm_cb.disc_cb.excl_disc_entry.in_use = FALSE; 2778 nfa_dm_cb.disc_cb.excl_disc_entry.p_disc_cback = NULL; 2779} 2780 2781/******************************************************************************* 2782** 2783** Function nfa_dm_delete_rf_discover 2784** 2785** Description Remove discovery configuration and callback function 2786** 2787** Returns void 2788** 2789*******************************************************************************/ 2790void nfa_dm_delete_rf_discover (tNFA_HANDLE handle) 2791{ 2792 NFA_TRACE_DEBUG1 ("nfa_dm_delete_rf_discover () handle=0x%x", handle); 2793 2794 if (handle < NFA_DM_DISC_NUM_ENTRIES) 2795 { 2796 nfa_dm_cb.disc_cb.entry[handle].in_use = FALSE; 2797 } 2798 else 2799 { 2800 NFA_TRACE_ERROR0 ("Invalid discovery handle"); 2801 } 2802} 2803 2804/******************************************************************************* 2805** 2806** Function nfa_dm_rf_discover_select 2807** 2808** Description Select target, protocol and RF interface 2809** 2810** Returns void 2811** 2812*******************************************************************************/ 2813void nfa_dm_rf_discover_select (UINT8 rf_disc_id, 2814 tNFA_NFC_PROTOCOL protocol, 2815 tNFA_INTF_TYPE rf_interface) 2816{ 2817 tNFA_DM_DISC_SELECT_PARAMS select_params; 2818 tNFA_CONN_EVT_DATA conn_evt; 2819 2820 NFA_TRACE_DEBUG3 ("nfa_dm_disc_select () rf_disc_id:0x%X, protocol:0x%X, rf_interface:0x%X", 2821 rf_disc_id, protocol, rf_interface); 2822 2823 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_W4_HOST_SELECT) 2824 { 2825 /* state is OK: notify the status when the response is received from NFCC */ 2826 select_params.rf_disc_id = rf_disc_id; 2827 select_params.protocol = protocol; 2828 select_params.rf_interface = rf_interface; 2829 2830 nfa_dm_cb.disc_cb.disc_flags |= NFA_DM_DISC_FLAGS_NOTIFY; 2831 nfa_dm_disc_sm_execute (NFA_DM_RF_DISCOVER_SELECT_CMD, (tNFA_DM_RF_DISC_DATA *) &select_params); 2832 } 2833 else 2834 { 2835 /* Wrong state: notify failed status right away */ 2836 conn_evt.status = NFA_STATUS_FAILED; 2837 nfa_dm_conn_cback_event_notify (NFA_SELECT_RESULT_EVT, &conn_evt); 2838 } 2839} 2840 2841/******************************************************************************* 2842** 2843** Function nfa_dm_rf_deactivate 2844** 2845** Description Deactivate NFC link 2846** 2847** Returns NFA_STATUS_OK if success 2848** 2849*******************************************************************************/ 2850tNFA_STATUS nfa_dm_rf_deactivate (tNFA_DEACTIVATE_TYPE deactivate_type) 2851{ 2852 NFA_TRACE_DEBUG1 ("nfa_dm_rf_deactivate () deactivate_type:0x%X", deactivate_type); 2853 2854 if (deactivate_type == NFA_DEACTIVATE_TYPE_SLEEP) 2855 { 2856 if (nfa_dm_cb.disc_cb.activated_protocol == NFA_PROTOCOL_NFC_DEP) 2857 deactivate_type = NFC_DEACTIVATE_TYPE_SLEEP_AF; 2858 else 2859 deactivate_type = NFC_DEACTIVATE_TYPE_SLEEP; 2860 } 2861 2862 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_IDLE) 2863 { 2864 return NFA_STATUS_FAILED; 2865 } 2866 else if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_DISCOVERY) 2867 { 2868 if (deactivate_type == NFA_DEACTIVATE_TYPE_DISCOVERY) 2869 { 2870 if (nfa_dm_cb.disc_cb.kovio_tle.in_use) 2871 { 2872 nfa_sys_stop_timer (&nfa_dm_cb.disc_cb.kovio_tle); 2873 nfa_dm_disc_kovio_timeout_cback (&nfa_dm_cb.disc_cb.kovio_tle); 2874 return NFA_STATUS_OK; 2875 } 2876 else 2877 { 2878 /* it could be race condition. */ 2879 NFA_TRACE_DEBUG0 ("nfa_dm_rf_deactivate (): already in discovery state"); 2880 return NFA_STATUS_FAILED; 2881 } 2882 } 2883 else if (deactivate_type == NFA_DEACTIVATE_TYPE_IDLE) 2884 { 2885 if (nfa_dm_cb.disc_cb.kovio_tle.in_use) 2886 { 2887 nfa_sys_stop_timer (&nfa_dm_cb.disc_cb.kovio_tle); 2888 nfa_dm_disc_kovio_timeout_cback (&nfa_dm_cb.disc_cb.kovio_tle); 2889 } 2890 nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD, (tNFA_DM_RF_DISC_DATA *) &deactivate_type); 2891 return NFA_STATUS_OK; 2892 } 2893 else 2894 { 2895 return NFA_STATUS_FAILED; 2896 } 2897 } 2898 else 2899 { 2900 nfa_dm_disc_sm_execute (NFA_DM_RF_DEACTIVATE_CMD, (tNFA_DM_RF_DISC_DATA *) &deactivate_type); 2901 return NFA_STATUS_OK; 2902 } 2903} 2904 2905#if (BT_TRACE_VERBOSE == TRUE) 2906/******************************************************************************* 2907** 2908** Function nfa_dm_disc_state_2_str 2909** 2910** Description convert nfc discovery state to string 2911** 2912*******************************************************************************/ 2913static char *nfa_dm_disc_state_2_str (UINT8 state) 2914{ 2915 switch (state) 2916 { 2917 case NFA_DM_RFST_IDLE: 2918 return "IDLE"; 2919 2920 case NFA_DM_RFST_DISCOVERY: 2921 return "DISCOVERY"; 2922 2923 case NFA_DM_RFST_W4_ALL_DISCOVERIES: 2924 return "W4_ALL_DISCOVERIES"; 2925 2926 case NFA_DM_RFST_W4_HOST_SELECT: 2927 return "W4_HOST_SELECT"; 2928 2929 case NFA_DM_RFST_POLL_ACTIVE: 2930 return "POLL_ACTIVE"; 2931 2932 case NFA_DM_RFST_LISTEN_ACTIVE: 2933 return "LISTEN_ACTIVE"; 2934 2935 case NFA_DM_RFST_LISTEN_SLEEP: 2936 return "LISTEN_SLEEP"; 2937 2938 case NFA_DM_RFST_LP_LISTEN: 2939 return "LP_LISTEN"; 2940 2941 case NFA_DM_RFST_LP_ACTIVE: 2942 return "LP_ACTIVE"; 2943 } 2944 return "Unknown"; 2945} 2946 2947/******************************************************************************* 2948** 2949** Function nfa_dm_disc_event_2_str 2950** 2951** Description convert nfc discovery RSP/NTF to string 2952** 2953*******************************************************************************/ 2954static char *nfa_dm_disc_event_2_str (UINT8 event) 2955{ 2956 switch (event) 2957 { 2958 case NFA_DM_RF_DISCOVER_CMD: 2959 return "DISCOVER_CMD"; 2960 2961 case NFA_DM_RF_DISCOVER_RSP: 2962 return "DISCOVER_RSP"; 2963 2964 case NFA_DM_RF_DISCOVER_NTF: 2965 return "DISCOVER_NTF"; 2966 2967 case NFA_DM_RF_DISCOVER_SELECT_CMD: 2968 return "SELECT_CMD"; 2969 2970 case NFA_DM_RF_DISCOVER_SELECT_RSP: 2971 return "SELECT_RSP"; 2972 2973 case NFA_DM_RF_INTF_ACTIVATED_NTF: 2974 return "ACTIVATED_NTF"; 2975 2976 case NFA_DM_RF_DEACTIVATE_CMD: 2977 return "DEACTIVATE_CMD"; 2978 2979 case NFA_DM_RF_DEACTIVATE_RSP: 2980 return "DEACTIVATE_RSP"; 2981 2982 case NFA_DM_RF_DEACTIVATE_NTF: 2983 return "DEACTIVATE_NTF"; 2984 2985 case NFA_DM_LP_LISTEN_CMD: 2986 return "NFA_DM_LP_LISTEN_CMD"; 2987 2988 case NFA_DM_CORE_INTF_ERROR_NTF: 2989 return "INTF_ERROR_NTF"; 2990 2991 } 2992 return "Unknown"; 2993} 2994#endif /* BT_TRACE_VERBOSE */ 2995 2996/******************************************************************************* 2997** 2998** Function P2P_Prio_Logic 2999** 3000** Description Implements algorithm for NFC-DEP protocol priority over 3001** ISO-DEP protocol. 3002** 3003** Returns True if success 3004** 3005*******************************************************************************/ 3006BOOLEAN nfa_dm_p2p_prio_logic (UINT8 event, UINT8 *p, UINT8 event_type) 3007{ 3008 if (!nfa_poll_bail_out_mode) 3009 { 3010 NFA_TRACE_DEBUG0 ("p2p priority is running under bail out mode ONLY."); 3011 return TRUE; 3012 } 3013 3014 if ((nfa_dm_cb.flags & NFA_DM_FLAGS_P2P_PAUSED) && 3015 (nfa_dm_cb.flags & NFA_DM_FLAGS_LISTEN_DISABLED)) 3016 { 3017 NFA_TRACE_DEBUG0 ("returning from nfa_dm_p2p_prio_logic Disable p2p_prio_logic"); 3018 return TRUE; 3019 } 3020 3021 if (event == NCI_MSG_RF_DISCOVER && p2p_prio_logic_data.timer_expired == TRUE && event_type == NFA_DM_P2P_PRIO_RSP) 3022 { 3023 NFA_TRACE_DEBUG0 ("nfa_dm_p2p_prio_logic starting a timer for next rf intf activated ntf"); 3024 nfc_start_quick_timer (&p2p_prio_logic_data.timer_list, 3025 NFC_TTYPE_P2P_PRIO_LOGIC_CLEANUP, 3026 ((UINT32) nfa_dm_act_get_rf_disc_duration() * QUICK_TIMER_TICKS_PER_SEC) / 1000); 3027 return TRUE; 3028 } 3029 3030 if (event == NCI_MSG_RF_INTF_ACTIVATED && p2p_prio_logic_data.timer_expired == TRUE) 3031 { 3032 NFA_TRACE_DEBUG0 ("nfa_dm_p2p_prio_logic stopping a timer for next rf intf activated ntf"); 3033 nfc_stop_quick_timer (&p2p_prio_logic_data.timer_list); 3034 } 3035 3036 if (nfa_dm_cb.disc_cb.disc_state == NFA_DM_RFST_DISCOVERY) 3037 { 3038 UINT8 rf_disc_id = 0xFF; 3039 UINT8 type = 0xFF; 3040 UINT8 protocol = 0xFF; 3041 UINT8 tech_mode = 0xFF; 3042 3043 NFA_TRACE_DEBUG0 ("P2P_Prio_Logic"); 3044 3045 if (event == NCI_MSG_RF_INTF_ACTIVATED ) 3046 { 3047 rf_disc_id = *p++; 3048 type = *p++; 3049 protocol = *p++; 3050 tech_mode = *p++; 3051 } 3052 NFA_TRACE_DEBUG1 ("nfa_dm_p2p_prio_logic event_type = 0x%x", event_type); 3053 3054 if (event == NCI_MSG_RF_INTF_ACTIVATED && tech_mode >= 0x80) 3055 { 3056 NFA_TRACE_DEBUG0 ("nfa_dm_p2p_prio_logic listen mode activated reset all the nfa_dm_p2p_prio_logic variables "); 3057 nfa_dm_p2p_prio_logic_cleanup (); 3058 } 3059 3060 if ((tech_mode < 0x80) && 3061 event == NCI_MSG_RF_INTF_ACTIVATED && 3062 protocol == NCI_PROTOCOL_ISO_DEP && 3063 p2p_prio_logic_data.isodep_detected == FALSE) 3064 { 3065 nfa_dm_p2p_prio_logic_cleanup (); 3066 p2p_prio_logic_data.isodep_detected = TRUE; 3067 p2p_prio_logic_data.first_tech_mode = tech_mode; 3068 NFA_TRACE_DEBUG0 ("ISO-DEP Detected First Time Resume the Polling Loop"); 3069 nci_snd_deactivate_cmd (NFA_DEACTIVATE_TYPE_DISCOVERY); 3070 return FALSE; 3071 } 3072 3073 else if (event == NCI_MSG_RF_INTF_ACTIVATED && 3074 protocol == NCI_PROTOCOL_ISO_DEP && 3075 p2p_prio_logic_data.isodep_detected == TRUE && 3076 p2p_prio_logic_data.first_tech_mode != tech_mode) 3077 { 3078 p2p_prio_logic_data.isodep_detected = TRUE; 3079 p2p_prio_logic_data.timer_expired = FALSE; 3080 NFA_TRACE_DEBUG0 ("ISO-DEP Detected Second Time Other Techmode Resume the Polling Loop"); 3081 nfc_stop_quick_timer (&p2p_prio_logic_data.timer_list); 3082 nci_snd_deactivate_cmd (NFA_DEACTIVATE_TYPE_DISCOVERY); 3083 return FALSE; 3084 } 3085 3086 else if (event == NCI_MSG_RF_INTF_ACTIVATED && 3087 protocol == NCI_PROTOCOL_ISO_DEP && 3088 p2p_prio_logic_data.isodep_detected == TRUE && 3089 p2p_prio_logic_data.timer_expired == TRUE) 3090 { 3091 NFA_TRACE_DEBUG0 ("ISO-DEP Detected TimerExpired, Final Notifying the Event"); 3092 nfc_stop_quick_timer (&p2p_prio_logic_data.timer_list); 3093 nfa_dm_p2p_prio_logic_cleanup (); 3094 } 3095 3096 else if (event == NCI_MSG_RF_INTF_ACTIVATED && 3097 protocol == NCI_PROTOCOL_ISO_DEP && 3098 p2p_prio_logic_data.isodep_detected == TRUE && 3099 p2p_prio_logic_data.first_tech_mode == tech_mode) 3100 { 3101 NFA_TRACE_DEBUG0 ("ISO-DEP Detected Same Techmode, Final Notifying the Event"); 3102 nfc_stop_quick_timer (&p2p_prio_logic_data.timer_list); 3103 NFA_TRACE_DEBUG0 ("P2P_Stop_Timer"); 3104 nfa_dm_p2p_prio_logic_cleanup (); 3105 } 3106 3107 else if (event == NCI_MSG_RF_INTF_ACTIVATED && 3108 protocol != NCI_PROTOCOL_ISO_DEP && 3109 p2p_prio_logic_data.isodep_detected == TRUE) 3110 { 3111 NFA_TRACE_DEBUG0 ("ISO-DEP Not Detected Giving Priority for other Technology"); 3112 nfc_stop_quick_timer (&p2p_prio_logic_data.timer_list); 3113 NFA_TRACE_DEBUG0 ("P2P_Stop_Timer"); 3114 nfa_dm_p2p_prio_logic_cleanup (); 3115 } 3116 3117 else if (event == NCI_MSG_RF_DEACTIVATE && 3118 p2p_prio_logic_data.isodep_detected == TRUE && 3119 p2p_prio_logic_data.timer_expired == FALSE && 3120 event_type == NFA_DM_P2P_PRIO_RSP) 3121 { 3122 NFA_TRACE_DEBUG0 ("NFA_DM_RF_DEACTIVATE_RSP"); 3123 return FALSE; 3124 } 3125 3126 else if (event == NCI_MSG_RF_DEACTIVATE && 3127 p2p_prio_logic_data.isodep_detected == TRUE && 3128 p2p_prio_logic_data.timer_expired == FALSE && 3129 event_type == NFA_DM_P2P_PRIO_NTF) 3130 { 3131 NFA_TRACE_DEBUG0 ("NFA_DM_RF_DEACTIVATE_NTF"); 3132 3133 nfc_start_quick_timer (&p2p_prio_logic_data.timer_list, 3134 NFC_TTYPE_P2P_PRIO_RESPONSE, 3135 ((UINT32) 160 * QUICK_TIMER_TICKS_PER_SEC) / 1000 ); 3136 3137 NFA_TRACE_DEBUG0 ("P2P_Start_Timer"); 3138 3139 return FALSE; 3140 } 3141 } 3142 3143 NFA_TRACE_DEBUG0 ("returning TRUE"); 3144 return TRUE; 3145} 3146 3147/******************************************************************************* 3148** 3149** Function p2p_prio_logic_timeout 3150** 3151** Description Callback function for p2p timer 3152** 3153** Returns void 3154** 3155*******************************************************************************/ 3156void nfa_dm_p2p_timer_event () 3157{ 3158 NFA_TRACE_DEBUG0 ("P2P_Timer_timeout NFC-DEP Not Discovered!!"); 3159 3160 p2p_prio_logic_data.timer_expired = TRUE; 3161 3162 if (p2p_prio_logic_data.isodep_detected == TRUE) 3163 { 3164 NFA_TRACE_DEBUG0 ("Deactivate and Restart RF discovery"); 3165 nci_snd_deactivate_cmd (NFC_DEACTIVATE_TYPE_IDLE); 3166 } 3167} 3168 3169/******************************************************************************* 3170** 3171** Function nfa_dm_p2p_prio_logic_cleanup 3172** 3173** Description Callback function for p2p prio logic cleanup timer 3174** 3175** Returns void 3176** 3177*******************************************************************************/ 3178void nfa_dm_p2p_prio_logic_cleanup () 3179{ 3180 memset (&p2p_prio_logic_data, 0x00, sizeof(nfa_dm_p2p_prio_logic_t)); 3181} 3182