1 /****************************************************************************** 2 * 3 * Copyright (C) 1999-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 * This file contains functions that handle BTM interface functions for the 22 * Bluetooth device including Rest, HCI buffer size and others 23 * 24 ******************************************************************************/ 25 26 #include <stdlib.h> 27 #include <string.h> 28 #include <stdio.h> 29 #include <stddef.h> 30 31 #include "bt_types.h" 32 #include "hcimsgs.h" 33 #include "btu.h" 34 #include "btm_int.h" 35 #include "l2c_int.h" 36 37 #if BLE_INCLUDED == TRUE 38 #include "gatt_int.h" 39 40 #endif /* BLE_INCLUDED */ 41 42 /* BTM_APP_DEV_INIT should be defined if additional controller initialization is 43 ** needed by the application to be performed after the HCI reset 44 */ 45 #ifdef BTM_APP_DEV_INIT 46 extern void BTM_APP_DEV_INIT(void); 47 #endif 48 49 #ifdef BTA_PRM_CHECK_FW_VER 50 extern BOOLEAN BTA_PRM_CHECK_FW_VER(UINT8 *p); 51 #endif 52 53 #ifndef TT_DEV_RESET_MASK 54 #define TT_DEV_RESET_MASK 0xff 55 #endif 56 57 /********************************************************************************/ 58 /* L O C A L D A T A D E F I N I T I O N S */ 59 /********************************************************************************/ 60 61 /* The default class of device. */ 62 #ifndef BTM_INIT_CLASS_OF_DEVICE 63 #define BTM_INIT_CLASS_OF_DEVICE "\x00\x1F\x00" 64 #endif 65 66 #ifndef BTM_DEV_RESET_TIMEOUT 67 #define BTM_DEV_RESET_TIMEOUT 4 68 #endif 69 70 #define BTM_DEV_REPLY_TIMEOUT 2 /* 1 second expiration time is not good. Timer may start between 0 and 1 second. */ 71 /* if it starts at the very end of the 0 second, timer will expire really easily. */ 72 73 #define BTM_INFO_TIMEOUT 5 /* 5 seconds for info response */ 74 75 /* After Reset a timeout can be specified in the target.h for specific targets 76 * that may require additional time to reset 77 * otherwise no timeout is required 78 */ 79 #ifndef BTM_AFTER_RESET_TIMEOUT 80 #define BTM_AFTER_RESET_TIMEOUT 0 81 #endif 82 83 /* Internal baseband so the parameters such as local features, version etc. are known 84 so there is no need to issue HCI commands and wait for responses at BTM initialization */ 85 #ifndef BTM_INTERNAL_BB 86 #define BTM_INTERNAL_BB FALSE 87 #endif 88 89 /* The local version information in the format specified in the HCI read local version 90 response message */ 91 #ifndef BTM_INTERNAL_LOCAL_VER 92 #define BTM_INTERNAL_LOCAL_VER {0x00, 0x01, 0x05, 0x81, 0x01, 0x30, 0x00, 0x40, 0x8D} 93 #endif 94 95 /* The local features information in the format specified in the HCI read local features 96 response message */ 97 #ifndef BTM_INTERNAL_LOCAL_FEA 98 #define BTM_INTERNAL_LOCAL_FEA {0x00, 0xFF, 0xF9, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00} 99 #endif 100 101 #ifndef BTM_SET_DEV_NAME_UPON_RESET 102 #define BTM_SET_DEV_NAME_UPON_RESET TRUE 103 #endif 104 105 /* host SCO buffer size */ 106 #ifndef BTM_SCO_HOST_BUF_SIZE 107 #define BTM_SCO_HOST_BUF_SIZE 0xff 108 #endif 109 110 /********************************************************************************/ 111 /* L O C A L F U N C T I O N P R O T O T Y P E S */ 112 /********************************************************************************/ 113 static void btm_dev_reset (void); 114 static void btm_after_reset_hold_complete (void); 115 static void btm_continue_reset (void); 116 117 static void btm_get_local_ext_features (UINT8 page_number); 118 static void btm_decode_ext_features_page (UINT8 page_number, const BD_FEATURES p_features); 119 static void btm_read_all_lmp_features_complete (UINT8 max_page_number); 120 static void btm_set_lmp_features_host_may_support (UINT8 max_page_number); 121 static void btm_get_local_features (void); 122 static void btm_issue_host_support_for_lmp_features (void); 123 static void btm_read_local_supported_cmds (UINT8 local_controller_id); 124 125 #if BLE_INCLUDED == TRUE 126 static void btm_read_ble_local_supported_features (void); 127 #endif 128 129 /******************************************************************************* 130 ** 131 ** Function btm_dev_init 132 ** 133 ** Description This function is on the BTM startup 134 ** 135 ** Returns void 136 ** 137 *******************************************************************************/ 138 void btm_dev_init (void) 139 { 140 #if 0 /* cleared in btm_init; put back in if called from anywhere else! */ 141 memset (&btm_cb.devcb, 0, sizeof (tBTM_DEVCB)); 142 #endif 143 144 /* Initialize nonzero defaults */ 145 #if (BTM_MAX_LOC_BD_NAME_LEN > 0) 146 memset(btm_cb.cfg.bd_name, 0, sizeof(tBTM_LOC_BD_NAME)); 147 #if (BTM_USE_DEF_LOCAL_NAME == TRUE) 148 BCM_STRNCPY_S(btm_cb.cfg.bd_name, sizeof(btm_cb.cfg.bd_name), BTM_DEF_LOCAL_NAME, BTM_MAX_LOC_BD_NAME_LEN); 149 #endif 150 #endif 151 152 btm_cb.devcb.reset_timer.param = (TIMER_PARAM_TYPE)TT_DEV_RESET; 153 btm_cb.devcb.rln_timer.param = (TIMER_PARAM_TYPE)TT_DEV_RLN; 154 btm_cb.devcb.rlinkp_timer.param = (TIMER_PARAM_TYPE)TT_DEV_RLNKP; 155 156 btm_cb.btm_acl_pkt_types_supported = BTM_ACL_PKT_TYPES_MASK_DH1 + BTM_ACL_PKT_TYPES_MASK_DM1 + 157 BTM_ACL_PKT_TYPES_MASK_DH3 + BTM_ACL_PKT_TYPES_MASK_DM3 + 158 BTM_ACL_PKT_TYPES_MASK_DH5 + BTM_ACL_PKT_TYPES_MASK_DM5; 159 160 btm_cb.btm_sco_pkt_types_supported = BTM_SCO_PKT_TYPES_MASK_HV1 + 161 BTM_SCO_PKT_TYPES_MASK_HV2 + 162 BTM_SCO_PKT_TYPES_MASK_HV3 + 163 BTM_SCO_PKT_TYPES_MASK_EV3 + 164 BTM_SCO_PKT_TYPES_MASK_EV4 + 165 BTM_SCO_PKT_TYPES_MASK_EV5; 166 167 btm_cb.first_disabled_channel = 0xff; /* To allow disabling 0th channel alone */ 168 btm_cb.last_disabled_channel = 0xff; /* To allow disabling 0th channel alone */ 169 170 #if (BTM_AUTOMATIC_HCI_RESET == TRUE) 171 172 #if (BTM_FIRST_RESET_DELAY > 0) 173 btm_cb.devcb.state = BTM_DEV_STATE_WAIT_RESET_CMPLT; 174 btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_FIRST_RESET_DELAY); 175 #else 176 btm_dev_reset(); 177 #endif 178 179 #else 180 BTM_TRACE_EVENT0 ("BTM_AUTOMATIC_HCI_RESET is FALSE, so skip btm reset for now"); 181 #endif 182 183 } 184 185 186 /******************************************************************************* 187 ** 188 ** Function btm_db_reset 189 ** 190 ** Description This function is called by BTM_DeviceReset and clears out any 191 ** pending callbacks for inquiries, discoveries, other pending 192 ** functions that may be in progress. 193 ** 194 ** Returns void 195 ** 196 *******************************************************************************/ 197 static void btm_db_reset (void) 198 { 199 tBTM_CMPL_CB *p_cb; 200 tBTM_STATUS status = BTM_DEV_RESET; 201 202 btm_inq_db_reset(); 203 204 if (btm_cb.devcb.p_rln_cmpl_cb) 205 { 206 p_cb = btm_cb.devcb.p_rln_cmpl_cb; 207 btm_cb.devcb.p_rln_cmpl_cb = NULL; 208 209 if (p_cb) 210 (*p_cb)((void *) NULL); 211 } 212 213 if (btm_cb.devcb.p_rlinkp_cmpl_cb) 214 { 215 p_cb = btm_cb.devcb.p_rlinkp_cmpl_cb; 216 btm_cb.devcb.p_rlinkp_cmpl_cb = NULL; 217 218 if (p_cb) 219 (*p_cb)((void *) &status); 220 } 221 222 if (btm_cb.devcb.p_rssi_cmpl_cb) 223 { 224 p_cb = btm_cb.devcb.p_rssi_cmpl_cb; 225 btm_cb.devcb.p_rssi_cmpl_cb = NULL; 226 227 if (p_cb) 228 (*p_cb)((tBTM_RSSI_RESULTS *) &status); 229 } 230 } 231 232 233 234 /******************************************************************************* 235 ** 236 ** Function btm_dev_absent 237 ** 238 ** Description This function is called by when it is detected that the 239 ** device is not connected any more. 240 ** 241 ** Returns void 242 ** 243 *******************************************************************************/ 244 void btm_dev_absent (void) 245 { 246 btm_cb.devcb.state = BTM_DEV_STATE_WAIT_RESET_CMPLT; 247 248 btm_db_reset (); 249 btm_inq_db_reset(); 250 251 /* If anyone wants device status notifications, give him one */ 252 btm_report_device_status (BTM_DEV_STATUS_DOWN); 253 254 btu_stop_timer (&btm_cb.devcb.reset_timer); 255 } 256 257 258 /******************************************************************************* 259 ** 260 ** Function BTM_DeviceReset 261 ** 262 ** Description This function is called to reset the HCI. Callback function 263 ** if provided is called when startup of the device is 264 ** completed. 265 ** 266 ** Returns void 267 ** 268 *******************************************************************************/ 269 void BTM_DeviceReset (tBTM_CMPL_CB *p_cb) 270 { 271 tBTM_STATUS status; 272 273 /* If device is already resetting, do not allow another */ 274 if ((!btm_cb.devcb.p_reset_cmpl_cb) || (btm_cb.devcb.p_reset_cmpl_cb == p_cb)) 275 { 276 /* Flush all ACL connections */ 277 btm_acl_device_down(); 278 279 /* Clear the callback, so application would not hang on reset */ 280 btm_db_reset(); 281 282 /* Save address of the completion routine, if provided */ 283 btm_cb.devcb.p_reset_cmpl_cb = p_cb; 284 285 btm_dev_reset (); 286 } 287 else 288 { 289 /* pass an error to the bad callback, another one was already provided */ 290 if (p_cb) 291 { 292 status = BTM_ILLEGAL_VALUE; 293 p_cb (&status); 294 } 295 } 296 } 297 298 299 /******************************************************************************* 300 ** 301 ** Function BTM_IsDeviceUp 302 ** 303 ** Description This function is called to check if the device is up. 304 ** 305 ** Returns TRUE if device is up, else FALSE 306 ** 307 *******************************************************************************/ 308 BOOLEAN BTM_IsDeviceUp (void) 309 { 310 return ((BOOLEAN) (btm_cb.devcb.state == BTM_DEV_STATE_READY)); 311 } 312 313 /******************************************************************************* 314 ** 315 ** Function BTM_SetAfhChannels 316 ** 317 ** Description This function is called disable channels 318 ** 319 ** Returns tBTM_STATUS 320 ** 321 *******************************************************************************/ 322 tBTM_STATUS BTM_SetAfhChannels (UINT8 first, UINT8 last) 323 { 324 BTM_TRACE_API4 ("BTM_SetAfhChannels first: %d (%d) last: %d (%d)", 325 first, btm_cb.first_disabled_channel, last, 326 btm_cb.last_disabled_channel); 327 328 /* Make sure the local device supports the feature before sending */ 329 if ((!HCI_LMP_AFH_CAP_MASTR_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0])) && 330 (!HCI_LMP_AFH_CLASS_SLAVE_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0])) && 331 (!HCI_LMP_AFH_CLASS_MASTR_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))) 332 return (BTM_MODE_UNSUPPORTED); 333 334 if (!BTM_IsDeviceUp()) 335 return (BTM_WRONG_MODE); 336 337 if ((btm_cb.first_disabled_channel != first) 338 || (btm_cb.last_disabled_channel != last)) 339 { 340 if (btsnd_hcic_set_afh_channels (first, last)) 341 { 342 btm_cb.first_disabled_channel = first; 343 btm_cb.last_disabled_channel = last; 344 } 345 else 346 return (BTM_NO_RESOURCES); 347 } 348 return (BTM_SUCCESS); 349 } 350 351 /******************************************************************************* 352 ** 353 ** Function BTM_SetAfhChannelAssessment 354 ** 355 ** Description This function is called to set the channel assessment mode on or off 356 ** 357 ** Returns none 358 ** 359 *******************************************************************************/ 360 tBTM_STATUS BTM_SetAfhChannelAssessment (BOOLEAN enable_or_disable) 361 { 362 /* whatever app wants if device is not 1.2 scan type should be STANDARD */ 363 if (!HCI_LMP_AFH_CAP_SLAVE_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0])) 364 return (BTM_MODE_UNSUPPORTED); 365 366 if (!btsnd_hcic_write_afh_channel_assessment_mode (enable_or_disable)) 367 return (BTM_NO_RESOURCES); 368 369 return (BTM_SUCCESS); 370 } 371 372 /******************************************************************************* 373 ** 374 ** Function BTM_ContinueReset 375 ** 376 ** Description This function is called by the application to continue 377 ** initialization after the application has completed its 378 ** vendor specific sequence. It is only used when 379 ** BTM_APP_DEV_INIT is defined in target.h. 380 ** 381 ** Returns void 382 ** 383 *******************************************************************************/ 384 void BTM_ContinueReset (void) 385 { 386 #ifdef BTM_APP_DEV_INIT 387 btm_continue_reset(); 388 #endif 389 } 390 391 /******************************************************************************* 392 ** 393 ** Function btm_dev_reset 394 ** 395 ** Description Local function called to send a reset command 396 ** 397 ** Returns void 398 ** 399 *******************************************************************************/ 400 static void btm_dev_reset (void) 401 { 402 btm_cb.devcb.state = BTM_DEV_STATE_WAIT_RESET_CMPLT; 403 404 /* flush out the command complete queue and command transmit queue */ 405 btu_hcif_flush_cmd_queue(); 406 407 /* Start reset timer. When timer expires we will send first command */ 408 /* from the setup sequence */ 409 410 btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, 411 BTM_DEV_RESET_TIMEOUT); 412 btsnd_hcic_reset (LOCAL_BR_EDR_CONTROLLER_ID); 413 } 414 415 416 /******************************************************************************* 417 ** 418 ** Function btm_get_hci_buf_size 419 ** 420 ** Description Local function called to send a read buffer size command 421 ** 422 ** Returns void 423 ** 424 *******************************************************************************/ 425 void btm_get_hci_buf_size (void) 426 { 427 428 btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT); 429 430 /* Send a Read Buffer Size message to the Host Controller. */ 431 btsnd_hcic_read_buffer_size (); 432 433 } 434 #if BLE_INCLUDED == TRUE 435 /******************************************************************************* 436 ** 437 ** Function btm_read_ble_wl_size 438 ** 439 ** Description Local function called to send a read BLE buffer size command 440 ** 441 ** Returns void 442 ** 443 *******************************************************************************/ 444 void btm_read_ble_wl_size(void) 445 { 446 BTM_TRACE_DEBUG0("btm_read_ble_wl_size "); 447 btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT); 448 449 /* Send a Read Buffer Size message to the Host Controller. */ 450 btsnd_hcic_ble_read_white_list_size(); 451 } 452 /******************************************************************************* 453 ** 454 ** Function btm_get_ble_buffer_size 455 ** 456 ** Description Local function called to send a read BLE buffer size command 457 ** 458 ** Returns void 459 ** 460 *******************************************************************************/ 461 void btm_get_ble_buffer_size(void) 462 { 463 BTM_TRACE_DEBUG0("btm_get_ble_buffer_size "); 464 btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT); 465 466 /* Send a Read Buffer Size message to the Host Controller. */ 467 btsnd_hcic_ble_read_buffer_size (); 468 } 469 470 /******************************************************************************* 471 ** 472 ** Function btm_read_ble_local_supported_features 473 ** 474 ** Description Local function called to send a read BLE local supported 475 ** features command 476 ** 477 ** Returns void 478 ** 479 *******************************************************************************/ 480 static void btm_read_ble_local_supported_features(void) 481 { 482 BTM_TRACE_DEBUG0("btm_read_ble_local_supported_features "); 483 btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT); 484 485 /* Send a Read Local Supported Features message to the Host Controller. */ 486 btsnd_hcic_ble_read_local_spt_feat (); 487 } 488 #endif 489 /******************************************************************************* 490 ** 491 ** Function btm_get_local_version 492 ** 493 ** Description Local function called to send a read local version to controller 494 ** 495 ** Returns void 496 ** 497 *******************************************************************************/ 498 void btm_get_local_version (void) 499 { 500 501 btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT); 502 503 /* Send a Read Local Version message to the Host Controller. */ 504 btsnd_hcic_read_local_ver (LOCAL_BR_EDR_CONTROLLER_ID); 505 btsnd_hcic_read_bd_addr (); 506 507 #if BTM_PWR_MGR_INCLUDED == TRUE 508 btm_pm_reset(); 509 #endif 510 511 } 512 513 /******************************************************************************* 514 ** 515 ** Function btm_read_local_supported_cmds 516 ** 517 ** Description Local function called to send a read local supported commands 518 ** 519 ** Returns void 520 ** 521 *******************************************************************************/ 522 static void btm_read_local_supported_cmds (UINT8 local_controller_id) 523 { 524 BTM_TRACE_DEBUG0("Start reading local supported commands"); 525 526 btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT); 527 528 btsnd_hcic_read_local_supported_cmds(local_controller_id); 529 } 530 531 /******************************************************************************* 532 ** 533 ** Function btm_get_local_features 534 ** 535 ** Description Local function called to send a read local features 536 ** 537 ** Returns void 538 ** 539 *******************************************************************************/ 540 static void btm_get_local_features (void) 541 { 542 /* If this BT controller supports Read Extended Feature */ 543 if (btm_cb.devcb.local_version.hci_version >= HCI_PROTO_VERSION_2_0) 544 { 545 btm_get_local_ext_features(HCI_EXT_FEATURES_PAGE_0); 546 } 547 /* else, if this is a very old BT controller */ 548 else 549 { 550 btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT); 551 552 /* Just read the basic features (legacy HCI command) */ 553 btsnd_hcic_read_local_features (); 554 } 555 } 556 557 /******************************************************************************* 558 ** 559 ** Function btm_get_local_ext_features 560 ** 561 ** Description Local function called to send a read local extended features 562 ** 563 ** Returns void 564 ** 565 *******************************************************************************/ 566 static void btm_get_local_ext_features (UINT8 page_number) 567 { 568 btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT); 569 570 btsnd_hcic_read_local_ext_features(page_number); 571 } 572 573 /******************************************************************************* 574 ** 575 ** Function btm_dev_timeout 576 ** 577 ** Description This function is called when a timer list entry expires. 578 ** 579 ** Returns void 580 ** 581 *******************************************************************************/ 582 void btm_dev_timeout (TIMER_LIST_ENT *p_tle) 583 { 584 TIMER_PARAM_TYPE timer_type = (TIMER_PARAM_TYPE)p_tle->param; 585 586 if ((timer_type & TT_DEV_RESET_MASK) == TT_DEV_RESET) 587 { 588 /* Call device reset as long as there is timeout*/ 589 btm_dev_reset(); 590 } 591 else if (timer_type == (TIMER_PARAM_TYPE)TT_DEV_RLN) 592 { 593 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_rln_cmpl_cb; 594 595 btm_cb.devcb.p_rln_cmpl_cb = NULL; 596 597 if (p_cb) 598 (*p_cb)((void *) NULL); 599 } 600 } 601 602 /******************************************************************************* 603 ** 604 ** Function btm_reset_complete 605 ** 606 ** Description This function is called when command complete for HCI_Reset 607 ** is received. It does not make sense to send next command 608 ** because device is resetting after command complete is 609 ** received. Just start timer and set required state. 610 ** 611 ** Returns void 612 ** 613 *******************************************************************************/ 614 void btm_reset_complete (void) 615 { 616 int devinx; 617 618 BTM_TRACE_EVENT0 ("btm_reset_complete"); 619 620 /* Handle if btm initiated the reset */ 621 if (btm_cb.devcb.state == BTM_DEV_STATE_WAIT_RESET_CMPLT) 622 { 623 /* Tell L2CAP that all connections are gone */ 624 l2cu_device_reset (); 625 626 /* Clear current security state */ 627 for (devinx = 0; devinx < BTM_SEC_MAX_DEVICE_RECORDS; devinx++) 628 { 629 btm_cb.sec_dev_rec[devinx].sec_state = BTM_SEC_STATE_IDLE; 630 } 631 632 /* After the reset controller should restore all parameters to defaults. */ 633 btm_cb.btm_inq_vars.inq_counter = 1; 634 btm_cb.btm_inq_vars.inq_scan_window = HCI_DEF_INQUIRYSCAN_WINDOW; 635 btm_cb.btm_inq_vars.inq_scan_period = HCI_DEF_INQUIRYSCAN_INTERVAL; 636 btm_cb.btm_inq_vars.inq_scan_type = HCI_DEF_SCAN_TYPE; 637 638 btm_cb.btm_inq_vars.page_scan_window = HCI_DEF_PAGESCAN_WINDOW; 639 btm_cb.btm_inq_vars.page_scan_period = HCI_DEF_PAGESCAN_INTERVAL; 640 btm_cb.btm_inq_vars.page_scan_type = HCI_DEF_SCAN_TYPE; 641 642 #if (BTM_AFTER_RESET_TIMEOUT > 0) 643 btu_start_timer (&btm_cb.devcb.reset_timer, BTU_TTYPE_BTM_DEV_CTL, 644 BTM_AFTER_RESET_TIMEOUT); 645 #else 646 btm_cb.devcb.state = BTM_DEV_STATE_WAIT_AFTER_RESET; 647 btm_after_reset_hold_complete(); 648 #endif 649 650 #if (BLE_INCLUDED == TRUE) 651 btm_cb.ble_ctr_cb.conn_state = BLE_CONN_IDLE; 652 btm_cb.ble_ctr_cb.bg_dev_num = 0; 653 btm_cb.ble_ctr_cb.bg_conn_type = BTM_BLE_CONN_NONE; 654 btm_cb.ble_ctr_cb.p_select_cback = NULL; 655 memset(&btm_cb.ble_ctr_cb.bg_dev_list, 0, (sizeof(tBTM_LE_BG_CONN_DEV)*BTM_BLE_MAX_BG_CONN_DEV_NUM)); 656 gatt_reset_bgdev_list(); 657 #endif 658 } 659 } 660 661 /******************************************************************************* 662 ** 663 ** Function btm_continue_reset 664 ** 665 ** Description This function is called when wait period expired after 666 ** device reset or called by the application to continue 667 ** initialization after the application has completed its 668 ** vendor specific sequence. 669 ** 670 ** Returns void 671 ** 672 *******************************************************************************/ 673 void btm_continue_reset (void) 674 { 675 676 /* Reinitialize the default class of device */ 677 #if BTM_INTERNAL_BB == TRUE 678 btsnd_hcic_read_bd_addr (); 679 #if BTM_PWR_MGR_INCLUDED == TRUE 680 btm_pm_reset(); 681 #endif 682 #endif 683 684 btm_get_hci_buf_size (); 685 686 /* default device class */ 687 BTM_SetDeviceClass((UINT8 *) BTM_INIT_CLASS_OF_DEVICE); 688 689 #if (BTM_MAX_LOC_BD_NAME_LEN > 0) && (BTM_SET_DEV_NAME_UPON_RESET == TRUE) 690 BTM_SetLocalDeviceName(btm_cb.cfg.bd_name); 691 #elif BTM_USE_DEF_LOCAL_NAME == TRUE 692 BTM_SetLocalDeviceName(BTM_DEF_LOCAL_NAME); 693 #endif 694 695 BTM_SetPinType (btm_cb.cfg.pin_type, btm_cb.cfg.pin_code, btm_cb.cfg.pin_code_len); 696 } 697 698 /******************************************************************************* 699 ** 700 ** Function btm_after_reset_hold_complete 701 ** 702 ** Description This function is called when wait period expired after 703 ** device reset. Continue intitialization 704 ** 705 ** Returns void 706 ** 707 *******************************************************************************/ 708 void btm_after_reset_hold_complete (void) 709 { 710 #ifdef BTM_APP_DEV_INIT 711 btu_stop_timer(&btm_cb.devcb.reset_timer); 712 BTM_APP_DEV_INIT(); 713 #else 714 btm_continue_reset(); 715 #endif 716 } 717 718 719 /******************************************************************************* 720 ** 721 ** Function btm_read_hci_buf_size_complete 722 ** 723 ** Description This function is called when command complete for 724 ** get HCI buffer size is received. Start timer and send 725 ** read local features request 726 ** 727 ** Returns void 728 ** 729 *******************************************************************************/ 730 void btm_read_hci_buf_size_complete (UINT8 *p, UINT16 evt_len) 731 { 732 UINT8 status; 733 UINT8 lm_sco_buf_size; 734 UINT16 lm_num_acl_bufs; 735 UINT16 lm_num_sco_bufs; 736 UINT16 acl_buf_size; 737 738 STREAM_TO_UINT8 (status, p); 739 if (status == HCI_SUCCESS) 740 { 741 STREAM_TO_UINT16 (btu_cb.hcit_acl_data_size, p); 742 STREAM_TO_UINT8 (lm_sco_buf_size, p); 743 STREAM_TO_UINT16 (lm_num_acl_bufs, p); 744 STREAM_TO_UINT16 (lm_num_sco_bufs, p); 745 746 btu_cb.hcit_acl_pkt_size = btu_cb.hcit_acl_data_size + HCI_DATA_PREAMBLE_SIZE; 747 748 l2c_link_processs_num_bufs (lm_num_acl_bufs); 749 750 #if BTM_ACL_BUF_SIZE > 0 751 acl_buf_size = (BTM_ACL_BUF_SIZE < L2CAP_MTU_SIZE) ? BTM_ACL_BUF_SIZE : L2CAP_MTU_SIZE; 752 #else 753 acl_buf_size = L2CAP_MTU_SIZE; 754 #endif 755 /* Tell the controller what our buffer sizes are. ?? Need SCO info */ 756 btsnd_hcic_set_host_buf_size (acl_buf_size, BTM_SCO_HOST_BUF_SIZE, L2CAP_HOST_FC_ACL_BUFS, 10); 757 758 #if L2CAP_HOST_FLOW_CTRL == TRUE 759 btsnd_hcic_set_host_flow_ctrl (HCI_HOST_FLOW_CTRL_ACL_ON); 760 #endif 761 } 762 763 /* Set the device into connectable and/or discoverable mode (if configured to do so) */ 764 #if BTM_IS_CONNECTABLE == TRUE 765 (void) BTM_SetConnectability (BTM_CONNECTABLE, BTM_DEFAULT_CONN_WINDOW, BTM_DEFAULT_CONN_INTERVAL); 766 #endif 767 768 #if BTM_IS_DISCOVERABLE == TRUE 769 (void) BTM_SetDiscoverability (BTM_DEFAULT_DISC_MODE, BTM_DEFAULT_DISC_WINDOW, BTM_DEFAULT_DISC_INTERVAL); 770 #endif 771 772 #if BTM_INTERNAL_BB == TRUE 773 { 774 UINT8 buf[9] = BTM_INTERNAL_LOCAL_VER; 775 btm_read_local_version_complete( buf, 9 ); 776 } 777 #else 778 btm_get_local_version (); 779 #endif 780 } 781 782 #if (BLE_INCLUDED == TRUE) 783 /******************************************************************************* 784 ** 785 ** Function btm_read_ble_buf_size_complete 786 ** 787 ** Description This function is called when command complete for 788 ** get HCI buffer size is received. Start timer and send 789 ** read local supported features request 790 ** 791 ** Returns void 792 ** 793 *******************************************************************************/ 794 void btm_read_ble_buf_size_complete (UINT8 *p, UINT16 evt_len) 795 { 796 UINT8 status; 797 UINT16 lm_num_le_bufs; 798 799 BTM_TRACE_DEBUG0("btm_read_ble_buf_size_complete "); 800 STREAM_TO_UINT8 (status, p); 801 if (status == HCI_SUCCESS) 802 { 803 STREAM_TO_UINT16 (btu_cb.hcit_ble_acl_data_size, p); 804 STREAM_TO_UINT8 (lm_num_le_bufs, p); 805 806 if (btu_cb.hcit_ble_acl_data_size == 0) 807 btu_cb.hcit_ble_acl_data_size = btu_cb.hcit_acl_data_size; 808 809 btu_cb.hcit_ble_acl_pkt_size = btu_cb.hcit_ble_acl_data_size + HCI_DATA_PREAMBLE_SIZE; 810 811 l2c_link_processs_ble_num_bufs (lm_num_le_bufs); 812 } 813 814 btm_read_ble_local_supported_features(); 815 } 816 817 /******************************************************************************* 818 ** 819 ** Function btm_read_ble_local_supported_features_complete 820 ** 821 ** Description This function is called when command complete for 822 ** Read LE Local Supported Features is received. Start timer and send 823 ** read LMP local features request 824 ** 825 ** Returns void 826 ** 827 *******************************************************************************/ 828 void btm_read_ble_local_supported_features_complete (UINT8 *p, UINT16 evt_len) 829 { 830 UINT8 status; 831 832 BTM_TRACE_DEBUG0("btm_read_ble_local_supported_features_complete "); 833 834 btu_stop_timer (&btm_cb.devcb.reset_timer); 835 836 STREAM_TO_UINT8 (status, p); 837 if (status == HCI_SUCCESS) 838 { 839 STREAM_TO_ARRAY(&btm_cb.devcb.local_le_features, p, HCI_FEATURE_BYTES_PER_PAGE); 840 } 841 else 842 { 843 BTM_TRACE_WARNING1 ("btm_read_ble_local_supported_features_complete status = %d", status); 844 } 845 846 #if BTM_INTERNAL_BB == TRUE 847 { 848 UINT8 buf[9] = BTM_INTERNAL_LOCAL_FEA; 849 btm_read_local_features_complete( buf, 9 ); 850 } 851 #else 852 853 /* get local feature if BRCM specific feature is not included */ 854 btm_reset_ctrlr_complete(); 855 #endif 856 857 } 858 859 /******************************************************************************* 860 ** 861 ** Function btm_read_white_list_size_complete 862 ** 863 ** Description This function read the current white list size. 864 *******************************************************************************/ 865 void btm_read_white_list_size_complete(UINT8 *p, UINT16 evt_len) 866 { 867 UINT8 status; 868 869 BTM_TRACE_DEBUG0("btm_read_white_list_size_complete "); 870 STREAM_TO_UINT8 (status, p); 871 872 if (status == HCI_SUCCESS) 873 { 874 STREAM_TO_UINT8(btm_cb.ble_ctr_cb.max_filter_entries, p); 875 btm_cb.ble_ctr_cb.num_empty_filter = btm_cb.ble_ctr_cb.max_filter_entries; 876 } 877 878 btm_get_ble_buffer_size(); 879 } 880 881 #endif 882 /******************************************************************************* 883 ** 884 ** Function btm_read_local_version_complete 885 ** 886 ** Description This function is called when local BD Addr read complete 887 ** message is received from the HCI. 888 ** 889 ** Returns void 890 ** 891 *******************************************************************************/ 892 void btm_read_local_version_complete (UINT8 *p, UINT16 evt_len) 893 { 894 tBTM_VERSION_INFO *p_vi = &btm_cb.devcb.local_version; 895 UINT8 status; 896 897 #ifdef BTA_PRM_CHECK_FW_VER 898 if(BTA_PRM_CHECK_FW_VER(p)) 899 return; 900 #endif 901 902 STREAM_TO_UINT8 (status, p); 903 if (status == HCI_SUCCESS) 904 { 905 906 STREAM_TO_UINT8 (p_vi->hci_version, p); 907 STREAM_TO_UINT16 (p_vi->hci_revision, p); 908 STREAM_TO_UINT8 (p_vi->lmp_version, p); 909 STREAM_TO_UINT16 (p_vi->manufacturer, p); 910 STREAM_TO_UINT16 (p_vi->lmp_subversion, p); 911 } 912 913 if (p_vi->hci_version >= HCI_PROTO_VERSION_1_2) 914 { 915 btm_read_local_supported_cmds(LOCAL_BR_EDR_CONTROLLER_ID); 916 } 917 else 918 { 919 btm_get_local_features (); 920 } 921 } 922 923 /******************************************************************************* 924 ** 925 ** Function btm_decode_ext_features_page 926 ** 927 ** Description This function is decodes a features page. 928 ** 929 ** Returns void 930 ** 931 *******************************************************************************/ 932 static void btm_decode_ext_features_page (UINT8 page_number, const UINT8 *p_features) 933 { 934 UINT8 last; 935 UINT8 first; 936 937 BTM_TRACE_DEBUG1 ("btm_decode_ext_features_page page: %d", page_number); 938 switch (page_number) 939 { 940 /* Extended (Legacy) Page 0 */ 941 case HCI_EXT_FEATURES_PAGE_0: 942 943 /* Create ACL supported packet types mask */ 944 btm_cb.btm_acl_pkt_types_supported = (BTM_ACL_PKT_TYPES_MASK_DH1 + 945 BTM_ACL_PKT_TYPES_MASK_DM1); 946 947 if (HCI_3_SLOT_PACKETS_SUPPORTED(p_features)) 948 btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_DH3 + 949 BTM_ACL_PKT_TYPES_MASK_DM3); 950 951 if (HCI_5_SLOT_PACKETS_SUPPORTED(p_features)) 952 btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_DH5 + 953 BTM_ACL_PKT_TYPES_MASK_DM5); 954 955 /* _NO_X_DXX masks are reserved before ver 2.0. 956 Set them only for later versions of controller */ 957 if (btm_cb.devcb.local_version.hci_version >= HCI_PROTO_VERSION_2_0) 958 { 959 /* Add in EDR related ACL types */ 960 if (!HCI_EDR_ACL_2MPS_SUPPORTED(p_features)) 961 { 962 btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH1 + 963 BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 + 964 BTM_ACL_PKT_TYPES_MASK_NO_2_DH5); 965 } 966 967 if (!HCI_EDR_ACL_3MPS_SUPPORTED(p_features)) 968 { 969 btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_3_DH1 + 970 BTM_ACL_PKT_TYPES_MASK_NO_3_DH3 + 971 BTM_ACL_PKT_TYPES_MASK_NO_3_DH5); 972 } 973 974 /* Check to see if 3 and 5 slot packets are available */ 975 if (HCI_EDR_ACL_2MPS_SUPPORTED(p_features) || 976 HCI_EDR_ACL_3MPS_SUPPORTED(p_features)) 977 { 978 if (!HCI_3_SLOT_EDR_ACL_SUPPORTED(p_features)) 979 btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 + 980 BTM_ACL_PKT_TYPES_MASK_NO_3_DH3); 981 982 if (!HCI_5_SLOT_EDR_ACL_SUPPORTED(p_features)) 983 btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH5 + 984 BTM_ACL_PKT_TYPES_MASK_NO_3_DH5); 985 } 986 } 987 988 BTM_TRACE_DEBUG1("Local supported ACL packet types: 0x%04x", 989 btm_cb.btm_acl_pkt_types_supported); 990 991 /* Create (e)SCO supported packet types mask */ 992 btm_cb.btm_sco_pkt_types_supported = 0; 993 #if BTM_SCO_INCLUDED == TRUE 994 btm_cb.sco_cb.esco_supported = FALSE; 995 #endif 996 if (HCI_SCO_LINK_SUPPORTED(p_features)) 997 { 998 btm_cb.btm_sco_pkt_types_supported = BTM_SCO_PKT_TYPES_MASK_HV1; 999 1000 if (HCI_HV2_PACKETS_SUPPORTED(p_features)) 1001 btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_HV2; 1002 1003 if (HCI_HV3_PACKETS_SUPPORTED(p_features)) 1004 btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_HV3; 1005 } 1006 1007 if (HCI_ESCO_EV3_SUPPORTED(p_features)) 1008 btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_EV3; 1009 1010 if (HCI_ESCO_EV4_SUPPORTED(p_features)) 1011 btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_EV4; 1012 1013 if (HCI_ESCO_EV5_SUPPORTED(p_features)) 1014 btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_EV5; 1015 #if BTM_SCO_INCLUDED == TRUE 1016 if (btm_cb.btm_sco_pkt_types_supported & BTM_ESCO_LINK_ONLY_MASK) 1017 { 1018 btm_cb.sco_cb.esco_supported = TRUE; 1019 1020 /* Add in EDR related eSCO types */ 1021 if (HCI_EDR_ESCO_2MPS_SUPPORTED(p_features)) 1022 { 1023 if (!HCI_3_SLOT_EDR_ESCO_SUPPORTED(p_features)) 1024 btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_NO_2_EV5; 1025 } 1026 else 1027 { 1028 btm_cb.btm_sco_pkt_types_supported |= (BTM_SCO_PKT_TYPES_MASK_NO_2_EV3 + 1029 BTM_SCO_PKT_TYPES_MASK_NO_2_EV5); 1030 } 1031 1032 if (HCI_EDR_ESCO_3MPS_SUPPORTED(p_features)) 1033 { 1034 if (!HCI_3_SLOT_EDR_ESCO_SUPPORTED(p_features)) 1035 btm_cb.btm_sco_pkt_types_supported |= BTM_SCO_PKT_TYPES_MASK_NO_3_EV5; 1036 } 1037 else 1038 { 1039 btm_cb.btm_sco_pkt_types_supported |= (BTM_SCO_PKT_TYPES_MASK_NO_3_EV3 + 1040 BTM_SCO_PKT_TYPES_MASK_NO_3_EV5); 1041 } 1042 } 1043 #endif 1044 1045 BTM_TRACE_DEBUG1("Local supported SCO packet types: 0x%04x", 1046 btm_cb.btm_sco_pkt_types_supported); 1047 1048 /* Create Default Policy Settings */ 1049 if (HCI_SWITCH_SUPPORTED(p_features)) 1050 btm_cb.btm_def_link_policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH; 1051 else 1052 btm_cb.btm_def_link_policy &= ~HCI_ENABLE_MASTER_SLAVE_SWITCH; 1053 1054 if (HCI_HOLD_MODE_SUPPORTED(p_features)) 1055 btm_cb.btm_def_link_policy |= HCI_ENABLE_HOLD_MODE; 1056 else 1057 btm_cb.btm_def_link_policy &= ~HCI_ENABLE_HOLD_MODE; 1058 1059 if (HCI_SNIFF_MODE_SUPPORTED(p_features)) 1060 btm_cb.btm_def_link_policy |= HCI_ENABLE_SNIFF_MODE; 1061 else 1062 btm_cb.btm_def_link_policy &= ~HCI_ENABLE_SNIFF_MODE; 1063 1064 if (HCI_PARK_MODE_SUPPORTED(p_features)) 1065 btm_cb.btm_def_link_policy |= HCI_ENABLE_PARK_MODE; 1066 else 1067 btm_cb.btm_def_link_policy &= ~HCI_ENABLE_PARK_MODE; 1068 1069 btm_sec_dev_reset (); 1070 #if ((BTM_EIR_SERVER_INCLUDED == TRUE)||(BTM_EIR_CLIENT_INCLUDED == TRUE)) 1071 if (HCI_LMP_INQ_RSSI_SUPPORTED(p_features)) 1072 { 1073 if (HCI_EXT_INQ_RSP_SUPPORTED(p_features)) 1074 BTM_SetInquiryMode (BTM_INQ_RESULT_EXTENDED); 1075 else 1076 BTM_SetInquiryMode (BTM_INQ_RESULT_WITH_RSSI); 1077 } 1078 #else 1079 if (HCI_LMP_INQ_RSSI_SUPPORTED(p_features)) 1080 BTM_SetInquiryMode (BTM_INQ_RESULT_WITH_RSSI); 1081 #endif 1082 #if L2CAP_NON_FLUSHABLE_PB_INCLUDED == TRUE 1083 if( HCI_NON_FLUSHABLE_PB_SUPPORTED(p_features)) 1084 l2cu_set_non_flushable_pbf(TRUE); 1085 else 1086 l2cu_set_non_flushable_pbf(FALSE); 1087 #endif 1088 BTM_SetPageScanType (BTM_DEFAULT_SCAN_TYPE); 1089 BTM_SetInquiryScanType (BTM_DEFAULT_SCAN_TYPE); 1090 1091 break; 1092 1093 /* Extended Page 1 */ 1094 case HCI_EXT_FEATURES_PAGE_1: 1095 /* Nothing to do for page 1 */ 1096 break; 1097 1098 /* Extended Page 2 */ 1099 case HCI_EXT_FEATURES_PAGE_2: 1100 /* Nothing to do for page 2 */ 1101 break; 1102 1103 default: 1104 BTM_TRACE_ERROR1("btm_decode_ext_features_page page=%d unknown", page_number); 1105 break; 1106 } 1107 } 1108 1109 /******************************************************************************* 1110 ** 1111 ** Function btm_reset_ctrlr_complete 1112 ** 1113 ** Description This is the last step of BR/EDR controller startup sequence. 1114 ** 1115 ** Returns void 1116 ** 1117 *******************************************************************************/ 1118 void btm_reset_ctrlr_complete () 1119 { 1120 tBTM_DEVCB *p_devcb = &btm_cb.devcb; 1121 tBTM_CMPL_CB *p_cb = p_devcb->p_reset_cmpl_cb; 1122 BOOLEAN found = FALSE; 1123 UINT8 i, j, max_page_number; 1124 1125 btu_stop_timer (&btm_cb.devcb.reset_timer); 1126 1127 /* find the highest feature page number which contains non-zero bits */ 1128 for (i = HCI_EXT_FEATURES_PAGE_MAX; i >= 0; i--) 1129 { 1130 for (j = 0; j < HCI_FEATURE_BYTES_PER_PAGE; j++) 1131 { 1132 if (p_devcb->local_lmp_features[i][j] != 0) 1133 { 1134 found = TRUE; 1135 break; 1136 } 1137 } 1138 if (found || !i) 1139 { 1140 break; 1141 } 1142 } 1143 1144 if (!found) 1145 BTM_TRACE_WARNING0 ("btm_reset_ctrlr_complete: NONE of local controller features is set"); 1146 1147 max_page_number = i; 1148 1149 BTM_TRACE_DEBUG1 ("btm_reset_ctrlr_complete: max_page_number: %d", max_page_number); 1150 1151 /* 1152 * Set State to Ready (needs to be done before btm_decode_ext_features_page 1153 * to allow it to send some HCI configuration commands) 1154 */ 1155 p_devcb->state = BTM_DEV_STATE_READY; 1156 1157 /* For every received/saved feature page */ 1158 for (i = 0; i <= max_page_number; i++) 1159 { 1160 /* Decode the saved Feature Page */ 1161 btm_decode_ext_features_page(i, p_devcb->local_lmp_features[i]); 1162 } 1163 1164 /* If there was a callback address for reset complete, reset it */ 1165 p_devcb->p_reset_cmpl_cb = NULL; 1166 1167 /* If anyone wants device status notifications, give him one */ 1168 btm_report_device_status(BTM_DEV_STATUS_UP); 1169 1170 /* Reset sequence is complete. If this was an application originated */ 1171 /* reset, tell him its done. */ 1172 if (p_cb) 1173 (*p_cb)((void *) NULL); 1174 } 1175 1176 /******************************************************************************* 1177 ** 1178 ** Function btm_issue_host_support_for_lmp_features 1179 ** 1180 ** Description This function: 1181 ** - issues commands to set host supported LMP features (one at 1182 ** a time); 1183 ** - after this is done it issues command to re-read LMP features 1184 ** page 1; 1185 ** - after this is done it calls the last step of BR/EDR 1186 ** controller startup sequence. 1187 ** 1188 ** Returns void 1189 ** 1190 *******************************************************************************/ 1191 static void btm_issue_host_support_for_lmp_features (void) 1192 { 1193 BTM_TRACE_DEBUG1("btm_issue_host_support_for_lmp_features lmp_features_host_may_support: 0x%02x", btm_cb.devcb.lmp_features_host_may_support); 1194 1195 if (btm_cb.devcb.lmp_features_host_may_support & BTM_HOST_MAY_SUPP_SSP) 1196 { 1197 btsnd_hcic_write_simple_pairing_mode(HCI_SP_MODE_ENABLED); 1198 return; 1199 } 1200 1201 #if (BLE_INCLUDED == TRUE) 1202 if (btm_cb.devcb.lmp_features_host_may_support & BTM_HOST_MAY_SUPP_LE) 1203 { 1204 if (btm_cb.devcb.lmp_features_host_may_support & BTM_HOST_MAY_SUPP_SIMULT_BR_LE) 1205 { 1206 /* At the moment the host can't work simultaneously with BR/EDR and LE */ 1207 btsnd_hcic_ble_write_host_supported(BTM_BLE_HOST_SUPPORT, 0); 1208 } 1209 else 1210 { 1211 btsnd_hcic_ble_write_host_supported(BTM_BLE_HOST_SUPPORT, 0); 1212 } 1213 return; 1214 } 1215 #endif 1216 1217 if (btm_cb.devcb.lmp_features_host_may_support & BTM_RE_READ_1ST_PAGE) 1218 { 1219 btm_get_local_ext_features(HCI_EXT_FEATURES_PAGE_1); 1220 return; 1221 } 1222 1223 if (!btm_cb.devcb.lmp_features_host_may_support) 1224 { 1225 #if BLE_INCLUDED == TRUE 1226 if (HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1])) 1227 { 1228 btm_read_ble_wl_size(); 1229 } 1230 else 1231 #elif BTM_INTERNAL_BB == TRUE 1232 { 1233 UINT8 buf[9] = BTM_INTERNAL_LOCAL_FEA; 1234 btm_read_local_features_complete( buf, 9 ); 1235 } 1236 #endif 1237 { 1238 btm_reset_ctrlr_complete(); 1239 } 1240 return; 1241 } 1242 1243 BTM_TRACE_ERROR2("%s lmp_features_host_may_support: 0x%02x. This is unexpected.",__FUNCTION__, 1244 btm_cb.devcb.lmp_features_host_may_support); 1245 } 1246 1247 /******************************************************************************* 1248 ** 1249 ** Function btm_set_lmp_features_host_may_support 1250 ** 1251 ** Description This function is called after all LMP features provided by 1252 ** controller are read. It sets the mask that indicates LMP 1253 ** features the host may support based on LMP features supported 1254 ** by controller. 1255 ** Example: 1256 ** Host may set SSP (host support) bit only if SSP (controller 1257 ** support) bit is set by controller. 1258 ** 1259 ** Returns void 1260 ** 1261 *******************************************************************************/ 1262 static void btm_set_lmp_features_host_may_support (UINT8 max_page_number) 1263 { 1264 btm_cb.devcb.lmp_features_host_may_support = 0; 1265 1266 /* LMP page 0 is always read */ 1267 if (HCI_SIMPLE_PAIRING_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0])) 1268 { 1269 /* host may support SSP */ 1270 btm_cb.devcb.lmp_features_host_may_support |= BTM_HOST_MAY_SUPP_SSP; 1271 } 1272 1273 #if (BLE_INCLUDED == TRUE) 1274 if (HCI_LE_SPT_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0])) 1275 { 1276 /* host may support LE */ 1277 btm_cb.devcb.lmp_features_host_may_support |= BTM_HOST_MAY_SUPP_LE; 1278 1279 if (HCI_SIMUL_LE_BREDR_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0])) 1280 { 1281 /* host may support BR/EDR and LE simultaneously */ 1282 btm_cb.devcb.lmp_features_host_may_support |= BTM_HOST_MAY_SUPP_SIMULT_BR_LE; 1283 } 1284 } 1285 #endif 1286 1287 if (max_page_number >= HCI_EXT_FEATURES_PAGE_1) 1288 { 1289 /* nothing yet for HCI_EXT_FEATURES_PAGE_1 */ 1290 } 1291 1292 if (max_page_number >= HCI_EXT_FEATURES_PAGE_1) 1293 { 1294 /* nothing yet for HCI_EXT_FEATURES_PAGE_2 */ 1295 } 1296 1297 if (btm_cb.devcb.lmp_features_host_may_support) 1298 btm_cb.devcb.lmp_features_host_may_support |= BTM_RE_READ_1ST_PAGE; 1299 } 1300 1301 /******************************************************************************* 1302 ** 1303 ** Function btm_read_all_lmp_features_complete 1304 ** 1305 ** Description This function is called after all LMP features provided by 1306 ** controller are read. 1307 ** It works with controller supported LMP features which host 1308 ** may support too. 1309 ** 1310 ** Returns void 1311 ** 1312 *******************************************************************************/ 1313 static void btm_read_all_lmp_features_complete (UINT8 max_page_number) 1314 { 1315 btm_set_lmp_features_host_may_support(max_page_number); 1316 1317 btm_issue_host_support_for_lmp_features(); 1318 } 1319 1320 /******************************************************************************* 1321 ** 1322 ** Function btm_read_local_features_complete 1323 ** 1324 ** Description This function is called when local supported features read 1325 ** is complete. 1326 ** 1327 ** Returns void 1328 ** 1329 *******************************************************************************/ 1330 void btm_read_local_features_complete (UINT8 *p, UINT16 evt_len) 1331 { 1332 tBTM_DEVCB *p_devcb = &btm_cb.devcb; 1333 UINT8 status; 1334 1335 btu_stop_timer (&p_devcb->reset_timer); 1336 1337 STREAM_TO_UINT8 (status, p); 1338 if (status == HCI_SUCCESS) 1339 { 1340 /* Save the Feature Page 0 */ 1341 STREAM_TO_ARRAY(p_devcb->local_lmp_features[0], 1342 p, HCI_FEATURE_BYTES_PER_PAGE); 1343 1344 if ((HCI_LMP_EXTENDED_SUPPORTED(p_devcb->local_lmp_features[HCI_EXT_FEATURES_PAGE_0])) && 1345 (HCI_READ_LOCAL_EXT_FEATURES_SUPPORTED(p_devcb->supported_cmds))) 1346 { 1347 /* if local controller has extended features and supports 1348 **HCI_Read_Local_Extended_Features command, 1349 ** then start reading these feature starting with extended features page 1 */ 1350 BTM_TRACE_DEBUG0 ("Start reading local extended features"); 1351 btm_get_local_ext_features(HCI_EXT_FEATURES_PAGE_1); 1352 } 1353 else 1354 { 1355 btm_read_all_lmp_features_complete (HCI_EXT_FEATURES_PAGE_0); 1356 } 1357 } 1358 } 1359 1360 /******************************************************************************* 1361 ** 1362 ** Function btm_read_local_ext_features_complete 1363 ** 1364 ** Description This function is called when read local extended features 1365 ** command complete message is received from the HCI. 1366 ** 1367 ** Returns void 1368 ** 1369 *******************************************************************************/ 1370 void btm_read_local_ext_features_complete (UINT8 *p, UINT16 evt_len) 1371 { 1372 tBTM_DEVCB *p_devcb = &btm_cb.devcb; 1373 tBTM_CMPL_CB *p_cb = p_devcb->p_reset_cmpl_cb; 1374 UINT8 status; 1375 UINT8 page_number; 1376 UINT8 page_number_max; 1377 1378 btu_stop_timer (&btm_cb.devcb.reset_timer); 1379 1380 STREAM_TO_UINT8 (status, p); 1381 1382 if (status != HCI_SUCCESS) 1383 { 1384 BTM_TRACE_WARNING1("btm_read_local_ext_features_complete status = 0x%02X", status); 1385 btm_read_all_lmp_features_complete (HCI_EXT_FEATURES_PAGE_0); 1386 return; 1387 } 1388 1389 /* Extract Page number */ 1390 STREAM_TO_UINT8 (page_number, p); 1391 1392 /* Extract Page number Max */ 1393 STREAM_TO_UINT8 (page_number_max, p); 1394 1395 if (page_number > HCI_EXT_FEATURES_PAGE_MAX) 1396 { 1397 BTM_TRACE_ERROR1("btm_read_local_ext_features_complete page=%d unknown", 1398 page_number); 1399 return; 1400 } 1401 1402 /* Save the extended features Page received */ 1403 STREAM_TO_ARRAY(btm_cb.devcb.local_lmp_features[page_number], 1404 p, HCI_FEATURE_BYTES_PER_PAGE); 1405 1406 /* If this is re-read of the 1-st extended page after host supported LMP features are set */ 1407 if ((page_number == HCI_EXT_FEATURES_PAGE_1) && 1408 (btm_cb.devcb.lmp_features_host_may_support == BTM_RE_READ_1ST_PAGE)) 1409 { 1410 btm_cb.devcb.lmp_features_host_may_support &= ~BTM_RE_READ_1ST_PAGE; 1411 btm_issue_host_support_for_lmp_features(); 1412 return; 1413 } 1414 1415 /* If this is the last page supported by the local BT controller OR */ 1416 /* if this is the last page supported by the Host */ 1417 if ((page_number == page_number_max) || 1418 (page_number == HCI_EXT_FEATURES_PAGE_MAX)) 1419 { 1420 BTM_TRACE_DEBUG1("BTM reached last extended features page (%d)", page_number); 1421 btm_read_all_lmp_features_complete(page_number); 1422 } 1423 /* Else (another page must be read) */ 1424 else 1425 { 1426 /* Read the next features page */ 1427 page_number++; 1428 BTM_TRACE_DEBUG1("BTM reads next extended features page (%d)", page_number); 1429 btm_get_local_ext_features(page_number); 1430 } 1431 } 1432 1433 /******************************************************************************* 1434 ** 1435 ** Function btm_read_local_supported_cmds_complete 1436 ** 1437 ** Description This function is called when local supported commands read 1438 ** is complete. 1439 ** 1440 ** Returns void 1441 ** 1442 *******************************************************************************/ 1443 void btm_read_local_supported_cmds_complete (UINT8 *p) 1444 { 1445 tBTM_DEVCB *p_devcb = &btm_cb.devcb; 1446 UINT8 status; 1447 1448 btu_stop_timer (&(p_devcb->reset_timer)); 1449 1450 STREAM_TO_UINT8 (status, p); 1451 BTM_TRACE_DEBUG1("btm_read_local_supported_cmds_complete status (0x%02x)", status); 1452 1453 if (status == HCI_SUCCESS) 1454 { 1455 /* Save the supported commands bit mask */ 1456 STREAM_TO_ARRAY(p_devcb->supported_cmds, p, HCI_NUM_SUPP_COMMANDS_BYTES); 1457 } 1458 1459 btm_get_local_features(); 1460 } 1461 1462 /******************************************************************************* 1463 ** 1464 ** Function btm_write_simple_paring_mode_complete 1465 ** 1466 ** Description This function is called when the command complete message 1467 ** is received from the HCI for the write simple pairing mode 1468 ** command. 1469 ** 1470 ** Returns void 1471 ** 1472 *******************************************************************************/ 1473 void btm_write_simple_paring_mode_complete (UINT8 *p) 1474 { 1475 UINT8 status; 1476 1477 STREAM_TO_UINT8 (status, p); 1478 1479 if (status != HCI_SUCCESS) 1480 { 1481 BTM_TRACE_WARNING1("btm_write_simple_paring_mode_complete status: 0x%02x", status); 1482 } 1483 1484 if (btm_cb.devcb.lmp_features_host_may_support & BTM_HOST_MAY_SUPP_SSP) 1485 { 1486 btm_cb.devcb.lmp_features_host_may_support &= ~BTM_HOST_MAY_SUPP_SSP; 1487 btm_issue_host_support_for_lmp_features(); 1488 } 1489 } 1490 1491 /******************************************************************************* 1492 ** 1493 ** Function btm_write_le_host_supported_complete 1494 ** 1495 ** Description This function is called when the command complete message 1496 ** is received from the HCI for the write LE host supported 1497 ** command. 1498 ** 1499 ** Returns void 1500 ** 1501 *******************************************************************************/ 1502 void btm_write_le_host_supported_complete (UINT8 *p) 1503 { 1504 UINT8 status; 1505 1506 STREAM_TO_UINT8 (status, p); 1507 1508 if (status != HCI_SUCCESS) 1509 { 1510 BTM_TRACE_WARNING1("btm_write_le_host_supported_complete status: 0x%02x", status); 1511 } 1512 1513 if (btm_cb.devcb.lmp_features_host_may_support & BTM_HOST_MAY_SUPP_LE) 1514 { 1515 btm_cb.devcb.lmp_features_host_may_support &= ~BTM_HOST_MAY_SUPP_LE; 1516 if (btm_cb.devcb.lmp_features_host_may_support & BTM_HOST_MAY_SUPP_SIMULT_BR_LE) 1517 { 1518 btm_cb.devcb.lmp_features_host_may_support &= ~BTM_HOST_MAY_SUPP_SIMULT_BR_LE; 1519 } 1520 btm_issue_host_support_for_lmp_features(); 1521 } 1522 } 1523 1524 /******************************************************************************* 1525 ** 1526 ** Function btm_get_voice_coding_support 1527 ** 1528 ** Description This function is provides a way to get the voice coding schemes 1529 ** supported the device. 1530 ** 1531 ** Returns A bit mask - Bit 0 if set indicates CVSD support 1532 ** Bit 1 if set indicates PCM A-law support 1533 ** Bit 2 if set indicates PCM Mu-law support 1534 ** 1535 *******************************************************************************/ 1536 1537 UINT8 btm_get_voice_coding_support( void ) 1538 { 1539 UINT8 code = 0; 1540 1541 if( HCI_LMP_CVSD_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]) ) code |= 0x01 ; 1542 if( HCI_LMP_A_LAW_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]) ) code |= 0x02 ; 1543 if( HCI_LMP_U_LAW_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]) ) code |= 0x04 ; 1544 1545 return code ; 1546 } 1547 1548 /******************************************************************************* 1549 ** 1550 ** Function BTM_SetLocalDeviceName 1551 ** 1552 ** Description This function is called to set the local device name. 1553 ** 1554 ** Returns status of the operation 1555 ** 1556 *******************************************************************************/ 1557 tBTM_STATUS BTM_SetLocalDeviceName (char *p_name) 1558 { 1559 UINT8 *p; 1560 1561 if (!p_name || !p_name[0] || (strlen ((char *)p_name) > BD_NAME_LEN)) 1562 return (BTM_ILLEGAL_VALUE); 1563 1564 if (btm_cb.devcb.state == BTM_DEV_STATE_WAIT_RESET_CMPLT || 1565 btm_cb.devcb.state == BTM_DEV_STATE_WAIT_AFTER_RESET) 1566 return (BTM_DEV_RESET); 1567 1568 #if BTM_MAX_LOC_BD_NAME_LEN > 0 1569 /* Save the device name if local storage is enabled */ 1570 p = (UINT8 *)btm_cb.cfg.bd_name; 1571 if (p != (UINT8 *)p_name) 1572 { 1573 BCM_STRNCPY_S(btm_cb.cfg.bd_name, sizeof(btm_cb.cfg.bd_name), p_name, BTM_MAX_LOC_BD_NAME_LEN); 1574 btm_cb.cfg.bd_name[BTM_MAX_LOC_BD_NAME_LEN] = '\0'; 1575 } 1576 #else 1577 p = (UINT8 *)p_name; 1578 #endif 1579 1580 if (btsnd_hcic_change_name(p)) 1581 return (BTM_CMD_STARTED); 1582 else 1583 return (BTM_NO_RESOURCES); 1584 } 1585 1586 1587 1588 /******************************************************************************* 1589 ** 1590 ** Function BTM_ReadLocalDeviceName 1591 ** 1592 ** Description This function is called to read the local device name. 1593 ** 1594 ** Returns status of the operation 1595 ** If success, BTM_SUCCESS is returned and p_name points stored 1596 ** local device name 1597 ** If BTM doesn't store local device name, BTM_NO_RESOURCES is 1598 ** is returned and p_name is set to NULL 1599 ** 1600 *******************************************************************************/ 1601 tBTM_STATUS BTM_ReadLocalDeviceName (char **p_name) 1602 { 1603 #if BTM_MAX_LOC_BD_NAME_LEN > 0 1604 *p_name = btm_cb.cfg.bd_name; 1605 return(BTM_SUCCESS); 1606 #else 1607 *p_name = NULL; 1608 return(BTM_NO_RESOURCES); 1609 #endif 1610 } 1611 1612 1613 /******************************************************************************* 1614 ** 1615 ** Function BTM_ReadLocalDeviceNameFromController 1616 ** 1617 ** Description Get local device name from controller. Do not use cached 1618 ** name (used to get chip-id prior to btm reset complete). 1619 ** 1620 ** Returns BTM_CMD_STARTED if successful, otherwise an error 1621 ** 1622 *******************************************************************************/ 1623 tBTM_STATUS BTM_ReadLocalDeviceNameFromController (tBTM_CMPL_CB *p_rln_cmpl_cback) 1624 { 1625 /* Check if rln already in progress */ 1626 if (btm_cb.devcb.p_rln_cmpl_cb) 1627 return(BTM_NO_RESOURCES); 1628 1629 /* Save callback */ 1630 btm_cb.devcb.p_rln_cmpl_cb = p_rln_cmpl_cback; 1631 1632 btsnd_hcic_read_name(); 1633 btu_start_timer (&btm_cb.devcb.rln_timer, BTU_TTYPE_BTM_DEV_CTL, BTM_DEV_REPLY_TIMEOUT); 1634 1635 return BTM_CMD_STARTED; 1636 } 1637 1638 /******************************************************************************* 1639 ** 1640 ** Function btm_read_local_name_complete 1641 ** 1642 ** Description This function is called when local name read complete. 1643 ** message is received from the HCI. 1644 ** 1645 ** Returns void 1646 ** 1647 *******************************************************************************/ 1648 void btm_read_local_name_complete (UINT8 *p, UINT16 evt_len) 1649 { 1650 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_rln_cmpl_cb; 1651 UINT8 status; 1652 1653 btu_stop_timer (&btm_cb.devcb.rln_timer); 1654 1655 /* If there was a callback address for read local name, call it */ 1656 btm_cb.devcb.p_rln_cmpl_cb = NULL; 1657 1658 if (p_cb) 1659 { 1660 STREAM_TO_UINT8 (status, p); 1661 1662 if (status == HCI_SUCCESS) 1663 (*p_cb)(p); 1664 else 1665 (*p_cb)(NULL); 1666 } 1667 } 1668 1669 1670 /******************************************************************************* 1671 ** 1672 ** Function BTM_GetLocalDeviceAddr 1673 ** 1674 ** Description This function is called to read the local device address 1675 ** 1676 ** Returns void 1677 ** the local device address is copied into bd_addr 1678 ** 1679 *******************************************************************************/ 1680 void BTM_GetLocalDeviceAddr (BD_ADDR bd_addr) 1681 { 1682 memcpy (bd_addr, btm_cb.devcb.local_addr, BD_ADDR_LEN); 1683 } 1684 1685 /******************************************************************************* 1686 ** 1687 ** Function BTM_ReadLocalDeviceAddr 1688 ** 1689 ** Description This function is called to read the local device address 1690 ** 1691 ** Returns status of the operation 1692 ** 1693 *******************************************************************************/ 1694 tBTM_STATUS BTM_ReadLocalDeviceAddr (tBTM_CMPL_CB *p_cb) 1695 { 1696 if(p_cb) 1697 (*p_cb)(btm_cb.devcb.local_addr); 1698 1699 return (BTM_SUCCESS); 1700 } 1701 1702 1703 /******************************************************************************* 1704 ** 1705 ** Function btm_read_local_addr_complete 1706 ** 1707 ** Description This function is called when local BD Addr read complete 1708 ** message is received from the HCI. 1709 ** 1710 ** Returns void 1711 ** 1712 *******************************************************************************/ 1713 void btm_read_local_addr_complete (UINT8 *p, UINT16 evt_len) 1714 { 1715 UINT8 status; 1716 1717 STREAM_TO_UINT8 (status, p); 1718 1719 if (status == HCI_SUCCESS) 1720 { 1721 STREAM_TO_BDADDR (btm_cb.devcb.local_addr, p); 1722 } 1723 } 1724 1725 1726 /******************************************************************************* 1727 ** 1728 ** Function BTM_ReadLocalVersion 1729 ** 1730 ** Description This function is called to read the local device version 1731 ** 1732 ** Returns status of the operation 1733 ** 1734 *******************************************************************************/ 1735 tBTM_STATUS BTM_ReadLocalVersion (tBTM_VERSION_INFO *p_vers) 1736 { 1737 /* Make sure the device has retrieved the info (not being reset) */ 1738 if (btm_cb.devcb.state < BTM_DEV_STATE_READY) 1739 return (BTM_DEV_RESET); 1740 1741 *p_vers = btm_cb.devcb.local_version; 1742 1743 return (BTM_SUCCESS); 1744 } 1745 1746 1747 1748 1749 /******************************************************************************* 1750 ** 1751 ** Function BTM_SetDeviceClass 1752 ** 1753 ** Description This function is called to set the local device class 1754 ** 1755 ** Returns status of the operation 1756 ** 1757 *******************************************************************************/ 1758 tBTM_STATUS BTM_SetDeviceClass (DEV_CLASS dev_class) 1759 { 1760 if(!memcmp (btm_cb.devcb.dev_class, dev_class, DEV_CLASS_LEN)) 1761 return(BTM_SUCCESS); 1762 1763 memcpy (btm_cb.devcb.dev_class, dev_class, DEV_CLASS_LEN); 1764 1765 if (btm_cb.devcb.state == BTM_DEV_STATE_WAIT_RESET_CMPLT || 1766 btm_cb.devcb.state == BTM_DEV_STATE_WAIT_AFTER_RESET) 1767 return (BTM_DEV_RESET); 1768 1769 if (!btsnd_hcic_write_dev_class (dev_class)) 1770 return (BTM_NO_RESOURCES); 1771 1772 return (BTM_SUCCESS); 1773 } 1774 1775 1776 /******************************************************************************* 1777 ** 1778 ** Function BTM_ReadDeviceClass 1779 ** 1780 ** Description This function is called to read the local device class 1781 ** 1782 ** Returns pointer to the device class 1783 ** 1784 *******************************************************************************/ 1785 UINT8 *BTM_ReadDeviceClass (void) 1786 { 1787 return ((UINT8 *)btm_cb.devcb.dev_class); 1788 } 1789 1790 1791 /******************************************************************************* 1792 ** 1793 ** Function BTM_ReadLocalFeatures 1794 ** 1795 ** Description This function is called to read the local features 1796 ** 1797 ** Returns pointer to the local features string 1798 ** 1799 *******************************************************************************/ 1800 UINT8 *BTM_ReadLocalFeatures (void) 1801 { 1802 return (btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]); 1803 } 1804 1805 /******************************************************************************* 1806 ** 1807 ** Function BTM_ReadLocalExtendedFeatures 1808 ** 1809 ** Description This function is called to read the local extended features 1810 ** 1811 ** Returns pointer to the local extended features mask or NULL if bad 1812 ** page 1813 ** 1814 *******************************************************************************/ 1815 UINT8 *BTM_ReadLocalExtendedFeatures (UINT8 page_number) 1816 { 1817 if (page_number <= HCI_EXT_FEATURES_PAGE_MAX) 1818 return (btm_cb.devcb.local_lmp_features[page_number]); 1819 1820 BTM_TRACE_ERROR1("Warning: BTM_ReadLocalExtendedFeatures page %d unknown", 1821 page_number); 1822 return NULL; 1823 } 1824 1825 /******************************************************************************* 1826 ** 1827 ** Function BTM_ReadBrcmFeatures 1828 ** 1829 ** Description This function is called to read the Broadcom specific features 1830 ** 1831 ** Returns pointer to the Broadcom features string 1832 ** 1833 *******************************************************************************/ 1834 UINT8 *BTM_ReadBrcmFeatures (void) 1835 { 1836 return (btm_cb.devcb.brcm_features); 1837 } 1838 1839 /******************************************************************************* 1840 ** 1841 ** Function BTM_RegisterForDeviceStatusNotif 1842 ** 1843 ** Description This function is called to register for device status 1844 ** change notifications. 1845 ** 1846 ** If one registration is already there calling function should 1847 ** save the pointer to the function that is return and 1848 ** call it when processing of the event is complete 1849 ** 1850 ** Returns status of the operation 1851 ** 1852 *******************************************************************************/ 1853 tBTM_DEV_STATUS_CB *BTM_RegisterForDeviceStatusNotif (tBTM_DEV_STATUS_CB *p_cb) 1854 { 1855 tBTM_DEV_STATUS_CB *p_prev = btm_cb.devcb.p_dev_status_cb; 1856 1857 btm_cb.devcb.p_dev_status_cb = p_cb; 1858 return (p_prev); 1859 } 1860 1861 /******************************************************************************* 1862 ** 1863 ** Function BTM_VendorSpecificCommand 1864 ** 1865 ** Description Send a vendor specific HCI command to the controller. 1866 ** 1867 ** Returns 1868 ** BTM_SUCCESS Command sent. Does not expect command complete 1869 ** event. (command cmpl callback param is NULL) 1870 ** BTM_CMD_STARTED Command sent. Waiting for command cmpl event. 1871 ** 1872 ** Notes 1873 ** Opcode will be OR'd with HCI_GRP_VENDOR_SPECIFIC. 1874 ** 1875 *******************************************************************************/ 1876 tBTM_STATUS BTM_VendorSpecificCommand(UINT16 opcode, UINT8 param_len, 1877 UINT8 *p_param_buf, tBTM_VSC_CMPL_CB *p_cb) 1878 { 1879 void *p_buf; 1880 1881 BTM_TRACE_EVENT2 ("BTM: BTM_VendorSpecificCommand: Opcode: 0x%04X, ParamLen: %i.", 1882 opcode, param_len); 1883 1884 /* Allocate a buffer to hold HCI command plus the callback function */ 1885 if ((p_buf = GKI_getbuf((UINT16)(sizeof(BT_HDR) + sizeof (tBTM_CMPL_CB *) + 1886 param_len + HCIC_PREAMBLE_SIZE))) != NULL) 1887 { 1888 /* Send the HCI command (opcode will be OR'd with HCI_GRP_VENDOR_SPECIFIC) */ 1889 btsnd_hcic_vendor_spec_cmd (p_buf, opcode, param_len, p_param_buf, (void *)p_cb); 1890 1891 /* Return value */ 1892 if (p_cb != NULL) 1893 return (BTM_CMD_STARTED); 1894 else 1895 return (BTM_SUCCESS); 1896 } 1897 else 1898 return (BTM_NO_RESOURCES); 1899 1900 } 1901 1902 1903 /******************************************************************************* 1904 ** 1905 ** Function btm_vsc_complete 1906 ** 1907 ** Description This function is called when local HCI Vendor Specific 1908 ** Command complete message is received from the HCI. 1909 ** 1910 ** Returns void 1911 ** 1912 *******************************************************************************/ 1913 void btm_vsc_complete (UINT8 *p, UINT16 opcode, UINT16 evt_len, 1914 tBTM_CMPL_CB *p_vsc_cplt_cback) 1915 { 1916 tBTM_VSC_CMPL vcs_cplt_params; 1917 1918 /* If there was a callback address for vcs complete, call it */ 1919 if (p_vsc_cplt_cback) 1920 { 1921 /* Pass paramters to the callback function */ 1922 vcs_cplt_params.opcode = opcode; /* Number of bytes in return info */ 1923 vcs_cplt_params.param_len = evt_len; /* Number of bytes in return info */ 1924 vcs_cplt_params.p_param_buf = p; 1925 (*p_vsc_cplt_cback)(&vcs_cplt_params); /* Call the VSC complete callback function */ 1926 } 1927 } 1928 1929 /******************************************************************************* 1930 ** 1931 ** Function BTM_RegisterForVSEvents 1932 ** 1933 ** Description This function is called to register/deregister for vendor 1934 ** specific HCI events. 1935 ** 1936 ** If is_register=TRUE, then the function will be registered; 1937 ** if is_register=FALSE, then the function will be deregistered. 1938 ** 1939 ** Returns BTM_SUCCESS if successful, 1940 ** BTM_BUSY if maximum number of callbacks have already been 1941 ** registered. 1942 ** 1943 *******************************************************************************/ 1944 tBTM_STATUS BTM_RegisterForVSEvents (tBTM_VS_EVT_CB *p_cb, BOOLEAN is_register) 1945 { 1946 tBTM_STATUS retval = BTM_SUCCESS; 1947 UINT8 i, free_idx = BTM_MAX_VSE_CALLBACKS; 1948 1949 /* See if callback is already registered */ 1950 for (i=0; i<BTM_MAX_VSE_CALLBACKS; i++) 1951 { 1952 if (btm_cb.devcb.p_vend_spec_cb[i] == NULL) 1953 { 1954 /* Found a free slot. Store index */ 1955 free_idx = i; 1956 } 1957 else if (btm_cb.devcb.p_vend_spec_cb[i] == p_cb) 1958 { 1959 /* Found callback in lookup table. If deregistering, clear the entry. */ 1960 if (is_register == FALSE) 1961 { 1962 btm_cb.devcb.p_vend_spec_cb[i] = NULL; 1963 BTM_TRACE_EVENT0("BTM Deregister For VSEvents is successfully"); 1964 } 1965 return (BTM_SUCCESS); 1966 } 1967 } 1968 1969 /* Didn't find callback. Add callback to free slot if registering */ 1970 if (is_register) 1971 { 1972 if (free_idx < BTM_MAX_VSE_CALLBACKS) 1973 { 1974 btm_cb.devcb.p_vend_spec_cb[free_idx] = p_cb; 1975 BTM_TRACE_EVENT0("BTM Register For VSEvents is successfully"); 1976 } 1977 else 1978 { 1979 /* No free entries available */ 1980 BTM_TRACE_ERROR0 ("BTM_RegisterForVSEvents: too many callbacks registered"); 1981 1982 retval = BTM_NO_RESOURCES; 1983 } 1984 } 1985 1986 return (retval); 1987 } 1988 1989 /******************************************************************************* 1990 ** 1991 ** Function btm_vendor_specific_evt 1992 ** 1993 ** Description Process event HCI_VENDOR_SPECIFIC_EVT 1994 ** 1995 ** Note: Some controllers do not send command complete, so 1996 ** the callback and busy flag are cleared here also. 1997 ** 1998 ** Returns void 1999 ** 2000 *******************************************************************************/ 2001 void btm_vendor_specific_evt (UINT8 *p, UINT8 evt_len) 2002 { 2003 UINT8 i; 2004 2005 BTM_TRACE_DEBUG0 ("BTM Event: Vendor Specific event from controller"); 2006 2007 for (i=0; i<BTM_MAX_VSE_CALLBACKS; i++) 2008 { 2009 if (btm_cb.devcb.p_vend_spec_cb[i]) 2010 (*btm_cb.devcb.p_vend_spec_cb[i])(evt_len, p); 2011 } 2012 } 2013 2014 2015 /******************************************************************************* 2016 ** 2017 ** Function BTM_WritePageTimeout 2018 ** 2019 ** Description Send HCI Write Page Timeout. 2020 ** 2021 ** Returns 2022 ** BTM_SUCCESS Command sent. 2023 ** BTM_NO_RESOURCES If out of resources to send the command. 2024 ** 2025 ** 2026 *******************************************************************************/ 2027 tBTM_STATUS BTM_WritePageTimeout(UINT16 timeout) 2028 { 2029 BTM_TRACE_EVENT1 ("BTM: BTM_WritePageTimeout: Timeout: %d.", timeout); 2030 2031 /* Send the HCI command */ 2032 if (btsnd_hcic_write_page_tout (timeout)) 2033 return (BTM_SUCCESS); 2034 else 2035 return (BTM_NO_RESOURCES); 2036 } 2037 2038 /******************************************************************************* 2039 ** 2040 ** Function BTM_WriteVoiceSettings 2041 ** 2042 ** Description Send HCI Write Voice Settings command. 2043 ** See hcidefs.h for settings bitmask values. 2044 ** 2045 ** Returns 2046 ** BTM_SUCCESS Command sent. 2047 ** BTM_NO_RESOURCES If out of resources to send the command. 2048 ** 2049 ** 2050 *******************************************************************************/ 2051 tBTM_STATUS BTM_WriteVoiceSettings(UINT16 settings) 2052 { 2053 BTM_TRACE_EVENT1 ("BTM: BTM_WriteVoiceSettings: Settings: 0x%04x.", settings); 2054 2055 /* Send the HCI command */ 2056 if (btsnd_hcic_write_voice_settings ((UINT16)(settings & 0x03ff))) 2057 return (BTM_SUCCESS); 2058 2059 return (BTM_NO_RESOURCES); 2060 } 2061 2062 /******************************************************************************* 2063 ** 2064 ** Function BTM_EnableTestMode 2065 ** 2066 ** Description Send HCI the enable device under test command. 2067 ** 2068 ** Note: Controller can only be taken out of this mode by 2069 ** resetting the controller. 2070 ** 2071 ** Returns 2072 ** BTM_SUCCESS Command sent. 2073 ** BTM_NO_RESOURCES If out of resources to send the command. 2074 ** 2075 ** 2076 *******************************************************************************/ 2077 tBTM_STATUS BTM_EnableTestMode(void) 2078 { 2079 UINT8 cond; 2080 2081 BTM_TRACE_EVENT0 ("BTM: BTM_EnableTestMode"); 2082 2083 /* set auto accept connection as this is needed during test mode */ 2084 /* Allocate a buffer to hold HCI command */ 2085 cond = HCI_DO_AUTO_ACCEPT_CONNECT; 2086 if (!btsnd_hcic_set_event_filter(HCI_FILTER_CONNECTION_SETUP, 2087 HCI_FILTER_COND_NEW_DEVICE, 2088 &cond, sizeof(cond))) 2089 { 2090 return (BTM_NO_RESOURCES); 2091 } 2092 2093 /* put device to connectable mode */ 2094 if (!BTM_SetConnectability(BTM_CONNECTABLE, BTM_DEFAULT_CONN_WINDOW, 2095 BTM_DEFAULT_CONN_INTERVAL) == BTM_SUCCESS) 2096 { 2097 return BTM_NO_RESOURCES; 2098 } 2099 2100 /* put device to discoverable mode */ 2101 if (!BTM_SetDiscoverability(BTM_GENERAL_DISCOVERABLE, BTM_DEFAULT_DISC_WINDOW, 2102 BTM_DEFAULT_DISC_INTERVAL) == BTM_SUCCESS) 2103 { 2104 return BTM_NO_RESOURCES; 2105 } 2106 2107 /* mask off all of event from controller */ 2108 if (!btsnd_hcic_set_event_mask(LOCAL_BR_EDR_CONTROLLER_ID, 2109 (UINT8 *)"\x00\x00\x00\x00\x00\x00\x00\x00")) 2110 { 2111 return BTM_NO_RESOURCES; 2112 } 2113 2114 /* Send the HCI command */ 2115 if (btsnd_hcic_enable_test_mode ()) 2116 return (BTM_SUCCESS); 2117 else 2118 return (BTM_NO_RESOURCES); 2119 } 2120 2121 /******************************************************************************* 2122 ** 2123 ** Function btm_get_hci_version 2124 ** 2125 ** Description Local function called to retrieve the current HCI version 2126 ** 2127 ** Returns Bluetooth HCI Version returned by the controller 2128 ** 2129 *******************************************************************************/ 2130 UINT8 btm_get_hci_version (void) 2131 { 2132 return (btm_cb.devcb.local_version.hci_version); 2133 } 2134 2135 2136 2137 /******************************************************************************* 2138 ** 2139 ** Function BTM_ReadStoredLinkKey 2140 ** 2141 ** Description This function is called to obtain link key for the specified 2142 ** device from the NVRAM storage attached to the Bluetooth 2143 ** controller. 2144 ** 2145 ** Parameters: bd_addr - Address of the device 2146 ** p_cb - Call back function to be called to return 2147 ** the results 2148 ** 2149 *******************************************************************************/ 2150 tBTM_STATUS BTM_ReadStoredLinkKey (BD_ADDR bd_addr, tBTM_CMPL_CB *p_cb) 2151 { 2152 BD_ADDR local_bd_addr; 2153 BOOLEAN read_all_flag = FALSE; 2154 2155 /* Check if the previous command is completed */ 2156 if (btm_cb.devcb.p_stored_link_key_cmpl_cb) 2157 return (BTM_BUSY); 2158 2159 if (!bd_addr) 2160 { 2161 /* This is to read all the link keys */ 2162 read_all_flag = TRUE; 2163 2164 /* We don't care the BD address. Just pass a non zero pointer */ 2165 bd_addr = local_bd_addr; 2166 } 2167 2168 BTM_TRACE_EVENT1 ("BTM: BTM_ReadStoredLinkKey: Read_All: %s", 2169 read_all_flag ? "TRUE" : "FALSE"); 2170 2171 /* Send the HCI command */ 2172 btm_cb.devcb.p_stored_link_key_cmpl_cb = p_cb; 2173 if (btsnd_hcic_read_stored_key (bd_addr, read_all_flag)) 2174 return (BTM_SUCCESS); 2175 else 2176 return (BTM_NO_RESOURCES); 2177 2178 } 2179 2180 2181 /******************************************************************************* 2182 ** 2183 ** Function BTM_WriteStoredLinkKey 2184 ** 2185 ** Description This function is called to write link keys for the specified 2186 ** device addresses to the NVRAM storage attached to the Bluetooth 2187 ** controller. 2188 ** 2189 ** Parameters: num_keys - Number of link keys 2190 ** bd_addr - Addresses of the devices 2191 ** link_key - Link Keys to be stored 2192 ** p_cb - Call back function to be called to return 2193 ** the results 2194 ** 2195 *******************************************************************************/ 2196 tBTM_STATUS BTM_WriteStoredLinkKey (UINT8 num_keys, 2197 BD_ADDR *bd_addr, 2198 LINK_KEY *link_key, 2199 tBTM_CMPL_CB *p_cb) 2200 { 2201 /* Check if the previous command is completed */ 2202 if (btm_cb.devcb.p_stored_link_key_cmpl_cb) 2203 return (BTM_BUSY); 2204 2205 BTM_TRACE_EVENT1 ("BTM: BTM_WriteStoredLinkKey: num_keys: %d", num_keys); 2206 2207 /* Check the maximum number of link keys */ 2208 if(num_keys > HCI_MAX_NUM_OF_LINK_KEYS_PER_CMMD) 2209 num_keys = HCI_MAX_NUM_OF_LINK_KEYS_PER_CMMD; 2210 2211 /* Send the HCI command */ 2212 btm_cb.devcb.p_stored_link_key_cmpl_cb = p_cb; 2213 if (btsnd_hcic_write_stored_key (num_keys, bd_addr, link_key)) 2214 return (BTM_SUCCESS); 2215 else 2216 return (BTM_NO_RESOURCES); 2217 2218 } 2219 2220 2221 /******************************************************************************* 2222 ** 2223 ** Function BTM_DeleteStoredLinkKey 2224 ** 2225 ** Description This function is called to delete link key for the specified 2226 ** device addresses from the NVRAM storage attached to the Bluetooth 2227 ** controller. 2228 ** 2229 ** Parameters: bd_addr - Addresses of the devices 2230 ** p_cb - Call back function to be called to return 2231 ** the results 2232 ** 2233 *******************************************************************************/ 2234 tBTM_STATUS BTM_DeleteStoredLinkKey(BD_ADDR bd_addr, tBTM_CMPL_CB *p_cb) 2235 { 2236 BD_ADDR local_bd_addr; 2237 BOOLEAN delete_all_flag = FALSE; 2238 2239 /* Check if the previous command is completed */ 2240 if (btm_cb.devcb.p_stored_link_key_cmpl_cb) 2241 return (BTM_BUSY); 2242 2243 if (!bd_addr) 2244 { 2245 /* This is to delete all link keys */ 2246 delete_all_flag = TRUE; 2247 2248 /* We don't care the BD address. Just pass a non zero pointer */ 2249 bd_addr = local_bd_addr; 2250 } 2251 2252 BTM_TRACE_EVENT1 ("BTM: BTM_DeleteStoredLinkKey: delete_all_flag: %s", 2253 delete_all_flag ? "TRUE" : "FALSE"); 2254 2255 /* Send the HCI command */ 2256 btm_cb.devcb.p_stored_link_key_cmpl_cb = p_cb; 2257 if (!btsnd_hcic_delete_stored_key (bd_addr, delete_all_flag)) 2258 { 2259 return (BTM_NO_RESOURCES); 2260 } 2261 else 2262 return (BTM_SUCCESS); 2263 } 2264 2265 2266 /******************************************************************************* 2267 ** 2268 ** Function btm_read_stored_link_key_complete 2269 ** 2270 ** Description This function is called when the command complete message 2271 ** is received from the HCI for the read stored link key command. 2272 ** 2273 ** Returns void 2274 ** 2275 *******************************************************************************/ 2276 void btm_read_stored_link_key_complete (UINT8 *p) 2277 { 2278 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_stored_link_key_cmpl_cb; 2279 tBTM_READ_STORED_LINK_KEY_COMPLETE result; 2280 2281 /* If there was a callback registered for read stored link key, call it */ 2282 btm_cb.devcb.p_stored_link_key_cmpl_cb = NULL; 2283 2284 if (p_cb) 2285 { 2286 /* Set the call back event to indicate command complete */ 2287 result.event = BTM_CB_EVT_READ_STORED_LINK_KEYS; 2288 2289 /* Extract the result fields from the HCI event if status is success */ 2290 STREAM_TO_UINT8 (result.status, p); 2291 if (result.status == HCI_SUCCESS) 2292 { 2293 STREAM_TO_UINT16 (result.max_keys, p); 2294 STREAM_TO_UINT16 (result.read_keys, p); 2295 } 2296 else 2297 { 2298 BTM_TRACE_WARNING1("Read stored link key status %d", result.status); 2299 result.max_keys = 0; 2300 result.read_keys = 0; 2301 } 2302 /* Call the call back and pass the result */ 2303 (*p_cb)(&result); 2304 } 2305 } 2306 2307 2308 /******************************************************************************* 2309 ** 2310 ** Function btm_write_stored_link_key_complete 2311 ** 2312 ** Description This function is called when the command complete message 2313 ** is received from the HCI for the write stored link key command. 2314 ** 2315 ** Returns void 2316 ** 2317 *******************************************************************************/ 2318 void btm_write_stored_link_key_complete (UINT8 *p) 2319 { 2320 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_stored_link_key_cmpl_cb; 2321 tBTM_WRITE_STORED_LINK_KEY_COMPLETE result; 2322 2323 /* If there was a callback registered for read stored link key, call it */ 2324 btm_cb.devcb.p_stored_link_key_cmpl_cb = NULL; 2325 2326 if (p_cb) 2327 { 2328 /* Set the call back event to indicate command complete */ 2329 result.event = BTM_CB_EVT_WRITE_STORED_LINK_KEYS; 2330 2331 /* Extract the result fields from the HCI event */ 2332 STREAM_TO_UINT8 (result.status, p); 2333 STREAM_TO_UINT8 (result.num_keys, p); 2334 2335 /* Call the call back and pass the result */ 2336 (*p_cb)(&result); 2337 } 2338 } 2339 2340 2341 /******************************************************************************* 2342 ** 2343 ** Function btm_delete_stored_link_key_complete 2344 ** 2345 ** Description This function is called when the command complete message 2346 ** is received from the HCI for the delete stored link key command. 2347 ** 2348 ** Returns void 2349 ** 2350 *******************************************************************************/ 2351 void btm_delete_stored_link_key_complete (UINT8 *p) 2352 { 2353 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_stored_link_key_cmpl_cb; 2354 tBTM_DELETE_STORED_LINK_KEY_COMPLETE result; 2355 2356 /* If there was a callback registered for read stored link key, call it */ 2357 btm_cb.devcb.p_stored_link_key_cmpl_cb = NULL; 2358 2359 if (p_cb) 2360 { 2361 /* Set the call back event to indicate command complete */ 2362 result.event = BTM_CB_EVT_DELETE_STORED_LINK_KEYS; 2363 2364 /* Extract the result fields from the HCI event */ 2365 STREAM_TO_UINT8 (result.status, p); 2366 STREAM_TO_UINT16 (result.num_keys, p); 2367 2368 /* Call the call back and pass the result */ 2369 (*p_cb)(&result); 2370 } 2371 } 2372 2373 2374 /******************************************************************************* 2375 ** 2376 ** Function btm_return_link_keys_evt 2377 ** 2378 ** Description This function is called when the return link keys event 2379 ** is received from the HCI for the read stored link key command. 2380 ** 2381 ** Returns void 2382 ** 2383 *******************************************************************************/ 2384 void btm_return_link_keys_evt (tBTM_RETURN_LINK_KEYS_EVT *result) 2385 { 2386 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_stored_link_key_cmpl_cb; 2387 UINT8 i, *p, *p1; 2388 UINT8 bd_addr[BD_ADDR_LEN]; 2389 UINT8 link_key[LINK_KEY_LEN]; 2390 2391 /* Call the call back to pass the link keys to application */ 2392 if (p_cb) 2393 { 2394 /* Change the BD addr and Link key in to big endian order */ 2395 p = (UINT8 *)(result + 1); 2396 for (i=0; i<result->num_keys; i++) 2397 { 2398 /* Initialize the backup pointer */ 2399 p1 = p; 2400 2401 /* Extract the BD Addr and Link Key */ 2402 REVERSE_STREAM_TO_ARRAY(bd_addr, p1, BD_ADDR_LEN); 2403 REVERSE_STREAM_TO_ARRAY(link_key, p1, LINK_KEY_LEN); 2404 2405 /* Write the BD Addr and Link Key back in big endian format */ 2406 ARRAY_TO_STREAM(p, bd_addr, BD_ADDR_LEN); 2407 ARRAY_TO_STREAM(p, link_key, LINK_KEY_LEN); 2408 } 2409 2410 (*p_cb)(result); 2411 } 2412 } 2413 2414 2415 2416 /******************************************************************************* 2417 ** 2418 ** Function btm_report_device_status 2419 ** 2420 ** Description This function is called when there is a change in the device 2421 ** status. This function will report the new device status to 2422 ** the application 2423 ** 2424 ** Returns void 2425 ** 2426 *******************************************************************************/ 2427 void btm_report_device_status (tBTM_DEV_STATUS status) 2428 { 2429 tBTM_DEV_STATUS_CB *p_cb = btm_cb.devcb.p_dev_status_cb; 2430 2431 /* Call the call back to pass the device status to application */ 2432 if (p_cb) 2433 (*p_cb)(status); 2434 } 2435 2436 2437
