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