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 * 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*******************************************************************************/ 54void 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*******************************************************************************/ 97tNFA_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*******************************************************************************/ 145tNFA_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*******************************************************************************/ 181tNFA_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*******************************************************************************/ 220tNFA_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*******************************************************************************/ 280tNFA_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*******************************************************************************/ 326tNFA_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*******************************************************************************/ 379tNFA_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*******************************************************************************/ 412tNFA_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*******************************************************************************/ 451tNFA_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*******************************************************************************/ 484tNFA_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*******************************************************************************/ 521tNFA_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*******************************************************************************/ 554tNFA_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*******************************************************************************/ 591tNFA_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*******************************************************************************/ 623tNFA_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*******************************************************************************/ 653tNFA_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*******************************************************************************/ 692tNFA_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*******************************************************************************/ 730tNFA_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*******************************************************************************/ 775tNFA_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*******************************************************************************/ 821NFC_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*******************************************************************************/ 857tNFA_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*******************************************************************************/ 918tNFA_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*******************************************************************************/ 975NFC_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*******************************************************************************/ 1034NFC_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*******************************************************************************/ 1068tNFA_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*******************************************************************************/ 1109tNFC_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*******************************************************************************/ 1153tNFA_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*******************************************************************************/ 1198UINT8 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