btm_devctl.cc revision 57f6508cf7b22788fa2e7a739cec241b785718fb 
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 <base/logging.h>
27#include <stddef.h>
28#include <stdio.h>
29#include <stdlib.h>
30#include <string.h>
31
32#include "bt_types.h"
33#include "bt_utils.h"
34#include "btcore/include/module.h"
35#include "btm_int.h"
36#include "btu.h"
37#include "device/include/controller.h"
38#include "hci_layer.h"
39#include "hcimsgs.h"
40#include "l2c_int.h"
41#include "osi/include/osi.h"
42#include "osi/include/thread.h"
43
44#include "gatt_int.h"
45
46extern fixed_queue_t* btu_general_alarm_queue;
47extern thread_t* bt_workqueue_thread;
48
49/******************************************************************************/
50/*               L O C A L    D A T A    D E F I N I T I O N S                */
51/******************************************************************************/
52
53#ifndef BTM_DEV_RESET_TIMEOUT
54#define BTM_DEV_RESET_TIMEOUT 4
55#endif
56
57// TODO: Reevaluate this value in the context of timers with ms granularity
58#define BTM_DEV_NAME_REPLY_TIMEOUT_MS    \
59  (2 * 1000) /* 2 seconds for name reply \
60                */
61
62#define BTM_INFO_TIMEOUT 5 /* 5 seconds for info response */
63
64/******************************************************************************/
65/*            L O C A L    F U N C T I O N     P R O T O T Y P E S            */
66/******************************************************************************/
67
68static void btm_decode_ext_features_page(uint8_t page_number,
69                                         const BD_FEATURES p_features);
70
71/*******************************************************************************
72 *
73 * Function         btm_dev_init
74 *
75 * Description      This function is on the BTM startup
76 *
77 * Returns          void
78 *
79 ******************************************************************************/
80void btm_dev_init(void) {
81  /* Initialize nonzero defaults */
82  memset(btm_cb.cfg.bd_name, 0, sizeof(tBTM_LOC_BD_NAME));
83
84  btm_cb.devcb.read_local_name_timer = alarm_new("btm.read_local_name_timer");
85  btm_cb.devcb.read_rssi_timer = alarm_new("btm.read_rssi_timer");
86  btm_cb.devcb.read_link_quality_timer =
87      alarm_new("btm.read_link_quality_timer");
88  btm_cb.devcb.read_inq_tx_power_timer =
89      alarm_new("btm.read_inq_tx_power_timer");
90  btm_cb.devcb.qos_setup_timer = alarm_new("btm.qos_setup_timer");
91  btm_cb.devcb.read_tx_power_timer = alarm_new("btm.read_tx_power_timer");
92
93  btm_cb.btm_acl_pkt_types_supported =
94      BTM_ACL_PKT_TYPES_MASK_DH1 + BTM_ACL_PKT_TYPES_MASK_DM1 +
95      BTM_ACL_PKT_TYPES_MASK_DH3 + BTM_ACL_PKT_TYPES_MASK_DM3 +
96      BTM_ACL_PKT_TYPES_MASK_DH5 + BTM_ACL_PKT_TYPES_MASK_DM5;
97
98  btm_cb.btm_sco_pkt_types_supported =
99      ESCO_PKT_TYPES_MASK_HV1 + ESCO_PKT_TYPES_MASK_HV2 +
100      ESCO_PKT_TYPES_MASK_HV3 + ESCO_PKT_TYPES_MASK_EV3 +
101      ESCO_PKT_TYPES_MASK_EV4 + ESCO_PKT_TYPES_MASK_EV5;
102}
103
104/*******************************************************************************
105 *
106 * Function         btm_db_reset
107 *
108 * Description      This function is called by BTM_DeviceReset and clears out
109 *                  any pending callbacks for inquiries, discoveries, other
110 *                  pending functions that may be in progress.
111 *
112 * Returns          void
113 *
114 ******************************************************************************/
115static void btm_db_reset(void) {
116  tBTM_CMPL_CB* p_cb;
117  tBTM_STATUS status = BTM_DEV_RESET;
118
119  btm_inq_db_reset();
120
121  if (btm_cb.devcb.p_rln_cmpl_cb) {
122    p_cb = btm_cb.devcb.p_rln_cmpl_cb;
123    btm_cb.devcb.p_rln_cmpl_cb = NULL;
124
125    if (p_cb) (*p_cb)((void*)NULL);
126  }
127
128  if (btm_cb.devcb.p_rssi_cmpl_cb) {
129    p_cb = btm_cb.devcb.p_rssi_cmpl_cb;
130    btm_cb.devcb.p_rssi_cmpl_cb = NULL;
131
132    if (p_cb) (*p_cb)((tBTM_RSSI_RESULTS*)&status);
133  }
134}
135
136bool set_sec_state_idle(void* data, void* context) {
137  tBTM_SEC_DEV_REC* p_dev_rec = static_cast<tBTM_SEC_DEV_REC*>(data);
138  p_dev_rec->sec_state = BTM_SEC_STATE_IDLE;
139  return true;
140}
141
142static void reset_complete(void* result) {
143  CHECK(result == FUTURE_SUCCESS);
144  const controller_t* controller = controller_get_interface();
145
146  /* Tell L2CAP that all connections are gone */
147  l2cu_device_reset();
148
149  /* Clear current security state */
150  list_foreach(btm_cb.sec_dev_rec, set_sec_state_idle, NULL);
151
152  /* After the reset controller should restore all parameters to defaults. */
153  btm_cb.btm_inq_vars.inq_counter = 1;
154  btm_cb.btm_inq_vars.inq_scan_window = HCI_DEF_INQUIRYSCAN_WINDOW;
155  btm_cb.btm_inq_vars.inq_scan_period = HCI_DEF_INQUIRYSCAN_INTERVAL;
156  btm_cb.btm_inq_vars.inq_scan_type = HCI_DEF_SCAN_TYPE;
157
158  btm_cb.btm_inq_vars.page_scan_window = HCI_DEF_PAGESCAN_WINDOW;
159  btm_cb.btm_inq_vars.page_scan_period = HCI_DEF_PAGESCAN_INTERVAL;
160  btm_cb.btm_inq_vars.page_scan_type = HCI_DEF_SCAN_TYPE;
161
162  btm_cb.ble_ctr_cb.conn_state = BLE_CONN_IDLE;
163  btm_cb.ble_ctr_cb.bg_conn_type = BTM_BLE_CONN_NONE;
164  gatt_reset_bgdev_list();
165
166  btm_pm_reset();
167
168  l2c_link_processs_num_bufs(controller->get_acl_buffer_count_classic());
169
170#if (BLE_PRIVACY_SPT == TRUE)
171  /* Set up the BLE privacy settings */
172  if (controller->supports_ble() && controller->supports_ble_privacy() &&
173      controller->get_ble_resolving_list_max_size() > 0) {
174    btm_ble_resolving_list_init(controller->get_ble_resolving_list_max_size());
175    /* set the default random private address timeout */
176    btsnd_hcic_ble_set_rand_priv_addr_timeout(BTM_BLE_PRIVATE_ADDR_INT_MS /
177                                              1000);
178  }
179#endif
180
181  if (controller->supports_ble()) {
182    btm_ble_white_list_init(controller->get_ble_white_list_size());
183    l2c_link_processs_ble_num_bufs(controller->get_acl_buffer_count_ble());
184  }
185
186  BTM_SetPinType(btm_cb.cfg.pin_type, btm_cb.cfg.pin_code,
187                 btm_cb.cfg.pin_code_len);
188
189  for (int i = 0; i <= controller->get_last_features_classic_index(); i++) {
190    btm_decode_ext_features_page(i,
191                                 controller->get_features_classic(i)->as_array);
192  }
193
194  btm_report_device_status(BTM_DEV_STATUS_UP);
195}
196
197// TODO(zachoverflow): remove this function
198void BTM_DeviceReset(UNUSED_ATTR tBTM_CMPL_CB* p_cb) {
199  /* Flush all ACL connections */
200  btm_acl_device_down();
201
202  /* Clear the callback, so application would not hang on reset */
203  btm_db_reset();
204
205  module_start_up_callbacked_wrapper(get_module(CONTROLLER_MODULE),
206                                     bt_workqueue_thread, reset_complete);
207}
208
209/*******************************************************************************
210 *
211 * Function         BTM_IsDeviceUp
212 *
213 * Description      This function is called to check if the device is up.
214 *
215 * Returns          true if device is up, else false
216 *
217 ******************************************************************************/
218bool BTM_IsDeviceUp(void) { return controller_get_interface()->get_is_ready(); }
219
220/*******************************************************************************
221 *
222 * Function         btm_read_local_name_timeout
223 *
224 * Description      Callback when reading the local name times out.
225 *
226 * Returns          void
227 *
228 ******************************************************************************/
229void btm_read_local_name_timeout(UNUSED_ATTR void* data) {
230  tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_rln_cmpl_cb;
231  btm_cb.devcb.p_rln_cmpl_cb = NULL;
232  if (p_cb) (*p_cb)((void*)NULL);
233}
234
235/*******************************************************************************
236 *
237 * Function         btm_decode_ext_features_page
238 *
239 * Description      This function is decodes a features page.
240 *
241 * Returns          void
242 *
243 ******************************************************************************/
244static void btm_decode_ext_features_page(uint8_t page_number,
245                                         const uint8_t* p_features) {
246  BTM_TRACE_DEBUG("btm_decode_ext_features_page page: %d", page_number);
247  switch (page_number) {
248    /* Extended (Legacy) Page 0 */
249    case 0:
250
251      /* Create ACL supported packet types mask */
252      btm_cb.btm_acl_pkt_types_supported =
253          (BTM_ACL_PKT_TYPES_MASK_DH1 + BTM_ACL_PKT_TYPES_MASK_DM1);
254
255      if (HCI_3_SLOT_PACKETS_SUPPORTED(p_features))
256        btm_cb.btm_acl_pkt_types_supported |=
257            (BTM_ACL_PKT_TYPES_MASK_DH3 + BTM_ACL_PKT_TYPES_MASK_DM3);
258
259      if (HCI_5_SLOT_PACKETS_SUPPORTED(p_features))
260        btm_cb.btm_acl_pkt_types_supported |=
261            (BTM_ACL_PKT_TYPES_MASK_DH5 + BTM_ACL_PKT_TYPES_MASK_DM5);
262
263      /* Add in EDR related ACL types */
264      if (!HCI_EDR_ACL_2MPS_SUPPORTED(p_features)) {
265        btm_cb.btm_acl_pkt_types_supported |=
266            (BTM_ACL_PKT_TYPES_MASK_NO_2_DH1 + BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 +
267             BTM_ACL_PKT_TYPES_MASK_NO_2_DH5);
268      }
269
270      if (!HCI_EDR_ACL_3MPS_SUPPORTED(p_features)) {
271        btm_cb.btm_acl_pkt_types_supported |=
272            (BTM_ACL_PKT_TYPES_MASK_NO_3_DH1 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH3 +
273             BTM_ACL_PKT_TYPES_MASK_NO_3_DH5);
274      }
275
276      /* Check to see if 3 and 5 slot packets are available */
277      if (HCI_EDR_ACL_2MPS_SUPPORTED(p_features) ||
278          HCI_EDR_ACL_3MPS_SUPPORTED(p_features)) {
279        if (!HCI_3_SLOT_EDR_ACL_SUPPORTED(p_features))
280          btm_cb.btm_acl_pkt_types_supported |=
281              (BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 +
282               BTM_ACL_PKT_TYPES_MASK_NO_3_DH3);
283
284        if (!HCI_5_SLOT_EDR_ACL_SUPPORTED(p_features))
285          btm_cb.btm_acl_pkt_types_supported |=
286              (BTM_ACL_PKT_TYPES_MASK_NO_2_DH5 +
287               BTM_ACL_PKT_TYPES_MASK_NO_3_DH5);
288      }
289
290      BTM_TRACE_DEBUG("Local supported ACL packet types: 0x%04x",
291                      btm_cb.btm_acl_pkt_types_supported);
292
293      /* Create (e)SCO supported packet types mask */
294      btm_cb.btm_sco_pkt_types_supported = 0;
295#if (BTM_SCO_INCLUDED == TRUE)
296      btm_cb.sco_cb.esco_supported = false;
297#endif
298      if (HCI_SCO_LINK_SUPPORTED(p_features)) {
299        btm_cb.btm_sco_pkt_types_supported = ESCO_PKT_TYPES_MASK_HV1;
300
301        if (HCI_HV2_PACKETS_SUPPORTED(p_features))
302          btm_cb.btm_sco_pkt_types_supported |= ESCO_PKT_TYPES_MASK_HV2;
303
304        if (HCI_HV3_PACKETS_SUPPORTED(p_features))
305          btm_cb.btm_sco_pkt_types_supported |= ESCO_PKT_TYPES_MASK_HV3;
306      }
307
308      if (HCI_ESCO_EV3_SUPPORTED(p_features))
309        btm_cb.btm_sco_pkt_types_supported |= ESCO_PKT_TYPES_MASK_EV3;
310
311      if (HCI_ESCO_EV4_SUPPORTED(p_features))
312        btm_cb.btm_sco_pkt_types_supported |= ESCO_PKT_TYPES_MASK_EV4;
313
314      if (HCI_ESCO_EV5_SUPPORTED(p_features))
315        btm_cb.btm_sco_pkt_types_supported |= ESCO_PKT_TYPES_MASK_EV5;
316      if (btm_cb.btm_sco_pkt_types_supported & BTM_ESCO_LINK_ONLY_MASK) {
317        btm_cb.sco_cb.esco_supported = true;
318
319        /* Add in EDR related eSCO types */
320        if (HCI_EDR_ESCO_2MPS_SUPPORTED(p_features)) {
321          if (!HCI_3_SLOT_EDR_ESCO_SUPPORTED(p_features))
322            btm_cb.btm_sco_pkt_types_supported |= ESCO_PKT_TYPES_MASK_NO_2_EV5;
323        } else {
324          btm_cb.btm_sco_pkt_types_supported |=
325              (ESCO_PKT_TYPES_MASK_NO_2_EV3 + ESCO_PKT_TYPES_MASK_NO_2_EV5);
326        }
327
328        if (HCI_EDR_ESCO_3MPS_SUPPORTED(p_features)) {
329          if (!HCI_3_SLOT_EDR_ESCO_SUPPORTED(p_features))
330            btm_cb.btm_sco_pkt_types_supported |= ESCO_PKT_TYPES_MASK_NO_3_EV5;
331        } else {
332          btm_cb.btm_sco_pkt_types_supported |=
333              (ESCO_PKT_TYPES_MASK_NO_3_EV3 + ESCO_PKT_TYPES_MASK_NO_3_EV5);
334        }
335      }
336
337      BTM_TRACE_DEBUG("Local supported SCO packet types: 0x%04x",
338                      btm_cb.btm_sco_pkt_types_supported);
339
340      /* Create Default Policy Settings */
341      if (HCI_SWITCH_SUPPORTED(p_features))
342        btm_cb.btm_def_link_policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;
343      else
344        btm_cb.btm_def_link_policy &= ~HCI_ENABLE_MASTER_SLAVE_SWITCH;
345
346      if (HCI_HOLD_MODE_SUPPORTED(p_features))
347        btm_cb.btm_def_link_policy |= HCI_ENABLE_HOLD_MODE;
348      else
349        btm_cb.btm_def_link_policy &= ~HCI_ENABLE_HOLD_MODE;
350
351      if (HCI_SNIFF_MODE_SUPPORTED(p_features))
352        btm_cb.btm_def_link_policy |= HCI_ENABLE_SNIFF_MODE;
353      else
354        btm_cb.btm_def_link_policy &= ~HCI_ENABLE_SNIFF_MODE;
355
356      if (HCI_PARK_MODE_SUPPORTED(p_features))
357        btm_cb.btm_def_link_policy |= HCI_ENABLE_PARK_MODE;
358      else
359        btm_cb.btm_def_link_policy &= ~HCI_ENABLE_PARK_MODE;
360
361      btm_sec_dev_reset();
362
363      if (HCI_LMP_INQ_RSSI_SUPPORTED(p_features)) {
364        if (HCI_EXT_INQ_RSP_SUPPORTED(p_features))
365          BTM_SetInquiryMode(BTM_INQ_RESULT_EXTENDED);
366        else
367          BTM_SetInquiryMode(BTM_INQ_RESULT_WITH_RSSI);
368      }
369
370#if (L2CAP_NON_FLUSHABLE_PB_INCLUDED == TRUE)
371      if (HCI_NON_FLUSHABLE_PB_SUPPORTED(p_features))
372        l2cu_set_non_flushable_pbf(true);
373      else
374        l2cu_set_non_flushable_pbf(false);
375#endif
376      BTM_SetPageScanType(BTM_DEFAULT_SCAN_TYPE);
377      BTM_SetInquiryScanType(BTM_DEFAULT_SCAN_TYPE);
378
379      break;
380
381    default:
382      BTM_TRACE_WARNING("%s: feature page %d ignored", __func__, page_number);
383      break;
384  }
385}
386
387/*******************************************************************************
388 *
389 * Function         BTM_SetLocalDeviceName
390 *
391 * Description      This function is called to set the local device name.
392 *
393 * Returns          status of the operation
394 *
395 ******************************************************************************/
396tBTM_STATUS BTM_SetLocalDeviceName(char* p_name) {
397  uint8_t* p;
398
399  if (!p_name || !p_name[0] || (strlen((char*)p_name) > BD_NAME_LEN))
400    return (BTM_ILLEGAL_VALUE);
401
402  if (!controller_get_interface()->get_is_ready()) return (BTM_DEV_RESET);
403  /* Save the device name if local storage is enabled */
404  p = (uint8_t*)btm_cb.cfg.bd_name;
405  if (p != (uint8_t*)p_name)
406    strlcpy(btm_cb.cfg.bd_name, p_name, BTM_MAX_LOC_BD_NAME_LEN);
407
408  btsnd_hcic_change_name(p);
409  return (BTM_CMD_STARTED);
410}
411
412/*******************************************************************************
413 *
414 * Function         BTM_ReadLocalDeviceName
415 *
416 * Description      This function is called to read the local device name.
417 *
418 * Returns          status of the operation
419 *                  If success, BTM_SUCCESS is returned and p_name points stored
420 *                              local device name
421 *                  If BTM doesn't store local device name, BTM_NO_RESOURCES is
422 *                              is returned and p_name is set to NULL
423 *
424 ******************************************************************************/
425tBTM_STATUS BTM_ReadLocalDeviceName(char** p_name) {
426  *p_name = btm_cb.cfg.bd_name;
427  return (BTM_SUCCESS);
428}
429
430/*******************************************************************************
431 *
432 * Function         BTM_ReadLocalDeviceNameFromController
433 *
434 * Description      Get local device name from controller. Do not use cached
435 *                  name (used to get chip-id prior to btm reset complete).
436 *
437 * Returns          BTM_CMD_STARTED if successful, otherwise an error
438 *
439 ******************************************************************************/
440tBTM_STATUS BTM_ReadLocalDeviceNameFromController(
441    tBTM_CMPL_CB* p_rln_cmpl_cback) {
442  /* Check if rln already in progress */
443  if (btm_cb.devcb.p_rln_cmpl_cb) return (BTM_NO_RESOURCES);
444
445  /* Save callback */
446  btm_cb.devcb.p_rln_cmpl_cb = p_rln_cmpl_cback;
447
448  btsnd_hcic_read_name();
449  alarm_set_on_queue(btm_cb.devcb.read_local_name_timer,
450                     BTM_DEV_NAME_REPLY_TIMEOUT_MS, btm_read_local_name_timeout,
451                     NULL, btu_general_alarm_queue);
452
453  return BTM_CMD_STARTED;
454}
455
456/*******************************************************************************
457 *
458 * Function         btm_read_local_name_complete
459 *
460 * Description      This function is called when local name read complete.
461 *                  message is received from the HCI.
462 *
463 * Returns          void
464 *
465 ******************************************************************************/
466void btm_read_local_name_complete(uint8_t* p, UNUSED_ATTR uint16_t evt_len) {
467  tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_rln_cmpl_cb;
468  uint8_t status;
469
470  alarm_cancel(btm_cb.devcb.read_local_name_timer);
471
472  /* If there was a callback address for read local name, call it */
473  btm_cb.devcb.p_rln_cmpl_cb = NULL;
474
475  if (p_cb) {
476    STREAM_TO_UINT8(status, p);
477
478    if (status == HCI_SUCCESS)
479      (*p_cb)(p);
480    else
481      (*p_cb)(NULL);
482  }
483}
484
485/*******************************************************************************
486 *
487 * Function         BTM_SetDeviceClass
488 *
489 * Description      This function is called to set the local device class
490 *
491 * Returns          status of the operation
492 *
493 ******************************************************************************/
494tBTM_STATUS BTM_SetDeviceClass(DEV_CLASS dev_class) {
495  if (!memcmp(btm_cb.devcb.dev_class, dev_class, DEV_CLASS_LEN))
496    return (BTM_SUCCESS);
497
498  memcpy(btm_cb.devcb.dev_class, dev_class, DEV_CLASS_LEN);
499
500  if (!controller_get_interface()->get_is_ready()) return (BTM_DEV_RESET);
501
502  btsnd_hcic_write_dev_class(dev_class);
503
504  return (BTM_SUCCESS);
505}
506
507/*******************************************************************************
508 *
509 * Function         BTM_ReadDeviceClass
510 *
511 * Description      This function is called to read the local device class
512 *
513 * Returns          pointer to the device class
514 *
515 ******************************************************************************/
516uint8_t* BTM_ReadDeviceClass(void) {
517  return ((uint8_t*)btm_cb.devcb.dev_class);
518}
519
520/*******************************************************************************
521 *
522 * Function         BTM_ReadLocalFeatures
523 *
524 * Description      This function is called to read the local features
525 *
526 * Returns          pointer to the local features string
527 *
528 ******************************************************************************/
529// TODO(zachoverflow): get rid of this function
530uint8_t* BTM_ReadLocalFeatures(void) {
531  // Discarding const modifier for now, until this function dies
532  return (uint8_t*)controller_get_interface()
533      ->get_features_classic(0)
534      ->as_array;
535}
536
537/*******************************************************************************
538 *
539 * Function         BTM_RegisterForDeviceStatusNotif
540 *
541 * Description      This function is called to register for device status
542 *                  change notifications.
543 *
544 *                  If one registration is already there calling function should
545 *                  save the pointer to the function that is return and
546 *                  call it when processing of the event is complete
547 *
548 * Returns          status of the operation
549 *
550 ******************************************************************************/
551tBTM_DEV_STATUS_CB* BTM_RegisterForDeviceStatusNotif(tBTM_DEV_STATUS_CB* p_cb) {
552  tBTM_DEV_STATUS_CB* p_prev = btm_cb.devcb.p_dev_status_cb;
553
554  btm_cb.devcb.p_dev_status_cb = p_cb;
555  return (p_prev);
556}
557
558/*******************************************************************************
559 *
560 * Function         BTM_VendorSpecificCommand
561 *
562 * Description      Send a vendor specific HCI command to the controller.
563 *
564 * Notes
565 *      Opcode will be OR'd with HCI_GRP_VENDOR_SPECIFIC.
566 *
567 ******************************************************************************/
568void BTM_VendorSpecificCommand(uint16_t opcode, uint8_t param_len,
569                               uint8_t* p_param_buf, tBTM_VSC_CMPL_CB* p_cb) {
570  /* Allocate a buffer to hold HCI command plus the callback function */
571  void* p_buf = osi_malloc(sizeof(BT_HDR) + sizeof(tBTM_CMPL_CB*) + param_len +
572                           HCIC_PREAMBLE_SIZE);
573
574  BTM_TRACE_EVENT("BTM: %s: Opcode: 0x%04X, ParamLen: %i.", __func__, opcode,
575                  param_len);
576
577  /* Send the HCI command (opcode will be OR'd with HCI_GRP_VENDOR_SPECIFIC) */
578  btsnd_hcic_vendor_spec_cmd(p_buf, opcode, param_len, p_param_buf,
579                             (void*)p_cb);
580}
581
582/*******************************************************************************
583 *
584 * Function         btm_vsc_complete
585 *
586 * Description      This function is called when local HCI Vendor Specific
587 *                  Command complete message is received from the HCI.
588 *
589 * Returns          void
590 *
591 ******************************************************************************/
592void btm_vsc_complete(uint8_t* p, uint16_t opcode, uint16_t evt_len,
593                      tBTM_CMPL_CB* p_vsc_cplt_cback) {
594  tBTM_VSC_CMPL vcs_cplt_params;
595
596  /* If there was a callback address for vcs complete, call it */
597  if (p_vsc_cplt_cback) {
598    /* Pass paramters to the callback function */
599    vcs_cplt_params.opcode = opcode;     /* Number of bytes in return info */
600    vcs_cplt_params.param_len = evt_len; /* Number of bytes in return info */
601    vcs_cplt_params.p_param_buf = p;
602    (*p_vsc_cplt_cback)(
603        &vcs_cplt_params); /* Call the VSC complete callback function */
604  }
605}
606
607/*******************************************************************************
608 *
609 * Function         BTM_RegisterForVSEvents
610 *
611 * Description      This function is called to register/deregister for vendor
612 *                  specific HCI events.
613 *
614 *                  If is_register=true, then the function will be registered;
615 *                  otherwise, the the function will be deregistered.
616 *
617 * Returns          BTM_SUCCESS if successful,
618 *                  BTM_BUSY if maximum number of callbacks have already been
619 *                           registered.
620 *
621 ******************************************************************************/
622tBTM_STATUS BTM_RegisterForVSEvents(tBTM_VS_EVT_CB* p_cb, bool is_register) {
623  tBTM_STATUS retval = BTM_SUCCESS;
624  uint8_t i, free_idx = BTM_MAX_VSE_CALLBACKS;
625
626  /* See if callback is already registered */
627  for (i = 0; i < BTM_MAX_VSE_CALLBACKS; i++) {
628    if (btm_cb.devcb.p_vend_spec_cb[i] == NULL) {
629      /* Found a free slot. Store index */
630      free_idx = i;
631    } else if (btm_cb.devcb.p_vend_spec_cb[i] == p_cb) {
632      /* Found callback in lookup table. If deregistering, clear the entry. */
633      if (is_register == false) {
634        btm_cb.devcb.p_vend_spec_cb[i] = NULL;
635        BTM_TRACE_EVENT("BTM Deregister For VSEvents is successfully");
636      }
637      return (BTM_SUCCESS);
638    }
639  }
640
641  /* Didn't find callback. Add callback to free slot if registering */
642  if (is_register) {
643    if (free_idx < BTM_MAX_VSE_CALLBACKS) {
644      btm_cb.devcb.p_vend_spec_cb[free_idx] = p_cb;
645      BTM_TRACE_EVENT("BTM Register For VSEvents is successfully");
646    } else {
647      /* No free entries available */
648      BTM_TRACE_ERROR("BTM_RegisterForVSEvents: too many callbacks registered");
649
650      retval = BTM_NO_RESOURCES;
651    }
652  }
653
654  return (retval);
655}
656
657/*******************************************************************************
658 *
659 * Function         btm_vendor_specific_evt
660 *
661 * Description      Process event HCI_VENDOR_SPECIFIC_EVT
662 *
663 *                  Note: Some controllers do not send command complete, so
664 *                  the callback and busy flag are cleared here also.
665 *
666 * Returns          void
667 *
668 ******************************************************************************/
669void btm_vendor_specific_evt(uint8_t* p, uint8_t evt_len) {
670  uint8_t i;
671
672  BTM_TRACE_DEBUG("BTM Event: Vendor Specific event from controller");
673
674  for (i = 0; i < BTM_MAX_VSE_CALLBACKS; i++) {
675    if (btm_cb.devcb.p_vend_spec_cb[i])
676      (*btm_cb.devcb.p_vend_spec_cb[i])(evt_len, p);
677  }
678}
679
680/*******************************************************************************
681 *
682 * Function         BTM_WritePageTimeout
683 *
684 * Description      Send HCI Write Page Timeout.
685 *
686 ******************************************************************************/
687void BTM_WritePageTimeout(uint16_t timeout) {
688  BTM_TRACE_EVENT("BTM: BTM_WritePageTimeout: Timeout: %d.", timeout);
689
690  /* Send the HCI command */
691  btsnd_hcic_write_page_tout(timeout);
692}
693
694/*******************************************************************************
695 *
696 * Function         BTM_WriteVoiceSettings
697 *
698 * Description      Send HCI Write Voice Settings command.
699 *                  See hcidefs.h for settings bitmask values.
700 *
701 ******************************************************************************/
702void BTM_WriteVoiceSettings(uint16_t settings) {
703  BTM_TRACE_EVENT("BTM: BTM_WriteVoiceSettings: Settings: 0x%04x.", settings);
704
705  /* Send the HCI command */
706  btsnd_hcic_write_voice_settings((uint16_t)(settings & 0x03ff));
707}
708
709/*******************************************************************************
710 *
711 * Function         BTM_EnableTestMode
712 *
713 * Description      Send HCI the enable device under test command.
714 *
715 *                  Note: Controller can only be taken out of this mode by
716 *                      resetting the controller.
717 *
718 * Returns
719 *      BTM_SUCCESS         Command sent.
720 *      BTM_NO_RESOURCES    If out of resources to send the command.
721 *
722 *
723 ******************************************************************************/
724tBTM_STATUS BTM_EnableTestMode(void) {
725  uint8_t cond;
726
727  BTM_TRACE_EVENT("BTM: BTM_EnableTestMode");
728
729  /* set auto accept connection as this is needed during test mode */
730  /* Allocate a buffer to hold HCI command */
731  cond = HCI_DO_AUTO_ACCEPT_CONNECT;
732  btsnd_hcic_set_event_filter(HCI_FILTER_CONNECTION_SETUP,
733                              HCI_FILTER_COND_NEW_DEVICE, &cond, sizeof(cond));
734
735  /* put device to connectable mode */
736  if (BTM_SetConnectability(BTM_CONNECTABLE, BTM_DEFAULT_CONN_WINDOW,
737                            BTM_DEFAULT_CONN_INTERVAL) != BTM_SUCCESS) {
738    return BTM_NO_RESOURCES;
739  }
740
741  /* put device to discoverable mode */
742  if (BTM_SetDiscoverability(BTM_GENERAL_DISCOVERABLE, BTM_DEFAULT_DISC_WINDOW,
743                             BTM_DEFAULT_DISC_INTERVAL) != BTM_SUCCESS) {
744    return BTM_NO_RESOURCES;
745  }
746
747  /* mask off all of event from controller */
748  hci_layer_get_interface()->transmit_command(
749      hci_packet_factory_get_interface()->make_set_event_mask(
750          (const bt_event_mask_t*)("\x00\x00\x00\x00\x00\x00\x00\x00")),
751      NULL, NULL, NULL);
752
753  /* Send the HCI command */
754  btsnd_hcic_enable_test_mode();
755  return (BTM_SUCCESS);
756}
757
758/*******************************************************************************
759 *
760 * Function         BTM_DeleteStoredLinkKey
761 *
762 * Description      This function is called to delete link key for the specified
763 *                  device addresses from the NVRAM storage attached to the
764 *                  Bluetooth controller.
765 *
766 * Parameters:      bd_addr      - Addresses of the devices
767 *                  p_cb         - Call back function to be called to return
768 *                                 the results
769 *
770 ******************************************************************************/
771tBTM_STATUS BTM_DeleteStoredLinkKey(BD_ADDR bd_addr, tBTM_CMPL_CB* p_cb) {
772  BD_ADDR local_bd_addr;
773  bool delete_all_flag = false;
774
775  /* Check if the previous command is completed */
776  if (btm_cb.devcb.p_stored_link_key_cmpl_cb) return (BTM_BUSY);
777
778  if (!bd_addr) {
779    /* This is to delete all link keys */
780    delete_all_flag = true;
781
782    /* We don't care the BD address. Just pass a non zero pointer */
783    bd_addr = local_bd_addr;
784  }
785
786  BTM_TRACE_EVENT("BTM: BTM_DeleteStoredLinkKey: delete_all_flag: %s",
787                  delete_all_flag ? "true" : "false");
788
789  /* Send the HCI command */
790  btm_cb.devcb.p_stored_link_key_cmpl_cb = p_cb;
791  btsnd_hcic_delete_stored_key(bd_addr, delete_all_flag);
792  return (BTM_SUCCESS);
793}
794
795/*******************************************************************************
796 *
797 * Function         btm_delete_stored_link_key_complete
798 *
799 * Description      This function is called when the command complete message
800 *                  is received from the HCI for the delete stored link key
801 *                  command.
802 *
803 * Returns          void
804 *
805 ******************************************************************************/
806void btm_delete_stored_link_key_complete(uint8_t* p) {
807  tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_stored_link_key_cmpl_cb;
808  tBTM_DELETE_STORED_LINK_KEY_COMPLETE result;
809
810  /* If there was a callback registered for read stored link key, call it */
811  btm_cb.devcb.p_stored_link_key_cmpl_cb = NULL;
812
813  if (p_cb) {
814    /* Set the call back event to indicate command complete */
815    result.event = BTM_CB_EVT_DELETE_STORED_LINK_KEYS;
816
817    /* Extract the result fields from the HCI event */
818    STREAM_TO_UINT8(result.status, p);
819    STREAM_TO_UINT16(result.num_keys, p);
820
821    /* Call the call back and pass the result */
822    (*p_cb)(&result);
823  }
824}
825
826/*******************************************************************************
827 *
828 * Function         btm_report_device_status
829 *
830 * Description      This function is called when there is a change in the device
831 *                  status. This function will report the new device status to
832 *                  the application
833 *
834 * Returns          void
835 *
836 ******************************************************************************/
837void btm_report_device_status(tBTM_DEV_STATUS status) {
838  tBTM_DEV_STATUS_CB* p_cb = btm_cb.devcb.p_dev_status_cb;
839
840  /* Call the call back to pass the device status to application */
841  if (p_cb) (*p_cb)(status);
842}
843