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