1 /******************************************************************************
2 *
3 * Copyright (C) 2000-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 ACL connections. This includes
22 * operations such as hold and sniff modes, supported packet types.
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 "bt_target.h"
33 #include "gki.h"
34 #include "hcimsgs.h"
35 #include "btu.h"
36 #include "btm_api.h"
37 #include "btm_int.h"
38 #include "l2c_int.h"
39 #include "hcidefs.h"
40 #include "bd.h"
41 #include "bt_utils.h"
42
43 static void btm_read_remote_features (UINT16 handle);
44 static void btm_read_remote_ext_features (UINT16 handle, UINT8 page_number);
45 static void btm_process_remote_ext_features_page (tACL_CONN *p_acl_cb, tBTM_SEC_DEV_REC *p_dev_rec,
46 UINT8 page_idx);
47 static void btm_process_remote_ext_features (tACL_CONN *p_acl_cb, UINT8 num_read_pages);
48
49 #define BTM_DEV_REPLY_TIMEOUT 3 /* 3 second timeout waiting for responses */
50
51 /*******************************************************************************
52 **
53 ** Function btm_acl_init
54 **
55 ** Description This function is called at BTM startup to initialize
56 **
57 ** Returns void
58 **
59 *******************************************************************************/
btm_acl_init(void)60 void btm_acl_init (void)
61 {
62 BTM_TRACE_DEBUG ("btm_acl_init");
63 #if 0 /* cleared in btm_init; put back in if called from anywhere else! */
64 memset (&btm_cb.acl_db, 0, sizeof (btm_cb.acl_db));
65 #if RFCOMM_INCLUDED == TRUE
66 memset (btm_cb.btm_scn, 0, BTM_MAX_SCN); /* Initialize the SCN usage to FALSE */
67 #endif
68 btm_cb.btm_def_link_policy = 0;
69 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
70 btm_cb.p_bl_changed_cb = NULL;
71 #else
72 btm_cb.p_acl_changed_cb = NULL;
73 #endif
74 #endif
75
76 /* Initialize nonzero defaults */
77 btm_cb.btm_def_link_super_tout = HCI_DEFAULT_INACT_TOUT;
78 btm_cb.acl_disc_reason = 0xff ;
79 }
80
81 /*******************************************************************************
82 **
83 ** Function btm_bda_to_acl
84 **
85 ** Description This function returns the FIRST acl_db entry for the passed BDA.
86 **
87 ** Parameters bda : BD address of the remote device
88 ** transport : Physical transport used for ACL connection (BR/EDR or LE)
89 **
90 ** Returns Returns pointer to the ACL DB for the requested BDA if found.
91 ** NULL if not found.
92 **
93 *******************************************************************************/
btm_bda_to_acl(BD_ADDR bda,tBT_TRANSPORT transport)94 tACL_CONN *btm_bda_to_acl (BD_ADDR bda, tBT_TRANSPORT transport)
95 {
96 tACL_CONN *p = &btm_cb.acl_db[0];
97 UINT16 xx;
98 if (bda)
99 {
100 for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p++)
101 {
102 if ((p->in_use) && (!memcmp (p->remote_addr, bda, BD_ADDR_LEN))
103 #if BLE_INCLUDED == TRUE
104 && p->transport == transport
105 #endif
106 )
107 {
108 BTM_TRACE_DEBUG ("btm_bda_to_acl found");
109 return(p);
110 }
111 }
112 }
113
114 /* If here, no BD Addr found */
115 return((tACL_CONN *)NULL);
116 }
117
118 /*******************************************************************************
119 **
120 ** Function btm_handle_to_acl_index
121 **
122 ** Description This function returns the FIRST acl_db entry for the passed hci_handle.
123 **
124 ** Returns index to the acl_db or MAX_L2CAP_LINKS.
125 **
126 *******************************************************************************/
btm_handle_to_acl_index(UINT16 hci_handle)127 UINT8 btm_handle_to_acl_index (UINT16 hci_handle)
128 {
129 tACL_CONN *p = &btm_cb.acl_db[0];
130 UINT8 xx;
131 BTM_TRACE_DEBUG ("btm_handle_to_acl_index");
132 for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p++)
133 {
134 if ((p->in_use) && (p->hci_handle == hci_handle))
135 {
136 break;
137 }
138 }
139
140 /* If here, no BD Addr found */
141 return(xx);
142 }
143
144 #if BLE_PRIVACY_SPT == TRUE
145 /*******************************************************************************
146 **
147 ** Function btm_ble_get_acl_remote_addr
148 **
149 ** Description This function reads the active remote address used for the
150 ** connection.
151 **
152 ** Returns success return TRUE, otherwise FALSE.
153 **
154 *******************************************************************************/
btm_ble_get_acl_remote_addr(tBTM_SEC_DEV_REC * p_dev_rec,BD_ADDR conn_addr,tBLE_ADDR_TYPE * p_addr_type)155 BOOLEAN btm_ble_get_acl_remote_addr(tBTM_SEC_DEV_REC *p_dev_rec, BD_ADDR conn_addr,
156 tBLE_ADDR_TYPE *p_addr_type)
157 {
158 #if BLE_INCLUDED == TRUE
159 BOOLEAN st = TRUE;
160
161 if (p_dev_rec == NULL)
162 {
163 BTM_TRACE_ERROR("btm_ble_get_acl_remote_addr can not find device with matching address");
164 return FALSE;
165 }
166
167 switch (p_dev_rec->ble.active_addr_type)
168 {
169 case BTM_BLE_ADDR_PSEUDO:
170 memcpy(conn_addr, p_dev_rec->bd_addr, BD_ADDR_LEN);
171 * p_addr_type = p_dev_rec->ble.ble_addr_type;
172 break;
173
174 case BTM_BLE_ADDR_RRA:
175 memcpy(conn_addr, p_dev_rec->ble.cur_rand_addr, BD_ADDR_LEN);
176 * p_addr_type = BLE_ADDR_RANDOM;
177 break;
178
179 case BTM_BLE_ADDR_STATIC:
180 memcpy(conn_addr, p_dev_rec->ble.static_addr, BD_ADDR_LEN);
181 * p_addr_type = p_dev_rec->ble.static_addr_type;
182 break;
183
184 default:
185 BTM_TRACE_ERROR("Unknown active address: %d", p_dev_rec->ble.active_addr_type);
186 st = FALSE;
187 break;
188 }
189
190 return st;
191 #else
192 UNUSED(p_dev_rec);
193 UNUSED(conn_addr);
194 UNUSED(p_addr_type);
195 return FALSE;
196 #endif
197 }
198 #endif
199 /*******************************************************************************
200 **
201 ** Function btm_acl_created
202 **
203 ** Description This function is called by L2CAP when an ACL connection
204 ** is created.
205 **
206 ** Returns void
207 **
208 *******************************************************************************/
btm_acl_created(BD_ADDR bda,DEV_CLASS dc,BD_NAME bdn,UINT16 hci_handle,UINT8 link_role,tBT_TRANSPORT transport)209 void btm_acl_created (BD_ADDR bda, DEV_CLASS dc, BD_NAME bdn,
210 UINT16 hci_handle, UINT8 link_role, tBT_TRANSPORT transport)
211 {
212 tBTM_SEC_DEV_REC *p_dev_rec = NULL;
213 UINT8 yy;
214 tACL_CONN *p;
215 UINT8 xx;
216
217 BTM_TRACE_DEBUG ("btm_acl_created hci_handle=%d link_role=%d transport=%d",
218 hci_handle,link_role, transport);
219 /* Ensure we don't have duplicates */
220 p = btm_bda_to_acl(bda, transport);
221 if (p != (tACL_CONN *)NULL)
222 {
223 p->hci_handle = hci_handle;
224 p->link_role = link_role;
225 #if BLE_INCLUDED == TRUE
226 p->transport = transport;
227 #endif
228 BTM_TRACE_DEBUG ("Duplicate btm_acl_created: RemBdAddr: %02x%02x%02x%02x%02x%02x",
229 bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
230 BTM_SetLinkPolicy(p->remote_addr, &btm_cb.btm_def_link_policy);
231 return;
232 }
233
234 /* Allocate acl_db entry */
235 for (xx = 0, p = &btm_cb.acl_db[0]; xx < MAX_L2CAP_LINKS; xx++, p++)
236 {
237 if (!p->in_use)
238 {
239 p->in_use = TRUE;
240 p->hci_handle = hci_handle;
241 p->link_role = link_role;
242 p->link_up_issued = FALSE;
243
244 #if BLE_INCLUDED == TRUE
245 p->transport = transport;
246 if (transport == BT_TRANSPORT_LE)
247 {
248 #if BLE_PRIVACY_SPT == TRUE
249 if (btm_cb.ble_ctr_cb.privacy)
250 {
251 p->conn_addr_type = btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type;
252 memcpy(p->conn_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, BD_ADDR_LEN);
253 }
254 else
255 #endif
256 {
257 p->conn_addr_type = BLE_ADDR_PUBLIC;
258 BTM_GetLocalDeviceAddr(p->conn_addr);
259 }
260 }
261 #endif
262 p->restore_pkt_types = 0; /* Only exists while SCO is active */
263 p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE;
264
265 #if BTM_PWR_MGR_INCLUDED == FALSE
266 p->mode = BTM_ACL_MODE_NORMAL;
267 #else
268 btm_pm_sm_alloc(xx);
269 #endif /* BTM_PWR_MGR_INCLUDED == FALSE */
270
271 memcpy (p->remote_addr, bda, BD_ADDR_LEN);
272
273 if (dc)
274 memcpy (p->remote_dc, dc, DEV_CLASS_LEN);
275
276 if (bdn)
277 memcpy (p->remote_name, bdn, BTM_MAX_REM_BD_NAME_LEN);
278
279 /* if BR/EDR do something more */
280 if (transport == BT_TRANSPORT_BR_EDR)
281 {
282 btsnd_hcic_read_rmt_clk_offset (p->hci_handle);
283 btsnd_hcic_rmt_ver_req (p->hci_handle);
284 }
285 p_dev_rec = btm_find_dev_by_handle (hci_handle);
286
287 #if (BLE_INCLUDED == TRUE)
288 if (p_dev_rec )
289 {
290 BTM_TRACE_DEBUG ("device_type=0x%x", p_dev_rec->device_type);
291 }
292 #endif
293
294 if (p_dev_rec && !(transport == BT_TRANSPORT_LE))
295 {
296 /* If remote features already known, copy them and continue connection setup */
297 if ((p_dev_rec->num_read_pages) &&
298 (p_dev_rec->num_read_pages <= (HCI_EXT_FEATURES_PAGE_MAX + 1)) /* sanity check */)
299 {
300 memcpy (p->peer_lmp_features, p_dev_rec->features,
301 (HCI_FEATURE_BYTES_PER_PAGE * p_dev_rec->num_read_pages));
302 p->num_read_pages = p_dev_rec->num_read_pages;
303
304 if (BTM_SEC_MODE_SP == btm_cb.security_mode
305 && HCI_SSP_HOST_SUPPORTED(p_dev_rec->features[HCI_EXT_FEATURES_PAGE_1])
306 && HCI_SIMPLE_PAIRING_SUPPORTED(p_dev_rec->features[HCI_EXT_FEATURES_PAGE_0]))
307 {
308 p_dev_rec->sm4 = BTM_SM4_TRUE;
309 }
310 else
311 {
312 p_dev_rec->sm4 |= BTM_SM4_KNOWN;
313 }
314
315 btm_establish_continue (p);
316 return;
317 }
318 }
319
320 #if (BLE_INCLUDED == TRUE)
321 /* If here, features are not known yet */
322 if (p_dev_rec && transport == BT_TRANSPORT_LE)
323 {
324 #if BLE_PRIVACY_SPT == TRUE
325 btm_ble_get_acl_remote_addr (p_dev_rec, p->active_remote_addr,
326 &p->active_remote_addr_type);
327 #endif
328
329 if (HCI_LE_SLAVE_INIT_FEAT_EXC_SUPPORTED(btm_cb.devcb.local_le_features)
330 || link_role == HCI_ROLE_MASTER)
331 {
332 btsnd_hcic_ble_read_remote_feat(p->hci_handle);
333 }
334 else
335 {
336 btm_establish_continue(p);
337 }
338 }
339 else
340 #endif
341 {
342 btm_read_remote_features (p->hci_handle);
343 }
344
345 /* read page 1 - on rmt feature event for buffer reasons */
346 return;
347 }
348 }
349 }
350
351
352 /*******************************************************************************
353 **
354 ** Function btm_acl_report_role_change
355 **
356 ** Description This function is called when the local device is deemed
357 ** to be down. It notifies L2CAP of the failure.
358 **
359 ** Returns void
360 **
361 *******************************************************************************/
btm_acl_report_role_change(UINT8 hci_status,BD_ADDR bda)362 void btm_acl_report_role_change (UINT8 hci_status, BD_ADDR bda)
363 {
364 tBTM_ROLE_SWITCH_CMPL ref_data;
365 BTM_TRACE_DEBUG ("btm_acl_report_role_change");
366 if (btm_cb.devcb.p_switch_role_cb
367 && (bda && (0 == memcmp(btm_cb.devcb.switch_role_ref_data.remote_bd_addr, bda, BD_ADDR_LEN))))
368 {
369 memcpy (&ref_data, &btm_cb.devcb.switch_role_ref_data, sizeof(tBTM_ROLE_SWITCH_CMPL));
370 ref_data.hci_status = hci_status;
371 (*btm_cb.devcb.p_switch_role_cb)(&ref_data);
372 memset (&btm_cb.devcb.switch_role_ref_data, 0, sizeof(tBTM_ROLE_SWITCH_CMPL));
373 btm_cb.devcb.p_switch_role_cb = NULL;
374 }
375 }
376
377 /*******************************************************************************
378 **
379 ** Function btm_acl_removed
380 **
381 ** Description This function is called by L2CAP when an ACL connection
382 ** is removed. Since only L2CAP creates ACL links, we use
383 ** the L2CAP link index as our index into the control blocks.
384 **
385 ** Returns void
386 **
387 *******************************************************************************/
btm_acl_removed(BD_ADDR bda,tBT_TRANSPORT transport)388 void btm_acl_removed (BD_ADDR bda, tBT_TRANSPORT transport)
389 {
390 tACL_CONN *p;
391 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
392 tBTM_BL_EVENT_DATA evt_data;
393 #endif
394 #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE)
395 tBTM_SEC_DEV_REC *p_dev_rec=NULL;
396 #endif
397
398 BTM_TRACE_DEBUG ("btm_acl_removed");
399 p = btm_bda_to_acl(bda, transport);
400 if (p != (tACL_CONN *)NULL)
401 {
402 p->in_use = FALSE;
403
404 /* if the disconnected channel has a pending role switch, clear it now */
405 btm_acl_report_role_change(HCI_ERR_NO_CONNECTION, bda);
406
407 /* Only notify if link up has had a chance to be issued */
408 if (p->link_up_issued)
409 {
410 p->link_up_issued = FALSE;
411
412 /* If anyone cares, tell him database changed */
413 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
414 if (btm_cb.p_bl_changed_cb)
415 {
416 evt_data.event = BTM_BL_DISCN_EVT;
417 evt_data.discn.p_bda = bda;
418 #if BLE_INCLUDED == TRUE
419 evt_data.discn.handle = p->hci_handle;
420 evt_data.discn.transport = p->transport;
421 #endif
422 (*btm_cb.p_bl_changed_cb)(&evt_data);
423 }
424
425 btm_acl_update_busy_level (BTM_BLI_ACL_DOWN_EVT);
426 #else
427 if (btm_cb.p_acl_changed_cb)
428 #if BLE_INCLUDED == TRUE
429 (*btm_cb.p_acl_changed_cb) (bda, NULL, NULL, NULL, FALSE, p->hci_handle, p->transport);
430 #else
431 (*btm_cb.p_acl_changed_cb) (bda, NULL, NULL, NULL, FALSE);
432 #endif
433 #endif
434 }
435
436 #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE)
437
438 BTM_TRACE_DEBUG ("acl hci_handle=%d transport=%d connectable_mode=0x%0x link_role=%d",
439 p->hci_handle,
440 p->transport,
441 btm_cb.ble_ctr_cb.inq_var.connectable_mode,
442 p->link_role);
443
444 p_dev_rec = btm_find_dev(bda);
445 if ( p_dev_rec)
446 {
447 BTM_TRACE_DEBUG("before update p_dev_rec->sec_flags=0x%x", p_dev_rec->sec_flags);
448 if (p->transport == BT_TRANSPORT_LE)
449 {
450 BTM_TRACE_DEBUG("LE link down");
451 p_dev_rec->sec_flags &= ~(BTM_SEC_LE_ENCRYPTED | BTM_SEC_ROLE_SWITCHED);
452 if ( (p_dev_rec->sec_flags & BTM_SEC_LE_LINK_KEY_KNOWN) == 0)
453 {
454 BTM_TRACE_DEBUG("Not Bonded");
455 p_dev_rec->sec_flags &= ~(BTM_SEC_LE_LINK_KEY_AUTHED | BTM_SEC_LE_AUTHENTICATED);
456 }
457 else
458 {
459 BTM_TRACE_DEBUG("Bonded");
460 }
461 }
462 else
463 {
464 BTM_TRACE_DEBUG("Bletooth link down");
465 p_dev_rec->sec_flags &= ~(BTM_SEC_AUTHORIZED | BTM_SEC_AUTHENTICATED
466 | BTM_SEC_ENCRYPTED | BTM_SEC_ROLE_SWITCHED);
467 }
468 BTM_TRACE_DEBUG("after update p_dev_rec->sec_flags=0x%x", p_dev_rec->sec_flags);
469 }
470 else
471 {
472 BTM_TRACE_ERROR("Device not found");
473
474 }
475 #endif
476
477 return;
478 }
479 }
480
481
482 /*******************************************************************************
483 **
484 ** Function btm_acl_device_down
485 **
486 ** Description This function is called when the local device is deemed
487 ** to be down. It notifies L2CAP of the failure.
488 **
489 ** Returns void
490 **
491 *******************************************************************************/
btm_acl_device_down(void)492 void btm_acl_device_down (void)
493 {
494 tACL_CONN *p = &btm_cb.acl_db[0];
495 UINT16 xx;
496 BTM_TRACE_DEBUG ("btm_acl_device_down");
497 for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p++)
498 {
499 if (p->in_use)
500 {
501 BTM_TRACE_DEBUG ("hci_handle=%d HCI_ERR_HW_FAILURE ",p->hci_handle );
502 l2c_link_hci_disc_comp (p->hci_handle, HCI_ERR_HW_FAILURE);
503 }
504 }
505 }
506
507 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
508 /*******************************************************************************
509 **
510 ** Function btm_acl_update_busy_level
511 **
512 ** Description This function is called to update the busy level of the system
513 ** .
514 **
515 ** Returns void
516 **
517 *******************************************************************************/
btm_acl_update_busy_level(tBTM_BLI_EVENT event)518 void btm_acl_update_busy_level (tBTM_BLI_EVENT event)
519 {
520 tBTM_BL_UPDATE_DATA evt;
521 UINT8 busy_level;
522 BTM_TRACE_DEBUG ("btm_acl_update_busy_level");
523 BOOLEAN old_inquiry_state = btm_cb.is_inquiry;
524 switch (event)
525 {
526 case BTM_BLI_ACL_UP_EVT:
527 BTM_TRACE_DEBUG ("BTM_BLI_ACL_UP_EVT");
528 btm_cb.num_acl++;
529 break;
530 case BTM_BLI_ACL_DOWN_EVT:
531 if (btm_cb.num_acl)
532 {
533 btm_cb.num_acl--;
534 BTM_TRACE_DEBUG ("BTM_BLI_ACL_DOWN_EVT", btm_cb.num_acl);
535 }
536 else
537 {
538 BTM_TRACE_ERROR ("BTM_BLI_ACL_DOWN_EVT issued, but num_acl already zero !!!");
539 }
540 break;
541 case BTM_BLI_PAGE_EVT:
542 BTM_TRACE_DEBUG ("BTM_BLI_PAGE_EVT");
543 btm_cb.is_paging = TRUE;
544 evt.busy_level_flags= BTM_BL_PAGING_STARTED;
545 break;
546 case BTM_BLI_PAGE_DONE_EVT:
547 BTM_TRACE_DEBUG ("BTM_BLI_PAGE_DONE_EVT");
548 btm_cb.is_paging = FALSE;
549 evt.busy_level_flags = BTM_BL_PAGING_COMPLETE;
550 break;
551 case BTM_BLI_INQ_EVT:
552 BTM_TRACE_DEBUG ("BTM_BLI_INQ_EVT");
553 btm_cb.is_inquiry = TRUE;
554 evt.busy_level_flags = BTM_BL_INQUIRY_STARTED;
555 break;
556 case BTM_BLI_INQ_CANCEL_EVT:
557 BTM_TRACE_DEBUG ("BTM_BLI_INQ_CANCEL_EVT");
558 btm_cb.is_inquiry = FALSE;
559 evt.busy_level_flags = BTM_BL_INQUIRY_CANCELLED;
560 break;
561 case BTM_BLI_INQ_DONE_EVT:
562 BTM_TRACE_DEBUG ("BTM_BLI_INQ_DONE_EVT");
563 btm_cb.is_inquiry = FALSE;
564 evt.busy_level_flags = BTM_BL_INQUIRY_COMPLETE;
565 break;
566 }
567
568 if (btm_cb.is_paging || btm_cb.is_inquiry)
569 busy_level = 10;
570 else
571 busy_level = (UINT8)btm_cb.num_acl;
572
573 if ((busy_level != btm_cb.busy_level) ||(old_inquiry_state != btm_cb.is_inquiry))
574 {
575 evt.event = BTM_BL_UPDATE_EVT;
576 evt.busy_level = busy_level;
577 btm_cb.busy_level = busy_level;
578 if (btm_cb.p_bl_changed_cb && (btm_cb.bl_evt_mask & BTM_BL_UPDATE_MASK))
579 {
580 (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA *)&evt);
581 }
582 }
583 }
584 #endif
585
586
587 /*******************************************************************************
588 **
589 ** Function BTM_GetRole
590 **
591 ** Description This function is called to get the role of the local device
592 ** for the ACL connection with the specified remote device
593 **
594 ** Returns BTM_SUCCESS if connection exists.
595 ** BTM_UNKNOWN_ADDR if no active link with bd addr specified
596 **
597 *******************************************************************************/
BTM_GetRole(BD_ADDR remote_bd_addr,UINT8 * p_role)598 tBTM_STATUS BTM_GetRole (BD_ADDR remote_bd_addr, UINT8 *p_role)
599 {
600 tACL_CONN *p;
601 BTM_TRACE_DEBUG ("BTM_GetRole");
602 if ((p = btm_bda_to_acl(remote_bd_addr, BT_TRANSPORT_BR_EDR)) == NULL)
603 {
604 *p_role = BTM_ROLE_UNDEFINED;
605 return(BTM_UNKNOWN_ADDR);
606 }
607
608 /* Get the current role */
609 *p_role = p->link_role;
610 return(BTM_SUCCESS);
611 }
612
613
614 /*******************************************************************************
615 **
616 ** Function BTM_SwitchRole
617 **
618 ** Description This function is called to switch role between master and
619 ** slave. If role is already set it will do nothing. If the
620 ** command was initiated, the callback function is called upon
621 ** completion.
622 **
623 ** Returns BTM_SUCCESS if already in specified role.
624 ** BTM_CMD_STARTED if command issued to controller.
625 ** BTM_NO_RESOURCES if couldn't allocate memory to issue command
626 ** BTM_UNKNOWN_ADDR if no active link with bd addr specified
627 ** BTM_MODE_UNSUPPORTED if local device does not support role switching
628 ** BTM_BUSY if the previous command is not completed
629 **
630 *******************************************************************************/
BTM_SwitchRole(BD_ADDR remote_bd_addr,UINT8 new_role,tBTM_CMPL_CB * p_cb)631 tBTM_STATUS BTM_SwitchRole (BD_ADDR remote_bd_addr, UINT8 new_role, tBTM_CMPL_CB *p_cb)
632 {
633 tACL_CONN *p;
634 tBTM_SEC_DEV_REC *p_dev_rec = NULL;
635 #if BTM_SCO_INCLUDED == TRUE
636 BOOLEAN is_sco_active;
637 #endif
638 #if BTM_PWR_MGR_INCLUDED == TRUE
639 tBTM_STATUS status;
640 tBTM_PM_MODE pwr_mode;
641 tBTM_PM_PWR_MD settings;
642 #endif
643 #if (BT_USE_TRACES == TRUE)
644 BD_ADDR_PTR p_bda;
645 #endif
646 BTM_TRACE_API ("BTM_SwitchRole BDA: %02x-%02x-%02x-%02x-%02x-%02x",
647 remote_bd_addr[0], remote_bd_addr[1], remote_bd_addr[2],
648 remote_bd_addr[3], remote_bd_addr[4], remote_bd_addr[5]);
649
650 /* Make sure the local device supports switching */
651 if (!(HCI_SWITCH_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0])))
652 return(BTM_MODE_UNSUPPORTED);
653
654 if (btm_cb.devcb.p_switch_role_cb && p_cb)
655 {
656 #if (BT_USE_TRACES == TRUE)
657 p_bda = btm_cb.devcb.switch_role_ref_data.remote_bd_addr;
658 BTM_TRACE_DEBUG ("Role switch on other device is in progress 0x%02x%02x%02x%02x%02x%02x",
659 p_bda[0], p_bda[1], p_bda[2],
660 p_bda[3], p_bda[4], p_bda[5]);
661 #endif
662 return(BTM_BUSY);
663 }
664
665 if ((p = btm_bda_to_acl(remote_bd_addr, BT_TRANSPORT_BR_EDR)) == NULL)
666 return(BTM_UNKNOWN_ADDR);
667
668 /* Finished if already in desired role */
669 if (p->link_role == new_role)
670 return(BTM_SUCCESS);
671
672 #if BTM_SCO_INCLUDED == TRUE
673 /* Check if there is any SCO Active on this BD Address */
674 is_sco_active = btm_is_sco_active_by_bdaddr(remote_bd_addr);
675
676 if (is_sco_active == TRUE)
677 return(BTM_NO_RESOURCES);
678 #endif
679
680 /* Ignore role switch request if the previous request was not completed */
681 if (p->switch_role_state != BTM_ACL_SWKEY_STATE_IDLE)
682 {
683 BTM_TRACE_DEBUG ("BTM_SwitchRole busy: %d",
684 p->switch_role_state);
685 return(BTM_BUSY);
686 }
687
688 /* Cannot switch role while parked or sniffing */
689 #if BTM_PWR_MGR_INCLUDED == FALSE
690 if (p->mode == HCI_MODE_PARK)
691 {
692 if (!btsnd_hcic_exit_park_mode (p->hci_handle))
693 return(BTM_NO_RESOURCES);
694
695 p->switch_role_state = BTM_ACL_SWKEY_STATE_MODE_CHANGE;
696 }
697 else if (p->mode == HCI_MODE_SNIFF)
698 {
699 if (!btsnd_hcic_exit_sniff_mode (p->hci_handle))
700 return(BTM_NO_RESOURCES);
701
702 p->switch_role_state = BTM_ACL_SWKEY_STATE_MODE_CHANGE;
703 }
704 #else /* power manager is in use */
705
706 if ((status = BTM_ReadPowerMode(p->remote_addr, &pwr_mode)) != BTM_SUCCESS)
707 return(status);
708
709 /* Wake up the link if in sniff or park before attempting switch */
710 if (pwr_mode == BTM_PM_MD_PARK || pwr_mode == BTM_PM_MD_SNIFF)
711 {
712 memset( (void*)&settings, 0, sizeof(settings));
713 settings.mode = BTM_PM_MD_ACTIVE;
714 status = BTM_SetPowerMode (BTM_PM_SET_ONLY_ID, p->remote_addr, &settings);
715 if (status != BTM_CMD_STARTED)
716 return(BTM_WRONG_MODE);
717
718 p->switch_role_state = BTM_ACL_SWKEY_STATE_MODE_CHANGE;
719 }
720 #endif
721 /* some devices do not support switch while encryption is on */
722 else
723 {
724 p_dev_rec = btm_find_dev (remote_bd_addr);
725 if ((p_dev_rec != NULL)
726 && ((p_dev_rec->sec_flags & BTM_SEC_ENCRYPTED) != 0)
727 && !BTM_EPR_AVAILABLE(p))
728 {
729 /* bypass turning off encryption if change link key is already doing it */
730 if (p->encrypt_state != BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF)
731 {
732 if (!btsnd_hcic_set_conn_encrypt (p->hci_handle, FALSE))
733 return(BTM_NO_RESOURCES);
734 else
735 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF;
736 }
737
738 p->switch_role_state = BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF;
739 }
740 else
741 {
742 if (!btsnd_hcic_switch_role (remote_bd_addr, new_role))
743 return(BTM_NO_RESOURCES);
744
745 p->switch_role_state = BTM_ACL_SWKEY_STATE_IN_PROGRESS;
746
747 #if BTM_DISC_DURING_RS == TRUE
748 if (p_dev_rec)
749 p_dev_rec->rs_disc_pending = BTM_SEC_RS_PENDING;
750 #endif
751 }
752 }
753
754 /* Initialize return structure in case request fails */
755 if (p_cb)
756 {
757 memcpy (btm_cb.devcb.switch_role_ref_data.remote_bd_addr, remote_bd_addr,
758 BD_ADDR_LEN);
759 btm_cb.devcb.switch_role_ref_data.role = new_role;
760 /* initialized to an error code */
761 btm_cb.devcb.switch_role_ref_data.hci_status = HCI_ERR_UNSUPPORTED_VALUE;
762 btm_cb.devcb.p_switch_role_cb = p_cb;
763 }
764 return(BTM_CMD_STARTED);
765 }
766
767 /*******************************************************************************
768 **
769 ** Function BTM_ChangeLinkKey
770 **
771 ** Description This function is called to change the link key of the
772 ** connection.
773 **
774 ** Returns BTM_CMD_STARTED if command issued to controller.
775 ** BTM_NO_RESOURCES if couldn't allocate memory to issue command
776 ** BTM_UNKNOWN_ADDR if no active link with bd addr specified
777 ** BTM_BUSY if the previous command is not completed
778 **
779 *******************************************************************************/
BTM_ChangeLinkKey(BD_ADDR remote_bd_addr,tBTM_CMPL_CB * p_cb)780 tBTM_STATUS BTM_ChangeLinkKey (BD_ADDR remote_bd_addr, tBTM_CMPL_CB *p_cb)
781 {
782 tACL_CONN *p;
783 tBTM_SEC_DEV_REC *p_dev_rec = NULL;
784 #if BTM_PWR_MGR_INCLUDED == TRUE
785 tBTM_STATUS status;
786 tBTM_PM_MODE pwr_mode;
787 tBTM_PM_PWR_MD settings;
788 #endif
789 BTM_TRACE_DEBUG ("BTM_ChangeLinkKey");
790 if ((p = btm_bda_to_acl(remote_bd_addr, BT_TRANSPORT_BR_EDR)) == NULL)
791 return(BTM_UNKNOWN_ADDR);
792
793 /* Ignore change link key request if the previsous request has not completed */
794 if (p->change_key_state != BTM_ACL_SWKEY_STATE_IDLE)
795 {
796 BTM_TRACE_DEBUG ("Link key change request declined since the previous request"
797 " for this device has not completed ");
798 return(BTM_BUSY);
799 }
800
801 memset (&btm_cb.devcb.chg_link_key_ref_data, 0, sizeof(tBTM_CHANGE_KEY_CMPL));
802
803 /* Cannot change key while parked */
804 #if BTM_PWR_MGR_INCLUDED == FALSE
805 if (p->mode == HCI_MODE_PARK)
806 {
807 if (!btsnd_hcic_exit_park_mode (p->hci_handle))
808 return(BTM_NO_RESOURCES);
809
810 p->change_key_state = BTM_ACL_SWKEY_STATE_MODE_CHANGE;
811 }
812 #else /* power manager is in use */
813
814
815 if ((status = BTM_ReadPowerMode(p->remote_addr, &pwr_mode)) != BTM_SUCCESS)
816 return(status);
817
818 /* Wake up the link if in park before attempting to change link keys */
819 if (pwr_mode == BTM_PM_MD_PARK)
820 {
821 memset( (void*)&settings, 0, sizeof(settings));
822 settings.mode = BTM_PM_MD_ACTIVE;
823 status = BTM_SetPowerMode (BTM_PM_SET_ONLY_ID, p->remote_addr, &settings);
824 if (status != BTM_CMD_STARTED)
825 return(BTM_WRONG_MODE);
826
827 p->change_key_state = BTM_ACL_SWKEY_STATE_MODE_CHANGE;
828 }
829 #endif
830 /* some devices do not support change of link key while encryption is on */
831 else if (((p_dev_rec = btm_find_dev (remote_bd_addr)) != NULL)
832 && ((p_dev_rec->sec_flags & BTM_SEC_ENCRYPTED) != 0) && !BTM_EPR_AVAILABLE(p))
833 {
834 /* bypass turning off encryption if switch role is already doing it */
835 if (p->encrypt_state != BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF)
836 {
837 if (!btsnd_hcic_set_conn_encrypt (p->hci_handle, FALSE))
838 return(BTM_NO_RESOURCES);
839 else
840 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF;
841 }
842
843 p->change_key_state = BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF;
844 }
845 else /* Ok to initiate change of link key */
846 {
847 if (!btsnd_hcic_change_link_key (p->hci_handle))
848 return(BTM_NO_RESOURCES);
849
850 p->change_key_state = BTM_ACL_SWKEY_STATE_IN_PROGRESS;
851 }
852
853 /* Initialize return structure in case request fails */
854 memcpy (btm_cb.devcb.chg_link_key_ref_data.remote_bd_addr, remote_bd_addr,
855 BD_ADDR_LEN);
856 btm_cb.devcb.p_chg_link_key_cb = p_cb;
857 return(BTM_CMD_STARTED);
858 }
859
860 /*******************************************************************************
861 **
862 ** Function btm_acl_link_key_change
863 **
864 ** Description This function is called to when a change link key event
865 ** is received.
866 **
867 *******************************************************************************/
btm_acl_link_key_change(UINT16 handle,UINT8 status)868 void btm_acl_link_key_change (UINT16 handle, UINT8 status)
869 {
870 tBTM_CHANGE_KEY_CMPL *p_data;
871 tACL_CONN *p;
872 UINT8 xx;
873 BTM_TRACE_DEBUG ("btm_acl_link_key_change");
874 /* Look up the connection by handle and set the current mode */
875 xx = btm_handle_to_acl_index(handle);
876
877 /* don't assume that we can never get a bad hci_handle */
878 if (xx >= MAX_L2CAP_LINKS)
879 return;
880
881 p_data = &btm_cb.devcb.chg_link_key_ref_data;
882 p = &btm_cb.acl_db[xx];
883 p_data->hci_status = status;
884
885 /* if switching state is switching we need to turn encryption on */
886 /* if idle, we did not change encryption */
887 if (p->change_key_state == BTM_ACL_SWKEY_STATE_SWITCHING)
888 {
889 /* Make sure there's not also a role switch going on before re-enabling */
890 if (p->switch_role_state != BTM_ACL_SWKEY_STATE_SWITCHING)
891 {
892 if (btsnd_hcic_set_conn_encrypt (p->hci_handle, TRUE))
893 {
894 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_ENCRYPT_ON;
895 p->change_key_state = BTM_ACL_SWKEY_STATE_ENCRYPTION_ON;
896 return;
897 }
898 }
899 else /* Set the state and wait for change link key */
900 {
901 p->change_key_state = BTM_ACL_SWKEY_STATE_ENCRYPTION_ON;
902 return;
903 }
904 }
905
906 /* Set the switch_role_state to IDLE since the reply received from HCI */
907 /* regardless of its result either success or failed. */
908 if (p->change_key_state == BTM_ACL_SWKEY_STATE_IN_PROGRESS)
909 {
910 p->change_key_state = BTM_ACL_SWKEY_STATE_IDLE;
911 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE;
912 }
913
914 if (btm_cb.devcb.p_chg_link_key_cb)
915 {
916 (*btm_cb.devcb.p_chg_link_key_cb)((void *)p_data);
917 btm_cb.devcb.p_chg_link_key_cb = NULL;
918 }
919
920 BTM_TRACE_ERROR("Change Link Key Complete Event: Handle 0x%02x, HCI Status 0x%02x",
921 handle, p_data->hci_status);
922 }
923
924 /*******************************************************************************
925 **
926 ** Function btm_acl_encrypt_change
927 **
928 ** Description This function is when encryption of the connection is
929 ** completed by the LM. Checks to see if a role switch or
930 ** change of link key was active and initiates or continues
931 ** process if needed.
932 **
933 ** Returns void
934 **
935 *******************************************************************************/
btm_acl_encrypt_change(UINT16 handle,UINT8 status,UINT8 encr_enable)936 void btm_acl_encrypt_change (UINT16 handle, UINT8 status, UINT8 encr_enable)
937 {
938 tACL_CONN *p;
939 UINT8 xx;
940 tBTM_SEC_DEV_REC *p_dev_rec;
941 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
942 tBTM_BL_ROLE_CHG_DATA evt;
943 #endif
944
945 BTM_TRACE_DEBUG ("btm_acl_encrypt_change handle=%d status=%d encr_enabl=%d",
946 handle, status, encr_enable);
947 xx = btm_handle_to_acl_index(handle);
948 /* don't assume that we can never get a bad hci_handle */
949 if (xx < MAX_L2CAP_LINKS)
950 p = &btm_cb.acl_db[xx];
951 else
952 return;
953
954 /* Process Role Switch if active */
955 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF)
956 {
957 /* if encryption turn off failed we still will try to switch role */
958 if (encr_enable)
959 {
960 p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE;
961 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE;
962 }
963 else
964 {
965 p->switch_role_state = BTM_ACL_SWKEY_STATE_SWITCHING;
966 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_TEMP_FUNC;
967 }
968
969 if (!btsnd_hcic_switch_role (p->remote_addr, (UINT8)!p->link_role))
970 {
971 p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE;
972 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE;
973 btm_acl_report_role_change(btm_cb.devcb.switch_role_ref_data.hci_status, p->remote_addr);
974 }
975 #if BTM_DISC_DURING_RS == TRUE
976 else
977 {
978 if ((p_dev_rec = btm_find_dev (p->remote_addr)) != NULL)
979 p_dev_rec->rs_disc_pending = BTM_SEC_RS_PENDING;
980 }
981 #endif
982
983 }
984 /* Finished enabling Encryption after role switch */
985 else if (p->switch_role_state == BTM_ACL_SWKEY_STATE_ENCRYPTION_ON)
986 {
987 p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE;
988 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE;
989 btm_acl_report_role_change(btm_cb.devcb.switch_role_ref_data.hci_status, p->remote_addr);
990
991 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
992 /* if role change event is registered, report it now */
993 if (btm_cb.p_bl_changed_cb && (btm_cb.bl_evt_mask & BTM_BL_ROLE_CHG_MASK))
994 {
995 evt.event = BTM_BL_ROLE_CHG_EVT;
996 evt.new_role = btm_cb.devcb.switch_role_ref_data.role;
997 evt.p_bda = btm_cb.devcb.switch_role_ref_data.remote_bd_addr;
998 evt.hci_status = btm_cb.devcb.switch_role_ref_data.hci_status;
999 (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA *)&evt);
1000
1001 BTM_TRACE_DEBUG("Role Switch Event: new_role 0x%02x, HCI Status 0x%02x, rs_st:%d",
1002 evt.new_role, evt.hci_status, p->switch_role_state);
1003 }
1004 #endif
1005
1006 #if BTM_DISC_DURING_RS == TRUE
1007 /* If a disconnect is pending, issue it now that role switch has completed */
1008 if ((p_dev_rec = btm_find_dev (p->remote_addr)) != NULL)
1009 {
1010 if (p_dev_rec->rs_disc_pending == BTM_SEC_DISC_PENDING)
1011 {
1012 BTM_TRACE_WARNING("btm_acl_encrypt_change -> Issuing delayed HCI_Disconnect!!!");
1013 btsnd_hcic_disconnect(p_dev_rec->hci_handle, HCI_ERR_PEER_USER);
1014 }
1015 BTM_TRACE_ERROR("btm_acl_encrypt_change: tBTM_SEC_DEV:0x%x rs_disc_pending=%d",
1016 (UINT32)p_dev_rec, p_dev_rec->rs_disc_pending);
1017 p_dev_rec->rs_disc_pending = BTM_SEC_RS_NOT_PENDING; /* reset flag */
1018 }
1019 #endif
1020 }
1021
1022
1023 /* Process Change Link Key if active */
1024 if (p->change_key_state == BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF)
1025 {
1026 /* if encryption turn off failed we still will try to change link key */
1027 if (encr_enable)
1028 {
1029 p->change_key_state = BTM_ACL_SWKEY_STATE_IDLE;
1030 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE;
1031 }
1032 else
1033 {
1034 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_TEMP_FUNC;
1035 p->change_key_state = BTM_ACL_SWKEY_STATE_SWITCHING;
1036 }
1037
1038 if (!btsnd_hcic_change_link_key (p->hci_handle))
1039 {
1040 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE;
1041 p->change_key_state = BTM_ACL_SWKEY_STATE_IDLE;
1042 if (btm_cb.devcb.p_chg_link_key_cb)
1043 {
1044 (*btm_cb.devcb.p_chg_link_key_cb)(&btm_cb.devcb.chg_link_key_ref_data);
1045 btm_cb.devcb.p_chg_link_key_cb = NULL;
1046 }
1047 }
1048 }
1049 /* Finished enabling Encryption after changing link key */
1050 else if (p->change_key_state == BTM_ACL_SWKEY_STATE_ENCRYPTION_ON)
1051 {
1052 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE;
1053 p->change_key_state = BTM_ACL_SWKEY_STATE_IDLE;
1054 if (btm_cb.devcb.p_chg_link_key_cb)
1055 {
1056 (*btm_cb.devcb.p_chg_link_key_cb)(&btm_cb.devcb.chg_link_key_ref_data);
1057 btm_cb.devcb.p_chg_link_key_cb = NULL;
1058 }
1059 }
1060 }
1061 /*******************************************************************************
1062 **
1063 ** Function BTM_SetLinkPolicy
1064 **
1065 ** Description Create and send HCI "Write Policy Set" command
1066 **
1067 ** Returns status of the operation
1068 **
1069 *******************************************************************************/
BTM_SetLinkPolicy(BD_ADDR remote_bda,UINT16 * settings)1070 tBTM_STATUS BTM_SetLinkPolicy (BD_ADDR remote_bda, UINT16 *settings)
1071 {
1072 tACL_CONN *p;
1073 UINT8 *localFeatures = BTM_ReadLocalFeatures();
1074 BTM_TRACE_DEBUG ("BTM_SetLinkPolicy");
1075 /* BTM_TRACE_API ("BTM_SetLinkPolicy: requested settings: 0x%04x", *settings ); */
1076
1077 /* First, check if hold mode is supported */
1078 if (*settings != HCI_DISABLE_ALL_LM_MODES)
1079 {
1080 if ( (*settings & HCI_ENABLE_MASTER_SLAVE_SWITCH) && (!HCI_SWITCH_SUPPORTED(localFeatures)) )
1081 {
1082 *settings &= (~HCI_ENABLE_MASTER_SLAVE_SWITCH);
1083 BTM_TRACE_API ("BTM_SetLinkPolicy switch not supported (settings: 0x%04x)", *settings );
1084 }
1085 if ( (*settings & HCI_ENABLE_HOLD_MODE) && (!HCI_HOLD_MODE_SUPPORTED(localFeatures)) )
1086 {
1087 *settings &= (~HCI_ENABLE_HOLD_MODE);
1088 BTM_TRACE_API ("BTM_SetLinkPolicy hold not supported (settings: 0x%04x)", *settings );
1089 }
1090 if ( (*settings & HCI_ENABLE_SNIFF_MODE) && (!HCI_SNIFF_MODE_SUPPORTED(localFeatures)) )
1091 {
1092 *settings &= (~HCI_ENABLE_SNIFF_MODE);
1093 BTM_TRACE_API ("BTM_SetLinkPolicy sniff not supported (settings: 0x%04x)", *settings );
1094 }
1095 if ( (*settings & HCI_ENABLE_PARK_MODE) && (!HCI_PARK_MODE_SUPPORTED(localFeatures)) )
1096 {
1097 *settings &= (~HCI_ENABLE_PARK_MODE);
1098 BTM_TRACE_API ("BTM_SetLinkPolicy park not supported (settings: 0x%04x)", *settings );
1099 }
1100 }
1101
1102 if ((p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR)) != NULL)
1103 return(btsnd_hcic_write_policy_set (p->hci_handle, *settings) ? BTM_CMD_STARTED : BTM_NO_RESOURCES);
1104
1105 /* If here, no BD Addr found */
1106 return(BTM_UNKNOWN_ADDR);
1107 }
1108
1109 /*******************************************************************************
1110 **
1111 ** Function BTM_SetDefaultLinkPolicy
1112 **
1113 ** Description Set the default value for HCI "Write Policy Set" command
1114 ** to use when an ACL link is created.
1115 **
1116 ** Returns void
1117 **
1118 *******************************************************************************/
BTM_SetDefaultLinkPolicy(UINT16 settings)1119 void BTM_SetDefaultLinkPolicy (UINT16 settings)
1120 {
1121 UINT8 *localFeatures = BTM_ReadLocalFeatures();
1122
1123 BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy setting:0x%04x", settings);
1124
1125 if((settings & HCI_ENABLE_MASTER_SLAVE_SWITCH) && (!HCI_SWITCH_SUPPORTED(localFeatures)))
1126 {
1127 settings &= ~HCI_ENABLE_MASTER_SLAVE_SWITCH;
1128 BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy switch not supported (settings: 0x%04x)", settings);
1129 }
1130 if ((settings & HCI_ENABLE_HOLD_MODE) && (!HCI_HOLD_MODE_SUPPORTED(localFeatures)))
1131 {
1132 settings &= ~HCI_ENABLE_HOLD_MODE;
1133 BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy hold not supported (settings: 0x%04x)", settings);
1134 }
1135 if ((settings & HCI_ENABLE_SNIFF_MODE) && (!HCI_SNIFF_MODE_SUPPORTED(localFeatures)))
1136 {
1137 settings &= ~HCI_ENABLE_SNIFF_MODE;
1138 BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy sniff not supported (settings: 0x%04x)", settings);
1139 }
1140 if ((settings & HCI_ENABLE_PARK_MODE) && (!HCI_PARK_MODE_SUPPORTED(localFeatures)))
1141 {
1142 settings &= ~HCI_ENABLE_PARK_MODE;
1143 BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy park not supported (settings: 0x%04x)", settings);
1144 }
1145 BTM_TRACE_DEBUG("Set DefaultLinkPolicy:0x%04x", settings);
1146
1147 btm_cb.btm_def_link_policy = settings;
1148
1149 /* Set the default Link Policy of the controller */
1150 btsnd_hcic_write_def_policy_set(settings);
1151 }
1152
1153
1154 /*******************************************************************************
1155 **
1156 ** Function BTM_ReadLinkPolicy
1157 **
1158 ** Description This function is called to read the link policy settings.
1159 ** The address of link policy results are returned in the callback.
1160 ** (tBTM_LNK_POLICY_RESULTS)
1161 **
1162 ** Returns status of the operation
1163 **
1164 *******************************************************************************/
BTM_ReadLinkPolicy(BD_ADDR remote_bda,tBTM_CMPL_CB * p_cb)1165 tBTM_STATUS BTM_ReadLinkPolicy (BD_ADDR remote_bda, tBTM_CMPL_CB *p_cb)
1166 {
1167 tACL_CONN *p;
1168
1169 BTM_TRACE_API ("BTM_ReadLinkPolicy: RemBdAddr: %02x%02x%02x%02x%02x%02x",
1170 remote_bda[0], remote_bda[1], remote_bda[2],
1171 remote_bda[3], remote_bda[4], remote_bda[5]);
1172
1173 /* If someone already waiting on the version, do not allow another */
1174 if (btm_cb.devcb.p_rlinkp_cmpl_cb)
1175 return(BTM_BUSY);
1176
1177 p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
1178 if (p != (tACL_CONN *)NULL)
1179 {
1180 btu_start_timer (&btm_cb.devcb.rlinkp_timer, BTU_TTYPE_BTM_ACL, BTM_DEV_REPLY_TIMEOUT);
1181 btm_cb.devcb.p_rlinkp_cmpl_cb = p_cb;
1182
1183 if (!btsnd_hcic_read_policy_set (p->hci_handle))
1184 {
1185 btu_stop_timer (&btm_cb.devcb.rlinkp_timer);
1186 btm_cb.devcb.p_rlinkp_cmpl_cb = NULL;
1187 return(BTM_NO_RESOURCES);
1188 }
1189
1190 return(BTM_CMD_STARTED);
1191 }
1192
1193 /* If here, no BD Addr found */
1194 return(BTM_UNKNOWN_ADDR);
1195 }
1196
1197
1198 /*******************************************************************************
1199 **
1200 ** Function btm_read_link_policy_complete
1201 **
1202 ** Description This function is called when the command complete message
1203 ** is received from the HCI for the read local link policy request.
1204 **
1205 ** Returns void
1206 **
1207 *******************************************************************************/
btm_read_link_policy_complete(UINT8 * p)1208 void btm_read_link_policy_complete (UINT8 *p)
1209 {
1210 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_rlinkp_cmpl_cb;
1211 tBTM_LNK_POLICY_RESULTS lnkpol;
1212 UINT16 handle;
1213 tACL_CONN *p_acl_cb = &btm_cb.acl_db[0];
1214 UINT16 index;
1215 BTM_TRACE_DEBUG ("btm_read_link_policy_complete");
1216 btu_stop_timer (&btm_cb.devcb.rlinkp_timer);
1217
1218 /* If there was a callback address for read local version, call it */
1219 btm_cb.devcb.p_rlinkp_cmpl_cb = NULL;
1220
1221 if (p_cb)
1222 {
1223 STREAM_TO_UINT8 (lnkpol.hci_status, p);
1224
1225 if (lnkpol.hci_status == HCI_SUCCESS)
1226 {
1227 lnkpol.status = BTM_SUCCESS;
1228
1229 STREAM_TO_UINT16 (handle, p);
1230
1231 STREAM_TO_UINT16 (lnkpol.settings, p);
1232
1233 /* Search through the list of active channels for the correct BD Addr */
1234 for (index = 0; index < MAX_L2CAP_LINKS; index++, p_acl_cb++)
1235 {
1236 if ((p_acl_cb->in_use) && (handle == p_acl_cb->hci_handle))
1237 {
1238 memcpy (lnkpol.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN);
1239 break;
1240 }
1241 }
1242 }
1243 else
1244 lnkpol.status = BTM_ERR_PROCESSING;
1245
1246 (*p_cb)(&lnkpol);
1247 }
1248 }
1249
1250
1251 /*******************************************************************************
1252 **
1253 ** Function btm_read_remote_version_complete
1254 **
1255 ** Description This function is called when the command complete message
1256 ** is received from the HCI for the remote version info.
1257 **
1258 ** Returns void
1259 **
1260 *******************************************************************************/
btm_read_remote_version_complete(UINT8 * p)1261 void btm_read_remote_version_complete (UINT8 *p)
1262 {
1263 tACL_CONN *p_acl_cb = &btm_cb.acl_db[0];
1264 UINT8 status;
1265 UINT16 handle;
1266 int xx;
1267 BTM_TRACE_DEBUG ("btm_read_remote_version_complete");
1268 STREAM_TO_UINT8 (status, p);
1269 if (status == HCI_SUCCESS)
1270 {
1271 STREAM_TO_UINT16 (handle, p);
1272
1273 /* Look up the connection by handle and copy features */
1274 for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p_acl_cb++)
1275 {
1276 if ((p_acl_cb->in_use) && (p_acl_cb->hci_handle == handle))
1277 {
1278 STREAM_TO_UINT8 (p_acl_cb->lmp_version, p);
1279 STREAM_TO_UINT16 (p_acl_cb->manufacturer, p);
1280 STREAM_TO_UINT16 (p_acl_cb->lmp_subversion, p);
1281 break;
1282 }
1283 }
1284 }
1285 }
1286
1287
1288 /*******************************************************************************
1289 **
1290 ** Function btm_process_remote_ext_features
1291 **
1292 ** Description Local function called to process all extended features pages
1293 ** read from a remote device.
1294 **
1295 ** Returns void
1296 **
1297 *******************************************************************************/
btm_process_remote_ext_features(tACL_CONN * p_acl_cb,UINT8 num_read_pages)1298 void btm_process_remote_ext_features (tACL_CONN *p_acl_cb, UINT8 num_read_pages)
1299 {
1300 UINT16 handle = p_acl_cb->hci_handle;
1301 tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev_by_handle (handle);
1302 UINT8 page_idx;
1303
1304 BTM_TRACE_DEBUG ("btm_process_remote_ext_features");
1305
1306 /* Make sure we have the record to save remote features information */
1307 if (p_dev_rec == NULL)
1308 {
1309 /* Get a new device; might be doing dedicated bonding */
1310 p_dev_rec = btm_find_or_alloc_dev (p_acl_cb->remote_addr);
1311 }
1312
1313 p_acl_cb->num_read_pages = num_read_pages;
1314 p_dev_rec->num_read_pages = num_read_pages;
1315
1316 /* Process the pages one by one */
1317 for (page_idx = 0; page_idx < num_read_pages; page_idx++)
1318 {
1319 btm_process_remote_ext_features_page (p_acl_cb, p_dev_rec, page_idx);
1320 }
1321 }
1322
1323
1324 /*******************************************************************************
1325 **
1326 ** Function btm_process_remote_ext_features_page
1327 **
1328 ** Description Local function called to process the information located
1329 ** in the specific extended features page read from a remote device.
1330 **
1331 ** Returns void
1332 **
1333 *******************************************************************************/
btm_process_remote_ext_features_page(tACL_CONN * p_acl_cb,tBTM_SEC_DEV_REC * p_dev_rec,UINT8 page_idx)1334 void btm_process_remote_ext_features_page (tACL_CONN *p_acl_cb, tBTM_SEC_DEV_REC *p_dev_rec,
1335 UINT8 page_idx)
1336 {
1337 UINT16 handle;
1338 UINT8 req_pend;
1339
1340 handle = p_acl_cb->hci_handle;
1341
1342 memcpy (p_dev_rec->features[page_idx], p_acl_cb->peer_lmp_features[page_idx],
1343 HCI_FEATURE_BYTES_PER_PAGE);
1344
1345 switch (page_idx)
1346 {
1347 /* Extended (Legacy) Page 0 */
1348 case HCI_EXT_FEATURES_PAGE_0:
1349 /* Page 0 indicates Controller support for SSP */
1350 if (btm_cb.security_mode < BTM_SEC_MODE_SP ||
1351 !HCI_SIMPLE_PAIRING_SUPPORTED(p_dev_rec->features[HCI_EXT_FEATURES_PAGE_0]))
1352 {
1353 req_pend = (p_dev_rec->sm4 & BTM_SM4_REQ_PEND);
1354 p_dev_rec->sm4 = BTM_SM4_KNOWN;
1355 if (req_pend)
1356 {
1357 l2cu_resubmit_pending_sec_req (p_dev_rec->bd_addr);
1358 }
1359 }
1360 break;
1361
1362 /* Extended Page 1 */
1363 case HCI_EXT_FEATURES_PAGE_1:
1364 /* Page 1 indicates Host support for SSP and SC */
1365 req_pend = (p_dev_rec->sm4 & BTM_SM4_REQ_PEND);
1366
1367 if (btm_cb.security_mode == BTM_SEC_MODE_SP
1368 && HCI_SSP_HOST_SUPPORTED(p_dev_rec->features[HCI_EXT_FEATURES_PAGE_1])
1369 && HCI_SIMPLE_PAIRING_SUPPORTED(p_dev_rec->features[HCI_EXT_FEATURES_PAGE_0]))
1370 {
1371 p_dev_rec->sm4 = BTM_SM4_TRUE;
1372 }
1373 else
1374 {
1375 p_dev_rec->sm4 = BTM_SM4_KNOWN;
1376 }
1377
1378 BTM_TRACE_API ("ext_features_complt page_num:%d f[0]:x%02x, sm4:%x, pend:%d",
1379 HCI_EXT_FEATURES_PAGE_1, *(p_dev_rec->features[HCI_EXT_FEATURES_PAGE_1]),
1380 p_dev_rec->sm4, req_pend);
1381
1382 if (req_pend)
1383 l2cu_resubmit_pending_sec_req (p_dev_rec->bd_addr);
1384
1385 break;
1386
1387 /* Extended Page 2 */
1388 case HCI_EXT_FEATURES_PAGE_2:
1389 /* Page 2 indicates Ping support*/
1390 break;
1391
1392 default:
1393 BTM_TRACE_ERROR("btm_process_remote_ext_features_page page=%d unexpected", page_idx);
1394 break;
1395 }
1396 }
1397
1398
1399 /*******************************************************************************
1400 **
1401 ** Function btm_read_remote_features
1402 **
1403 ** Description Local function called to send a read remote supported features/
1404 ** remote extended features page[0].
1405 **
1406 ** Returns void
1407 **
1408 *******************************************************************************/
btm_read_remote_features(UINT16 handle)1409 void btm_read_remote_features (UINT16 handle)
1410 {
1411 UINT8 acl_idx;
1412 tACL_CONN *p_acl_cb;
1413
1414 BTM_TRACE_DEBUG("btm_read_remote_features() handle: %d", handle);
1415
1416 if ((acl_idx = btm_handle_to_acl_index(handle)) >= MAX_L2CAP_LINKS)
1417 {
1418 BTM_TRACE_ERROR("btm_read_remote_features handle=%d invalid", handle);
1419 return;
1420 }
1421
1422 p_acl_cb = &btm_cb.acl_db[acl_idx];
1423 p_acl_cb->num_read_pages = 0;
1424 memset (p_acl_cb->peer_lmp_features, 0, sizeof(p_acl_cb->peer_lmp_features));
1425
1426 /* first send read remote supported features HCI command */
1427 /* because we don't know whether the remote support extended feature command */
1428 btsnd_hcic_rmt_features_req (handle);
1429 }
1430
1431
1432 /*******************************************************************************
1433 **
1434 ** Function btm_read_remote_ext_features
1435 **
1436 ** Description Local function called to send a read remote extended features
1437 **
1438 ** Returns void
1439 **
1440 *******************************************************************************/
btm_read_remote_ext_features(UINT16 handle,UINT8 page_number)1441 void btm_read_remote_ext_features (UINT16 handle, UINT8 page_number)
1442 {
1443 BTM_TRACE_DEBUG("btm_read_remote_ext_features() handle: %d page: %d", handle, page_number);
1444
1445 btsnd_hcic_rmt_ext_features(handle, page_number);
1446 }
1447
1448
1449 /*******************************************************************************
1450 **
1451 ** Function btm_read_remote_features_complete
1452 **
1453 ** Description This function is called when the remote supported features
1454 ** complete event is received from the HCI.
1455 **
1456 ** Returns void
1457 **
1458 *******************************************************************************/
btm_read_remote_features_complete(UINT8 * p)1459 void btm_read_remote_features_complete (UINT8 *p)
1460 {
1461 tACL_CONN *p_acl_cb;
1462 UINT8 status;
1463 UINT16 handle;
1464 UINT8 acl_idx;
1465
1466 BTM_TRACE_DEBUG ("btm_read_remote_features_complete");
1467 STREAM_TO_UINT8 (status, p);
1468
1469 if (status != HCI_SUCCESS)
1470 {
1471 BTM_TRACE_ERROR ("btm_read_remote_features_complete failed (status 0x%02x)", status);
1472 return;
1473 }
1474
1475 STREAM_TO_UINT16 (handle, p);
1476
1477 if ((acl_idx = btm_handle_to_acl_index(handle)) >= MAX_L2CAP_LINKS)
1478 {
1479 BTM_TRACE_ERROR("btm_read_remote_features_complete handle=%d invalid", handle);
1480 return;
1481 }
1482
1483 p_acl_cb = &btm_cb.acl_db[acl_idx];
1484
1485 /* Copy the received features page */
1486 STREAM_TO_ARRAY(p_acl_cb->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0], p,
1487 HCI_FEATURE_BYTES_PER_PAGE);
1488
1489 if ((HCI_LMP_EXTENDED_SUPPORTED(p_acl_cb->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) &&
1490 (HCI_READ_REMOTE_EXT_FEATURES_SUPPORTED(btm_cb.devcb.supported_cmds)))
1491 {
1492 /* if the remote controller has extended features and local controller supports
1493 ** HCI_Read_Remote_Extended_Features command then start reading these feature starting
1494 ** with extended features page 1 */
1495 BTM_TRACE_DEBUG ("Start reading remote extended features");
1496 btm_read_remote_ext_features(handle, HCI_EXT_FEATURES_PAGE_1);
1497 return;
1498 }
1499
1500 /* Remote controller has no extended features. Process remote controller supported features
1501 (features page HCI_EXT_FEATURES_PAGE_0). */
1502 btm_process_remote_ext_features (p_acl_cb, 1);
1503
1504 /* Continue with HCI connection establishment */
1505 btm_establish_continue (p_acl_cb);
1506 }
1507
1508 /*******************************************************************************
1509 **
1510 ** Function btm_read_remote_ext_features_complete
1511 **
1512 ** Description This function is called when the remote extended features
1513 ** complete event is received from the HCI.
1514 **
1515 ** Returns void
1516 **
1517 *******************************************************************************/
btm_read_remote_ext_features_complete(UINT8 * p)1518 void btm_read_remote_ext_features_complete (UINT8 *p)
1519 {
1520 tACL_CONN *p_acl_cb;
1521 UINT8 status, page_num, max_page;
1522 UINT16 handle;
1523 UINT8 acl_idx;
1524
1525 BTM_TRACE_DEBUG ("btm_read_remote_ext_features_complete");
1526
1527 STREAM_TO_UINT8 (status, p);
1528 STREAM_TO_UINT16 (handle, p);
1529 STREAM_TO_UINT8 (page_num, p);
1530 STREAM_TO_UINT8 (max_page, p);
1531
1532 /* Validate parameters */
1533 if ((acl_idx = btm_handle_to_acl_index(handle)) >= MAX_L2CAP_LINKS)
1534 {
1535 BTM_TRACE_ERROR("btm_read_remote_ext_features_complete handle=%d invalid", handle);
1536 return;
1537 }
1538
1539 if (max_page > HCI_EXT_FEATURES_PAGE_MAX)
1540 {
1541 BTM_TRACE_ERROR("btm_read_remote_ext_features_complete page=%d unknown", max_page);
1542 return;
1543 }
1544
1545 p_acl_cb = &btm_cb.acl_db[acl_idx];
1546
1547 /* Copy the received features page */
1548 STREAM_TO_ARRAY(p_acl_cb->peer_lmp_features[page_num], p, HCI_FEATURE_BYTES_PER_PAGE);
1549
1550 /* If there is the next remote features page and
1551 * we have space to keep this page data - read this page */
1552 if ((page_num < max_page) && (page_num < HCI_EXT_FEATURES_PAGE_MAX))
1553 {
1554 page_num++;
1555 BTM_TRACE_DEBUG("BTM reads next remote extended features page (%d)", page_num);
1556 btm_read_remote_ext_features (handle, page_num);
1557 return;
1558 }
1559
1560 /* Reading of remote feature pages is complete */
1561 BTM_TRACE_DEBUG("BTM reached last remote extended features page (%d)", page_num);
1562
1563 /* Process the pages */
1564 btm_process_remote_ext_features (p_acl_cb, (UINT8) (page_num + 1));
1565
1566 /* Continue with HCI connection establishment */
1567 btm_establish_continue (p_acl_cb);
1568 }
1569
1570 /*******************************************************************************
1571 **
1572 ** Function btm_read_remote_ext_features_failed
1573 **
1574 ** Description This function is called when the remote extended features
1575 ** complete event returns a failed status.
1576 **
1577 ** Returns void
1578 **
1579 *******************************************************************************/
btm_read_remote_ext_features_failed(UINT8 status,UINT16 handle)1580 void btm_read_remote_ext_features_failed (UINT8 status, UINT16 handle)
1581 {
1582 tACL_CONN *p_acl_cb;
1583 UINT8 acl_idx;
1584
1585 BTM_TRACE_WARNING ("btm_read_remote_ext_features_failed (status 0x%02x) for handle %d",
1586 status, handle);
1587
1588 if ((acl_idx = btm_handle_to_acl_index(handle)) >= MAX_L2CAP_LINKS)
1589 {
1590 BTM_TRACE_ERROR("btm_read_remote_ext_features_failed handle=%d invalid", handle);
1591 return;
1592 }
1593
1594 p_acl_cb = &btm_cb.acl_db[acl_idx];
1595
1596 /* Process supported features only */
1597 btm_process_remote_ext_features (p_acl_cb, 1);
1598
1599 /* Continue HCI connection establishment */
1600 btm_establish_continue (p_acl_cb);
1601 }
1602
1603 /*******************************************************************************
1604 **
1605 ** Function btm_establish_continue
1606 **
1607 ** Description This function is called when the command complete message
1608 ** is received from the HCI for the read local link policy request.
1609 **
1610 ** Returns void
1611 **
1612 *******************************************************************************/
btm_establish_continue(tACL_CONN * p_acl_cb)1613 void btm_establish_continue (tACL_CONN *p_acl_cb)
1614 {
1615 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
1616 tBTM_BL_EVENT_DATA evt_data;
1617 #endif
1618 BTM_TRACE_DEBUG ("btm_establish_continue");
1619 #if (!defined(BTM_BYPASS_EXTRA_ACL_SETUP) || BTM_BYPASS_EXTRA_ACL_SETUP == FALSE)
1620 #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE)
1621 if (p_acl_cb->transport == BT_TRANSPORT_BR_EDR)
1622 #endif
1623 {
1624 /* For now there are a some devices that do not like sending */
1625 /* commands events and data at the same time. */
1626 /* Set the packet types to the default allowed by the device */
1627 btm_set_packet_types (p_acl_cb, btm_cb.btm_acl_pkt_types_supported);
1628
1629 if (btm_cb.btm_def_link_policy)
1630 BTM_SetLinkPolicy (p_acl_cb->remote_addr, &btm_cb.btm_def_link_policy);
1631 }
1632 #endif
1633 p_acl_cb->link_up_issued = TRUE;
1634
1635 /* If anyone cares, tell him database changed */
1636 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
1637 if (btm_cb.p_bl_changed_cb)
1638 {
1639 evt_data.event = BTM_BL_CONN_EVT;
1640 evt_data.conn.p_bda = p_acl_cb->remote_addr;
1641 evt_data.conn.p_bdn = p_acl_cb->remote_name;
1642 evt_data.conn.p_dc = p_acl_cb->remote_dc;
1643 evt_data.conn.p_features = p_acl_cb->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0];
1644 #if BLE_INCLUDED == TRUE
1645 evt_data.conn.handle = p_acl_cb->hci_handle;
1646 evt_data.conn.transport = p_acl_cb->transport;
1647 #endif
1648
1649 (*btm_cb.p_bl_changed_cb)(&evt_data);
1650 }
1651 btm_acl_update_busy_level (BTM_BLI_ACL_UP_EVT);
1652 #else
1653 if (btm_cb.p_acl_changed_cb)
1654 #if BLE_INCLUDED == TRUE
1655 (*btm_cb.p_acl_changed_cb) (p_acl_cb->remote_addr,
1656 p_acl_cb->remote_dc,
1657 p_acl_cb->remote_name,
1658 p_acl_cb->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0],
1659 TRUE,
1660 p_acl_cb->hci_handle,
1661 p_acl_cb->transport);
1662 #else
1663 (*btm_cb.p_acl_changed_cb) (p_acl_cb->remote_addr,
1664 p_acl_cb->remote_dc,
1665 p_acl_cb->remote_name,
1666 p_acl_cb->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0],
1667 TRUE);
1668 #endif
1669
1670 #endif
1671
1672 }
1673
1674
1675 /*******************************************************************************
1676 **
1677 ** Function BTM_SetDefaultLinkSuperTout
1678 **
1679 ** Description Set the default value for HCI "Write Link Supervision Timeout"
1680 ** command to use when an ACL link is created.
1681 **
1682 ** Returns void
1683 **
1684 *******************************************************************************/
BTM_SetDefaultLinkSuperTout(UINT16 timeout)1685 void BTM_SetDefaultLinkSuperTout (UINT16 timeout)
1686 {
1687 BTM_TRACE_DEBUG ("BTM_SetDefaultLinkSuperTout");
1688 btm_cb.btm_def_link_super_tout = timeout;
1689 }
1690
1691 /*******************************************************************************
1692 **
1693 ** Function BTM_GetLinkSuperTout
1694 **
1695 ** Description Read the link supervision timeout value of the connection
1696 **
1697 ** Returns status of the operation
1698 **
1699 *******************************************************************************/
BTM_GetLinkSuperTout(BD_ADDR remote_bda,UINT16 * p_timeout)1700 tBTM_STATUS BTM_GetLinkSuperTout (BD_ADDR remote_bda, UINT16 *p_timeout)
1701 {
1702 tACL_CONN *p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
1703
1704 BTM_TRACE_DEBUG ("BTM_GetLinkSuperTout");
1705 if (p != (tACL_CONN *)NULL)
1706 {
1707 *p_timeout = p->link_super_tout;
1708 return(BTM_SUCCESS);
1709 }
1710 /* If here, no BD Addr found */
1711 return(BTM_UNKNOWN_ADDR);
1712 }
1713
1714
1715 /*******************************************************************************
1716 **
1717 ** Function BTM_SetLinkSuperTout
1718 **
1719 ** Description Create and send HCI "Write Link Supervision Timeout" command
1720 **
1721 ** Returns status of the operation
1722 **
1723 *******************************************************************************/
BTM_SetLinkSuperTout(BD_ADDR remote_bda,UINT16 timeout)1724 tBTM_STATUS BTM_SetLinkSuperTout (BD_ADDR remote_bda, UINT16 timeout)
1725 {
1726 tACL_CONN *p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
1727
1728 BTM_TRACE_DEBUG ("BTM_SetLinkSuperTout");
1729 if (p != (tACL_CONN *)NULL)
1730 {
1731 p->link_super_tout = timeout;
1732
1733 /* Only send if current role is Master; 2.0 spec requires this */
1734 if (p->link_role == BTM_ROLE_MASTER)
1735 {
1736 if (!btsnd_hcic_write_link_super_tout (LOCAL_BR_EDR_CONTROLLER_ID,
1737 p->hci_handle, timeout))
1738 return(BTM_NO_RESOURCES);
1739
1740 return(BTM_CMD_STARTED);
1741 }
1742 else
1743 return(BTM_SUCCESS);
1744 }
1745
1746 /* If here, no BD Addr found */
1747 return(BTM_UNKNOWN_ADDR);
1748 }
1749
1750 /*******************************************************************************
1751 **
1752 ** Function BTM_RegForLstoEvt
1753 **
1754 ** Description register for the HCI "Link Supervision Timeout Change" event
1755 **
1756 ** Returns void
1757 **
1758 *******************************************************************************/
BTM_RegForLstoEvt(tBTM_LSTO_CBACK * p_cback)1759 void BTM_RegForLstoEvt (tBTM_LSTO_CBACK *p_cback)
1760 {
1761 BTM_TRACE_DEBUG ("BTM_RegForLstoEvt");
1762 btm_cb.p_lsto_cback = p_cback;
1763 }
1764
1765 /*******************************************************************************
1766 **
1767 ** Function btm_proc_lsto_evt
1768 **
1769 ** Description process the HCI "Link Supervision Timeout Change" event
1770 **
1771 ** Returns void
1772 **
1773 *******************************************************************************/
btm_proc_lsto_evt(UINT16 handle,UINT16 timeout)1774 void btm_proc_lsto_evt(UINT16 handle, UINT16 timeout)
1775 {
1776 UINT8 xx;
1777
1778 BTM_TRACE_DEBUG ("btm_proc_lsto_evt");
1779 if (btm_cb.p_lsto_cback)
1780 {
1781 /* Look up the connection by handle and set the current mode */
1782 xx = btm_handle_to_acl_index(handle);
1783
1784 /* don't assume that we can never get a bad hci_handle */
1785 if (xx < MAX_L2CAP_LINKS)
1786 {
1787 (*btm_cb.p_lsto_cback)(btm_cb.acl_db[xx].remote_addr, timeout);
1788 }
1789 }
1790 }
1791
1792 #if BTM_PWR_MGR_INCLUDED == FALSE
1793 /*******************************************************************************
1794 **
1795 ** Function BTM_SetHoldMode
1796 **
1797 ** Description This function is called to set a connection into hold mode.
1798 ** A check is made if the connection is in sniff or park mode,
1799 ** and if yes, the hold mode is ignored.
1800 **
1801 ** Returns status of the operation
1802 **
1803 *******************************************************************************/
BTM_SetHoldMode(BD_ADDR remote_bda,UINT16 min_interval,UINT16 max_interval)1804 tBTM_STATUS BTM_SetHoldMode (BD_ADDR remote_bda, UINT16 min_interval, UINT16 max_interval)
1805 {
1806 tACL_CONN *p;
1807
1808 BTM_TRACE_DEBUG ("BTM_SetHoldMode");
1809 /* First, check if hold mode is supported */
1810 if (!HCI_HOLD_MODE_SUPPORTED(BTM_ReadLocalFeatures()))
1811 return(BTM_MODE_UNSUPPORTED);
1812
1813 p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
1814 if (p != (tACL_CONN *)NULL)
1815 {
1816 /* If the connection is in park or sniff mode, forget about holding it */
1817 if (p->mode != BTM_ACL_MODE_NORMAL)
1818 return(BTM_SUCCESS);
1819
1820 if (!btsnd_hcic_hold_mode (p->hci_handle, max_interval, min_interval))
1821 return(BTM_NO_RESOURCES);
1822
1823 return(BTM_CMD_STARTED);
1824 }
1825
1826 /* If here, no BD Addr found */
1827 return(BTM_UNKNOWN_ADDR);
1828 }
1829
1830
1831 /*******************************************************************************
1832 **
1833 ** Function BTM_SetSniffMode
1834 **
1835 ** Description This function is called to set a connection into sniff mode.
1836 ** A check is made if the connection is already in sniff or park
1837 ** mode, and if yes, the sniff mode is ignored.
1838 **
1839 ** Returns status of the operation
1840 **
1841 *******************************************************************************/
BTM_SetSniffMode(BD_ADDR remote_bda,UINT16 min_period,UINT16 max_period,UINT16 attempt,UINT16 timeout)1842 tBTM_STATUS BTM_SetSniffMode (BD_ADDR remote_bda, UINT16 min_period, UINT16 max_period,
1843 UINT16 attempt, UINT16 timeout)
1844 {
1845 tACL_CONN *p;
1846 BTM_TRACE_DEBUG ("BTM_SetSniffMode");
1847 /* First, check if sniff mode is supported */
1848 if (!HCI_SNIFF_MODE_SUPPORTED(BTM_ReadLocalFeatures()))
1849 return(BTM_MODE_UNSUPPORTED);
1850
1851 p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
1852 if (p != (tACL_CONN *)NULL)
1853 {
1854 /* If the connection is in park mode, forget about sniffing it */
1855 if (p->mode != BTM_ACL_MODE_NORMAL)
1856 return(BTM_WRONG_MODE);
1857
1858 if (!btsnd_hcic_sniff_mode (p->hci_handle, max_period,
1859 min_period, attempt, timeout))
1860 return(BTM_NO_RESOURCES);
1861
1862 return(BTM_CMD_STARTED);
1863 }
1864
1865 /* If here, no BD Addr found */
1866 return(BTM_UNKNOWN_ADDR);
1867 }
1868
1869
1870
1871
1872 /*******************************************************************************
1873 **
1874 ** Function BTM_CancelSniffMode
1875 **
1876 ** Description This function is called to put a connection out of sniff mode.
1877 ** A check is made if the connection is already in sniff mode,
1878 ** and if not, the cancel sniff mode is ignored.
1879 **
1880 ** Returns status of the operation
1881 **
1882 *******************************************************************************/
BTM_CancelSniffMode(BD_ADDR remote_bda)1883 tBTM_STATUS BTM_CancelSniffMode (BD_ADDR remote_bda)
1884 {
1885 tACL_CONN *p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
1886 BTM_TRACE_DEBUG ("BTM_CancelSniffMode ");
1887 if (p == (tACL_CONN *)NULL)
1888 return(BTM_UNKNOWN_ADDR);
1889
1890 /* If the connection is not in sniff mode, cannot cancel */
1891 if (p->mode != BTM_ACL_MODE_SNIFF)
1892 return(BTM_WRONG_MODE);
1893
1894 if (!btsnd_hcic_exit_sniff_mode (p->hci_handle))
1895 return(BTM_NO_RESOURCES);
1896
1897 return(BTM_CMD_STARTED);
1898 }
1899
1900
1901 /*******************************************************************************
1902 **
1903 ** Function BTM_SetParkMode
1904 **
1905 ** Description This function is called to set a connection into park mode.
1906 ** A check is made if the connection is already in sniff or park
1907 ** mode, and if yes, the park mode is ignored.
1908 **
1909 ** Returns status of the operation
1910 **
1911 *******************************************************************************/
BTM_SetParkMode(BD_ADDR remote_bda,UINT16 beacon_min_period,UINT16 beacon_max_period)1912 tBTM_STATUS BTM_SetParkMode (BD_ADDR remote_bda, UINT16 beacon_min_period, UINT16 beacon_max_period)
1913 {
1914 tACL_CONN *p;
1915
1916 BTM_TRACE_DEBUG ("BTM_SetParkMode");
1917 /* First, check if park mode is supported */
1918 if (!HCI_PARK_MODE_SUPPORTED(BTM_ReadLocalFeatures()))
1919 return(BTM_MODE_UNSUPPORTED);
1920
1921 p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
1922 if (p != (tACL_CONN *)NULL)
1923 {
1924 /* If the connection is in sniff mode, forget about parking it */
1925 if (p->mode != BTM_ACL_MODE_NORMAL)
1926 return(BTM_WRONG_MODE);
1927
1928 /* no park mode if SCO exists -- CR#1982, 1.1 errata 1124
1929 command status event should be returned /w error code 0x0C "Command Disallowed"
1930 Let LM do this.
1931 */
1932 if (!btsnd_hcic_park_mode (p->hci_handle,
1933 beacon_max_period, beacon_min_period))
1934 return(BTM_NO_RESOURCES);
1935
1936 return(BTM_CMD_STARTED);
1937 }
1938
1939 /* If here, no BD Addr found */
1940 return(BTM_UNKNOWN_ADDR);
1941 }
1942
1943 /*******************************************************************************
1944 **
1945 ** Function BTM_CancelParkMode
1946 **
1947 ** Description This function is called to put a connection out of park mode.
1948 ** A check is made if the connection is already in park mode,
1949 ** and if not, the cancel sniff mode is ignored.
1950 **
1951 ** Returns status of the operation
1952 **
1953 *******************************************************************************/
BTM_CancelParkMode(BD_ADDR remote_bda)1954 tBTM_STATUS BTM_CancelParkMode (BD_ADDR remote_bda)
1955 {
1956 tACL_CONN *p;
1957
1958 BTM_TRACE_DEBUG ("BTM_CancelParkMode");
1959 p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
1960 if (p != (tACL_CONN *)NULL)
1961 {
1962 /* If the connection is not in park mode, cannot cancel */
1963 if (p->mode != BTM_ACL_MODE_PARK)
1964 return(BTM_WRONG_MODE);
1965
1966 if (!btsnd_hcic_exit_park_mode (p->hci_handle))
1967 return(BTM_NO_RESOURCES);
1968
1969 return(BTM_CMD_STARTED);
1970 }
1971
1972 /* If here, no BD Addr found */
1973 return(BTM_UNKNOWN_ADDR);
1974 }
1975 #endif /* BTM_PWR_MGR_INCLUDED == FALSE */
1976
1977
1978 /*******************************************************************************
1979 **
1980 ** Function BTM_SetPacketTypes
1981 **
1982 ** Description This function is set the packet types used for a specific
1983 ** ACL connection,
1984 **
1985 ** Returns status of the operation
1986 **
1987 *******************************************************************************/
BTM_SetPacketTypes(BD_ADDR remote_bda,UINT16 pkt_types)1988 tBTM_STATUS BTM_SetPacketTypes (BD_ADDR remote_bda, UINT16 pkt_types)
1989 {
1990 tACL_CONN *p;
1991 BTM_TRACE_DEBUG ("BTM_SetPacketTypes");
1992
1993 if ((p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR)) != NULL)
1994 return(btm_set_packet_types (p, pkt_types));
1995
1996 /* If here, no BD Addr found */
1997 return(BTM_UNKNOWN_ADDR);
1998 }
1999
2000
2001 /*******************************************************************************
2002 **
2003 ** Function BTM_ReadPacketTypes
2004 **
2005 ** Description This function is set the packet types used for a specific
2006 ** ACL connection,
2007 **
2008 ** Returns packet types supported for the connection, or 0 if no BD address
2009 **
2010 *******************************************************************************/
BTM_ReadPacketTypes(BD_ADDR remote_bda)2011 UINT16 BTM_ReadPacketTypes (BD_ADDR remote_bda)
2012 {
2013 tACL_CONN *p;
2014
2015 BTM_TRACE_DEBUG ("BTM_ReadPacketTypes");
2016 p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
2017 if (p != (tACL_CONN *)NULL)
2018 {
2019 return(p->pkt_types_mask);
2020 }
2021
2022 /* If here, no BD Addr found */
2023 return(0);
2024 }
2025
2026
2027 /*******************************************************************************
2028 **
2029 ** Function BTM_ReadAclMode
2030 **
2031 ** Description This returns the current mode for a specific
2032 ** ACL connection.
2033 **
2034 ** Input Param remote_bda - device address of desired ACL connection
2035 **
2036 ** Output Param p_mode - address where the current mode is copied into.
2037 ** BTM_ACL_MODE_NORMAL
2038 ** BTM_ACL_MODE_HOLD
2039 ** BTM_ACL_MODE_SNIFF
2040 ** BTM_ACL_MODE_PARK
2041 ** (valid only if return code is BTM_SUCCESS)
2042 **
2043 ** Returns BTM_SUCCESS if successful,
2044 ** BTM_UNKNOWN_ADDR if bd addr is not active or bad
2045 **
2046 *******************************************************************************/
2047 #if BTM_PWR_MGR_INCLUDED == FALSE
BTM_ReadAclMode(BD_ADDR remote_bda,UINT8 * p_mode)2048 tBTM_STATUS BTM_ReadAclMode (BD_ADDR remote_bda, UINT8 *p_mode)
2049 {
2050 tACL_CONN *p;
2051
2052 BTM_TRACE_API ("BTM_ReadAclMode: RemBdAddr: %02x%02x%02x%02x%02x%02x",
2053 remote_bda[0], remote_bda[1], remote_bda[2],
2054 remote_bda[3], remote_bda[4], remote_bda[5]);
2055
2056 p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
2057 if (p != (tACL_CONN *)NULL)
2058 {
2059 *p_mode = p->mode;
2060 return(BTM_SUCCESS);
2061 }
2062
2063 /* If here, no BD Addr found */
2064 return(BTM_UNKNOWN_ADDR);
2065 }
2066 #endif /* BTM_PWR_MGR_INCLUDED == FALSE */
2067
2068 /*******************************************************************************
2069 **
2070 ** Function BTM_ReadClockOffset
2071 **
2072 ** Description This returns the clock offset for a specific
2073 ** ACL connection.
2074 **
2075 ** Input Param remote_bda - device address of desired ACL connection
2076 **
2077 ** Returns clock-offset or 0 if unknown
2078 **
2079 *******************************************************************************/
BTM_ReadClockOffset(BD_ADDR remote_bda)2080 UINT16 BTM_ReadClockOffset (BD_ADDR remote_bda)
2081 {
2082 tACL_CONN *p;
2083
2084 BTM_TRACE_API ("BTM_ReadClockOffset: RemBdAddr: %02x%02x%02x%02x%02x%02x",
2085 remote_bda[0], remote_bda[1], remote_bda[2],
2086 remote_bda[3], remote_bda[4], remote_bda[5]);
2087
2088 if ( (p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR)) != NULL)
2089 return(p->clock_offset);
2090
2091 /* If here, no BD Addr found */
2092 return(0);
2093 }
2094
2095 /*******************************************************************************
2096 **
2097 ** Function BTM_IsAclConnectionUp
2098 **
2099 ** Description This function is called to check if an ACL connection exists
2100 ** to a specific remote BD Address.
2101 **
2102 ** Returns TRUE if connection is up, else FALSE.
2103 **
2104 *******************************************************************************/
BTM_IsAclConnectionUp(BD_ADDR remote_bda,tBT_TRANSPORT transport)2105 BOOLEAN BTM_IsAclConnectionUp (BD_ADDR remote_bda, tBT_TRANSPORT transport)
2106 {
2107 tACL_CONN *p;
2108
2109 BTM_TRACE_API ("BTM_IsAclConnectionUp: RemBdAddr: %02x%02x%02x%02x%02x%02x",
2110 remote_bda[0], remote_bda[1], remote_bda[2],
2111 remote_bda[3], remote_bda[4], remote_bda[5]);
2112
2113 p = btm_bda_to_acl(remote_bda, transport);
2114 if (p != (tACL_CONN *)NULL)
2115 {
2116 return(TRUE);
2117 }
2118
2119 /* If here, no BD Addr found */
2120 return(FALSE);
2121 }
2122
2123 /*******************************************************************************
2124 **
2125 ** Function BTM_GetNumAclLinks
2126 **
2127 ** Description This function is called to count the number of
2128 ** ACL links that are active.
2129 **
2130 ** Returns UINT16 Number of active ACL links
2131 **
2132 *******************************************************************************/
BTM_GetNumAclLinks(void)2133 UINT16 BTM_GetNumAclLinks (void)
2134 {
2135 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
2136 return(UINT16)btm_cb.num_acl;
2137 #else
2138 tACL_CONN *p = &btm_cb.acl_db[0];
2139 UINT16 xx, yy;
2140 BTM_TRACE_DEBUG ("BTM_GetNumAclLinks");
2141 for (xx = yy = 0; xx < MAX_L2CAP_LINKS; xx++, p++)
2142 {
2143 if (p->in_use)
2144 yy++;
2145 }
2146
2147 return(yy);
2148 #endif
2149 }
2150
2151 /*******************************************************************************
2152 **
2153 ** Function BTM_GetNumLeLinks
2154 **
2155 ** Description This function is called to count the number of
2156 ** LE ACL links that are active.
2157 **
2158 ** Returns UINT16 Number of active LE links
2159 **
2160 *******************************************************************************/
BTM_GetNumLeLinks(void)2161 UINT16 BTM_GetNumLeLinks (void)
2162 {
2163 UINT16 yy = 0;
2164
2165 #if BLE_INCLUDED == TRUE
2166 tACL_CONN *p = &btm_cb.acl_db[0];
2167 UINT16 xx;
2168 BTM_TRACE_DEBUG ("BTM_GetNumLeLinks");
2169 for (xx = yy = 0; xx < MAX_L2CAP_LINKS; xx++, p++)
2170 {
2171 if ((p->in_use) &&(p->transport == BT_TRANSPORT_LE))
2172 yy++;
2173 }
2174 #endif
2175
2176 return(yy);
2177 }
2178
2179 /*******************************************************************************
2180 **
2181 ** Function btm_get_acl_disc_reason_code
2182 **
2183 ** Description This function is called to get the disconnection reason code
2184 ** returned by the HCI at disconnection complete event.
2185 **
2186 ** Returns TRUE if connection is up, else FALSE.
2187 **
2188 *******************************************************************************/
btm_get_acl_disc_reason_code(void)2189 UINT16 btm_get_acl_disc_reason_code (void)
2190 {
2191 UINT8 res = btm_cb.acl_disc_reason;
2192 BTM_TRACE_DEBUG ("btm_get_acl_disc_reason_code");
2193 return(res);
2194 }
2195
2196
2197 /*******************************************************************************
2198 **
2199 ** Function BTM_GetHCIConnHandle
2200 **
2201 ** Description This function is called to get the handle for an ACL connection
2202 ** to a specific remote BD Address.
2203 **
2204 ** Returns the handle of the connection, or 0xFFFF if none.
2205 **
2206 *******************************************************************************/
BTM_GetHCIConnHandle(BD_ADDR remote_bda,tBT_TRANSPORT transport)2207 UINT16 BTM_GetHCIConnHandle (BD_ADDR remote_bda, tBT_TRANSPORT transport)
2208 {
2209 tACL_CONN *p;
2210 BTM_TRACE_DEBUG ("BTM_GetHCIConnHandle");
2211 p = btm_bda_to_acl(remote_bda, transport);
2212 if (p != (tACL_CONN *)NULL)
2213 {
2214 return(p->hci_handle);
2215 }
2216
2217 /* If here, no BD Addr found */
2218 return(0xFFFF);
2219 }
2220
2221 #if BTM_PWR_MGR_INCLUDED == FALSE
2222 /*******************************************************************************
2223 **
2224 ** Function btm_process_mode_change
2225 **
2226 ** Description This function is called when an HCI mode change event occurs.
2227 **
2228 ** Input Parms hci_status - status of the event (HCI_SUCCESS if no errors)
2229 ** hci_handle - connection handle associated with the change
2230 ** mode - HCI_MODE_ACTIVE, HCI_MODE_HOLD, HCI_MODE_SNIFF, or HCI_MODE_PARK
2231 ** interval - number of baseband slots (meaning depends on mode)
2232 **
2233 ** Returns void
2234 **
2235 *******************************************************************************/
btm_process_mode_change(UINT8 hci_status,UINT16 hci_handle,UINT8 mode,UINT16 interval)2236 void btm_process_mode_change (UINT8 hci_status, UINT16 hci_handle, UINT8 mode, UINT16 interval)
2237 {
2238 tACL_CONN *p;
2239 UINT8 xx;
2240 BTM_TRACE_DEBUG ("btm_process_mode_change");
2241 if (hci_status != HCI_SUCCESS)
2242 {
2243 BTM_TRACE_WARNING ("BTM: HCI Mode Change Error Status: 0x%02x", hci_status);
2244 }
2245
2246 /* Look up the connection by handle and set the current mode */
2247 xx = btm_handle_to_acl_index(hci_handle);
2248
2249 /* don't assume that we can never get a bad hci_handle */
2250 if (xx >= MAX_L2CAP_LINKS)
2251 return;
2252
2253 p = &btm_cb.acl_db[xx];
2254
2255 /* If status is not success mode does not mean anything */
2256 if (hci_status == HCI_SUCCESS)
2257 p->mode = mode;
2258
2259 /* If mode change was because of an active role switch or change link key */
2260 btm_cont_rswitch_or_chglinkkey(p, btm_find_dev(p->remote_addr), hci_status);
2261 }
2262 #endif /* BTM_PWR_MGR_INCLUDED == FALSE */
2263
2264 /*******************************************************************************
2265 **
2266 ** Function btm_process_clk_off_comp_evt
2267 **
2268 ** Description This function is called when clock offset command completes.
2269 **
2270 ** Input Parms hci_handle - connection handle associated with the change
2271 ** clock offset
2272 **
2273 ** Returns void
2274 **
2275 *******************************************************************************/
btm_process_clk_off_comp_evt(UINT16 hci_handle,UINT16 clock_offset)2276 void btm_process_clk_off_comp_evt (UINT16 hci_handle, UINT16 clock_offset)
2277 {
2278 UINT8 xx;
2279 BTM_TRACE_DEBUG ("btm_process_clk_off_comp_evt");
2280 /* Look up the connection by handle and set the current mode */
2281 if ((xx = btm_handle_to_acl_index(hci_handle)) < MAX_L2CAP_LINKS)
2282 btm_cb.acl_db[xx].clock_offset = clock_offset;
2283 }
2284
2285 /*******************************************************************************
2286 **
2287 ** Function btm_acl_role_changed
2288 **
2289 ** Description This function is called whan a link's master/slave role change
2290 ** event or command status event (with error) is received.
2291 ** It updates the link control block, and calls
2292 ** the registered callback with status and role (if registered).
2293 **
2294 ** Returns void
2295 **
2296 *******************************************************************************/
btm_acl_role_changed(UINT8 hci_status,BD_ADDR bd_addr,UINT8 new_role)2297 void btm_acl_role_changed (UINT8 hci_status, BD_ADDR bd_addr, UINT8 new_role)
2298 {
2299 UINT8 *p_bda = (bd_addr) ? bd_addr :
2300 btm_cb.devcb.switch_role_ref_data.remote_bd_addr;
2301 tACL_CONN *p = btm_bda_to_acl(p_bda, BT_TRANSPORT_BR_EDR);
2302 tBTM_ROLE_SWITCH_CMPL *p_data = &btm_cb.devcb.switch_role_ref_data;
2303 tBTM_SEC_DEV_REC *p_dev_rec;
2304 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
2305 tBTM_BL_ROLE_CHG_DATA evt;
2306 #endif
2307
2308 BTM_TRACE_DEBUG ("btm_acl_role_changed");
2309 /* Ignore any stray events */
2310 if (p == NULL)
2311 {
2312 /* it could be a failure */
2313 if (hci_status != HCI_SUCCESS)
2314 btm_acl_report_role_change(hci_status, bd_addr);
2315 return;
2316 }
2317
2318 p_data->hci_status = hci_status;
2319
2320 if (hci_status == HCI_SUCCESS)
2321 {
2322 p_data->role = new_role;
2323 memcpy(p_data->remote_bd_addr, p_bda, BD_ADDR_LEN);
2324
2325 /* Update cached value */
2326 p->link_role = new_role;
2327
2328 /* Reload LSTO: link supervision timeout is reset in the LM after a role switch */
2329 if (new_role == BTM_ROLE_MASTER)
2330 {
2331 BTM_SetLinkSuperTout (p->remote_addr, p->link_super_tout);
2332 }
2333 }
2334 else
2335 {
2336 /* so the BTM_BL_ROLE_CHG_EVT uses the old role */
2337 new_role = p->link_role;
2338 }
2339
2340 /* Check if any SCO req is pending for role change */
2341 btm_sco_chk_pend_rolechange (p->hci_handle);
2342
2343 /* if switching state is switching we need to turn encryption on */
2344 /* if idle, we did not change encryption */
2345 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_SWITCHING)
2346 {
2347 /* Make sure there's not also a change link key going on before re-enabling */
2348 if (p->change_key_state != BTM_ACL_SWKEY_STATE_SWITCHING)
2349 {
2350 if (btsnd_hcic_set_conn_encrypt (p->hci_handle, TRUE))
2351 {
2352 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_ENCRYPT_ON;
2353 p->switch_role_state = BTM_ACL_SWKEY_STATE_ENCRYPTION_ON;
2354 return;
2355 }
2356 }
2357 else /* Set the state and wait for change link key */
2358 {
2359 p->switch_role_state = BTM_ACL_SWKEY_STATE_ENCRYPTION_ON;
2360 return;
2361 }
2362 }
2363
2364 /* Set the switch_role_state to IDLE since the reply received from HCI */
2365 /* regardless of its result either success or failed. */
2366 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_IN_PROGRESS)
2367 {
2368 p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE;
2369 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE;
2370 }
2371
2372 /* if role switch complete is needed, report it now */
2373 btm_acl_report_role_change(hci_status, bd_addr);
2374
2375 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
2376 /* if role change event is registered, report it now */
2377 if (btm_cb.p_bl_changed_cb && (btm_cb.bl_evt_mask & BTM_BL_ROLE_CHG_MASK))
2378 {
2379 evt.event = BTM_BL_ROLE_CHG_EVT;
2380 evt.new_role = new_role;
2381 evt.p_bda = p_bda;
2382 evt.hci_status = hci_status;
2383 (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA *)&evt);
2384 }
2385
2386 BTM_TRACE_DEBUG("Role Switch Event: new_role 0x%02x, HCI Status 0x%02x, rs_st:%d",
2387 p_data->role, p_data->hci_status, p->switch_role_state);
2388 #endif
2389
2390 #if BTM_DISC_DURING_RS == TRUE
2391 /* If a disconnect is pending, issue it now that role switch has completed */
2392 if ((p_dev_rec = btm_find_dev (p_bda)) != NULL)
2393 {
2394 if (p_dev_rec->rs_disc_pending == BTM_SEC_DISC_PENDING)
2395 {
2396 BTM_TRACE_WARNING("btm_acl_role_changed -> Issuing delayed HCI_Disconnect!!!");
2397 btsnd_hcic_disconnect(p_dev_rec->hci_handle, HCI_ERR_PEER_USER);
2398 }
2399 BTM_TRACE_ERROR("tBTM_SEC_DEV:0x%x rs_disc_pending=%d",
2400 (UINT32)p_dev_rec, p_dev_rec->rs_disc_pending);
2401 p_dev_rec->rs_disc_pending = BTM_SEC_RS_NOT_PENDING; /* reset flag */
2402 }
2403
2404 #endif
2405
2406 }
2407
2408 #if (RFCOMM_INCLUDED==TRUE)
2409 /*******************************************************************************
2410 **
2411 ** Function BTM_AllocateSCN
2412 **
2413 ** Description Look through the Server Channel Numbers for a free one.
2414 **
2415 ** Returns Allocated SCN number or 0 if none.
2416 **
2417 *******************************************************************************/
2418
BTM_AllocateSCN(void)2419 UINT8 BTM_AllocateSCN(void)
2420 {
2421 UINT8 x;
2422 BTM_TRACE_DEBUG ("BTM_AllocateSCN");
2423
2424 // stack reserves scn 1 for HFP, HSP we still do the correct way
2425 for (x = 1; x < BTM_MAX_SCN; x++)
2426 {
2427 if (!btm_cb.btm_scn[x])
2428 {
2429 btm_cb.btm_scn[x] = TRUE;
2430 return(x+1);
2431 }
2432 }
2433
2434 return(0); /* No free ports */
2435 }
2436
2437 /*******************************************************************************
2438 **
2439 ** Function BTM_TryAllocateSCN
2440 **
2441 ** Description Try to allocate a fixed server channel
2442 **
2443 ** Returns Returns TRUE if server channel was available
2444 **
2445 *******************************************************************************/
2446
BTM_TryAllocateSCN(UINT8 scn)2447 BOOLEAN BTM_TryAllocateSCN(UINT8 scn)
2448 {
2449 UINT8 x;
2450
2451 /* Make sure we don't exceed max port range.
2452 * Stack reserves scn 1 for HFP, HSP we still do the correct way.
2453 */
2454 if ( (scn>=BTM_MAX_SCN) || (scn == 1) )
2455 return FALSE;
2456
2457 /* check if this port is available */
2458 if (!btm_cb.btm_scn[scn-1])
2459 {
2460 btm_cb.btm_scn[scn-1] = TRUE;
2461 return TRUE;
2462 }
2463
2464 return (FALSE); /* Port was busy */
2465 }
2466
2467 /*******************************************************************************
2468 **
2469 ** Function BTM_FreeSCN
2470 **
2471 ** Description Free the specified SCN.
2472 **
2473 ** Returns TRUE or FALSE
2474 **
2475 *******************************************************************************/
BTM_FreeSCN(UINT8 scn)2476 BOOLEAN BTM_FreeSCN(UINT8 scn)
2477 {
2478 BTM_TRACE_DEBUG ("BTM_FreeSCN ");
2479 if (scn <= BTM_MAX_SCN)
2480 {
2481 btm_cb.btm_scn[scn-1] = FALSE;
2482 return(TRUE);
2483 }
2484 else
2485 return(FALSE); /* Illegal SCN passed in */
2486 }
2487
2488 #else
2489
2490 /* Make dummy functions for the RPC to link against */
BTM_AllocateSCN(void)2491 UINT8 BTM_AllocateSCN(void)
2492 {
2493 return(0);
2494 }
2495
BTM_FreeSCN(UINT8 scn)2496 BOOLEAN BTM_FreeSCN(UINT8 scn)
2497 {
2498 return(FALSE);
2499 }
2500
2501 #endif
2502
2503
2504 /*******************************************************************************
2505 **
2506 ** Function btm_acl_timeout
2507 **
2508 ** Description This function is called when a timer list entry expires.
2509 **
2510 ** Returns void
2511 **
2512 *******************************************************************************/
btm_acl_timeout(TIMER_LIST_ENT * p_tle)2513 void btm_acl_timeout (TIMER_LIST_ENT *p_tle)
2514 {
2515 UINT32 timer_type = p_tle->param;
2516
2517 BTM_TRACE_DEBUG ("btm_acl_timeout");
2518 if (timer_type == TT_DEV_RLNKP)
2519 {
2520 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_rlinkp_cmpl_cb;
2521 tBTM_LNK_POLICY_RESULTS lnkpol;
2522
2523 lnkpol.status = BTM_ERR_PROCESSING;
2524 lnkpol.settings = 0;
2525
2526 btm_cb.devcb.p_rlinkp_cmpl_cb = NULL;
2527
2528 if (p_cb)
2529 (*p_cb)(&lnkpol);
2530 }
2531 }
2532
2533 /*******************************************************************************
2534 **
2535 ** Function btm_set_packet_types
2536 **
2537 ** Description This function sets the packet types used for a specific
2538 ** ACL connection. It is called internally by btm_acl_created
2539 ** or by an application/profile by BTM_SetPacketTypes.
2540 **
2541 ** Returns status of the operation
2542 **
2543 *******************************************************************************/
btm_set_packet_types(tACL_CONN * p,UINT16 pkt_types)2544 tBTM_STATUS btm_set_packet_types (tACL_CONN *p, UINT16 pkt_types)
2545 {
2546 UINT16 temp_pkt_types;
2547 BTM_TRACE_DEBUG ("btm_set_packet_types");
2548 /* Save in the ACL control blocks, types that we support */
2549 temp_pkt_types = (pkt_types & BTM_ACL_SUPPORTED_PKTS_MASK &
2550 btm_cb.btm_acl_pkt_types_supported);
2551
2552 /* OR in any exception packet types if at least 2.0 version of spec */
2553 if (btm_cb.devcb.local_version.hci_version >= HCI_PROTO_VERSION_2_0)
2554 {
2555 temp_pkt_types |= ((pkt_types & BTM_ACL_EXCEPTION_PKTS_MASK) |
2556 (btm_cb.btm_acl_pkt_types_supported & BTM_ACL_EXCEPTION_PKTS_MASK));
2557 }
2558 else
2559 {
2560 temp_pkt_types &= (~BTM_ACL_EXCEPTION_PKTS_MASK);
2561 }
2562
2563 /* Exclude packet types not supported by the peer */
2564 btm_acl_chk_peer_pkt_type_support (p, &temp_pkt_types);
2565
2566 BTM_TRACE_DEBUG ("SetPacketType Mask -> 0x%04x", temp_pkt_types);
2567
2568 if (!btsnd_hcic_change_conn_type (p->hci_handle, temp_pkt_types))
2569 {
2570 return(BTM_NO_RESOURCES);
2571 }
2572
2573 p->pkt_types_mask = temp_pkt_types;
2574
2575 return(BTM_CMD_STARTED);
2576 }
2577
2578 /*******************************************************************************
2579 **
2580 ** Function btm_get_max_packet_size
2581 **
2582 ** Returns Returns maximum packet size that can be used for current
2583 ** connection, 0 if connection is not established
2584 **
2585 *******************************************************************************/
btm_get_max_packet_size(BD_ADDR addr)2586 UINT16 btm_get_max_packet_size (BD_ADDR addr)
2587 {
2588 tACL_CONN *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
2589 UINT16 pkt_types = 0;
2590 UINT16 pkt_size = 0;
2591 BTM_TRACE_DEBUG ("btm_get_max_packet_size");
2592 if (p != NULL)
2593 {
2594 pkt_types = p->pkt_types_mask;
2595 }
2596 else
2597 {
2598 /* Special case for when info for the local device is requested */
2599 if (memcmp (btm_cb.devcb.local_addr, addr, BD_ADDR_LEN) == 0)
2600 {
2601 pkt_types = btm_cb.btm_acl_pkt_types_supported;
2602 }
2603 }
2604
2605 if (pkt_types)
2606 {
2607 if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_3_DH5))
2608 pkt_size = HCI_EDR3_DH5_PACKET_SIZE;
2609 else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_2_DH5))
2610 pkt_size = HCI_EDR2_DH5_PACKET_SIZE;
2611 else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_3_DH3))
2612 pkt_size = HCI_EDR3_DH3_PACKET_SIZE;
2613 else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DH5)
2614 pkt_size = HCI_DH5_PACKET_SIZE;
2615 else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_2_DH3))
2616 pkt_size = HCI_EDR2_DH3_PACKET_SIZE;
2617 else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DM5)
2618 pkt_size = HCI_DM5_PACKET_SIZE;
2619 else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DH3)
2620 pkt_size = HCI_DH3_PACKET_SIZE;
2621 else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DM3)
2622 pkt_size = HCI_DM3_PACKET_SIZE;
2623 else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_3_DH1))
2624 pkt_size = HCI_EDR3_DH1_PACKET_SIZE;
2625 else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_2_DH1))
2626 pkt_size = HCI_EDR2_DH1_PACKET_SIZE;
2627 else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DH1)
2628 pkt_size = HCI_DH1_PACKET_SIZE;
2629 else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DM1)
2630 pkt_size = HCI_DM1_PACKET_SIZE;
2631 }
2632
2633 return(pkt_size);
2634 }
2635
2636 /*******************************************************************************
2637 **
2638 ** Function BTM_ReadRemoteVersion
2639 **
2640 ** Returns If connected report peer device info
2641 **
2642 *******************************************************************************/
BTM_ReadRemoteVersion(BD_ADDR addr,UINT8 * lmp_version,UINT16 * manufacturer,UINT16 * lmp_sub_version)2643 tBTM_STATUS BTM_ReadRemoteVersion (BD_ADDR addr, UINT8 *lmp_version,
2644 UINT16 *manufacturer, UINT16 *lmp_sub_version)
2645 {
2646 tACL_CONN *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
2647 BTM_TRACE_DEBUG ("BTM_ReadRemoteVersion");
2648 if (p == NULL)
2649 return(BTM_UNKNOWN_ADDR);
2650
2651 if (lmp_version)
2652 *lmp_version = p->lmp_version;
2653
2654 if (manufacturer)
2655 *manufacturer = p->manufacturer;
2656
2657 if (lmp_sub_version)
2658 *lmp_sub_version = p->lmp_subversion;
2659
2660 return(BTM_SUCCESS);
2661 }
2662
2663 /*******************************************************************************
2664 **
2665 ** Function BTM_ReadRemoteFeatures
2666 **
2667 ** Returns pointer to the remote supported features mask (8 bytes)
2668 **
2669 *******************************************************************************/
BTM_ReadRemoteFeatures(BD_ADDR addr)2670 UINT8 *BTM_ReadRemoteFeatures (BD_ADDR addr)
2671 {
2672 tACL_CONN *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
2673 BTM_TRACE_DEBUG ("BTM_ReadRemoteFeatures");
2674 if (p == NULL)
2675 {
2676 return(NULL);
2677 }
2678
2679 return(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]);
2680 }
2681
2682 /*******************************************************************************
2683 **
2684 ** Function BTM_ReadRemoteExtendedFeatures
2685 **
2686 ** Returns pointer to the remote extended features mask (8 bytes)
2687 ** or NULL if bad page
2688 **
2689 *******************************************************************************/
BTM_ReadRemoteExtendedFeatures(BD_ADDR addr,UINT8 page_number)2690 UINT8 *BTM_ReadRemoteExtendedFeatures (BD_ADDR addr, UINT8 page_number)
2691 {
2692 tACL_CONN *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
2693 BTM_TRACE_DEBUG ("BTM_ReadRemoteExtendedFeatures");
2694 if (p == NULL)
2695 {
2696 return(NULL);
2697 }
2698
2699 if (page_number > HCI_EXT_FEATURES_PAGE_MAX)
2700 {
2701 BTM_TRACE_ERROR("Warning: BTM_ReadRemoteExtendedFeatures page %d unknown", page_number);
2702 return NULL;
2703 }
2704
2705 return(p->peer_lmp_features[page_number]);
2706 }
2707
2708 /*******************************************************************************
2709 **
2710 ** Function BTM_ReadNumberRemoteFeaturesPages
2711 **
2712 ** Returns number of features pages read from the remote device.
2713 **
2714 *******************************************************************************/
BTM_ReadNumberRemoteFeaturesPages(BD_ADDR addr)2715 UINT8 BTM_ReadNumberRemoteFeaturesPages (BD_ADDR addr)
2716 {
2717 tACL_CONN *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
2718 BTM_TRACE_DEBUG ("BTM_ReadNumberRemoteFeaturesPages");
2719 if (p == NULL)
2720 {
2721 return(0);
2722 }
2723
2724 return(p->num_read_pages);
2725 }
2726
2727 /*******************************************************************************
2728 **
2729 ** Function BTM_ReadAllRemoteFeatures
2730 **
2731 ** Returns pointer to all features of the remote (24 bytes).
2732 **
2733 *******************************************************************************/
BTM_ReadAllRemoteFeatures(BD_ADDR addr)2734 UINT8 *BTM_ReadAllRemoteFeatures (BD_ADDR addr)
2735 {
2736 tACL_CONN *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
2737 BTM_TRACE_DEBUG ("BTM_ReadAllRemoteFeatures");
2738 if (p == NULL)
2739 {
2740 return(NULL);
2741 }
2742
2743 return(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]);
2744 }
2745
2746 /*******************************************************************************
2747 **
2748 ** Function BTM_RegBusyLevelNotif
2749 **
2750 ** Description This function is called to register a callback to receive
2751 ** busy level change events.
2752 **
2753 ** Returns BTM_SUCCESS if successfully registered, otherwise error
2754 **
2755 *******************************************************************************/
2756 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
BTM_RegBusyLevelNotif(tBTM_BL_CHANGE_CB * p_cb,UINT8 * p_level,tBTM_BL_EVENT_MASK evt_mask)2757 tBTM_STATUS BTM_RegBusyLevelNotif (tBTM_BL_CHANGE_CB *p_cb, UINT8 *p_level,
2758 tBTM_BL_EVENT_MASK evt_mask)
2759 {
2760 BTM_TRACE_DEBUG ("BTM_RegBusyLevelNotif");
2761 if (p_level)
2762 *p_level = btm_cb.busy_level;
2763
2764 btm_cb.bl_evt_mask = evt_mask;
2765
2766 if (!p_cb)
2767 btm_cb.p_bl_changed_cb = NULL;
2768 else if (btm_cb.p_bl_changed_cb)
2769 return(BTM_BUSY);
2770 else
2771 btm_cb.p_bl_changed_cb = p_cb;
2772
2773 return(BTM_SUCCESS);
2774 }
2775 #else
2776 /*******************************************************************************
2777 **
2778 ** Function BTM_AclRegisterForChanges
2779 **
2780 ** Returns This function is called to register a callback for when the
2781 ** ACL database changes, i.e. new entry or entry deleted.
2782 **
2783 *******************************************************************************/
BTM_AclRegisterForChanges(tBTM_ACL_DB_CHANGE_CB * p_cb)2784 tBTM_STATUS BTM_AclRegisterForChanges (tBTM_ACL_DB_CHANGE_CB *p_cb)
2785 {
2786 BTM_TRACE_DEBUG ("BTM_AclRegisterForChanges");
2787 if (!p_cb)
2788 btm_cb.p_acl_changed_cb = NULL;
2789 else if (btm_cb.p_acl_changed_cb)
2790 return(BTM_BUSY);
2791 else
2792 btm_cb.p_acl_changed_cb = p_cb;
2793
2794 return(BTM_SUCCESS);
2795 }
2796 #endif
2797
2798 /*******************************************************************************
2799 **
2800 ** Function BTM_SetQoS
2801 **
2802 ** Description This function is called to setup QoS
2803 **
2804 ** Returns status of the operation
2805 **
2806 *******************************************************************************/
BTM_SetQoS(BD_ADDR bd,FLOW_SPEC * p_flow,tBTM_CMPL_CB * p_cb)2807 tBTM_STATUS BTM_SetQoS (BD_ADDR bd, FLOW_SPEC *p_flow, tBTM_CMPL_CB *p_cb)
2808 {
2809 tACL_CONN *p = &btm_cb.acl_db[0];
2810
2811 BTM_TRACE_API ("BTM_SetQoS: BdAddr: %02x%02x%02x%02x%02x%02x",
2812 bd[0], bd[1], bd[2],
2813 bd[3], bd[4], bd[5]);
2814
2815 /* If someone already waiting on the version, do not allow another */
2816 if (btm_cb.devcb.p_qossu_cmpl_cb)
2817 return(BTM_BUSY);
2818
2819 if ( (p = btm_bda_to_acl(bd, BT_TRANSPORT_BR_EDR)) != NULL)
2820 {
2821 btu_start_timer (&btm_cb.devcb.qossu_timer, BTU_TTYPE_BTM_ACL, BTM_DEV_REPLY_TIMEOUT);
2822 btm_cb.devcb.p_qossu_cmpl_cb = p_cb;
2823
2824 if (!btsnd_hcic_qos_setup (p->hci_handle, p_flow->qos_flags, p_flow->service_type,
2825 p_flow->token_rate, p_flow->peak_bandwidth,
2826 p_flow->latency,p_flow->delay_variation))
2827 {
2828 btm_cb.devcb.p_qossu_cmpl_cb = NULL;
2829 btu_stop_timer(&btm_cb.devcb.qossu_timer);
2830 return(BTM_NO_RESOURCES);
2831 }
2832 else
2833 return(BTM_CMD_STARTED);
2834 }
2835
2836 /* If here, no BD Addr found */
2837 return(BTM_UNKNOWN_ADDR);
2838 }
2839
2840 /*******************************************************************************
2841 **
2842 ** Function btm_qos_setup_complete
2843 **
2844 ** Description This function is called when the command complete message
2845 ** is received from the HCI for the qos setup request.
2846 **
2847 ** Returns void
2848 **
2849 *******************************************************************************/
btm_qos_setup_complete(UINT8 status,UINT16 handle,FLOW_SPEC * p_flow)2850 void btm_qos_setup_complete (UINT8 status, UINT16 handle, FLOW_SPEC *p_flow)
2851 {
2852 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_qossu_cmpl_cb;
2853 tBTM_QOS_SETUP_CMPL qossu;
2854 BTM_TRACE_DEBUG ("btm_qos_setup_complete");
2855 btu_stop_timer (&btm_cb.devcb.qossu_timer);
2856
2857 btm_cb.devcb.p_qossu_cmpl_cb = NULL;
2858
2859 if (p_cb)
2860 {
2861 memset(&qossu, 0, sizeof(tBTM_QOS_SETUP_CMPL));
2862 qossu.status = status;
2863 qossu.handle = handle;
2864 if (p_flow != NULL)
2865 {
2866 qossu.flow.qos_flags = p_flow->qos_flags;
2867 qossu.flow.service_type = p_flow->service_type;
2868 qossu.flow.token_rate = p_flow->token_rate;
2869 qossu.flow.peak_bandwidth = p_flow->peak_bandwidth;
2870 qossu.flow.latency = p_flow->latency;
2871 qossu.flow.delay_variation = p_flow->delay_variation;
2872 }
2873 BTM_TRACE_DEBUG ("BTM: p_flow->delay_variation: 0x%02x",
2874 qossu.flow.delay_variation);
2875 (*p_cb)(&qossu);
2876 }
2877 }
2878
2879
2880 /*******************************************************************************
2881 **
2882 ** Function BTM_ReadRSSI
2883 **
2884 ** Description This function is called to read the link policy settings.
2885 ** The address of link policy results are returned in the callback.
2886 ** (tBTM_RSSI_RESULTS)
2887 **
2888 ** Returns BTM_CMD_STARTED if successfully initiated or error code
2889 **
2890 *******************************************************************************/
BTM_ReadRSSI(BD_ADDR remote_bda,tBTM_CMPL_CB * p_cb)2891 tBTM_STATUS BTM_ReadRSSI (BD_ADDR remote_bda, tBTM_CMPL_CB *p_cb)
2892 {
2893 tACL_CONN *p;
2894 tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR;
2895 #if BLE_INCLUDED == TRUE
2896 tBT_DEVICE_TYPE dev_type;
2897 tBLE_ADDR_TYPE addr_type;
2898 #endif
2899 BTM_TRACE_API ("BTM_ReadRSSI: RemBdAddr: %02x%02x%02x%02x%02x%02x",
2900 remote_bda[0], remote_bda[1], remote_bda[2],
2901 remote_bda[3], remote_bda[4], remote_bda[5]);
2902
2903 /* If someone already waiting on the version, do not allow another */
2904 if (btm_cb.devcb.p_rssi_cmpl_cb)
2905 return(BTM_BUSY);
2906
2907 #if BLE_INCLUDED == TRUE
2908 BTM_ReadDevInfo(remote_bda, &dev_type, &addr_type);
2909 if (dev_type == BT_DEVICE_TYPE_BLE)
2910 transport = BT_TRANSPORT_LE;
2911 #endif
2912
2913 p = btm_bda_to_acl(remote_bda, transport);
2914 if (p != (tACL_CONN *)NULL)
2915 {
2916 btu_start_timer (&btm_cb.devcb.rssi_timer, BTU_TTYPE_BTM_ACL,
2917 BTM_DEV_REPLY_TIMEOUT);
2918
2919 btm_cb.devcb.p_rssi_cmpl_cb = p_cb;
2920
2921 if (!btsnd_hcic_read_rssi (p->hci_handle))
2922 {
2923 btm_cb.devcb.p_rssi_cmpl_cb = NULL;
2924 btu_stop_timer (&btm_cb.devcb.rssi_timer);
2925 return(BTM_NO_RESOURCES);
2926 }
2927 else
2928 return(BTM_CMD_STARTED);
2929 }
2930
2931 /* If here, no BD Addr found */
2932 return(BTM_UNKNOWN_ADDR);
2933 }
2934
2935 /*******************************************************************************
2936 **
2937 ** Function BTM_ReadLinkQuality
2938 **
2939 ** Description This function is called to read the link qulaity.
2940 ** The value of the link quality is returned in the callback.
2941 ** (tBTM_LINK_QUALITY_RESULTS)
2942 **
2943 ** Returns BTM_CMD_STARTED if successfully initiated or error code
2944 **
2945 *******************************************************************************/
BTM_ReadLinkQuality(BD_ADDR remote_bda,tBTM_CMPL_CB * p_cb)2946 tBTM_STATUS BTM_ReadLinkQuality (BD_ADDR remote_bda, tBTM_CMPL_CB *p_cb)
2947 {
2948 tACL_CONN *p;
2949
2950 BTM_TRACE_API ("BTM_ReadLinkQuality: RemBdAddr: %02x%02x%02x%02x%02x%02x",
2951 remote_bda[0], remote_bda[1], remote_bda[2],
2952 remote_bda[3], remote_bda[4], remote_bda[5]);
2953
2954 /* If someone already waiting on the version, do not allow another */
2955 if (btm_cb.devcb.p_lnk_qual_cmpl_cb)
2956 return(BTM_BUSY);
2957
2958 p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
2959 if (p != (tACL_CONN *)NULL)
2960 {
2961 btu_start_timer (&btm_cb.devcb.lnk_quality_timer, BTU_TTYPE_BTM_ACL,
2962 BTM_DEV_REPLY_TIMEOUT);
2963 btm_cb.devcb.p_lnk_qual_cmpl_cb = p_cb;
2964
2965 if (!btsnd_hcic_get_link_quality (p->hci_handle))
2966 {
2967 btu_stop_timer (&btm_cb.devcb.lnk_quality_timer);
2968 btm_cb.devcb.p_lnk_qual_cmpl_cb = NULL;
2969 return(BTM_NO_RESOURCES);
2970 }
2971 else
2972 return(BTM_CMD_STARTED);
2973 }
2974
2975 /* If here, no BD Addr found */
2976 return(BTM_UNKNOWN_ADDR);
2977 }
2978
2979 /*******************************************************************************
2980 **
2981 ** Function BTM_ReadTxPower
2982 **
2983 ** Description This function is called to read the current
2984 ** TX power of the connection. The tx power level results
2985 ** are returned in the callback.
2986 ** (tBTM_RSSI_RESULTS)
2987 **
2988 ** Returns BTM_CMD_STARTED if successfully initiated or error code
2989 **
2990 *******************************************************************************/
BTM_ReadTxPower(BD_ADDR remote_bda,tBT_TRANSPORT transport,tBTM_CMPL_CB * p_cb)2991 tBTM_STATUS BTM_ReadTxPower (BD_ADDR remote_bda, tBT_TRANSPORT transport, tBTM_CMPL_CB *p_cb)
2992 {
2993 tACL_CONN *p;
2994 BOOLEAN ret;
2995 #define BTM_READ_RSSI_TYPE_CUR 0x00
2996 #define BTM_READ_RSSI_TYPE_MAX 0X01
2997
2998 BTM_TRACE_API ("BTM_ReadTxPower: RemBdAddr: %02x%02x%02x%02x%02x%02x",
2999 remote_bda[0], remote_bda[1], remote_bda[2],
3000 remote_bda[3], remote_bda[4], remote_bda[5]);
3001
3002 /* If someone already waiting on the version, do not allow another */
3003 if (btm_cb.devcb.p_tx_power_cmpl_cb)
3004 return(BTM_BUSY);
3005
3006 p = btm_bda_to_acl(remote_bda, transport);
3007 if (p != (tACL_CONN *)NULL)
3008 {
3009 btu_start_timer (&btm_cb.devcb.tx_power_timer, BTU_TTYPE_BTM_ACL,
3010 BTM_DEV_REPLY_TIMEOUT);
3011
3012 btm_cb.devcb.p_tx_power_cmpl_cb = p_cb;
3013
3014 #if BLE_INCLUDED == TRUE
3015 if (p->transport == BT_TRANSPORT_LE)
3016 {
3017 memcpy(btm_cb.devcb.read_tx_pwr_addr, remote_bda, BD_ADDR_LEN);
3018 ret = btsnd_hcic_ble_read_adv_chnl_tx_power();
3019 }
3020 else
3021 #endif
3022 {
3023 ret = btsnd_hcic_read_tx_power (p->hci_handle, BTM_READ_RSSI_TYPE_CUR);
3024 }
3025 if (!ret)
3026 {
3027 btm_cb.devcb.p_tx_power_cmpl_cb = NULL;
3028 btu_stop_timer (&btm_cb.devcb.tx_power_timer);
3029 return(BTM_NO_RESOURCES);
3030 }
3031 else
3032 return(BTM_CMD_STARTED);
3033 }
3034
3035 /* If here, no BD Addr found */
3036 return (BTM_UNKNOWN_ADDR);
3037 }
3038 /*******************************************************************************
3039 **
3040 ** Function btm_read_tx_power_complete
3041 **
3042 ** Description This function is called when the command complete message
3043 ** is received from the HCI for the read tx power request.
3044 **
3045 ** Returns void
3046 **
3047 *******************************************************************************/
btm_read_tx_power_complete(UINT8 * p,BOOLEAN is_ble)3048 void btm_read_tx_power_complete (UINT8 *p, BOOLEAN is_ble)
3049 {
3050 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_tx_power_cmpl_cb;
3051 tBTM_TX_POWER_RESULTS results;
3052 UINT16 handle;
3053 tACL_CONN *p_acl_cb = &btm_cb.acl_db[0];
3054 UINT16 index;
3055 BTM_TRACE_DEBUG ("btm_read_tx_power_complete");
3056 btu_stop_timer (&btm_cb.devcb.tx_power_timer);
3057
3058 /* If there was a callback registered for read rssi, call it */
3059 btm_cb.devcb.p_tx_power_cmpl_cb = NULL;
3060
3061 if (p_cb)
3062 {
3063 STREAM_TO_UINT8 (results.hci_status, p);
3064
3065 if (results.hci_status == HCI_SUCCESS)
3066 {
3067 results.status = BTM_SUCCESS;
3068
3069 if (!is_ble)
3070 {
3071 STREAM_TO_UINT16 (handle, p);
3072 STREAM_TO_UINT8 (results.tx_power, p);
3073
3074 /* Search through the list of active channels for the correct BD Addr */
3075 for (index = 0; index < MAX_L2CAP_LINKS; index++, p_acl_cb++)
3076 {
3077 if ((p_acl_cb->in_use) && (handle == p_acl_cb->hci_handle))
3078 {
3079 memcpy (results.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN);
3080 break;
3081 }
3082 }
3083 }
3084 #if BLE_INCLUDED == TRUE
3085 else
3086 {
3087 STREAM_TO_UINT8 (results.tx_power, p);
3088 memcpy(results.rem_bda, btm_cb.devcb.read_tx_pwr_addr, BD_ADDR_LEN);
3089 }
3090 #endif
3091 BTM_TRACE_DEBUG ("BTM TX power Complete: tx_power %d, hci status 0x%02x",
3092 results.tx_power, results.hci_status);
3093 }
3094 else
3095 results.status = BTM_ERR_PROCESSING;
3096
3097 (*p_cb)(&results);
3098 }
3099 }
3100
3101 /*******************************************************************************
3102 **
3103 ** Function btm_read_rssi_complete
3104 **
3105 ** Description This function is called when the command complete message
3106 ** is received from the HCI for the read rssi request.
3107 **
3108 ** Returns void
3109 **
3110 *******************************************************************************/
btm_read_rssi_complete(UINT8 * p)3111 void btm_read_rssi_complete (UINT8 *p)
3112 {
3113 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_rssi_cmpl_cb;
3114 tBTM_RSSI_RESULTS results;
3115 UINT16 handle;
3116 tACL_CONN *p_acl_cb = &btm_cb.acl_db[0];
3117 UINT16 index;
3118 BTM_TRACE_DEBUG ("btm_read_rssi_complete");
3119 btu_stop_timer (&btm_cb.devcb.rssi_timer);
3120
3121 /* If there was a callback registered for read rssi, call it */
3122 btm_cb.devcb.p_rssi_cmpl_cb = NULL;
3123
3124 if (p_cb)
3125 {
3126 STREAM_TO_UINT8 (results.hci_status, p);
3127
3128 if (results.hci_status == HCI_SUCCESS)
3129 {
3130 results.status = BTM_SUCCESS;
3131
3132 STREAM_TO_UINT16 (handle, p);
3133
3134 STREAM_TO_UINT8 (results.rssi, p);
3135 BTM_TRACE_DEBUG ("BTM RSSI Complete: rssi %d, hci status 0x%02x",
3136 results.rssi, results.hci_status);
3137
3138 /* Search through the list of active channels for the correct BD Addr */
3139 for (index = 0; index < MAX_L2CAP_LINKS; index++, p_acl_cb++)
3140 {
3141 if ((p_acl_cb->in_use) && (handle == p_acl_cb->hci_handle))
3142 {
3143 memcpy (results.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN);
3144 break;
3145 }
3146 }
3147 }
3148 else
3149 results.status = BTM_ERR_PROCESSING;
3150
3151 (*p_cb)(&results);
3152 }
3153 }
3154
3155 /*******************************************************************************
3156 **
3157 ** Function btm_read_link_quality_complete
3158 **
3159 ** Description This function is called when the command complete message
3160 ** is received from the HCI for the read link quality.
3161 **
3162 ** Returns void
3163 **
3164 *******************************************************************************/
btm_read_link_quality_complete(UINT8 * p)3165 void btm_read_link_quality_complete (UINT8 *p)
3166 {
3167 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_lnk_qual_cmpl_cb;
3168 tBTM_LINK_QUALITY_RESULTS results;
3169 UINT16 handle;
3170 tACL_CONN *p_acl_cb = &btm_cb.acl_db[0];
3171 UINT16 index;
3172 BTM_TRACE_DEBUG ("btm_read_link_quality_complete");
3173 btu_stop_timer (&btm_cb.devcb.lnk_quality_timer);
3174
3175 /* If there was a callback registered for read rssi, call it */
3176 btm_cb.devcb.p_lnk_qual_cmpl_cb = NULL;
3177
3178 if (p_cb)
3179 {
3180 STREAM_TO_UINT8 (results.hci_status, p);
3181
3182 if (results.hci_status == HCI_SUCCESS)
3183 {
3184 results.status = BTM_SUCCESS;
3185
3186 STREAM_TO_UINT16 (handle, p);
3187
3188 STREAM_TO_UINT8 (results.link_quality, p);
3189 BTM_TRACE_DEBUG ("BTM Link Quality Complete: Link Quality %d, hci status 0x%02x",
3190 results.link_quality, results.hci_status);
3191
3192 /* Search through the list of active channels for the correct BD Addr */
3193 for (index = 0; index < MAX_L2CAP_LINKS; index++, p_acl_cb++)
3194 {
3195 if ((p_acl_cb->in_use) && (handle == p_acl_cb->hci_handle))
3196 {
3197 memcpy (results.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN);
3198 break;
3199 }
3200 }
3201 }
3202 else
3203 results.status = BTM_ERR_PROCESSING;
3204
3205 (*p_cb)(&results);
3206 }
3207 }
3208
3209 /*******************************************************************************
3210 **
3211 ** Function btm_remove_acl
3212 **
3213 ** Description This function is called to disconnect an ACL connection
3214 **
3215 ** Returns BTM_SUCCESS if successfully initiated, otherwise BTM_NO_RESOURCES.
3216 **
3217 *******************************************************************************/
btm_remove_acl(BD_ADDR bd_addr,tBT_TRANSPORT transport)3218 tBTM_STATUS btm_remove_acl (BD_ADDR bd_addr, tBT_TRANSPORT transport)
3219 {
3220 UINT16 hci_handle = BTM_GetHCIConnHandle(bd_addr, transport);
3221 tBTM_STATUS status = BTM_SUCCESS;
3222
3223 BTM_TRACE_DEBUG ("btm_remove_acl");
3224 #if BTM_DISC_DURING_RS == TRUE
3225 tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (bd_addr);
3226
3227 /* Role Switch is pending, postpone until completed */
3228 if (p_dev_rec && (p_dev_rec->rs_disc_pending == BTM_SEC_RS_PENDING))
3229 {
3230 p_dev_rec->rs_disc_pending = BTM_SEC_DISC_PENDING;
3231 }
3232 else /* otherwise can disconnect right away */
3233 #endif
3234 {
3235 if (hci_handle != 0xFFFF && p_dev_rec &&
3236 p_dev_rec->sec_state!= BTM_SEC_STATE_DISCONNECTING)
3237 {
3238 if (!btsnd_hcic_disconnect (hci_handle, HCI_ERR_PEER_USER))
3239 status = BTM_NO_RESOURCES;
3240 }
3241 else
3242 status = BTM_UNKNOWN_ADDR;
3243 }
3244
3245 return status;
3246 }
3247
3248
3249 /*******************************************************************************
3250 **
3251 ** Function BTM_SetTraceLevel
3252 **
3253 ** Description This function sets the trace level for BTM. If called with
3254 ** a value of 0xFF, it simply returns the current trace level.
3255 **
3256 ** Returns The new or current trace level
3257 **
3258 *******************************************************************************/
BTM_SetTraceLevel(UINT8 new_level)3259 UINT8 BTM_SetTraceLevel (UINT8 new_level)
3260 {
3261 BTM_TRACE_DEBUG ("BTM_SetTraceLevel");
3262 if (new_level != 0xFF)
3263 btm_cb.trace_level = new_level;
3264
3265 return(btm_cb.trace_level);
3266 }
3267
3268 /*******************************************************************************
3269 **
3270 ** Function btm_cont_rswitch_or_chglinkkey
3271 **
3272 ** Description This function is called to continue processing an active
3273 ** role switch or change of link key procedure. It first
3274 ** disables encryption if enabled and EPR is not supported
3275 **
3276 ** Returns void
3277 **
3278 *******************************************************************************/
btm_cont_rswitch_or_chglinkkey(tACL_CONN * p,tBTM_SEC_DEV_REC * p_dev_rec,UINT8 hci_status)3279 void btm_cont_rswitch_or_chglinkkey (tACL_CONN *p, tBTM_SEC_DEV_REC *p_dev_rec,
3280 UINT8 hci_status)
3281 {
3282 BOOLEAN sw_ok = TRUE;
3283 BOOLEAN chlk_ok = TRUE;
3284 BTM_TRACE_DEBUG ("btm_cont_rswitch_or_chglinkkey ");
3285 /* Check to see if encryption needs to be turned off if pending
3286 change of link key or role switch */
3287 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE ||
3288 p->change_key_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE)
3289 {
3290 /* Must turn off Encryption first if necessary */
3291 /* Some devices do not support switch or change of link key while encryption is on */
3292 if (p_dev_rec != NULL && ((p_dev_rec->sec_flags & BTM_SEC_ENCRYPTED) != 0)
3293 && !BTM_EPR_AVAILABLE(p))
3294 {
3295 if (btsnd_hcic_set_conn_encrypt (p->hci_handle, FALSE))
3296 {
3297 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF;
3298 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE)
3299 p->switch_role_state = BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF;
3300
3301 if (p->change_key_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE)
3302 p->change_key_state = BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF;
3303 }
3304 else
3305 {
3306 /* Error occurred; set states back to Idle */
3307 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE)
3308 sw_ok = FALSE;
3309
3310 if (p->change_key_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE)
3311 chlk_ok = FALSE;
3312 }
3313 }
3314 else /* Encryption not used or EPR supported, continue with switch
3315 and/or change of link key */
3316 {
3317 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE)
3318 {
3319 p->switch_role_state = BTM_ACL_SWKEY_STATE_IN_PROGRESS;
3320 #if BTM_DISC_DURING_RS == TRUE
3321 if (p_dev_rec)
3322 p_dev_rec->rs_disc_pending = BTM_SEC_RS_PENDING;
3323 #endif
3324 sw_ok = btsnd_hcic_switch_role (p->remote_addr, (UINT8)!p->link_role);
3325 }
3326
3327 if (p->change_key_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE)
3328 {
3329 p->switch_role_state = BTM_ACL_SWKEY_STATE_IN_PROGRESS;
3330 chlk_ok = btsnd_hcic_change_link_key (p->hci_handle);
3331 }
3332 }
3333
3334 if (!sw_ok)
3335 {
3336 p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE;
3337 btm_acl_report_role_change(hci_status, p->remote_addr);
3338 }
3339
3340 if (!chlk_ok)
3341 {
3342 p->change_key_state = BTM_ACL_SWKEY_STATE_IDLE;
3343 if (btm_cb.devcb.p_chg_link_key_cb)
3344 {
3345 btm_cb.devcb.chg_link_key_ref_data.hci_status = hci_status;
3346 (*btm_cb.devcb.p_chg_link_key_cb)(&btm_cb.devcb.chg_link_key_ref_data);
3347 btm_cb.devcb.p_chg_link_key_cb = NULL;
3348 }
3349 }
3350 }
3351 }
3352
3353 /*******************************************************************************
3354 **
3355 ** Function btm_acl_resubmit_page
3356 **
3357 ** Description send pending page request
3358 **
3359 *******************************************************************************/
btm_acl_resubmit_page(void)3360 void btm_acl_resubmit_page (void)
3361 {
3362 tBTM_SEC_DEV_REC *p_dev_rec;
3363 BT_HDR *p_buf;
3364 UINT8 *pp;
3365 BD_ADDR bda;
3366 BTM_TRACE_DEBUG ("btm_acl_resubmit_page");
3367 /* If there were other page request schedule can start the next one */
3368 if ((p_buf = (BT_HDR *)GKI_dequeue (&btm_cb.page_queue)) != NULL)
3369 {
3370 /* skip 3 (2 bytes opcode and 1 byte len) to get to the bd_addr
3371 * for both create_conn and rmt_name */
3372 pp = (UINT8 *)(p_buf + 1) + p_buf->offset + 3;
3373
3374 STREAM_TO_BDADDR (bda, pp);
3375
3376 p_dev_rec = btm_find_or_alloc_dev (bda);
3377
3378 memcpy (btm_cb.connecting_bda, p_dev_rec->bd_addr, BD_ADDR_LEN);
3379 memcpy (btm_cb.connecting_dc, p_dev_rec->dev_class, DEV_CLASS_LEN);
3380
3381 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p_buf);
3382 }
3383 else
3384 btm_cb.paging = FALSE;
3385 }
3386
3387 /*******************************************************************************
3388 **
3389 ** Function btm_acl_reset_paging
3390 **
3391 ** Description set paging to FALSE and free the page queue - called at hci_reset
3392 **
3393 *******************************************************************************/
btm_acl_reset_paging(void)3394 void btm_acl_reset_paging (void)
3395 {
3396 BT_HDR *p;
3397 BTM_TRACE_DEBUG ("btm_acl_reset_paging");
3398 /* If we sent reset we are definitely not paging any more */
3399 while ((p = (BT_HDR *)GKI_dequeue(&btm_cb.page_queue)) != NULL)
3400 GKI_freebuf (p);
3401
3402 btm_cb.paging = FALSE;
3403 }
3404
3405 /*******************************************************************************
3406 **
3407 ** Function btm_acl_set_discing
3408 **
3409 ** Description set discing to the given value
3410 **
3411 *******************************************************************************/
btm_acl_set_discing(BOOLEAN discing)3412 void btm_acl_set_discing (BOOLEAN discing)
3413 {
3414 BTM_TRACE_DEBUG ("btm_acl_set_discing");
3415 btm_cb.discing = discing;
3416 }
3417
3418 /*******************************************************************************
3419 **
3420 ** Function btm_acl_paging
3421 **
3422 ** Description send a paging command or queue it in btm_cb
3423 **
3424 *******************************************************************************/
btm_acl_paging(BT_HDR * p,BD_ADDR bda)3425 void btm_acl_paging (BT_HDR *p, BD_ADDR bda)
3426 {
3427 tBTM_SEC_DEV_REC *p_dev_rec;
3428
3429 BTM_TRACE_DEBUG ("btm_acl_paging discing:%d, paging:%d BDA: %06x%06x",
3430 btm_cb.discing, btm_cb.paging,
3431 (bda[0]<<16) + (bda[1]<<8) + bda[2], (bda[3]<<16) + (bda[4] << 8) + bda[5]);
3432 if (btm_cb.discing)
3433 {
3434 btm_cb.paging = TRUE;
3435 GKI_enqueue (&btm_cb.page_queue, p);
3436 }
3437 else
3438 {
3439 if (!BTM_ACL_IS_CONNECTED (bda))
3440 {
3441 BTM_TRACE_DEBUG ("connecting_bda: %06x%06x",
3442 (btm_cb.connecting_bda[0]<<16) + (btm_cb.connecting_bda[1]<<8) +
3443 btm_cb.connecting_bda[2],
3444 (btm_cb.connecting_bda[3]<<16) + (btm_cb.connecting_bda[4] << 8) +
3445 btm_cb.connecting_bda[5]);
3446 if (btm_cb.paging &&
3447 memcmp (bda, btm_cb.connecting_bda, BD_ADDR_LEN) != 0)
3448 {
3449 GKI_enqueue (&btm_cb.page_queue, p);
3450 }
3451 else
3452 {
3453 p_dev_rec = btm_find_or_alloc_dev (bda);
3454 memcpy (btm_cb.connecting_bda, p_dev_rec->bd_addr, BD_ADDR_LEN);
3455 memcpy (btm_cb.connecting_dc, p_dev_rec->dev_class, DEV_CLASS_LEN);
3456
3457 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3458 }
3459
3460 btm_cb.paging = TRUE;
3461 }
3462 else /* ACL is already up */
3463 {
3464 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3465 }
3466 }
3467 }
3468
3469 /*******************************************************************************
3470 **
3471 ** Function btm_acl_notif_conn_collision
3472 **
3473 ** Description Send connection collision event to upper layer if registered
3474 **
3475 ** Returns TRUE if sent out to upper layer,
3476 ** FALSE if BTM_BUSY_LEVEL_CHANGE_INCLUDED == FALSE, or no one
3477 ** needs the notification.
3478 **
3479 ** Note: Function only used if BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE
3480 **
3481 *******************************************************************************/
btm_acl_notif_conn_collision(BD_ADDR bda)3482 BOOLEAN btm_acl_notif_conn_collision (BD_ADDR bda)
3483 {
3484 #if (BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
3485 tBTM_BL_EVENT_DATA evt_data;
3486
3487 /* Report possible collision to the upper layer. */
3488 if (btm_cb.p_bl_changed_cb)
3489 {
3490 BTM_TRACE_DEBUG ("btm_acl_notif_conn_collision: RemBdAddr: %02x%02x%02x%02x%02x%02x",
3491 bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
3492
3493 evt_data.event = BTM_BL_COLLISION_EVT;
3494 evt_data.conn.p_bda = bda;
3495
3496 #if BLE_INCLUDED == TRUE
3497 evt_data.conn.transport = BT_TRANSPORT_BR_EDR;
3498 evt_data.conn.handle = BTM_INVALID_HCI_HANDLE;
3499 #endif
3500 (*btm_cb.p_bl_changed_cb)(&evt_data);
3501 return TRUE;
3502 }
3503 else
3504 return FALSE;
3505 #else
3506 return FALSE;
3507 #endif
3508 }
3509
3510
3511 /*******************************************************************************
3512 **
3513 ** Function btm_acl_chk_peer_pkt_type_support
3514 **
3515 ** Description Check if peer supports requested packets
3516 **
3517 *******************************************************************************/
btm_acl_chk_peer_pkt_type_support(tACL_CONN * p,UINT16 * p_pkt_type)3518 void btm_acl_chk_peer_pkt_type_support (tACL_CONN *p, UINT16 *p_pkt_type)
3519 {
3520 /* 3 and 5 slot packets? */
3521 if (!HCI_3_SLOT_PACKETS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
3522 *p_pkt_type &= ~(BTM_ACL_PKT_TYPES_MASK_DH3 +BTM_ACL_PKT_TYPES_MASK_DM3);
3523
3524 if (!HCI_5_SLOT_PACKETS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
3525 *p_pkt_type &= ~(BTM_ACL_PKT_TYPES_MASK_DH5 + BTM_ACL_PKT_TYPES_MASK_DM5);
3526
3527 /* If HCI version > 2.0, then also check EDR packet types */
3528 if (btm_cb.devcb.local_version.hci_version >= HCI_PROTO_VERSION_2_0)
3529 {
3530 /* 2 and 3 MPS support? */
3531 if (!HCI_EDR_ACL_2MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
3532 /* Not supported. Add 'not_supported' mask for all 2MPS packet types */
3533 *p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH1 + BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 +
3534 BTM_ACL_PKT_TYPES_MASK_NO_2_DH5);
3535
3536 if (!HCI_EDR_ACL_3MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
3537 /* Not supported. Add 'not_supported' mask for all 3MPS packet types */
3538 *p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_3_DH1 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH3 +
3539 BTM_ACL_PKT_TYPES_MASK_NO_3_DH5);
3540
3541 /* EDR 3 and 5 slot support? */
3542 if (HCI_EDR_ACL_2MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])
3543 || HCI_EDR_ACL_3MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
3544 {
3545 if (!HCI_3_SLOT_EDR_ACL_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
3546 /* Not supported. Add 'not_supported' mask for all 3-slot EDR packet types */
3547 *p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH3);
3548
3549 if (!HCI_5_SLOT_EDR_ACL_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
3550 /* Not supported. Add 'not_supported' mask for all 5-slot EDR packet types */
3551 *p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH5 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH5);
3552 }
3553 }
3554 }
3555