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