1 /****************************************************************************** 2 * 3 * Copyright (C) 2014 The Android Open Source Project 4 * Copyright (C) 2009-2012 Broadcom Corporation 5 * 6 * Licensed under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at: 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 * 18 ******************************************************************************/ 19 20 /************************************************************************************ 21 * 22 * Filename: btif_core.c 23 * 24 * Description: Contains core functionality related to interfacing between 25 * Bluetooth HAL and BTE core stack. 26 * 27 ***********************************************************************************/ 28 29 #include <stdlib.h> 30 #include <hardware/bluetooth.h> 31 #include <string.h> 32 #include <sys/types.h> 33 #include <sys/stat.h> 34 #include <fcntl.h> 35 #include <dirent.h> 36 #include <ctype.h> 37 #include <cutils/properties.h> 38 39 #define LOG_TAG "BTIF_CORE" 40 #include "btif_api.h" 41 #include "bt_utils.h" 42 #include "bta_api.h" 43 #include "gki.h" 44 #include "btu.h" 45 #include "bte.h" 46 #include "bd.h" 47 #include "btif_av.h" 48 #include "btif_storage.h" 49 #include "btif_util.h" 50 #include "btif_sock.h" 51 #include "btif_pan.h" 52 #include "btif_mce.h" 53 #include "btif_profile_queue.h" 54 #include "btif_config.h" 55 /************************************************************************************ 56 ** Constants & Macros 57 ************************************************************************************/ 58 59 #ifndef BTIF_TASK_STACK_SIZE 60 #define BTIF_TASK_STACK_SIZE 0x2000 /* In bytes */ 61 #endif 62 63 #ifndef BTE_DID_CONF_FILE 64 #define BTE_DID_CONF_FILE "/etc/bluetooth/bt_did.conf" 65 #endif 66 67 #define BTIF_TASK_STR ((INT8 *) "BTIF") 68 69 /************************************************************************************ 70 ** Local type definitions 71 ************************************************************************************/ 72 73 /* These type definitions are used when passing data from the HAL to BTIF context 74 * in the downstream path for the adapter and remote_device property APIs */ 75 76 typedef struct { 77 bt_bdaddr_t bd_addr; 78 bt_property_type_t type; 79 } btif_storage_read_t; 80 81 typedef struct { 82 bt_bdaddr_t bd_addr; 83 bt_property_t prop; 84 } btif_storage_write_t; 85 86 typedef union { 87 btif_storage_read_t read_req; 88 btif_storage_write_t write_req; 89 } btif_storage_req_t; 90 91 typedef enum { 92 BTIF_CORE_STATE_DISABLED = 0, 93 BTIF_CORE_STATE_ENABLING, 94 BTIF_CORE_STATE_ENABLED, 95 BTIF_CORE_STATE_DISABLING 96 } btif_core_state_t; 97 98 /************************************************************************************ 99 ** Static variables 100 ************************************************************************************/ 101 102 bt_bdaddr_t btif_local_bd_addr; 103 104 static UINT32 btif_task_stack[(BTIF_TASK_STACK_SIZE + 3) / 4]; 105 106 /* holds main adapter state */ 107 static btif_core_state_t btif_core_state = BTIF_CORE_STATE_DISABLED; 108 109 static int btif_shutdown_pending = 0; 110 static tBTA_SERVICE_MASK btif_enabled_services = 0; 111 112 /* 113 * This variable should be set to 1, if the Bluedroid+BTIF libraries are to 114 * function in DUT mode. 115 * 116 * To set this, the btif_init_bluetooth needs to be called with argument as 1 117 */ 118 static UINT8 btif_dut_mode = 0; 119 120 /************************************************************************************ 121 ** Static functions 122 ************************************************************************************/ 123 static bt_status_t btif_associate_evt(void); 124 static bt_status_t btif_disassociate_evt(void); 125 126 /* sends message to btif task */ 127 static void btif_sendmsg(void *p_msg); 128 129 /************************************************************************************ 130 ** Externs 131 ************************************************************************************/ 132 extern void bte_load_did_conf(const char *p_path); 133 134 /** TODO: Move these to _common.h */ 135 void bte_main_boot_entry(void); 136 void bte_main_enable(); 137 void bte_main_disable(void); 138 void bte_main_shutdown(void); 139 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE) 140 void bte_main_enable_lpm(BOOLEAN enable); 141 #endif 142 void bte_main_postload_cfg(void); 143 void btif_dm_execute_service_request(UINT16 event, char *p_param); 144 #ifdef BTIF_DM_OOB_TEST 145 void btif_dm_load_local_oob(void); 146 #endif 147 void bte_main_config_hci_logging(BOOLEAN enable, BOOLEAN bt_disabled); 148 149 /************************************************************************************ 150 ** Functions 151 ************************************************************************************/ 152 153 154 /***************************************************************************** 155 ** Context switching functions 156 *****************************************************************************/ 157 158 159 /******************************************************************************* 160 ** 161 ** Function btif_context_switched 162 ** 163 ** Description Callback used to execute transferred context callback 164 ** 165 ** p_msg : message to be executed in btif context 166 ** 167 ** Returns void 168 ** 169 *******************************************************************************/ 170 171 static void btif_context_switched(void *p_msg) 172 { 173 tBTIF_CONTEXT_SWITCH_CBACK *p; 174 175 BTIF_TRACE_VERBOSE("btif_context_switched"); 176 177 p = (tBTIF_CONTEXT_SWITCH_CBACK *) p_msg; 178 179 /* each callback knows how to parse the data */ 180 if (p->p_cb) 181 p->p_cb(p->event, p->p_param); 182 } 183 184 185 /******************************************************************************* 186 ** 187 ** Function btif_transfer_context 188 ** 189 ** Description This function switches context to btif task 190 ** 191 ** p_cback : callback used to process message in btif context 192 ** event : event id of message 193 ** p_params : parameter area passed to callback (copied) 194 ** param_len : length of parameter area 195 ** p_copy_cback : If set this function will be invoked for deep copy 196 ** 197 ** Returns void 198 ** 199 *******************************************************************************/ 200 201 bt_status_t btif_transfer_context (tBTIF_CBACK *p_cback, UINT16 event, char* p_params, int param_len, tBTIF_COPY_CBACK *p_copy_cback) 202 { 203 tBTIF_CONTEXT_SWITCH_CBACK *p_msg; 204 205 BTIF_TRACE_VERBOSE("btif_transfer_context event %d, len %d", event, param_len); 206 207 /* allocate and send message that will be executed in btif context */ 208 if ((p_msg = (tBTIF_CONTEXT_SWITCH_CBACK *) GKI_getbuf(sizeof(tBTIF_CONTEXT_SWITCH_CBACK) + param_len)) != NULL) 209 { 210 p_msg->hdr.event = BT_EVT_CONTEXT_SWITCH_EVT; /* internal event */ 211 p_msg->p_cb = p_cback; 212 213 p_msg->event = event; /* callback event */ 214 215 /* check if caller has provided a copy callback to do the deep copy */ 216 if (p_copy_cback) 217 { 218 p_copy_cback(event, p_msg->p_param, p_params); 219 } 220 else if (p_params) 221 { 222 memcpy(p_msg->p_param, p_params, param_len); /* callback parameter data */ 223 } 224 225 btif_sendmsg(p_msg); 226 return BT_STATUS_SUCCESS; 227 } 228 else 229 { 230 /* let caller deal with a failed allocation */ 231 return BT_STATUS_NOMEM; 232 } 233 } 234 235 /******************************************************************************* 236 ** 237 ** Function btif_is_dut_mode 238 ** 239 ** Description checks if BTIF is currently in DUT mode 240 ** 241 ** Returns 1 if test mode, otherwize 0 242 ** 243 *******************************************************************************/ 244 245 UINT8 btif_is_dut_mode(void) 246 { 247 return (btif_dut_mode == 1); 248 } 249 250 /******************************************************************************* 251 ** 252 ** Function btif_is_enabled 253 ** 254 ** Description checks if main adapter is fully enabled 255 ** 256 ** Returns 1 if fully enabled, otherwize 0 257 ** 258 *******************************************************************************/ 259 260 int btif_is_enabled(void) 261 { 262 return ((!btif_is_dut_mode()) && (btif_core_state == BTIF_CORE_STATE_ENABLED)); 263 } 264 265 /******************************************************************************* 266 ** 267 ** Function btif_task 268 ** 269 ** Description BTIF task handler managing all messages being passed 270 ** Bluetooth HAL and BTA. 271 ** 272 ** Returns void 273 ** 274 *******************************************************************************/ 275 276 static void btif_task(UINT32 params) 277 { 278 UINT16 event; 279 BT_HDR *p_msg; 280 UNUSED(params); 281 282 BTIF_TRACE_DEBUG("btif task starting"); 283 284 btif_associate_evt(); 285 286 for(;;) 287 { 288 /* wait for specified events */ 289 event = GKI_wait(0xFFFF, 0); 290 291 /* 292 * Wait for the trigger to init chip and stack. This trigger will 293 * be received by btu_task once the UART is opened and ready 294 */ 295 if (event == BT_EVT_TRIGGER_STACK_INIT) 296 { 297 BTIF_TRACE_DEBUG("btif_task: received trigger stack init event"); 298 #if (BLE_INCLUDED == TRUE) 299 btif_dm_load_ble_local_keys(); 300 #endif 301 BTA_EnableBluetooth(bte_dm_evt); 302 } 303 304 /* 305 * Failed to initialize controller hardware, reset state and bring 306 * down all threads 307 */ 308 if (event == BT_EVT_HARDWARE_INIT_FAIL) 309 { 310 BTIF_TRACE_DEBUG("btif_task: hardware init failed"); 311 bte_main_disable(); 312 btif_queue_release(); 313 GKI_task_self_cleanup(BTIF_TASK); 314 bte_main_shutdown(); 315 btif_dut_mode = 0; 316 btif_core_state = BTIF_CORE_STATE_DISABLED; 317 HAL_CBACK(bt_hal_cbacks,adapter_state_changed_cb,BT_STATE_OFF); 318 break; 319 } 320 321 if (event & EVENT_MASK(GKI_SHUTDOWN_EVT)) 322 break; 323 324 if(event & TASK_MBOX_1_EVT_MASK) 325 { 326 while((p_msg = GKI_read_mbox(BTU_BTIF_MBOX)) != NULL) 327 { 328 BTIF_TRACE_VERBOSE("btif task fetched event %x", p_msg->event); 329 330 switch (p_msg->event) 331 { 332 case BT_EVT_CONTEXT_SWITCH_EVT: 333 btif_context_switched(p_msg); 334 break; 335 default: 336 BTIF_TRACE_ERROR("unhandled btif event (%d)", p_msg->event & BT_EVT_MASK); 337 break; 338 } 339 340 GKI_freebuf(p_msg); 341 } 342 } 343 } 344 345 btif_disassociate_evt(); 346 347 BTIF_TRACE_DEBUG("btif task exiting"); 348 } 349 350 351 /******************************************************************************* 352 ** 353 ** Function btif_sendmsg 354 ** 355 ** Description Sends msg to BTIF task 356 ** 357 ** Returns void 358 ** 359 *******************************************************************************/ 360 361 void btif_sendmsg(void *p_msg) 362 { 363 GKI_send_msg(BTIF_TASK, BTU_BTIF_MBOX, p_msg); 364 } 365 366 static void btif_fetch_local_bdaddr(bt_bdaddr_t *local_addr) 367 { 368 char val[256]; 369 uint8_t valid_bda = FALSE; 370 int val_size = 0; 371 const uint8_t null_bdaddr[BD_ADDR_LEN] = {0,0,0,0,0,0}; 372 373 /* Get local bdaddr storage path from property */ 374 if (property_get(PROPERTY_BT_BDADDR_PATH, val, NULL)) 375 { 376 int addr_fd; 377 378 BTIF_TRACE_DEBUG("local bdaddr is stored in %s", val); 379 380 if ((addr_fd = open(val, O_RDONLY)) != -1) 381 { 382 memset(val, 0, sizeof(val)); 383 read(addr_fd, val, FACTORY_BT_BDADDR_STORAGE_LEN); 384 str2bd(val, local_addr); 385 /* If this is not a reserved/special bda, then use it */ 386 if (memcmp(local_addr->address, null_bdaddr, BD_ADDR_LEN) != 0) 387 { 388 valid_bda = TRUE; 389 BTIF_TRACE_DEBUG("Got Factory BDA %02X:%02X:%02X:%02X:%02X:%02X", 390 local_addr->address[0], local_addr->address[1], local_addr->address[2], 391 local_addr->address[3], local_addr->address[4], local_addr->address[5]); 392 } 393 394 close(addr_fd); 395 } 396 } 397 398 if(!valid_bda) 399 { 400 val_size = sizeof(val); 401 if(btif_config_get_str("Local", "Adapter", "Address", val, &val_size)) 402 { 403 str2bd(val, local_addr); 404 BTIF_TRACE_DEBUG("local bdaddr from bt_config.xml is %s", val); 405 return; 406 } 407 } 408 409 /* No factory BDADDR found. Look for previously generated random BDA */ 410 if ((!valid_bda) && \ 411 (property_get(PERSIST_BDADDR_PROPERTY, val, NULL))) 412 { 413 str2bd(val, local_addr); 414 valid_bda = TRUE; 415 BTIF_TRACE_DEBUG("Got prior random BDA %02X:%02X:%02X:%02X:%02X:%02X", 416 local_addr->address[0], local_addr->address[1], local_addr->address[2], 417 local_addr->address[3], local_addr->address[4], local_addr->address[5]); 418 } 419 420 /* Generate new BDA if necessary */ 421 if (!valid_bda) 422 { 423 bdstr_t bdstr; 424 /* Seed the random number generator */ 425 srand((unsigned int) (time(0))); 426 427 /* No autogen BDA. Generate one now. */ 428 local_addr->address[0] = 0x22; 429 local_addr->address[1] = 0x22; 430 local_addr->address[2] = (uint8_t) ((rand() >> 8) & 0xFF); 431 local_addr->address[3] = (uint8_t) ((rand() >> 8) & 0xFF); 432 local_addr->address[4] = (uint8_t) ((rand() >> 8) & 0xFF); 433 local_addr->address[5] = (uint8_t) ((rand() >> 8) & 0xFF); 434 435 /* Convert to ascii, and store as a persistent property */ 436 bd2str(local_addr, &bdstr); 437 438 BTIF_TRACE_DEBUG("No preset BDA. Generating BDA: %s for prop %s", 439 (char*)bdstr, PERSIST_BDADDR_PROPERTY); 440 441 if (property_set(PERSIST_BDADDR_PROPERTY, (char*)bdstr) < 0) 442 BTIF_TRACE_ERROR("Failed to set random BDA in prop %s",PERSIST_BDADDR_PROPERTY); 443 } 444 445 //save the bd address to config file 446 bdstr_t bdstr; 447 bd2str(local_addr, &bdstr); 448 val_size = sizeof(val); 449 if (btif_config_get_str("Local", "Adapter", "Address", val, &val_size)) 450 { 451 if (strcmp(bdstr, val) ==0) 452 { 453 // BDA is already present in the config file. 454 return; 455 } 456 } 457 btif_config_set_str("Local", "Adapter", "Address", bdstr); 458 btif_config_save(); 459 } 460 461 /***************************************************************************** 462 ** 463 ** btif core api functions 464 ** 465 *****************************************************************************/ 466 467 /******************************************************************************* 468 ** 469 ** Function btif_init_bluetooth 470 ** 471 ** Description Creates BTIF task and prepares BT scheduler for startup 472 ** 473 ** Returns bt_status_t 474 ** 475 *******************************************************************************/ 476 477 bt_status_t btif_init_bluetooth() 478 { 479 UINT8 status; 480 btif_config_init(); 481 bte_main_boot_entry(); 482 483 /* As part of the init, fetch the local BD ADDR */ 484 memset(&btif_local_bd_addr, 0, sizeof(bt_bdaddr_t)); 485 btif_fetch_local_bdaddr(&btif_local_bd_addr); 486 487 /* start btif task */ 488 status = GKI_create_task(btif_task, BTIF_TASK, BTIF_TASK_STR, 489 (UINT16 *) ((UINT8 *)btif_task_stack + BTIF_TASK_STACK_SIZE), 490 sizeof(btif_task_stack)); 491 492 if (status != GKI_SUCCESS) 493 return BT_STATUS_FAIL; 494 495 return BT_STATUS_SUCCESS; 496 } 497 498 /******************************************************************************* 499 ** 500 ** Function btif_associate_evt 501 ** 502 ** Description Event indicating btif_task is up 503 ** Attach btif_task to JVM 504 ** 505 ** Returns void 506 ** 507 *******************************************************************************/ 508 509 static bt_status_t btif_associate_evt(void) 510 { 511 BTIF_TRACE_DEBUG("%s: notify ASSOCIATE_JVM", __FUNCTION__); 512 HAL_CBACK(bt_hal_cbacks, thread_evt_cb, ASSOCIATE_JVM); 513 514 return BT_STATUS_SUCCESS; 515 } 516 517 518 /******************************************************************************* 519 ** 520 ** Function btif_enable_bluetooth 521 ** 522 ** Description Performs chip power on and kickstarts OS scheduler 523 ** 524 ** Returns bt_status_t 525 ** 526 *******************************************************************************/ 527 528 bt_status_t btif_enable_bluetooth(void) 529 { 530 BTIF_TRACE_DEBUG("BTIF ENABLE BLUETOOTH"); 531 532 if (btif_core_state != BTIF_CORE_STATE_DISABLED) 533 { 534 ALOGD("not disabled\n"); 535 return BT_STATUS_DONE; 536 } 537 538 btif_core_state = BTIF_CORE_STATE_ENABLING; 539 540 /* Create the GKI tasks and run them */ 541 bte_main_enable(); 542 543 return BT_STATUS_SUCCESS; 544 } 545 546 547 /******************************************************************************* 548 ** 549 ** Function btif_enable_bluetooth_evt 550 ** 551 ** Description Event indicating bluetooth enable is completed 552 ** Notifies HAL user with updated adapter state 553 ** 554 ** Returns void 555 ** 556 *******************************************************************************/ 557 558 void btif_enable_bluetooth_evt(tBTA_STATUS status, BD_ADDR local_bd) 559 { 560 bt_bdaddr_t bd_addr; 561 bdstr_t bdstr; 562 563 bdcpy(bd_addr.address, local_bd); 564 BTIF_TRACE_DEBUG("%s: status %d, local bd [%s]", __FUNCTION__, status, 565 bd2str(&bd_addr, &bdstr)); 566 567 if (bdcmp(btif_local_bd_addr.address,local_bd)) 568 { 569 bdstr_t buf; 570 bt_property_t prop; 571 572 /** 573 * The Controller's BDADDR does not match to the BTIF's initial BDADDR! 574 * This could be because the factory BDADDR was stored separatley in 575 * the Controller's non-volatile memory rather than in device's file 576 * system. 577 **/ 578 BTIF_TRACE_WARNING("***********************************************"); 579 BTIF_TRACE_WARNING("BTIF init BDA was %02X:%02X:%02X:%02X:%02X:%02X", 580 btif_local_bd_addr.address[0], btif_local_bd_addr.address[1], 581 btif_local_bd_addr.address[2], btif_local_bd_addr.address[3], 582 btif_local_bd_addr.address[4], btif_local_bd_addr.address[5]); 583 BTIF_TRACE_WARNING("Controller BDA is %02X:%02X:%02X:%02X:%02X:%02X", 584 local_bd[0], local_bd[1], local_bd[2], 585 local_bd[3], local_bd[4], local_bd[5]); 586 BTIF_TRACE_WARNING("***********************************************"); 587 588 bdcpy(btif_local_bd_addr.address, local_bd); 589 590 //save the bd address to config file 591 bd2str(&btif_local_bd_addr, &buf); 592 btif_config_set_str("Local", "Adapter", "Address", buf); 593 btif_config_save(); 594 595 //fire HAL callback for property change 596 memcpy(buf, &btif_local_bd_addr, sizeof(bt_bdaddr_t)); 597 prop.type = BT_PROPERTY_BDADDR; 598 prop.val = (void*)buf; 599 prop.len = sizeof(bt_bdaddr_t); 600 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, BT_STATUS_SUCCESS, 1, &prop); 601 } 602 603 bte_main_postload_cfg(); 604 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE) 605 bte_main_enable_lpm(TRUE); 606 #endif 607 /* add passing up bd address as well ? */ 608 609 /* callback to HAL */ 610 if (status == BTA_SUCCESS) 611 { 612 /* initialize a2dp service */ 613 btif_av_init(); 614 615 /* init rfcomm & l2cap api */ 616 btif_sock_init(); 617 618 /* init pan */ 619 btif_pan_init(); 620 621 /* load did configuration */ 622 bte_load_did_conf(BTE_DID_CONF_FILE); 623 624 #ifdef BTIF_DM_OOB_TEST 625 btif_dm_load_local_oob(); 626 #endif 627 /* now fully enabled, update state */ 628 btif_core_state = BTIF_CORE_STATE_ENABLED; 629 630 HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_ON); 631 } 632 else 633 { 634 /* cleanup rfcomm & l2cap api */ 635 btif_sock_cleanup(); 636 637 btif_pan_cleanup(); 638 639 /* we failed to enable, reset state */ 640 btif_core_state = BTIF_CORE_STATE_DISABLED; 641 642 HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_OFF); 643 } 644 } 645 646 /******************************************************************************* 647 ** 648 ** Function btif_disable_bluetooth 649 ** 650 ** Description Inititates shutdown of Bluetooth system. 651 ** Any active links will be dropped and device entering 652 ** non connectable/discoverable mode 653 ** 654 ** Returns void 655 ** 656 *******************************************************************************/ 657 bt_status_t btif_disable_bluetooth(void) 658 { 659 tBTA_STATUS status; 660 661 if (!btif_is_enabled()) 662 { 663 BTIF_TRACE_ERROR("btif_disable_bluetooth : not yet enabled"); 664 return BT_STATUS_NOT_READY; 665 } 666 667 BTIF_TRACE_DEBUG("BTIF DISABLE BLUETOOTH"); 668 669 btif_dm_on_disable(); 670 btif_core_state = BTIF_CORE_STATE_DISABLING; 671 672 /* cleanup rfcomm & l2cap api */ 673 btif_sock_cleanup(); 674 675 btif_pan_cleanup(); 676 677 status = BTA_DisableBluetooth(); 678 679 btif_config_flush(); 680 681 if (status != BTA_SUCCESS) 682 { 683 BTIF_TRACE_ERROR("disable bt failed (%d)", status); 684 685 /* reset the original state to allow attempting disable again */ 686 btif_core_state = BTIF_CORE_STATE_ENABLED; 687 688 return BT_STATUS_FAIL; 689 } 690 return BT_STATUS_SUCCESS; 691 } 692 693 /******************************************************************************* 694 ** 695 ** Function btif_disable_bluetooth_evt 696 ** 697 ** Description Event notifying BT disable is now complete. 698 ** Terminates main stack tasks and notifies HAL 699 ** user with updated BT state. 700 ** 701 ** Returns void 702 ** 703 *******************************************************************************/ 704 705 void btif_disable_bluetooth_evt(void) 706 { 707 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 708 709 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE) 710 bte_main_enable_lpm(FALSE); 711 #endif 712 713 #if (BLE_INCLUDED == TRUE) 714 BTA_VendorCleanup(); 715 #endif 716 717 bte_main_disable(); 718 719 /* update local state */ 720 btif_core_state = BTIF_CORE_STATE_DISABLED; 721 722 /* callback to HAL */ 723 HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_OFF); 724 725 if (btif_shutdown_pending) 726 { 727 BTIF_TRACE_DEBUG("%s: calling btif_shutdown_bluetooth", __FUNCTION__); 728 btif_shutdown_bluetooth(); 729 } 730 } 731 732 733 /******************************************************************************* 734 ** 735 ** Function btif_shutdown_bluetooth 736 ** 737 ** Description Finalizes BT scheduler shutdown and terminates BTIF 738 ** task. 739 ** 740 ** Returns void 741 ** 742 *******************************************************************************/ 743 744 bt_status_t btif_shutdown_bluetooth(void) 745 { 746 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 747 748 if (btif_core_state == BTIF_CORE_STATE_DISABLING) 749 { 750 BTIF_TRACE_WARNING("shutdown during disabling"); 751 /* shutdown called before disabling is done */ 752 btif_shutdown_pending = 1; 753 return BT_STATUS_NOT_READY; 754 } 755 756 if (btif_is_enabled()) 757 { 758 BTIF_TRACE_WARNING("shutdown while still enabled, initiate disable"); 759 760 /* shutdown called prior to disabling, initiate disable */ 761 btif_disable_bluetooth(); 762 btif_shutdown_pending = 1; 763 return BT_STATUS_NOT_READY; 764 } 765 766 btif_shutdown_pending = 0; 767 768 if (btif_core_state == BTIF_CORE_STATE_ENABLING) 769 { 770 // Java layer abort BT ENABLING, could be due to ENABLE TIMEOUT 771 // Direct call from cleanup()@bluetooth.c 772 // bring down HCI/Vendor lib 773 bte_main_disable(); 774 btif_core_state = BTIF_CORE_STATE_DISABLED; 775 HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, BT_STATE_OFF); 776 } 777 778 GKI_destroy_task(BTIF_TASK); 779 btif_queue_release(); 780 bte_main_shutdown(); 781 782 btif_dut_mode = 0; 783 784 bt_utils_cleanup(); 785 786 BTIF_TRACE_DEBUG("%s done", __FUNCTION__); 787 788 return BT_STATUS_SUCCESS; 789 } 790 791 792 /******************************************************************************* 793 ** 794 ** Function btif_disassociate_evt 795 ** 796 ** Description Event indicating btif_task is going down 797 ** Detach btif_task to JVM 798 ** 799 ** Returns void 800 ** 801 *******************************************************************************/ 802 803 static bt_status_t btif_disassociate_evt(void) 804 { 805 BTIF_TRACE_DEBUG("%s: notify DISASSOCIATE_JVM", __FUNCTION__); 806 807 HAL_CBACK(bt_hal_cbacks, thread_evt_cb, DISASSOCIATE_JVM); 808 809 /* shutdown complete, all events notified and we reset HAL callbacks */ 810 bt_hal_cbacks = NULL; 811 812 return BT_STATUS_SUCCESS; 813 } 814 815 /**************************************************************************** 816 ** 817 ** BTIF Test Mode APIs 818 ** 819 *****************************************************************************/ 820 /******************************************************************************* 821 ** 822 ** Function btif_dut_mode_cback 823 ** 824 ** Description Callback invoked on completion of vendor specific test mode command 825 ** 826 ** Returns None 827 ** 828 *******************************************************************************/ 829 static void btif_dut_mode_cback( tBTM_VSC_CMPL *p ) 830 { 831 UNUSED(p); 832 /* For now nothing to be done. */ 833 } 834 835 /******************************************************************************* 836 ** 837 ** Function btif_dut_mode_configure 838 ** 839 ** Description Configure Test Mode - 'enable' to 1 puts the device in test mode and 0 exits 840 ** test mode 841 ** 842 ** Returns BT_STATUS_SUCCESS on success 843 ** 844 *******************************************************************************/ 845 bt_status_t btif_dut_mode_configure(uint8_t enable) 846 { 847 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 848 849 if (btif_core_state != BTIF_CORE_STATE_ENABLED) { 850 BTIF_TRACE_ERROR("btif_dut_mode_configure : Bluetooth not enabled"); 851 return BT_STATUS_NOT_READY; 852 } 853 854 btif_dut_mode = enable; 855 if (enable == 1) { 856 BTA_EnableTestMode(); 857 } else { 858 BTA_DisableTestMode(); 859 } 860 return BT_STATUS_SUCCESS; 861 } 862 863 /******************************************************************************* 864 ** 865 ** Function btif_dut_mode_send 866 ** 867 ** Description Sends a HCI Vendor specific command to the controller 868 ** 869 ** Returns BT_STATUS_SUCCESS on success 870 ** 871 *******************************************************************************/ 872 bt_status_t btif_dut_mode_send(uint16_t opcode, uint8_t *buf, uint8_t len) 873 { 874 /* TODO: Check that opcode is a vendor command group */ 875 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 876 if (!btif_is_dut_mode()) { 877 BTIF_TRACE_ERROR("Bluedroid HAL needs to be init with test_mode set to 1."); 878 return BT_STATUS_FAIL; 879 } 880 BTM_VendorSpecificCommand(opcode, len, buf, btif_dut_mode_cback); 881 return BT_STATUS_SUCCESS; 882 } 883 884 /***************************************************************************** 885 ** 886 ** btif api adapter property functions 887 ** 888 *****************************************************************************/ 889 890 static bt_status_t btif_in_get_adapter_properties(void) 891 { 892 bt_property_t properties[6]; 893 uint32_t num_props; 894 895 bt_bdaddr_t addr; 896 bt_bdname_t name; 897 bt_scan_mode_t mode; 898 uint32_t disc_timeout; 899 bt_bdaddr_t bonded_devices[BTM_SEC_MAX_DEVICE_RECORDS]; 900 bt_uuid_t local_uuids[BT_MAX_NUM_UUIDS]; 901 num_props = 0; 902 903 /* BD_ADDR */ 904 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_BDADDR, 905 sizeof(addr), &addr); 906 btif_storage_get_adapter_property(&properties[num_props]); 907 num_props++; 908 909 /* BD_NAME */ 910 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_BDNAME, 911 sizeof(name), &name); 912 btif_storage_get_adapter_property(&properties[num_props]); 913 num_props++; 914 915 /* SCAN_MODE */ 916 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_ADAPTER_SCAN_MODE, 917 sizeof(mode), &mode); 918 btif_storage_get_adapter_property(&properties[num_props]); 919 num_props++; 920 921 /* DISC_TIMEOUT */ 922 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT, 923 sizeof(disc_timeout), &disc_timeout); 924 btif_storage_get_adapter_property(&properties[num_props]); 925 num_props++; 926 927 /* BONDED_DEVICES */ 928 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_ADAPTER_BONDED_DEVICES, 929 sizeof(bonded_devices), bonded_devices); 930 btif_storage_get_adapter_property(&properties[num_props]); 931 num_props++; 932 933 /* LOCAL UUIDs */ 934 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_UUIDS, 935 sizeof(local_uuids), local_uuids); 936 btif_storage_get_adapter_property(&properties[num_props]); 937 num_props++; 938 939 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, 940 BT_STATUS_SUCCESS, num_props, properties); 941 942 return BT_STATUS_SUCCESS; 943 } 944 945 static bt_status_t btif_in_get_remote_device_properties(bt_bdaddr_t *bd_addr) 946 { 947 bt_property_t remote_properties[8]; 948 uint32_t num_props = 0; 949 950 bt_bdname_t name, alias; 951 uint32_t cod, devtype; 952 bt_uuid_t remote_uuids[BT_MAX_NUM_UUIDS]; 953 954 memset(remote_properties, 0, sizeof(remote_properties)); 955 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_BDNAME, 956 sizeof(name), &name); 957 btif_storage_get_remote_device_property(bd_addr, 958 &remote_properties[num_props]); 959 num_props++; 960 961 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_REMOTE_FRIENDLY_NAME, 962 sizeof(alias), &alias); 963 btif_storage_get_remote_device_property(bd_addr, 964 &remote_properties[num_props]); 965 num_props++; 966 967 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_CLASS_OF_DEVICE, 968 sizeof(cod), &cod); 969 btif_storage_get_remote_device_property(bd_addr, 970 &remote_properties[num_props]); 971 num_props++; 972 973 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_TYPE_OF_DEVICE, 974 sizeof(devtype), &devtype); 975 btif_storage_get_remote_device_property(bd_addr, 976 &remote_properties[num_props]); 977 num_props++; 978 979 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_UUIDS, 980 sizeof(remote_uuids), remote_uuids); 981 btif_storage_get_remote_device_property(bd_addr, 982 &remote_properties[num_props]); 983 num_props++; 984 985 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb, 986 BT_STATUS_SUCCESS, bd_addr, num_props, remote_properties); 987 988 return BT_STATUS_SUCCESS; 989 } 990 991 992 /******************************************************************************* 993 ** 994 ** Function execute_storage_request 995 ** 996 ** Description Executes adapter storage request in BTIF context 997 ** 998 ** Returns bt_status_t 999 ** 1000 *******************************************************************************/ 1001 1002 static void execute_storage_request(UINT16 event, char *p_param) 1003 { 1004 uint8_t is_local; 1005 int num_entries = 0; 1006 bt_status_t status = BT_STATUS_SUCCESS; 1007 1008 BTIF_TRACE_EVENT("execute storage request event : %d", event); 1009 1010 switch(event) 1011 { 1012 case BTIF_CORE_STORAGE_ADAPTER_WRITE: 1013 { 1014 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param; 1015 bt_property_t *p_prop = &(p_req->write_req.prop); 1016 BTIF_TRACE_EVENT("type: %d, len %d, 0x%x", p_prop->type, 1017 p_prop->len, p_prop->val); 1018 1019 status = btif_storage_set_adapter_property(p_prop); 1020 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 1, p_prop); 1021 } break; 1022 1023 case BTIF_CORE_STORAGE_ADAPTER_READ: 1024 { 1025 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param; 1026 char buf[512]; 1027 bt_property_t prop; 1028 prop.type = p_req->read_req.type; 1029 prop.val = (void*)buf; 1030 prop.len = sizeof(buf); 1031 if (prop.type == BT_PROPERTY_LOCAL_LE_FEATURES) 1032 { 1033 #if (BLE_INCLUDED == TRUE) 1034 tBTM_BLE_VSC_CB cmn_vsc_cb; 1035 bt_local_le_features_t local_le_features; 1036 1037 /* LE features are not stored in storage. Should be retrived from stack */ 1038 BTM_BleGetVendorCapabilities(&cmn_vsc_cb); 1039 local_le_features.local_privacy_enabled = BTM_BleLocalPrivacyEnabled(); 1040 1041 prop.len = sizeof (bt_local_le_features_t); 1042 if (cmn_vsc_cb.filter_support == 1) 1043 local_le_features.max_adv_filter_supported = cmn_vsc_cb.max_filter; 1044 else 1045 local_le_features.max_adv_filter_supported = 0; 1046 local_le_features.max_adv_instance = cmn_vsc_cb.adv_inst_max; 1047 local_le_features.max_irk_list_size = cmn_vsc_cb.max_irk_list_sz; 1048 local_le_features.rpa_offload_supported = cmn_vsc_cb.rpa_offloading; 1049 local_le_features.scan_result_storage_size_hibyte = 1050 (cmn_vsc_cb.tot_scan_results_strg >> 8) & (0xFF); 1051 local_le_features.scan_result_storage_size_lobyte = 1052 (cmn_vsc_cb.tot_scan_results_strg) & (0xFF); 1053 local_le_features.activity_energy_info_supported = cmn_vsc_cb.energy_support; 1054 memcpy(prop.val, &local_le_features, prop.len); 1055 #endif 1056 } 1057 else 1058 { 1059 status = btif_storage_get_adapter_property(&prop); 1060 } 1061 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 1, &prop); 1062 } break; 1063 1064 case BTIF_CORE_STORAGE_ADAPTER_READ_ALL: 1065 { 1066 status = btif_in_get_adapter_properties(); 1067 } break; 1068 1069 case BTIF_CORE_STORAGE_NOTIFY_STATUS: 1070 { 1071 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 0, NULL); 1072 } break; 1073 1074 default: 1075 BTIF_TRACE_ERROR("%s invalid event id (%d)", __FUNCTION__, event); 1076 break; 1077 } 1078 } 1079 1080 static void execute_storage_remote_request(UINT16 event, char *p_param) 1081 { 1082 bt_status_t status = BT_STATUS_FAIL; 1083 bt_property_t prop; 1084 1085 BTIF_TRACE_EVENT("execute storage remote request event : %d", event); 1086 1087 switch (event) 1088 { 1089 case BTIF_CORE_STORAGE_REMOTE_READ: 1090 { 1091 char buf[1024]; 1092 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param; 1093 prop.type = p_req->read_req.type; 1094 prop.val = (void*) buf; 1095 prop.len = sizeof(buf); 1096 1097 status = btif_storage_get_remote_device_property(&(p_req->read_req.bd_addr), 1098 &prop); 1099 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb, 1100 status, &(p_req->read_req.bd_addr), 1, &prop); 1101 }break; 1102 case BTIF_CORE_STORAGE_REMOTE_WRITE: 1103 { 1104 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param; 1105 status = btif_storage_set_remote_device_property(&(p_req->write_req.bd_addr), 1106 &(p_req->write_req.prop)); 1107 }break; 1108 case BTIF_CORE_STORAGE_REMOTE_READ_ALL: 1109 { 1110 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param; 1111 btif_in_get_remote_device_properties(&p_req->read_req.bd_addr); 1112 }break; 1113 } 1114 } 1115 1116 void btif_adapter_properties_evt(bt_status_t status, uint32_t num_props, 1117 bt_property_t *p_props) 1118 { 1119 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, 1120 status, num_props, p_props); 1121 1122 } 1123 void btif_remote_properties_evt(bt_status_t status, bt_bdaddr_t *remote_addr, 1124 uint32_t num_props, bt_property_t *p_props) 1125 { 1126 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb, 1127 status, remote_addr, num_props, p_props); 1128 } 1129 1130 /******************************************************************************* 1131 ** 1132 ** Function btif_in_storage_request_copy_cb 1133 ** 1134 ** Description Switch context callback function to perform the deep copy for 1135 ** both the adapter and remote_device property API 1136 ** 1137 ** Returns None 1138 ** 1139 *******************************************************************************/ 1140 static void btif_in_storage_request_copy_cb(UINT16 event, 1141 char *p_new_buf, char *p_old_buf) 1142 { 1143 btif_storage_req_t *new_req = (btif_storage_req_t*)p_new_buf; 1144 btif_storage_req_t *old_req = (btif_storage_req_t*)p_old_buf; 1145 1146 BTIF_TRACE_EVENT("%s", __FUNCTION__); 1147 switch (event) 1148 { 1149 case BTIF_CORE_STORAGE_REMOTE_WRITE: 1150 case BTIF_CORE_STORAGE_ADAPTER_WRITE: 1151 { 1152 bdcpy(new_req->write_req.bd_addr.address, old_req->write_req.bd_addr.address); 1153 /* Copy the member variables one at a time */ 1154 new_req->write_req.prop.type = old_req->write_req.prop.type; 1155 new_req->write_req.prop.len = old_req->write_req.prop.len; 1156 1157 new_req->write_req.prop.val = (UINT8 *)(p_new_buf + sizeof(btif_storage_req_t)); 1158 memcpy(new_req->write_req.prop.val, old_req->write_req.prop.val, 1159 old_req->write_req.prop.len); 1160 }break; 1161 } 1162 } 1163 1164 /******************************************************************************* 1165 ** 1166 ** Function btif_get_adapter_properties 1167 ** 1168 ** Description Fetch all available properties (local & remote) 1169 ** 1170 ** Returns bt_status_t 1171 ** 1172 *******************************************************************************/ 1173 1174 bt_status_t btif_get_adapter_properties(void) 1175 { 1176 BTIF_TRACE_EVENT("%s", __FUNCTION__); 1177 1178 if (!btif_is_enabled()) 1179 return BT_STATUS_NOT_READY; 1180 1181 return btif_transfer_context(execute_storage_request, 1182 BTIF_CORE_STORAGE_ADAPTER_READ_ALL, 1183 NULL, 0, NULL); 1184 } 1185 1186 /******************************************************************************* 1187 ** 1188 ** Function btif_get_adapter_property 1189 ** 1190 ** Description Fetches property value from local cache 1191 ** 1192 ** Returns bt_status_t 1193 ** 1194 *******************************************************************************/ 1195 1196 bt_status_t btif_get_adapter_property(bt_property_type_t type) 1197 { 1198 btif_storage_req_t req; 1199 1200 BTIF_TRACE_EVENT("%s %d", __FUNCTION__, type); 1201 1202 /* Allow get_adapter_property only for BDADDR and BDNAME if BT is disabled */ 1203 if (!btif_is_enabled() && (type != BT_PROPERTY_BDADDR) && (type != BT_PROPERTY_BDNAME)) 1204 return BT_STATUS_NOT_READY; 1205 1206 memset(&(req.read_req.bd_addr), 0, sizeof(bt_bdaddr_t)); 1207 req.read_req.type = type; 1208 1209 return btif_transfer_context(execute_storage_request, 1210 BTIF_CORE_STORAGE_ADAPTER_READ, 1211 (char*)&req, sizeof(btif_storage_req_t), NULL); 1212 } 1213 1214 /******************************************************************************* 1215 ** 1216 ** Function btif_set_adapter_property 1217 ** 1218 ** Description Updates core stack with property value and stores it in 1219 ** local cache 1220 ** 1221 ** Returns bt_status_t 1222 ** 1223 *******************************************************************************/ 1224 1225 bt_status_t btif_set_adapter_property(const bt_property_t *property) 1226 { 1227 btif_storage_req_t req; 1228 bt_status_t status = BT_STATUS_SUCCESS; 1229 int storage_req_id = BTIF_CORE_STORAGE_NOTIFY_STATUS; /* default */ 1230 char bd_name[BTM_MAX_LOC_BD_NAME_LEN +1]; 1231 UINT16 name_len = 0; 1232 1233 BTIF_TRACE_EVENT("btif_set_adapter_property type: %d, len %d, 0x%x", 1234 property->type, property->len, property->val); 1235 1236 if (!btif_is_enabled()) 1237 return BT_STATUS_NOT_READY; 1238 1239 switch(property->type) 1240 { 1241 case BT_PROPERTY_BDNAME: 1242 { 1243 name_len = property->len > BTM_MAX_LOC_BD_NAME_LEN ? BTM_MAX_LOC_BD_NAME_LEN: 1244 property->len; 1245 memcpy(bd_name,property->val, name_len); 1246 bd_name[name_len] = '\0'; 1247 1248 BTIF_TRACE_EVENT("set property name : %s", (char *)bd_name); 1249 1250 BTA_DmSetDeviceName((char *)bd_name); 1251 1252 storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE; 1253 } 1254 break; 1255 1256 case BT_PROPERTY_ADAPTER_SCAN_MODE: 1257 { 1258 bt_scan_mode_t mode = *(bt_scan_mode_t*)property->val; 1259 tBTA_DM_DISC disc_mode; 1260 tBTA_DM_CONN conn_mode; 1261 1262 switch(mode) 1263 { 1264 case BT_SCAN_MODE_NONE: 1265 disc_mode = BTA_DM_NON_DISC; 1266 conn_mode = BTA_DM_NON_CONN; 1267 break; 1268 1269 case BT_SCAN_MODE_CONNECTABLE: 1270 disc_mode = BTA_DM_NON_DISC; 1271 conn_mode = BTA_DM_CONN; 1272 break; 1273 1274 case BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE: 1275 disc_mode = BTA_DM_GENERAL_DISC; 1276 conn_mode = BTA_DM_CONN; 1277 break; 1278 1279 default: 1280 BTIF_TRACE_ERROR("invalid scan mode (0x%x)", mode); 1281 return BT_STATUS_PARM_INVALID; 1282 } 1283 1284 BTIF_TRACE_EVENT("set property scan mode : %x", mode); 1285 1286 BTA_DmSetVisibility(disc_mode, conn_mode, BTA_DM_IGNORE, BTA_DM_IGNORE); 1287 1288 storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE; 1289 } 1290 break; 1291 case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT: 1292 { 1293 /* Nothing to do beside store the value in NV. Java 1294 will change the SCAN_MODE property after setting timeout, 1295 if required */ 1296 storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE; 1297 } 1298 break; 1299 case BT_PROPERTY_BDADDR: 1300 case BT_PROPERTY_UUIDS: 1301 case BT_PROPERTY_ADAPTER_BONDED_DEVICES: 1302 case BT_PROPERTY_REMOTE_FRIENDLY_NAME: 1303 /* no write support through HAL, these properties are only populated from BTA events */ 1304 status = BT_STATUS_FAIL; 1305 break; 1306 default: 1307 BTIF_TRACE_ERROR("btif_get_adapter_property : invalid type %d", 1308 property->type); 1309 status = BT_STATUS_FAIL; 1310 break; 1311 } 1312 1313 if (storage_req_id != BTIF_CORE_STORAGE_NO_ACTION) 1314 { 1315 int btif_status; 1316 /* pass on to storage for updating local database */ 1317 1318 memset(&(req.write_req.bd_addr), 0, sizeof(bt_bdaddr_t)); 1319 memcpy(&(req.write_req.prop), property, sizeof(bt_property_t)); 1320 1321 return btif_transfer_context(execute_storage_request, 1322 storage_req_id, 1323 (char*)&req, 1324 sizeof(btif_storage_req_t)+property->len, 1325 btif_in_storage_request_copy_cb); 1326 } 1327 1328 return status; 1329 1330 } 1331 1332 /******************************************************************************* 1333 ** 1334 ** Function btif_get_remote_device_property 1335 ** 1336 ** Description Fetches the remote device property from the NVRAM 1337 ** 1338 ** Returns bt_status_t 1339 ** 1340 *******************************************************************************/ 1341 bt_status_t btif_get_remote_device_property(bt_bdaddr_t *remote_addr, 1342 bt_property_type_t type) 1343 { 1344 btif_storage_req_t req; 1345 1346 if (!btif_is_enabled()) 1347 return BT_STATUS_NOT_READY; 1348 1349 memcpy(&(req.read_req.bd_addr), remote_addr, sizeof(bt_bdaddr_t)); 1350 req.read_req.type = type; 1351 return btif_transfer_context(execute_storage_remote_request, 1352 BTIF_CORE_STORAGE_REMOTE_READ, 1353 (char*)&req, sizeof(btif_storage_req_t), 1354 NULL); 1355 } 1356 1357 /******************************************************************************* 1358 ** 1359 ** Function btif_get_remote_device_properties 1360 ** 1361 ** Description Fetches all the remote device properties from NVRAM 1362 ** 1363 ** Returns bt_status_t 1364 ** 1365 *******************************************************************************/ 1366 bt_status_t btif_get_remote_device_properties(bt_bdaddr_t *remote_addr) 1367 { 1368 btif_storage_req_t req; 1369 1370 if (!btif_is_enabled()) 1371 return BT_STATUS_NOT_READY; 1372 1373 memcpy(&(req.read_req.bd_addr), remote_addr, sizeof(bt_bdaddr_t)); 1374 return btif_transfer_context(execute_storage_remote_request, 1375 BTIF_CORE_STORAGE_REMOTE_READ_ALL, 1376 (char*)&req, sizeof(btif_storage_req_t), 1377 NULL); 1378 } 1379 1380 /******************************************************************************* 1381 ** 1382 ** Function btif_set_remote_device_property 1383 ** 1384 ** Description Writes the remote device property to NVRAM. 1385 ** Currently, BT_PROPERTY_REMOTE_FRIENDLY_NAME is the only 1386 ** remote device property that can be set 1387 ** 1388 ** Returns bt_status_t 1389 ** 1390 *******************************************************************************/ 1391 bt_status_t btif_set_remote_device_property(bt_bdaddr_t *remote_addr, 1392 const bt_property_t *property) 1393 { 1394 btif_storage_req_t req; 1395 1396 if (!btif_is_enabled()) 1397 return BT_STATUS_NOT_READY; 1398 1399 memcpy(&(req.write_req.bd_addr), remote_addr, sizeof(bt_bdaddr_t)); 1400 memcpy(&(req.write_req.prop), property, sizeof(bt_property_t)); 1401 1402 return btif_transfer_context(execute_storage_remote_request, 1403 BTIF_CORE_STORAGE_REMOTE_WRITE, 1404 (char*)&req, 1405 sizeof(btif_storage_req_t)+property->len, 1406 btif_in_storage_request_copy_cb); 1407 } 1408 1409 1410 /******************************************************************************* 1411 ** 1412 ** Function btif_get_remote_service_record 1413 ** 1414 ** Description Looks up the service matching uuid on the remote device 1415 ** and fetches the SCN and service_name if the UUID is found 1416 ** 1417 ** Returns bt_status_t 1418 ** 1419 *******************************************************************************/ 1420 bt_status_t btif_get_remote_service_record(bt_bdaddr_t *remote_addr, 1421 bt_uuid_t *uuid) 1422 { 1423 if (!btif_is_enabled()) 1424 return BT_STATUS_NOT_READY; 1425 1426 return btif_dm_get_remote_service_record(remote_addr, uuid); 1427 } 1428 1429 1430 /******************************************************************************* 1431 ** 1432 ** Function btif_get_enabled_services_mask 1433 ** 1434 ** Description Fetches currently enabled services 1435 ** 1436 ** Returns tBTA_SERVICE_MASK 1437 ** 1438 *******************************************************************************/ 1439 1440 tBTA_SERVICE_MASK btif_get_enabled_services_mask(void) 1441 { 1442 return btif_enabled_services; 1443 } 1444 1445 /******************************************************************************* 1446 ** 1447 ** Function btif_enable_service 1448 ** 1449 ** Description Enables the service 'service_ID' to the service_mask. 1450 ** Upon BT enable, BTIF core shall invoke the BTA APIs to 1451 ** enable the profiles 1452 ** 1453 ** Returns bt_status_t 1454 ** 1455 *******************************************************************************/ 1456 bt_status_t btif_enable_service(tBTA_SERVICE_ID service_id) 1457 { 1458 tBTA_SERVICE_ID *p_id = &service_id; 1459 1460 /* If BT is enabled, we need to switch to BTIF context and trigger the 1461 * enable for that profile 1462 * 1463 * Otherwise, we just set the flag. On BT_Enable, the DM will trigger 1464 * enable for the profiles that have been enabled */ 1465 1466 btif_enabled_services |= (1 << service_id); 1467 1468 BTIF_TRACE_DEBUG("%s: current services:0x%x", __FUNCTION__, btif_enabled_services); 1469 1470 if (btif_is_enabled()) 1471 { 1472 btif_transfer_context(btif_dm_execute_service_request, 1473 BTIF_DM_ENABLE_SERVICE, 1474 (char*)p_id, sizeof(tBTA_SERVICE_ID), NULL); 1475 } 1476 1477 return BT_STATUS_SUCCESS; 1478 } 1479 /******************************************************************************* 1480 ** 1481 ** Function btif_disable_service 1482 ** 1483 ** Description Disables the service 'service_ID' to the service_mask. 1484 ** Upon BT disable, BTIF core shall invoke the BTA APIs to 1485 ** disable the profiles 1486 ** 1487 ** Returns bt_status_t 1488 ** 1489 *******************************************************************************/ 1490 bt_status_t btif_disable_service(tBTA_SERVICE_ID service_id) 1491 { 1492 tBTA_SERVICE_ID *p_id = &service_id; 1493 1494 /* If BT is enabled, we need to switch to BTIF context and trigger the 1495 * disable for that profile so that the appropriate uuid_property_changed will 1496 * be triggerred. Otherwise, we just need to clear the service_id in the mask 1497 */ 1498 1499 btif_enabled_services &= (tBTA_SERVICE_MASK)(~(1<<service_id)); 1500 1501 BTIF_TRACE_DEBUG("%s: Current Services:0x%x", __FUNCTION__, btif_enabled_services); 1502 1503 if (btif_is_enabled()) 1504 { 1505 btif_transfer_context(btif_dm_execute_service_request, 1506 BTIF_DM_DISABLE_SERVICE, 1507 (char*)p_id, sizeof(tBTA_SERVICE_ID), NULL); 1508 } 1509 1510 return BT_STATUS_SUCCESS; 1511 } 1512 1513 /******************************************************************************* 1514 ** 1515 ** Function btif_config_hci_snoop_log 1516 ** 1517 ** Description enable or disable HCI snoop log 1518 ** 1519 ** Returns bt_status_t 1520 ** 1521 *******************************************************************************/ 1522 bt_status_t btif_config_hci_snoop_log(uint8_t enable) 1523 { 1524 bte_main_config_hci_logging(enable != 0, 1525 btif_core_state == BTIF_CORE_STATE_DISABLED); 1526 return BT_STATUS_SUCCESS; 1527 } 1528
