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