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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 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 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 *******************************************************************************/ 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 */ 2491 UINT8 BTM_AllocateSCN(void) 2492 { 2493 return(0); 2494 } 2495 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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) 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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
