1 /****************************************************************************** 2 * 3 * Copyright (C) 2010-2013 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 * NFA interface for device management 23 * 24 ******************************************************************************/ 25 #include <string.h> 26 #include "nfa_api.h" 27 #include "nfa_sys.h" 28 #include "nfa_dm_int.h" 29 #include "nfa_ce_int.h" 30 #include "nfa_sys_int.h" 31 #include "ndef_utils.h" 32 33 /***************************************************************************** 34 ** Constants 35 *****************************************************************************/ 36 37 /***************************************************************************** 38 ** APIs 39 *****************************************************************************/ 40 /******************************************************************************* 41 ** 42 ** Function NFA_Init 43 ** 44 ** Description This function initializes control blocks for NFA 45 ** 46 ** p_hal_entry_tbl points to a table of HAL entry points 47 ** 48 ** NOTE: the buffer that p_hal_entry_tbl points must be 49 ** persistent until NFA is disabled. 50 ** 51 ** Returns none 52 ** 53 *******************************************************************************/ 54 void NFA_Init(tHAL_NFC_ENTRY *p_hal_entry_tbl) 55 { 56 NFA_TRACE_API0 ("NFA_Init ()"); 57 nfa_sys_init(); 58 nfa_dm_init(); 59 nfa_p2p_init(); 60 nfa_cho_init(); 61 nfa_snep_init(FALSE); 62 nfa_rw_init(); 63 nfa_ce_init(); 64 nfa_ee_init(); 65 if (nfa_ee_max_ee_cfg != 0) 66 { 67 nfa_dm_cb.get_max_ee = p_hal_entry_tbl->get_max_ee; 68 nfa_hci_init(); 69 } 70 71 72 /* Initialize NFC module */ 73 NFC_Init (p_hal_entry_tbl); 74 } 75 76 /******************************************************************************* 77 ** 78 ** Function NFA_Enable 79 ** 80 ** Description This function enables NFC. Prior to calling NFA_Enable, 81 ** the NFCC must be powered up, and ready to receive commands. 82 ** This function enables the tasks needed by NFC, opens the NCI 83 ** transport, resets the NFC controller, downloads patches to 84 ** the NFCC (if necessary), and initializes the NFC subsystems. 85 ** 86 ** This function should only be called once - typically when NFC 87 ** is enabled during boot-up, or when NFC is enabled from a 88 ** settings UI. Subsequent calls to NFA_Enable while NFA is 89 ** enabling or enabled will be ignored. When the NFC startup 90 ** procedure is completed, an NFA_DM_ENABLE_EVT is returned to the 91 ** application using the tNFA_DM_CBACK. 92 ** 93 ** Returns NFA_STATUS_OK if successfully initiated 94 ** NFA_STATUS_FAILED otherwise 95 ** 96 *******************************************************************************/ 97 tNFA_STATUS NFA_Enable (tNFA_DM_CBACK *p_dm_cback, 98 tNFA_CONN_CBACK *p_conn_cback) 99 { 100 tNFA_DM_API_ENABLE *p_msg; 101 102 NFA_TRACE_API0 ("NFA_Enable ()"); 103 104 /* Validate parameters */ 105 if ((!p_dm_cback) || (!p_conn_cback)) 106 { 107 NFA_TRACE_ERROR0 ("NFA_Enable (): error null callback"); 108 return (NFA_STATUS_FAILED); 109 } 110 111 if ((p_msg = (tNFA_DM_API_ENABLE *) GKI_getbuf (sizeof (tNFA_DM_API_ENABLE))) != NULL) 112 { 113 p_msg->hdr.event = NFA_DM_API_ENABLE_EVT; 114 p_msg->p_dm_cback = p_dm_cback; 115 p_msg->p_conn_cback = p_conn_cback; 116 117 nfa_sys_sendmsg (p_msg); 118 119 return (NFA_STATUS_OK); 120 } 121 122 return (NFA_STATUS_FAILED); 123 } 124 125 /******************************************************************************* 126 ** 127 ** Function NFA_Disable 128 ** 129 ** Description This function is called to shutdown NFC. The tasks for NFC 130 ** are terminated, and clean up routines are performed. This 131 ** function is typically called during platform shut-down, or 132 ** when NFC is disabled from a settings UI. When the NFC 133 ** shutdown procedure is completed, an NFA_DM_DISABLE_EVT is 134 ** returned to the application using the tNFA_DM_CBACK. 135 ** 136 ** The platform should wait until the NFC_DISABLE_REVT is 137 ** received before powering down the NFC chip and NCI transport. 138 ** This is required to so that NFA can gracefully shut down any 139 ** open connections. 140 ** 141 ** Returns NFA_STATUS_OK if successfully initiated 142 ** NFA_STATUS_FAILED otherwise 143 ** 144 *******************************************************************************/ 145 tNFA_STATUS NFA_Disable (BOOLEAN graceful) 146 { 147 tNFA_DM_API_DISABLE *p_msg; 148 149 NFA_TRACE_API1 ("NFA_Disable (graceful=%i)", graceful); 150 151 if ((p_msg = (tNFA_DM_API_DISABLE *) GKI_getbuf (sizeof (tNFA_DM_API_DISABLE))) != NULL) 152 { 153 p_msg->hdr.event = NFA_DM_API_DISABLE_EVT; 154 p_msg->graceful = graceful; 155 156 nfa_sys_sendmsg (p_msg); 157 158 return (NFA_STATUS_OK); 159 } 160 161 return (NFA_STATUS_FAILED); 162 } 163 164 /******************************************************************************* 165 ** 166 ** Function NFA_SetConfig 167 ** 168 ** Description Set the configuration parameters to NFCC. The result is 169 ** reported with an NFA_DM_SET_CONFIG_EVT in the tNFA_DM_CBACK 170 ** callback. 171 ** 172 ** Note: If RF discovery is started, NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT 173 ** should happen before calling this function. Most Configuration 174 ** parameters are related to RF discovery. 175 ** 176 ** Returns NFA_STATUS_OK if successfully initiated 177 ** NFA_STATUS_BUSY if previous setting is on-going 178 ** NFA_STATUS_FAILED otherwise 179 ** 180 *******************************************************************************/ 181 tNFA_STATUS NFA_SetConfig (tNFA_PMID param_id, 182 UINT8 length, 183 UINT8 *p_data) 184 { 185 tNFA_DM_API_SET_CONFIG *p_msg; 186 187 NFA_TRACE_API1 ("NFA_SetConfig (): param_id:0x%X", param_id); 188 189 if ((p_msg = (tNFA_DM_API_SET_CONFIG *) GKI_getbuf ((UINT16) (sizeof (tNFA_DM_API_SET_CONFIG) + length))) != NULL) 190 { 191 p_msg->hdr.event = NFA_DM_API_SET_CONFIG_EVT; 192 193 p_msg->param_id = param_id; 194 p_msg->length = length; 195 p_msg->p_data = (UINT8 *) (p_msg + 1); 196 197 /* Copy parameter data */ 198 memcpy (p_msg->p_data, p_data, length); 199 200 nfa_sys_sendmsg (p_msg); 201 202 return (NFA_STATUS_OK); 203 } 204 205 return (NFA_STATUS_FAILED); 206 } 207 208 /******************************************************************************* 209 ** 210 ** Function NFA_GetConfig 211 ** 212 ** Description Get the configuration parameters from NFCC. The result is 213 ** reported with an NFA_DM_GET_CONFIG_EVT in the tNFA_DM_CBACK 214 ** callback. 215 ** 216 ** Returns NFA_STATUS_OK if successfully initiated 217 ** NFA_STATUS_FAILED otherwise 218 ** 219 *******************************************************************************/ 220 tNFA_STATUS NFA_GetConfig (UINT8 num_ids, 221 tNFA_PMID *p_param_ids) 222 { 223 tNFA_DM_API_GET_CONFIG *p_msg; 224 225 NFA_TRACE_API1 ("NFA_GetConfig (): num_ids: %i", num_ids); 226 227 228 if ((p_msg = (tNFA_DM_API_GET_CONFIG *) GKI_getbuf ((UINT16) (sizeof (tNFA_DM_API_GET_CONFIG) + num_ids))) != NULL) 229 { 230 p_msg->hdr.event = NFA_DM_API_GET_CONFIG_EVT; 231 232 p_msg->num_ids = num_ids; 233 p_msg->p_pmids = (tNFA_PMID *) (p_msg+1); 234 235 /* Copy the param IDs */ 236 memcpy (p_msg->p_pmids, p_param_ids, num_ids); 237 238 nfa_sys_sendmsg (p_msg); 239 240 return (NFA_STATUS_OK); 241 } 242 243 return (NFA_STATUS_FAILED); 244 } 245 246 /******************************************************************************* 247 ** 248 ** Function NFA_RequestExclusiveRfControl 249 ** 250 ** Description Request exclusive control of NFC. 251 ** - Previous behavior (polling/tag reading, DH card emulation) 252 ** will be suspended . 253 ** - Polling and listening will be done based on the specified 254 ** params 255 ** 256 ** The NFA_EXCLUSIVE_RF_CONTROL_STARTED_EVT event of 257 ** tNFA_CONN_CBACK indicates the status of the operation. 258 ** 259 ** NFA_ACTIVATED_EVT and NFA_DEACTIVATED_EVT indicates link 260 ** activation/deactivation. 261 ** 262 ** NFA_SendRawFrame is used to send data to the peer. NFA_DATA_EVT 263 ** indicates data from the peer. 264 ** 265 ** If a tag is activated, then the NFA_RW APIs may be used to 266 ** send commands to the tag. Incoming NDEF messages are sent to 267 ** the NDEF callback. 268 ** 269 ** Once exclusive RF control has started, NFA will not activate 270 ** LLCP internally. The application has exclusive control of 271 ** the link. 272 ** 273 ** Note: If RF discovery is started, NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT 274 ** should happen before calling this function 275 ** 276 ** Returns NFA_STATUS_OK if successfully initiated 277 ** NFA_STATUS_FAILED otherwise 278 ** 279 *******************************************************************************/ 280 tNFA_STATUS NFA_RequestExclusiveRfControl (tNFA_TECHNOLOGY_MASK poll_mask, 281 tNFA_LISTEN_CFG *p_listen_cfg, 282 tNFA_CONN_CBACK *p_conn_cback, 283 tNFA_NDEF_CBACK *p_ndef_cback) 284 { 285 tNFA_DM_API_REQ_EXCL_RF_CTRL *p_msg; 286 287 NFA_TRACE_API1 ("NFA_RequestExclusiveRfControl () poll_mask=0x%x", poll_mask); 288 289 if (!p_conn_cback) 290 { 291 NFA_TRACE_ERROR0 ("NFA_RequestExclusiveRfControl (): error null callback"); 292 return (NFA_STATUS_FAILED); 293 } 294 295 if ((p_msg = (tNFA_DM_API_REQ_EXCL_RF_CTRL *) GKI_getbuf (sizeof (tNFA_DM_API_REQ_EXCL_RF_CTRL))) != NULL) 296 { 297 p_msg->hdr.event = NFA_DM_API_REQUEST_EXCL_RF_CTRL_EVT; 298 p_msg->poll_mask = poll_mask; 299 p_msg->p_conn_cback = p_conn_cback; 300 p_msg->p_ndef_cback = p_ndef_cback; 301 302 if (p_listen_cfg) 303 memcpy (&p_msg->listen_cfg, p_listen_cfg, sizeof (tNFA_LISTEN_CFG)); 304 else 305 memset (&p_msg->listen_cfg, 0x00, sizeof (tNFA_LISTEN_CFG)); 306 307 nfa_sys_sendmsg (p_msg); 308 309 return (NFA_STATUS_OK); 310 } 311 312 return (NFA_STATUS_FAILED); 313 } 314 315 /******************************************************************************* 316 ** 317 ** Function NFA_ReleaseExclusiveRfControl 318 ** 319 ** Description Release exclusive control of NFC. Once released, behavior 320 ** prior to obtaining exclusive RF control will resume. 321 ** 322 ** Returns NFA_STATUS_OK if successfully initiated 323 ** NFA_STATUS_FAILED otherwise 324 ** 325 *******************************************************************************/ 326 tNFA_STATUS NFA_ReleaseExclusiveRfControl (void) 327 { 328 BT_HDR *p_msg; 329 330 NFA_TRACE_API0 ("NFA_ReleaseExclusiveRfControl ()"); 331 332 if (!nfa_dm_cb.p_excl_conn_cback) 333 { 334 NFA_TRACE_ERROR0 ("NFA_ReleaseExclusiveRfControl (): Exclusive rf control is not in progress"); 335 return (NFA_STATUS_FAILED); 336 } 337 338 if ((p_msg = (BT_HDR *) GKI_getbuf (sizeof (BT_HDR))) != NULL) 339 { 340 p_msg->event = NFA_DM_API_RELEASE_EXCL_RF_CTRL_EVT; 341 nfa_sys_sendmsg (p_msg); 342 return (NFA_STATUS_OK); 343 } 344 345 return (NFA_STATUS_FAILED); 346 } 347 348 349 /******************************************************************************* 350 ** 351 ** Function NFA_EnablePolling 352 ** 353 ** Description Enable polling for technologies specified by poll_mask. 354 ** 355 ** The following events (notified using the connection 356 ** callback registered with NFA_Enable) are generated during 357 ** polling: 358 ** 359 ** - NFA_POLL_ENABLED_EVT indicates whether or not polling 360 ** successfully enabled. 361 ** - NFA_DISC_RESULT_EVT indicates there are more than one devices, 362 ** so application must select one of tags by calling NFA_Select(). 363 ** - NFA_SELECT_RESULT_EVT indicates whether previous selection was 364 ** successful or not. If it was failed then application must select 365 ** again or deactivate by calling NFA_Deactivate(). 366 ** - NFA_ACTIVATED_EVT is generated when an NFC link is activated. 367 ** - NFA_NDEF_DETECT_EVT is generated if tag is activated 368 ** - NFA_LLCP_ACTIVATED_EVT/NFA_LLCP_DEACTIVATED_EVT is generated 369 ** if NFC-DEP is activated 370 ** - NFA_DEACTIVATED_EVT will be returned after deactivating NFC link. 371 ** 372 ** Note: If RF discovery is started, NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT 373 ** should happen before calling this function 374 ** 375 ** Returns NFA_STATUS_OK if successfully initiated 376 ** NFA_STATUS_FAILED otherwise 377 ** 378 *******************************************************************************/ 379 tNFA_STATUS NFA_EnablePolling (tNFA_TECHNOLOGY_MASK poll_mask) 380 { 381 tNFA_DM_API_ENABLE_POLL *p_msg; 382 383 NFA_TRACE_API1 ("NFA_EnablePolling () 0x%X", poll_mask); 384 385 if ((p_msg = (tNFA_DM_API_ENABLE_POLL *) GKI_getbuf (sizeof (tNFA_DM_API_ENABLE_POLL))) != NULL) 386 { 387 p_msg->hdr.event = NFA_DM_API_ENABLE_POLLING_EVT; 388 p_msg->poll_mask = poll_mask; 389 390 nfa_sys_sendmsg (p_msg); 391 392 return (NFA_STATUS_OK); 393 } 394 395 return (NFA_STATUS_FAILED); 396 } 397 398 /******************************************************************************* 399 ** 400 ** Function NFA_DisablePolling 401 ** 402 ** Description Disable polling 403 ** NFA_POLL_DISABLED_EVT will be returned after stopping polling. 404 ** 405 ** Note: If RF discovery is started, NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT 406 ** should happen before calling this function 407 ** 408 ** Returns NFA_STATUS_OK if successfully initiated 409 ** NFA_STATUS_FAILED otherwise 410 ** 411 *******************************************************************************/ 412 tNFA_STATUS NFA_DisablePolling (void) 413 { 414 BT_HDR *p_msg; 415 416 NFA_TRACE_API0 ("NFA_DisablePolling ()"); 417 418 if ((p_msg = (BT_HDR *) GKI_getbuf (sizeof (BT_HDR))) != NULL) 419 { 420 p_msg->event = NFA_DM_API_DISABLE_POLLING_EVT; 421 422 nfa_sys_sendmsg (p_msg); 423 424 return (NFA_STATUS_OK); 425 } 426 427 return (NFA_STATUS_FAILED); 428 } 429 430 /******************************************************************************* 431 ** 432 ** Function NFA_EnableListening 433 ** 434 ** Description Enable listening. 435 ** NFA_LISTEN_ENABLED_EVT will be returned after listening is allowed. 436 ** 437 ** The actual listening technologies are specified by other NFA 438 ** API functions. Such functions include (but not limited to) 439 ** NFA_CeConfigureUiccListenTech. 440 ** If NFA_DisableListening () is called to ignore the listening technologies, 441 ** NFA_EnableListening () is called to restore the listening technologies 442 ** set by these functions. 443 ** 444 ** Note: If RF discovery is started, NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT 445 ** should happen before calling this function 446 ** 447 ** Returns NFA_STATUS_OK if successfully initiated 448 ** NFA_STATUS_FAILED otherwise 449 ** 450 *******************************************************************************/ 451 tNFA_STATUS NFA_EnableListening (void) 452 { 453 BT_HDR *p_msg; 454 455 NFA_TRACE_API0 ("NFA_EnableListening ()"); 456 457 if ((p_msg = (BT_HDR *) GKI_getbuf (sizeof (BT_HDR))) != NULL) 458 { 459 p_msg->event = NFA_DM_API_ENABLE_LISTENING_EVT; 460 461 nfa_sys_sendmsg (p_msg); 462 463 return (NFA_STATUS_OK); 464 } 465 466 return (NFA_STATUS_FAILED); 467 } 468 469 /******************************************************************************* 470 ** 471 ** Function NFA_DisableListening 472 ** 473 ** Description Disable listening 474 ** NFA_LISTEN_DISABLED_EVT will be returned after stopping listening. 475 ** This function is called to exclude listen at RF discovery. 476 ** 477 ** Note: If RF discovery is started, NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT 478 ** should happen before calling this function 479 ** 480 ** Returns NFA_STATUS_OK if successfully initiated 481 ** NFA_STATUS_FAILED otherwise 482 ** 483 *******************************************************************************/ 484 tNFA_STATUS NFA_DisableListening (void) 485 { 486 BT_HDR *p_msg; 487 488 NFA_TRACE_API0 ("NFA_DisableListening ()"); 489 490 if ((p_msg = (BT_HDR *) GKI_getbuf (sizeof (BT_HDR))) != NULL) 491 { 492 p_msg->event = NFA_DM_API_DISABLE_LISTENING_EVT; 493 494 nfa_sys_sendmsg (p_msg); 495 496 return (NFA_STATUS_OK); 497 } 498 499 return (NFA_STATUS_FAILED); 500 } 501 502 /******************************************************************************* 503 ** 504 ** Function NFA_PauseP2p 505 ** 506 ** Description Pause P2P services. 507 ** NFA_P2P_PAUSED_EVT will be returned after P2P services are 508 ** disabled. 509 ** 510 ** The P2P services enabled by NFA_P2p* API functions are not 511 ** available. NFA_ResumeP2p() is called to resume the P2P 512 ** services. 513 ** 514 ** Note: If RF discovery is started, NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT 515 ** should happen before calling this function 516 ** 517 ** Returns NFA_STATUS_OK if successfully initiated 518 ** NFA_STATUS_FAILED otherwise 519 ** 520 *******************************************************************************/ 521 tNFA_STATUS NFA_PauseP2p (void) 522 { 523 BT_HDR *p_msg; 524 525 NFA_TRACE_API0 ("NFA_PauseP2p ()"); 526 527 if ((p_msg = (BT_HDR *) GKI_getbuf (sizeof (BT_HDR))) != NULL) 528 { 529 p_msg->event = NFA_DM_API_PAUSE_P2P_EVT; 530 531 nfa_sys_sendmsg (p_msg); 532 533 return (NFA_STATUS_OK); 534 } 535 536 return (NFA_STATUS_FAILED); 537 } 538 539 /******************************************************************************* 540 ** 541 ** Function NFA_ResumeP2p 542 ** 543 ** Description Resume P2P services. 544 ** NFA_P2P_RESUMED_EVT will be returned after P2P services are. 545 ** enables again. 546 ** 547 ** Note: If RF discovery is started, NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT 548 ** should happen before calling this function 549 ** 550 ** Returns NFA_STATUS_OK if successfully initiated 551 ** NFA_STATUS_FAILED otherwise 552 ** 553 *******************************************************************************/ 554 tNFA_STATUS NFA_ResumeP2p (void) 555 { 556 BT_HDR *p_msg; 557 558 NFA_TRACE_API0 ("NFA_ResumeP2p ()"); 559 560 if ((p_msg = (BT_HDR *) GKI_getbuf (sizeof (BT_HDR))) != NULL) 561 { 562 p_msg->event = NFA_DM_API_RESUME_P2P_EVT; 563 564 nfa_sys_sendmsg (p_msg); 565 566 return (NFA_STATUS_OK); 567 } 568 569 return (NFA_STATUS_FAILED); 570 } 571 572 /******************************************************************************* 573 ** 574 ** Function NFA_SetP2pListenTech 575 ** 576 ** Description This function is called to set listen technology for NFC-DEP. 577 ** This funtion may be called before or after starting any server 578 ** on NFA P2P/CHO/SNEP. 579 ** If there is no technology for NFC-DEP, P2P listening will be 580 ** stopped. 581 ** 582 ** NFA_SET_P2P_LISTEN_TECH_EVT without data will be returned. 583 ** 584 ** Note: If RF discovery is started, NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT 585 ** should happen before calling this function 586 ** 587 ** Returns NFA_STATUS_OK if successfully initiated 588 ** NFA_STATUS_FAILED otherwise 589 ** 590 *******************************************************************************/ 591 tNFA_STATUS NFA_SetP2pListenTech (tNFA_TECHNOLOGY_MASK tech_mask) 592 { 593 tNFA_DM_API_SET_P2P_LISTEN_TECH *p_msg; 594 595 NFA_TRACE_API1 ("NFA_P2pSetListenTech (): tech_mask:0x%X", tech_mask); 596 597 if ((p_msg = (tNFA_DM_API_SET_P2P_LISTEN_TECH *) GKI_getbuf (sizeof (tNFA_DM_API_SET_P2P_LISTEN_TECH))) != NULL) 598 { 599 p_msg->hdr.event = NFA_DM_API_SET_P2P_LISTEN_TECH_EVT; 600 p_msg->tech_mask = tech_mask; 601 602 nfa_sys_sendmsg (p_msg); 603 604 return (NFA_STATUS_OK); 605 } 606 607 return (NFA_STATUS_FAILED); 608 } 609 610 /******************************************************************************* 611 ** 612 ** Function NFA_StartRfDiscovery 613 ** 614 ** Description Start RF discovery 615 ** RF discovery parameters shall be set by other APIs. 616 ** 617 ** An NFA_RF_DISCOVERY_STARTED_EVT indicates whether starting was successful or not. 618 ** 619 ** Returns NFA_STATUS_OK if successfully initiated 620 ** NFA_STATUS_FAILED otherwise 621 ** 622 *******************************************************************************/ 623 tNFA_STATUS NFA_StartRfDiscovery (void) 624 { 625 BT_HDR *p_msg; 626 627 NFA_TRACE_API0 ("NFA_StartRfDiscovery ()"); 628 629 if ((p_msg = (BT_HDR *) GKI_getbuf (sizeof (BT_HDR))) != NULL) 630 { 631 p_msg->event = NFA_DM_API_START_RF_DISCOVERY_EVT; 632 633 nfa_sys_sendmsg (p_msg); 634 635 return (NFA_STATUS_OK); 636 } 637 638 return (NFA_STATUS_FAILED); 639 } 640 641 /******************************************************************************* 642 ** 643 ** Function NFA_StopRfDiscovery 644 ** 645 ** Description Stop RF discovery 646 ** 647 ** An NFA_RF_DISCOVERY_STOPPED_EVT indicates whether stopping was successful or not. 648 ** 649 ** Returns NFA_STATUS_OK if successfully initiated 650 ** NFA_STATUS_FAILED otherwise 651 ** 652 *******************************************************************************/ 653 tNFA_STATUS NFA_StopRfDiscovery (void) 654 { 655 BT_HDR *p_msg; 656 657 NFA_TRACE_API0 ("NFA_StopRfDiscovery ()"); 658 659 if ((p_msg = (BT_HDR *) GKI_getbuf (sizeof (BT_HDR))) != NULL) 660 { 661 p_msg->event = NFA_DM_API_STOP_RF_DISCOVERY_EVT; 662 663 nfa_sys_sendmsg (p_msg); 664 665 return (NFA_STATUS_OK); 666 } 667 668 return (NFA_STATUS_FAILED); 669 } 670 671 /******************************************************************************* 672 ** 673 ** Function NFA_SetRfDiscoveryDuration 674 ** 675 ** Description Set the duration of the single discovery period in [ms]. 676 ** Allowable range: 0 ms to 0xFFFF ms. 677 ** 678 ** If discovery is already started, the application should 679 ** call NFA_StopRfDiscovery prior to calling 680 ** NFA_SetRfDiscoveryDuration, and then call 681 ** NFA_StartRfDiscovery afterwards to restart discovery using 682 ** the new duration. 683 ** 684 ** Note: If RF discovery is started, NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT 685 ** should happen before calling this function 686 ** 687 ** Returns: 688 ** NFA_STATUS_OK, if command accepted 689 ** NFA_STATUS_FAILED: otherwise 690 ** 691 *******************************************************************************/ 692 tNFA_STATUS NFA_SetRfDiscoveryDuration (UINT16 discovery_period_ms) 693 { 694 tNFA_DM_API_SET_RF_DISC_DUR *p_msg; 695 696 NFA_TRACE_API0 ("NFA_SetRfDiscoveryDuration ()"); 697 698 /* Post the API message */ 699 if ((p_msg = (tNFA_DM_API_SET_RF_DISC_DUR *) GKI_getbuf (sizeof (BT_HDR))) != NULL) 700 { 701 p_msg->hdr.event = NFA_DM_API_SET_RF_DISC_DURATION_EVT; 702 703 /* Set discovery duration */ 704 p_msg->rf_disc_dur_ms = discovery_period_ms; 705 706 nfa_sys_sendmsg (p_msg); 707 708 return (NFA_STATUS_OK); 709 } 710 711 return (NFA_STATUS_FAILED); 712 } 713 714 /******************************************************************************* 715 ** 716 ** Function NFA_Select 717 ** 718 ** Description Select one from detected devices during discovery 719 ** (from NFA_DISC_RESULT_EVTs). The application should wait for 720 ** the final NFA_DISC_RESULT_EVT before selecting. 721 ** 722 ** An NFA_SELECT_RESULT_EVT indicates whether selection was successful or not. 723 ** If failed then application must select again or deactivate by NFA_Deactivate(). 724 ** 725 ** Returns NFA_STATUS_OK if successfully initiated 726 ** NFA_STATUS_INVALID_PARAM if RF interface is not matched protocol 727 ** NFA_STATUS_FAILED otherwise 728 ** 729 *******************************************************************************/ 730 tNFA_STATUS NFA_Select (UINT8 rf_disc_id, 731 tNFA_NFC_PROTOCOL protocol, 732 tNFA_INTF_TYPE rf_interface) 733 { 734 tNFA_DM_API_SELECT *p_msg; 735 736 NFA_TRACE_API3 ("NFA_Select (): rf_disc_id:0x%X, protocol:0x%X, rf_interface:0x%X", 737 rf_disc_id, protocol, rf_interface); 738 739 if ( ((rf_interface == NFA_INTERFACE_ISO_DEP) && (protocol != NFA_PROTOCOL_ISO_DEP)) 740 ||((rf_interface == NFA_INTERFACE_NFC_DEP) && (protocol != NFA_PROTOCOL_NFC_DEP)) ) 741 { 742 NFA_TRACE_ERROR0 ("NFA_Select (): RF interface is not matched protocol"); 743 return (NFA_STATUS_INVALID_PARAM); 744 } 745 746 if ((p_msg = (tNFA_DM_API_SELECT *) GKI_getbuf ((UINT16) (sizeof (tNFA_DM_API_SELECT)))) != NULL) 747 { 748 p_msg->hdr.event = NFA_DM_API_SELECT_EVT; 749 p_msg->rf_disc_id = rf_disc_id; 750 p_msg->protocol = protocol; 751 p_msg->rf_interface = rf_interface; 752 753 nfa_sys_sendmsg (p_msg); 754 755 return (NFA_STATUS_OK); 756 } 757 758 return (NFA_STATUS_FAILED); 759 } 760 761 /******************************************************************************* 762 ** 763 ** Function NFA_UpdateRFCommParams 764 ** 765 ** Description This function is called to update RF Communication parameters 766 ** once the Frame RF Interface has been activated. 767 ** 768 ** An NFA_UPDATE_RF_PARAM_RESULT_EVT indicates whether updating 769 ** was successful or not. 770 ** 771 ** Returns NFA_STATUS_OK if successfully initiated 772 ** NFA_STATUS_FAILED otherwise 773 ** 774 *******************************************************************************/ 775 tNFA_STATUS NFA_UpdateRFCommParams (tNFA_RF_COMM_PARAMS *p_params) 776 { 777 tNFA_DM_API_UPDATE_RF_PARAMS *p_msg; 778 779 NFA_TRACE_API0 ("NFA_UpdateRFCommParams ()"); 780 781 if ((p_msg = (tNFA_DM_API_UPDATE_RF_PARAMS *) GKI_getbuf ((UINT16) (sizeof (tNFA_DM_API_UPDATE_RF_PARAMS)))) != NULL) 782 { 783 p_msg->hdr.event = NFA_DM_API_UPDATE_RF_PARAMS_EVT; 784 memcpy (&p_msg->params, p_params, sizeof (tNFA_RF_COMM_PARAMS)); 785 786 nfa_sys_sendmsg (p_msg); 787 788 return (NFA_STATUS_OK); 789 } 790 791 return (NFA_STATUS_FAILED); 792 } 793 794 /******************************************************************************* 795 ** 796 ** Function NFA_Deactivate 797 ** 798 ** Description 799 ** If sleep_mode=TRUE: 800 ** Deselect the activated device by deactivating into sleep mode. 801 ** 802 ** An NFA_DEACTIVATE_FAIL_EVT indicates that selection was not successful. 803 ** Application can select another discovered device or deactivate by NFA_Deactivate () 804 ** after receiving NFA_DEACTIVATED_EVT. 805 ** 806 ** Deactivating to sleep mode is not allowed when NFCC is in wait-for-host-select 807 ** mode, or in listen-sleep states; NFA will deactivate to idle or discovery state 808 ** for these cases respectively. 809 ** 810 ** 811 ** If sleep_mode=FALSE: 812 ** Deactivate the connection (e.g. as a result of presence check failure) 813 ** NFA_DEACTIVATED_EVT will indicate that link is deactivated. 814 ** Polling/listening will resume (unless the nfcc is in wait_for-all-discoveries state) 815 ** 816 ** 817 ** Returns NFA_STATUS_OK if successfully initiated 818 ** NFA_STATUS_FAILED otherwise 819 ** 820 *******************************************************************************/ 821 NFC_API extern tNFA_STATUS NFA_Deactivate (BOOLEAN sleep_mode) 822 { 823 tNFA_DM_API_DEACTIVATE *p_msg; 824 825 NFA_TRACE_API1 ("NFA_Deactivate (): sleep_mode:%i", sleep_mode); 826 827 if ((p_msg = (tNFA_DM_API_DEACTIVATE *) GKI_getbuf ((UINT16) (sizeof (tNFA_DM_API_DEACTIVATE)))) != NULL) 828 { 829 p_msg->hdr.event = NFA_DM_API_DEACTIVATE_EVT; 830 p_msg->sleep_mode = sleep_mode; 831 832 nfa_sys_sendmsg (p_msg); 833 834 return (NFA_STATUS_OK); 835 } 836 837 return (NFA_STATUS_FAILED); 838 } 839 840 /******************************************************************************* 841 ** 842 ** Function NFA_SendRawFrame 843 ** 844 ** Description Send a raw frame over the activated interface with the NFCC. 845 ** This function can only be called after NFC link is activated. 846 ** 847 ** If the activated interface is a tag and auto-presence check is 848 ** enabled then presence_check_start_delay can be used to indicate 849 ** the delay in msec after which the next auto presence check 850 ** command can be sent. NFA_DM_DEFAULT_PRESENCE_CHECK_START_DELAY 851 ** can be used as the default value for the delay. 852 ** 853 ** Returns NFA_STATUS_OK if successfully initiated 854 ** NFA_STATUS_FAILED otherwise 855 ** 856 *******************************************************************************/ 857 tNFA_STATUS NFA_SendRawFrame (UINT8 *p_raw_data, 858 UINT16 data_len, 859 UINT16 presence_check_start_delay) 860 { 861 BT_HDR *p_msg; 862 UINT16 size; 863 UINT8 *p; 864 865 NFA_TRACE_API1 ("NFA_SendRawFrame () data_len:%d", data_len); 866 867 /* Validate parameters */ 868 if ((data_len == 0) || (p_raw_data == NULL)) 869 return (NFA_STATUS_INVALID_PARAM); 870 871 size = BT_HDR_SIZE + NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE + data_len; 872 if ((p_msg = (BT_HDR *) GKI_getbuf (size)) != NULL) 873 { 874 p_msg->event = NFA_DM_API_RAW_FRAME_EVT; 875 p_msg->layer_specific = presence_check_start_delay; 876 p_msg->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE; 877 p_msg->len = data_len; 878 879 p = (UINT8 *) (p_msg + 1) + p_msg->offset; 880 memcpy (p, p_raw_data, data_len); 881 882 nfa_sys_sendmsg (p_msg); 883 884 return (NFA_STATUS_OK); 885 } 886 887 return (NFA_STATUS_FAILED); 888 } 889 890 /******************************************************************************* 891 ** NDEF Handler APIs 892 *******************************************************************************/ 893 894 /******************************************************************************* 895 ** 896 ** Function NFA_RegisterNDefTypeHandler 897 ** 898 ** Description This function allows the applications to register for 899 ** specific types of NDEF records. When NDEF records are 900 ** received, NFA will parse the record-type field, and pass 901 ** the record to the registered tNFA_NDEF_CBACK. 902 ** 903 ** For records types which were not registered, the record will 904 ** be sent to the default handler. A default type-handler may 905 ** be registered by calling this NFA_RegisterNDefTypeHandler 906 ** with tnf=NFA_TNF_DEFAULT. In this case, all un-registered 907 ** record types will be sent to the callback. Only one default 908 ** handler may be registered at a time. 909 ** 910 ** An NFA_NDEF_REGISTER_EVT will be sent to the tNFA_NDEF_CBACK 911 ** to indicate that registration was successful, and provide a 912 ** handle for this record type. 913 ** 914 ** Returns NFA_STATUS_OK if successfully initiated 915 ** NFA_STATUS_FAILED otherwise 916 ** 917 *******************************************************************************/ 918 tNFA_STATUS NFA_RegisterNDefTypeHandler (BOOLEAN handle_whole_message, 919 tNFA_TNF tnf, 920 UINT8 *p_type_name, 921 UINT8 type_name_len, 922 tNFA_NDEF_CBACK *p_ndef_cback) 923 { 924 tNFA_DM_API_REG_NDEF_HDLR *p_msg; 925 926 NFA_TRACE_API2 ("NFA_RegisterNDefTypeHandler (): handle whole ndef message: %i, tnf=0x%02x", handle_whole_message, tnf); 927 928 /* Check for NULL callback */ 929 if (!p_ndef_cback) 930 { 931 NFA_TRACE_ERROR0 ("NFA_RegisterNDefTypeHandler (): error - null callback"); 932 return (NFA_STATUS_INVALID_PARAM); 933 } 934 935 936 if ((p_msg = (tNFA_DM_API_REG_NDEF_HDLR *) GKI_getbuf ((UINT16) (sizeof (tNFA_DM_API_REG_NDEF_HDLR) + type_name_len))) != NULL) 937 { 938 p_msg->hdr.event = NFA_DM_API_REG_NDEF_HDLR_EVT; 939 940 p_msg->flags = (handle_whole_message ? NFA_NDEF_FLAGS_HANDLE_WHOLE_MESSAGE : 0); 941 p_msg->tnf = tnf; 942 p_msg->name_len = type_name_len; 943 p_msg->p_ndef_cback = p_ndef_cback; 944 memcpy (p_msg->name, p_type_name, type_name_len); 945 946 nfa_sys_sendmsg (p_msg); 947 948 return (NFA_STATUS_OK); 949 } 950 951 return (NFA_STATUS_FAILED); 952 } 953 954 /******************************************************************************* 955 ** 956 ** Function NFA_RegisterNDefUriHandler 957 ** 958 ** Description This API is a special-case of NFA_RegisterNDefTypeHandler 959 ** with TNF=NFA_TNF_WKT, and type_name='U' (URI record); and allows 960 ** registering for specific URI types (e.g. 'tel:' or 'mailto:'). 961 ** 962 ** An NFA_NDEF_REGISTER_EVT will be sent to the tNFA_NDEF_CBACK 963 ** to indicate that registration was successful, and provide a 964 ** handle for this registration. 965 ** 966 ** If uri_id=NFA_NDEF_URI_ID_ABSOLUTE, then p_abs_uri contains the 967 ** unabridged URI. For all other uri_id values, the p_abs_uri 968 ** parameter is ignored (i.e the URI prefix is implied by uri_id). 969 ** See [NFC RTD URI] for more information. 970 ** 971 ** Returns NFA_STATUS_OK if successfully initiated 972 ** NFA_STATUS_FAILED otherwise 973 ** 974 *******************************************************************************/ 975 NFC_API extern tNFA_STATUS NFA_RegisterNDefUriHandler (BOOLEAN handle_whole_message, 976 tNFA_NDEF_URI_ID uri_id, 977 UINT8 *p_abs_uri, 978 UINT8 uri_id_len, 979 tNFA_NDEF_CBACK *p_ndef_cback) 980 { 981 tNFA_DM_API_REG_NDEF_HDLR *p_msg; 982 983 NFA_TRACE_API2 ("NFA_RegisterNDefUriHandler (): handle whole ndef message: %i, uri_id=0x%02x", handle_whole_message, uri_id); 984 985 /* Check for NULL callback */ 986 if (!p_ndef_cback) 987 { 988 NFA_TRACE_ERROR0 ("NFA_RegisterNDefUriHandler (): error - null callback"); 989 return (NFA_STATUS_INVALID_PARAM); 990 } 991 992 993 if ((p_msg = (tNFA_DM_API_REG_NDEF_HDLR *) GKI_getbuf ((UINT16) (sizeof (tNFA_DM_API_REG_NDEF_HDLR) + uri_id_len))) != NULL) 994 { 995 p_msg->hdr.event = NFA_DM_API_REG_NDEF_HDLR_EVT; 996 997 p_msg->flags = NFA_NDEF_FLAGS_WKT_URI; 998 999 if (handle_whole_message) 1000 { 1001 p_msg->flags |= NFA_NDEF_FLAGS_HANDLE_WHOLE_MESSAGE; 1002 } 1003 1004 /* abs_uri is only valid fir uri_id=NFA_NDEF_URI_ID_ABSOLUTE */ 1005 if (uri_id != NFA_NDEF_URI_ID_ABSOLUTE) 1006 { 1007 uri_id_len = 0; 1008 } 1009 1010 p_msg->tnf = NFA_TNF_WKT; 1011 p_msg->uri_id = uri_id; 1012 p_msg->name_len = uri_id_len; 1013 p_msg->p_ndef_cback = p_ndef_cback; 1014 memcpy (p_msg->name, p_abs_uri, uri_id_len); 1015 1016 nfa_sys_sendmsg (p_msg); 1017 1018 return (NFA_STATUS_OK); 1019 } 1020 1021 return (NFA_STATUS_FAILED); 1022 } 1023 1024 /******************************************************************************* 1025 ** 1026 ** Function NFA_DeregisterNDefTypeHandler 1027 ** 1028 ** Description Deregister NDEF record type handler. 1029 ** 1030 ** Returns NFA_STATUS_OK if successfully initiated 1031 ** NFA_STATUS_FAILED otherwise 1032 ** 1033 *******************************************************************************/ 1034 NFC_API extern tNFA_STATUS NFA_DeregisterNDefTypeHandler (tNFA_HANDLE ndef_type_handle) 1035 { 1036 tNFA_DM_API_DEREG_NDEF_HDLR *p_msg; 1037 1038 NFA_TRACE_API1 ("NFA_DeregisterNDefHandler (): handle 0x%08x", ndef_type_handle); 1039 1040 1041 if ((p_msg = (tNFA_DM_API_DEREG_NDEF_HDLR *) GKI_getbuf ((UINT16) (sizeof (tNFA_DM_API_DEREG_NDEF_HDLR)))) != NULL) 1042 { 1043 p_msg->hdr.event = NFA_DM_API_DEREG_NDEF_HDLR_EVT; 1044 p_msg->ndef_type_handle = ndef_type_handle; 1045 1046 nfa_sys_sendmsg (p_msg); 1047 1048 return (NFA_STATUS_OK); 1049 } 1050 1051 return (NFA_STATUS_FAILED); 1052 } 1053 1054 /******************************************************************************* 1055 ** 1056 ** Function NFA_PowerOffSleepMode 1057 ** 1058 ** Description This function is called to enter or leave NFCC Power Off Sleep mode 1059 ** NFA_DM_PWR_MODE_CHANGE_EVT will be sent to indicate status. 1060 ** 1061 ** start_stop : TRUE if entering Power Off Sleep mode 1062 ** FALSE if leaving Power Off Sleep mode 1063 ** 1064 ** Returns NFA_STATUS_OK if successfully initiated 1065 ** NFA_STATUS_FAILED otherwise 1066 ** 1067 *******************************************************************************/ 1068 tNFA_STATUS NFA_PowerOffSleepMode (BOOLEAN start_stop) 1069 { 1070 BT_HDR *p_msg; 1071 1072 NFA_TRACE_API1 ("NFA_PowerOffSleepState () start_stop=%d", start_stop); 1073 1074 if (nfa_dm_cb.flags & NFA_DM_FLAGS_SETTING_PWR_MODE) 1075 { 1076 NFA_TRACE_ERROR0 ("NFA_PowerOffSleepState (): NFA DM is busy to update power mode"); 1077 return (NFA_STATUS_FAILED); 1078 } 1079 else 1080 { 1081 nfa_dm_cb.flags |= NFA_DM_FLAGS_SETTING_PWR_MODE; 1082 } 1083 1084 if ((p_msg = (BT_HDR *) GKI_getbuf (sizeof (BT_HDR))) != NULL) 1085 { 1086 p_msg->event = NFA_DM_API_POWER_OFF_SLEEP_EVT; 1087 p_msg->layer_specific = start_stop; 1088 1089 nfa_sys_sendmsg (p_msg); 1090 1091 return (NFA_STATUS_OK); 1092 } 1093 1094 return (NFA_STATUS_FAILED); 1095 } 1096 1097 /******************************************************************************* 1098 ** 1099 ** Function NFA_RegVSCback 1100 ** 1101 ** Description This function is called to register or de-register a callback 1102 ** function to receive Proprietary NCI response and notification 1103 ** events. 1104 ** The maximum number of callback functions allowed is NFC_NUM_VS_CBACKS 1105 ** 1106 ** Returns tNFC_STATUS 1107 ** 1108 *******************************************************************************/ 1109 tNFC_STATUS NFA_RegVSCback (BOOLEAN is_register, 1110 tNFA_VSC_CBACK *p_cback) 1111 { 1112 tNFA_DM_API_REG_VSC *p_msg; 1113 1114 NFA_TRACE_API1 ("NFA_RegVSCback() is_register=%d", is_register); 1115 1116 if (p_cback == NULL) 1117 { 1118 NFA_TRACE_ERROR0 ("NFA_RegVSCback() requires a valid callback function"); 1119 return (NFA_STATUS_FAILED); 1120 } 1121 1122 if ((p_msg = (tNFA_DM_API_REG_VSC *) GKI_getbuf (sizeof(tNFA_DM_API_REG_VSC))) != NULL) 1123 { 1124 p_msg->hdr.event = NFA_DM_API_REG_VSC_EVT; 1125 p_msg->is_register = is_register; 1126 p_msg->p_cback = p_cback; 1127 1128 nfa_sys_sendmsg (p_msg); 1129 1130 return (NFA_STATUS_OK); 1131 } 1132 1133 return (NFA_STATUS_FAILED); 1134 } 1135 1136 /******************************************************************************* 1137 ** 1138 ** Function NFA_SendVsCommand 1139 ** 1140 ** Description This function is called to send an NCI Vendor Specific 1141 ** command to NFCC. 1142 ** 1143 ** oid - The opcode of the VS command. 1144 ** cmd_params_len - The command parameter len 1145 ** p_cmd_params - The command parameter 1146 ** p_cback - The callback function to receive the command 1147 ** status 1148 ** 1149 ** Returns NFA_STATUS_OK if successfully initiated 1150 ** NFA_STATUS_FAILED otherwise 1151 ** 1152 *******************************************************************************/ 1153 tNFA_STATUS NFA_SendVsCommand (UINT8 oid, 1154 UINT8 cmd_params_len, 1155 UINT8 *p_cmd_params, 1156 tNFA_VSC_CBACK *p_cback) 1157 { 1158 tNFA_DM_API_SEND_VSC *p_msg; 1159 UINT16 size = sizeof(tNFA_DM_API_SEND_VSC) + cmd_params_len; 1160 1161 NFA_TRACE_API1 ("NFA_SendVsCommand() oid=0x%x", oid); 1162 1163 if ((p_msg = (tNFA_DM_API_SEND_VSC *) GKI_getbuf (size)) != NULL) 1164 { 1165 p_msg->hdr.event = NFA_DM_API_SEND_VSC_EVT; 1166 p_msg->oid = oid; 1167 p_msg->p_cback = p_cback; 1168 if (cmd_params_len && p_cmd_params) 1169 { 1170 p_msg->cmd_params_len = cmd_params_len; 1171 p_msg->p_cmd_params = (UINT8 *)(p_msg + 1); 1172 memcpy (p_msg->p_cmd_params, p_cmd_params, cmd_params_len); 1173 } 1174 else 1175 { 1176 p_msg->cmd_params_len = 0; 1177 p_msg->p_cmd_params = NULL; 1178 } 1179 1180 nfa_sys_sendmsg (p_msg); 1181 1182 return (NFA_STATUS_OK); 1183 } 1184 1185 return (NFA_STATUS_FAILED); 1186 } 1187 1188 /******************************************************************************* 1189 ** 1190 ** Function NFA_SetTraceLevel 1191 ** 1192 ** Description This function sets the trace level for NFA. If called with 1193 ** a value of 0xFF, it simply returns the current trace level. 1194 ** 1195 ** Returns The new or current trace level 1196 ** 1197 *******************************************************************************/ 1198 UINT8 NFA_SetTraceLevel (UINT8 new_level) 1199 { 1200 if (new_level != 0xFF) 1201 nfa_sys_set_trace_level (new_level); 1202 1203 return (nfa_sys_cb.trace_level); 1204 } 1205 1206
