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 ** Name: btm_acl.c 22 ** 23 ** Description: This file contains functions that handle ACL connections. 24 ** This includes operations such as hold and sniff modes, 25 ** supported packet types. 26 ** 27 ** This module contains both internal and external (API) 28 ** functions. External (API) functions are distinguishable 29 ** by their names beginning with uppercase BTM. 30 ** 31 ** 32 ******************************************************************************/ 33 34 #include <stdlib.h> 35 #include <string.h> 36 #include <stdio.h> 37 #include <stddef.h> 38 39 #include "bt_types.h" 40 #include "bt_target.h" 41 #include "device/include/controller.h" 42 #include "bt_common.h" 43 #include "hcimsgs.h" 44 #include "btu.h" 45 #include "btm_api.h" 46 #include "btm_int.h" 47 #include "l2c_int.h" 48 #include "hcidefs.h" 49 #include "bt_utils.h" 50 51 52 extern fixed_queue_t *btu_general_alarm_queue; 53 54 static void btm_read_remote_features (UINT16 handle); 55 static void btm_read_remote_ext_features (UINT16 handle, UINT8 page_number); 56 static void btm_process_remote_ext_features (tACL_CONN *p_acl_cb, UINT8 num_read_pages); 57 58 /* 3 seconds timeout waiting for responses */ 59 #define BTM_DEV_REPLY_TIMEOUT_MS (3 * 1000) 60 61 /******************************************************************************* 62 ** 63 ** Function btm_acl_init 64 ** 65 ** Description This function is called at BTM startup to initialize 66 ** 67 ** Returns void 68 ** 69 *******************************************************************************/ 70 void btm_acl_init (void) 71 { 72 BTM_TRACE_DEBUG ("btm_acl_init"); 73 #if 0 /* cleared in btm_init; put back in if called from anywhere else! */ 74 memset (&btm_cb.acl_db, 0, sizeof (btm_cb.acl_db)); 75 memset (btm_cb.btm_scn, 0, BTM_MAX_SCN); /* Initialize the SCN usage to FALSE */ 76 btm_cb.btm_def_link_policy = 0; 77 btm_cb.p_bl_changed_cb = NULL; 78 #endif 79 80 /* Initialize nonzero defaults */ 81 btm_cb.btm_def_link_super_tout = HCI_DEFAULT_INACT_TOUT; 82 btm_cb.acl_disc_reason = 0xff ; 83 } 84 85 /******************************************************************************* 86 ** 87 ** Function btm_bda_to_acl 88 ** 89 ** Description This function returns the FIRST acl_db entry for the passed BDA. 90 ** 91 ** Parameters bda : BD address of the remote device 92 ** transport : Physical transport used for ACL connection (BR/EDR or LE) 93 ** 94 ** Returns Returns pointer to the ACL DB for the requested BDA if found. 95 ** NULL if not found. 96 ** 97 *******************************************************************************/ 98 tACL_CONN *btm_bda_to_acl (BD_ADDR bda, tBT_TRANSPORT transport) 99 { 100 tACL_CONN *p = &btm_cb.acl_db[0]; 101 UINT16 xx; 102 if (bda) 103 { 104 for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p++) 105 { 106 if ((p->in_use) && (!memcmp (p->remote_addr, bda, BD_ADDR_LEN)) 107 #if BLE_INCLUDED == TRUE 108 && p->transport == transport 109 #endif 110 ) 111 { 112 BTM_TRACE_DEBUG ("btm_bda_to_acl found"); 113 return(p); 114 } 115 } 116 } 117 118 /* If here, no BD Addr found */ 119 return((tACL_CONN *)NULL); 120 } 121 122 /******************************************************************************* 123 ** 124 ** Function btm_handle_to_acl_index 125 ** 126 ** Description This function returns the FIRST acl_db entry for the passed hci_handle. 127 ** 128 ** Returns index to the acl_db or MAX_L2CAP_LINKS. 129 ** 130 *******************************************************************************/ 131 UINT8 btm_handle_to_acl_index (UINT16 hci_handle) 132 { 133 tACL_CONN *p = &btm_cb.acl_db[0]; 134 UINT8 xx; 135 BTM_TRACE_DEBUG ("btm_handle_to_acl_index"); 136 for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p++) 137 { 138 if ((p->in_use) && (p->hci_handle == hci_handle)) 139 { 140 break; 141 } 142 } 143 144 /* If here, no BD Addr found */ 145 return(xx); 146 } 147 148 #if BLE_PRIVACY_SPT == TRUE 149 /******************************************************************************* 150 ** 151 ** Function btm_ble_get_acl_remote_addr 152 ** 153 ** Description This function reads the active remote address used for the 154 ** connection. 155 ** 156 ** Returns success return TRUE, otherwise FALSE. 157 ** 158 *******************************************************************************/ 159 BOOLEAN btm_ble_get_acl_remote_addr(tBTM_SEC_DEV_REC *p_dev_rec, BD_ADDR conn_addr, 160 tBLE_ADDR_TYPE *p_addr_type) 161 { 162 #if BLE_INCLUDED == TRUE 163 BOOLEAN st = TRUE; 164 165 if (p_dev_rec == NULL) 166 { 167 BTM_TRACE_ERROR("btm_ble_get_acl_remote_addr can not find device with matching address"); 168 return FALSE; 169 } 170 171 switch (p_dev_rec->ble.active_addr_type) 172 { 173 case BTM_BLE_ADDR_PSEUDO: 174 memcpy(conn_addr, p_dev_rec->bd_addr, BD_ADDR_LEN); 175 * p_addr_type = p_dev_rec->ble.ble_addr_type; 176 break; 177 178 case BTM_BLE_ADDR_RRA: 179 memcpy(conn_addr, p_dev_rec->ble.cur_rand_addr, BD_ADDR_LEN); 180 * p_addr_type = BLE_ADDR_RANDOM; 181 break; 182 183 case BTM_BLE_ADDR_STATIC: 184 memcpy(conn_addr, p_dev_rec->ble.static_addr, BD_ADDR_LEN); 185 * p_addr_type = p_dev_rec->ble.static_addr_type; 186 break; 187 188 default: 189 BTM_TRACE_ERROR("Unknown active address: %d", p_dev_rec->ble.active_addr_type); 190 st = FALSE; 191 break; 192 } 193 194 return st; 195 #else 196 UNUSED(p_dev_rec); 197 UNUSED(conn_addr); 198 UNUSED(p_addr_type); 199 return FALSE; 200 #endif 201 } 202 #endif 203 /******************************************************************************* 204 ** 205 ** Function btm_acl_created 206 ** 207 ** Description This function is called by L2CAP when an ACL connection 208 ** is created. 209 ** 210 ** Returns void 211 ** 212 *******************************************************************************/ 213 void btm_acl_created (BD_ADDR bda, DEV_CLASS dc, BD_NAME bdn, 214 UINT16 hci_handle, UINT8 link_role, tBT_TRANSPORT transport) 215 { 216 tBTM_SEC_DEV_REC *p_dev_rec = NULL; 217 tACL_CONN *p; 218 UINT8 xx; 219 220 BTM_TRACE_DEBUG ("btm_acl_created hci_handle=%d link_role=%d transport=%d", 221 hci_handle,link_role, transport); 222 /* Ensure we don't have duplicates */ 223 p = btm_bda_to_acl(bda, transport); 224 if (p != (tACL_CONN *)NULL) 225 { 226 p->hci_handle = hci_handle; 227 p->link_role = link_role; 228 #if BLE_INCLUDED == TRUE 229 p->transport = transport; 230 #endif 231 BTM_TRACE_DEBUG ("Duplicate btm_acl_created: RemBdAddr: %02x%02x%02x%02x%02x%02x", 232 bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]); 233 BTM_SetLinkPolicy(p->remote_addr, &btm_cb.btm_def_link_policy); 234 return; 235 } 236 237 /* Allocate acl_db entry */ 238 for (xx = 0, p = &btm_cb.acl_db[0]; xx < MAX_L2CAP_LINKS; xx++, p++) 239 { 240 if (!p->in_use) 241 { 242 p->in_use = TRUE; 243 p->hci_handle = hci_handle; 244 p->link_role = link_role; 245 p->link_up_issued = FALSE; 246 memcpy (p->remote_addr, bda, BD_ADDR_LEN); 247 248 #if BLE_INCLUDED == TRUE 249 p->transport = transport; 250 #if BLE_PRIVACY_SPT == TRUE 251 if (transport == BT_TRANSPORT_LE) 252 btm_ble_refresh_local_resolvable_private_addr(bda, 253 btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr); 254 #else 255 p->conn_addr_type = BLE_ADDR_PUBLIC; 256 memcpy(p->conn_addr, &controller_get_interface()->get_address()->address, BD_ADDR_LEN); 257 258 #endif 259 #endif 260 p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE; 261 262 btm_pm_sm_alloc(xx); 263 264 265 if (dc) 266 memcpy (p->remote_dc, dc, DEV_CLASS_LEN); 267 268 if (bdn) 269 memcpy (p->remote_name, bdn, BTM_MAX_REM_BD_NAME_LEN); 270 271 /* if BR/EDR do something more */ 272 if (transport == BT_TRANSPORT_BR_EDR) 273 { 274 btsnd_hcic_read_rmt_clk_offset (p->hci_handle); 275 btsnd_hcic_rmt_ver_req (p->hci_handle); 276 } 277 p_dev_rec = btm_find_dev_by_handle (hci_handle); 278 279 #if (BLE_INCLUDED == TRUE) 280 if (p_dev_rec ) 281 { 282 BTM_TRACE_DEBUG ("device_type=0x%x", p_dev_rec->device_type); 283 } 284 #endif 285 286 if (p_dev_rec && !(transport == BT_TRANSPORT_LE)) 287 { 288 /* If remote features already known, copy them and continue connection setup */ 289 if ((p_dev_rec->num_read_pages) && 290 (p_dev_rec->num_read_pages <= (HCI_EXT_FEATURES_PAGE_MAX + 1))) 291 { 292 memcpy (p->peer_lmp_features, p_dev_rec->features, 293 (HCI_FEATURE_BYTES_PER_PAGE * p_dev_rec->num_read_pages)); 294 p->num_read_pages = p_dev_rec->num_read_pages; 295 296 const UINT8 req_pend = (p_dev_rec->sm4 & BTM_SM4_REQ_PEND); 297 298 /* Store the Peer Security Capabilites (in SM4 and rmt_sec_caps) */ 299 btm_sec_set_peer_sec_caps(p, p_dev_rec); 300 301 BTM_TRACE_API("%s: pend:%d", __FUNCTION__, req_pend); 302 if (req_pend) 303 { 304 /* Request for remaining Security Features (if any) */ 305 l2cu_resubmit_pending_sec_req (p_dev_rec->bd_addr); 306 } 307 btm_establish_continue (p); 308 return; 309 } 310 } 311 312 #if (BLE_INCLUDED == TRUE) 313 /* If here, features are not known yet */ 314 if (p_dev_rec && transport == BT_TRANSPORT_LE) 315 { 316 #if BLE_PRIVACY_SPT == TRUE 317 btm_ble_get_acl_remote_addr (p_dev_rec, p->active_remote_addr, 318 &p->active_remote_addr_type); 319 #endif 320 321 if (HCI_LE_SLAVE_INIT_FEAT_EXC_SUPPORTED(controller_get_interface()->get_features_ble()->as_array) 322 || link_role == HCI_ROLE_MASTER) 323 { 324 btsnd_hcic_ble_read_remote_feat(p->hci_handle); 325 } 326 else 327 { 328 btm_establish_continue(p); 329 } 330 } 331 else 332 #endif 333 { 334 btm_read_remote_features (p->hci_handle); 335 } 336 337 /* read page 1 - on rmt feature event for buffer reasons */ 338 return; 339 } 340 } 341 } 342 343 344 /******************************************************************************* 345 ** 346 ** Function btm_acl_report_role_change 347 ** 348 ** Description This function is called when the local device is deemed 349 ** to be down. It notifies L2CAP of the failure. 350 ** 351 ** Returns void 352 ** 353 *******************************************************************************/ 354 void btm_acl_report_role_change (UINT8 hci_status, BD_ADDR bda) 355 { 356 tBTM_ROLE_SWITCH_CMPL ref_data; 357 BTM_TRACE_DEBUG ("btm_acl_report_role_change"); 358 if (btm_cb.devcb.p_switch_role_cb 359 && (bda && (0 == memcmp(btm_cb.devcb.switch_role_ref_data.remote_bd_addr, bda, BD_ADDR_LEN)))) 360 { 361 memcpy (&ref_data, &btm_cb.devcb.switch_role_ref_data, sizeof(tBTM_ROLE_SWITCH_CMPL)); 362 ref_data.hci_status = hci_status; 363 (*btm_cb.devcb.p_switch_role_cb)(&ref_data); 364 memset (&btm_cb.devcb.switch_role_ref_data, 0, sizeof(tBTM_ROLE_SWITCH_CMPL)); 365 btm_cb.devcb.p_switch_role_cb = NULL; 366 } 367 } 368 369 /******************************************************************************* 370 ** 371 ** Function btm_acl_removed 372 ** 373 ** Description This function is called by L2CAP when an ACL connection 374 ** is removed. Since only L2CAP creates ACL links, we use 375 ** the L2CAP link index as our index into the control blocks. 376 ** 377 ** Returns void 378 ** 379 *******************************************************************************/ 380 void btm_acl_removed (BD_ADDR bda, tBT_TRANSPORT transport) 381 { 382 tACL_CONN *p; 383 tBTM_BL_EVENT_DATA evt_data; 384 #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE) 385 tBTM_SEC_DEV_REC *p_dev_rec=NULL; 386 #endif 387 BTM_TRACE_DEBUG ("btm_acl_removed"); 388 p = btm_bda_to_acl(bda, transport); 389 if (p != (tACL_CONN *)NULL) 390 { 391 p->in_use = FALSE; 392 393 /* if the disconnected channel has a pending role switch, clear it now */ 394 btm_acl_report_role_change(HCI_ERR_NO_CONNECTION, bda); 395 396 /* Only notify if link up has had a chance to be issued */ 397 if (p->link_up_issued) 398 { 399 p->link_up_issued = FALSE; 400 401 /* If anyone cares, tell him database changed */ 402 if (btm_cb.p_bl_changed_cb) 403 { 404 evt_data.event = BTM_BL_DISCN_EVT; 405 evt_data.discn.p_bda = bda; 406 #if BLE_INCLUDED == TRUE 407 evt_data.discn.handle = p->hci_handle; 408 evt_data.discn.transport = p->transport; 409 #endif 410 (*btm_cb.p_bl_changed_cb)(&evt_data); 411 } 412 413 btm_acl_update_busy_level (BTM_BLI_ACL_DOWN_EVT); 414 } 415 416 #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE) 417 418 BTM_TRACE_DEBUG ("acl hci_handle=%d transport=%d connectable_mode=0x%0x link_role=%d", 419 p->hci_handle, 420 p->transport, 421 btm_cb.ble_ctr_cb.inq_var.connectable_mode, 422 p->link_role); 423 424 p_dev_rec = btm_find_dev(bda); 425 if ( p_dev_rec) 426 { 427 BTM_TRACE_DEBUG("before update p_dev_rec->sec_flags=0x%x", p_dev_rec->sec_flags); 428 if (p->transport == BT_TRANSPORT_LE) 429 { 430 BTM_TRACE_DEBUG("LE link down"); 431 p_dev_rec->sec_flags &= ~(BTM_SEC_LE_ENCRYPTED | BTM_SEC_ROLE_SWITCHED); 432 if ( (p_dev_rec->sec_flags & BTM_SEC_LE_LINK_KEY_KNOWN) == 0) 433 { 434 BTM_TRACE_DEBUG("Not Bonded"); 435 p_dev_rec->sec_flags &= ~(BTM_SEC_LE_LINK_KEY_AUTHED | BTM_SEC_LE_AUTHENTICATED); 436 } 437 else 438 { 439 BTM_TRACE_DEBUG("Bonded"); 440 } 441 } 442 else 443 { 444 BTM_TRACE_DEBUG("Bletooth link down"); 445 p_dev_rec->sec_flags &= ~(BTM_SEC_AUTHORIZED | BTM_SEC_AUTHENTICATED 446 | BTM_SEC_ENCRYPTED | BTM_SEC_ROLE_SWITCHED); 447 } 448 BTM_TRACE_DEBUG("after update p_dev_rec->sec_flags=0x%x", p_dev_rec->sec_flags); 449 } 450 else 451 { 452 BTM_TRACE_ERROR("Device not found"); 453 454 } 455 #endif 456 457 /* Clear the ACL connection data */ 458 memset(p, 0, sizeof(tACL_CONN)); 459 } 460 } 461 462 463 /******************************************************************************* 464 ** 465 ** Function btm_acl_device_down 466 ** 467 ** Description This function is called when the local device is deemed 468 ** to be down. It notifies L2CAP of the failure. 469 ** 470 ** Returns void 471 ** 472 *******************************************************************************/ 473 void btm_acl_device_down (void) 474 { 475 tACL_CONN *p = &btm_cb.acl_db[0]; 476 UINT16 xx; 477 BTM_TRACE_DEBUG ("btm_acl_device_down"); 478 for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p++) 479 { 480 if (p->in_use) 481 { 482 BTM_TRACE_DEBUG ("hci_handle=%d HCI_ERR_HW_FAILURE ",p->hci_handle ); 483 l2c_link_hci_disc_comp (p->hci_handle, HCI_ERR_HW_FAILURE); 484 } 485 } 486 } 487 488 /******************************************************************************* 489 ** 490 ** Function btm_acl_update_busy_level 491 ** 492 ** Description This function is called to update the busy level of the system 493 ** . 494 ** 495 ** Returns void 496 ** 497 *******************************************************************************/ 498 void btm_acl_update_busy_level (tBTM_BLI_EVENT event) 499 { 500 tBTM_BL_UPDATE_DATA evt; 501 UINT8 busy_level; 502 BTM_TRACE_DEBUG ("btm_acl_update_busy_level"); 503 BOOLEAN old_inquiry_state = btm_cb.is_inquiry; 504 switch (event) 505 { 506 case BTM_BLI_ACL_UP_EVT: 507 BTM_TRACE_DEBUG ("BTM_BLI_ACL_UP_EVT"); 508 break; 509 case BTM_BLI_ACL_DOWN_EVT: 510 BTM_TRACE_DEBUG ("BTM_BLI_ACL_DOWN_EVT"); 511 break; 512 case BTM_BLI_PAGE_EVT: 513 BTM_TRACE_DEBUG ("BTM_BLI_PAGE_EVT"); 514 btm_cb.is_paging = TRUE; 515 evt.busy_level_flags= BTM_BL_PAGING_STARTED; 516 break; 517 case BTM_BLI_PAGE_DONE_EVT: 518 BTM_TRACE_DEBUG ("BTM_BLI_PAGE_DONE_EVT"); 519 btm_cb.is_paging = FALSE; 520 evt.busy_level_flags = BTM_BL_PAGING_COMPLETE; 521 break; 522 case BTM_BLI_INQ_EVT: 523 BTM_TRACE_DEBUG ("BTM_BLI_INQ_EVT"); 524 btm_cb.is_inquiry = TRUE; 525 evt.busy_level_flags = BTM_BL_INQUIRY_STARTED; 526 break; 527 case BTM_BLI_INQ_CANCEL_EVT: 528 BTM_TRACE_DEBUG ("BTM_BLI_INQ_CANCEL_EVT"); 529 btm_cb.is_inquiry = FALSE; 530 evt.busy_level_flags = BTM_BL_INQUIRY_CANCELLED; 531 break; 532 case BTM_BLI_INQ_DONE_EVT: 533 BTM_TRACE_DEBUG ("BTM_BLI_INQ_DONE_EVT"); 534 btm_cb.is_inquiry = FALSE; 535 evt.busy_level_flags = BTM_BL_INQUIRY_COMPLETE; 536 break; 537 } 538 539 if (btm_cb.is_paging || btm_cb.is_inquiry) 540 busy_level = 10; 541 else 542 busy_level = BTM_GetNumAclLinks(); 543 544 if ((busy_level != btm_cb.busy_level) ||(old_inquiry_state != btm_cb.is_inquiry)) 545 { 546 evt.event = BTM_BL_UPDATE_EVT; 547 evt.busy_level = busy_level; 548 btm_cb.busy_level = busy_level; 549 if (btm_cb.p_bl_changed_cb && (btm_cb.bl_evt_mask & BTM_BL_UPDATE_MASK)) 550 { 551 (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA *)&evt); 552 } 553 } 554 } 555 556 /******************************************************************************* 557 ** 558 ** Function BTM_GetRole 559 ** 560 ** Description This function is called to get the role of the local device 561 ** for the ACL connection with the specified remote device 562 ** 563 ** Returns BTM_SUCCESS if connection exists. 564 ** BTM_UNKNOWN_ADDR if no active link with bd addr specified 565 ** 566 *******************************************************************************/ 567 tBTM_STATUS BTM_GetRole (BD_ADDR remote_bd_addr, UINT8 *p_role) 568 { 569 tACL_CONN *p; 570 BTM_TRACE_DEBUG ("BTM_GetRole"); 571 if ((p = btm_bda_to_acl(remote_bd_addr, BT_TRANSPORT_BR_EDR)) == NULL) 572 { 573 *p_role = BTM_ROLE_UNDEFINED; 574 return(BTM_UNKNOWN_ADDR); 575 } 576 577 /* Get the current role */ 578 *p_role = p->link_role; 579 return(BTM_SUCCESS); 580 } 581 582 583 /******************************************************************************* 584 ** 585 ** Function BTM_SwitchRole 586 ** 587 ** Description This function is called to switch role between master and 588 ** slave. If role is already set it will do nothing. If the 589 ** command was initiated, the callback function is called upon 590 ** completion. 591 ** 592 ** Returns BTM_SUCCESS if already in specified role. 593 ** BTM_CMD_STARTED if command issued to controller. 594 ** BTM_NO_RESOURCES if couldn't allocate memory to issue command 595 ** BTM_UNKNOWN_ADDR if no active link with bd addr specified 596 ** BTM_MODE_UNSUPPORTED if local device does not support role switching 597 ** BTM_BUSY if the previous command is not completed 598 ** 599 *******************************************************************************/ 600 tBTM_STATUS BTM_SwitchRole (BD_ADDR remote_bd_addr, UINT8 new_role, tBTM_CMPL_CB *p_cb) 601 { 602 tACL_CONN *p; 603 tBTM_SEC_DEV_REC *p_dev_rec = NULL; 604 #if BTM_SCO_INCLUDED == TRUE 605 BOOLEAN is_sco_active; 606 #endif 607 tBTM_STATUS status; 608 tBTM_PM_MODE pwr_mode; 609 tBTM_PM_PWR_MD settings; 610 #if (BT_USE_TRACES == TRUE) 611 BD_ADDR_PTR p_bda; 612 #endif 613 BTM_TRACE_API ("BTM_SwitchRole BDA: %02x-%02x-%02x-%02x-%02x-%02x", 614 remote_bd_addr[0], remote_bd_addr[1], remote_bd_addr[2], 615 remote_bd_addr[3], remote_bd_addr[4], remote_bd_addr[5]); 616 617 /* Make sure the local device supports switching */ 618 if (!controller_get_interface()->supports_master_slave_role_switch()) 619 return(BTM_MODE_UNSUPPORTED); 620 621 if (btm_cb.devcb.p_switch_role_cb && p_cb) 622 { 623 #if (BT_USE_TRACES == TRUE) 624 p_bda = btm_cb.devcb.switch_role_ref_data.remote_bd_addr; 625 BTM_TRACE_DEBUG ("Role switch on other device is in progress 0x%02x%02x%02x%02x%02x%02x", 626 p_bda[0], p_bda[1], p_bda[2], 627 p_bda[3], p_bda[4], p_bda[5]); 628 #endif 629 return(BTM_BUSY); 630 } 631 632 if ((p = btm_bda_to_acl(remote_bd_addr, BT_TRANSPORT_BR_EDR)) == NULL) 633 return(BTM_UNKNOWN_ADDR); 634 635 /* Finished if already in desired role */ 636 if (p->link_role == new_role) 637 return(BTM_SUCCESS); 638 639 #if BTM_SCO_INCLUDED == TRUE 640 /* Check if there is any SCO Active on this BD Address */ 641 is_sco_active = btm_is_sco_active_by_bdaddr(remote_bd_addr); 642 643 if (is_sco_active == TRUE) 644 return(BTM_NO_RESOURCES); 645 #endif 646 647 /* Ignore role switch request if the previous request was not completed */ 648 if (p->switch_role_state != BTM_ACL_SWKEY_STATE_IDLE) 649 { 650 BTM_TRACE_DEBUG ("BTM_SwitchRole busy: %d", 651 p->switch_role_state); 652 return(BTM_BUSY); 653 } 654 655 if ((status = BTM_ReadPowerMode(p->remote_addr, &pwr_mode)) != BTM_SUCCESS) 656 return(status); 657 658 /* Wake up the link if in sniff or park before attempting switch */ 659 if (pwr_mode == BTM_PM_MD_PARK || pwr_mode == BTM_PM_MD_SNIFF) 660 { 661 memset( (void*)&settings, 0, sizeof(settings)); 662 settings.mode = BTM_PM_MD_ACTIVE; 663 status = BTM_SetPowerMode (BTM_PM_SET_ONLY_ID, p->remote_addr, &settings); 664 if (status != BTM_CMD_STARTED) 665 return(BTM_WRONG_MODE); 666 667 p->switch_role_state = BTM_ACL_SWKEY_STATE_MODE_CHANGE; 668 } 669 /* some devices do not support switch while encryption is on */ 670 else 671 { 672 p_dev_rec = btm_find_dev (remote_bd_addr); 673 if ((p_dev_rec != NULL) 674 && ((p_dev_rec->sec_flags & BTM_SEC_ENCRYPTED) != 0) 675 && !BTM_EPR_AVAILABLE(p)) 676 { 677 /* bypass turning off encryption if change link key is already doing it */ 678 if (p->encrypt_state != BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF) 679 { 680 if (!btsnd_hcic_set_conn_encrypt (p->hci_handle, FALSE)) 681 return(BTM_NO_RESOURCES); 682 else 683 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF; 684 } 685 686 p->switch_role_state = BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF; 687 } 688 else 689 { 690 if (!btsnd_hcic_switch_role (remote_bd_addr, new_role)) 691 return(BTM_NO_RESOURCES); 692 693 p->switch_role_state = BTM_ACL_SWKEY_STATE_IN_PROGRESS; 694 695 #if BTM_DISC_DURING_RS == TRUE 696 if (p_dev_rec) 697 p_dev_rec->rs_disc_pending = BTM_SEC_RS_PENDING; 698 #endif 699 } 700 } 701 702 /* Initialize return structure in case request fails */ 703 if (p_cb) 704 { 705 memcpy (btm_cb.devcb.switch_role_ref_data.remote_bd_addr, remote_bd_addr, 706 BD_ADDR_LEN); 707 btm_cb.devcb.switch_role_ref_data.role = new_role; 708 /* initialized to an error code */ 709 btm_cb.devcb.switch_role_ref_data.hci_status = HCI_ERR_UNSUPPORTED_VALUE; 710 btm_cb.devcb.p_switch_role_cb = p_cb; 711 } 712 return(BTM_CMD_STARTED); 713 } 714 715 /******************************************************************************* 716 ** 717 ** Function btm_acl_encrypt_change 718 ** 719 ** Description This function is when encryption of the connection is 720 ** completed by the LM. Checks to see if a role switch or 721 ** change of link key was active and initiates or continues 722 ** process if needed. 723 ** 724 ** Returns void 725 ** 726 *******************************************************************************/ 727 void btm_acl_encrypt_change (UINT16 handle, UINT8 status, UINT8 encr_enable) 728 { 729 tACL_CONN *p; 730 UINT8 xx; 731 tBTM_SEC_DEV_REC *p_dev_rec; 732 tBTM_BL_ROLE_CHG_DATA evt; 733 734 BTM_TRACE_DEBUG ("btm_acl_encrypt_change handle=%d status=%d encr_enabl=%d", 735 handle, status, encr_enable); 736 xx = btm_handle_to_acl_index(handle); 737 /* don't assume that we can never get a bad hci_handle */ 738 if (xx < MAX_L2CAP_LINKS) 739 p = &btm_cb.acl_db[xx]; 740 else 741 return; 742 743 /* Process Role Switch if active */ 744 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF) 745 { 746 /* if encryption turn off failed we still will try to switch role */ 747 if (encr_enable) 748 { 749 p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE; 750 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE; 751 } 752 else 753 { 754 p->switch_role_state = BTM_ACL_SWKEY_STATE_SWITCHING; 755 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_TEMP_FUNC; 756 } 757 758 if (!btsnd_hcic_switch_role (p->remote_addr, (UINT8)!p->link_role)) 759 { 760 p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE; 761 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE; 762 btm_acl_report_role_change(btm_cb.devcb.switch_role_ref_data.hci_status, p->remote_addr); 763 } 764 #if BTM_DISC_DURING_RS == TRUE 765 else 766 { 767 if ((p_dev_rec = btm_find_dev (p->remote_addr)) != NULL) 768 p_dev_rec->rs_disc_pending = BTM_SEC_RS_PENDING; 769 } 770 #endif 771 772 } 773 /* Finished enabling Encryption after role switch */ 774 else if (p->switch_role_state == BTM_ACL_SWKEY_STATE_ENCRYPTION_ON) 775 { 776 p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE; 777 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE; 778 btm_acl_report_role_change(btm_cb.devcb.switch_role_ref_data.hci_status, p->remote_addr); 779 780 /* if role change event is registered, report it now */ 781 if (btm_cb.p_bl_changed_cb && (btm_cb.bl_evt_mask & BTM_BL_ROLE_CHG_MASK)) 782 { 783 evt.event = BTM_BL_ROLE_CHG_EVT; 784 evt.new_role = btm_cb.devcb.switch_role_ref_data.role; 785 evt.p_bda = btm_cb.devcb.switch_role_ref_data.remote_bd_addr; 786 evt.hci_status = btm_cb.devcb.switch_role_ref_data.hci_status; 787 (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA *)&evt); 788 789 BTM_TRACE_DEBUG("Role Switch Event: new_role 0x%02x, HCI Status 0x%02x, rs_st:%d", 790 evt.new_role, evt.hci_status, p->switch_role_state); 791 } 792 793 #if BTM_DISC_DURING_RS == TRUE 794 /* If a disconnect is pending, issue it now that role switch has completed */ 795 if ((p_dev_rec = btm_find_dev (p->remote_addr)) != NULL) 796 { 797 if (p_dev_rec->rs_disc_pending == BTM_SEC_DISC_PENDING) 798 { 799 BTM_TRACE_WARNING("btm_acl_encrypt_change -> Issuing delayed HCI_Disconnect!!!"); 800 btsnd_hcic_disconnect(p_dev_rec->hci_handle, HCI_ERR_PEER_USER); 801 } 802 BTM_TRACE_ERROR("btm_acl_encrypt_change: tBTM_SEC_DEV:0x%x rs_disc_pending=%d", 803 PTR_TO_UINT(p_dev_rec), p_dev_rec->rs_disc_pending); 804 p_dev_rec->rs_disc_pending = BTM_SEC_RS_NOT_PENDING; /* reset flag */ 805 } 806 #endif 807 } 808 } 809 /******************************************************************************* 810 ** 811 ** Function BTM_SetLinkPolicy 812 ** 813 ** Description Create and send HCI "Write Policy Set" command 814 ** 815 ** Returns status of the operation 816 ** 817 *******************************************************************************/ 818 tBTM_STATUS BTM_SetLinkPolicy (BD_ADDR remote_bda, UINT16 *settings) 819 { 820 tACL_CONN *p; 821 UINT8 *localFeatures = BTM_ReadLocalFeatures(); 822 BTM_TRACE_DEBUG ("BTM_SetLinkPolicy"); 823 /* BTM_TRACE_API ("BTM_SetLinkPolicy: requested settings: 0x%04x", *settings ); */ 824 825 /* First, check if hold mode is supported */ 826 if (*settings != HCI_DISABLE_ALL_LM_MODES) 827 { 828 if ( (*settings & HCI_ENABLE_MASTER_SLAVE_SWITCH) && (!HCI_SWITCH_SUPPORTED(localFeatures)) ) 829 { 830 *settings &= (~HCI_ENABLE_MASTER_SLAVE_SWITCH); 831 BTM_TRACE_API ("BTM_SetLinkPolicy switch not supported (settings: 0x%04x)", *settings ); 832 } 833 if ( (*settings & HCI_ENABLE_HOLD_MODE) && (!HCI_HOLD_MODE_SUPPORTED(localFeatures)) ) 834 { 835 *settings &= (~HCI_ENABLE_HOLD_MODE); 836 BTM_TRACE_API ("BTM_SetLinkPolicy hold not supported (settings: 0x%04x)", *settings ); 837 } 838 if ( (*settings & HCI_ENABLE_SNIFF_MODE) && (!HCI_SNIFF_MODE_SUPPORTED(localFeatures)) ) 839 { 840 *settings &= (~HCI_ENABLE_SNIFF_MODE); 841 BTM_TRACE_API ("BTM_SetLinkPolicy sniff not supported (settings: 0x%04x)", *settings ); 842 } 843 if ( (*settings & HCI_ENABLE_PARK_MODE) && (!HCI_PARK_MODE_SUPPORTED(localFeatures)) ) 844 { 845 *settings &= (~HCI_ENABLE_PARK_MODE); 846 BTM_TRACE_API ("BTM_SetLinkPolicy park not supported (settings: 0x%04x)", *settings ); 847 } 848 } 849 850 if ((p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR)) != NULL) 851 return(btsnd_hcic_write_policy_set (p->hci_handle, *settings) ? BTM_CMD_STARTED : BTM_NO_RESOURCES); 852 853 /* If here, no BD Addr found */ 854 return(BTM_UNKNOWN_ADDR); 855 } 856 857 /******************************************************************************* 858 ** 859 ** Function BTM_SetDefaultLinkPolicy 860 ** 861 ** Description Set the default value for HCI "Write Policy Set" command 862 ** to use when an ACL link is created. 863 ** 864 ** Returns void 865 ** 866 *******************************************************************************/ 867 void BTM_SetDefaultLinkPolicy (UINT16 settings) 868 { 869 UINT8 *localFeatures = BTM_ReadLocalFeatures(); 870 871 BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy setting:0x%04x", settings); 872 873 if((settings & HCI_ENABLE_MASTER_SLAVE_SWITCH) && (!HCI_SWITCH_SUPPORTED(localFeatures))) 874 { 875 settings &= ~HCI_ENABLE_MASTER_SLAVE_SWITCH; 876 BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy switch not supported (settings: 0x%04x)", settings); 877 } 878 if ((settings & HCI_ENABLE_HOLD_MODE) && (!HCI_HOLD_MODE_SUPPORTED(localFeatures))) 879 { 880 settings &= ~HCI_ENABLE_HOLD_MODE; 881 BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy hold not supported (settings: 0x%04x)", settings); 882 } 883 if ((settings & HCI_ENABLE_SNIFF_MODE) && (!HCI_SNIFF_MODE_SUPPORTED(localFeatures))) 884 { 885 settings &= ~HCI_ENABLE_SNIFF_MODE; 886 BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy sniff not supported (settings: 0x%04x)", settings); 887 } 888 if ((settings & HCI_ENABLE_PARK_MODE) && (!HCI_PARK_MODE_SUPPORTED(localFeatures))) 889 { 890 settings &= ~HCI_ENABLE_PARK_MODE; 891 BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy park not supported (settings: 0x%04x)", settings); 892 } 893 BTM_TRACE_DEBUG("Set DefaultLinkPolicy:0x%04x", settings); 894 895 btm_cb.btm_def_link_policy = settings; 896 897 /* Set the default Link Policy of the controller */ 898 btsnd_hcic_write_def_policy_set(settings); 899 } 900 901 /******************************************************************************* 902 ** 903 ** Function btm_read_remote_version_complete 904 ** 905 ** Description This function is called when the command complete message 906 ** is received from the HCI for the remote version info. 907 ** 908 ** Returns void 909 ** 910 *******************************************************************************/ 911 void btm_read_remote_version_complete (UINT8 *p) 912 { 913 tACL_CONN *p_acl_cb = &btm_cb.acl_db[0]; 914 UINT8 status; 915 UINT16 handle; 916 int xx; 917 BTM_TRACE_DEBUG ("btm_read_remote_version_complete"); 918 919 STREAM_TO_UINT8 (status, p); 920 STREAM_TO_UINT16 (handle, p); 921 922 /* Look up the connection by handle and copy features */ 923 for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p_acl_cb++) 924 { 925 if ((p_acl_cb->in_use) && (p_acl_cb->hci_handle == handle)) 926 { 927 if (status == HCI_SUCCESS) 928 { 929 STREAM_TO_UINT8 (p_acl_cb->lmp_version, p); 930 STREAM_TO_UINT16 (p_acl_cb->manufacturer, p); 931 STREAM_TO_UINT16 (p_acl_cb->lmp_subversion, p); 932 } 933 934 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE)) 935 if (p_acl_cb->transport == BT_TRANSPORT_LE) 936 l2cble_notify_le_connection (p_acl_cb->remote_addr); 937 #endif // (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE)) 938 break; 939 } 940 } 941 } 942 943 944 /******************************************************************************* 945 ** 946 ** Function btm_process_remote_ext_features 947 ** 948 ** Description Local function called to process all extended features pages 949 ** read from a remote device. 950 ** 951 ** Returns void 952 ** 953 *******************************************************************************/ 954 void btm_process_remote_ext_features (tACL_CONN *p_acl_cb, UINT8 num_read_pages) 955 { 956 UINT16 handle = p_acl_cb->hci_handle; 957 tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev_by_handle (handle); 958 UINT8 page_idx; 959 960 BTM_TRACE_DEBUG ("btm_process_remote_ext_features"); 961 962 /* Make sure we have the record to save remote features information */ 963 if (p_dev_rec == NULL) 964 { 965 /* Get a new device; might be doing dedicated bonding */ 966 p_dev_rec = btm_find_or_alloc_dev (p_acl_cb->remote_addr); 967 } 968 969 p_acl_cb->num_read_pages = num_read_pages; 970 p_dev_rec->num_read_pages = num_read_pages; 971 972 /* Move the pages to placeholder */ 973 for (page_idx = 0; page_idx < num_read_pages; page_idx++) 974 { 975 if (page_idx > HCI_EXT_FEATURES_PAGE_MAX) 976 { 977 BTM_TRACE_ERROR("%s: page=%d unexpected", __FUNCTION__, page_idx); 978 break; 979 } 980 memcpy (p_dev_rec->features[page_idx], p_acl_cb->peer_lmp_features[page_idx], 981 HCI_FEATURE_BYTES_PER_PAGE); 982 } 983 984 const UINT8 req_pend = (p_dev_rec->sm4 & BTM_SM4_REQ_PEND); 985 986 /* Store the Peer Security Capabilites (in SM4 and rmt_sec_caps) */ 987 btm_sec_set_peer_sec_caps(p_acl_cb, p_dev_rec); 988 989 BTM_TRACE_API("%s: pend:%d", __FUNCTION__, req_pend); 990 if (req_pend) 991 { 992 /* Request for remaining Security Features (if any) */ 993 l2cu_resubmit_pending_sec_req (p_dev_rec->bd_addr); 994 } 995 } 996 997 998 /******************************************************************************* 999 ** 1000 ** Function btm_read_remote_features 1001 ** 1002 ** Description Local function called to send a read remote supported features/ 1003 ** remote extended features page[0]. 1004 ** 1005 ** Returns void 1006 ** 1007 *******************************************************************************/ 1008 void btm_read_remote_features (UINT16 handle) 1009 { 1010 UINT8 acl_idx; 1011 tACL_CONN *p_acl_cb; 1012 1013 BTM_TRACE_DEBUG("btm_read_remote_features() handle: %d", handle); 1014 1015 if ((acl_idx = btm_handle_to_acl_index(handle)) >= MAX_L2CAP_LINKS) 1016 { 1017 BTM_TRACE_ERROR("btm_read_remote_features handle=%d invalid", handle); 1018 return; 1019 } 1020 1021 p_acl_cb = &btm_cb.acl_db[acl_idx]; 1022 p_acl_cb->num_read_pages = 0; 1023 memset (p_acl_cb->peer_lmp_features, 0, sizeof(p_acl_cb->peer_lmp_features)); 1024 1025 /* first send read remote supported features HCI command */ 1026 /* because we don't know whether the remote support extended feature command */ 1027 btsnd_hcic_rmt_features_req (handle); 1028 } 1029 1030 1031 /******************************************************************************* 1032 ** 1033 ** Function btm_read_remote_ext_features 1034 ** 1035 ** Description Local function called to send a read remote extended features 1036 ** 1037 ** Returns void 1038 ** 1039 *******************************************************************************/ 1040 void btm_read_remote_ext_features (UINT16 handle, UINT8 page_number) 1041 { 1042 BTM_TRACE_DEBUG("btm_read_remote_ext_features() handle: %d page: %d", handle, page_number); 1043 1044 btsnd_hcic_rmt_ext_features(handle, page_number); 1045 } 1046 1047 1048 /******************************************************************************* 1049 ** 1050 ** Function btm_read_remote_features_complete 1051 ** 1052 ** Description This function is called when the remote supported features 1053 ** complete event is received from the HCI. 1054 ** 1055 ** Returns void 1056 ** 1057 *******************************************************************************/ 1058 void btm_read_remote_features_complete (UINT8 *p) 1059 { 1060 tACL_CONN *p_acl_cb; 1061 UINT8 status; 1062 UINT16 handle; 1063 UINT8 acl_idx; 1064 1065 BTM_TRACE_DEBUG ("btm_read_remote_features_complete"); 1066 STREAM_TO_UINT8 (status, p); 1067 1068 if (status != HCI_SUCCESS) 1069 { 1070 BTM_TRACE_ERROR ("btm_read_remote_features_complete failed (status 0x%02x)", status); 1071 return; 1072 } 1073 1074 STREAM_TO_UINT16 (handle, p); 1075 1076 if ((acl_idx = btm_handle_to_acl_index(handle)) >= MAX_L2CAP_LINKS) 1077 { 1078 BTM_TRACE_ERROR("btm_read_remote_features_complete handle=%d invalid", handle); 1079 return; 1080 } 1081 1082 p_acl_cb = &btm_cb.acl_db[acl_idx]; 1083 1084 /* Copy the received features page */ 1085 STREAM_TO_ARRAY(p_acl_cb->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0], p, 1086 HCI_FEATURE_BYTES_PER_PAGE); 1087 1088 if ((HCI_LMP_EXTENDED_SUPPORTED(p_acl_cb->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) && 1089 (controller_get_interface()->supports_reading_remote_extended_features())) 1090 { 1091 /* if the remote controller has extended features and local controller supports 1092 ** HCI_Read_Remote_Extended_Features command then start reading these feature starting 1093 ** with extended features page 1 */ 1094 BTM_TRACE_DEBUG ("Start reading remote extended features"); 1095 btm_read_remote_ext_features(handle, HCI_EXT_FEATURES_PAGE_1); 1096 return; 1097 } 1098 1099 /* Remote controller has no extended features. Process remote controller supported features 1100 (features page HCI_EXT_FEATURES_PAGE_0). */ 1101 btm_process_remote_ext_features (p_acl_cb, 1); 1102 1103 /* Continue with HCI connection establishment */ 1104 btm_establish_continue (p_acl_cb); 1105 } 1106 1107 /******************************************************************************* 1108 ** 1109 ** Function btm_read_remote_ext_features_complete 1110 ** 1111 ** Description This function is called when the remote extended features 1112 ** complete event is received from the HCI. 1113 ** 1114 ** Returns void 1115 ** 1116 *******************************************************************************/ 1117 void btm_read_remote_ext_features_complete (UINT8 *p) 1118 { 1119 tACL_CONN *p_acl_cb; 1120 UINT8 page_num, max_page; 1121 UINT16 handle; 1122 UINT8 acl_idx; 1123 1124 BTM_TRACE_DEBUG ("btm_read_remote_ext_features_complete"); 1125 1126 ++p; 1127 STREAM_TO_UINT16 (handle, p); 1128 STREAM_TO_UINT8 (page_num, p); 1129 STREAM_TO_UINT8 (max_page, p); 1130 1131 /* Validate parameters */ 1132 if ((acl_idx = btm_handle_to_acl_index(handle)) >= MAX_L2CAP_LINKS) 1133 { 1134 BTM_TRACE_ERROR("btm_read_remote_ext_features_complete handle=%d invalid", handle); 1135 return; 1136 } 1137 1138 if (max_page > HCI_EXT_FEATURES_PAGE_MAX) 1139 { 1140 BTM_TRACE_ERROR("btm_read_remote_ext_features_complete page=%d unknown", max_page); 1141 return; 1142 } 1143 1144 p_acl_cb = &btm_cb.acl_db[acl_idx]; 1145 1146 /* Copy the received features page */ 1147 STREAM_TO_ARRAY(p_acl_cb->peer_lmp_features[page_num], p, HCI_FEATURE_BYTES_PER_PAGE); 1148 1149 /* If there is the next remote features page and 1150 * we have space to keep this page data - read this page */ 1151 if ((page_num < max_page) && (page_num < HCI_EXT_FEATURES_PAGE_MAX)) 1152 { 1153 page_num++; 1154 BTM_TRACE_DEBUG("BTM reads next remote extended features page (%d)", page_num); 1155 btm_read_remote_ext_features (handle, page_num); 1156 return; 1157 } 1158 1159 /* Reading of remote feature pages is complete */ 1160 BTM_TRACE_DEBUG("BTM reached last remote extended features page (%d)", page_num); 1161 1162 /* Process the pages */ 1163 btm_process_remote_ext_features (p_acl_cb, (UINT8) (page_num + 1)); 1164 1165 /* Continue with HCI connection establishment */ 1166 btm_establish_continue (p_acl_cb); 1167 } 1168 1169 /******************************************************************************* 1170 ** 1171 ** Function btm_read_remote_ext_features_failed 1172 ** 1173 ** Description This function is called when the remote extended features 1174 ** complete event returns a failed status. 1175 ** 1176 ** Returns void 1177 ** 1178 *******************************************************************************/ 1179 void btm_read_remote_ext_features_failed (UINT8 status, UINT16 handle) 1180 { 1181 tACL_CONN *p_acl_cb; 1182 UINT8 acl_idx; 1183 1184 BTM_TRACE_WARNING ("btm_read_remote_ext_features_failed (status 0x%02x) for handle %d", 1185 status, handle); 1186 1187 if ((acl_idx = btm_handle_to_acl_index(handle)) >= MAX_L2CAP_LINKS) 1188 { 1189 BTM_TRACE_ERROR("btm_read_remote_ext_features_failed handle=%d invalid", handle); 1190 return; 1191 } 1192 1193 p_acl_cb = &btm_cb.acl_db[acl_idx]; 1194 1195 /* Process supported features only */ 1196 btm_process_remote_ext_features (p_acl_cb, 1); 1197 1198 /* Continue HCI connection establishment */ 1199 btm_establish_continue (p_acl_cb); 1200 } 1201 1202 /******************************************************************************* 1203 ** 1204 ** Function btm_establish_continue 1205 ** 1206 ** Description This function is called when the command complete message 1207 ** is received from the HCI for the read local link policy request. 1208 ** 1209 ** Returns void 1210 ** 1211 *******************************************************************************/ 1212 void btm_establish_continue (tACL_CONN *p_acl_cb) 1213 { 1214 tBTM_BL_EVENT_DATA evt_data; 1215 BTM_TRACE_DEBUG ("btm_establish_continue"); 1216 #if (!defined(BTM_BYPASS_EXTRA_ACL_SETUP) || BTM_BYPASS_EXTRA_ACL_SETUP == FALSE) 1217 #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE) 1218 if (p_acl_cb->transport == BT_TRANSPORT_BR_EDR) 1219 #endif 1220 { 1221 /* For now there are a some devices that do not like sending */ 1222 /* commands events and data at the same time. */ 1223 /* Set the packet types to the default allowed by the device */ 1224 btm_set_packet_types (p_acl_cb, btm_cb.btm_acl_pkt_types_supported); 1225 1226 if (btm_cb.btm_def_link_policy) 1227 BTM_SetLinkPolicy (p_acl_cb->remote_addr, &btm_cb.btm_def_link_policy); 1228 } 1229 #endif 1230 p_acl_cb->link_up_issued = TRUE; 1231 1232 /* If anyone cares, tell him database changed */ 1233 if (btm_cb.p_bl_changed_cb) 1234 { 1235 evt_data.event = BTM_BL_CONN_EVT; 1236 evt_data.conn.p_bda = p_acl_cb->remote_addr; 1237 evt_data.conn.p_bdn = p_acl_cb->remote_name; 1238 evt_data.conn.p_dc = p_acl_cb->remote_dc; 1239 evt_data.conn.p_features = p_acl_cb->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]; 1240 #if BLE_INCLUDED == TRUE 1241 evt_data.conn.handle = p_acl_cb->hci_handle; 1242 evt_data.conn.transport = p_acl_cb->transport; 1243 #endif 1244 1245 (*btm_cb.p_bl_changed_cb)(&evt_data); 1246 } 1247 btm_acl_update_busy_level (BTM_BLI_ACL_UP_EVT); 1248 } 1249 1250 1251 /******************************************************************************* 1252 ** 1253 ** Function BTM_SetDefaultLinkSuperTout 1254 ** 1255 ** Description Set the default value for HCI "Write Link Supervision Timeout" 1256 ** command to use when an ACL link is created. 1257 ** 1258 ** Returns void 1259 ** 1260 *******************************************************************************/ 1261 void BTM_SetDefaultLinkSuperTout (UINT16 timeout) 1262 { 1263 BTM_TRACE_DEBUG ("BTM_SetDefaultLinkSuperTout"); 1264 btm_cb.btm_def_link_super_tout = timeout; 1265 } 1266 1267 /******************************************************************************* 1268 ** 1269 ** Function BTM_GetLinkSuperTout 1270 ** 1271 ** Description Read the link supervision timeout value of the connection 1272 ** 1273 ** Returns status of the operation 1274 ** 1275 *******************************************************************************/ 1276 tBTM_STATUS BTM_GetLinkSuperTout (BD_ADDR remote_bda, UINT16 *p_timeout) 1277 { 1278 tACL_CONN *p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR); 1279 1280 BTM_TRACE_DEBUG ("BTM_GetLinkSuperTout"); 1281 if (p != (tACL_CONN *)NULL) 1282 { 1283 *p_timeout = p->link_super_tout; 1284 return(BTM_SUCCESS); 1285 } 1286 /* If here, no BD Addr found */ 1287 return(BTM_UNKNOWN_ADDR); 1288 } 1289 1290 1291 /******************************************************************************* 1292 ** 1293 ** Function BTM_SetLinkSuperTout 1294 ** 1295 ** Description Create and send HCI "Write Link Supervision Timeout" command 1296 ** 1297 ** Returns status of the operation 1298 ** 1299 *******************************************************************************/ 1300 tBTM_STATUS BTM_SetLinkSuperTout (BD_ADDR remote_bda, UINT16 timeout) 1301 { 1302 tACL_CONN *p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR); 1303 1304 BTM_TRACE_DEBUG ("BTM_SetLinkSuperTout"); 1305 if (p != (tACL_CONN *)NULL) 1306 { 1307 p->link_super_tout = timeout; 1308 1309 /* Only send if current role is Master; 2.0 spec requires this */ 1310 if (p->link_role == BTM_ROLE_MASTER) 1311 { 1312 if (!btsnd_hcic_write_link_super_tout (LOCAL_BR_EDR_CONTROLLER_ID, 1313 p->hci_handle, timeout)) 1314 return(BTM_NO_RESOURCES); 1315 1316 return(BTM_CMD_STARTED); 1317 } 1318 else 1319 return(BTM_SUCCESS); 1320 } 1321 1322 /* If here, no BD Addr found */ 1323 return(BTM_UNKNOWN_ADDR); 1324 } 1325 1326 /******************************************************************************* 1327 ** 1328 ** Function BTM_IsAclConnectionUp 1329 ** 1330 ** Description This function is called to check if an ACL connection exists 1331 ** to a specific remote BD Address. 1332 ** 1333 ** Returns TRUE if connection is up, else FALSE. 1334 ** 1335 *******************************************************************************/ 1336 BOOLEAN BTM_IsAclConnectionUp (BD_ADDR remote_bda, tBT_TRANSPORT transport) 1337 { 1338 tACL_CONN *p; 1339 1340 BTM_TRACE_API ("BTM_IsAclConnectionUp: RemBdAddr: %02x%02x%02x%02x%02x%02x", 1341 remote_bda[0], remote_bda[1], remote_bda[2], 1342 remote_bda[3], remote_bda[4], remote_bda[5]); 1343 1344 p = btm_bda_to_acl(remote_bda, transport); 1345 if (p != (tACL_CONN *)NULL) 1346 { 1347 return(TRUE); 1348 } 1349 1350 /* If here, no BD Addr found */ 1351 return(FALSE); 1352 } 1353 1354 /******************************************************************************* 1355 ** 1356 ** Function BTM_GetNumAclLinks 1357 ** 1358 ** Description This function is called to count the number of 1359 ** ACL links that are active. 1360 ** 1361 ** Returns UINT16 Number of active ACL links 1362 ** 1363 *******************************************************************************/ 1364 UINT16 BTM_GetNumAclLinks (void) 1365 { 1366 uint16_t num_acl = 0; 1367 1368 for (uint16_t i = 0; i < MAX_L2CAP_LINKS; ++i) 1369 { 1370 if (btm_cb.acl_db[i].in_use) 1371 ++num_acl; 1372 } 1373 1374 return num_acl; 1375 } 1376 1377 /******************************************************************************* 1378 ** 1379 ** Function btm_get_acl_disc_reason_code 1380 ** 1381 ** Description This function is called to get the disconnection reason code 1382 ** returned by the HCI at disconnection complete event. 1383 ** 1384 ** Returns TRUE if connection is up, else FALSE. 1385 ** 1386 *******************************************************************************/ 1387 UINT16 btm_get_acl_disc_reason_code (void) 1388 { 1389 UINT8 res = btm_cb.acl_disc_reason; 1390 BTM_TRACE_DEBUG ("btm_get_acl_disc_reason_code"); 1391 return(res); 1392 } 1393 1394 1395 /******************************************************************************* 1396 ** 1397 ** Function BTM_GetHCIConnHandle 1398 ** 1399 ** Description This function is called to get the handle for an ACL connection 1400 ** to a specific remote BD Address. 1401 ** 1402 ** Returns the handle of the connection, or 0xFFFF if none. 1403 ** 1404 *******************************************************************************/ 1405 UINT16 BTM_GetHCIConnHandle (BD_ADDR remote_bda, tBT_TRANSPORT transport) 1406 { 1407 tACL_CONN *p; 1408 BTM_TRACE_DEBUG ("BTM_GetHCIConnHandle"); 1409 p = btm_bda_to_acl(remote_bda, transport); 1410 if (p != (tACL_CONN *)NULL) 1411 { 1412 return(p->hci_handle); 1413 } 1414 1415 /* If here, no BD Addr found */ 1416 return(0xFFFF); 1417 } 1418 1419 /******************************************************************************* 1420 ** 1421 ** Function btm_process_clk_off_comp_evt 1422 ** 1423 ** Description This function is called when clock offset command completes. 1424 ** 1425 ** Input Parms hci_handle - connection handle associated with the change 1426 ** clock offset 1427 ** 1428 ** Returns void 1429 ** 1430 *******************************************************************************/ 1431 void btm_process_clk_off_comp_evt (UINT16 hci_handle, UINT16 clock_offset) 1432 { 1433 UINT8 xx; 1434 BTM_TRACE_DEBUG ("btm_process_clk_off_comp_evt"); 1435 /* Look up the connection by handle and set the current mode */ 1436 if ((xx = btm_handle_to_acl_index(hci_handle)) < MAX_L2CAP_LINKS) 1437 btm_cb.acl_db[xx].clock_offset = clock_offset; 1438 } 1439 1440 /******************************************************************************* 1441 ** 1442 ** Function btm_acl_role_changed 1443 ** 1444 ** Description This function is called whan a link's master/slave role change 1445 ** event or command status event (with error) is received. 1446 ** It updates the link control block, and calls 1447 ** the registered callback with status and role (if registered). 1448 ** 1449 ** Returns void 1450 ** 1451 *******************************************************************************/ 1452 void btm_acl_role_changed (UINT8 hci_status, BD_ADDR bd_addr, UINT8 new_role) 1453 { 1454 UINT8 *p_bda = (bd_addr) ? bd_addr : 1455 btm_cb.devcb.switch_role_ref_data.remote_bd_addr; 1456 tACL_CONN *p = btm_bda_to_acl(p_bda, BT_TRANSPORT_BR_EDR); 1457 tBTM_ROLE_SWITCH_CMPL *p_data = &btm_cb.devcb.switch_role_ref_data; 1458 tBTM_SEC_DEV_REC *p_dev_rec; 1459 tBTM_BL_ROLE_CHG_DATA evt; 1460 1461 BTM_TRACE_DEBUG ("btm_acl_role_changed"); 1462 /* Ignore any stray events */ 1463 if (p == NULL) 1464 { 1465 /* it could be a failure */ 1466 if (hci_status != HCI_SUCCESS) 1467 btm_acl_report_role_change(hci_status, bd_addr); 1468 return; 1469 } 1470 1471 p_data->hci_status = hci_status; 1472 1473 if (hci_status == HCI_SUCCESS) 1474 { 1475 p_data->role = new_role; 1476 memcpy(p_data->remote_bd_addr, p_bda, BD_ADDR_LEN); 1477 1478 /* Update cached value */ 1479 p->link_role = new_role; 1480 1481 /* Reload LSTO: link supervision timeout is reset in the LM after a role switch */ 1482 if (new_role == BTM_ROLE_MASTER) 1483 { 1484 BTM_SetLinkSuperTout (p->remote_addr, p->link_super_tout); 1485 } 1486 } 1487 else 1488 { 1489 /* so the BTM_BL_ROLE_CHG_EVT uses the old role */ 1490 new_role = p->link_role; 1491 } 1492 1493 /* Check if any SCO req is pending for role change */ 1494 btm_sco_chk_pend_rolechange (p->hci_handle); 1495 1496 /* if switching state is switching we need to turn encryption on */ 1497 /* if idle, we did not change encryption */ 1498 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_SWITCHING) 1499 { 1500 if (btsnd_hcic_set_conn_encrypt (p->hci_handle, TRUE)) 1501 { 1502 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_ENCRYPT_ON; 1503 p->switch_role_state = BTM_ACL_SWKEY_STATE_ENCRYPTION_ON; 1504 return; 1505 } 1506 } 1507 1508 /* Set the switch_role_state to IDLE since the reply received from HCI */ 1509 /* regardless of its result either success or failed. */ 1510 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_IN_PROGRESS) 1511 { 1512 p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE; 1513 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE; 1514 } 1515 1516 /* if role switch complete is needed, report it now */ 1517 btm_acl_report_role_change(hci_status, bd_addr); 1518 1519 /* if role change event is registered, report it now */ 1520 if (btm_cb.p_bl_changed_cb && (btm_cb.bl_evt_mask & BTM_BL_ROLE_CHG_MASK)) 1521 { 1522 evt.event = BTM_BL_ROLE_CHG_EVT; 1523 evt.new_role = new_role; 1524 evt.p_bda = p_bda; 1525 evt.hci_status = hci_status; 1526 (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA *)&evt); 1527 } 1528 1529 BTM_TRACE_DEBUG("Role Switch Event: new_role 0x%02x, HCI Status 0x%02x, rs_st:%d", 1530 p_data->role, p_data->hci_status, p->switch_role_state); 1531 1532 #if BTM_DISC_DURING_RS == TRUE 1533 /* If a disconnect is pending, issue it now that role switch has completed */ 1534 if ((p_dev_rec = btm_find_dev (p_bda)) != NULL) 1535 { 1536 if (p_dev_rec->rs_disc_pending == BTM_SEC_DISC_PENDING) 1537 { 1538 BTM_TRACE_WARNING("btm_acl_role_changed -> Issuing delayed HCI_Disconnect!!!"); 1539 btsnd_hcic_disconnect(p_dev_rec->hci_handle, HCI_ERR_PEER_USER); 1540 } 1541 BTM_TRACE_ERROR("tBTM_SEC_DEV:0x%x rs_disc_pending=%d", 1542 PTR_TO_UINT(p_dev_rec), p_dev_rec->rs_disc_pending); 1543 p_dev_rec->rs_disc_pending = BTM_SEC_RS_NOT_PENDING; /* reset flag */ 1544 } 1545 1546 #endif 1547 1548 } 1549 1550 /******************************************************************************* 1551 ** 1552 ** Function BTM_AllocateSCN 1553 ** 1554 ** Description Look through the Server Channel Numbers for a free one. 1555 ** 1556 ** Returns Allocated SCN number or 0 if none. 1557 ** 1558 *******************************************************************************/ 1559 1560 UINT8 BTM_AllocateSCN(void) 1561 { 1562 UINT8 x; 1563 BTM_TRACE_DEBUG ("BTM_AllocateSCN"); 1564 1565 // stack reserves scn 1 for HFP, HSP we still do the correct way 1566 for (x = 1; x < BTM_MAX_SCN; x++) 1567 { 1568 if (!btm_cb.btm_scn[x]) 1569 { 1570 btm_cb.btm_scn[x] = TRUE; 1571 return(x+1); 1572 } 1573 } 1574 1575 return(0); /* No free ports */ 1576 } 1577 1578 /******************************************************************************* 1579 ** 1580 ** Function BTM_TryAllocateSCN 1581 ** 1582 ** Description Try to allocate a fixed server channel 1583 ** 1584 ** Returns Returns TRUE if server channel was available 1585 ** 1586 *******************************************************************************/ 1587 1588 BOOLEAN BTM_TryAllocateSCN(UINT8 scn) 1589 { 1590 /* Make sure we don't exceed max port range. 1591 * Stack reserves scn 1 for HFP, HSP we still do the correct way. 1592 */ 1593 if ( (scn>=BTM_MAX_SCN) || (scn == 1) ) 1594 return FALSE; 1595 1596 /* check if this port is available */ 1597 if (!btm_cb.btm_scn[scn-1]) 1598 { 1599 btm_cb.btm_scn[scn-1] = TRUE; 1600 return TRUE; 1601 } 1602 1603 return (FALSE); /* Port was busy */ 1604 } 1605 1606 /******************************************************************************* 1607 ** 1608 ** Function BTM_FreeSCN 1609 ** 1610 ** Description Free the specified SCN. 1611 ** 1612 ** Returns TRUE or FALSE 1613 ** 1614 *******************************************************************************/ 1615 BOOLEAN BTM_FreeSCN(UINT8 scn) 1616 { 1617 BTM_TRACE_DEBUG ("BTM_FreeSCN "); 1618 if (scn <= BTM_MAX_SCN) 1619 { 1620 btm_cb.btm_scn[scn-1] = FALSE; 1621 return(TRUE); 1622 } 1623 else 1624 return(FALSE); /* Illegal SCN passed in */ 1625 } 1626 1627 /******************************************************************************* 1628 ** 1629 ** Function btm_set_packet_types 1630 ** 1631 ** Description This function sets the packet types used for a specific 1632 ** ACL connection. It is called internally by btm_acl_created 1633 ** or by an application/profile by BTM_SetPacketTypes. 1634 ** 1635 ** Returns status of the operation 1636 ** 1637 *******************************************************************************/ 1638 tBTM_STATUS btm_set_packet_types (tACL_CONN *p, UINT16 pkt_types) 1639 { 1640 UINT16 temp_pkt_types; 1641 BTM_TRACE_DEBUG ("btm_set_packet_types"); 1642 /* Save in the ACL control blocks, types that we support */ 1643 temp_pkt_types = (pkt_types & BTM_ACL_SUPPORTED_PKTS_MASK & 1644 btm_cb.btm_acl_pkt_types_supported); 1645 1646 /* OR in any exception packet types if at least 2.0 version of spec */ 1647 temp_pkt_types |= ((pkt_types & BTM_ACL_EXCEPTION_PKTS_MASK) | 1648 (btm_cb.btm_acl_pkt_types_supported & BTM_ACL_EXCEPTION_PKTS_MASK)); 1649 1650 /* Exclude packet types not supported by the peer */ 1651 btm_acl_chk_peer_pkt_type_support (p, &temp_pkt_types); 1652 1653 BTM_TRACE_DEBUG ("SetPacketType Mask -> 0x%04x", temp_pkt_types); 1654 1655 if (!btsnd_hcic_change_conn_type (p->hci_handle, temp_pkt_types)) 1656 { 1657 return(BTM_NO_RESOURCES); 1658 } 1659 1660 p->pkt_types_mask = temp_pkt_types; 1661 1662 return(BTM_CMD_STARTED); 1663 } 1664 1665 /******************************************************************************* 1666 ** 1667 ** Function btm_get_max_packet_size 1668 ** 1669 ** Returns Returns maximum packet size that can be used for current 1670 ** connection, 0 if connection is not established 1671 ** 1672 *******************************************************************************/ 1673 UINT16 btm_get_max_packet_size (BD_ADDR addr) 1674 { 1675 tACL_CONN *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR); 1676 UINT16 pkt_types = 0; 1677 UINT16 pkt_size = 0; 1678 BTM_TRACE_DEBUG ("btm_get_max_packet_size"); 1679 if (p != NULL) 1680 { 1681 pkt_types = p->pkt_types_mask; 1682 } 1683 else 1684 { 1685 /* Special case for when info for the local device is requested */ 1686 if (memcmp (controller_get_interface()->get_address(), addr, BD_ADDR_LEN) == 0) 1687 { 1688 pkt_types = btm_cb.btm_acl_pkt_types_supported; 1689 } 1690 } 1691 1692 if (pkt_types) 1693 { 1694 if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_3_DH5)) 1695 pkt_size = HCI_EDR3_DH5_PACKET_SIZE; 1696 else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_2_DH5)) 1697 pkt_size = HCI_EDR2_DH5_PACKET_SIZE; 1698 else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_3_DH3)) 1699 pkt_size = HCI_EDR3_DH3_PACKET_SIZE; 1700 else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DH5) 1701 pkt_size = HCI_DH5_PACKET_SIZE; 1702 else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_2_DH3)) 1703 pkt_size = HCI_EDR2_DH3_PACKET_SIZE; 1704 else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DM5) 1705 pkt_size = HCI_DM5_PACKET_SIZE; 1706 else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DH3) 1707 pkt_size = HCI_DH3_PACKET_SIZE; 1708 else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DM3) 1709 pkt_size = HCI_DM3_PACKET_SIZE; 1710 else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_3_DH1)) 1711 pkt_size = HCI_EDR3_DH1_PACKET_SIZE; 1712 else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_2_DH1)) 1713 pkt_size = HCI_EDR2_DH1_PACKET_SIZE; 1714 else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DH1) 1715 pkt_size = HCI_DH1_PACKET_SIZE; 1716 else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DM1) 1717 pkt_size = HCI_DM1_PACKET_SIZE; 1718 } 1719 1720 return(pkt_size); 1721 } 1722 1723 /******************************************************************************* 1724 ** 1725 ** Function BTM_ReadRemoteVersion 1726 ** 1727 ** Returns If connected report peer device info 1728 ** 1729 *******************************************************************************/ 1730 tBTM_STATUS BTM_ReadRemoteVersion (BD_ADDR addr, UINT8 *lmp_version, 1731 UINT16 *manufacturer, UINT16 *lmp_sub_version) 1732 { 1733 tACL_CONN *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR); 1734 BTM_TRACE_DEBUG ("BTM_ReadRemoteVersion"); 1735 if (p == NULL) 1736 return(BTM_UNKNOWN_ADDR); 1737 1738 if (lmp_version) 1739 *lmp_version = p->lmp_version; 1740 1741 if (manufacturer) 1742 *manufacturer = p->manufacturer; 1743 1744 if (lmp_sub_version) 1745 *lmp_sub_version = p->lmp_subversion; 1746 1747 return(BTM_SUCCESS); 1748 } 1749 1750 /******************************************************************************* 1751 ** 1752 ** Function BTM_ReadRemoteFeatures 1753 ** 1754 ** Returns pointer to the remote supported features mask (8 bytes) 1755 ** 1756 *******************************************************************************/ 1757 UINT8 *BTM_ReadRemoteFeatures (BD_ADDR addr) 1758 { 1759 tACL_CONN *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR); 1760 BTM_TRACE_DEBUG ("BTM_ReadRemoteFeatures"); 1761 if (p == NULL) 1762 { 1763 return(NULL); 1764 } 1765 1766 return(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]); 1767 } 1768 1769 /******************************************************************************* 1770 ** 1771 ** Function BTM_ReadRemoteExtendedFeatures 1772 ** 1773 ** Returns pointer to the remote extended features mask (8 bytes) 1774 ** or NULL if bad page 1775 ** 1776 *******************************************************************************/ 1777 UINT8 *BTM_ReadRemoteExtendedFeatures (BD_ADDR addr, UINT8 page_number) 1778 { 1779 tACL_CONN *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR); 1780 BTM_TRACE_DEBUG ("BTM_ReadRemoteExtendedFeatures"); 1781 if (p == NULL) 1782 { 1783 return(NULL); 1784 } 1785 1786 if (page_number > HCI_EXT_FEATURES_PAGE_MAX) 1787 { 1788 BTM_TRACE_ERROR("Warning: BTM_ReadRemoteExtendedFeatures page %d unknown", page_number); 1789 return NULL; 1790 } 1791 1792 return(p->peer_lmp_features[page_number]); 1793 } 1794 1795 /******************************************************************************* 1796 ** 1797 ** Function BTM_ReadNumberRemoteFeaturesPages 1798 ** 1799 ** Returns number of features pages read from the remote device. 1800 ** 1801 *******************************************************************************/ 1802 UINT8 BTM_ReadNumberRemoteFeaturesPages (BD_ADDR addr) 1803 { 1804 tACL_CONN *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR); 1805 BTM_TRACE_DEBUG ("BTM_ReadNumberRemoteFeaturesPages"); 1806 if (p == NULL) 1807 { 1808 return(0); 1809 } 1810 1811 return(p->num_read_pages); 1812 } 1813 1814 /******************************************************************************* 1815 ** 1816 ** Function BTM_ReadAllRemoteFeatures 1817 ** 1818 ** Returns pointer to all features of the remote (24 bytes). 1819 ** 1820 *******************************************************************************/ 1821 UINT8 *BTM_ReadAllRemoteFeatures (BD_ADDR addr) 1822 { 1823 tACL_CONN *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR); 1824 BTM_TRACE_DEBUG ("BTM_ReadAllRemoteFeatures"); 1825 if (p == NULL) 1826 { 1827 return(NULL); 1828 } 1829 1830 return(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]); 1831 } 1832 1833 /******************************************************************************* 1834 ** 1835 ** Function BTM_RegBusyLevelNotif 1836 ** 1837 ** Description This function is called to register a callback to receive 1838 ** busy level change events. 1839 ** 1840 ** Returns BTM_SUCCESS if successfully registered, otherwise error 1841 ** 1842 *******************************************************************************/ 1843 tBTM_STATUS BTM_RegBusyLevelNotif (tBTM_BL_CHANGE_CB *p_cb, UINT8 *p_level, 1844 tBTM_BL_EVENT_MASK evt_mask) 1845 { 1846 BTM_TRACE_DEBUG ("BTM_RegBusyLevelNotif"); 1847 if (p_level) 1848 *p_level = btm_cb.busy_level; 1849 1850 btm_cb.bl_evt_mask = evt_mask; 1851 1852 if (!p_cb) 1853 btm_cb.p_bl_changed_cb = NULL; 1854 else if (btm_cb.p_bl_changed_cb) 1855 return(BTM_BUSY); 1856 else 1857 btm_cb.p_bl_changed_cb = p_cb; 1858 1859 return(BTM_SUCCESS); 1860 } 1861 1862 /******************************************************************************* 1863 ** 1864 ** Function BTM_SetQoS 1865 ** 1866 ** Description This function is called to setup QoS 1867 ** 1868 ** Returns status of the operation 1869 ** 1870 *******************************************************************************/ 1871 tBTM_STATUS BTM_SetQoS (BD_ADDR bd, FLOW_SPEC *p_flow, tBTM_CMPL_CB *p_cb) 1872 { 1873 tACL_CONN *p = &btm_cb.acl_db[0]; 1874 1875 BTM_TRACE_API ("BTM_SetQoS: BdAddr: %02x%02x%02x%02x%02x%02x", 1876 bd[0], bd[1], bd[2], 1877 bd[3], bd[4], bd[5]); 1878 1879 /* If someone already waiting on the version, do not allow another */ 1880 if (btm_cb.devcb.p_qos_setup_cmpl_cb) 1881 return(BTM_BUSY); 1882 1883 if ( (p = btm_bda_to_acl(bd, BT_TRANSPORT_BR_EDR)) != NULL) 1884 { 1885 btm_cb.devcb.p_qos_setup_cmpl_cb = p_cb; 1886 alarm_set_on_queue(btm_cb.devcb.qos_setup_timer, 1887 BTM_DEV_REPLY_TIMEOUT_MS, 1888 btm_qos_setup_timeout, NULL, 1889 btu_general_alarm_queue); 1890 1891 if (!btsnd_hcic_qos_setup (p->hci_handle, p_flow->qos_flags, p_flow->service_type, 1892 p_flow->token_rate, p_flow->peak_bandwidth, 1893 p_flow->latency,p_flow->delay_variation)) 1894 { 1895 btm_cb.devcb.p_qos_setup_cmpl_cb = NULL; 1896 alarm_cancel(btm_cb.devcb.qos_setup_timer); 1897 return(BTM_NO_RESOURCES); 1898 } 1899 else 1900 return(BTM_CMD_STARTED); 1901 } 1902 1903 /* If here, no BD Addr found */ 1904 return(BTM_UNKNOWN_ADDR); 1905 } 1906 1907 /******************************************************************************* 1908 ** 1909 ** Function btm_qos_setup_timeout 1910 ** 1911 ** Description Callback when QoS setup times out. 1912 ** 1913 ** Returns void 1914 ** 1915 *******************************************************************************/ 1916 void btm_qos_setup_timeout(UNUSED_ATTR void *data) 1917 { 1918 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_qos_setup_cmpl_cb; 1919 btm_cb.devcb.p_qos_setup_cmpl_cb = NULL; 1920 if (p_cb) 1921 (*p_cb)((void *) NULL); 1922 } 1923 1924 /******************************************************************************* 1925 ** 1926 ** Function btm_qos_setup_complete 1927 ** 1928 ** Description This function is called when the command complete message 1929 ** is received from the HCI for the qos setup request. 1930 ** 1931 ** Returns void 1932 ** 1933 *******************************************************************************/ 1934 void btm_qos_setup_complete(UINT8 status, UINT16 handle, FLOW_SPEC *p_flow) 1935 { 1936 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_qos_setup_cmpl_cb; 1937 tBTM_QOS_SETUP_CMPL qossu; 1938 1939 BTM_TRACE_DEBUG("%s", __func__); 1940 alarm_cancel(btm_cb.devcb.qos_setup_timer); 1941 btm_cb.devcb.p_qos_setup_cmpl_cb = NULL; 1942 1943 /* If there was a registered callback, call it */ 1944 if (p_cb) 1945 { 1946 memset(&qossu, 0, sizeof(tBTM_QOS_SETUP_CMPL)); 1947 qossu.status = status; 1948 qossu.handle = handle; 1949 if (p_flow != NULL) 1950 { 1951 qossu.flow.qos_flags = p_flow->qos_flags; 1952 qossu.flow.service_type = p_flow->service_type; 1953 qossu.flow.token_rate = p_flow->token_rate; 1954 qossu.flow.peak_bandwidth = p_flow->peak_bandwidth; 1955 qossu.flow.latency = p_flow->latency; 1956 qossu.flow.delay_variation = p_flow->delay_variation; 1957 } 1958 BTM_TRACE_DEBUG ("BTM: p_flow->delay_variation: 0x%02x", 1959 qossu.flow.delay_variation); 1960 (*p_cb)(&qossu); 1961 } 1962 } 1963 1964 /******************************************************************************* 1965 ** 1966 ** Function BTM_ReadRSSI 1967 ** 1968 ** Description This function is called to read the link policy settings. 1969 ** The address of link policy results are returned in the callback. 1970 ** (tBTM_RSSI_RESULTS) 1971 ** 1972 ** Returns BTM_CMD_STARTED if successfully initiated or error code 1973 ** 1974 *******************************************************************************/ 1975 tBTM_STATUS BTM_ReadRSSI (BD_ADDR remote_bda, tBTM_CMPL_CB *p_cb) 1976 { 1977 tACL_CONN *p; 1978 tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR; 1979 #if BLE_INCLUDED == TRUE 1980 tBT_DEVICE_TYPE dev_type; 1981 tBLE_ADDR_TYPE addr_type; 1982 #endif 1983 BTM_TRACE_API ("BTM_ReadRSSI: RemBdAddr: %02x%02x%02x%02x%02x%02x", 1984 remote_bda[0], remote_bda[1], remote_bda[2], 1985 remote_bda[3], remote_bda[4], remote_bda[5]); 1986 1987 /* If someone already waiting on the version, do not allow another */ 1988 if (btm_cb.devcb.p_rssi_cmpl_cb) 1989 return(BTM_BUSY); 1990 1991 #if BLE_INCLUDED == TRUE 1992 BTM_ReadDevInfo(remote_bda, &dev_type, &addr_type); 1993 if (dev_type == BT_DEVICE_TYPE_BLE) 1994 transport = BT_TRANSPORT_LE; 1995 #endif 1996 1997 p = btm_bda_to_acl(remote_bda, transport); 1998 if (p != (tACL_CONN *)NULL) 1999 { 2000 btm_cb.devcb.p_rssi_cmpl_cb = p_cb; 2001 alarm_set_on_queue(btm_cb.devcb.read_rssi_timer, 2002 BTM_DEV_REPLY_TIMEOUT_MS, btm_read_rssi_timeout, 2003 NULL, btu_general_alarm_queue); 2004 2005 if (!btsnd_hcic_read_rssi (p->hci_handle)) 2006 { 2007 btm_cb.devcb.p_rssi_cmpl_cb = NULL; 2008 alarm_cancel(btm_cb.devcb.read_rssi_timer); 2009 return(BTM_NO_RESOURCES); 2010 } 2011 else 2012 return(BTM_CMD_STARTED); 2013 } 2014 2015 /* If here, no BD Addr found */ 2016 return(BTM_UNKNOWN_ADDR); 2017 } 2018 2019 /******************************************************************************* 2020 ** 2021 ** Function BTM_ReadLinkQuality 2022 ** 2023 ** Description This function is called to read the link qulaity. 2024 ** The value of the link quality is returned in the callback. 2025 ** (tBTM_LINK_QUALITY_RESULTS) 2026 ** 2027 ** Returns BTM_CMD_STARTED if successfully initiated or error code 2028 ** 2029 *******************************************************************************/ 2030 tBTM_STATUS BTM_ReadLinkQuality (BD_ADDR remote_bda, tBTM_CMPL_CB *p_cb) 2031 { 2032 tACL_CONN *p; 2033 2034 BTM_TRACE_API ("BTM_ReadLinkQuality: RemBdAddr: %02x%02x%02x%02x%02x%02x", 2035 remote_bda[0], remote_bda[1], remote_bda[2], 2036 remote_bda[3], remote_bda[4], remote_bda[5]); 2037 2038 /* If someone already waiting on the version, do not allow another */ 2039 if (btm_cb.devcb.p_link_qual_cmpl_cb) 2040 return(BTM_BUSY); 2041 2042 p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR); 2043 if (p != (tACL_CONN *)NULL) 2044 { 2045 btm_cb.devcb.p_link_qual_cmpl_cb = p_cb; 2046 alarm_set_on_queue(btm_cb.devcb.read_link_quality_timer, 2047 BTM_DEV_REPLY_TIMEOUT_MS, 2048 btm_read_link_quality_timeout, NULL, 2049 btu_general_alarm_queue); 2050 2051 if (!btsnd_hcic_get_link_quality (p->hci_handle)) 2052 { 2053 btm_cb.devcb.p_link_qual_cmpl_cb = NULL; 2054 alarm_cancel(btm_cb.devcb.read_link_quality_timer); 2055 return(BTM_NO_RESOURCES); 2056 } 2057 else 2058 return(BTM_CMD_STARTED); 2059 } 2060 2061 /* If here, no BD Addr found */ 2062 return(BTM_UNKNOWN_ADDR); 2063 } 2064 2065 /******************************************************************************* 2066 ** 2067 ** Function BTM_ReadTxPower 2068 ** 2069 ** Description This function is called to read the current 2070 ** TX power of the connection. The tx power level results 2071 ** are returned in the callback. 2072 ** (tBTM_RSSI_RESULTS) 2073 ** 2074 ** Returns BTM_CMD_STARTED if successfully initiated or error code 2075 ** 2076 *******************************************************************************/ 2077 tBTM_STATUS BTM_ReadTxPower (BD_ADDR remote_bda, tBT_TRANSPORT transport, tBTM_CMPL_CB *p_cb) 2078 { 2079 tACL_CONN *p; 2080 BOOLEAN ret; 2081 #define BTM_READ_RSSI_TYPE_CUR 0x00 2082 #define BTM_READ_RSSI_TYPE_MAX 0X01 2083 2084 BTM_TRACE_API ("BTM_ReadTxPower: 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 someone already waiting on the version, do not allow another */ 2089 if (btm_cb.devcb.p_tx_power_cmpl_cb) 2090 return(BTM_BUSY); 2091 2092 p = btm_bda_to_acl(remote_bda, transport); 2093 if (p != (tACL_CONN *)NULL) 2094 { 2095 btm_cb.devcb.p_tx_power_cmpl_cb = p_cb; 2096 alarm_set_on_queue(btm_cb.devcb.read_tx_power_timer, 2097 BTM_DEV_REPLY_TIMEOUT_MS, 2098 btm_read_tx_power_timeout, NULL, 2099 btu_general_alarm_queue); 2100 2101 #if BLE_INCLUDED == TRUE 2102 if (p->transport == BT_TRANSPORT_LE) 2103 { 2104 memcpy(btm_cb.devcb.read_tx_pwr_addr, remote_bda, BD_ADDR_LEN); 2105 ret = btsnd_hcic_ble_read_adv_chnl_tx_power(); 2106 } 2107 else 2108 #endif 2109 { 2110 ret = btsnd_hcic_read_tx_power (p->hci_handle, BTM_READ_RSSI_TYPE_CUR); 2111 } 2112 if (!ret) 2113 { 2114 btm_cb.devcb.p_tx_power_cmpl_cb = NULL; 2115 alarm_cancel(btm_cb.devcb.read_tx_power_timer); 2116 return(BTM_NO_RESOURCES); 2117 } 2118 else 2119 return(BTM_CMD_STARTED); 2120 } 2121 2122 /* If here, no BD Addr found */ 2123 return (BTM_UNKNOWN_ADDR); 2124 } 2125 2126 /******************************************************************************* 2127 ** 2128 ** Function btm_read_tx_power_timeout 2129 ** 2130 ** Description Callback when reading the tx power times out. 2131 ** 2132 ** Returns void 2133 ** 2134 *******************************************************************************/ 2135 void btm_read_tx_power_timeout(UNUSED_ATTR void *data) 2136 { 2137 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_tx_power_cmpl_cb; 2138 btm_cb.devcb.p_tx_power_cmpl_cb = NULL; 2139 if (p_cb) 2140 (*p_cb)((void *) NULL); 2141 } 2142 2143 /******************************************************************************* 2144 ** 2145 ** Function btm_read_tx_power_complete 2146 ** 2147 ** Description This function is called when the command complete message 2148 ** is received from the HCI for the read tx power request. 2149 ** 2150 ** Returns void 2151 ** 2152 *******************************************************************************/ 2153 void btm_read_tx_power_complete(UINT8 *p, BOOLEAN is_ble) 2154 { 2155 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_tx_power_cmpl_cb; 2156 tBTM_TX_POWER_RESULTS results; 2157 UINT16 handle; 2158 tACL_CONN *p_acl_cb = &btm_cb.acl_db[0]; 2159 UINT16 index; 2160 2161 BTM_TRACE_DEBUG("%s", __func__); 2162 alarm_cancel(btm_cb.devcb.read_tx_power_timer); 2163 btm_cb.devcb.p_tx_power_cmpl_cb = NULL; 2164 2165 /* If there was a registered callback, call it */ 2166 if (p_cb) 2167 { 2168 STREAM_TO_UINT8 (results.hci_status, p); 2169 2170 if (results.hci_status == HCI_SUCCESS) 2171 { 2172 results.status = BTM_SUCCESS; 2173 2174 if (!is_ble) 2175 { 2176 STREAM_TO_UINT16 (handle, p); 2177 STREAM_TO_UINT8 (results.tx_power, p); 2178 2179 /* Search through the list of active channels for the correct BD Addr */ 2180 for (index = 0; index < MAX_L2CAP_LINKS; index++, p_acl_cb++) 2181 { 2182 if ((p_acl_cb->in_use) && (handle == p_acl_cb->hci_handle)) 2183 { 2184 memcpy (results.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN); 2185 break; 2186 } 2187 } 2188 } 2189 #if BLE_INCLUDED == TRUE 2190 else 2191 { 2192 STREAM_TO_UINT8 (results.tx_power, p); 2193 memcpy(results.rem_bda, btm_cb.devcb.read_tx_pwr_addr, BD_ADDR_LEN); 2194 } 2195 #endif 2196 BTM_TRACE_DEBUG ("BTM TX power Complete: tx_power %d, hci status 0x%02x", 2197 results.tx_power, results.hci_status); 2198 } 2199 else 2200 results.status = BTM_ERR_PROCESSING; 2201 2202 (*p_cb)(&results); 2203 } 2204 } 2205 2206 /******************************************************************************* 2207 ** 2208 ** Function btm_read_rssi_timeout 2209 ** 2210 ** Description Callback when reading the RSSI times out. 2211 ** 2212 ** Returns void 2213 ** 2214 *******************************************************************************/ 2215 void btm_read_rssi_timeout(UNUSED_ATTR void *data) 2216 { 2217 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_rssi_cmpl_cb; 2218 btm_cb.devcb.p_rssi_cmpl_cb = NULL; 2219 if (p_cb) 2220 (*p_cb)((void *) NULL); 2221 } 2222 2223 /******************************************************************************* 2224 ** 2225 ** Function btm_read_rssi_complete 2226 ** 2227 ** Description This function is called when the command complete message 2228 ** is received from the HCI for the read rssi request. 2229 ** 2230 ** Returns void 2231 ** 2232 *******************************************************************************/ 2233 void btm_read_rssi_complete (UINT8 *p) 2234 { 2235 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_rssi_cmpl_cb; 2236 tBTM_RSSI_RESULTS results; 2237 UINT16 handle; 2238 tACL_CONN *p_acl_cb = &btm_cb.acl_db[0]; 2239 UINT16 index; 2240 2241 BTM_TRACE_DEBUG("%s", __func__); 2242 alarm_cancel(btm_cb.devcb.read_rssi_timer); 2243 btm_cb.devcb.p_rssi_cmpl_cb = NULL; 2244 2245 /* If there was a registered callback, call it */ 2246 if (p_cb) 2247 { 2248 STREAM_TO_UINT8 (results.hci_status, p); 2249 2250 if (results.hci_status == HCI_SUCCESS) 2251 { 2252 results.status = BTM_SUCCESS; 2253 2254 STREAM_TO_UINT16 (handle, p); 2255 2256 STREAM_TO_UINT8 (results.rssi, p); 2257 BTM_TRACE_DEBUG ("BTM RSSI Complete: rssi %d, hci status 0x%02x", 2258 results.rssi, results.hci_status); 2259 2260 /* Search through the list of active channels for the correct BD Addr */ 2261 for (index = 0; index < MAX_L2CAP_LINKS; index++, p_acl_cb++) 2262 { 2263 if ((p_acl_cb->in_use) && (handle == p_acl_cb->hci_handle)) 2264 { 2265 memcpy (results.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN); 2266 break; 2267 } 2268 } 2269 } 2270 else 2271 results.status = BTM_ERR_PROCESSING; 2272 2273 (*p_cb)(&results); 2274 } 2275 } 2276 2277 /******************************************************************************* 2278 ** 2279 ** Function btm_read_link_quality_timeout 2280 ** 2281 ** Description Callback when reading the link quality times out. 2282 ** 2283 ** Returns void 2284 ** 2285 *******************************************************************************/ 2286 void btm_read_link_quality_timeout(UNUSED_ATTR void *data) 2287 { 2288 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_link_qual_cmpl_cb; 2289 btm_cb.devcb.p_link_qual_cmpl_cb = NULL; 2290 if (p_cb) 2291 (*p_cb)((void *) NULL); 2292 } 2293 2294 /******************************************************************************* 2295 ** 2296 ** Function btm_read_link_quality_complete 2297 ** 2298 ** Description This function is called when the command complete message 2299 ** is received from the HCI for the read link quality. 2300 ** 2301 ** Returns void 2302 ** 2303 *******************************************************************************/ 2304 void btm_read_link_quality_complete(UINT8 *p) 2305 { 2306 tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_link_qual_cmpl_cb; 2307 tBTM_LINK_QUALITY_RESULTS results; 2308 UINT16 handle; 2309 tACL_CONN *p_acl_cb = &btm_cb.acl_db[0]; 2310 UINT16 index; 2311 2312 BTM_TRACE_DEBUG("%s", __func__); 2313 alarm_cancel(btm_cb.devcb.read_link_quality_timer); 2314 btm_cb.devcb.p_link_qual_cmpl_cb = NULL; 2315 2316 /* If there was a registered callback, call it */ 2317 if (p_cb) 2318 { 2319 STREAM_TO_UINT8 (results.hci_status, p); 2320 2321 if (results.hci_status == HCI_SUCCESS) 2322 { 2323 results.status = BTM_SUCCESS; 2324 2325 STREAM_TO_UINT16 (handle, p); 2326 2327 STREAM_TO_UINT8 (results.link_quality, p); 2328 BTM_TRACE_DEBUG ("BTM Link Quality Complete: Link Quality %d, hci status 0x%02x", 2329 results.link_quality, results.hci_status); 2330 2331 /* Search through the list of active channels for the correct BD Addr */ 2332 for (index = 0; index < MAX_L2CAP_LINKS; index++, p_acl_cb++) 2333 { 2334 if ((p_acl_cb->in_use) && (handle == p_acl_cb->hci_handle)) 2335 { 2336 memcpy (results.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN); 2337 break; 2338 } 2339 } 2340 } 2341 else 2342 results.status = BTM_ERR_PROCESSING; 2343 2344 (*p_cb)(&results); 2345 } 2346 } 2347 2348 /******************************************************************************* 2349 ** 2350 ** Function btm_remove_acl 2351 ** 2352 ** Description This function is called to disconnect an ACL connection 2353 ** 2354 ** Returns BTM_SUCCESS if successfully initiated, otherwise BTM_NO_RESOURCES. 2355 ** 2356 *******************************************************************************/ 2357 tBTM_STATUS btm_remove_acl (BD_ADDR bd_addr, tBT_TRANSPORT transport) 2358 { 2359 UINT16 hci_handle = BTM_GetHCIConnHandle(bd_addr, transport); 2360 tBTM_STATUS status = BTM_SUCCESS; 2361 2362 BTM_TRACE_DEBUG ("btm_remove_acl"); 2363 #if BTM_DISC_DURING_RS == TRUE 2364 tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev (bd_addr); 2365 2366 /* Role Switch is pending, postpone until completed */ 2367 if (p_dev_rec && (p_dev_rec->rs_disc_pending == BTM_SEC_RS_PENDING)) 2368 { 2369 p_dev_rec->rs_disc_pending = BTM_SEC_DISC_PENDING; 2370 } 2371 else /* otherwise can disconnect right away */ 2372 #endif 2373 { 2374 if (hci_handle != 0xFFFF && p_dev_rec && 2375 p_dev_rec->sec_state!= BTM_SEC_STATE_DISCONNECTING) 2376 { 2377 if (!btsnd_hcic_disconnect (hci_handle, HCI_ERR_PEER_USER)) 2378 status = BTM_NO_RESOURCES; 2379 } 2380 else 2381 status = BTM_UNKNOWN_ADDR; 2382 } 2383 2384 return status; 2385 } 2386 2387 2388 /******************************************************************************* 2389 ** 2390 ** Function BTM_SetTraceLevel 2391 ** 2392 ** Description This function sets the trace level for BTM. If called with 2393 ** a value of 0xFF, it simply returns the current trace level. 2394 ** 2395 ** Returns The new or current trace level 2396 ** 2397 *******************************************************************************/ 2398 UINT8 BTM_SetTraceLevel (UINT8 new_level) 2399 { 2400 BTM_TRACE_DEBUG ("BTM_SetTraceLevel"); 2401 if (new_level != 0xFF) 2402 btm_cb.trace_level = new_level; 2403 2404 return(btm_cb.trace_level); 2405 } 2406 2407 /******************************************************************************* 2408 ** 2409 ** Function btm_cont_rswitch 2410 ** 2411 ** Description This function is called to continue processing an active 2412 ** role switch. It first disables encryption if enabled and 2413 ** EPR is not supported 2414 ** 2415 ** Returns void 2416 ** 2417 *******************************************************************************/ 2418 void btm_cont_rswitch (tACL_CONN *p, tBTM_SEC_DEV_REC *p_dev_rec, 2419 UINT8 hci_status) 2420 { 2421 BOOLEAN sw_ok = TRUE; 2422 BTM_TRACE_DEBUG ("btm_cont_rswitch"); 2423 /* Check to see if encryption needs to be turned off if pending 2424 change of link key or role switch */ 2425 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE) 2426 { 2427 /* Must turn off Encryption first if necessary */ 2428 /* Some devices do not support switch or change of link key while encryption is on */ 2429 if (p_dev_rec != NULL && ((p_dev_rec->sec_flags & BTM_SEC_ENCRYPTED) != 0) 2430 && !BTM_EPR_AVAILABLE(p)) 2431 { 2432 if (btsnd_hcic_set_conn_encrypt (p->hci_handle, FALSE)) 2433 { 2434 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF; 2435 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE) 2436 p->switch_role_state = BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF; 2437 } 2438 else 2439 { 2440 /* Error occurred; set states back to Idle */ 2441 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE) 2442 sw_ok = FALSE; 2443 } 2444 } 2445 else /* Encryption not used or EPR supported, continue with switch 2446 and/or change of link key */ 2447 { 2448 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE) 2449 { 2450 p->switch_role_state = BTM_ACL_SWKEY_STATE_IN_PROGRESS; 2451 #if BTM_DISC_DURING_RS == TRUE 2452 if (p_dev_rec) 2453 p_dev_rec->rs_disc_pending = BTM_SEC_RS_PENDING; 2454 #endif 2455 sw_ok = btsnd_hcic_switch_role (p->remote_addr, (UINT8)!p->link_role); 2456 } 2457 } 2458 2459 if (!sw_ok) 2460 { 2461 p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE; 2462 btm_acl_report_role_change(hci_status, p->remote_addr); 2463 } 2464 } 2465 } 2466 2467 /******************************************************************************* 2468 ** 2469 ** Function btm_acl_resubmit_page 2470 ** 2471 ** Description send pending page request 2472 ** 2473 *******************************************************************************/ 2474 void btm_acl_resubmit_page (void) 2475 { 2476 tBTM_SEC_DEV_REC *p_dev_rec; 2477 BT_HDR *p_buf; 2478 UINT8 *pp; 2479 BD_ADDR bda; 2480 BTM_TRACE_DEBUG ("btm_acl_resubmit_page"); 2481 /* If there were other page request schedule can start the next one */ 2482 if ((p_buf = (BT_HDR *)fixed_queue_try_dequeue(btm_cb.page_queue)) != NULL) 2483 { 2484 /* skip 3 (2 bytes opcode and 1 byte len) to get to the bd_addr 2485 * for both create_conn and rmt_name */ 2486 pp = (UINT8 *)(p_buf + 1) + p_buf->offset + 3; 2487 2488 STREAM_TO_BDADDR (bda, pp); 2489 2490 p_dev_rec = btm_find_or_alloc_dev (bda); 2491 2492 memcpy (btm_cb.connecting_bda, p_dev_rec->bd_addr, BD_ADDR_LEN); 2493 memcpy (btm_cb.connecting_dc, p_dev_rec->dev_class, DEV_CLASS_LEN); 2494 2495 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p_buf); 2496 } 2497 else 2498 btm_cb.paging = FALSE; 2499 } 2500 2501 /******************************************************************************* 2502 ** 2503 ** Function btm_acl_reset_paging 2504 ** 2505 ** Description set paging to FALSE and free the page queue - called at hci_reset 2506 ** 2507 *******************************************************************************/ 2508 void btm_acl_reset_paging (void) 2509 { 2510 BT_HDR *p; 2511 BTM_TRACE_DEBUG ("btm_acl_reset_paging"); 2512 /* If we sent reset we are definitely not paging any more */ 2513 while ((p = (BT_HDR *)fixed_queue_try_dequeue(btm_cb.page_queue)) != NULL) 2514 osi_free(p); 2515 2516 btm_cb.paging = FALSE; 2517 } 2518 2519 /******************************************************************************* 2520 ** 2521 ** Function btm_acl_paging 2522 ** 2523 ** Description send a paging command or queue it in btm_cb 2524 ** 2525 *******************************************************************************/ 2526 void btm_acl_paging (BT_HDR *p, BD_ADDR bda) 2527 { 2528 tBTM_SEC_DEV_REC *p_dev_rec; 2529 2530 BTM_TRACE_DEBUG ("btm_acl_paging discing:%d, paging:%d BDA: %06x%06x", 2531 btm_cb.discing, btm_cb.paging, 2532 (bda[0]<<16) + (bda[1]<<8) + bda[2], (bda[3]<<16) + (bda[4] << 8) + bda[5]); 2533 if (btm_cb.discing) 2534 { 2535 btm_cb.paging = TRUE; 2536 fixed_queue_enqueue(btm_cb.page_queue, p); 2537 } 2538 else 2539 { 2540 if (!BTM_ACL_IS_CONNECTED (bda)) 2541 { 2542 BTM_TRACE_DEBUG ("connecting_bda: %06x%06x", 2543 (btm_cb.connecting_bda[0]<<16) + (btm_cb.connecting_bda[1]<<8) + 2544 btm_cb.connecting_bda[2], 2545 (btm_cb.connecting_bda[3]<<16) + (btm_cb.connecting_bda[4] << 8) + 2546 btm_cb.connecting_bda[5]); 2547 if (btm_cb.paging && 2548 memcmp (bda, btm_cb.connecting_bda, BD_ADDR_LEN) != 0) 2549 { 2550 fixed_queue_enqueue(btm_cb.page_queue, p); 2551 } 2552 else 2553 { 2554 p_dev_rec = btm_find_or_alloc_dev (bda); 2555 memcpy (btm_cb.connecting_bda, p_dev_rec->bd_addr, BD_ADDR_LEN); 2556 memcpy (btm_cb.connecting_dc, p_dev_rec->dev_class, DEV_CLASS_LEN); 2557 2558 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 2559 } 2560 2561 btm_cb.paging = TRUE; 2562 } 2563 else /* ACL is already up */ 2564 { 2565 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 2566 } 2567 } 2568 } 2569 2570 /******************************************************************************* 2571 ** 2572 ** Function btm_acl_notif_conn_collision 2573 ** 2574 ** Description Send connection collision event to upper layer if registered 2575 ** 2576 ** Returns TRUE if sent out to upper layer, 2577 ** FALSE if no one needs the notification. 2578 ** 2579 *******************************************************************************/ 2580 BOOLEAN btm_acl_notif_conn_collision (BD_ADDR bda) 2581 { 2582 tBTM_BL_EVENT_DATA evt_data; 2583 2584 /* Report possible collision to the upper layer. */ 2585 if (btm_cb.p_bl_changed_cb) 2586 { 2587 BTM_TRACE_DEBUG ("btm_acl_notif_conn_collision: RemBdAddr: %02x%02x%02x%02x%02x%02x", 2588 bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]); 2589 2590 evt_data.event = BTM_BL_COLLISION_EVT; 2591 evt_data.conn.p_bda = bda; 2592 2593 #if BLE_INCLUDED == TRUE 2594 evt_data.conn.transport = BT_TRANSPORT_BR_EDR; 2595 evt_data.conn.handle = BTM_INVALID_HCI_HANDLE; 2596 #endif 2597 (*btm_cb.p_bl_changed_cb)(&evt_data); 2598 return TRUE; 2599 } 2600 else 2601 return FALSE; 2602 } 2603 2604 2605 /******************************************************************************* 2606 ** 2607 ** Function btm_acl_chk_peer_pkt_type_support 2608 ** 2609 ** Description Check if peer supports requested packets 2610 ** 2611 *******************************************************************************/ 2612 void btm_acl_chk_peer_pkt_type_support (tACL_CONN *p, UINT16 *p_pkt_type) 2613 { 2614 /* 3 and 5 slot packets? */ 2615 if (!HCI_3_SLOT_PACKETS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) 2616 *p_pkt_type &= ~(BTM_ACL_PKT_TYPES_MASK_DH3 +BTM_ACL_PKT_TYPES_MASK_DM3); 2617 2618 if (!HCI_5_SLOT_PACKETS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) 2619 *p_pkt_type &= ~(BTM_ACL_PKT_TYPES_MASK_DH5 + BTM_ACL_PKT_TYPES_MASK_DM5); 2620 2621 /* 2 and 3 MPS support? */ 2622 if (!HCI_EDR_ACL_2MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) 2623 /* Not supported. Add 'not_supported' mask for all 2MPS packet types */ 2624 *p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH1 + BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 + 2625 BTM_ACL_PKT_TYPES_MASK_NO_2_DH5); 2626 2627 if (!HCI_EDR_ACL_3MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) 2628 /* Not supported. Add 'not_supported' mask for all 3MPS packet types */ 2629 *p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_3_DH1 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH3 + 2630 BTM_ACL_PKT_TYPES_MASK_NO_3_DH5); 2631 2632 /* EDR 3 and 5 slot support? */ 2633 if (HCI_EDR_ACL_2MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]) 2634 || HCI_EDR_ACL_3MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) 2635 { 2636 if (!HCI_3_SLOT_EDR_ACL_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) 2637 /* Not supported. Add 'not_supported' mask for all 3-slot EDR packet types */ 2638 *p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH3); 2639 2640 if (!HCI_5_SLOT_EDR_ACL_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) 2641 /* Not supported. Add 'not_supported' mask for all 5-slot EDR packet types */ 2642 *p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH5 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH5); 2643 } 2644 } 2645
