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