nfc_main.c revision ba4c17ee1d31e1b9f396292711f1414d449dd361
1/****************************************************************************** 2 * 3 * Copyright (C) 2010-2012 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19/****************************************************************************** 20 * 21 * This file contains functions that interface with the NFC NCI transport. 22 * On the receive side, it routes events to the appropriate handler 23 * (callback). On the transmit side, it manages the command transmission. 24 * 25 ******************************************************************************/ 26#include <string.h> 27#include "gki.h" 28#include "nfc_target.h" 29#include "bt_types.h" 30#include "hcidefs.h" 31 32#if (NFC_INCLUDED == TRUE) 33#include "nfc_hal_api.h" 34#include "nfc_api.h" 35#include "nfc_int.h" 36#include "nci_hmsgs.h" 37#include "rw_int.h" 38#include "ce_int.h" 39 40#if (NFC_RW_ONLY == FALSE) 41#include "ce_api.h" 42#include "ce_int.h" 43#include "llcp_int.h" 44 45/* NFC mandates support for at least one logical connection; 46 * Update max_conn to the NFCC capability on InitRsp */ 47#define NFC_SET_MAX_CONN_DEFAULT() {nfc_cb.max_conn = 1;} 48 49#else /* NFC_RW_ONLY */ 50#define ce_init() 51#define llcp_init() 52 53#define NFC_SET_MAX_CONN_DEFAULT() 54 55#endif /* NFC_RW_ONLY */ 56/**************************************************************************** 57** Declarations 58****************************************************************************/ 59#if NFC_DYNAMIC_MEMORY == FALSE 60tNFC_CB nfc_cb; 61#endif 62 63#if (NFC_RW_ONLY == FALSE) 64#define NFC_NUM_INTERFACE_MAP 2 65#else 66#define NFC_NUM_INTERFACE_MAP 1 67#endif 68 69static const tNCI_DISCOVER_MAPS nfc_interface_mapping[NFC_NUM_INTERFACE_MAP] = 70{ 71 /* Protocols that use Frame Interface do not need to be included in the interface mapping */ 72 { 73 NCI_PROTOCOL_ISO_DEP, 74 NCI_INTERFACE_MODE_POLL_N_LISTEN, 75 NCI_INTERFACE_ISO_DEP 76 } 77#if (NFC_RW_ONLY == FALSE) 78 , 79 /* this can not be set here due to 2079xB0 NFCC issues */ 80 { 81 NCI_PROTOCOL_NFC_DEP, 82 NCI_INTERFACE_MODE_POLL_N_LISTEN, 83 NCI_INTERFACE_NFC_DEP 84 } 85#endif 86}; 87 88 89#if (BT_TRACE_VERBOSE == TRUE) 90/******************************************************************************* 91** 92** Function nfc_state_name 93** 94** Description This function returns the state name. 95** 96** NOTE conditionally compiled to save memory. 97** 98** Returns pointer to the name 99** 100*******************************************************************************/ 101static char *nfc_state_name (UINT8 state) 102{ 103 switch (state) 104 { 105 case NFC_STATE_NONE: 106 return ("NONE"); 107 case NFC_STATE_W4_HAL_OPEN: 108 return ("W4_HAL_OPEN"); 109 case NFC_STATE_CORE_INIT: 110 return ("CORE_INIT"); 111 case NFC_STATE_W4_POST_INIT_CPLT: 112 return ("W4_POST_INIT_CPLT"); 113 case NFC_STATE_IDLE: 114 return ("IDLE"); 115 case NFC_STATE_OPEN: 116 return ("OPEN"); 117 case NFC_STATE_CLOSING: 118 return ("CLOSING"); 119 case NFC_STATE_W4_HAL_CLOSE: 120 return ("W4_HAL_CLOSE"); 121 case NFC_STATE_NFCC_POWER_OFF_SLEEP: 122 return ("NFCC_POWER_OFF_SLEEP"); 123 default: 124 return ("???? UNKNOWN STATE"); 125 } 126} 127 128/******************************************************************************* 129** 130** Function nfc_hal_event_name 131** 132** Description This function returns the HAL event name. 133** 134** NOTE conditionally compiled to save memory. 135** 136** Returns pointer to the name 137** 138*******************************************************************************/ 139static char *nfc_hal_event_name (UINT8 event) 140{ 141 switch (event) 142 { 143 case HAL_NFC_OPEN_CPLT_EVT: 144 return ("HAL_NFC_OPEN_CPLT_EVT"); 145 146 case HAL_NFC_CLOSE_CPLT_EVT: 147 return ("HAL_NFC_CLOSE_CPLT_EVT"); 148 149 case HAL_NFC_POST_INIT_CPLT_EVT: 150 return ("HAL_NFC_POST_INIT_CPLT_EVT"); 151 152 case HAL_NFC_PRE_DISCOVER_CPLT_EVT: 153 return ("HAL_NFC_PRE_DISCOVER_CPLT_EVT"); 154 155 case HAL_NFC_REQUEST_CONTROL_EVT: 156 return ("HAL_NFC_REQUEST_CONTROL_EVT"); 157 158 case HAL_NFC_RELEASE_CONTROL_EVT: 159 return ("HAL_NFC_RELEASE_CONTROL_EVT"); 160 161 case HAL_NFC_ERROR_EVT: 162 return ("HAL_NFC_ERROR_EVT"); 163 164 default: 165 return ("???? UNKNOWN EVENT"); 166 } 167} 168#endif /* BT_TRACE_VERBOSE == TRUE */ 169 170/******************************************************************************* 171** 172** Function nfc_main_notify_enable_status 173** 174** Description Notify status of Enable/PowerOffSleep/PowerCycle 175** 176*******************************************************************************/ 177static void nfc_main_notify_enable_status (tNFC_STATUS nfc_status) 178{ 179 tNFC_RESPONSE evt_data; 180 181 evt_data.status = nfc_status; 182 183 if (nfc_cb.p_resp_cback) 184 { 185 /* if getting out of PowerOffSleep mode or restarting NFCC */ 186 if (nfc_cb.flags & (NFC_FL_RESTARTING|NFC_FL_POWER_CYCLE_NFCC)) 187 { 188 nfc_cb.flags &= ~(NFC_FL_RESTARTING|NFC_FL_POWER_CYCLE_NFCC); 189 (*nfc_cb.p_resp_cback) (NFC_NFCC_RESTART_REVT, &evt_data); 190 } 191 else 192 { 193 (*nfc_cb.p_resp_cback) (NFC_ENABLE_REVT, &evt_data); 194 } 195 } 196} 197 198/******************************************************************************* 199** 200** Function nfc_enabled 201** 202** Description NFCC enabled, proceed with stack start up. 203** 204** Returns void 205** 206*******************************************************************************/ 207void nfc_enabled (tNFC_STATUS nfc_status, BT_HDR *p_init_rsp_msg) 208{ 209 tNFC_RESPONSE evt_data; 210 tNFC_CONN_CB *p_cb = &nfc_cb.conn_cb[NFC_RF_CONN_ID]; 211 UINT8 *p; 212 UINT8 num_interfaces = 0, xx; 213 int yy = 0; 214 215 memset (&evt_data, 0, sizeof (tNFC_RESPONSE)); 216 217 if (nfc_status == NCI_STATUS_OK) 218 { 219 nfc_set_state (NFC_STATE_IDLE); 220 221 p = (UINT8 *) (p_init_rsp_msg + 1) + p_init_rsp_msg->offset + NCI_MSG_HDR_SIZE + 1; 222 /* we currently only support NCI of the same version. 223 * We may need to change this, when we support multiple version of NFCC */ 224 evt_data.enable.nci_version = NCI_VERSION; 225 STREAM_TO_UINT32 (evt_data.enable.nci_features, p); 226 STREAM_TO_UINT8 (num_interfaces, p); 227 228 evt_data.enable.nci_interfaces = 0; 229 for (xx = 0; xx < num_interfaces; xx++) 230 { 231 if ((*p) <= NCI_INTERFACE_MAX) 232 evt_data.enable.nci_interfaces |= (1 << (*p)); 233 else if (((*p) > NCI_INTERFACE_FIRST_VS) && (yy < NFC_NFCC_MAX_NUM_VS_INTERFACE)) 234 { 235 /* save the VS RF interface in control block, if there's still room */ 236 nfc_cb.vs_interface[yy++] = *p; 237 } 238 p++; 239 } 240 nfc_cb.nci_interfaces = evt_data.enable.nci_interfaces; 241 memcpy (evt_data.enable.vs_interface, nfc_cb.vs_interface, NFC_NFCC_MAX_NUM_VS_INTERFACE); 242 evt_data.enable.max_conn = *p++; 243 STREAM_TO_UINT16 (evt_data.enable.max_ce_table, p); 244#if (NFC_RW_ONLY == FALSE) 245 nfc_cb.max_ce_table = evt_data.enable.max_ce_table; 246 nfc_cb.nci_features = evt_data.enable.nci_features; 247 nfc_cb.max_conn = evt_data.enable.max_conn; 248#endif 249 nfc_cb.nci_ctrl_size = *p++; /* Max Control Packet Payload Length */ 250 p_cb->init_credits = p_cb->num_buff = 0; 251 STREAM_TO_UINT16 (evt_data.enable.max_param_size, p); 252 nfc_set_conn_id (p_cb, NFC_RF_CONN_ID); 253 evt_data.enable.manufacture_id = *p++; 254 STREAM_TO_ARRAY (evt_data.enable.nfcc_info, p, NFC_NFCC_INFO_LEN); 255 NFC_DiscoveryMap (nfc_cb.num_disc_maps, (tNCI_DISCOVER_MAPS *) nfc_cb.p_disc_maps, NULL); 256 } 257 /* else not successful. the buffers will be freed in nfc_free_conn_cb () */ 258 else 259 { 260 nfc_free_conn_cb (p_cb); 261 262 /* if NFCC didn't respond to CORE_RESET or CORE_INIT */ 263 if (nfc_cb.nfc_state == NFC_STATE_CORE_INIT) 264 { 265 /* report status after closing HAL */ 266 nfc_cb.p_hal->close (); 267 return; 268 } 269 else 270 nfc_set_state (NFC_STATE_NONE); 271 } 272 273 nfc_main_notify_enable_status (nfc_status); 274} 275 276/******************************************************************************* 277** 278** Function nfc_set_state 279** 280** Description Set the state of NFC stack 281** 282** Returns void 283** 284*******************************************************************************/ 285void nfc_set_state (tNFC_STATE nfc_state) 286{ 287#if (BT_TRACE_VERBOSE == TRUE) 288 NFC_TRACE_DEBUG4 ("nfc_set_state %d (%s)->%d (%s)", nfc_cb.nfc_state, nfc_state_name (nfc_cb.nfc_state), nfc_state, nfc_state_name (nfc_state)); 289#else 290 NFC_TRACE_DEBUG2 ("nfc_set_state %d->%d", nfc_cb.nfc_state, nfc_state); 291#endif 292 nfc_cb.nfc_state = nfc_state; 293} 294 295/******************************************************************************* 296** 297** Function nfc_gen_cleanup 298** 299** Description Clean up for both going into low power mode and disabling NFC 300** 301*******************************************************************************/ 302void nfc_gen_cleanup (void) 303{ 304 nfc_cb.flags &= ~NFC_FL_DEACTIVATING; 305 306 /* the HAL pre-discover is still active - clear the pending flag/free the buffer */ 307 if (nfc_cb.flags & NFC_FL_DISCOVER_PENDING) 308 { 309 nfc_cb.flags &= ~NFC_FL_DISCOVER_PENDING; 310 GKI_freebuf (nfc_cb.p_disc_pending); 311 nfc_cb.p_disc_pending = NULL; 312 } 313 314 nfc_cb.flags &= ~(NFC_FL_CONTROL_REQUESTED|NFC_FL_CONTROL_GRANTED); 315 316 nfc_stop_timer (&nfc_cb.deactivate_timer); 317 318 /* Reset the connection control blocks */ 319 nfc_reset_all_conn_cbs (); 320 321 if (nfc_cb.p_nci_init_rsp) 322 { 323 GKI_freebuf (nfc_cb.p_nci_init_rsp); 324 nfc_cb.p_nci_init_rsp = NULL; 325 } 326 327 /* clear any pending CMD/RSP */ 328 nfc_main_flush_cmd_queue (); 329} 330 331/******************************************************************************* 332** 333** Function nfc_main_handle_hal_evt 334** 335** Description Handle BT_EVT_TO_NFC_MSGS 336** 337*******************************************************************************/ 338void nfc_main_handle_hal_evt (tNFC_HAL_EVT_MSG *p_msg) 339{ 340 UINT8 *ps; 341 342 NFC_TRACE_DEBUG1 ("nfc_main_handle_hal_evt(): HAL event=0x%x", p_msg->hal_evt); 343 344 switch (p_msg->hal_evt) 345 { 346 case HAL_NFC_OPEN_CPLT_EVT: /* only for failure case */ 347 nfc_enabled (NFC_STATUS_FAILED, NULL); 348 break; 349 350 case HAL_NFC_CLOSE_CPLT_EVT: 351 if (nfc_cb.p_resp_cback) 352 { 353 if (nfc_cb.nfc_state == NFC_STATE_W4_HAL_CLOSE) 354 { 355 if (nfc_cb.flags & NFC_FL_POWER_OFF_SLEEP) 356 { 357 nfc_cb.flags &= ~NFC_FL_POWER_OFF_SLEEP; 358 nfc_set_state (NFC_STATE_NFCC_POWER_OFF_SLEEP); 359 (*nfc_cb.p_resp_cback) (NFC_NFCC_POWER_OFF_REVT, NULL); 360 } 361 else 362 { 363 nfc_set_state (NFC_STATE_NONE); 364 (*nfc_cb.p_resp_cback) (NFC_DISABLE_REVT, NULL); 365 nfc_cb.p_resp_cback = NULL; 366 } 367 } 368 else 369 { 370 /* found error during initialization */ 371 nfc_set_state (NFC_STATE_NONE); 372 nfc_main_notify_enable_status (NFC_STATUS_FAILED); 373 } 374 } 375 break; 376 377 case HAL_NFC_POST_INIT_CPLT_EVT: 378 if (nfc_cb.p_nci_init_rsp) 379 { 380 /* 381 ** if NFC_Disable() is called before receiving HAL_NFC_POST_INIT_CPLT_EVT, 382 ** then wait for HAL_NFC_CLOSE_CPLT_EVT. 383 */ 384 if (nfc_cb.nfc_state == NFC_STATE_W4_POST_INIT_CPLT) 385 { 386 if (p_msg->status == HAL_NFC_STATUS_OK) 387 { 388 nfc_enabled (NCI_STATUS_OK, nfc_cb.p_nci_init_rsp); 389 } 390 else /* if post initailization failed */ 391 { 392 nfc_enabled (NCI_STATUS_FAILED, NULL); 393 } 394 } 395 396 GKI_freebuf (nfc_cb.p_nci_init_rsp); 397 nfc_cb.p_nci_init_rsp = NULL; 398 } 399 break; 400 401 case HAL_NFC_PRE_DISCOVER_CPLT_EVT: 402 /* restore the command window, no matter if the discover command is still pending */ 403 nfc_cb.nci_cmd_window = NCI_MAX_CMD_WINDOW; 404 nfc_cb.flags &= ~NFC_FL_CONTROL_GRANTED; 405 if (nfc_cb.flags & NFC_FL_DISCOVER_PENDING) 406 { 407 /* issue the discovery command now, if it is still pending */ 408 nfc_cb.flags &= ~NFC_FL_DISCOVER_PENDING; 409 ps = (UINT8 *)nfc_cb.p_disc_pending; 410 nci_snd_discover_cmd (*ps, (tNFC_DISCOVER_PARAMS *)(ps + 1)); 411 GKI_freebuf (nfc_cb.p_disc_pending); 412 nfc_cb.p_disc_pending = NULL; 413 } 414 else 415 { 416 /* check if there's other pending commands */ 417 nfc_ncif_check_cmd_queue (NULL); 418 } 419 420 if (p_msg->status == HAL_NFC_STATUS_ERR_CMD_TIMEOUT) 421 nfc_ncif_event_status (NFC_NFCC_TIMEOUT_REVT, NFC_STATUS_HW_TIMEOUT); 422 break; 423 424 case HAL_NFC_REQUEST_CONTROL_EVT: 425 nfc_cb.flags |= NFC_FL_CONTROL_REQUESTED; 426 nfc_ncif_check_cmd_queue (NULL); 427 break; 428 429 case HAL_NFC_RELEASE_CONTROL_EVT: 430 if (nfc_cb.flags & NFC_FL_CONTROL_GRANTED) 431 { 432 nfc_cb.flags &= ~NFC_FL_CONTROL_GRANTED; 433 nfc_cb.nci_cmd_window = NCI_MAX_CMD_WINDOW; 434 nfc_ncif_check_cmd_queue (NULL); 435 436 if (p_msg->status == HAL_NFC_STATUS_ERR_CMD_TIMEOUT) 437 nfc_ncif_event_status (NFC_NFCC_TIMEOUT_REVT, NFC_STATUS_HW_TIMEOUT); 438 } 439 break; 440 441 case HAL_NFC_ERROR_EVT: 442 switch (p_msg->status) 443 { 444 case HAL_NFC_STATUS_ERR_TRANSPORT: 445 /* Notify app of transport error */ 446 if (nfc_cb.p_resp_cback) 447 { 448 (*nfc_cb.p_resp_cback) (NFC_NFCC_TRANSPORT_ERR_REVT, NULL); 449 450 /* if enabling NFC, notify upper layer of failure after closing HAL */ 451 if (nfc_cb.nfc_state < NFC_STATE_IDLE) 452 { 453 nfc_enabled (NFC_STATUS_FAILED, NULL); 454 } 455 } 456 break; 457 458 case HAL_NFC_STATUS_ERR_CMD_TIMEOUT: 459 nfc_ncif_event_status (NFC_NFCC_TIMEOUT_REVT, NFC_STATUS_HW_TIMEOUT); 460 461 /* if enabling NFC, notify upper layer of failure after closing HAL */ 462 if (nfc_cb.nfc_state < NFC_STATE_IDLE) 463 { 464 nfc_enabled (NFC_STATUS_FAILED, NULL); 465 return; 466 } 467 break; 468 469 default: 470 break; 471 } 472 break; 473 474 default: 475 NFC_TRACE_ERROR1 ("nfc_main_handle_hal_evt (): unhandled event (0x%x).", p_msg->hal_evt); 476 break; 477 } 478} 479 480 481/******************************************************************************* 482** 483** Function nfc_main_flush_cmd_queue 484** 485** Description This function is called when setting power off sleep state. 486** 487** Returns void 488** 489*******************************************************************************/ 490void nfc_main_flush_cmd_queue (void) 491{ 492 BT_HDR *p_msg; 493 494 NFC_TRACE_DEBUG0 ("nfc_main_flush_cmd_queue ()"); 495 496 /* initialize command window */ 497 nfc_cb.nci_cmd_window = NCI_MAX_CMD_WINDOW; 498 499 /* Stop command-pending timer */ 500 nfc_stop_timer(&nfc_cb.nci_wait_rsp_timer); 501 502 /* dequeue and free buffer */ 503 while ((p_msg = (BT_HDR *)GKI_dequeue (&nfc_cb.nci_cmd_xmit_q)) != NULL) 504 { 505 GKI_freebuf (p_msg); 506 } 507} 508 509/******************************************************************************* 510** 511** Function nfc_main_post_hal_evt 512** 513** Description This function posts HAL event to NFC_TASK 514** 515** Returns void 516** 517*******************************************************************************/ 518void nfc_main_post_hal_evt (UINT8 hal_evt, tHAL_NFC_STATUS status) 519{ 520 tNFC_HAL_EVT_MSG *p_msg; 521 522 if ((p_msg = (tNFC_HAL_EVT_MSG *) GKI_getbuf (sizeof(tNFC_HAL_EVT_MSG))) != NULL) 523 { 524 /* Initialize BT_HDR */ 525 p_msg->hdr.len = 0; 526 p_msg->hdr.event = BT_EVT_TO_NFC_MSGS; 527 p_msg->hdr.offset = 0; 528 p_msg->hdr.layer_specific = 0; 529 p_msg->hal_evt = hal_evt; 530 p_msg->status = status; 531 GKI_send_msg (NFC_TASK, NFC_MBOX_ID, p_msg); 532 } 533 else 534 { 535 NFC_TRACE_ERROR0 ("nfc_main_post_hal_evt (): No buffer"); 536 } 537} 538 539 540/******************************************************************************* 541** 542** Function nfc_main_hal_cback 543** 544** Description HAL event handler 545** 546** Returns void 547** 548*******************************************************************************/ 549static void nfc_main_hal_cback(UINT8 event, tHAL_NFC_STATUS status) 550{ 551#if (BT_TRACE_VERBOSE == TRUE) 552 NFC_TRACE_DEBUG3 ("nfc_main_hal_cback event: %s(0x%x), status=%d", 553 nfc_hal_event_name (event), event, status); 554#else 555 NFC_TRACE_DEBUG2 ("nfc_main_hal_cback event: 0x%x, status=%d", event, status); 556#endif 557 558 switch (event) 559 { 560 case HAL_NFC_OPEN_CPLT_EVT: 561 /* 562 ** if NFC_Disable() is called before receiving HAL_NFC_OPEN_CPLT_EVT, 563 ** then wait for HAL_NFC_CLOSE_CPLT_EVT. 564 */ 565 if (nfc_cb.nfc_state == NFC_STATE_W4_HAL_OPEN) 566 { 567 if (status == HAL_NFC_STATUS_OK) 568 { 569 /* Notify NFC_TASK that NCI tranport is initialized */ 570 GKI_send_event (NFC_TASK, NFC_TASK_EVT_TRANSPORT_READY); 571 } 572 else 573 { 574 nfc_main_post_hal_evt (event, status); 575 } 576 } 577 break; 578 579 case HAL_NFC_CLOSE_CPLT_EVT: 580 case HAL_NFC_POST_INIT_CPLT_EVT: 581 case HAL_NFC_PRE_DISCOVER_CPLT_EVT: 582 case HAL_NFC_REQUEST_CONTROL_EVT: 583 case HAL_NFC_RELEASE_CONTROL_EVT: 584 case HAL_NFC_ERROR_EVT: 585 nfc_main_post_hal_evt (event, status); 586 break; 587 588 default: 589 NFC_TRACE_DEBUG1 ("nfc_main_hal_cback unhandled event %x", event); 590 break; 591 } 592} 593 594/******************************************************************************* 595** 596** Function nfc_main_hal_data_cback 597** 598** Description HAL data event handler 599** 600** Returns void 601** 602*******************************************************************************/ 603static void nfc_main_hal_data_cback(UINT16 data_len, UINT8 *p_data) 604{ 605 BT_HDR *p_msg; 606 607 /* ignore all data while shutting down NFCC */ 608 if (nfc_cb.nfc_state == NFC_STATE_W4_HAL_CLOSE) 609 { 610 return; 611 } 612 613 if (p_data) 614 { 615 if ((p_msg = (BT_HDR *) GKI_getpoolbuf (NFC_NCI_POOL_ID)) != NULL) 616 { 617 /* Initialize BT_HDR */ 618 p_msg->len = data_len; 619 p_msg->event = BT_EVT_TO_NFC_NCI; 620 p_msg->offset = NFC_RECEIVE_MSGS_OFFSET; 621 622 /* no need to check length, it always less than pool size */ 623 memcpy ((UINT8 *)(p_msg + 1) + p_msg->offset, p_data, p_msg->len); 624 625 GKI_send_msg (NFC_TASK, NFC_MBOX_ID, p_msg); 626 } 627 else 628 { 629 NFC_TRACE_ERROR0 ("nfc_main_hal_data_cback (): No buffer"); 630 } 631 } 632} 633 634/******************************************************************************* 635** 636** Function NFC_Enable 637** 638** Description This function enables NFC. Prior to calling NFC_Enable: 639** - the NFCC must be powered up, and ready to receive commands. 640** - GKI must be enabled 641** - NFC_TASK must be started 642** - NCIT_TASK must be started (if using dedicated NCI transport) 643** 644** This function opens the NCI transport (if applicable), 645** resets the NFC controller, and initializes the NFC subsystems. 646** 647** When the NFC startup procedure is completed, an 648** NFC_ENABLE_REVT is returned to the application using the 649** tNFC_RESPONSE_CBACK. 650** 651** Returns tNFC_STATUS 652** 653*******************************************************************************/ 654tNFC_STATUS NFC_Enable (tNFC_RESPONSE_CBACK *p_cback) 655{ 656 NFC_TRACE_API0 ("NFC_Enable ()"); 657 658 /* Validate callback */ 659 if (!p_cback) 660 { 661 return (NFC_STATUS_INVALID_PARAM); 662 } 663 nfc_cb.p_resp_cback = p_cback; 664 665 /* Open HAL transport. */ 666 nfc_set_state (NFC_STATE_W4_HAL_OPEN); 667 nfc_cb.p_hal->open (nfc_main_hal_cback, nfc_main_hal_data_cback); 668 669 return (NFC_STATUS_OK); 670} 671 672/******************************************************************************* 673** 674** Function NFC_Disable 675** 676** Description This function performs clean up routines for shutting down 677** NFC and closes the NCI transport (if using dedicated NCI 678** transport). 679** 680** When the NFC shutdown procedure is completed, an 681** NFC_DISABLED_REVT is returned to the application using the 682** tNFC_RESPONSE_CBACK. 683** 684** Returns nothing 685** 686*******************************************************************************/ 687void NFC_Disable (void) 688{ 689 NFC_TRACE_API1 ("NFC_Disable (): nfc_state = %d", nfc_cb.nfc_state); 690 691 if (nfc_cb.nfc_state == NFC_STATE_NONE) 692 { 693 if (nfc_cb.p_resp_cback) 694 { 695 (*nfc_cb.p_resp_cback) (NFC_DISABLE_REVT, NULL); 696 nfc_cb.p_resp_cback = NULL; 697 } 698 return; 699 } 700 701 /* Close transport and clean up */ 702 nfc_task_shutdown_nfcc (); 703} 704 705/******************************************************************************* 706** 707** Function NFC_Init 708** 709** Description This function initializes control block for NFC 710** 711** Returns nothing 712** 713*******************************************************************************/ 714void NFC_Init (tHAL_NFC_ENTRY *p_hal_entry_tbl) 715{ 716 int xx; 717 718 /* Clear nfc control block */ 719 memset (&nfc_cb, 0, sizeof (tNFC_CB)); 720 721 /* Reset the nfc control block */ 722 for (xx = 0; xx < NCI_MAX_CONN_CBS; xx++) 723 { 724 nfc_cb.conn_cb[xx].conn_id = NFC_ILLEGAL_CONN_ID; 725 } 726 727 /* NCI init */ 728 nfc_cb.p_hal = p_hal_entry_tbl; 729 nfc_cb.nfc_state = NFC_STATE_NONE; 730 nfc_cb.nci_cmd_window = NCI_MAX_CMD_WINDOW; 731 nfc_cb.nci_wait_rsp_tout= NFC_CMD_CMPL_TIMEOUT; 732 nfc_cb.p_disc_maps = nfc_interface_mapping; 733 nfc_cb.num_disc_maps = NFC_NUM_INTERFACE_MAP; 734 nfc_cb.trace_level = NFC_INITIAL_TRACE_LEVEL; 735 nfc_cb.nci_ctrl_size = NCI_CTRL_INIT_SIZE; 736 737 rw_init (); 738 ce_init (); 739 llcp_init (); 740 NFC_SET_MAX_CONN_DEFAULT (); 741} 742 743/******************************************************************************* 744** 745** Function NFC_GetLmrtSize 746** 747** Description Called by application wto query the Listen Mode Routing 748** Table size supported by NFCC 749** 750** Returns Listen Mode Routing Table size 751** 752*******************************************************************************/ 753UINT16 NFC_GetLmrtSize (void) 754{ 755 UINT16 size = 0; 756#if (NFC_RW_ONLY == FALSE) 757 size = nfc_cb.max_ce_table; 758#endif 759 return size; 760} 761 762 763/******************************************************************************* 764** 765** Function NFC_SetConfig 766** 767** Description This function is called to send the configuration parameter 768** TLV to NFCC. The response from NFCC is reported by 769** tNFC_RESPONSE_CBACK as NFC_SET_CONFIG_REVT. 770** 771** Parameters tlv_size - the length of p_param_tlvs. 772** p_param_tlvs - the parameter ID/Len/Value list 773** 774** Returns tNFC_STATUS 775** 776*******************************************************************************/ 777tNFC_STATUS NFC_SetConfig (UINT8 tlv_size, 778 UINT8 *p_param_tlvs) 779{ 780 return nci_snd_core_set_config (p_param_tlvs, tlv_size); 781} 782 783/******************************************************************************* 784** 785** Function NFC_GetConfig 786** 787** Description This function is called to retrieve the parameter TLV from NFCC. 788** The response from NFCC is reported by tNFC_RESPONSE_CBACK 789** as NFC_GET_CONFIG_REVT. 790** 791** Parameters num_ids - the number of parameter IDs 792** p_param_ids - the parameter ID list. 793** 794** Returns tNFC_STATUS 795** 796*******************************************************************************/ 797tNFC_STATUS NFC_GetConfig (UINT8 num_ids, 798 UINT8 *p_param_ids) 799{ 800 return nci_snd_core_get_config (p_param_ids, num_ids); 801} 802 803/******************************************************************************* 804** 805** Function NFC_DiscoveryMap 806** 807** Description This function is called to set the discovery interface mapping. 808** The response from NFCC is reported by tNFC_DISCOVER_CBACK as. 809** NFC_MAP_DEVT. 810** 811** Parameters num - the number of items in p_params. 812** p_maps - the discovery interface mappings 813** p_cback - the discovery callback function 814** 815** Returns tNFC_STATUS 816** 817*******************************************************************************/ 818tNFC_STATUS NFC_DiscoveryMap (UINT8 num, tNFC_DISCOVER_MAPS *p_maps, 819 tNFC_DISCOVER_CBACK *p_cback) 820{ 821 UINT8 num_disc_maps = num; 822 UINT8 xx, yy, num_intf, intf_mask; 823 tNFC_DISCOVER_MAPS max_maps[NFC_NFCC_MAX_NUM_VS_INTERFACE + NCI_INTERFACE_MAX]; 824 BOOLEAN is_supported; 825 826 nfc_cb.p_discv_cback = p_cback; 827 num_intf = 0; 828 NFC_TRACE_DEBUG1 ("nci_interfaces supported by NFCC: 0x%x", nfc_cb.nci_interfaces); 829 for (xx = 0; xx < num_disc_maps; xx++) 830 { 831 is_supported = FALSE; 832 if (p_maps[xx].intf_type > NCI_INTERFACE_MAX) 833 { 834 for (yy = 0; yy < NFC_NFCC_MAX_NUM_VS_INTERFACE; yy++) 835 { 836 if (nfc_cb.vs_interface[yy] == p_maps[xx].intf_type) 837 is_supported = TRUE; 838 } 839 NFC_TRACE_DEBUG3 ("[%d]: vs intf_type:0x%x is_supported:%d", xx, p_maps[xx].intf_type, is_supported); 840 } 841 else 842 { 843 intf_mask = (1 << (p_maps[xx].intf_type)); 844 if (intf_mask & nfc_cb.nci_interfaces) 845 { 846 is_supported = TRUE; 847 } 848 NFC_TRACE_DEBUG4 ("[%d]: intf_type:%d intf_mask: 0x%x is_supported:%d", xx, p_maps[xx].intf_type, intf_mask, is_supported); 849 } 850 if (is_supported) 851 memcpy (&max_maps[num_intf++], &p_maps[xx], sizeof (tNFC_DISCOVER_MAPS)); 852 else 853 { 854 NFC_TRACE_WARNING1 ("NFC_DiscoveryMap interface=0x%x is not supported by NFCC", p_maps[xx].intf_type); 855 } 856 } 857 858 return nci_snd_discover_map_cmd (num_intf, (tNCI_DISCOVER_MAPS *) max_maps); 859} 860 861/******************************************************************************* 862** 863** Function NFC_DiscoveryStart 864** 865** Description This function is called to start Polling and/or Listening. 866** The response from NFCC is reported by tNFC_DISCOVER_CBACK as. 867** NFC_START_DEVT. The notification from NFCC is reported by 868** tNFC_DISCOVER_CBACK as NFC_RESULT_DEVT. 869** 870** Parameters num_params - the number of items in p_params. 871** p_params - the discovery parameters 872** p_cback - the discovery callback function 873** 874** Returns tNFC_STATUS 875** 876*******************************************************************************/ 877tNFC_STATUS NFC_DiscoveryStart (UINT8 num_params, 878 tNFC_DISCOVER_PARAMS *p_params, 879 tNFC_DISCOVER_CBACK *p_cback) 880{ 881 UINT8 *p; 882 int params_size; 883 tNFC_STATUS status = NFC_STATUS_NO_BUFFERS; 884 885 NFC_TRACE_API0 ("NFC_DiscoveryStart"); 886 if (nfc_cb.p_disc_pending) 887 { 888 NFC_TRACE_ERROR0 ("There's pending NFC_DiscoveryStart"); 889 status = NFC_STATUS_BUSY; 890 } 891 else 892 { 893 nfc_cb.p_discv_cback = p_cback; 894 nfc_cb.flags |= NFC_FL_DISCOVER_PENDING; 895 nfc_cb.flags |= NFC_FL_CONTROL_REQUESTED; 896 params_size = sizeof (tNFC_DISCOVER_PARAMS) * num_params; 897 nfc_cb.p_disc_pending = GKI_getbuf ((UINT16)(BT_HDR_SIZE + 1 + params_size)); 898 if (nfc_cb.p_disc_pending) 899 { 900 p = (UINT8 *)nfc_cb.p_disc_pending; 901 *p++ = num_params; 902 memcpy (p, p_params, params_size); 903 status = NFC_STATUS_CMD_STARTED; 904 nfc_ncif_check_cmd_queue (NULL); 905 } 906 } 907 908 NFC_TRACE_API1 ("NFC_DiscoveryStart status: 0x%x", status); 909 return status; 910} 911 912/******************************************************************************* 913** 914** Function NFC_DiscoverySelect 915** 916** Description If tNFC_DISCOVER_CBACK reports status=NFC_MULTIPLE_PROT, 917** the application needs to use this function to select the 918** the logical endpoint to continue. The response from NFCC is 919** reported by tNFC_DISCOVER_CBACK as NFC_SELECT_DEVT. 920** 921** Parameters rf_disc_id - The ID identifies the remote device. 922** protocol - the logical endpoint on the remote devide 923** rf_interface - the RF interface to communicate with NFCC 924** 925** Returns tNFC_STATUS 926** 927*******************************************************************************/ 928tNFC_STATUS NFC_DiscoverySelect (UINT8 rf_disc_id, 929 UINT8 protocol, 930 UINT8 rf_interface) 931{ 932 return nci_snd_discover_select_cmd (rf_disc_id, protocol, rf_interface); 933} 934 935/******************************************************************************* 936** 937** Function NFC_ConnCreate 938** 939** Description This function is called to create a logical connection with 940** NFCC for data exchange. 941** 942** Parameters dest_type - the destination type 943** id - the NFCEE ID or RF Discovery ID . 944** protocol - the protocol. 945** p_cback - the connection callback function 946** 947** Returns tNFC_STATUS 948** 949*******************************************************************************/ 950tNFC_STATUS NFC_ConnCreate (UINT8 dest_type, 951 UINT8 id, 952 UINT8 protocol, 953 tNFC_CONN_CBACK *p_cback) 954{ 955 tNFC_STATUS status = NFC_STATUS_FAILED; 956 tNFC_CONN_CB *p_cb; 957 UINT8 num_tlv=0, tlv_size=0; 958 UINT8 param_tlvs[4], *pp; 959 960 p_cb = nfc_alloc_conn_cb (p_cback); 961 if (p_cb) 962 { 963 p_cb->id = id; 964 pp = param_tlvs; 965 if (dest_type == NCI_DEST_TYPE_NFCEE) 966 { 967 num_tlv = 1; 968 UINT8_TO_STREAM (pp, NCI_CON_CREATE_TAG_NFCEE_VAL); 969 UINT8_TO_STREAM (pp, 2); 970 UINT8_TO_STREAM (pp, id); 971 UINT8_TO_STREAM (pp, protocol); 972 tlv_size = 4; 973 } 974 else if (dest_type == NCI_DEST_TYPE_REMOTE) 975 { 976 num_tlv = 1; 977 UINT8_TO_STREAM (pp, NCI_CON_CREATE_TAG_RF_DISC_ID); 978 UINT8_TO_STREAM (pp, 1); 979 UINT8_TO_STREAM (pp, id); 980 tlv_size = 3; 981 } 982 else if (dest_type == NCI_DEST_TYPE_NFCC) 983 { 984 p_cb->id = NFC_TEST_ID; 985 } 986 /* Add handling of NCI_DEST_TYPE_REMOTE when more RF interface definitions are added */ 987 p_cb->act_protocol = protocol; 988 p_cb->p_cback = p_cback; 989 status = nci_snd_core_conn_create (dest_type, num_tlv, tlv_size, param_tlvs); 990 if (status == NFC_STATUS_FAILED) 991 nfc_free_conn_cb (p_cb); 992 } 993 return status; 994} 995 996/******************************************************************************* 997** 998** Function NFC_ConnClose 999** 1000** Description This function is called to close a logical connection with 1001** NFCC. 1002** 1003** Parameters conn_id - the connection id. 1004** 1005** Returns tNFC_STATUS 1006** 1007*******************************************************************************/ 1008tNFC_STATUS NFC_ConnClose (UINT8 conn_id) 1009{ 1010 tNFC_CONN_CB *p_cb = nfc_find_conn_cb_by_conn_id (conn_id); 1011 tNFC_STATUS status = NFC_STATUS_FAILED; 1012 1013 if (p_cb) 1014 { 1015 status = nci_snd_core_conn_close (conn_id); 1016 } 1017 return status; 1018} 1019 1020/******************************************************************************* 1021** 1022** Function NFC_SetStaticRfCback 1023** 1024** Description This function is called to update the data callback function 1025** to receive the data for the given connection id. 1026** 1027** Parameters p_cback - the connection callback function 1028** 1029** Returns Nothing 1030** 1031*******************************************************************************/ 1032void NFC_SetStaticRfCback (tNFC_CONN_CBACK *p_cback) 1033{ 1034 tNFC_CONN_CB * p_cb = &nfc_cb.conn_cb[NFC_RF_CONN_ID]; 1035 1036 p_cb->p_cback = p_cback; 1037 /* just in case DH has received NCI data before the data callback is set 1038 * check if there's any data event to report on this connection id */ 1039 nfc_data_event (p_cb); 1040} 1041 1042/******************************************************************************* 1043** 1044** Function NFC_SendData 1045** 1046** Description This function is called to send the given data packet 1047** to the connection identified by the given connection id. 1048** 1049** Parameters conn_id - the connection id. 1050** p_data - the data packet. 1051** p_data->offset must be >= NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE 1052** The data payload starts at ((UINT8 *) (p_data + 1) + p_data->offset) 1053** 1054** Returns tNFC_STATUS 1055** 1056*******************************************************************************/ 1057tNFC_STATUS NFC_SendData (UINT8 conn_id, 1058 BT_HDR *p_data) 1059{ 1060 tNFC_STATUS status = NFC_STATUS_FAILED; 1061 tNFC_CONN_CB *p_cb = nfc_find_conn_cb_by_conn_id (conn_id); 1062 1063 if (p_cb && p_data && p_data->offset >= NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE) 1064 { 1065 status = nfc_ncif_send_data (p_cb, p_data); 1066 } 1067 1068 if (status != NFC_STATUS_OK) 1069 GKI_freebuf (p_data); 1070 1071 return status; 1072} 1073 1074/******************************************************************************* 1075** 1076** Function NFC_FlushData 1077** 1078** Description This function is called to discard the tx data queue of 1079** the given connection id. 1080** 1081** Parameters conn_id - the connection id. 1082** 1083** Returns tNFC_STATUS 1084** 1085*******************************************************************************/ 1086tNFC_STATUS NFC_FlushData (UINT8 conn_id) 1087{ 1088 tNFC_STATUS status = NFC_STATUS_FAILED; 1089 tNFC_CONN_CB *p_cb = nfc_find_conn_cb_by_conn_id (conn_id); 1090 void *p_buf; 1091 1092 if (p_cb) 1093 { 1094 status = NFC_STATUS_OK; 1095 while ((p_buf = GKI_dequeue (&p_cb->tx_q)) != NULL) 1096 GKI_freebuf (p_buf); 1097 } 1098 1099 return status; 1100} 1101 1102/******************************************************************************* 1103** 1104** Function NFC_Deactivate 1105** 1106** Description This function is called to stop the discovery process or 1107** put the listen device in sleep mode or terminate the NFC link. 1108** 1109** The response from NFCC is reported by tNFC_DISCOVER_CBACK 1110** as NFC_DEACTIVATE_DEVT. 1111** 1112** Parameters deactivate_type - NFC_DEACTIVATE_TYPE_IDLE, to IDLE mode. 1113** NFC_DEACTIVATE_TYPE_SLEEP to SLEEP mode. 1114** NFC_DEACTIVATE_TYPE_SLEEP_AF to SLEEP_AF mode. 1115** 1116** Returns tNFC_STATUS 1117** 1118*******************************************************************************/ 1119tNFC_STATUS NFC_Deactivate (tNFC_DEACT_TYPE deactivate_type) 1120{ 1121 tNFC_CONN_CB * p_cb = &nfc_cb.conn_cb[NFC_RF_CONN_ID]; 1122 tNFC_STATUS status = NFC_STATUS_OK; 1123 1124#if (BT_TRACE_VERBOSE == TRUE) 1125 NFC_TRACE_API3 ("NFC_Deactivate %d (%s) deactivate_type:%d", nfc_cb.nfc_state, nfc_state_name (nfc_cb.nfc_state), deactivate_type); 1126#else 1127 NFC_TRACE_API2 ("NFC_Deactivate %d deactivate_type:%d", nfc_cb.nfc_state, deactivate_type); 1128#endif 1129 1130 if (nfc_cb.flags & NFC_FL_DISCOVER_PENDING) 1131 { 1132 /* the HAL pre-discover is still active - clear the pending flag */ 1133 nfc_cb.flags &= ~NFC_FL_DISCOVER_PENDING; 1134 GKI_freebuf (nfc_cb.p_disc_pending); 1135 nfc_cb.p_disc_pending = NULL; 1136 return NFC_STATUS_OK; 1137 } 1138 1139 if (nfc_cb.nfc_state == NFC_STATE_OPEN) 1140 { 1141 nfc_set_state (NFC_STATE_CLOSING); 1142 NFC_TRACE_DEBUG3 ( "act_protocol %d credits:%d/%d", p_cb->act_protocol, p_cb->init_credits, p_cb->num_buff); 1143 if ((p_cb->act_protocol == NCI_PROTOCOL_NFC_DEP) && 1144 (p_cb->init_credits != p_cb->num_buff)) 1145 { 1146 nfc_cb.flags |= NFC_FL_DEACTIVATING; 1147 nfc_cb.deactivate_timer.param = (TIMER_PARAM_TYPE) deactivate_type; 1148 nfc_start_timer (&nfc_cb.deactivate_timer , (UINT16) (NFC_TTYPE_WAIT_2_DEACTIVATE), NFC_DEACTIVATE_TIMEOUT); 1149 return status; 1150 } 1151 } 1152 1153 status = nci_snd_deactivate_cmd (deactivate_type); 1154 return status; 1155} 1156 1157/******************************************************************************* 1158** 1159** Function NFC_UpdateRFCommParams 1160** 1161** Description This function is called to update RF Communication parameters 1162** once the Frame RF Interface has been activated. 1163** 1164** The response from NFCC is reported by tNFC_RESPONSE_CBACK 1165** as NFC_RF_COMM_PARAMS_UPDATE_REVT. 1166** 1167** Returns tNFC_STATUS 1168** 1169*******************************************************************************/ 1170tNFC_STATUS NFC_UpdateRFCommParams (tNFC_RF_COMM_PARAMS *p_params) 1171{ 1172 UINT8 tlvs[12]; 1173 UINT8 *p = tlvs; 1174 UINT8 data_exch_config; 1175 1176 /* RF Technology and Mode */ 1177 if (p_params->include_rf_tech_mode) 1178 { 1179 UINT8_TO_STREAM (p, NCI_RF_PARAM_ID_TECH_N_MODE); 1180 UINT8_TO_STREAM (p, 1); 1181 UINT8_TO_STREAM (p, p_params->rf_tech_n_mode); 1182 } 1183 1184 /* Transmit Bit Rate */ 1185 if (p_params->include_tx_bit_rate) 1186 { 1187 UINT8_TO_STREAM (p, NCI_RF_PARAM_ID_TX_BIT_RATE); 1188 UINT8_TO_STREAM (p, 1); 1189 UINT8_TO_STREAM (p, p_params->tx_bit_rate); 1190 } 1191 1192 /* Receive Bit Rate */ 1193 if (p_params->include_tx_bit_rate) 1194 { 1195 UINT8_TO_STREAM (p, NCI_RF_PARAM_ID_RX_BIT_RATE); 1196 UINT8_TO_STREAM (p, 1); 1197 UINT8_TO_STREAM (p, p_params->rx_bit_rate); 1198 } 1199 1200 /* NFC-B Data Exchange Configuration */ 1201 if (p_params->include_nfc_b_config) 1202 { 1203 UINT8_TO_STREAM (p, NCI_RF_PARAM_ID_B_DATA_EX_PARAM); 1204 UINT8_TO_STREAM (p, 1); 1205 1206 data_exch_config = (p_params->min_tr0 & 0x03) << 6; /* b7b6 : Mininum TR0 */ 1207 data_exch_config |= (p_params->min_tr1 & 0x03) << 4; /* b5b4 : Mininum TR1 */ 1208 data_exch_config |= (p_params->suppression_eos & 0x01) << 3; /* b3 : Suppression of EoS */ 1209 data_exch_config |= (p_params->suppression_sos & 0x01) << 2; /* b2 : Suppression of SoS */ 1210 data_exch_config |= (p_params->min_tr2 & 0x03); /* b1b0 : Mininum TR2 */ 1211 1212 UINT8_TO_STREAM (p, data_exch_config); 1213 } 1214 1215 return nci_snd_parameter_update_cmd (tlvs, (UINT8) (p - tlvs)); 1216} 1217 1218/******************************************************************************* 1219** 1220** Function NFC_SetPowerOffSleep 1221** 1222** Description This function closes/opens transport and turns off/on NFCC. 1223** 1224** Returns tNFC_STATUS 1225** 1226*******************************************************************************/ 1227tNFC_STATUS NFC_SetPowerOffSleep (BOOLEAN enable) 1228{ 1229 NFC_TRACE_API1 ("NFC_SetPowerOffSleep () enable = %d", enable); 1230 1231 if ( (enable == FALSE) 1232 &&(nfc_cb.nfc_state == NFC_STATE_NFCC_POWER_OFF_SLEEP) ) 1233 { 1234 nfc_cb.flags |= NFC_FL_RESTARTING; 1235 1236 /* open transport */ 1237 nfc_set_state (NFC_STATE_W4_HAL_OPEN); 1238 nfc_cb.p_hal->open (nfc_main_hal_cback, nfc_main_hal_data_cback); 1239 1240 return NFC_STATUS_OK; 1241 } 1242 else if ( (enable == TRUE) 1243 &&(nfc_cb.nfc_state == NFC_STATE_IDLE) ) 1244 { 1245 /* close transport to turn off NFCC and clean up */ 1246 nfc_cb.flags |= NFC_FL_POWER_OFF_SLEEP; 1247 nfc_task_shutdown_nfcc (); 1248 1249 return NFC_STATUS_OK; 1250 } 1251 1252 NFC_TRACE_ERROR1 ("NFC_SetPowerOffSleep () invalid state = %d", nfc_cb.nfc_state); 1253 return NFC_STATUS_FAILED; 1254} 1255 1256/******************************************************************************* 1257** 1258** Function NFC_PowerCycleNFCC 1259** 1260** Description This function turns off and then on NFCC. 1261** 1262** Returns tNFC_STATUS 1263** 1264*******************************************************************************/ 1265tNFC_STATUS NFC_PowerCycleNFCC (void) 1266{ 1267 NFC_TRACE_API0 ("NFC_PowerCycleNFCC ()"); 1268 1269 if (nfc_cb.nfc_state == NFC_STATE_IDLE) 1270 { 1271 /* power cycle NFCC */ 1272 nfc_cb.flags |= NFC_FL_POWER_CYCLE_NFCC; 1273 nfc_task_shutdown_nfcc (); 1274 1275 return NFC_STATUS_OK; 1276 } 1277 1278 NFC_TRACE_ERROR1 ("NFC_PowerCycleNFCC () invalid state = %d", nfc_cb.nfc_state); 1279 return NFC_STATUS_FAILED; 1280} 1281 1282 1283/******************************************************************************* 1284** 1285** Function NFC_SetTraceLevel 1286** 1287** Description This function sets the trace level for NFC. If called with 1288** a value of 0xFF, it simply returns the current trace level. 1289** 1290** Returns The new or current trace level 1291** 1292*******************************************************************************/ 1293UINT8 NFC_SetTraceLevel (UINT8 new_level) 1294{ 1295 NFC_TRACE_API1 ("NFC_SetTraceLevel () new_level = %d", new_level); 1296 1297 if (new_level != 0xFF) 1298 nfc_cb.trace_level = new_level; 1299 1300 return (nfc_cb.trace_level); 1301} 1302 1303 1304#endif /* NFC_INCLUDED == TRUE */ 1305