You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2972 lines
102 KiB
2972 lines
102 KiB
/******************************************************************************
|
|
*
|
|
* Copyright 2000-2012 Broadcom Corporation
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
******************************************************************************/
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Name: btm_acl.cc
|
|
*
|
|
* Description: This file contains functions that handle ACL connections.
|
|
* This includes operations such as hold and sniff modes,
|
|
* supported packet types.
|
|
*
|
|
* This module contains both internal and external (API)
|
|
* functions. External (API) functions are distinguishable
|
|
* by their names beginning with uppercase BTM.
|
|
*
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define LOG_TAG "btm_acl"
|
|
|
|
#include <cstdint>
|
|
|
|
#include "bta/include/bta_dm_acl.h"
|
|
#include "bta/sys/bta_sys.h"
|
|
#include "btif/include/btif_acl.h"
|
|
#include "common/metrics.h"
|
|
#include "device/include/controller.h"
|
|
#include "device/include/interop.h"
|
|
#include "include/l2cap_hci_link_interface.h"
|
|
#include "main/shim/acl_api.h"
|
|
#include "main/shim/btm_api.h"
|
|
#include "main/shim/dumpsys.h"
|
|
#include "main/shim/l2c_api.h"
|
|
#include "main/shim/shim.h"
|
|
#include "osi/include/log.h"
|
|
#include "stack/acl/acl.h"
|
|
#include "stack/acl/peer_packet_types.h"
|
|
#include "stack/btm/btm_dev.h"
|
|
#include "stack/btm/btm_int_types.h"
|
|
#include "stack/btm/btm_sec.h"
|
|
#include "stack/btm/security_device_record.h"
|
|
#include "stack/gatt/connection_manager.h"
|
|
#include "stack/include/acl_api.h"
|
|
#include "stack/include/acl_hci_link_interface.h"
|
|
#include "stack/include/btm_api.h"
|
|
#include "stack/include/btm_iso_api.h"
|
|
#include "stack/include/btu.h"
|
|
#include "stack/include/hci_error_code.h"
|
|
#include "stack/include/hcimsgs.h"
|
|
#include "stack/include/l2cap_acl_interface.h"
|
|
#include "stack/include/sco_hci_link_interface.h"
|
|
#include "types/hci_role.h"
|
|
#include "types/raw_address.h"
|
|
|
|
void BTM_update_version_info(const RawAddress& bd_addr,
|
|
const remote_version_info& remote_version_info);
|
|
|
|
void gatt_find_in_device_record(const RawAddress& bd_addr,
|
|
tBLE_BD_ADDR* address_with_type);
|
|
void l2c_link_hci_conn_comp(tHCI_STATUS status, uint16_t handle,
|
|
const RawAddress& p_bda);
|
|
|
|
void BTM_db_reset(void);
|
|
|
|
extern tBTM_CB btm_cb;
|
|
|
|
struct StackAclBtmAcl {
|
|
tACL_CONN* acl_allocate_connection();
|
|
tACL_CONN* acl_get_connection_from_handle(uint16_t handle);
|
|
tACL_CONN* btm_bda_to_acl(const RawAddress& bda, tBT_TRANSPORT transport);
|
|
bool change_connection_packet_types(tACL_CONN& link,
|
|
const uint16_t new_packet_type_bitmask);
|
|
void btm_establish_continue(tACL_CONN* p_acl_cb);
|
|
void btm_read_remote_features(uint16_t handle);
|
|
void btm_set_default_link_policy(tLINK_POLICY settings);
|
|
void btm_acl_role_changed(tHCI_STATUS hci_status, const RawAddress& bd_addr,
|
|
tHCI_ROLE new_role);
|
|
void hci_start_role_switch_to_central(tACL_CONN& p_acl);
|
|
void set_default_packet_types_supported(uint16_t packet_types_supported) {
|
|
btm_cb.acl_cb_.btm_acl_pkt_types_supported = packet_types_supported;
|
|
}
|
|
};
|
|
|
|
struct RoleChangeView {
|
|
tHCI_ROLE new_role = HCI_ROLE_UNKNOWN;
|
|
RawAddress bd_addr;
|
|
};
|
|
|
|
namespace {
|
|
StackAclBtmAcl internal_;
|
|
std::unique_ptr<RoleChangeView> delayed_role_change_ = nullptr;
|
|
const bluetooth::legacy::hci::Interface& GetLegacyHciInterface() {
|
|
return bluetooth::legacy::hci::GetInterface();
|
|
}
|
|
}
|
|
|
|
typedef struct {
|
|
uint16_t handle;
|
|
uint16_t hci_len;
|
|
} __attribute__((packed)) acl_header_t;
|
|
|
|
constexpr uint8_t BTM_MAX_SW_ROLE_FAILED_ATTEMPTS = 3;
|
|
|
|
/* Define masks for supported and exception 2.0 ACL packet types
|
|
*/
|
|
constexpr uint16_t BTM_ACL_SUPPORTED_PKTS_MASK =
|
|
(HCI_PKT_TYPES_MASK_DM1 | HCI_PKT_TYPES_MASK_DH1 | HCI_PKT_TYPES_MASK_DM3 |
|
|
HCI_PKT_TYPES_MASK_DH3 | HCI_PKT_TYPES_MASK_DM5 | HCI_PKT_TYPES_MASK_DH5);
|
|
|
|
constexpr uint16_t BTM_ACL_EXCEPTION_PKTS_MASK =
|
|
(HCI_PKT_TYPES_MASK_NO_2_DH1 | HCI_PKT_TYPES_MASK_NO_3_DH1 |
|
|
HCI_PKT_TYPES_MASK_NO_2_DH3 | HCI_PKT_TYPES_MASK_NO_3_DH3 |
|
|
HCI_PKT_TYPES_MASK_NO_2_DH5 | HCI_PKT_TYPES_MASK_NO_3_DH5);
|
|
|
|
inline bool IsEprAvailable(const tACL_CONN& p_acl) {
|
|
if (!p_acl.peer_lmp_feature_valid[0]) {
|
|
LOG_WARN("Checking incomplete feature page read");
|
|
return false;
|
|
}
|
|
return HCI_ATOMIC_ENCRYPT_SUPPORTED(p_acl.peer_lmp_feature_pages[0]) &&
|
|
controller_get_interface()->supports_encryption_pause();
|
|
}
|
|
|
|
static void btm_process_remote_ext_features(tACL_CONN* p_acl_cb,
|
|
uint8_t max_page_number);
|
|
static void btm_read_failed_contact_counter_timeout(void* data);
|
|
static void btm_read_remote_ext_features(uint16_t handle, uint8_t page_number);
|
|
static void btm_read_rssi_timeout(void* data);
|
|
static void btm_read_tx_power_timeout(void* data);
|
|
static void check_link_policy(tLINK_POLICY* settings);
|
|
void btm_set_link_policy(tACL_CONN* conn, tLINK_POLICY policy);
|
|
|
|
namespace {
|
|
void NotifyAclLinkUp(tACL_CONN& p_acl) {
|
|
if (p_acl.link_up_issued) {
|
|
LOG_INFO("Already notified BTA layer that the link is up");
|
|
return;
|
|
}
|
|
p_acl.link_up_issued = true;
|
|
BTA_dm_acl_up(p_acl.remote_addr, p_acl.transport);
|
|
}
|
|
|
|
void NotifyAclLinkDown(tACL_CONN& p_acl) {
|
|
/* Only notify if link up has had a chance to be issued */
|
|
if (p_acl.link_up_issued) {
|
|
p_acl.link_up_issued = false;
|
|
BTA_dm_acl_down(p_acl.remote_addr, p_acl.transport);
|
|
}
|
|
}
|
|
|
|
void NotifyAclRoleSwitchComplete(const RawAddress& bda, tHCI_ROLE new_role,
|
|
tHCI_STATUS hci_status) {
|
|
BTA_dm_report_role_change(bda, new_role, hci_status);
|
|
}
|
|
|
|
void NotifyAclFeaturesReadComplete(tACL_CONN& p_acl,
|
|
UNUSED_ATTR uint8_t max_page_number) {
|
|
ASSERT_LOG(bluetooth::shim::is_gd_acl_enabled(),
|
|
"For right now only called with gd_acl support");
|
|
btm_process_remote_ext_features(&p_acl, max_page_number);
|
|
btm_set_link_policy(&p_acl, btm_cb.acl_cb_.DefaultLinkPolicy());
|
|
BTA_dm_notify_remote_features_complete(p_acl.remote_addr);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
static void hci_btsnd_hcic_disconnect(tACL_CONN& p_acl, tHCI_STATUS reason) {
|
|
LOG_INFO("Disconnecting peer:%s reason:%s",
|
|
PRIVATE_ADDRESS(p_acl.remote_addr),
|
|
hci_error_code_text(reason).c_str());
|
|
p_acl.disconnect_reason = reason;
|
|
|
|
if (bluetooth::shim::is_gd_acl_enabled()) {
|
|
return bluetooth::shim::ACL_Disconnect(p_acl.hci_handle,
|
|
p_acl.is_transport_br_edr(), reason);
|
|
} else {
|
|
GetLegacyHciInterface().Disconnect(p_acl.hci_handle,
|
|
static_cast<uint16_t>(reason));
|
|
}
|
|
}
|
|
|
|
void StackAclBtmAcl::hci_start_role_switch_to_central(tACL_CONN& p_acl) {
|
|
GetLegacyHciInterface().StartRoleSwitch(
|
|
p_acl.remote_addr, static_cast<uint8_t>(HCI_ROLE_CENTRAL));
|
|
p_acl.set_switch_role_in_progress();
|
|
p_acl.rs_disc_pending = BTM_SEC_RS_PENDING;
|
|
}
|
|
|
|
void hci_btm_set_link_supervision_timeout(tACL_CONN& link, uint16_t timeout) {
|
|
if (link.link_role != HCI_ROLE_CENTRAL) {
|
|
/* Only send if current role is Central; 2.0 spec requires this */
|
|
LOG_WARN("Can only set link supervision timeout if central role:%s",
|
|
RoleText(link.link_role).c_str());
|
|
return;
|
|
}
|
|
|
|
LOG_DEBUG("Setting link supervision timeout:%.2fs peer:%s",
|
|
double(timeout) * 0.01, PRIVATE_ADDRESS(link.RemoteAddress()));
|
|
link.link_super_tout = timeout;
|
|
btsnd_hcic_write_link_super_tout(LOCAL_BR_EDR_CONTROLLER_ID, link.Handle(),
|
|
timeout);
|
|
}
|
|
|
|
/* 3 seconds timeout waiting for responses */
|
|
#define BTM_DEV_REPLY_TIMEOUT_MS (3 * 1000)
|
|
|
|
void BTM_acl_after_controller_started(const controller_t* controller) {
|
|
internal_.btm_set_default_link_policy(
|
|
HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH | HCI_ENABLE_HOLD_MODE |
|
|
HCI_ENABLE_SNIFF_MODE | HCI_ENABLE_PARK_MODE);
|
|
|
|
/* Create ACL supported packet types mask */
|
|
uint16_t btm_acl_pkt_types_supported =
|
|
(HCI_PKT_TYPES_MASK_DH1 + HCI_PKT_TYPES_MASK_DM1);
|
|
|
|
if (controller->supports_3_slot_packets())
|
|
btm_acl_pkt_types_supported |=
|
|
(HCI_PKT_TYPES_MASK_DH3 + HCI_PKT_TYPES_MASK_DM3);
|
|
|
|
if (controller->supports_5_slot_packets())
|
|
btm_acl_pkt_types_supported |=
|
|
(HCI_PKT_TYPES_MASK_DH5 + HCI_PKT_TYPES_MASK_DM5);
|
|
|
|
/* Add in EDR related ACL types */
|
|
if (!controller->supports_classic_2m_phy()) {
|
|
btm_acl_pkt_types_supported |=
|
|
(HCI_PKT_TYPES_MASK_NO_2_DH1 + HCI_PKT_TYPES_MASK_NO_2_DH3 +
|
|
HCI_PKT_TYPES_MASK_NO_2_DH5);
|
|
}
|
|
|
|
if (!controller->supports_classic_3m_phy()) {
|
|
btm_acl_pkt_types_supported |=
|
|
(HCI_PKT_TYPES_MASK_NO_3_DH1 + HCI_PKT_TYPES_MASK_NO_3_DH3 +
|
|
HCI_PKT_TYPES_MASK_NO_3_DH5);
|
|
}
|
|
|
|
/* Check to see if 3 and 5 slot packets are available */
|
|
if (controller->supports_classic_2m_phy() ||
|
|
controller->supports_classic_3m_phy()) {
|
|
if (!controller->supports_3_slot_edr_packets())
|
|
btm_acl_pkt_types_supported |=
|
|
(HCI_PKT_TYPES_MASK_NO_2_DH3 + HCI_PKT_TYPES_MASK_NO_3_DH3);
|
|
|
|
if (!controller->supports_5_slot_edr_packets())
|
|
btm_acl_pkt_types_supported |=
|
|
(HCI_PKT_TYPES_MASK_NO_2_DH5 + HCI_PKT_TYPES_MASK_NO_3_DH5);
|
|
}
|
|
internal_.set_default_packet_types_supported(btm_acl_pkt_types_supported);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_bda_to_acl
|
|
*
|
|
* Description This function returns the FIRST acl_db entry for the passed
|
|
* BDA.
|
|
*
|
|
* Parameters bda : BD address of the remote device
|
|
* transport : Physical transport used for ACL connection
|
|
* (BR/EDR or LE)
|
|
*
|
|
* Returns Returns pointer to the ACL DB for the requested BDA if found.
|
|
* nullptr if not found.
|
|
*
|
|
******************************************************************************/
|
|
tACL_CONN* StackAclBtmAcl::btm_bda_to_acl(const RawAddress& bda,
|
|
tBT_TRANSPORT transport) {
|
|
tACL_CONN* p_acl = &btm_cb.acl_cb_.acl_db[0];
|
|
for (uint8_t index = 0; index < MAX_L2CAP_LINKS; index++, p_acl++) {
|
|
if ((p_acl->in_use) && p_acl->remote_addr == bda &&
|
|
p_acl->transport == transport) {
|
|
return p_acl;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
tACL_CONN* acl_get_connection_from_address(const RawAddress& bd_addr,
|
|
tBT_TRANSPORT transport) {
|
|
return internal_.btm_bda_to_acl(bd_addr, transport);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_handle_to_acl_index
|
|
*
|
|
* Description This function returns the FIRST acl_db entry for the passed
|
|
* hci_handle.
|
|
*
|
|
* Returns index to the acl_db or MAX_L2CAP_LINKS.
|
|
*
|
|
******************************************************************************/
|
|
uint8_t btm_handle_to_acl_index(uint16_t hci_handle) {
|
|
tACL_CONN* p = &btm_cb.acl_cb_.acl_db[0];
|
|
uint8_t xx;
|
|
for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p++) {
|
|
if ((p->in_use) && (p->hci_handle == hci_handle)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* If here, no BD Addr found */
|
|
return (xx);
|
|
}
|
|
|
|
tACL_CONN* StackAclBtmAcl::acl_get_connection_from_handle(uint16_t hci_handle) {
|
|
uint8_t index = btm_handle_to_acl_index(hci_handle);
|
|
if (index >= MAX_L2CAP_LINKS) return nullptr;
|
|
return &btm_cb.acl_cb_.acl_db[index];
|
|
}
|
|
|
|
tACL_CONN* acl_get_connection_from_handle(uint16_t handle) {
|
|
return internal_.acl_get_connection_from_handle(handle);
|
|
}
|
|
|
|
void btm_acl_process_sca_cmpl_pkt(uint8_t len, uint8_t* data) {
|
|
uint16_t handle;
|
|
uint8_t sca;
|
|
uint8_t status;
|
|
|
|
if (len < 4) {
|
|
LOG_WARN("Malformatted packet, not containing enough data");
|
|
return;
|
|
}
|
|
|
|
STREAM_TO_UINT8(status, data);
|
|
|
|
if (status != HCI_SUCCESS) {
|
|
LOG_WARN("Peer SCA Command complete failed:%s",
|
|
hci_error_code_text(static_cast<tHCI_STATUS>(status)).c_str());
|
|
return;
|
|
}
|
|
|
|
STREAM_TO_UINT16(handle, data);
|
|
STREAM_TO_UINT8(sca, data);
|
|
|
|
tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
p_acl->sca = sca;
|
|
}
|
|
|
|
tACL_CONN* StackAclBtmAcl::acl_allocate_connection() {
|
|
tACL_CONN* p_acl = &btm_cb.acl_cb_.acl_db[0];
|
|
for (uint8_t xx = 0; xx < MAX_L2CAP_LINKS; xx++, p_acl++) {
|
|
if (!p_acl->in_use) {
|
|
return p_acl;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void btm_acl_created(const RawAddress& bda, uint16_t hci_handle,
|
|
tHCI_ROLE link_role, tBT_TRANSPORT transport) {
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(bda, transport);
|
|
if (p_acl != (tACL_CONN*)NULL) {
|
|
p_acl->hci_handle = hci_handle;
|
|
p_acl->link_role = link_role;
|
|
p_acl->transport = transport;
|
|
btm_set_link_policy(p_acl, btm_cb.acl_cb_.DefaultLinkPolicy());
|
|
LOG_WARN(
|
|
"Unable to create duplicate acl when one already exists handle:%hu"
|
|
" role:%s transport:%s",
|
|
hci_handle, RoleText(link_role).c_str(),
|
|
bt_transport_text(transport).c_str());
|
|
return;
|
|
}
|
|
|
|
p_acl = internal_.acl_allocate_connection();
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
|
|
p_acl->in_use = true;
|
|
p_acl->hci_handle = hci_handle;
|
|
p_acl->link_role = link_role;
|
|
p_acl->link_up_issued = false;
|
|
p_acl->remote_addr = bda;
|
|
p_acl->sca = 0xFF;
|
|
p_acl->transport = transport;
|
|
p_acl->switch_role_failed_attempts = 0;
|
|
p_acl->reset_switch_role();
|
|
BTM_PM_OnConnected(hci_handle, bda);
|
|
|
|
LOG_DEBUG(
|
|
"Created new ACL connection peer:%s role:%s handle:0x%04x transport:%s",
|
|
PRIVATE_ADDRESS(bda), RoleText(p_acl->link_role).c_str(), hci_handle,
|
|
bt_transport_text(transport).c_str());
|
|
btm_set_link_policy(p_acl, btm_cb.acl_cb_.DefaultLinkPolicy());
|
|
|
|
if (transport == BT_TRANSPORT_LE) {
|
|
btm_ble_refresh_local_resolvable_private_addr(
|
|
bda, btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr);
|
|
}
|
|
/* if BR/EDR do something more */
|
|
if (transport == BT_TRANSPORT_BR_EDR) {
|
|
btsnd_hcic_read_rmt_clk_offset(hci_handle);
|
|
if (!bluetooth::shim::is_gd_l2cap_enabled() &&
|
|
!bluetooth::shim::is_gd_acl_enabled()) {
|
|
// GD L2cap and GD Acl read this automatically
|
|
btsnd_hcic_rmt_ver_req(hci_handle);
|
|
}
|
|
}
|
|
|
|
if (transport == BT_TRANSPORT_LE) {
|
|
btm_ble_get_acl_remote_addr(hci_handle, p_acl->active_remote_addr,
|
|
&p_acl->active_remote_addr_type);
|
|
|
|
if (controller_get_interface()
|
|
->supports_ble_peripheral_initiated_feature_exchange() ||
|
|
link_role == HCI_ROLE_CENTRAL) {
|
|
btsnd_hcic_ble_read_remote_feat(p_acl->hci_handle);
|
|
} else {
|
|
internal_.btm_establish_continue(p_acl);
|
|
}
|
|
}
|
|
}
|
|
|
|
void btm_acl_update_conn_addr(uint16_t handle, const RawAddress& address) {
|
|
tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
p_acl->conn_addr = address;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_acl_removed
|
|
*
|
|
* Description This function is called by L2CAP when an ACL connection
|
|
* is removed. Since only L2CAP creates ACL links, we use
|
|
* the L2CAP link index as our index into the control blocks.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_acl_removed(uint16_t handle) {
|
|
tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
p_acl->in_use = false;
|
|
NotifyAclLinkDown(*p_acl);
|
|
p_acl->Reset();
|
|
BTM_PM_OnDisconnected(handle);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_acl_device_down
|
|
*
|
|
* Description This function is called when the local device is deemed
|
|
* to be down. It notifies L2CAP of the failure.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_acl_device_down(void) {
|
|
tACL_CONN* p = &btm_cb.acl_cb_.acl_db[0];
|
|
uint16_t xx;
|
|
for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p++) {
|
|
if (p->in_use) {
|
|
l2c_link_hci_disc_comp(p->hci_handle, HCI_ERR_HW_FAILURE);
|
|
}
|
|
}
|
|
BTM_db_reset();
|
|
}
|
|
|
|
void btm_acl_set_paging(bool value) { btm_cb.is_paging = value; }
|
|
|
|
void btm_acl_update_inquiry_status(uint8_t status) {
|
|
btm_cb.is_inquiry = status == BTM_INQUIRY_STARTED;
|
|
BTIF_dm_report_inquiry_status_change(status);
|
|
}
|
|
|
|
tBTM_STATUS BTM_GetRole(const RawAddress& remote_bd_addr, tHCI_ROLE* p_role) {
|
|
if (p_role == nullptr) {
|
|
return BTM_ILLEGAL_VALUE;
|
|
}
|
|
*p_role = HCI_ROLE_UNKNOWN;
|
|
|
|
tACL_CONN* p_acl =
|
|
internal_.btm_bda_to_acl(remote_bd_addr, BT_TRANSPORT_BR_EDR);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return BTM_UNKNOWN_ADDR;
|
|
}
|
|
*p_role = p_acl->link_role;
|
|
return BTM_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_SwitchRoleToCentral
|
|
*
|
|
* Description This function is called to switch role between central and
|
|
* peripheral. If role is already set it will do nothing.
|
|
*
|
|
* Returns BTM_SUCCESS if already in specified role.
|
|
* BTM_CMD_STARTED if command issued to controller.
|
|
* BTM_NO_RESOURCES if couldn't allocate memory to issue
|
|
* command
|
|
* BTM_UNKNOWN_ADDR if no active link with bd addr specified
|
|
* BTM_MODE_UNSUPPORTED if local device does not support role
|
|
* switching
|
|
* BTM_BUSY if the previous command is not completed
|
|
*
|
|
******************************************************************************/
|
|
tBTM_STATUS BTM_SwitchRoleToCentral(const RawAddress& remote_bd_addr) {
|
|
if (bluetooth::shim::is_gd_l2cap_enabled()) {
|
|
bluetooth::shim::L2CA_SwitchRoleToCentral(remote_bd_addr);
|
|
return BTM_SUCCESS;
|
|
}
|
|
if (!controller_get_interface()->supports_central_peripheral_role_switch()) {
|
|
LOG_INFO("Local controller does not support role switching");
|
|
return BTM_MODE_UNSUPPORTED;
|
|
}
|
|
|
|
tACL_CONN* p_acl =
|
|
internal_.btm_bda_to_acl(remote_bd_addr, BT_TRANSPORT_BR_EDR);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return BTM_UNKNOWN_ADDR;
|
|
}
|
|
|
|
if (p_acl->link_role == HCI_ROLE_CENTRAL) {
|
|
LOG_INFO("Requested role is already in effect");
|
|
return BTM_SUCCESS;
|
|
}
|
|
|
|
if (interop_match_addr(INTEROP_DISABLE_ROLE_SWITCH, &remote_bd_addr)) {
|
|
LOG_INFO("Remote device is on list preventing role switch");
|
|
return BTM_DEV_RESTRICT_LISTED;
|
|
}
|
|
|
|
if (BTM_IsScoActiveByBdaddr(remote_bd_addr)) {
|
|
LOG_INFO("An active SCO to device prevents role switch at this time");
|
|
return BTM_NO_RESOURCES;
|
|
}
|
|
|
|
if (!p_acl->is_switch_role_idle()) {
|
|
LOG_INFO("Role switch is already progress");
|
|
return BTM_BUSY;
|
|
}
|
|
|
|
tBTM_PM_MODE pwr_mode;
|
|
if (!BTM_ReadPowerMode(p_acl->remote_addr, &pwr_mode)) {
|
|
LOG_WARN(
|
|
"Unable to find device to read current power mode prior to role "
|
|
"switch");
|
|
return BTM_UNKNOWN_ADDR;
|
|
};
|
|
|
|
if (pwr_mode == BTM_PM_MD_PARK || pwr_mode == BTM_PM_MD_SNIFF) {
|
|
if (!BTM_SetLinkPolicyActiveMode(p_acl->remote_addr)) {
|
|
LOG_WARN("Unable to set link policy active before attempting switch");
|
|
return BTM_WRONG_MODE;
|
|
}
|
|
p_acl->set_switch_role_changing();
|
|
}
|
|
/* some devices do not support switch while encryption is on */
|
|
else {
|
|
if (p_acl->is_encrypted && !IsEprAvailable(*p_acl)) {
|
|
/* bypass turning off encryption if change link key is already doing it */
|
|
p_acl->set_encryption_off();
|
|
p_acl->set_switch_role_encryption_off();
|
|
} else {
|
|
internal_.hci_start_role_switch_to_central(*p_acl);
|
|
}
|
|
}
|
|
|
|
return BTM_CMD_STARTED;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_acl_encrypt_change
|
|
*
|
|
* Description This function is when encryption of the connection is
|
|
* completed by the LM. Checks to see if a role switch or
|
|
* change of link key was active and initiates or continues
|
|
* process if needed.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_acl_encrypt_change(uint16_t handle, uint8_t status,
|
|
uint8_t encr_enable) {
|
|
tACL_CONN* p = internal_.acl_get_connection_from_handle(handle);
|
|
if (p == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
|
|
p->is_encrypted = encr_enable;
|
|
|
|
/* Process Role Switch if active */
|
|
if (p->is_switch_role_encryption_off()) {
|
|
/* if encryption turn off failed we still will try to switch role */
|
|
if (encr_enable) {
|
|
p->set_encryption_idle();
|
|
p->reset_switch_role();
|
|
} else {
|
|
p->set_encryption_switching();
|
|
p->set_switch_role_switching();
|
|
}
|
|
internal_.hci_start_role_switch_to_central(*p);
|
|
}
|
|
/* Finished enabling Encryption after role switch */
|
|
else if (p->is_switch_role_encryption_on()) {
|
|
p->reset_switch_role();
|
|
p->set_encryption_idle();
|
|
NotifyAclRoleSwitchComplete(
|
|
btm_cb.acl_cb_.switch_role_ref_data.remote_bd_addr,
|
|
btm_cb.acl_cb_.switch_role_ref_data.role,
|
|
btm_cb.acl_cb_.switch_role_ref_data.hci_status);
|
|
|
|
/* If a disconnect is pending, issue it now that role switch has completed
|
|
*/
|
|
if (p->rs_disc_pending == BTM_SEC_DISC_PENDING) {
|
|
hci_btsnd_hcic_disconnect(*p, HCI_ERR_PEER_USER);
|
|
}
|
|
p->rs_disc_pending = BTM_SEC_RS_NOT_PENDING; /* reset flag */
|
|
}
|
|
}
|
|
|
|
static void check_link_policy(tLINK_POLICY* settings) {
|
|
const controller_t* controller = controller_get_interface();
|
|
|
|
if ((*settings & HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH) &&
|
|
(!controller->supports_role_switch())) {
|
|
*settings &= (~HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH);
|
|
LOG_INFO("Role switch not supported (settings: 0x%04x)", *settings);
|
|
}
|
|
if ((*settings & HCI_ENABLE_HOLD_MODE) &&
|
|
(!controller->supports_hold_mode())) {
|
|
*settings &= (~HCI_ENABLE_HOLD_MODE);
|
|
LOG_INFO("hold not supported (settings: 0x%04x)", *settings);
|
|
}
|
|
if ((*settings & HCI_ENABLE_SNIFF_MODE) &&
|
|
(!controller->supports_sniff_mode())) {
|
|
*settings &= (~HCI_ENABLE_SNIFF_MODE);
|
|
LOG_INFO("sniff not supported (settings: 0x%04x)", *settings);
|
|
}
|
|
if ((*settings & HCI_ENABLE_PARK_MODE) &&
|
|
(!controller->supports_park_mode())) {
|
|
*settings &= (~HCI_ENABLE_PARK_MODE);
|
|
LOG_INFO("park not supported (settings: 0x%04x)", *settings);
|
|
}
|
|
}
|
|
|
|
void btm_set_link_policy(tACL_CONN* conn, tLINK_POLICY policy) {
|
|
conn->link_policy = policy;
|
|
check_link_policy(&conn->link_policy);
|
|
if ((conn->link_policy & HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH) &&
|
|
interop_match_addr(INTEROP_DISABLE_SNIFF, &(conn->remote_addr))) {
|
|
conn->link_policy &= (~HCI_ENABLE_SNIFF_MODE);
|
|
}
|
|
btsnd_hcic_write_policy_set(conn->hci_handle,
|
|
static_cast<uint16_t>(conn->link_policy));
|
|
}
|
|
|
|
static void btm_toggle_policy_on_for(const RawAddress& peer_addr,
|
|
uint16_t flag) {
|
|
auto conn = internal_.btm_bda_to_acl(peer_addr, BT_TRANSPORT_BR_EDR);
|
|
if (!conn) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
btm_set_link_policy(conn, conn->link_policy | flag);
|
|
}
|
|
|
|
static void btm_toggle_policy_off_for(const RawAddress& peer_addr,
|
|
uint16_t flag) {
|
|
auto conn = internal_.btm_bda_to_acl(peer_addr, BT_TRANSPORT_BR_EDR);
|
|
if (!conn) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
btm_set_link_policy(conn, conn->link_policy & ~flag);
|
|
}
|
|
|
|
bool BTM_is_sniff_allowed_for(const RawAddress& peer_addr) {
|
|
auto conn = internal_.btm_bda_to_acl(peer_addr, BT_TRANSPORT_BR_EDR);
|
|
if (!conn) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return false;
|
|
}
|
|
return conn->link_policy & HCI_ENABLE_SNIFF_MODE;
|
|
}
|
|
|
|
void BTM_unblock_sniff_mode_for(const RawAddress& peer_addr) {
|
|
btm_toggle_policy_on_for(peer_addr, HCI_ENABLE_SNIFF_MODE);
|
|
}
|
|
|
|
void BTM_block_sniff_mode_for(const RawAddress& peer_addr) {
|
|
btm_toggle_policy_off_for(peer_addr, HCI_ENABLE_SNIFF_MODE);
|
|
}
|
|
|
|
void BTM_unblock_role_switch_for(const RawAddress& peer_addr) {
|
|
btm_toggle_policy_on_for(peer_addr, HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH);
|
|
}
|
|
|
|
void BTM_block_role_switch_for(const RawAddress& peer_addr) {
|
|
btm_toggle_policy_off_for(peer_addr, HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH);
|
|
}
|
|
|
|
void StackAclBtmAcl::btm_set_default_link_policy(tLINK_POLICY settings) {
|
|
check_link_policy(&settings);
|
|
btm_cb.acl_cb_.btm_def_link_policy = settings;
|
|
btsnd_hcic_write_def_policy_set(settings);
|
|
}
|
|
|
|
void BTM_default_unblock_role_switch() {
|
|
internal_.btm_set_default_link_policy(btm_cb.acl_cb_.DefaultLinkPolicy() |
|
|
HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH);
|
|
}
|
|
|
|
void BTM_default_block_role_switch() {
|
|
internal_.btm_set_default_link_policy(btm_cb.acl_cb_.DefaultLinkPolicy() &
|
|
~HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_remote_version_complete
|
|
*
|
|
* Description This function is called when the command complete message
|
|
* is received from the HCI for the remote version info.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
static void maybe_chain_more_commands_after_read_remote_version_complete(
|
|
uint8_t status, uint16_t handle) {
|
|
tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl_cb == nullptr) {
|
|
LOG_WARN("Received remote version complete for unknown device");
|
|
return;
|
|
}
|
|
|
|
switch (p_acl_cb->transport) {
|
|
case BT_TRANSPORT_LE:
|
|
l2cble_notify_le_connection(p_acl_cb->remote_addr);
|
|
l2cble_use_preferred_conn_params(p_acl_cb->remote_addr);
|
|
break;
|
|
case BT_TRANSPORT_BR_EDR:
|
|
/**
|
|
* When running legacy stack continue chain of executing various
|
|
* read commands. Skip when gd_acl is enabled because that
|
|
* module handles all remote read functionality.
|
|
*/
|
|
if (!bluetooth::shim::is_gd_acl_enabled()) {
|
|
if (status == HCI_SUCCESS) {
|
|
internal_.btm_read_remote_features(p_acl_cb->hci_handle);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void btm_process_remote_version_complete(uint8_t status, uint16_t handle,
|
|
uint8_t lmp_version,
|
|
uint16_t manufacturer,
|
|
uint16_t lmp_subversion) {
|
|
tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl_cb == nullptr) {
|
|
LOG_WARN("Received remote version complete for unknown acl");
|
|
return;
|
|
}
|
|
|
|
if (status == HCI_SUCCESS) {
|
|
p_acl_cb->remote_version_info.lmp_version = lmp_version;
|
|
p_acl_cb->remote_version_info.manufacturer = manufacturer;
|
|
p_acl_cb->remote_version_info.lmp_subversion = lmp_subversion;
|
|
p_acl_cb->remote_version_info.valid = true;
|
|
BTM_update_version_info(p_acl_cb->RemoteAddress(),
|
|
p_acl_cb->remote_version_info);
|
|
|
|
bluetooth::common::LogRemoteVersionInfo(handle, status, lmp_version,
|
|
manufacturer, lmp_subversion);
|
|
} else {
|
|
bluetooth::common::LogRemoteVersionInfo(handle, status, 0, 0, 0);
|
|
}
|
|
}
|
|
|
|
void btm_read_remote_version_complete_raw(uint8_t* p) {
|
|
uint8_t status;
|
|
uint16_t handle;
|
|
uint8_t lmp_version;
|
|
uint16_t manufacturer;
|
|
uint16_t lmp_subversion;
|
|
|
|
STREAM_TO_UINT8(status, p);
|
|
STREAM_TO_UINT16(handle, p);
|
|
STREAM_TO_UINT8(lmp_version, p);
|
|
STREAM_TO_UINT16(manufacturer, p);
|
|
STREAM_TO_UINT16(lmp_subversion, p);
|
|
|
|
ASSERT_LOG(!bluetooth::shim::is_gd_acl_enabled(),
|
|
"gd acl layer should be receiving this completion");
|
|
btm_read_remote_version_complete(static_cast<tHCI_STATUS>(status), handle,
|
|
lmp_version, manufacturer, lmp_version);
|
|
}
|
|
|
|
void btm_read_remote_version_complete(tHCI_STATUS status, uint16_t handle,
|
|
uint8_t lmp_version,
|
|
uint16_t manufacturer,
|
|
uint16_t lmp_subversion) {
|
|
btm_process_remote_version_complete(status, handle, lmp_version, manufacturer,
|
|
lmp_subversion);
|
|
maybe_chain_more_commands_after_read_remote_version_complete(status, handle);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_process_remote_ext_features
|
|
*
|
|
* Description Local function called to process all extended features pages
|
|
* read from a remote device.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_process_remote_ext_features(tACL_CONN* p_acl_cb,
|
|
uint8_t max_page_number) {
|
|
CHECK(p_acl_cb != nullptr);
|
|
if (!p_acl_cb->peer_lmp_feature_valid[max_page_number]) {
|
|
LOG_WARN(
|
|
"Checking remote features but remote feature read is "
|
|
"incomplete");
|
|
}
|
|
|
|
bool ssp_supported =
|
|
HCI_SSP_HOST_SUPPORTED(p_acl_cb->peer_lmp_feature_pages[1]);
|
|
bool secure_connections_supported =
|
|
HCI_SC_HOST_SUPPORTED(p_acl_cb->peer_lmp_feature_pages[1]);
|
|
bool role_switch_supported =
|
|
HCI_SWITCH_SUPPORTED(p_acl_cb->peer_lmp_feature_pages[0]);
|
|
bool br_edr_supported =
|
|
!HCI_BREDR_NOT_SPT_SUPPORTED(p_acl_cb->peer_lmp_feature_pages[0]);
|
|
bool le_supported =
|
|
HCI_LE_SPT_SUPPORTED(p_acl_cb->peer_lmp_feature_pages[0]) &&
|
|
HCI_LE_HOST_SUPPORTED(p_acl_cb->peer_lmp_feature_pages[1]);
|
|
btm_sec_set_peer_sec_caps(p_acl_cb->hci_handle, ssp_supported,
|
|
secure_connections_supported, role_switch_supported,
|
|
br_edr_supported, le_supported);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_remote_features
|
|
*
|
|
* Description Local function called to send a read remote supported
|
|
* features/remote extended features page[0].
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void StackAclBtmAcl::btm_read_remote_features(uint16_t handle) {
|
|
uint8_t acl_idx;
|
|
tACL_CONN* p_acl_cb;
|
|
|
|
acl_idx = btm_handle_to_acl_index(handle);
|
|
if (acl_idx >= MAX_L2CAP_LINKS) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
|
|
p_acl_cb = &btm_cb.acl_cb_.acl_db[acl_idx];
|
|
memset(p_acl_cb->peer_lmp_feature_pages, 0,
|
|
sizeof(p_acl_cb->peer_lmp_feature_pages));
|
|
|
|
/* first send read remote supported features HCI command */
|
|
/* because we don't know whether the remote support extended feature command
|
|
*/
|
|
if (bluetooth::shim::is_gd_l2cap_enabled()) {
|
|
// GD L2cap reads this automatically
|
|
return;
|
|
}
|
|
btsnd_hcic_rmt_features_req(handle);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_remote_ext_features
|
|
*
|
|
* Description Local function called to send a read remote extended
|
|
* features
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_read_remote_ext_features(uint16_t handle, uint8_t page_number) {
|
|
if (bluetooth::shim::is_gd_l2cap_enabled()) {
|
|
// GD L2cap reads this automatically
|
|
return;
|
|
}
|
|
btsnd_hcic_rmt_ext_features(handle, page_number);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_remote_features_complete
|
|
*
|
|
* Description This function is called when the remote supported features
|
|
* complete event is received from the HCI.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_read_remote_features_complete_raw(uint8_t* p) {
|
|
uint8_t status;
|
|
uint16_t handle;
|
|
|
|
STREAM_TO_UINT8(status, p);
|
|
|
|
if (status != HCI_SUCCESS) {
|
|
LOG_WARN("Uanble to read remote features status:%s",
|
|
hci_error_code_text(static_cast<tHCI_STATUS>(status)).c_str());
|
|
return;
|
|
}
|
|
|
|
STREAM_TO_UINT16(handle, p);
|
|
|
|
btm_read_remote_features_complete(handle, p);
|
|
}
|
|
|
|
void btm_read_remote_features_complete(uint16_t handle, uint8_t* features) {
|
|
tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl_cb == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
|
|
/* Copy the received features page */
|
|
STREAM_TO_ARRAY(p_acl_cb->peer_lmp_feature_pages[0], features,
|
|
HCI_FEATURE_BYTES_PER_PAGE);
|
|
p_acl_cb->peer_lmp_feature_valid[0] = true;
|
|
|
|
if ((HCI_LMP_EXTENDED_SUPPORTED(p_acl_cb->peer_lmp_feature_pages[0])) &&
|
|
(controller_get_interface()
|
|
->supports_reading_remote_extended_features())) {
|
|
/* if the remote controller has extended features and local controller
|
|
supports HCI_Read_Remote_Extended_Features command then start reading
|
|
these feature starting with extended features page 1 */
|
|
LOG_DEBUG("Start reading remote extended features");
|
|
btm_read_remote_ext_features(handle, 1);
|
|
return;
|
|
}
|
|
|
|
/* Remote controller has no extended features. Process remote controller
|
|
supported features (features page 0). */
|
|
btm_process_remote_ext_features(p_acl_cb, 0);
|
|
|
|
/* Continue with HCI connection establishment */
|
|
internal_.btm_establish_continue(p_acl_cb);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_remote_ext_features_complete
|
|
*
|
|
* Description This function is called when the remote extended features
|
|
* complete event is received from the HCI.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_read_remote_ext_features_complete_raw(uint8_t* p, uint8_t evt_len) {
|
|
uint8_t page_num, max_page;
|
|
uint16_t handle;
|
|
|
|
if (evt_len < HCI_EXT_FEATURES_SUCCESS_EVT_LEN) {
|
|
android_errorWriteLog(0x534e4554, "141552859");
|
|
LOG_WARN("Remote extended feature length too short. length=%d", evt_len);
|
|
return;
|
|
}
|
|
|
|
++p;
|
|
STREAM_TO_UINT16(handle, p);
|
|
STREAM_TO_UINT8(page_num, p);
|
|
STREAM_TO_UINT8(max_page, p);
|
|
|
|
if (max_page > HCI_EXT_FEATURES_PAGE_MAX) {
|
|
LOG_WARN("Too many max pages read page=%d unknown", max_page);
|
|
return;
|
|
}
|
|
|
|
if (page_num > HCI_EXT_FEATURES_PAGE_MAX) {
|
|
android_errorWriteLog(0x534e4554, "141552859");
|
|
LOG_WARN("Too many received pages num_page=%d invalid", page_num);
|
|
return;
|
|
}
|
|
|
|
if (page_num > max_page) {
|
|
LOG_WARN("num_page=%d, max_page=%d invalid", page_num, max_page);
|
|
}
|
|
|
|
btm_read_remote_ext_features_complete(handle, page_num, max_page, p);
|
|
}
|
|
|
|
void btm_read_remote_ext_features_complete(uint16_t handle, uint8_t page_num,
|
|
uint8_t max_page,
|
|
uint8_t* features) {
|
|
/* Validate parameters */
|
|
auto* p_acl_cb = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl_cb == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
|
|
/* Copy the received features page */
|
|
STREAM_TO_ARRAY(p_acl_cb->peer_lmp_feature_pages[page_num], features,
|
|
HCI_FEATURE_BYTES_PER_PAGE);
|
|
p_acl_cb->peer_lmp_feature_valid[page_num] = true;
|
|
|
|
/* If there is the next remote features page and
|
|
* we have space to keep this page data - read this page */
|
|
if ((page_num < max_page) && (page_num < HCI_EXT_FEATURES_PAGE_MAX)) {
|
|
page_num++;
|
|
LOG_DEBUG("BTM reads next remote extended features page (%d)", page_num);
|
|
btm_read_remote_ext_features(handle, page_num);
|
|
return;
|
|
}
|
|
|
|
/* Reading of remote feature pages is complete */
|
|
LOG_DEBUG("BTM reached last remote extended features page (%d)", page_num);
|
|
|
|
/* Process the pages */
|
|
btm_process_remote_ext_features(p_acl_cb, max_page);
|
|
|
|
/* Continue with HCI connection establishment */
|
|
internal_.btm_establish_continue(p_acl_cb);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_remote_ext_features_failed
|
|
*
|
|
* Description This function is called when the remote extended features
|
|
* complete event returns a failed status.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_read_remote_ext_features_failed(uint8_t status, uint16_t handle) {
|
|
LOG_WARN("status 0x%02x for handle %d", status, handle);
|
|
|
|
tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl_cb == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
|
|
/* Process supported features only */
|
|
btm_process_remote_ext_features(p_acl_cb, 0);
|
|
|
|
/* Continue HCI connection establishment */
|
|
internal_.btm_establish_continue(p_acl_cb);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_establish_continue
|
|
*
|
|
* Description This function is called when the command complete message
|
|
* is received from the HCI for the read local link policy
|
|
* request.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void StackAclBtmAcl::btm_establish_continue(tACL_CONN* p_acl) {
|
|
CHECK(p_acl != nullptr);
|
|
|
|
if (p_acl->is_transport_br_edr()) {
|
|
/* For now there are a some devices that do not like sending */
|
|
/* commands events and data at the same time. */
|
|
/* Set the packet types to the default allowed by the device */
|
|
const uint16_t default_packet_type_mask =
|
|
btm_cb.acl_cb_.DefaultPacketTypes();
|
|
if (!internal_.change_connection_packet_types(*p_acl,
|
|
default_packet_type_mask)) {
|
|
LOG_ERROR("Unable to change connection packet type types:%04x address:%s",
|
|
default_packet_type_mask,
|
|
PRIVATE_ADDRESS(p_acl->RemoteAddress()));
|
|
}
|
|
btm_set_link_policy(p_acl, btm_cb.acl_cb_.DefaultLinkPolicy());
|
|
}
|
|
NotifyAclLinkUp(*p_acl);
|
|
}
|
|
|
|
void btm_establish_continue_from_address(const RawAddress& bda,
|
|
tBT_TRANSPORT transport) {
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(bda, transport);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
internal_.btm_establish_continue(p_acl);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_GetLinkSuperTout
|
|
*
|
|
* Description Read the link supervision timeout value of the connection
|
|
*
|
|
* Returns status of the operation
|
|
*
|
|
******************************************************************************/
|
|
tBTM_STATUS BTM_GetLinkSuperTout(const RawAddress& remote_bda,
|
|
uint16_t* p_timeout) {
|
|
CHECK(p_timeout != nullptr);
|
|
const tACL_CONN* p_acl =
|
|
internal_.btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return BTM_UNKNOWN_ADDR;
|
|
}
|
|
*p_timeout = p_acl->link_super_tout;
|
|
return BTM_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_SetLinkSuperTout
|
|
*
|
|
* Description Create and send HCI "Write Link Supervision Timeout" command
|
|
*
|
|
* Returns status of the operation
|
|
*
|
|
******************************************************************************/
|
|
tBTM_STATUS BTM_SetLinkSuperTout(const RawAddress& remote_bda,
|
|
uint16_t timeout) {
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return BTM_UNKNOWN_ADDR;
|
|
}
|
|
|
|
/* Only send if current role is Central; 2.0 spec requires this */
|
|
if (p_acl->link_role == HCI_ROLE_CENTRAL) {
|
|
p_acl->link_super_tout = timeout;
|
|
btsnd_hcic_write_link_super_tout(LOCAL_BR_EDR_CONTROLLER_ID,
|
|
p_acl->hci_handle, timeout);
|
|
LOG_DEBUG("Set supervision timeout:%.2fms bd_addr:%s",
|
|
supervision_timeout_to_seconds(timeout),
|
|
PRIVATE_ADDRESS(remote_bda));
|
|
return BTM_CMD_STARTED;
|
|
} else {
|
|
LOG_WARN(
|
|
"Role is peripheral so unable to set supervision timeout:%.2fms "
|
|
"bd_addr:%s",
|
|
supervision_timeout_to_seconds(timeout), PRIVATE_ADDRESS(remote_bda));
|
|
return BTM_SUCCESS;
|
|
}
|
|
}
|
|
|
|
bool BTM_IsAclConnectionUp(const RawAddress& remote_bda,
|
|
tBT_TRANSPORT transport) {
|
|
if (bluetooth::shim::is_gd_l2cap_enabled()) {
|
|
return bluetooth::shim::L2CA_IsLinkEstablished(remote_bda, transport);
|
|
}
|
|
|
|
return internal_.btm_bda_to_acl(remote_bda, transport) != nullptr;
|
|
}
|
|
|
|
bool BTM_IsAclConnectionUpAndHandleValid(const RawAddress& remote_bda,
|
|
tBT_TRANSPORT transport) {
|
|
if (bluetooth::shim::is_gd_l2cap_enabled()) {
|
|
return bluetooth::shim::L2CA_IsLinkEstablished(remote_bda, transport);
|
|
}
|
|
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(remote_bda, transport);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return false;
|
|
}
|
|
return p_acl->hci_handle != HCI_INVALID_HANDLE;
|
|
}
|
|
|
|
bool BTM_IsAclConnectionUpFromHandle(uint16_t hci_handle) {
|
|
return internal_.acl_get_connection_from_handle(hci_handle) != nullptr;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_GetNumAclLinks
|
|
*
|
|
* Description This function is called to count the number of
|
|
* ACL links that are active.
|
|
*
|
|
* Returns uint16_t Number of active ACL links
|
|
*
|
|
******************************************************************************/
|
|
uint16_t BTM_GetNumAclLinks(void) {
|
|
if (bluetooth::shim::is_gd_l2cap_enabled()) {
|
|
return bluetooth::shim::L2CA_GetNumLinks();
|
|
}
|
|
return static_cast<uint16_t>(btm_cb.acl_cb_.NumberOfActiveLinks());
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_get_acl_disc_reason_code
|
|
*
|
|
* Description This function is called to get the disconnection reason code
|
|
* returned by the HCI at disconnection complete event.
|
|
*
|
|
* Returns true if connection is up, else false.
|
|
*
|
|
******************************************************************************/
|
|
tHCI_REASON btm_get_acl_disc_reason_code(void) {
|
|
return btm_cb.acl_cb_.get_disconnect_reason();
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_GetHCIConnHandle
|
|
*
|
|
* Description This function is called to get the handle for an ACL
|
|
* connection to a specific remote BD Address.
|
|
*
|
|
* Returns the handle of the connection, or HCI_INVALID_HANDLE if none.
|
|
*
|
|
******************************************************************************/
|
|
uint16_t BTM_GetHCIConnHandle(const RawAddress& remote_bda,
|
|
tBT_TRANSPORT transport) {
|
|
if (bluetooth::shim::is_gd_l2cap_enabled()) {
|
|
return bluetooth::shim::BTM_GetHCIConnHandle(remote_bda, transport);
|
|
}
|
|
|
|
tACL_CONN* p;
|
|
p = internal_.btm_bda_to_acl(remote_bda, transport);
|
|
if (p != (tACL_CONN*)NULL) {
|
|
return (p->hci_handle);
|
|
}
|
|
|
|
/* If here, no BD Addr found */
|
|
return HCI_INVALID_HANDLE;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_IsPhy2mSupported
|
|
*
|
|
* Description This function is called to check PHY 2M support
|
|
* from peer device
|
|
* Returns True when PHY 2M supported false otherwise
|
|
*
|
|
******************************************************************************/
|
|
bool BTM_IsPhy2mSupported(const RawAddress& remote_bda, tBT_TRANSPORT transport) {
|
|
tACL_CONN* p;
|
|
BTM_TRACE_DEBUG("BTM_IsPhy2mSupported");
|
|
p = internal_.btm_bda_to_acl(remote_bda, transport);
|
|
if (p == (tACL_CONN*)NULL) {
|
|
BTM_TRACE_DEBUG("BTM_IsPhy2mSupported: no connection");
|
|
return false;
|
|
}
|
|
|
|
if (!p->peer_le_features_valid) {
|
|
LOG_WARN(
|
|
"Checking remote features but remote feature read is "
|
|
"incomplete");
|
|
}
|
|
return HCI_LE_2M_PHY_SUPPORTED(p->peer_le_features);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_RequestPeerSCA
|
|
*
|
|
* Description This function is called to request sleep clock accuracy
|
|
* from peer device
|
|
*
|
|
******************************************************************************/
|
|
void BTM_RequestPeerSCA(const RawAddress& remote_bda, tBT_TRANSPORT transport) {
|
|
tACL_CONN* p;
|
|
p = internal_.btm_bda_to_acl(remote_bda, transport);
|
|
if (p == (tACL_CONN*)NULL) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
|
|
btsnd_hcic_req_peer_sca(p->hci_handle);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_GetPeerSCA
|
|
*
|
|
* Description This function is called to get peer sleep clock accuracy
|
|
*
|
|
* Returns SCA or 0xFF if SCA was never previously requested, request
|
|
* is not supported by peer device or ACL does not exist
|
|
*
|
|
******************************************************************************/
|
|
uint8_t BTM_GetPeerSCA(const RawAddress& remote_bda, tBT_TRANSPORT transport) {
|
|
tACL_CONN* p;
|
|
p = internal_.btm_bda_to_acl(remote_bda, transport);
|
|
if (p != (tACL_CONN*)NULL) {
|
|
return (p->sca);
|
|
}
|
|
LOG_WARN("Unable to find active acl");
|
|
|
|
/* If here, no BD Addr found */
|
|
return (0xFF);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_rejectlist_role_change_device
|
|
*
|
|
* Description This function is used to rejectlist the device if the role
|
|
* switch fails for maximum number of times. It also removes
|
|
* the device from the black list if the role switch succeeds.
|
|
*
|
|
* Input Parms bd_addr - remote BD addr
|
|
* hci_status - role switch status
|
|
*
|
|
* Returns void
|
|
*
|
|
*******************************************************************************/
|
|
void btm_rejectlist_role_change_device(const RawAddress& bd_addr,
|
|
uint8_t hci_status) {
|
|
tACL_CONN* p = internal_.btm_bda_to_acl(bd_addr, BT_TRANSPORT_BR_EDR);
|
|
|
|
if (!p) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
if (hci_status == HCI_SUCCESS) {
|
|
p->switch_role_failed_attempts = 0;
|
|
return;
|
|
}
|
|
|
|
/* check for carkits */
|
|
const uint32_t cod_audio_device =
|
|
(BTM_COD_SERVICE_AUDIO | BTM_COD_MAJOR_AUDIO) << 8;
|
|
const uint8_t* dev_class = btm_get_dev_class(bd_addr);
|
|
if (dev_class == nullptr) return;
|
|
const uint32_t cod =
|
|
((dev_class[0] << 16) | (dev_class[1] << 8) | dev_class[2]) & 0xffffff;
|
|
if ((hci_status != HCI_SUCCESS) &&
|
|
(p->is_switch_role_switching_or_in_progress()) &&
|
|
((cod & cod_audio_device) == cod_audio_device) &&
|
|
(!interop_match_addr(INTEROP_DYNAMIC_ROLE_SWITCH, &bd_addr))) {
|
|
p->switch_role_failed_attempts++;
|
|
if (p->switch_role_failed_attempts == BTM_MAX_SW_ROLE_FAILED_ATTEMPTS) {
|
|
LOG_WARN(
|
|
"Device %s rejectlisted for role switching - "
|
|
"multiple role switch failed attempts: %u",
|
|
bd_addr.ToString().c_str(), p->switch_role_failed_attempts);
|
|
interop_database_add(INTEROP_DYNAMIC_ROLE_SWITCH, &bd_addr, 3);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_acl_role_changed
|
|
*
|
|
* Description This function is called whan a link's central/peripheral
|
|
*role change event or command status event (with error) is received. It updates
|
|
*the link control block, and calls the registered callback with status and role
|
|
*(if registered).
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void StackAclBtmAcl::btm_acl_role_changed(tHCI_STATUS hci_status,
|
|
const RawAddress& bd_addr,
|
|
tHCI_ROLE new_role) {
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, BT_TRANSPORT_BR_EDR);
|
|
if (p_acl == nullptr) {
|
|
// If we get a role change before connection complete, we cache the new
|
|
// role here and then propagate it when ACL Link is created.
|
|
RoleChangeView role_change;
|
|
role_change.new_role = new_role;
|
|
role_change.bd_addr = bd_addr;
|
|
delayed_role_change_ =
|
|
std::make_unique<RoleChangeView>(std::move(role_change));
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
|
|
tBTM_ROLE_SWITCH_CMPL* p_switch_role = &btm_cb.acl_cb_.switch_role_ref_data;
|
|
LOG_DEBUG("Role change event received peer:%s hci_status:%s new_role:%s",
|
|
PRIVATE_ADDRESS(bd_addr), hci_error_code_text(hci_status).c_str(),
|
|
RoleText(new_role).c_str());
|
|
|
|
p_switch_role->hci_status = hci_status;
|
|
if (hci_status == HCI_SUCCESS) {
|
|
p_switch_role->role = new_role;
|
|
p_switch_role->remote_bd_addr = bd_addr;
|
|
|
|
/* Update cached value */
|
|
p_acl->link_role = new_role;
|
|
|
|
/* Reload LSTO: link supervision timeout is reset in the LM after a role
|
|
* switch */
|
|
if (new_role == HCI_ROLE_CENTRAL) {
|
|
constexpr uint16_t link_supervision_timeout = 8000;
|
|
BTM_SetLinkSuperTout(bd_addr, link_supervision_timeout);
|
|
}
|
|
} else {
|
|
new_role = p_acl->link_role;
|
|
}
|
|
|
|
/* Check if any SCO req is pending for role change */
|
|
btm_sco_chk_pend_rolechange(p_acl->hci_handle);
|
|
|
|
/* if switching state is switching we need to turn encryption on */
|
|
/* if idle, we did not change encryption */
|
|
if (p_acl->is_switch_role_switching()) {
|
|
p_acl->set_encryption_on();
|
|
p_acl->set_switch_role_encryption_on();
|
|
return;
|
|
}
|
|
|
|
/* Set the switch_role_state to IDLE since the reply received from HCI */
|
|
/* regardless of its result either success or failed. */
|
|
if (p_acl->is_switch_role_in_progress()) {
|
|
p_acl->set_encryption_idle();
|
|
p_acl->reset_switch_role();
|
|
}
|
|
|
|
BTA_dm_report_role_change(bd_addr, new_role, hci_status);
|
|
|
|
/* If a disconnect is pending, issue it now that role switch has completed */
|
|
if (p_acl->rs_disc_pending == BTM_SEC_DISC_PENDING) {
|
|
hci_btsnd_hcic_disconnect(*p_acl, HCI_ERR_PEER_USER);
|
|
}
|
|
p_acl->rs_disc_pending = BTM_SEC_RS_NOT_PENDING; /* reset flag */
|
|
}
|
|
|
|
void btm_acl_role_changed(tHCI_STATUS hci_status, const RawAddress& bd_addr,
|
|
tHCI_ROLE new_role) {
|
|
if (hci_status == HCI_SUCCESS) {
|
|
l2c_link_role_changed(&bd_addr, new_role, hci_status);
|
|
} else {
|
|
l2c_link_role_changed(nullptr, HCI_ROLE_UNKNOWN,
|
|
HCI_ERR_COMMAND_DISALLOWED);
|
|
}
|
|
internal_.btm_acl_role_changed(hci_status, bd_addr, new_role);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function change_connection_packet_types
|
|
*
|
|
* Description This function sets the packet types used for a specific
|
|
* ACL connection. It is called internally by btm_acl_created
|
|
* or by an application/profile by BTM_SetPacketTypes.
|
|
*
|
|
* Returns status of the operation
|
|
*
|
|
******************************************************************************/
|
|
bool StackAclBtmAcl::change_connection_packet_types(
|
|
tACL_CONN& link, const uint16_t new_packet_type_mask) {
|
|
// Start with the default configured packet types
|
|
const uint16_t default_packet_type_mask = btm_cb.acl_cb_.DefaultPacketTypes();
|
|
|
|
uint16_t packet_type_mask =
|
|
default_packet_type_mask &
|
|
(new_packet_type_mask & BTM_ACL_SUPPORTED_PKTS_MASK);
|
|
|
|
/* OR in any exception packet types if at least 2.0 version of spec */
|
|
packet_type_mask |=
|
|
((new_packet_type_mask & BTM_ACL_EXCEPTION_PKTS_MASK) |
|
|
(BTM_ACL_EXCEPTION_PKTS_MASK & default_packet_type_mask));
|
|
|
|
/* Exclude packet types not supported by the peer */
|
|
if (link.peer_lmp_feature_valid[0]) {
|
|
PeerPacketTypes peer_packet_types(link.peer_lmp_feature_pages[0]);
|
|
packet_type_mask &= peer_packet_types.acl.supported;
|
|
packet_type_mask |= peer_packet_types.acl.unsupported;
|
|
} else {
|
|
LOG_INFO(
|
|
"Unable to include remote supported packet types as read feature "
|
|
"incomplete");
|
|
LOG_INFO("TIP: Maybe wait until read feature complete beforehand");
|
|
}
|
|
|
|
if (packet_type_mask == 0) {
|
|
LOG_WARN("Unable to send controller illegal change packet mask:0x%04x",
|
|
packet_type_mask);
|
|
return false;
|
|
}
|
|
|
|
link.pkt_types_mask = packet_type_mask;
|
|
bluetooth::legacy::hci::GetInterface().ChangeConnectionPacketType(
|
|
link.Handle(), link.pkt_types_mask);
|
|
LOG_DEBUG("Started change connection packet type:0x%04x address:%s",
|
|
link.pkt_types_mask, PRIVATE_ADDRESS(link.RemoteAddress()));
|
|
return true;
|
|
}
|
|
|
|
void btm_set_packet_types_from_address(const RawAddress& bd_addr,
|
|
uint16_t pkt_types) {
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, BT_TRANSPORT_BR_EDR);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
|
|
if (!internal_.change_connection_packet_types(*p_acl, pkt_types)) {
|
|
LOG_ERROR("Unable to change connection packet type types:%04x address:%s",
|
|
pkt_types, PRIVATE_ADDRESS(bd_addr));
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_GetMaxPacketSize
|
|
*
|
|
* Returns Returns maximum packet size that can be used for current
|
|
* connection, 0 if connection is not established
|
|
*
|
|
******************************************************************************/
|
|
uint16_t BTM_GetMaxPacketSize(const RawAddress& addr) {
|
|
tACL_CONN* p = internal_.btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
|
|
uint16_t pkt_types = 0;
|
|
uint16_t pkt_size = 0;
|
|
if (p != NULL) {
|
|
pkt_types = p->pkt_types_mask;
|
|
} else {
|
|
/* Special case for when info for the local device is requested */
|
|
if (addr == *controller_get_interface()->get_address()) {
|
|
pkt_types = btm_cb.acl_cb_.DefaultPacketTypes();
|
|
}
|
|
}
|
|
|
|
if (pkt_types) {
|
|
if (!(pkt_types & HCI_PKT_TYPES_MASK_NO_3_DH5))
|
|
pkt_size = HCI_EDR3_DH5_PACKET_SIZE;
|
|
else if (!(pkt_types & HCI_PKT_TYPES_MASK_NO_2_DH5))
|
|
pkt_size = HCI_EDR2_DH5_PACKET_SIZE;
|
|
else if (!(pkt_types & HCI_PKT_TYPES_MASK_NO_3_DH3))
|
|
pkt_size = HCI_EDR3_DH3_PACKET_SIZE;
|
|
else if (pkt_types & HCI_PKT_TYPES_MASK_DH5)
|
|
pkt_size = HCI_DH5_PACKET_SIZE;
|
|
else if (!(pkt_types & HCI_PKT_TYPES_MASK_NO_2_DH3))
|
|
pkt_size = HCI_EDR2_DH3_PACKET_SIZE;
|
|
else if (pkt_types & HCI_PKT_TYPES_MASK_DM5)
|
|
pkt_size = HCI_DM5_PACKET_SIZE;
|
|
else if (pkt_types & HCI_PKT_TYPES_MASK_DH3)
|
|
pkt_size = HCI_DH3_PACKET_SIZE;
|
|
else if (pkt_types & HCI_PKT_TYPES_MASK_DM3)
|
|
pkt_size = HCI_DM3_PACKET_SIZE;
|
|
else if (!(pkt_types & HCI_PKT_TYPES_MASK_NO_3_DH1))
|
|
pkt_size = HCI_EDR3_DH1_PACKET_SIZE;
|
|
else if (!(pkt_types & HCI_PKT_TYPES_MASK_NO_2_DH1))
|
|
pkt_size = HCI_EDR2_DH1_PACKET_SIZE;
|
|
else if (pkt_types & HCI_PKT_TYPES_MASK_DH1)
|
|
pkt_size = HCI_DH1_PACKET_SIZE;
|
|
else if (pkt_types & HCI_PKT_TYPES_MASK_DM1)
|
|
pkt_size = HCI_DM1_PACKET_SIZE;
|
|
}
|
|
|
|
return (pkt_size);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_ReadRemoteVersion
|
|
*
|
|
* Returns If connected report peer device info
|
|
*
|
|
******************************************************************************/
|
|
bool BTM_ReadRemoteVersion(const RawAddress& addr, uint8_t* lmp_version,
|
|
uint16_t* manufacturer, uint16_t* lmp_sub_version) {
|
|
if (bluetooth::shim::is_gd_l2cap_enabled()) {
|
|
return bluetooth::shim::L2CA_ReadRemoteVersion(
|
|
addr, lmp_version, manufacturer, lmp_sub_version);
|
|
}
|
|
|
|
const tACL_CONN* p_acl = internal_.btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
|
|
if (p_acl == nullptr) {
|
|
p_acl = internal_.btm_bda_to_acl(addr, BT_TRANSPORT_LE);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!p_acl->remote_version_info.valid) {
|
|
LOG_WARN("Remote version information is invalid");
|
|
return false;
|
|
}
|
|
|
|
if (lmp_version) *lmp_version = p_acl->remote_version_info.lmp_version;
|
|
|
|
if (manufacturer) *manufacturer = p_acl->remote_version_info.manufacturer;
|
|
|
|
if (lmp_sub_version)
|
|
*lmp_sub_version = p_acl->remote_version_info.lmp_subversion;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_ReadRemoteFeatures
|
|
*
|
|
* Returns pointer to the remote supported features mask (8 bytes)
|
|
*
|
|
******************************************************************************/
|
|
uint8_t* BTM_ReadRemoteFeatures(const RawAddress& addr) {
|
|
if (bluetooth::shim::is_gd_l2cap_enabled()) {
|
|
return bluetooth::shim::L2CA_ReadRemoteFeatures(addr);
|
|
}
|
|
tACL_CONN* p = internal_.btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
|
|
if (p == NULL) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return (NULL);
|
|
}
|
|
|
|
return (p->peer_lmp_feature_pages[0]);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_ReadRSSI
|
|
*
|
|
* Description This function is called to read the link policy settings.
|
|
* The address of link policy results are returned in the
|
|
* callback.
|
|
* (tBTM_RSSI_RESULT)
|
|
*
|
|
* Returns BTM_CMD_STARTED if successfully initiated or error code
|
|
*
|
|
******************************************************************************/
|
|
tBTM_STATUS BTM_ReadRSSI(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb) {
|
|
tACL_CONN* p = NULL;
|
|
tBT_DEVICE_TYPE dev_type;
|
|
tBLE_ADDR_TYPE addr_type;
|
|
|
|
/* If someone already waiting on the version, do not allow another */
|
|
if (btm_cb.devcb.p_rssi_cmpl_cb) return (BTM_BUSY);
|
|
|
|
BTM_ReadDevInfo(remote_bda, &dev_type, &addr_type);
|
|
|
|
if (dev_type & BT_DEVICE_TYPE_BLE) {
|
|
p = internal_.btm_bda_to_acl(remote_bda, BT_TRANSPORT_LE);
|
|
}
|
|
|
|
if (p == NULL && dev_type & BT_DEVICE_TYPE_BREDR) {
|
|
p = internal_.btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
|
|
}
|
|
|
|
if (p) {
|
|
btm_cb.devcb.p_rssi_cmpl_cb = p_cb;
|
|
alarm_set_on_mloop(btm_cb.devcb.read_rssi_timer, BTM_DEV_REPLY_TIMEOUT_MS,
|
|
btm_read_rssi_timeout, NULL);
|
|
|
|
btsnd_hcic_read_rssi(p->hci_handle);
|
|
return (BTM_CMD_STARTED);
|
|
}
|
|
LOG_WARN("Unable to find active acl");
|
|
|
|
/* If here, no BD Addr found */
|
|
return (BTM_UNKNOWN_ADDR);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_ReadFailedContactCounter
|
|
*
|
|
* Description This function is called to read the failed contact counter.
|
|
* The result is returned in the callback.
|
|
* (tBTM_FAILED_CONTACT_COUNTER_RESULT)
|
|
*
|
|
* Returns BTM_CMD_STARTED if successfully initiated or error code
|
|
*
|
|
******************************************************************************/
|
|
tBTM_STATUS BTM_ReadFailedContactCounter(const RawAddress& remote_bda,
|
|
tBTM_CMPL_CB* p_cb) {
|
|
tACL_CONN* p;
|
|
tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR;
|
|
tBT_DEVICE_TYPE dev_type;
|
|
tBLE_ADDR_TYPE addr_type;
|
|
|
|
/* If someone already waiting on the result, do not allow another */
|
|
if (btm_cb.devcb.p_failed_contact_counter_cmpl_cb) return (BTM_BUSY);
|
|
|
|
BTM_ReadDevInfo(remote_bda, &dev_type, &addr_type);
|
|
if (dev_type == BT_DEVICE_TYPE_BLE) transport = BT_TRANSPORT_LE;
|
|
|
|
p = internal_.btm_bda_to_acl(remote_bda, transport);
|
|
if (p != (tACL_CONN*)NULL) {
|
|
btm_cb.devcb.p_failed_contact_counter_cmpl_cb = p_cb;
|
|
alarm_set_on_mloop(btm_cb.devcb.read_failed_contact_counter_timer,
|
|
BTM_DEV_REPLY_TIMEOUT_MS,
|
|
btm_read_failed_contact_counter_timeout, NULL);
|
|
|
|
btsnd_hcic_read_failed_contact_counter(p->hci_handle);
|
|
return (BTM_CMD_STARTED);
|
|
}
|
|
LOG_WARN("Unable to find active acl");
|
|
|
|
/* If here, no BD Addr found */
|
|
return (BTM_UNKNOWN_ADDR);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_ReadTxPower
|
|
*
|
|
* Description This function is called to read the current
|
|
* TX power of the connection. The tx power level results
|
|
* are returned in the callback.
|
|
* (tBTM_RSSI_RESULT)
|
|
*
|
|
* Returns BTM_CMD_STARTED if successfully initiated or error code
|
|
*
|
|
******************************************************************************/
|
|
tBTM_STATUS BTM_ReadTxPower(const RawAddress& remote_bda,
|
|
tBT_TRANSPORT transport, tBTM_CMPL_CB* p_cb) {
|
|
tACL_CONN* p;
|
|
#define BTM_READ_RSSI_TYPE_CUR 0x00
|
|
#define BTM_READ_RSSI_TYPE_MAX 0X01
|
|
|
|
VLOG(2) << __func__ << ": RemBdAddr: " << remote_bda;
|
|
|
|
/* If someone already waiting on the version, do not allow another */
|
|
if (btm_cb.devcb.p_tx_power_cmpl_cb) return (BTM_BUSY);
|
|
|
|
p = internal_.btm_bda_to_acl(remote_bda, transport);
|
|
if (p != (tACL_CONN*)NULL) {
|
|
btm_cb.devcb.p_tx_power_cmpl_cb = p_cb;
|
|
alarm_set_on_mloop(btm_cb.devcb.read_tx_power_timer,
|
|
BTM_DEV_REPLY_TIMEOUT_MS, btm_read_tx_power_timeout,
|
|
NULL);
|
|
|
|
if (p->transport == BT_TRANSPORT_LE) {
|
|
btm_cb.devcb.read_tx_pwr_addr = remote_bda;
|
|
btsnd_hcic_ble_read_adv_chnl_tx_power();
|
|
} else {
|
|
btsnd_hcic_read_tx_power(p->hci_handle, BTM_READ_RSSI_TYPE_CUR);
|
|
}
|
|
|
|
return (BTM_CMD_STARTED);
|
|
}
|
|
|
|
LOG_WARN("Unable to find active acl");
|
|
|
|
/* If here, no BD Addr found */
|
|
return (BTM_UNKNOWN_ADDR);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_tx_power_timeout
|
|
*
|
|
* Description Callback when reading the tx power times out.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_read_tx_power_timeout(UNUSED_ATTR void* data) {
|
|
tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_tx_power_cmpl_cb;
|
|
btm_cb.devcb.p_tx_power_cmpl_cb = NULL;
|
|
if (p_cb) (*p_cb)((void*)NULL);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_tx_power_complete
|
|
*
|
|
* Description This function is called when the command complete message
|
|
* is received from the HCI for the read tx power request.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_read_tx_power_complete(uint8_t* p, bool is_ble) {
|
|
tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_tx_power_cmpl_cb;
|
|
tBTM_TX_POWER_RESULT result;
|
|
|
|
alarm_cancel(btm_cb.devcb.read_tx_power_timer);
|
|
btm_cb.devcb.p_tx_power_cmpl_cb = NULL;
|
|
|
|
/* If there was a registered callback, call it */
|
|
if (p_cb) {
|
|
STREAM_TO_UINT8(result.hci_status, p);
|
|
|
|
if (result.hci_status == HCI_SUCCESS) {
|
|
result.status = BTM_SUCCESS;
|
|
|
|
if (!is_ble) {
|
|
uint16_t handle;
|
|
STREAM_TO_UINT16(handle, p);
|
|
STREAM_TO_UINT8(result.tx_power, p);
|
|
|
|
tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl_cb != nullptr) {
|
|
result.rem_bda = p_acl_cb->remote_addr;
|
|
}
|
|
} else {
|
|
STREAM_TO_UINT8(result.tx_power, p);
|
|
result.rem_bda = btm_cb.devcb.read_tx_pwr_addr;
|
|
}
|
|
LOG_DEBUG("Transmit power complete: tx_power:%d hci status:%s",
|
|
result.tx_power,
|
|
hci_error_code_text(static_cast<tHCI_STATUS>(result.hci_status))
|
|
.c_str());
|
|
} else {
|
|
result.status = BTM_ERR_PROCESSING;
|
|
}
|
|
|
|
(*p_cb)(&result);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_rssi_timeout
|
|
*
|
|
* Description Callback when reading the RSSI times out.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_read_rssi_timeout(UNUSED_ATTR void* data) {
|
|
tBTM_RSSI_RESULT result;
|
|
tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_rssi_cmpl_cb;
|
|
btm_cb.devcb.p_rssi_cmpl_cb = NULL;
|
|
result.status = BTM_DEVICE_TIMEOUT;
|
|
if (p_cb) (*p_cb)(&result);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_rssi_complete
|
|
*
|
|
* Description This function is called when the command complete message
|
|
* is received from the HCI for the read rssi request.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_read_rssi_complete(uint8_t* p) {
|
|
tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_rssi_cmpl_cb;
|
|
tBTM_RSSI_RESULT result;
|
|
|
|
alarm_cancel(btm_cb.devcb.read_rssi_timer);
|
|
btm_cb.devcb.p_rssi_cmpl_cb = NULL;
|
|
|
|
/* If there was a registered callback, call it */
|
|
if (p_cb) {
|
|
STREAM_TO_UINT8(result.hci_status, p);
|
|
result.status = BTM_ERR_PROCESSING;
|
|
|
|
if (result.hci_status == HCI_SUCCESS) {
|
|
uint16_t handle;
|
|
STREAM_TO_UINT16(handle, p);
|
|
|
|
STREAM_TO_UINT8(result.rssi, p);
|
|
LOG_DEBUG("Read rrsi complete rssi:%hhd hci status:%s", result.rssi,
|
|
hci_error_code_text(static_cast<tHCI_STATUS>(result.hci_status))
|
|
.c_str());
|
|
|
|
tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl_cb != nullptr) {
|
|
result.rem_bda = p_acl_cb->remote_addr;
|
|
result.status = BTM_SUCCESS;
|
|
}
|
|
}
|
|
(*p_cb)(&result);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_failed_contact_counter_timeout
|
|
*
|
|
* Description Callback when reading the failed contact counter times out.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_read_failed_contact_counter_timeout(UNUSED_ATTR void* data) {
|
|
tBTM_FAILED_CONTACT_COUNTER_RESULT result;
|
|
tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_failed_contact_counter_cmpl_cb;
|
|
btm_cb.devcb.p_failed_contact_counter_cmpl_cb = NULL;
|
|
result.status = BTM_DEVICE_TIMEOUT;
|
|
if (p_cb) (*p_cb)(&result);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_failed_contact_counter_complete
|
|
*
|
|
* Description This function is called when the command complete message
|
|
* is received from the HCI for the read failed contact
|
|
* counter request.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_read_failed_contact_counter_complete(uint8_t* p) {
|
|
tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_failed_contact_counter_cmpl_cb;
|
|
tBTM_FAILED_CONTACT_COUNTER_RESULT result;
|
|
|
|
alarm_cancel(btm_cb.devcb.read_failed_contact_counter_timer);
|
|
btm_cb.devcb.p_failed_contact_counter_cmpl_cb = NULL;
|
|
|
|
/* If there was a registered callback, call it */
|
|
if (p_cb) {
|
|
uint16_t handle;
|
|
STREAM_TO_UINT8(result.hci_status, p);
|
|
|
|
if (result.hci_status == HCI_SUCCESS) {
|
|
result.status = BTM_SUCCESS;
|
|
|
|
STREAM_TO_UINT16(handle, p);
|
|
|
|
STREAM_TO_UINT16(result.failed_contact_counter, p);
|
|
LOG_DEBUG(
|
|
"Failed contact counter complete: counter %u, hci status:%s",
|
|
result.failed_contact_counter,
|
|
hci_status_code_text(to_hci_status_code(result.hci_status)).c_str());
|
|
|
|
tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl_cb != nullptr) {
|
|
result.rem_bda = p_acl_cb->remote_addr;
|
|
}
|
|
} else {
|
|
result.status = BTM_ERR_PROCESSING;
|
|
}
|
|
|
|
(*p_cb)(&result);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_automatic_flush_timeout_complete
|
|
*
|
|
* Description This function is called when the command complete message
|
|
* is received from the HCI for the read automatic flush
|
|
* timeout request.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_read_automatic_flush_timeout_complete(uint8_t* p) {
|
|
tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_automatic_flush_timeout_cmpl_cb;
|
|
tBTM_AUTOMATIC_FLUSH_TIMEOUT_RESULT result;
|
|
|
|
alarm_cancel(btm_cb.devcb.read_automatic_flush_timeout_timer);
|
|
btm_cb.devcb.p_automatic_flush_timeout_cmpl_cb = nullptr;
|
|
|
|
/* If there was a registered callback, call it */
|
|
if (p_cb) {
|
|
uint16_t handle;
|
|
STREAM_TO_UINT8(result.hci_status, p);
|
|
result.status = BTM_ERR_PROCESSING;
|
|
|
|
if (result.hci_status == HCI_SUCCESS) {
|
|
result.status = BTM_SUCCESS;
|
|
|
|
STREAM_TO_UINT16(handle, p);
|
|
STREAM_TO_UINT16(result.automatic_flush_timeout, p);
|
|
LOG_DEBUG(
|
|
"Read automatic flush timeout complete timeout:%hu hci_status:%s",
|
|
result.automatic_flush_timeout,
|
|
hci_error_code_text(static_cast<tHCI_STATUS>(result.hci_status))
|
|
.c_str());
|
|
|
|
tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl_cb != nullptr) {
|
|
result.rem_bda = p_acl_cb->remote_addr;
|
|
}
|
|
}
|
|
(*p_cb)(&result);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_link_quality_timeout
|
|
*
|
|
* Description Callback when reading the link quality times out.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_read_link_quality_timeout(UNUSED_ATTR void* data) {
|
|
tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_link_qual_cmpl_cb;
|
|
btm_cb.devcb.p_link_qual_cmpl_cb = NULL;
|
|
if (p_cb) (*p_cb)((void*)NULL);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_read_link_quality_complete
|
|
*
|
|
* Description This function is called when the command complete message
|
|
* is received from the HCI for the read link quality.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void btm_read_link_quality_complete(uint8_t* p) {
|
|
tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_link_qual_cmpl_cb;
|
|
tBTM_LINK_QUALITY_RESULT result;
|
|
|
|
alarm_cancel(btm_cb.devcb.read_link_quality_timer);
|
|
btm_cb.devcb.p_link_qual_cmpl_cb = NULL;
|
|
|
|
/* If there was a registered callback, call it */
|
|
if (p_cb) {
|
|
STREAM_TO_UINT8(result.hci_status, p);
|
|
|
|
if (result.hci_status == HCI_SUCCESS) {
|
|
uint16_t handle;
|
|
result.status = BTM_SUCCESS;
|
|
|
|
STREAM_TO_UINT16(handle, p);
|
|
|
|
STREAM_TO_UINT8(result.link_quality, p);
|
|
LOG_DEBUG("BTM Link Quality Complete: Link Quality %d, hci status:%s",
|
|
result.link_quality,
|
|
hci_error_code_text(static_cast<tHCI_STATUS>(result.hci_status))
|
|
.c_str());
|
|
|
|
tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl_cb != nullptr) {
|
|
result.rem_bda = p_acl_cb->remote_addr;
|
|
}
|
|
} else {
|
|
result.status = BTM_ERR_PROCESSING;
|
|
}
|
|
|
|
(*p_cb)(&result);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_remove_acl
|
|
*
|
|
* Description This function is called to disconnect an ACL connection
|
|
*
|
|
* Returns BTM_SUCCESS if successfully initiated, otherwise
|
|
* BTM_NO_RESOURCES.
|
|
*
|
|
******************************************************************************/
|
|
tBTM_STATUS btm_remove_acl(const RawAddress& bd_addr, tBT_TRANSPORT transport) {
|
|
if (bluetooth::shim::is_gd_l2cap_enabled()) {
|
|
if (transport == BT_TRANSPORT_LE) {
|
|
LOG(ERROR) << __func__ << ": Unsupported";
|
|
}
|
|
bluetooth::shim::L2CA_DisconnectLink(bd_addr);
|
|
return BTM_SUCCESS;
|
|
}
|
|
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, transport);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return BTM_UNKNOWN_ADDR;
|
|
}
|
|
|
|
if (p_acl->Handle() == HCI_INVALID_HANDLE) {
|
|
LOG_WARN("Cannot remove unknown acl bd_addr:%s transport:%s",
|
|
PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str());
|
|
return BTM_UNKNOWN_ADDR;
|
|
}
|
|
|
|
if (p_acl->rs_disc_pending == BTM_SEC_RS_PENDING) {
|
|
LOG_DEBUG(
|
|
"Delay disconnect until role switch is complete bd_addr:%s "
|
|
"transport:%s",
|
|
PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str());
|
|
p_acl->rs_disc_pending = BTM_SEC_DISC_PENDING;
|
|
return BTM_SUCCESS;
|
|
}
|
|
|
|
hci_btsnd_hcic_disconnect(*p_acl, HCI_ERR_PEER_USER);
|
|
return BTM_SUCCESS;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_SetTraceLevel
|
|
*
|
|
* Description This function sets the trace level for BTM. If called with
|
|
* a value of 0xFF, it simply returns the current trace level.
|
|
*
|
|
* Returns The new or current trace level
|
|
*
|
|
******************************************************************************/
|
|
uint8_t BTM_SetTraceLevel(uint8_t new_level) {
|
|
if (new_level != 0xFF) btm_cb.trace_level = new_level;
|
|
|
|
return (btm_cb.trace_level);
|
|
}
|
|
|
|
void btm_cont_rswitch_from_handle(uint16_t hci_handle) {
|
|
tACL_CONN* p = internal_.acl_get_connection_from_handle(hci_handle);
|
|
if (p == nullptr) {
|
|
LOG_WARN("Role switch received but with no active ACL");
|
|
return;
|
|
}
|
|
|
|
/* Check to see if encryption needs to be turned off if pending
|
|
change of link key or role switch */
|
|
if (p->is_switch_role_mode_change()) {
|
|
/* Must turn off Encryption first if necessary */
|
|
/* Some devices do not support switch or change of link key while encryption
|
|
* is on */
|
|
if (p->is_encrypted && !IsEprAvailable(*p)) {
|
|
p->set_encryption_off();
|
|
if (p->is_switch_role_mode_change()) {
|
|
p->set_switch_role_encryption_off();
|
|
}
|
|
} else /* Encryption not used or EPR supported, continue with switch
|
|
and/or change of link key */
|
|
{
|
|
if (p->is_switch_role_mode_change()) {
|
|
internal_.hci_start_role_switch_to_central(*p);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_acl_resubmit_page
|
|
*
|
|
* Description send pending page request
|
|
*
|
|
******************************************************************************/
|
|
void btm_acl_resubmit_page(void) {
|
|
BT_HDR* p_buf;
|
|
uint8_t* pp;
|
|
/* If there were other page request schedule can start the next one */
|
|
p_buf = (BT_HDR*)fixed_queue_try_dequeue(btm_cb.page_queue);
|
|
if (p_buf != NULL) {
|
|
/* skip 3 (2 bytes opcode and 1 byte len) to get to the bd_addr
|
|
* for both create_conn and rmt_name */
|
|
pp = (uint8_t*)(p_buf + 1) + p_buf->offset + 3;
|
|
|
|
RawAddress bda;
|
|
STREAM_TO_BDADDR(bda, pp);
|
|
|
|
btm_cb.connecting_bda = bda;
|
|
memcpy(btm_cb.connecting_dc, btm_get_dev_class(bda), DEV_CLASS_LEN);
|
|
|
|
btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p_buf);
|
|
} else {
|
|
btm_cb.paging = false;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_acl_reset_paging
|
|
*
|
|
* Description set paging to false and free the page queue - called at
|
|
* hci_reset
|
|
*
|
|
******************************************************************************/
|
|
void btm_acl_reset_paging(void) {
|
|
BT_HDR* p;
|
|
/* If we sent reset we are definitely not paging any more */
|
|
while ((p = (BT_HDR*)fixed_queue_try_dequeue(btm_cb.page_queue)) != NULL)
|
|
osi_free(p);
|
|
|
|
btm_cb.paging = false;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_acl_paging
|
|
*
|
|
* Description send a paging command or queue it in btm_cb
|
|
*
|
|
******************************************************************************/
|
|
void btm_acl_paging(BT_HDR* p, const RawAddress& bda) {
|
|
// This function is called by the device initiating the connection.
|
|
// If no role change is requested from the remote device, we want
|
|
// to classify the connection initiator as the central device.
|
|
if (delayed_role_change_ == nullptr) {
|
|
RoleChangeView role_change;
|
|
role_change.bd_addr = bda;
|
|
role_change.new_role = HCI_ROLE_CENTRAL;
|
|
delayed_role_change_ =
|
|
std::make_unique<RoleChangeView>(std::move(role_change));
|
|
}
|
|
if (!BTM_IsAclConnectionUp(bda, BT_TRANSPORT_BR_EDR)) {
|
|
VLOG(1) << "connecting_bda: " << btm_cb.connecting_bda;
|
|
if (btm_cb.paging && bda == btm_cb.connecting_bda) {
|
|
fixed_queue_enqueue(btm_cb.page_queue, p);
|
|
} else {
|
|
btm_cb.connecting_bda = bda;
|
|
memcpy(btm_cb.connecting_dc, btm_get_dev_class(bda), DEV_CLASS_LEN);
|
|
|
|
btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);
|
|
}
|
|
|
|
btm_cb.paging = true;
|
|
} else /* ACL is already up */
|
|
{
|
|
btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_acl_notif_conn_collision
|
|
*
|
|
* Description Send connection collision event to upper layer if registered
|
|
*
|
|
*
|
|
******************************************************************************/
|
|
void btm_acl_notif_conn_collision(const RawAddress& bda) {
|
|
do_in_main_thread(FROM_HERE, base::Bind(bta_sys_notify_collision, bda));
|
|
}
|
|
|
|
bool BTM_BLE_IS_RESOLVE_BDA(const RawAddress& x) {
|
|
return ((x.address)[0] & BLE_RESOLVE_ADDR_MASK) == BLE_RESOLVE_ADDR_MSB;
|
|
}
|
|
|
|
bool acl_refresh_remote_address(const RawAddress& identity_address,
|
|
tBLE_ADDR_TYPE identity_address_type,
|
|
const RawAddress& bda, tBLE_ADDR_TYPE rra_type,
|
|
const RawAddress& rpa) {
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(bda, BT_TRANSPORT_LE);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return false;
|
|
}
|
|
|
|
if (rra_type == tBTM_SEC_BLE::BTM_BLE_ADDR_PSEUDO) {
|
|
/* use identity address, resolvable_private_addr is empty */
|
|
if (rpa.IsEmpty()) {
|
|
p_acl->active_remote_addr_type = identity_address_type;
|
|
p_acl->active_remote_addr = identity_address;
|
|
} else {
|
|
p_acl->active_remote_addr_type = BLE_ADDR_RANDOM;
|
|
p_acl->active_remote_addr = rpa;
|
|
}
|
|
} else {
|
|
p_acl->active_remote_addr_type = rra_type;
|
|
p_acl->active_remote_addr = rpa;
|
|
}
|
|
|
|
LOG_DEBUG("active_remote_addr_type: %d ", p_acl->active_remote_addr_type);
|
|
return true;
|
|
}
|
|
|
|
bool acl_peer_supports_ble_connection_parameters_request(
|
|
const RawAddress& remote_bda) {
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(remote_bda, BT_TRANSPORT_LE);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return false;
|
|
}
|
|
if (!p_acl->peer_le_features_valid) {
|
|
LOG_WARN(
|
|
"Checking remote features but remote feature read is "
|
|
"incomplete");
|
|
}
|
|
return HCI_LE_CONN_PARAM_REQ_SUPPORTED(p_acl->peer_le_features);
|
|
}
|
|
|
|
bool acl_peer_supports_sniff_subrating(const RawAddress& remote_bda) {
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return false;
|
|
}
|
|
if (!p_acl->peer_lmp_feature_valid[0]) {
|
|
LOG_WARN(
|
|
"Checking remote features but remote feature read is "
|
|
"incomplete");
|
|
}
|
|
return HCI_SNIFF_SUB_RATE_SUPPORTED(p_acl->peer_lmp_feature_pages[0]);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_ReadConnectionAddr
|
|
*
|
|
* Description This function is called to get the local device address
|
|
* information.
|
|
*
|
|
* Returns void
|
|
*
|
|
******************************************************************************/
|
|
void BTM_ReadConnectionAddr(const RawAddress& remote_bda,
|
|
RawAddress& local_conn_addr,
|
|
tBLE_ADDR_TYPE* p_addr_type) {
|
|
if (bluetooth::shim::is_gd_shim_enabled()) {
|
|
return bluetooth::shim::BTM_ReadConnectionAddr(remote_bda, local_conn_addr,
|
|
p_addr_type);
|
|
}
|
|
|
|
if (bluetooth::shim::is_gd_l2cap_enabled()) {
|
|
bluetooth::shim::L2CA_ReadConnectionAddr(remote_bda, local_conn_addr,
|
|
p_addr_type);
|
|
return;
|
|
} else if (bluetooth::shim::is_gd_scanning_enabled()) {
|
|
bluetooth::shim::ACL_ReadConnectionAddress(remote_bda, local_conn_addr,
|
|
p_addr_type);
|
|
return;
|
|
}
|
|
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(remote_bda, BT_TRANSPORT_LE);
|
|
|
|
if (p_acl == NULL) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
local_conn_addr = p_acl->conn_addr;
|
|
*p_addr_type = p_acl->conn_addr_type;
|
|
|
|
LOG_DEBUG("BTM_ReadConnectionAddr address type: %d addr: 0x%02x",
|
|
p_acl->conn_addr_type, p_acl->conn_addr.address[0]);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_IsBleConnection
|
|
*
|
|
* Description This function is called to check if the connection handle
|
|
* for an LE link
|
|
*
|
|
* Returns true if connection is LE link, otherwise false.
|
|
*
|
|
******************************************************************************/
|
|
bool BTM_IsBleConnection(uint16_t hci_handle) {
|
|
if (bluetooth::shim::is_gd_shim_enabled()) {
|
|
ASSERT_LOG(false, "This should not be invoked from code path");
|
|
}
|
|
|
|
if (bluetooth::shim::is_gd_l2cap_enabled()) {
|
|
return bluetooth::shim::L2CA_IsLeLink(hci_handle);
|
|
}
|
|
|
|
const tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(hci_handle);
|
|
if (p_acl == nullptr) return false;
|
|
return p_acl->is_transport_ble();
|
|
}
|
|
|
|
const RawAddress acl_address_from_handle(uint16_t handle) {
|
|
tACL_CONN* p_acl = acl_get_connection_from_handle(handle);
|
|
if (p_acl == nullptr) {
|
|
return RawAddress::kEmpty;
|
|
}
|
|
return p_acl->remote_addr;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function btm_ble_refresh_local_resolvable_private_addr
|
|
*
|
|
* Description This function refresh the currently used resolvable private
|
|
* address for the active link to the remote device
|
|
*
|
|
******************************************************************************/
|
|
void btm_ble_refresh_local_resolvable_private_addr(
|
|
const RawAddress& pseudo_addr, const RawAddress& local_rpa) {
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(pseudo_addr, BT_TRANSPORT_LE);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
|
|
if (btm_cb.ble_ctr_cb.privacy_mode == BTM_PRIVACY_NONE) {
|
|
p_acl->conn_addr_type = BLE_ADDR_PUBLIC;
|
|
p_acl->conn_addr = *controller_get_interface()->get_address();
|
|
} else {
|
|
p_acl->conn_addr_type = BLE_ADDR_RANDOM;
|
|
if (local_rpa.IsEmpty()) {
|
|
p_acl->conn_addr = btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr;
|
|
} else {
|
|
p_acl->conn_addr = local_rpa;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool sco_peer_supports_esco_2m_phy(const RawAddress& remote_bda) {
|
|
uint8_t* features = BTM_ReadRemoteFeatures(remote_bda);
|
|
if (features == nullptr) {
|
|
LOG_WARN(
|
|
"Checking remote features but remote feature read is "
|
|
"incomplete");
|
|
return false;
|
|
}
|
|
return HCI_EDR_ESCO_2MPS_SUPPORTED(features);
|
|
}
|
|
|
|
bool sco_peer_supports_esco_3m_phy(const RawAddress& remote_bda) {
|
|
uint8_t* features = BTM_ReadRemoteFeatures(remote_bda);
|
|
if (features == nullptr) {
|
|
LOG_WARN(
|
|
"Checking remote features but remote feature read is "
|
|
"incomplete");
|
|
return false;
|
|
}
|
|
return HCI_EDR_ESCO_3MPS_SUPPORTED(features);
|
|
}
|
|
|
|
bool acl_is_switch_role_idle(const RawAddress& bd_addr,
|
|
tBT_TRANSPORT transport) {
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, transport);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return false;
|
|
}
|
|
return p_acl->is_switch_role_idle();
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Function BTM_ReadRemoteConnectionAddr
|
|
*
|
|
* Description This function is read the remote device address currently used
|
|
*
|
|
* Parameters pseudo_addr: pseudo random address available
|
|
* conn_addr:connection address used
|
|
* p_addr_type : BD Address type, Public or Random of the address
|
|
* used
|
|
*
|
|
* Returns bool, true if connection to remote device exists, else false
|
|
*
|
|
******************************************************************************/
|
|
bool BTM_ReadRemoteConnectionAddr(const RawAddress& pseudo_addr,
|
|
RawAddress& conn_addr,
|
|
tBLE_ADDR_TYPE* p_addr_type) {
|
|
if (bluetooth::shim::is_gd_shim_enabled()) {
|
|
return bluetooth::shim::BTM_ReadRemoteConnectionAddr(pseudo_addr, conn_addr,
|
|
p_addr_type);
|
|
}
|
|
|
|
if (bluetooth::shim::is_gd_l2cap_enabled()) {
|
|
return bluetooth::shim::L2CA_ReadRemoteConnectionAddr(
|
|
pseudo_addr, conn_addr, p_addr_type);
|
|
}
|
|
|
|
bool st = true;
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(pseudo_addr, BT_TRANSPORT_LE);
|
|
|
|
if (p_acl == NULL) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return false;
|
|
}
|
|
|
|
conn_addr = p_acl->active_remote_addr;
|
|
*p_addr_type = p_acl->active_remote_addr_type;
|
|
return st;
|
|
}
|
|
|
|
uint8_t acl_link_role_from_handle(uint16_t handle) {
|
|
tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl == nullptr) {
|
|
return HCI_ROLE_UNKNOWN;
|
|
}
|
|
return p_acl->link_role;
|
|
}
|
|
|
|
bool acl_peer_supports_ble_packet_extension(uint16_t hci_handle) {
|
|
tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(hci_handle);
|
|
if (p_acl == nullptr) {
|
|
return false;
|
|
}
|
|
if (!p_acl->peer_le_features_valid) {
|
|
LOG_WARN(
|
|
"Checking remote features but remote feature read is "
|
|
"incomplete");
|
|
}
|
|
return HCI_LE_DATA_LEN_EXT_SUPPORTED(p_acl->peer_le_features);
|
|
}
|
|
|
|
bool acl_peer_supports_ble_2m_phy(uint16_t hci_handle) {
|
|
tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(hci_handle);
|
|
if (p_acl == nullptr) {
|
|
return false;
|
|
}
|
|
if (!p_acl->peer_le_features_valid) {
|
|
LOG_WARN(
|
|
"Checking remote features but remote feature read is "
|
|
"incomplete");
|
|
}
|
|
return HCI_LE_2M_PHY_SUPPORTED(p_acl->peer_le_features);
|
|
}
|
|
|
|
bool acl_peer_supports_ble_coded_phy(uint16_t hci_handle) {
|
|
tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(hci_handle);
|
|
if (p_acl == nullptr) {
|
|
return false;
|
|
}
|
|
if (!p_acl->peer_le_features_valid) {
|
|
LOG_WARN(
|
|
"Checking remote features but remote feature read is "
|
|
"incomplete");
|
|
return false;
|
|
}
|
|
return HCI_LE_CODED_PHY_SUPPORTED(p_acl->peer_le_features);
|
|
}
|
|
|
|
void acl_set_disconnect_reason(tHCI_STATUS acl_disc_reason) {
|
|
btm_cb.acl_cb_.set_disconnect_reason(acl_disc_reason);
|
|
}
|
|
|
|
bool acl_is_role_switch_allowed() {
|
|
return btm_cb.acl_cb_.DefaultLinkPolicy() &
|
|
HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH;
|
|
}
|
|
|
|
uint16_t acl_get_supported_packet_types() {
|
|
return btm_cb.acl_cb_.DefaultPacketTypes();
|
|
}
|
|
|
|
bool acl_set_peer_le_features_from_handle(uint16_t hci_handle,
|
|
const uint8_t* p) {
|
|
tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(hci_handle);
|
|
if (p_acl == nullptr) {
|
|
return false;
|
|
}
|
|
STREAM_TO_ARRAY(p_acl->peer_le_features, p, BD_FEATURES_LEN);
|
|
p_acl->peer_le_features_valid = true;
|
|
LOG_DEBUG("Completed le feature read request");
|
|
return true;
|
|
}
|
|
|
|
void on_acl_br_edr_connected(const RawAddress& bda, uint16_t handle,
|
|
uint8_t enc_mode) {
|
|
if (delayed_role_change_ != nullptr && delayed_role_change_->bd_addr == bda) {
|
|
btm_sec_connected(bda, handle, HCI_SUCCESS, enc_mode,
|
|
delayed_role_change_->new_role);
|
|
} else {
|
|
btm_sec_connected(bda, handle, HCI_SUCCESS, enc_mode);
|
|
}
|
|
delayed_role_change_ = nullptr;
|
|
btm_acl_set_paging(false);
|
|
l2c_link_hci_conn_comp(HCI_SUCCESS, handle, bda);
|
|
constexpr uint16_t link_supervision_timeout = 8000;
|
|
BTM_SetLinkSuperTout(bda, link_supervision_timeout);
|
|
|
|
tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* The legacy code path informs the upper layer via the BTA
|
|
* layer after all relevant read_remote_ commands are complete.
|
|
* The GD code path has ownership of the read_remote_ commands
|
|
* and thus may inform the upper layers about the connection.
|
|
*/
|
|
if (bluetooth::shim::is_gd_acl_enabled()) {
|
|
NotifyAclLinkUp(*p_acl);
|
|
}
|
|
}
|
|
|
|
void on_acl_br_edr_failed(const RawAddress& bda, tHCI_STATUS status) {
|
|
ASSERT_LOG(status != HCI_SUCCESS,
|
|
"Successful connection entering failing code path");
|
|
if (delayed_role_change_ != nullptr && delayed_role_change_->bd_addr == bda) {
|
|
btm_sec_connected(bda, HCI_INVALID_HANDLE, status, false,
|
|
delayed_role_change_->new_role);
|
|
} else {
|
|
btm_sec_connected(bda, HCI_INVALID_HANDLE, status, false);
|
|
}
|
|
delayed_role_change_ = nullptr;
|
|
btm_acl_set_paging(false);
|
|
l2c_link_hci_conn_comp(status, HCI_INVALID_HANDLE, bda);
|
|
}
|
|
|
|
void btm_acl_connected(const RawAddress& bda, uint16_t handle,
|
|
tHCI_STATUS status, uint8_t enc_mode) {
|
|
switch (status) {
|
|
case HCI_SUCCESS:
|
|
return on_acl_br_edr_connected(bda, handle, enc_mode);
|
|
default:
|
|
return on_acl_br_edr_failed(bda, status);
|
|
}
|
|
}
|
|
|
|
void btm_acl_disconnected(tHCI_STATUS status, uint16_t handle,
|
|
tHCI_REASON reason) {
|
|
if (status != HCI_SUCCESS) {
|
|
LOG_WARN("Received disconnect with error:%s",
|
|
hci_error_code_text(status).c_str());
|
|
}
|
|
|
|
/* There can be a case when we rejected PIN code authentication */
|
|
/* otherwise save a new reason */
|
|
if (btm_get_acl_disc_reason_code() != HCI_ERR_HOST_REJECT_SECURITY) {
|
|
acl_set_disconnect_reason(static_cast<tHCI_STATUS>(reason));
|
|
}
|
|
|
|
/* If L2CAP or SCO doesn't know about it, send it to ISO */
|
|
if (!l2c_link_hci_disc_comp(handle, reason) &&
|
|
!btm_sco_removed(handle, reason)) {
|
|
bluetooth::hci::IsoManager::GetInstance()->HandleDisconnect(handle, reason);
|
|
}
|
|
|
|
/* Notify security manager */
|
|
btm_sec_disconnected(handle, reason);
|
|
}
|
|
|
|
constexpr uint16_t kDefaultPacketTypes =
|
|
HCI_PKT_TYPES_MASK_DM1 | HCI_PKT_TYPES_MASK_DH1 | HCI_PKT_TYPES_MASK_DM3 |
|
|
HCI_PKT_TYPES_MASK_DH3 | HCI_PKT_TYPES_MASK_DM5 | HCI_PKT_TYPES_MASK_DH5;
|
|
|
|
void acl_create_classic_connection(const RawAddress& bd_addr,
|
|
bool there_are_high_priority_channels,
|
|
bool is_bonding) {
|
|
if (bluetooth::shim::is_gd_acl_enabled()) {
|
|
return bluetooth::shim::ACL_CreateClassicConnection(bd_addr);
|
|
}
|
|
|
|
const bool controller_supports_role_switch =
|
|
controller_get_interface()->supports_role_switch();
|
|
const bool acl_allows_role_switch = acl_is_role_switch_allowed();
|
|
|
|
/* FW team says that we can participant in 4 piconets
|
|
* typically 3 piconet + 1 for scanning.
|
|
* We can enhance the code to count the number of piconets later. */
|
|
uint8_t allow_role_switch = HCI_CR_CONN_NOT_ALLOW_SWITCH;
|
|
if (((acl_allows_role_switch && (BTM_GetNumAclLinks() < 3)) ||
|
|
(is_bonding && !there_are_high_priority_channels &&
|
|
controller_supports_role_switch)))
|
|
allow_role_switch = HCI_CR_CONN_ALLOW_SWITCH;
|
|
|
|
/* Check with the BT manager if details about remote device are known */
|
|
uint8_t page_scan_rep_mode{HCI_PAGE_SCAN_REP_MODE_R1};
|
|
uint8_t page_scan_mode{HCI_MANDATARY_PAGE_SCAN_MODE};
|
|
uint16_t clock_offset = BTM_GetClockOffset(bd_addr);
|
|
|
|
tBTM_INQ_INFO* p_inq_info = BTM_InqDbRead(bd_addr);
|
|
if (p_inq_info != nullptr &&
|
|
(p_inq_info->results.inq_result_type & BTM_INQ_RESULT_BR)) {
|
|
page_scan_rep_mode = p_inq_info->results.page_scan_rep_mode;
|
|
page_scan_mode = p_inq_info->results.page_scan_mode;
|
|
clock_offset = p_inq_info->results.clock_offset;
|
|
}
|
|
|
|
btsnd_hcic_create_conn(bd_addr, kDefaultPacketTypes, page_scan_rep_mode,
|
|
page_scan_mode, clock_offset, allow_role_switch);
|
|
btm_acl_set_paging(true);
|
|
}
|
|
|
|
void btm_acl_connection_request(const RawAddress& bda, uint8_t* dc) {
|
|
btm_sec_conn_req(bda, dc);
|
|
l2c_link_hci_conn_req(bda);
|
|
}
|
|
|
|
void acl_accept_connection_request(const RawAddress& bd_addr, uint8_t role) {
|
|
btsnd_hcic_accept_conn(bd_addr, role);
|
|
}
|
|
|
|
void acl_reject_connection_request(const RawAddress& bd_addr, uint8_t reason) {
|
|
btsnd_hcic_reject_conn(bd_addr, reason);
|
|
}
|
|
|
|
void acl_disconnect_from_handle(uint16_t handle, tHCI_STATUS reason) {
|
|
acl_disconnect_after_role_switch(handle, reason);
|
|
}
|
|
|
|
void acl_disconnect_after_role_switch(uint16_t conn_handle,
|
|
tHCI_STATUS reason) {
|
|
tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(conn_handle);
|
|
if (p_acl == nullptr) {
|
|
LOG_ERROR("Sending disconnect for unknown acl:%hu PLEASE FIX", conn_handle);
|
|
GetLegacyHciInterface().Disconnect(conn_handle, reason);
|
|
return;
|
|
}
|
|
|
|
/* If a role switch is in progress, delay the HCI Disconnect to avoid
|
|
* controller problem */
|
|
if (p_acl->rs_disc_pending == BTM_SEC_RS_PENDING) {
|
|
LOG_DEBUG(
|
|
"Role switch in progress - Set DISC Pending flag in "
|
|
"btm_sec_send_hci_disconnect "
|
|
"to delay disconnect");
|
|
p_acl->rs_disc_pending = BTM_SEC_DISC_PENDING;
|
|
} else {
|
|
LOG_DEBUG("Sending acl disconnect reason:%s [%hu]",
|
|
hci_error_code_text(reason).c_str(), reason);
|
|
hci_btsnd_hcic_disconnect(*p_acl, reason);
|
|
}
|
|
}
|
|
|
|
constexpr uint16_t kDataPacketEventBrEdr = (BT_EVT_TO_LM_HCI_ACL);
|
|
constexpr uint16_t kDataPacketEventBle =
|
|
(BT_EVT_TO_LM_HCI_ACL | LOCAL_BLE_CONTROLLER_ID);
|
|
|
|
void acl_send_data_packet_br_edr(const RawAddress& bd_addr, BT_HDR* p_buf) {
|
|
if (bluetooth::shim::is_gd_acl_enabled()) {
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, BT_TRANSPORT_BR_EDR);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Acl br_edr data write for unknown device:%s",
|
|
PRIVATE_ADDRESS(bd_addr));
|
|
osi_free(p_buf);
|
|
return;
|
|
}
|
|
return bluetooth::shim::ACL_WriteData(p_acl->hci_handle, p_buf);
|
|
}
|
|
bte_main_hci_send(p_buf, kDataPacketEventBrEdr);
|
|
}
|
|
|
|
void acl_send_data_packet_ble(const RawAddress& bd_addr, BT_HDR* p_buf) {
|
|
if (bluetooth::shim::is_gd_acl_enabled()) {
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, BT_TRANSPORT_LE);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Acl le data write for unknown device:%s",
|
|
PRIVATE_ADDRESS(bd_addr));
|
|
osi_free(p_buf);
|
|
return;
|
|
}
|
|
return bluetooth::shim::ACL_WriteData(p_acl->hci_handle, p_buf);
|
|
}
|
|
bte_main_hci_send(p_buf, kDataPacketEventBle);
|
|
}
|
|
|
|
void acl_write_automatic_flush_timeout(const RawAddress& bd_addr,
|
|
uint16_t flush_timeout_in_ticks) {
|
|
tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, BT_TRANSPORT_BR_EDR);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
if (p_acl->flush_timeout_in_ticks == flush_timeout_in_ticks) {
|
|
LOG_INFO(
|
|
"Ignoring since cached value is same as requested flush_timeout:%hd",
|
|
flush_timeout_in_ticks);
|
|
return;
|
|
}
|
|
flush_timeout_in_ticks &= HCI_MAX_AUTOMATIC_FLUSH_TIMEOUT;
|
|
p_acl->flush_timeout_in_ticks = flush_timeout_in_ticks;
|
|
btsnd_hcic_write_auto_flush_tout(p_acl->hci_handle, flush_timeout_in_ticks);
|
|
}
|
|
|
|
bool acl_create_le_connection_with_id(uint8_t id, const RawAddress& bd_addr) {
|
|
if (bluetooth::shim::is_gd_acl_enabled()) {
|
|
tBLE_BD_ADDR address_with_type{
|
|
.bda = bd_addr,
|
|
.type = BLE_ADDR_RANDOM,
|
|
};
|
|
gatt_find_in_device_record(bd_addr, &address_with_type);
|
|
LOG_DEBUG("Creating le connection to:%s",
|
|
address_with_type.ToString().c_str());
|
|
bluetooth::shim::ACL_AcceptLeConnectionFrom(address_with_type,
|
|
/* is_direct */ true);
|
|
return true;
|
|
}
|
|
return connection_manager::direct_connect_add(id, bd_addr);
|
|
}
|
|
|
|
bool acl_create_le_connection(const RawAddress& bd_addr) {
|
|
return acl_create_le_connection_with_id(CONN_MGR_ID_L2CAP, bd_addr);
|
|
}
|
|
|
|
void acl_rcv_acl_data(BT_HDR* p_msg) {
|
|
acl_header_t acl_header{
|
|
.handle = HCI_INVALID_HANDLE,
|
|
.hci_len = 0,
|
|
};
|
|
const uint8_t* p = (uint8_t*)(p_msg + 1) + p_msg->offset;
|
|
|
|
STREAM_TO_UINT16(acl_header.handle, p);
|
|
acl_header.handle = HCID_GET_HANDLE(acl_header.handle);
|
|
|
|
STREAM_TO_UINT16(acl_header.hci_len, p);
|
|
if (acl_header.hci_len < L2CAP_PKT_OVERHEAD ||
|
|
acl_header.hci_len != p_msg->len - sizeof(acl_header)) {
|
|
LOG_WARN("Received mismatched hci header length:%u data_len:%zu",
|
|
acl_header.hci_len, p_msg->len - sizeof(acl_header));
|
|
osi_free(p_msg);
|
|
return;
|
|
}
|
|
l2c_rcv_acl_data(p_msg);
|
|
}
|
|
|
|
void acl_link_segments_xmitted(BT_HDR* p_msg) {
|
|
l2c_link_segments_xmitted(p_msg);
|
|
}
|
|
|
|
void acl_packets_completed(uint16_t handle, uint16_t credits) {
|
|
l2c_packets_completed(handle, credits);
|
|
}
|
|
|
|
static void acl_parse_num_completed_pkts(uint8_t* p, uint8_t evt_len) {
|
|
if (evt_len == 0) {
|
|
LOG_ERROR("Received num completed packets with zero length");
|
|
return;
|
|
}
|
|
|
|
uint8_t num_handles{0};
|
|
STREAM_TO_UINT8(num_handles, p);
|
|
|
|
if (num_handles > evt_len / (2 * sizeof(uint16_t))) {
|
|
android_errorWriteLog(0x534e4554, "141617601");
|
|
num_handles = evt_len / (2 * sizeof(uint16_t));
|
|
}
|
|
|
|
for (uint8_t xx = 0; xx < num_handles; xx++) {
|
|
uint16_t handle{0};
|
|
uint16_t num_packets{0};
|
|
STREAM_TO_UINT16(handle, p);
|
|
handle = HCID_GET_HANDLE(handle);
|
|
STREAM_TO_UINT16(num_packets, p);
|
|
acl_packets_completed(handle, num_packets);
|
|
}
|
|
}
|
|
|
|
void acl_process_num_completed_pkts(uint8_t* p, uint8_t evt_len) {
|
|
if (bluetooth::shim::is_gd_acl_enabled()) {
|
|
acl_parse_num_completed_pkts(p, evt_len);
|
|
} else {
|
|
l2c_link_process_num_completed_pkts(p, evt_len);
|
|
}
|
|
bluetooth::hci::IsoManager::GetInstance()->HandleNumComplDataPkts(p, evt_len);
|
|
}
|
|
|
|
void acl_process_supported_features(uint16_t handle, uint64_t features) {
|
|
ASSERT_LOG(bluetooth::shim::is_gd_acl_enabled(),
|
|
"Should only be called when gd_acl enabled");
|
|
|
|
tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
const uint8_t current_page_number = 0;
|
|
|
|
memcpy(p_acl->peer_lmp_feature_pages[current_page_number],
|
|
(uint8_t*)&features, sizeof(uint64_t));
|
|
p_acl->peer_lmp_feature_valid[current_page_number] = true;
|
|
|
|
LOG_DEBUG(
|
|
"Copied supported feature pages handle:%hu current_page_number:%hhu "
|
|
"features:%s",
|
|
handle, current_page_number,
|
|
bd_features_text(p_acl->peer_lmp_feature_pages[current_page_number])
|
|
.c_str());
|
|
|
|
if ((HCI_LMP_EXTENDED_SUPPORTED(p_acl->peer_lmp_feature_pages[0])) &&
|
|
(controller_get_interface()
|
|
->supports_reading_remote_extended_features())) {
|
|
LOG_DEBUG("Waiting for remote extended feature response to arrive");
|
|
} else {
|
|
LOG_DEBUG("No more remote features outstanding so notify upper layer");
|
|
NotifyAclFeaturesReadComplete(*p_acl, current_page_number);
|
|
}
|
|
}
|
|
|
|
void acl_process_extended_features(uint16_t handle, uint8_t current_page_number,
|
|
uint8_t max_page_number, uint64_t features) {
|
|
ASSERT_LOG(bluetooth::shim::is_gd_acl_enabled(),
|
|
"Should only be called when gd_acl enabled");
|
|
|
|
if (current_page_number > HCI_EXT_FEATURES_PAGE_MAX) {
|
|
LOG_WARN("Unable to process current_page_number:%hhu", current_page_number);
|
|
return;
|
|
}
|
|
tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(handle);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return;
|
|
}
|
|
memcpy(p_acl->peer_lmp_feature_pages[current_page_number],
|
|
(uint8_t*)&features, sizeof(uint64_t));
|
|
p_acl->peer_lmp_feature_valid[current_page_number] = true;
|
|
|
|
LOG_DEBUG(
|
|
"Copied extended feature pages handle:%hu current_page_number:%hhu "
|
|
"max_page_number:%hhu features:%s",
|
|
handle, current_page_number, max_page_number,
|
|
bd_features_text(p_acl->peer_lmp_feature_pages[current_page_number])
|
|
.c_str());
|
|
|
|
if (max_page_number == current_page_number) {
|
|
NotifyAclFeaturesReadComplete(*p_acl, max_page_number);
|
|
}
|
|
}
|
|
|
|
void ACL_RegisterClient(struct acl_client_callback_s* callbacks) {
|
|
LOG_DEBUG("UNIMPLEMENTED");
|
|
}
|
|
|
|
void ACL_UnregisterClient(struct acl_client_callback_s* callbacks) {
|
|
LOG_DEBUG("UNIMPLEMENTED");
|
|
}
|
|
|
|
bool ACL_SupportTransparentSynchronousData(const RawAddress& bd_addr) {
|
|
const tACL_CONN* p_acl =
|
|
internal_.btm_bda_to_acl(bd_addr, BT_TRANSPORT_BR_EDR);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl");
|
|
return false;
|
|
}
|
|
|
|
return HCI_LMP_TRANSPNT_SUPPORTED(p_acl->peer_lmp_feature_pages[0]);
|
|
}
|
|
|
|
void acl_add_to_ignore_auto_connect_after_disconnect(
|
|
const RawAddress& bd_addr) {
|
|
btm_cb.acl_cb_.AddToIgnoreAutoConnectAfterDisconnect(bd_addr);
|
|
}
|
|
|
|
bool acl_check_and_clear_ignore_auto_connect_after_disconnect(
|
|
const RawAddress& bd_addr) {
|
|
return btm_cb.acl_cb_.CheckAndClearIgnoreAutoConnectAfterDisconnect(bd_addr);
|
|
}
|
|
|
|
void acl_clear_all_ignore_auto_connect_after_disconnect() {
|
|
btm_cb.acl_cb_.ClearAllIgnoreAutoConnectAfterDisconnect();
|
|
}
|
|
|
|
/**
|
|
* Confusingly, immutable device features are stored in the
|
|
* ephemeral connection data structure while connection security
|
|
* is stored in the device record.
|
|
*
|
|
* This HACK allows legacy security protocols to work as intended under
|
|
* those conditions.
|
|
*/
|
|
void HACK_acl_check_sm4(tBTM_SEC_DEV_REC& record) {
|
|
// Return if we already know this info
|
|
if ((record.sm4 & BTM_SM4_TRUE) != BTM_SM4_UNKNOWN) return;
|
|
|
|
tACL_CONN* p_acl =
|
|
internal_.btm_bda_to_acl(record.RemoteAddress(), BT_TRANSPORT_BR_EDR);
|
|
if (p_acl == nullptr) {
|
|
LOG_WARN("Unable to find active acl for authentication device:%s",
|
|
PRIVATE_ADDRESS(record.RemoteAddress()));
|
|
}
|
|
|
|
// If we have not received the SSP feature record
|
|
// we have to wait
|
|
if (!p_acl->peer_lmp_feature_valid[1]) {
|
|
LOG_WARN(
|
|
"Authentication started without extended feature page 1 request "
|
|
"response");
|
|
return;
|
|
}
|
|
record.sm4 = (HCI_SSP_HOST_SUPPORTED(p_acl->peer_lmp_feature_pages[1]))
|
|
? BTM_SM4_TRUE
|
|
: BTM_SM4_KNOWN;
|
|
}
|