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