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