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#define LOG_TAG "bt_btif_core" 30 31#include <ctype.h> 32#include <dirent.h> 33#include <fcntl.h> 34#include <hardware/bluetooth.h> 35#include <stdlib.h> 36#include <string.h> 37#include <sys/stat.h> 38#include <sys/types.h> 39#include <unistd.h> 40 41#include "bdaddr.h" 42#include "bt_utils.h" 43#include "bta_api.h" 44#include "bte.h" 45#include "btif_api.h" 46#include "btif_av.h" 47#include "btif_config.h" 48#include "btif_config.h" 49#include "btif_pan.h" 50#include "btif_profile_queue.h" 51#include "btif_sock.h" 52#include "btif_storage.h" 53#include "btif_uid.h" 54#include "btif_util.h" 55#include "btu.h" 56#include "device/include/controller.h" 57#include "bt_common.h" 58#include "osi/include/fixed_queue.h" 59#include "osi/include/future.h" 60#include "osi/include/log.h" 61#include "osi/include/osi.h" 62#include "osi/include/properties.h" 63#include "osi/include/thread.h" 64#include "stack_manager.h" 65 66/************************************************************************************ 67** Constants & Macros 68************************************************************************************/ 69 70#ifndef BTE_DID_CONF_FILE 71// TODO(armansito): Find a better way than searching by a hardcoded path. 72#if defined(OS_GENERIC) 73#define BTE_DID_CONF_FILE "bt_did.conf" 74#else // !defined(OS_GENERIC) 75#define BTE_DID_CONF_FILE "/etc/bluetooth/bt_did.conf" 76#endif // defined(OS_GENERIC) 77#endif // BTE_DID_CONF_FILE 78 79/************************************************************************************ 80** Local type definitions 81************************************************************************************/ 82 83/* These type definitions are used when passing data from the HAL to BTIF context 84* in the downstream path for the adapter and remote_device property APIs */ 85 86typedef struct { 87 bt_bdaddr_t bd_addr; 88 bt_property_type_t type; 89} btif_storage_read_t; 90 91typedef struct { 92 bt_bdaddr_t bd_addr; 93 bt_property_t prop; 94} btif_storage_write_t; 95 96typedef union { 97 btif_storage_read_t read_req; 98 btif_storage_write_t write_req; 99} btif_storage_req_t; 100 101typedef enum { 102 BTIF_CORE_STATE_DISABLED = 0, 103 BTIF_CORE_STATE_ENABLING, 104 BTIF_CORE_STATE_ENABLED, 105 BTIF_CORE_STATE_DISABLING 106} btif_core_state_t; 107 108/************************************************************************************ 109** Static variables 110************************************************************************************/ 111 112bt_bdaddr_t btif_local_bd_addr; 113 114static tBTA_SERVICE_MASK btif_enabled_services = 0; 115 116/* 117* This variable should be set to 1, if the Bluedroid+BTIF libraries are to 118* function in DUT mode. 119* 120* To set this, the btif_init_bluetooth needs to be called with argument as 1 121*/ 122static UINT8 btif_dut_mode = 0; 123 124static thread_t *bt_jni_workqueue_thread; 125static const char *BT_JNI_WORKQUEUE_NAME = "bt_jni_workqueue"; 126static uid_set_t* uid_set = NULL; 127 128/************************************************************************************ 129** Static functions 130************************************************************************************/ 131static void btif_jni_associate(UNUSED_ATTR uint16_t event, UNUSED_ATTR char *p_param); 132static void btif_jni_disassociate(); 133static bool btif_fetch_property(const char *key, bt_bdaddr_t *addr); 134 135/* sends message to btif task */ 136static void btif_sendmsg(void *p_msg); 137 138/************************************************************************************ 139** Externs 140************************************************************************************/ 141extern fixed_queue_t *btu_hci_msg_queue; 142 143extern void bte_load_did_conf(const char *p_path); 144 145/** TODO: Move these to _common.h */ 146void bte_main_boot_entry(void); 147void bte_main_disable(void); 148void bte_main_cleanup(void); 149#if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE) 150void bte_main_enable_lpm(BOOLEAN enable); 151#endif 152void bte_main_postload_cfg(void); 153void btif_dm_execute_service_request(UINT16 event, char *p_param); 154#ifdef BTIF_DM_OOB_TEST 155void btif_dm_load_local_oob(void); 156#endif 157void bte_main_config_hci_logging(BOOLEAN enable, BOOLEAN bt_disabled); 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 171static void btif_context_switched(void *p_msg) 172{ 173 174 BTIF_TRACE_VERBOSE("btif_context_switched"); 175 176 tBTIF_CONTEXT_SWITCH_CBACK *p = (tBTIF_CONTEXT_SWITCH_CBACK *) p_msg; 177 178 /* each callback knows how to parse the data */ 179 if (p->p_cb) 180 p->p_cb(p->event, p->p_param); 181} 182 183 184/******************************************************************************* 185** 186** Function btif_transfer_context 187** 188** Description This function switches context to btif task 189** 190** p_cback : callback used to process message in btif context 191** event : event id of message 192** p_params : parameter area passed to callback (copied) 193** param_len : length of parameter area 194** p_copy_cback : If set this function will be invoked for deep copy 195** 196** Returns void 197** 198*******************************************************************************/ 199 200bt_status_t btif_transfer_context (tBTIF_CBACK *p_cback, UINT16 event, char* p_params, int param_len, tBTIF_COPY_CBACK *p_copy_cback) 201{ 202 tBTIF_CONTEXT_SWITCH_CBACK *p_msg = 203 (tBTIF_CONTEXT_SWITCH_CBACK *)osi_malloc(sizeof(tBTIF_CONTEXT_SWITCH_CBACK) + param_len); 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 p_msg->hdr.event = BT_EVT_CONTEXT_SWITCH_EVT; /* internal event */ 209 p_msg->p_cb = p_cback; 210 211 p_msg->event = event; /* callback event */ 212 213 /* check if caller has provided a copy callback to do the deep copy */ 214 if (p_copy_cback) { 215 p_copy_cback(event, p_msg->p_param, p_params); 216 } else if (p_params) { 217 memcpy(p_msg->p_param, p_params, param_len); /* callback parameter data */ 218 } 219 220 btif_sendmsg(p_msg); 221 222 return BT_STATUS_SUCCESS; 223} 224 225/******************************************************************************* 226** 227** Function btif_is_dut_mode 228** 229** Description checks if BTIF is currently in DUT mode 230** 231** Returns 1 if test mode, otherwize 0 232** 233*******************************************************************************/ 234 235UINT8 btif_is_dut_mode(void) 236{ 237 return (btif_dut_mode == 1); 238} 239 240/******************************************************************************* 241** 242** Function btif_is_enabled 243** 244** Description checks if main adapter is fully enabled 245** 246** Returns 1 if fully enabled, otherwize 0 247** 248*******************************************************************************/ 249 250int btif_is_enabled(void) 251{ 252 return ((!btif_is_dut_mode()) && (stack_manager_get_interface()->get_stack_is_running())); 253} 254 255void btif_init_ok(UNUSED_ATTR uint16_t event, UNUSED_ATTR char *p_param) { 256 BTIF_TRACE_DEBUG("btif_task: received trigger stack init event"); 257#if (BLE_INCLUDED == TRUE) 258 btif_dm_load_ble_local_keys(); 259#endif 260 BTA_EnableBluetooth(bte_dm_evt); 261} 262 263/******************************************************************************* 264** 265** Function btif_task 266** 267** Description BTIF task handler managing all messages being passed 268** Bluetooth HAL and BTA. 269** 270** Returns void 271** 272*******************************************************************************/ 273static void bt_jni_msg_ready(void *context) { 274 BT_HDR *p_msg = (BT_HDR *)context; 275 276 BTIF_TRACE_VERBOSE("btif task fetched event %x", p_msg->event); 277 278 switch (p_msg->event) { 279 case BT_EVT_CONTEXT_SWITCH_EVT: 280 btif_context_switched(p_msg); 281 break; 282 default: 283 BTIF_TRACE_ERROR("unhandled btif event (%d)", p_msg->event & BT_EVT_MASK); 284 break; 285 } 286 osi_free(p_msg); 287} 288 289/******************************************************************************* 290** 291** Function btif_sendmsg 292** 293** Description Sends msg to BTIF task 294** 295** Returns void 296** 297*******************************************************************************/ 298 299void btif_sendmsg(void *p_msg) 300{ 301 if (!bt_jni_workqueue_thread) { 302 BTIF_TRACE_ERROR("%s: message dropped, queue not initialized or gone", __func__); 303 osi_free(p_msg); 304 return; 305 } 306 307 thread_post(bt_jni_workqueue_thread, bt_jni_msg_ready, p_msg); 308} 309 310void btif_thread_post(thread_fn func, void *context) { 311 if (!bt_jni_workqueue_thread) { 312 BTIF_TRACE_ERROR("%s: call dropped, queue not initialized or gone", __func__); 313 return; 314 } 315 316 thread_post(bt_jni_workqueue_thread, func, context); 317} 318 319static bool btif_fetch_property(const char *key, bt_bdaddr_t *addr) { 320 char val[PROPERTY_VALUE_MAX] = {0}; 321 322 if (osi_property_get(key, val, NULL)) { 323 if (string_to_bdaddr(val, addr)) { 324 BTIF_TRACE_DEBUG("%s: Got BDA %s", __func__, val); 325 return TRUE; 326 } 327 BTIF_TRACE_DEBUG("%s: System Property did not contain valid bdaddr", __func__); 328 } 329 return FALSE; 330} 331 332static void btif_fetch_local_bdaddr(bt_bdaddr_t *local_addr) 333{ 334 char val[PROPERTY_VALUE_MAX] = {0}; 335 uint8_t valid_bda = FALSE; 336 int val_size = 0; 337 338 const uint8_t null_bdaddr[BD_ADDR_LEN] = {0,0,0,0,0,0}; 339 340 /* Get local bdaddr storage path from property */ 341 if (osi_property_get(PROPERTY_BT_BDADDR_PATH, val, NULL)) 342 { 343 int addr_fd; 344 345 BTIF_TRACE_DEBUG("%s, local bdaddr is stored in %s", __func__, val); 346 347 if ((addr_fd = open(val, O_RDONLY)) != -1) 348 { 349 memset(val, 0, sizeof(val)); 350 read(addr_fd, val, FACTORY_BT_BDADDR_STORAGE_LEN); 351 /* If this is not a reserved/special bda, then use it */ 352 if ((string_to_bdaddr(val, local_addr)) && 353 (memcmp(local_addr->address, null_bdaddr, BD_ADDR_LEN) != 0)) 354 { 355 valid_bda = TRUE; 356 BTIF_TRACE_DEBUG("%s: Got Factory BDA %s", __func__, val); 357 } 358 close(addr_fd); 359 } 360 } 361 362 if(!valid_bda) 363 { 364 val_size = sizeof(val); 365 if(btif_config_get_str("Adapter", "Address", val, &val_size)) 366 { 367 string_to_bdaddr(val, local_addr); 368 BTIF_TRACE_DEBUG("local bdaddr from bt_config.xml is %s", val); 369 return; 370 } 371 } 372 373 /* No factory BDADDR found. Look for previously generated random BDA */ 374 if (!valid_bda) { 375 valid_bda = btif_fetch_property(PERSIST_BDADDR_PROPERTY, local_addr); 376 } 377 378 /* No BDADDR found in file. Look for BDA in factory property */ 379 if (!valid_bda) { 380 valid_bda = btif_fetch_property(FACTORY_BT_ADDR_PROPERTY, local_addr); 381 } 382 383 /* Generate new BDA if necessary */ 384 if (!valid_bda) 385 { 386 bdstr_t bdstr; 387 388 /* No autogen BDA. Generate one now. */ 389 local_addr->address[0] = 0x22; 390 local_addr->address[1] = 0x22; 391 local_addr->address[2] = (uint8_t) osi_rand(); 392 local_addr->address[3] = (uint8_t) osi_rand(); 393 local_addr->address[4] = (uint8_t) osi_rand(); 394 local_addr->address[5] = (uint8_t) osi_rand(); 395 396 /* Convert to ascii, and store as a persistent property */ 397 bdaddr_to_string(local_addr, bdstr, sizeof(bdstr)); 398 399 BTIF_TRACE_DEBUG("No preset BDA. Generating BDA: %s for prop %s", 400 (char*)bdstr, PERSIST_BDADDR_PROPERTY); 401 402 if (osi_property_set(PERSIST_BDADDR_PROPERTY, (char*)bdstr) < 0) 403 BTIF_TRACE_ERROR("Failed to set random BDA in prop %s",PERSIST_BDADDR_PROPERTY); 404 } 405 406 //save the bd address to config file 407 bdstr_t bdstr; 408 bdaddr_to_string(local_addr, bdstr, sizeof(bdstr)); 409 val_size = sizeof(val); 410 if (btif_config_get_str("Adapter", "Address", val, &val_size)) 411 { 412 if (strcmp(bdstr, val) ==0) 413 { 414 // BDA is already present in the config file. 415 return; 416 } 417 } 418 btif_config_set_str("Adapter", "Address", bdstr); 419} 420 421/******************************************************************************* 422** 423** Function btif_init_bluetooth 424** 425** Description Creates BTIF task and prepares BT scheduler for startup 426** 427** Returns bt_status_t 428** 429*******************************************************************************/ 430bt_status_t btif_init_bluetooth() { 431 bte_main_boot_entry(); 432 433 /* As part of the init, fetch the local BD ADDR */ 434 memset(&btif_local_bd_addr, 0, sizeof(bt_bdaddr_t)); 435 btif_fetch_local_bdaddr(&btif_local_bd_addr); 436 437 bt_jni_workqueue_thread = thread_new(BT_JNI_WORKQUEUE_NAME); 438 if (bt_jni_workqueue_thread == NULL) { 439 LOG_ERROR(LOG_TAG, "%s Unable to create thread %s", __func__, BT_JNI_WORKQUEUE_NAME); 440 goto error_exit; 441 } 442 443 // Associate this workqueue thread with jni. 444 btif_transfer_context(btif_jni_associate, 0, NULL, 0, NULL); 445 446 return BT_STATUS_SUCCESS; 447 448error_exit:; 449 thread_free(bt_jni_workqueue_thread); 450 451 bt_jni_workqueue_thread = NULL; 452 453 return BT_STATUS_FAIL; 454} 455 456/******************************************************************************* 457** 458** Function btif_enable_bluetooth_evt 459** 460** Description Event indicating bluetooth enable is completed 461** Notifies HAL user with updated adapter state 462** 463** Returns void 464** 465*******************************************************************************/ 466 467void btif_enable_bluetooth_evt(tBTA_STATUS status) 468{ 469 const controller_t *controller = controller_get_interface(); 470 bdstr_t bdstr; 471 bdaddr_to_string(controller->get_address(), bdstr, sizeof(bdstr)); 472 473 BTIF_TRACE_DEBUG("%s: status %d, local bd [%s]", __FUNCTION__, status, bdstr); 474 475 if (bdcmp(btif_local_bd_addr.address, controller->get_address()->address)) 476 { 477 // TODO(zachoverflow): this whole code path seems like a bad time waiting to happen 478 // We open the vendor library using the old address. 479 bdstr_t old_address; 480 bt_property_t prop; 481 482 bdaddr_to_string(&btif_local_bd_addr, old_address, sizeof(old_address)); 483 484 /** 485 * The Controller's BDADDR does not match to the BTIF's initial BDADDR! 486 * This could be because the factory BDADDR was stored separately in 487 * the Controller's non-volatile memory rather than in device's file 488 * system. 489 **/ 490 BTIF_TRACE_WARNING("***********************************************"); 491 BTIF_TRACE_WARNING("BTIF init BDA was %s", old_address); 492 BTIF_TRACE_WARNING("Controller BDA is %s", bdstr); 493 BTIF_TRACE_WARNING("***********************************************"); 494 495 btif_local_bd_addr = *controller->get_address(); 496 497 //save the bd address to config file 498 btif_config_set_str("Adapter", "Address", bdstr); 499 btif_config_save(); 500 501 //fire HAL callback for property change 502 prop.type = BT_PROPERTY_BDADDR; 503 prop.val = (void*)&btif_local_bd_addr; 504 prop.len = sizeof(bt_bdaddr_t); 505 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, BT_STATUS_SUCCESS, 1, &prop); 506 } 507 508 bte_main_postload_cfg(); 509#if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE) 510 bte_main_enable_lpm(TRUE); 511#endif 512 /* add passing up bd address as well ? */ 513 514 /* callback to HAL */ 515 if (status == BTA_SUCCESS) 516 { 517 uid_set = uid_set_create(); 518 519 btif_dm_init(uid_set); 520 521 /* init rfcomm & l2cap api */ 522 btif_sock_init(uid_set); 523 524 /* init pan */ 525 btif_pan_init(); 526 527 /* load did configuration */ 528 bte_load_did_conf(BTE_DID_CONF_FILE); 529 530#ifdef BTIF_DM_OOB_TEST 531 btif_dm_load_local_oob(); 532#endif 533 534 future_ready(stack_manager_get_hack_future(), FUTURE_SUCCESS); 535 } 536 else 537 { 538 /* cleanup rfcomm & l2cap api */ 539 btif_sock_cleanup(); 540 541 btif_pan_cleanup(); 542 543 future_ready(stack_manager_get_hack_future(), FUTURE_FAIL); 544 } 545} 546 547/******************************************************************************* 548** 549** Function btif_disable_bluetooth 550** 551** Description Inititates shutdown of Bluetooth system. 552** Any active links will be dropped and device entering 553** non connectable/discoverable mode 554** 555** Returns void 556** 557*******************************************************************************/ 558bt_status_t btif_disable_bluetooth(void) 559{ 560 BTIF_TRACE_DEBUG("BTIF DISABLE BLUETOOTH"); 561 562 btif_dm_on_disable(); 563 /* cleanup rfcomm & l2cap api */ 564 btif_sock_cleanup(); 565 btif_pan_cleanup(); 566 BTA_DisableBluetooth(); 567 568 return BT_STATUS_SUCCESS; 569} 570 571/******************************************************************************* 572** 573** Function btif_disable_bluetooth_evt 574** 575** Description Event notifying BT disable is now complete. 576** Terminates main stack tasks and notifies HAL 577** user with updated BT state. 578** 579** Returns void 580** 581*******************************************************************************/ 582 583void btif_disable_bluetooth_evt(void) 584{ 585 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 586 587#if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE) 588 bte_main_enable_lpm(FALSE); 589#endif 590 591 bte_main_disable(); 592 593 /* callback to HAL */ 594 future_ready(stack_manager_get_hack_future(), FUTURE_SUCCESS); 595} 596 597/******************************************************************************* 598** 599** Function btif_cleanup_bluetooth 600** 601** Description Cleanup BTIF state. 602** 603** Returns void 604** 605*******************************************************************************/ 606 607bt_status_t btif_cleanup_bluetooth(void) 608{ 609 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 610 611#if (BLE_INCLUDED == TRUE) 612 BTA_VendorCleanup(); 613#endif 614 615 btif_dm_cleanup(); 616 btif_jni_disassociate(); 617 btif_queue_release(); 618 619 thread_free(bt_jni_workqueue_thread); 620 bt_jni_workqueue_thread = NULL; 621 622 bte_main_cleanup(); 623 624 btif_dut_mode = 0; 625 626 BTIF_TRACE_DEBUG("%s done", __FUNCTION__); 627 628 return BT_STATUS_SUCCESS; 629} 630 631/******************************************************************************* 632** 633** Function btif_dut_mode_cback 634** 635** Description Callback invoked on completion of vendor specific test mode command 636** 637** Returns None 638** 639*******************************************************************************/ 640static void btif_dut_mode_cback( tBTM_VSC_CMPL *p ) 641{ 642 UNUSED(p); 643 /* For now nothing to be done. */ 644} 645 646/******************************************************************************* 647** 648** Function btif_dut_mode_configure 649** 650** Description Configure Test Mode - 'enable' to 1 puts the device in test mode and 0 exits 651** test mode 652** 653** Returns BT_STATUS_SUCCESS on success 654** 655*******************************************************************************/ 656bt_status_t btif_dut_mode_configure(uint8_t enable) 657{ 658 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 659 660 if (!stack_manager_get_interface()->get_stack_is_running()) { 661 BTIF_TRACE_ERROR("btif_dut_mode_configure : Bluetooth not enabled"); 662 return BT_STATUS_NOT_READY; 663 } 664 665 btif_dut_mode = enable; 666 if (enable == 1) { 667 BTA_EnableTestMode(); 668 } else { 669 BTA_DisableTestMode(); 670 } 671 return BT_STATUS_SUCCESS; 672} 673 674/******************************************************************************* 675** 676** Function btif_dut_mode_send 677** 678** Description Sends a HCI Vendor specific command to the controller 679** 680** Returns BT_STATUS_SUCCESS on success 681** 682*******************************************************************************/ 683bt_status_t btif_dut_mode_send(uint16_t opcode, uint8_t *buf, uint8_t len) 684{ 685 /* TODO: Check that opcode is a vendor command group */ 686 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 687 if (!btif_is_dut_mode()) { 688 BTIF_TRACE_ERROR("Bluedroid HAL needs to be init with test_mode set to 1."); 689 return BT_STATUS_FAIL; 690 } 691 BTM_VendorSpecificCommand(opcode, len, buf, btif_dut_mode_cback); 692 return BT_STATUS_SUCCESS; 693} 694 695/***************************************************************************** 696** 697** btif api adapter property functions 698** 699*****************************************************************************/ 700 701static bt_status_t btif_in_get_adapter_properties(void) 702{ 703 bt_property_t properties[6]; 704 uint32_t num_props; 705 706 bt_bdaddr_t addr; 707 bt_bdname_t name; 708 bt_scan_mode_t mode; 709 uint32_t disc_timeout; 710 bt_bdaddr_t bonded_devices[BTM_SEC_MAX_DEVICE_RECORDS]; 711 bt_uuid_t local_uuids[BT_MAX_NUM_UUIDS]; 712 num_props = 0; 713 714 /* BD_ADDR */ 715 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_BDADDR, 716 sizeof(addr), &addr); 717 btif_storage_get_adapter_property(&properties[num_props]); 718 num_props++; 719 720 /* BD_NAME */ 721 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_BDNAME, 722 sizeof(name), &name); 723 btif_storage_get_adapter_property(&properties[num_props]); 724 num_props++; 725 726 /* SCAN_MODE */ 727 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_ADAPTER_SCAN_MODE, 728 sizeof(mode), &mode); 729 btif_storage_get_adapter_property(&properties[num_props]); 730 num_props++; 731 732 /* DISC_TIMEOUT */ 733 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT, 734 sizeof(disc_timeout), &disc_timeout); 735 btif_storage_get_adapter_property(&properties[num_props]); 736 num_props++; 737 738 /* BONDED_DEVICES */ 739 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_ADAPTER_BONDED_DEVICES, 740 sizeof(bonded_devices), bonded_devices); 741 btif_storage_get_adapter_property(&properties[num_props]); 742 num_props++; 743 744 /* LOCAL UUIDs */ 745 BTIF_STORAGE_FILL_PROPERTY(&properties[num_props], BT_PROPERTY_UUIDS, 746 sizeof(local_uuids), local_uuids); 747 btif_storage_get_adapter_property(&properties[num_props]); 748 num_props++; 749 750 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, 751 BT_STATUS_SUCCESS, num_props, properties); 752 753 return BT_STATUS_SUCCESS; 754} 755 756static bt_status_t btif_in_get_remote_device_properties(bt_bdaddr_t *bd_addr) 757{ 758 bt_property_t remote_properties[8]; 759 uint32_t num_props = 0; 760 761 bt_bdname_t name, alias; 762 uint32_t cod, devtype; 763 bt_uuid_t remote_uuids[BT_MAX_NUM_UUIDS]; 764 765 memset(remote_properties, 0, sizeof(remote_properties)); 766 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_BDNAME, 767 sizeof(name), &name); 768 btif_storage_get_remote_device_property(bd_addr, 769 &remote_properties[num_props]); 770 num_props++; 771 772 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_REMOTE_FRIENDLY_NAME, 773 sizeof(alias), &alias); 774 btif_storage_get_remote_device_property(bd_addr, 775 &remote_properties[num_props]); 776 num_props++; 777 778 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_CLASS_OF_DEVICE, 779 sizeof(cod), &cod); 780 btif_storage_get_remote_device_property(bd_addr, 781 &remote_properties[num_props]); 782 num_props++; 783 784 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_TYPE_OF_DEVICE, 785 sizeof(devtype), &devtype); 786 btif_storage_get_remote_device_property(bd_addr, 787 &remote_properties[num_props]); 788 num_props++; 789 790 BTIF_STORAGE_FILL_PROPERTY(&remote_properties[num_props], BT_PROPERTY_UUIDS, 791 sizeof(remote_uuids), remote_uuids); 792 btif_storage_get_remote_device_property(bd_addr, 793 &remote_properties[num_props]); 794 num_props++; 795 796 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb, 797 BT_STATUS_SUCCESS, bd_addr, num_props, remote_properties); 798 799 return BT_STATUS_SUCCESS; 800} 801 802 803/******************************************************************************* 804** 805** Function execute_storage_request 806** 807** Description Executes adapter storage request in BTIF context 808** 809** Returns bt_status_t 810** 811*******************************************************************************/ 812 813static void execute_storage_request(UINT16 event, char *p_param) 814{ 815 bt_status_t status = BT_STATUS_SUCCESS; 816 817 BTIF_TRACE_EVENT("execute storage request event : %d", event); 818 819 switch(event) 820 { 821 case BTIF_CORE_STORAGE_ADAPTER_WRITE: 822 { 823 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param; 824 bt_property_t *p_prop = &(p_req->write_req.prop); 825 BTIF_TRACE_EVENT("type: %d, len %d, 0x%x", p_prop->type, 826 p_prop->len, p_prop->val); 827 828 status = btif_storage_set_adapter_property(p_prop); 829 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 1, p_prop); 830 } break; 831 832 case BTIF_CORE_STORAGE_ADAPTER_READ: 833 { 834 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param; 835 char buf[512]; 836 bt_property_t prop; 837 prop.type = p_req->read_req.type; 838 prop.val = (void*)buf; 839 prop.len = sizeof(buf); 840 if (prop.type == BT_PROPERTY_LOCAL_LE_FEATURES) 841 { 842 #if (BLE_INCLUDED == TRUE) 843 tBTM_BLE_VSC_CB cmn_vsc_cb; 844 bt_local_le_features_t local_le_features; 845 846 /* LE features are not stored in storage. Should be retrived from stack */ 847 BTM_BleGetVendorCapabilities(&cmn_vsc_cb); 848 local_le_features.local_privacy_enabled = BTM_BleLocalPrivacyEnabled(); 849 850 prop.len = sizeof (bt_local_le_features_t); 851 if (cmn_vsc_cb.filter_support == 1) 852 local_le_features.max_adv_filter_supported = cmn_vsc_cb.max_filter; 853 else 854 local_le_features.max_adv_filter_supported = 0; 855 local_le_features.max_adv_instance = cmn_vsc_cb.adv_inst_max; 856 local_le_features.max_irk_list_size = cmn_vsc_cb.max_irk_list_sz; 857 local_le_features.rpa_offload_supported = cmn_vsc_cb.rpa_offloading; 858 local_le_features.scan_result_storage_size = cmn_vsc_cb.tot_scan_results_strg; 859 local_le_features.activity_energy_info_supported = cmn_vsc_cb.energy_support; 860 local_le_features.version_supported = cmn_vsc_cb.version_supported; 861 local_le_features.total_trackable_advertisers = 862 cmn_vsc_cb.total_trackable_advertisers; 863 864 local_le_features.extended_scan_support = cmn_vsc_cb.extended_scan_support > 0; 865 local_le_features.debug_logging_supported = cmn_vsc_cb.debug_logging_supported > 0; 866 memcpy(prop.val, &local_le_features, prop.len); 867 #endif 868 } 869 else 870 { 871 status = btif_storage_get_adapter_property(&prop); 872 } 873 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 1, &prop); 874 } break; 875 876 case BTIF_CORE_STORAGE_ADAPTER_READ_ALL: 877 { 878 status = btif_in_get_adapter_properties(); 879 } break; 880 881 case BTIF_CORE_STORAGE_NOTIFY_STATUS: 882 { 883 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, 0, NULL); 884 } break; 885 886 default: 887 BTIF_TRACE_ERROR("%s invalid event id (%d)", __FUNCTION__, event); 888 break; 889 } 890} 891 892static void execute_storage_remote_request(UINT16 event, char *p_param) 893{ 894 bt_status_t status = BT_STATUS_FAIL; 895 bt_property_t prop; 896 897 BTIF_TRACE_EVENT("execute storage remote request event : %d", event); 898 899 switch (event) 900 { 901 case BTIF_CORE_STORAGE_REMOTE_READ: 902 { 903 char buf[1024]; 904 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param; 905 prop.type = p_req->read_req.type; 906 prop.val = (void*) buf; 907 prop.len = sizeof(buf); 908 909 status = btif_storage_get_remote_device_property(&(p_req->read_req.bd_addr), 910 &prop); 911 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb, 912 status, &(p_req->read_req.bd_addr), 1, &prop); 913 }break; 914 case BTIF_CORE_STORAGE_REMOTE_WRITE: 915 { 916 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param; 917 status = btif_storage_set_remote_device_property(&(p_req->write_req.bd_addr), 918 &(p_req->write_req.prop)); 919 }break; 920 case BTIF_CORE_STORAGE_REMOTE_READ_ALL: 921 { 922 btif_storage_req_t *p_req = (btif_storage_req_t*)p_param; 923 btif_in_get_remote_device_properties(&p_req->read_req.bd_addr); 924 }break; 925 } 926} 927 928void btif_adapter_properties_evt(bt_status_t status, uint32_t num_props, 929 bt_property_t *p_props) 930{ 931 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, 932 status, num_props, p_props); 933 934} 935void btif_remote_properties_evt(bt_status_t status, bt_bdaddr_t *remote_addr, 936 uint32_t num_props, bt_property_t *p_props) 937{ 938 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb, 939 status, remote_addr, num_props, p_props); 940} 941 942/******************************************************************************* 943** 944** Function btif_in_storage_request_copy_cb 945** 946** Description Switch context callback function to perform the deep copy for 947** both the adapter and remote_device property API 948** 949** Returns None 950** 951*******************************************************************************/ 952static void btif_in_storage_request_copy_cb(UINT16 event, 953 char *p_new_buf, char *p_old_buf) 954{ 955 btif_storage_req_t *new_req = (btif_storage_req_t*)p_new_buf; 956 btif_storage_req_t *old_req = (btif_storage_req_t*)p_old_buf; 957 958 BTIF_TRACE_EVENT("%s", __FUNCTION__); 959 switch (event) 960 { 961 case BTIF_CORE_STORAGE_REMOTE_WRITE: 962 case BTIF_CORE_STORAGE_ADAPTER_WRITE: 963 { 964 bdcpy(new_req->write_req.bd_addr.address, old_req->write_req.bd_addr.address); 965 /* Copy the member variables one at a time */ 966 new_req->write_req.prop.type = old_req->write_req.prop.type; 967 new_req->write_req.prop.len = old_req->write_req.prop.len; 968 969 new_req->write_req.prop.val = (UINT8 *)(p_new_buf + sizeof(btif_storage_req_t)); 970 memcpy(new_req->write_req.prop.val, old_req->write_req.prop.val, 971 old_req->write_req.prop.len); 972 }break; 973 } 974} 975 976/******************************************************************************* 977** 978** Function btif_get_adapter_properties 979** 980** Description Fetch all available properties (local & remote) 981** 982** Returns bt_status_t 983** 984*******************************************************************************/ 985 986bt_status_t btif_get_adapter_properties(void) 987{ 988 BTIF_TRACE_EVENT("%s", __FUNCTION__); 989 990 if (!btif_is_enabled()) 991 return BT_STATUS_NOT_READY; 992 993 return btif_transfer_context(execute_storage_request, 994 BTIF_CORE_STORAGE_ADAPTER_READ_ALL, 995 NULL, 0, NULL); 996} 997 998/******************************************************************************* 999** 1000** Function btif_get_adapter_property 1001** 1002** Description Fetches property value from local cache 1003** 1004** Returns bt_status_t 1005** 1006*******************************************************************************/ 1007 1008bt_status_t btif_get_adapter_property(bt_property_type_t type) 1009{ 1010 btif_storage_req_t req; 1011 1012 BTIF_TRACE_EVENT("%s %d", __FUNCTION__, type); 1013 1014 /* Allow get_adapter_property only for BDADDR and BDNAME if BT is disabled */ 1015 if (!btif_is_enabled() && (type != BT_PROPERTY_BDADDR) && (type != BT_PROPERTY_BDNAME)) 1016 return BT_STATUS_NOT_READY; 1017 1018 memset(&(req.read_req.bd_addr), 0, sizeof(bt_bdaddr_t)); 1019 req.read_req.type = type; 1020 1021 return btif_transfer_context(execute_storage_request, 1022 BTIF_CORE_STORAGE_ADAPTER_READ, 1023 (char*)&req, sizeof(btif_storage_req_t), NULL); 1024} 1025 1026/******************************************************************************* 1027** 1028** Function btif_set_adapter_property 1029** 1030** Description Updates core stack with property value and stores it in 1031** local cache 1032** 1033** Returns bt_status_t 1034** 1035*******************************************************************************/ 1036 1037bt_status_t btif_set_adapter_property(const bt_property_t *property) 1038{ 1039 btif_storage_req_t req; 1040 bt_status_t status = BT_STATUS_SUCCESS; 1041 int storage_req_id = BTIF_CORE_STORAGE_NOTIFY_STATUS; /* default */ 1042 char bd_name[BTM_MAX_LOC_BD_NAME_LEN +1]; 1043 UINT16 name_len = 0; 1044 1045 BTIF_TRACE_EVENT("btif_set_adapter_property type: %d, len %d, 0x%x", 1046 property->type, property->len, property->val); 1047 1048 if (!btif_is_enabled()) 1049 return BT_STATUS_NOT_READY; 1050 1051 switch(property->type) 1052 { 1053 case BT_PROPERTY_BDNAME: 1054 { 1055 name_len = property->len > BTM_MAX_LOC_BD_NAME_LEN ? BTM_MAX_LOC_BD_NAME_LEN: 1056 property->len; 1057 memcpy(bd_name,property->val, name_len); 1058 bd_name[name_len] = '\0'; 1059 1060 BTIF_TRACE_EVENT("set property name : %s", (char *)bd_name); 1061 1062 BTA_DmSetDeviceName((char *)bd_name); 1063 1064 storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE; 1065 } 1066 break; 1067 1068 case BT_PROPERTY_ADAPTER_SCAN_MODE: 1069 { 1070 bt_scan_mode_t mode = *(bt_scan_mode_t*)property->val; 1071 tBTA_DM_DISC disc_mode; 1072 tBTA_DM_CONN conn_mode; 1073 1074 switch(mode) 1075 { 1076 case BT_SCAN_MODE_NONE: 1077 disc_mode = BTA_DM_NON_DISC; 1078 conn_mode = BTA_DM_NON_CONN; 1079 break; 1080 1081 case BT_SCAN_MODE_CONNECTABLE: 1082 disc_mode = BTA_DM_NON_DISC; 1083 conn_mode = BTA_DM_CONN; 1084 break; 1085 1086 case BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE: 1087 disc_mode = BTA_DM_GENERAL_DISC; 1088 conn_mode = BTA_DM_CONN; 1089 break; 1090 1091 default: 1092 BTIF_TRACE_ERROR("invalid scan mode (0x%x)", mode); 1093 return BT_STATUS_PARM_INVALID; 1094 } 1095 1096 BTIF_TRACE_EVENT("set property scan mode : %x", mode); 1097 1098 BTA_DmSetVisibility(disc_mode, conn_mode, BTA_DM_IGNORE, BTA_DM_IGNORE); 1099 1100 storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE; 1101 } 1102 break; 1103 case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT: 1104 { 1105 /* Nothing to do beside store the value in NV. Java 1106 will change the SCAN_MODE property after setting timeout, 1107 if required */ 1108 storage_req_id = BTIF_CORE_STORAGE_ADAPTER_WRITE; 1109 } 1110 break; 1111 case BT_PROPERTY_BDADDR: 1112 case BT_PROPERTY_UUIDS: 1113 case BT_PROPERTY_ADAPTER_BONDED_DEVICES: 1114 case BT_PROPERTY_REMOTE_FRIENDLY_NAME: 1115 /* no write support through HAL, these properties are only populated from BTA events */ 1116 status = BT_STATUS_FAIL; 1117 break; 1118 default: 1119 BTIF_TRACE_ERROR("btif_get_adapter_property : invalid type %d", 1120 property->type); 1121 status = BT_STATUS_FAIL; 1122 break; 1123 } 1124 1125 if (storage_req_id != BTIF_CORE_STORAGE_NO_ACTION) 1126 { 1127 /* pass on to storage for updating local database */ 1128 1129 memset(&(req.write_req.bd_addr), 0, sizeof(bt_bdaddr_t)); 1130 memcpy(&(req.write_req.prop), property, sizeof(bt_property_t)); 1131 1132 return btif_transfer_context(execute_storage_request, 1133 storage_req_id, 1134 (char*)&req, 1135 sizeof(btif_storage_req_t)+property->len, 1136 btif_in_storage_request_copy_cb); 1137 } 1138 1139 return status; 1140 1141} 1142 1143/******************************************************************************* 1144** 1145** Function btif_get_remote_device_property 1146** 1147** Description Fetches the remote device property from the NVRAM 1148** 1149** Returns bt_status_t 1150** 1151*******************************************************************************/ 1152bt_status_t btif_get_remote_device_property(bt_bdaddr_t *remote_addr, 1153 bt_property_type_t type) 1154{ 1155 btif_storage_req_t req; 1156 1157 if (!btif_is_enabled()) 1158 return BT_STATUS_NOT_READY; 1159 1160 memcpy(&(req.read_req.bd_addr), remote_addr, sizeof(bt_bdaddr_t)); 1161 req.read_req.type = type; 1162 return btif_transfer_context(execute_storage_remote_request, 1163 BTIF_CORE_STORAGE_REMOTE_READ, 1164 (char*)&req, sizeof(btif_storage_req_t), 1165 NULL); 1166} 1167 1168/******************************************************************************* 1169** 1170** Function btif_get_remote_device_properties 1171** 1172** Description Fetches all the remote device properties from NVRAM 1173** 1174** Returns bt_status_t 1175** 1176*******************************************************************************/ 1177bt_status_t btif_get_remote_device_properties(bt_bdaddr_t *remote_addr) 1178{ 1179 btif_storage_req_t req; 1180 1181 if (!btif_is_enabled()) 1182 return BT_STATUS_NOT_READY; 1183 1184 memcpy(&(req.read_req.bd_addr), remote_addr, sizeof(bt_bdaddr_t)); 1185 return btif_transfer_context(execute_storage_remote_request, 1186 BTIF_CORE_STORAGE_REMOTE_READ_ALL, 1187 (char*)&req, sizeof(btif_storage_req_t), 1188 NULL); 1189} 1190 1191/******************************************************************************* 1192** 1193** Function btif_set_remote_device_property 1194** 1195** Description Writes the remote device property to NVRAM. 1196** Currently, BT_PROPERTY_REMOTE_FRIENDLY_NAME is the only 1197** remote device property that can be set 1198** 1199** Returns bt_status_t 1200** 1201*******************************************************************************/ 1202bt_status_t btif_set_remote_device_property(bt_bdaddr_t *remote_addr, 1203 const bt_property_t *property) 1204{ 1205 btif_storage_req_t req; 1206 1207 if (!btif_is_enabled()) 1208 return BT_STATUS_NOT_READY; 1209 1210 memcpy(&(req.write_req.bd_addr), remote_addr, sizeof(bt_bdaddr_t)); 1211 memcpy(&(req.write_req.prop), property, sizeof(bt_property_t)); 1212 1213 return btif_transfer_context(execute_storage_remote_request, 1214 BTIF_CORE_STORAGE_REMOTE_WRITE, 1215 (char*)&req, 1216 sizeof(btif_storage_req_t)+property->len, 1217 btif_in_storage_request_copy_cb); 1218} 1219 1220 1221/******************************************************************************* 1222** 1223** Function btif_get_remote_service_record 1224** 1225** Description Looks up the service matching uuid on the remote device 1226** and fetches the SCN and service_name if the UUID is found 1227** 1228** Returns bt_status_t 1229** 1230*******************************************************************************/ 1231bt_status_t btif_get_remote_service_record(bt_bdaddr_t *remote_addr, 1232 bt_uuid_t *uuid) 1233{ 1234 if (!btif_is_enabled()) 1235 return BT_STATUS_NOT_READY; 1236 1237 return btif_dm_get_remote_service_record(remote_addr, uuid); 1238} 1239 1240 1241/******************************************************************************* 1242** 1243** Function btif_get_enabled_services_mask 1244** 1245** Description Fetches currently enabled services 1246** 1247** Returns tBTA_SERVICE_MASK 1248** 1249*******************************************************************************/ 1250 1251tBTA_SERVICE_MASK btif_get_enabled_services_mask(void) 1252{ 1253 return btif_enabled_services; 1254} 1255 1256/******************************************************************************* 1257** 1258** Function btif_enable_service 1259** 1260** Description Enables the service 'service_ID' to the service_mask. 1261** Upon BT enable, BTIF core shall invoke the BTA APIs to 1262** enable the profiles 1263** 1264** Returns bt_status_t 1265** 1266*******************************************************************************/ 1267bt_status_t btif_enable_service(tBTA_SERVICE_ID service_id) 1268{ 1269 tBTA_SERVICE_ID *p_id = &service_id; 1270 1271 /* If BT is enabled, we need to switch to BTIF context and trigger the 1272 * enable for that profile 1273 * 1274 * Otherwise, we just set the flag. On BT_Enable, the DM will trigger 1275 * enable for the profiles that have been enabled */ 1276 1277 btif_enabled_services |= (1 << service_id); 1278 1279 BTIF_TRACE_DEBUG("%s: current services:0x%x", __FUNCTION__, btif_enabled_services); 1280 1281 if (btif_is_enabled()) 1282 { 1283 btif_transfer_context(btif_dm_execute_service_request, 1284 BTIF_DM_ENABLE_SERVICE, 1285 (char*)p_id, sizeof(tBTA_SERVICE_ID), NULL); 1286 } 1287 1288 return BT_STATUS_SUCCESS; 1289} 1290/******************************************************************************* 1291** 1292** Function btif_disable_service 1293** 1294** Description Disables the service 'service_ID' to the service_mask. 1295** Upon BT disable, BTIF core shall invoke the BTA APIs to 1296** disable the profiles 1297** 1298** Returns bt_status_t 1299** 1300*******************************************************************************/ 1301bt_status_t btif_disable_service(tBTA_SERVICE_ID service_id) 1302{ 1303 tBTA_SERVICE_ID *p_id = &service_id; 1304 1305 /* If BT is enabled, we need to switch to BTIF context and trigger the 1306 * disable for that profile so that the appropriate uuid_property_changed will 1307 * be triggerred. Otherwise, we just need to clear the service_id in the mask 1308 */ 1309 1310 btif_enabled_services &= (tBTA_SERVICE_MASK)(~(1<<service_id)); 1311 1312 BTIF_TRACE_DEBUG("%s: Current Services:0x%x", __FUNCTION__, btif_enabled_services); 1313 1314 if (btif_is_enabled()) 1315 { 1316 btif_transfer_context(btif_dm_execute_service_request, 1317 BTIF_DM_DISABLE_SERVICE, 1318 (char*)p_id, sizeof(tBTA_SERVICE_ID), NULL); 1319 } 1320 1321 return BT_STATUS_SUCCESS; 1322} 1323 1324static void btif_jni_associate(UNUSED_ATTR uint16_t event, UNUSED_ATTR char *p_param) { 1325 BTIF_TRACE_DEBUG("%s Associating thread to JVM", __func__); 1326 HAL_CBACK(bt_hal_cbacks, thread_evt_cb, ASSOCIATE_JVM); 1327} 1328 1329static void btif_jni_disassociate() { 1330 BTIF_TRACE_DEBUG("%s Disassociating thread from JVM", __func__); 1331 HAL_CBACK(bt_hal_cbacks, thread_evt_cb, DISASSOCIATE_JVM); 1332 bt_hal_cbacks = NULL; 1333} 1334