Mirrors/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2026-10-02 03:00:34 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'bugfix/fix_some_bluedroid_bugs_260121_v5.4' into 'release/v5.4'

Browse Source 
Bugfix/fix some bluedroid bugs 260121 (5.4)

See merge request espressif/esp-idf!46982
This commit is contained in:
Island
2026-04-17 18:11:09 +08:00
parent 7f6adb256f 1ced86789b
commit aee5245e2d
120 changed files with 3975 additions and 2805 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/bt/host/bluedroid/stack/btm/btm_acl.c
+129 -113
View File
@@ -49,6 +49,7 @@
#include "stack/hcidefs.h"
//#include "bt_utils.h"
#include "osi/list.h"
#include "bta_dm_gap.h"
static void btm_read_remote_features (UINT16 handle);
static void btm_read_remote_ext_features (UINT16 handle, UINT8 page_number);
@@ -362,124 +363,131 @@ void btm_acl_created (BD_ADDR bda, DEV_CLASS dc, UINT8 bdn[BTM_MAX_REM_BD_NAME_L
}
else {
p = (tACL_CONN *)osi_malloc(sizeof(tACL_CONN));
if (p && list_append(btm_cb.p_acl_db_list, p)) {
memset(p, 0, sizeof(tACL_CONN));
p->in_use = TRUE;
p->hci_handle = hci_handle;
p->link_role = link_role;
p->link_up_issued = FALSE;
memcpy (p->remote_addr, bda, BD_ADDR_LEN);
/* Set the default version of the peer device to version4.0 before exchange the version with it.
If the peer device act as a master and don't exchange the version with us, then it can only use the
legacy connect instead of secure connection in the pairing step. */
p->lmp_version = HCI_PROTO_VERSION_4_0;
if (p == NULL) {
BTM_TRACE_ERROR("btm_acl_created: osi_malloc failed for tACL_CONN\n");
return;
}
if (!list_append(btm_cb.p_acl_db_list, p)) {
BTM_TRACE_ERROR("btm_acl_created: list_append failed\n");
osi_free(p);
return;
}
memset(p, 0, sizeof(tACL_CONN));
p->in_use = TRUE;
p->hci_handle = hci_handle;
p->link_role = link_role;
p->link_up_issued = FALSE;
memcpy (p->remote_addr, bda, BD_ADDR_LEN);
/* Set the default version of the peer device to version4.0 before exchange the version with it.
If the peer device act as a master and don't exchange the version with us, then it can only use the
legacy connect instead of secure connection in the pairing step. */
p->lmp_version = HCI_PROTO_VERSION_4_0;
#if BLE_INCLUDED == TRUE
p->transport = transport;
p->transport = transport;
#if BLE_PRIVACY_SPT == TRUE
if (transport == BT_TRANSPORT_LE) {
btm_ble_refresh_local_resolvable_private_addr(bda,
btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr);
}
if (transport == BT_TRANSPORT_LE) {
btm_ble_refresh_local_resolvable_private_addr(bda,
btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr);
}
#else
p->conn_addr_type = BLE_ADDR_PUBLIC;
memcpy(p->conn_addr, &controller_get_interface()->get_address()->address, BD_ADDR_LEN);
BTM_TRACE_DEBUG ("conn_addr: RemBdAddr: %02x%02x%02x%02x%02x%02x\n",
p->conn_addr[0], p->conn_addr[1], p->conn_addr[2], p->conn_addr[3], p->conn_addr[4], p->conn_addr[5]);
p->conn_addr_type = BLE_ADDR_PUBLIC;
memcpy(p->conn_addr, &controller_get_interface()->get_address()->address, BD_ADDR_LEN);
BTM_TRACE_DEBUG ("conn_addr: RemBdAddr: %02x%02x%02x%02x%02x%02x\n",
p->conn_addr[0], p->conn_addr[1], p->conn_addr[2], p->conn_addr[3], p->conn_addr[4], p->conn_addr[5]);
#endif
#endif
#if (CLASSIC_BT_INCLUDED == TRUE)
p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE;
p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE;
p->p_pm_mode_db = btm_pm_sm_alloc();
p->p_pm_mode_db = btm_pm_sm_alloc();
#if BTM_PM_DEBUG == TRUE
BTM_TRACE_DEBUG( "btm_pm_sm_alloc handle:%d st:%d", hci_handle, p->p_pm_mode_db->state);
BTM_TRACE_DEBUG( "btm_pm_sm_alloc handle:%d st:%d", hci_handle, p->p_pm_mode_db->state);
#endif // BTM_PM_DEBUG
#endif // (CLASSIC_BT_INCLUDED == TRUE)
#if (CLASSIC_BT_INCLUDED == TRUE)
btm_sec_update_legacy_auth_state(p, BTM_ACL_LEGACY_AUTH_NONE);
btm_sec_update_legacy_auth_state(p, BTM_ACL_LEGACY_AUTH_NONE);
#endif
if (dc) {
memcpy (p->remote_dc, dc, DEV_CLASS_LEN);
}
if (dc) {
memcpy (p->remote_dc, dc, DEV_CLASS_LEN);
}
if (bdn) {
memcpy (p->remote_name, bdn, BTM_MAX_REM_BD_NAME_LEN);
}
if (bdn) {
memcpy (p->remote_name, bdn, BTM_MAX_REM_BD_NAME_LEN);
}
/* if BR/EDR do something more */
if (transport == BT_TRANSPORT_BR_EDR) {
btsnd_hcic_read_rmt_clk_offset (p->hci_handle);
btsnd_hcic_rmt_ver_req (p->hci_handle);
}
p_dev_rec = btm_find_dev_by_handle (hci_handle);
/* if BR/EDR do something more */
if (transport == BT_TRANSPORT_BR_EDR) {
btsnd_hcic_read_rmt_clk_offset (p->hci_handle);
btsnd_hcic_rmt_ver_req (p->hci_handle);
}
p_dev_rec = btm_find_dev_by_handle (hci_handle);
#if (BLE_INCLUDED == TRUE)
if (p_dev_rec ) {
BTM_TRACE_DEBUG ("device_type=0x%x\n", p_dev_rec->device_type);
}
if (p_dev_rec ) {
BTM_TRACE_DEBUG ("device_type=0x%x\n", p_dev_rec->device_type);
}
#endif
if (p_dev_rec && !(transport == BT_TRANSPORT_LE)) {
if (!p_dev_rec->remote_secure_connection_previous_state) {
/* If remote features already known, copy them and continue connection setup */
if ((p_dev_rec->num_read_pages) &&
(p_dev_rec->num_read_pages <= (HCI_EXT_FEATURES_PAGE_MAX + 1))) {
memcpy (p->peer_lmp_features, p_dev_rec->features,
(HCI_FEATURE_BYTES_PER_PAGE * p_dev_rec->num_read_pages));
p->num_read_pages = p_dev_rec->num_read_pages;
if (p_dev_rec && !(transport == BT_TRANSPORT_LE)) {
if (!p_dev_rec->remote_secure_connection_previous_state) {
/* If remote features already known, copy them and continue connection setup */
if ((p_dev_rec->num_read_pages) &&
(p_dev_rec->num_read_pages <= (HCI_EXT_FEATURES_PAGE_MAX + 1))) {
memcpy (p->peer_lmp_features, p_dev_rec->features,
(HCI_FEATURE_BYTES_PER_PAGE * p_dev_rec->num_read_pages));
p->num_read_pages = p_dev_rec->num_read_pages;
#if (CLASSIC_BT_INCLUDED == TRUE)
const UINT8 req_pend = (p_dev_rec->sm4 & BTM_SM4_REQ_PEND);
const UINT8 req_pend = (p_dev_rec->sm4 & BTM_SM4_REQ_PEND);
#endif ///CLASSIC_BT_INCLUDED == TRUE
/* Store the Peer Security Capabilities (in SM4 and rmt_sec_caps) */
/* Store the Peer Security Capabilities (in SM4 and rmt_sec_caps) */
#if (SMP_INCLUDED == TRUE)
btm_sec_set_peer_sec_caps(p, p_dev_rec);
btm_sec_set_peer_sec_caps(p, p_dev_rec);
#endif ///SMP_INCLUDED == TRUE
#if (CLASSIC_BT_INCLUDED == TRUE)
BTM_TRACE_API("%s: pend:%d\n", __FUNCTION__, req_pend);
if (req_pend) {
/* Request for remaining Security Features (if any) */
l2cu_resubmit_pending_sec_req (p_dev_rec->bd_addr);
}
#endif ///CLASSIC_BT_INCLUDED == TRUE
btm_establish_continue (p);
return;
BTM_TRACE_API("%s: pend:%d\n", __FUNCTION__, req_pend);
if (req_pend) {
/* Request for remaining Security Features (if any) */
l2cu_resubmit_pending_sec_req (p_dev_rec->bd_addr);
}
} else {
/* If remote features indicated secure connection (SC) mode, check the remote features again*/
/* this is to prevent from BIAS attack where attacker can downgrade SC mode*/
btm_read_remote_features (p->hci_handle);
#endif ///CLASSIC_BT_INCLUDED == TRUE
btm_establish_continue (p);
return;
}
}
#if (BLE_INCLUDED == TRUE)
/* If here, features are not known yet */
if (p_dev_rec && transport == BT_TRANSPORT_LE) {
#if BLE_PRIVACY_SPT == TRUE
btm_ble_get_acl_remote_addr (p_dev_rec, p->active_remote_addr,
&p->active_remote_addr_type);
#endif
if (link_role == HCI_ROLE_MASTER) {
btsnd_hcic_ble_read_remote_feat(p->hci_handle);
} else if (HCI_LE_SLAVE_INIT_FEAT_EXC_SUPPORTED(controller_get_interface()->get_features_ble()->as_array)
&& link_role == HCI_ROLE_SLAVE) {
btsnd_hcic_rmt_ver_req (p->hci_handle);
} else {
btm_establish_continue(p);
}
} else
#endif
{
} else {
/* If remote features indicated secure connection (SC) mode, check the remote features again*/
/* this is to prevent from BIAS attack where attacker can downgrade SC mode*/
btm_read_remote_features (p->hci_handle);
}
/* read page 1 - on rmt feature event for buffer reasons */
return;
}
#if (BLE_INCLUDED == TRUE)
/* If here, features are not known yet */
if (p_dev_rec && transport == BT_TRANSPORT_LE) {
#if BLE_PRIVACY_SPT == TRUE
btm_ble_get_acl_remote_addr (p_dev_rec, p->active_remote_addr,
&p->active_remote_addr_type);
#endif
if (link_role == HCI_ROLE_MASTER) {
btsnd_hcic_ble_read_remote_feat(p->hci_handle);
} else if (HCI_LE_SLAVE_INIT_FEAT_EXC_SUPPORTED(controller_get_interface()->get_features_ble()->as_array)
&& link_role == HCI_ROLE_SLAVE) {
btsnd_hcic_rmt_ver_req (p->hci_handle);
} else {
btm_establish_continue(p);
}
} else
#endif
{
btm_read_remote_features (p->hci_handle);
}
/* read page 1 - on rmt feature event for buffer reasons */
return;
}
}
@@ -589,11 +597,9 @@ void btm_acl_removed (BD_ADDR bda, tBT_TRANSPORT transport)
#if (CLASSIC_BT_INCLUDED == TRUE)
list_remove(btm_cb.p_pm_mode_db_list, p->p_pm_mode_db);
#endif // #if (CLASSIC_BT_INCLUDED == TRUE)
/* Clear the ACL connection data */
memset(p, 0, sizeof(tACL_CONN));
if (list_remove(btm_cb.p_acl_db_list, p)) {
p = NULL;
}
/* Remove and free the ACL connection data */
list_remove(btm_cb.p_acl_db_list, p);
p = NULL;
}
}
@@ -2270,10 +2276,12 @@ void btm_acl_pkt_types_changed(UINT8 status, UINT16 handle, UINT16 pkt_types)
** Returns BTM_CMD_STARTED if successfully initiated or error code
**
*******************************************************************************/
tBTM_STATUS BTM_ReadChannelMap(BD_ADDR remote_bda, tBTM_CMPL_CB *p_cb)
tBTM_STATUS BTM_ReadChannelMap(BD_ADDR remote_bda)
{
tACL_CONN *p;
tBTM_BLE_CH_MAP_RESULTS result;
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params;
UINT8 status;
BTM_TRACE_DEBUG("BTM_ReadChannelMap: RemBdAddr: %02x%02x%02x%02x%02x%02x\n",
remote_bda[0], remote_bda[1], remote_bda[2],
@@ -2281,29 +2289,33 @@ tBTM_STATUS BTM_ReadChannelMap(BD_ADDR remote_bda, tBTM_CMPL_CB *p_cb)
memset(result.channel_map, 0, sizeof(result.channel_map)); // Clear channel map data
/* If someone already waiting for the channel map, do not allow another */
if (btm_cb.devcb.p_ble_ch_map_cmpl_cb) {
if (btm_cb.devcb.is_ch_map_cb) {
result.status = BTM_BUSY;
(*p_cb)(&result);
return BTM_BUSY;
status = BTM_BUSY;
goto _ch_map_err;
}
p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_LE);
if (p != NULL) {
btm_cb.devcb.p_ble_ch_map_cmpl_cb = p_cb;
if (!btsnd_hcic_ble_read_chnl_map(p->hci_handle)) {
btm_cb.devcb.p_ble_ch_map_cmpl_cb = NULL;
btm_cb.devcb.is_ch_map_cb = false;
result.status = BTM_NO_RESOURCES;
(*p_cb)(&result);
return BTM_NO_RESOURCES;
status = BTM_NO_RESOURCES;
goto _ch_map_err;
} else {
btm_cb.devcb.is_ch_map_cb = true;
return BTM_CMD_STARTED;
}
}
status = BTM_UNKNOWN_ADDR;
/* If here, no BD Addr found */
result.status = BTM_UNKNOWN_ADDR;
(*p_cb)(&result);
return BTM_UNKNOWN_ADDR;
_ch_map_err:
memset(&cb_params, 0, sizeof(cb_params));
// `ch_map_read` is same as `results`
memcpy(&cb_params.ch_map_results, &result, sizeof(tBTM_BLE_CH_MAP_RESULTS));
BTM_LegacyBleCallbackTrigger(BTM_BLE_LEGACY_GAP_READ_CHANNEL_MAP_EVT, &cb_params);
return status;
}
void BTM_BleGetWhiteListSize(uint16_t *length)
@@ -2344,17 +2356,16 @@ void BTM_BleGetPeriodicAdvListSize(uint8_t *size)
*******************************************************************************/
void btm_read_channel_map_complete(UINT8 *p)
{
tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_ble_ch_map_cmpl_cb;
tBTM_BLE_CH_MAP_RESULTS results;
UINT16 handle;
tACL_CONN *p_acl_cb = NULL;
BTM_TRACE_DEBUG("btm_read_channel_map_complete\n");
/* Reset the callback pointer to prevent duplicate calls */
btm_cb.devcb.p_ble_ch_map_cmpl_cb = NULL;
if (p_cb) {
if (btm_cb.devcb.is_ch_map_cb) {
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params;
/* Reset the callback pointer to prevent duplicate calls */
btm_cb.devcb.is_ch_map_cb = false;
/* Extract HCI status from the response */
STREAM_TO_UINT8(results.hci_status, p);
@@ -2381,7 +2392,10 @@ void btm_read_channel_map_complete(UINT8 *p)
}
/* Invoke the registered callback with the results */
(*p_cb)(&results);
memset(&cb_params, 0, sizeof(cb_params));
// `ch_map_read` is same as `results`
memcpy(&cb_params.ch_map_results, &results, sizeof(tBTM_BLE_CH_MAP_RESULTS));
BTM_LegacyBleCallbackTrigger(BTM_BLE_LEGACY_GAP_READ_CHANNEL_MAP_EVT, &cb_params);
}
}
#endif // #if BLE_INCLUDED == TRUE
@@ -2399,7 +2413,7 @@ void btm_read_channel_map_complete(UINT8 *p)
void btm_read_rssi_complete (UINT8 *p, UINT16 evt_len)
{
tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_rssi_cmpl_cb;
tBTM_RSSI_RESULTS results;
tBTM_RSSI_RESULTS results = {0};
UINT16 handle;
tACL_CONN *p_acl_cb = NULL;
BTM_TRACE_DEBUG ("btm_read_rssi_complete\n");
@@ -2431,10 +2445,12 @@ void btm_read_rssi_complete (UINT8 *p, UINT16 evt_len)
results.rssi, results.hci_status);
/* Search through the list of active channels for the correct BD Addr */
p_acl_cb = btm_handle_to_acl(handle);
if (p_acl_cb) {
p_acl_cb = btm_handle_to_acl(handle);
if (p_acl_cb) {
memcpy (results.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN);
}
} else {
results.status = BTM_UNKNOWN_ADDR;
}
} else {
results.status = BTM_ERR_PROCESSING;
}
components/bt/host/bluedroid/stack/btm/btm_ble.c
+9 -8
View File
@@ -407,8 +407,9 @@ void BTM_BlePasskeyReply (BD_ADDR bd_addr, UINT8 res, UINT32 passkey)
BTM_TRACE_ERROR("Passkey reply to Unknown device");
return;
}
p_dev_rec->sec_flags |= BTM_SEC_LE_AUTHENTICATED;
if (res_smp == SMP_SUCCESS) {
p_dev_rec->sec_flags |= BTM_SEC_LE_AUTHENTICATED;
}
BTM_TRACE_DEBUG ("BTM_BlePasskeyReply");
SMP_PasskeyReply(bd_addr, res_smp, passkey);
#endif
@@ -487,8 +488,9 @@ void BTM_BleOobDataReply(BD_ADDR bd_addr, UINT8 res, UINT8 len, UINT8 *p_data)
BTM_TRACE_ERROR("BTM_BleOobDataReply() to Unknown device");
return;
}
p_dev_rec->sec_flags |= BTM_SEC_LE_AUTHENTICATED;
if (res_smp == SMP_SUCCESS) {
p_dev_rec->sec_flags |= BTM_SEC_LE_AUTHENTICATED;
}
SMP_OobDataReply(bd_addr, res_smp, len, p_data);
#endif
}
@@ -902,7 +904,7 @@ tBTM_STATUS BTM_SetBleDataLength(BD_ADDR bd_addr, UINT16 tx_pdu_length)
} else if (tx_pdu_length < BTM_BLE_DATA_SIZE_MIN) {
tx_pdu_length = BTM_BLE_DATA_SIZE_MIN;
}
p_acl->data_len_updating = true;
/* always set the TxTime to be max, as controller does not care for now */
btsnd_hcic_ble_set_data_length(p_acl->hci_handle, tx_pdu_length,
BTM_BLE_DATA_TX_TIME_MAX);
@@ -1431,6 +1433,7 @@ void btm_ble_link_sec_check(BD_ADDR bd_addr, tBTM_LE_AUTH_REQ auth_req, tBTM_BLE
if (p_dev_rec == NULL) {
BTM_TRACE_ERROR ("btm_ble_link_sec_check received for unknown device");
*p_sec_req_act = BTM_BLE_SEC_REQ_ACT_NONE;
return;
}
@@ -2170,9 +2173,7 @@ UINT8 btm_proc_smp_cback(tSMP_EVT event, BD_ADDR bd_addr, tSMP_EVT_DATA *p_data)
case SMP_OOB_REQ_EVT:
case SMP_NC_REQ_EVT:
case SMP_SC_OOB_REQ_EVT:
/* fall through */
p_dev_rec->sec_flags |= BTM_SEC_LE_AUTHENTICATED;
/* fall through */
case SMP_SEC_REQUEST_EVT:
if (event == SMP_SEC_REQUEST_EVT && btm_cb.pairing_state != BTM_PAIR_STATE_IDLE) {
BTM_TRACE_DEBUG("%s: Ignoring SMP Security request", __func__);
components/bt/host/bluedroid/stack/btm/btm_ble_5_gap.c
+54 -183
View File
@@ -16,12 +16,14 @@ tBTM_BLE_EXTENDED_CB extend_adv_cb;
tBTM_BLE_5_HCI_CBACK ble_5_hci_cb;
#define INVALID_VALUE 0XFF
#define INVALID_VALUE_8BIT 0XFF
#define INVALID_VALUE_16BIT 0XFFFF
#define INVALID_VALUE_32BIT 0XFFFFFFFF
extern BOOLEAN BTM_GetLocalResolvablePrivateAddr(BD_ADDR bda);
extern void BTM_UpdateAddrInfor(uint8_t addr_type, BD_ADDR bda);
extern void BTM_BleSetStaticAddr(BD_ADDR rand_addr);
extern uint32_t BTM_BleUpdateOwnType(uint8_t *own_bda_type, tBTM_START_ADV_CMPL_CBACK *cb);
extern uint32_t BTM_BleUpdateOwnType(uint8_t *own_bda_type);
#if (BLE_50_EXTEND_ADV_EN == TRUE)
static tBTM_STATUS btm_ble_ext_adv_params_validate(tBTM_BLE_GAP_EXT_ADV_PARAMS *params);
static tBTM_STATUS btm_ble_ext_adv_set_data_validate(UINT8 instance, UINT16 len, UINT8 *data);
@@ -54,158 +56,6 @@ static tBTM_BLE_SYNC_RETRY_CB sync_retry_cb = {0};
extern void btm_ble_inter_set(bool extble_inter);
#if !UC_BT_STACK_NO_LOG
static const char *btm_ble_hci_status_to_str(tHCI_STATUS status)
{
switch(status) {
case HCI_SUCCESS:
return "HCI_SUCCESS";
case HCI_ERR_ILLEGAL_COMMAND:
return "HCI_ERR_ILLEGAL_COMMAND";
case HCI_ERR_NO_CONNECTION:
return "HCI_ERR_NO_CONNECTION";
case HCI_ERR_HW_FAILURE:
return "HCI_ERR_HW_FAILURE";
case HCI_ERR_PAGE_TIMEOUT:
return "HCI_ERR_PAGE_TIMEOUT";
case HCI_ERR_AUTH_FAILURE:
return "HCI_ERR_AUTH_FAILURE";
case HCI_ERR_KEY_MISSING:
return "HCI_ERR_KEY_MISSING";
case HCI_ERR_MEMORY_FULL:
return "HCI_ERR_MEMORY_FULL";
case HCI_ERR_CONNECTION_TOUT:
return "HCI_ERR_CONNECTION_TOUT";
case HCI_ERR_MAX_NUM_OF_CONNECTIONS:
return "HCI_ERR_MAX_NUM_OF_CONNECTIONS";
case HCI_ERR_MAX_NUM_OF_SCOS:
return "HCI_ERR_MAX_NUM_OF_SCOS";
case HCI_ERR_CONNECTION_EXISTS:
return "HCI_ERR_CONNECTION_EXISTS";
case HCI_ERR_COMMAND_DISALLOWED:
return "HCI_ERR_COMMAND_DISALLOWED";
case HCI_ERR_HOST_REJECT_RESOURCES:
return "HCI_ERR_HOST_REJECT_RESOURCES";
case HCI_ERR_HOST_REJECT_SECURITY:
return "HCI_ERR_HOST_REJECT_SECURITY";
case HCI_ERR_HOST_REJECT_DEVICE:
return "HCI_ERR_HOST_REJECT_DEVICE";
case HCI_ERR_HOST_TIMEOUT:
return "HCI_ERR_HOST_TIMEOUT";
case HCI_ERR_UNSUPPORTED_VALUE:
return "HCI_ERR_UNSUPPORTED_VALUE";
case HCI_ERR_ILLEGAL_PARAMETER_FMT:
return "HCI_ERR_ILLEGAL_PARAMETER_FMT";
case HCI_ERR_PEER_USER:
return "HCI_ERR_PEER_USER";
case HCI_ERR_PEER_LOW_RESOURCES:
return "HCI_ERR_PEER_LOW_RESOURCES";
case HCI_ERR_PEER_POWER_OFF:
return "HCI_ERR_PEER_POWER_OFF";
case HCI_ERR_CONN_CAUSE_LOCAL_HOST:
return "HCI_ERR_CONN_CAUSE_LOCAL_HOST";
case HCI_ERR_REPEATED_ATTEMPTS:
return "HCI_ERR_REPEATED_ATTEMPTS";
case HCI_ERR_PAIRING_NOT_ALLOWED:
return "HCI_ERR_PAIRING_NOT_ALLOWED";
case HCI_ERR_UNKNOWN_LMP_PDU:
return "HCI_ERR_UNKNOWN_LMP_PDU";
case HCI_ERR_UNSUPPORTED_REM_FEATURE:
return "HCI_ERR_UNSUPPORTED_REM_FEATURE";
case HCI_ERR_SCO_OFFSET_REJECTED:
return "HCI_ERR_SCO_OFFSET_REJECTED";
case HCI_ERR_SCO_INTERVAL_REJECTED:
return "HCI_ERR_SCO_INTERVAL_REJECTED";
case HCI_ERR_SCO_AIR_MODE:
return "HCI_ERR_SCO_AIR_MODE";
case HCI_ERR_INVALID_LMP_PARAM:
return "HCI_ERR_INVALID_LMP_PARAM";
case HCI_ERR_UNSPECIFIED:
return "HCI_ERR_UNSPECIFIED";
case HCI_ERR_UNSUPPORTED_LMP_PARAMETERS:
return "HCI_ERR_UNSUPPORTED_LMP_PARAMETERS";
case HCI_ERR_ROLE_CHANGE_NOT_ALLOWED:
return "HCI_ERR_ROLE_CHANGE_NOT_ALLOWED";
case HCI_ERR_LMP_RESPONSE_TIMEOUT:
return "HCI_ERR_LMP_RESPONSE_TIMEOUT";
case HCI_ERR_LMP_ERR_TRANS_COLLISION:
return "HCI_ERR_LMP_ERR_TRANS_COLLISION";
case HCI_ERR_LMP_PDU_NOT_ALLOWED:
return "HCI_ERR_LMP_PDU_NOT_ALLOWED";
case HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE:
return "HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE";
case HCI_ERR_UNIT_KEY_USED:
return "HCI_ERR_UNIT_KEY_USED";
case HCI_ERR_QOS_NOT_SUPPORTED:
return "HCI_ERR_QOS_NOT_SUPPORTED";
case HCI_ERR_INSTANT_PASSED:
return "HCI_ERR_INSTANT_PASSED";
case HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED:
return "HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED";
case HCI_ERR_DIFF_TRANSACTION_COLLISION:
return "HCI_ERR_DIFF_TRANSACTION_COLLISION";
case HCI_ERR_UNDEFINED_0x2B:
return "HCI_ERR_UNDEFINED_0x2B";
case HCI_ERR_QOS_UNACCEPTABLE_PARAM:
return "HCI_ERR_QOS_UNACCEPTABLE_PARAM";
case HCI_ERR_QOS_REJECTED:
return "HCI_ERR_QOS_REJECTED";
case HCI_ERR_CHAN_CLASSIF_NOT_SUPPORTED:
return "HCI_ERR_CHAN_CLASSIF_NOT_SUPPORTED";
case HCI_ERR_INSUFFCIENT_SECURITY:
return "HCI_ERR_INSUFFCIENT_SECURITY";
case HCI_ERR_PARAM_OUT_OF_RANGE:
return "HCI_ERR_PARAM_OUT_OF_RANGE";
case HCI_ERR_UNDEFINED_0x31:
return "HCI_ERR_UNDEFINED_0x31";
case HCI_ERR_ROLE_SWITCH_PENDING:
return "HCI_ERR_ROLE_SWITCH_PENDING";
case HCI_ERR_UNDEFINED_0x33:
return "HCI_ERR_UNDEFINED_0x33";
case HCI_ERR_RESERVED_SLOT_VIOLATION:
return "HCI_ERR_RESERVED_SLOT_VIOLATION";
case HCI_ERR_ROLE_SWITCH_FAILED:
return "HCI_ERR_ROLE_SWITCH_FAILED";
case HCI_ERR_INQ_RSP_DATA_TOO_LARGE:
return "HCI_ERR_INQ_RSP_DATA_TOO_LARGE";
case HCI_ERR_SIMPLE_PAIRING_NOT_SUPPORTED:
return "HCI_ERR_SIMPLE_PAIRING_NOT_SUPPORTED";
case HCI_ERR_HOST_BUSY_PAIRING:
return "HCI_ERR_HOST_BUSY_PAIRING";
case HCI_ERR_REJ_NO_SUITABLE_CHANNEL:
return "HCI_ERR_REJ_NO_SUITABLE_CHANNEL";
case HCI_ERR_CONTROLLER_BUSY:
return "HCI_ERR_CONTROLLER_BUSY";
case HCI_ERR_UNACCEPT_CONN_INTERVAL:
return "HCI_ERR_UNACCEPT_CONN_INTERVAL";
case HCI_ERR_DIRECTED_ADVERTISING_TIMEOUT:
return "HCI_ERR_DIRECTED_ADVERTISING_TIMEOUT";
case HCI_ERR_CONN_TOUT_DUE_TO_MIC_FAILURE:
return "HCI_ERR_CONN_TOUT_DUE_TO_MIC_FAILURE";
case HCI_ERR_CONN_FAILED_ESTABLISHMENT:
return "HCI_ERR_CONN_FAILED_ESTABLISHMENT";
case HCI_ERR_MAC_CONNECTION_FAILED:
return "HCI_ERR_MAC_CONNECTION_FAILED";
case HCI_ERR_LT_ADDR_ALREADY_IN_USE:
return "HCI_ERR_LT_ADDR_ALREADY_IN_USE";
case HCI_ERR_LT_ADDR_NOT_ALLOCATED:
return "HCI_ERR_LT_ADDR_NOT_ALLOCATED";
case HCI_ERR_CLB_NOT_ENABLED:
return "HCI_ERR_CLB_NOT_ENABLED";
case HCI_ERR_MAX_ERR:
return "HCI_ERR_MAX_ERR";
case HCI_ERR_ESP_VENDOR_FAIL:
return "HCI_ERR_ESP_VENDOR_FAIL";
case HCI_HINT_TO_RECREATE_AMP_PHYS_LINK:
return "HCI_HINT_TO_RECREATE_AMP_PHYS_LINK";
default:
return "Invalid HCI status code.";
}
return NULL;
}
#endif /* !UC_BT_STACK_NO_LOG */
void btm_ble_extendadvcb_init(void)
{
memset(&extend_adv_cb, 0, sizeof(tBTM_BLE_EXTENDED_CB));
@@ -245,9 +95,7 @@ tBTM_STATUS BTM_BleReadPhy(BD_ADDR bd_addr, UINT8 *tx_phy, UINT8 *rx_phy)
cb_params.read_phy.status = BTM_ILLEGAL_VALUE;
memcpy(cb_params.read_phy.addr, bd_addr, BD_ADDR_LEN);
if (ble_5_hci_cb) {
ble_5_hci_cb(BTM_BLE_5_GAP_READ_PHY_COMPLETE_EVT, &cb_params);
}
BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_READ_PHY_COMPLETE_EVT, &cb_params);
BTM_TRACE_ERROR("%s, invalid parameters", __func__);
return BTM_ILLEGAL_VALUE;
}
@@ -265,8 +113,8 @@ tBTM_STATUS BTM_BleSetPreferDefaultPhy(UINT8 tx_phy_mask, UINT8 rx_phy_mask)
tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
if ((err = btsnd_hcic_ble_set_prefered_default_phy(all_phys, tx_phy_mask, rx_phy_mask)) != HCI_SUCCESS) {
BTM_TRACE_ERROR("%s, fail to send the hci command, the error code = %s(0x%x)",
__func__, btm_ble_hci_status_to_str(err), err);
BTM_TRACE_ERROR("%s, fail to send the hci command, the error code = 0x%x",
__func__, err);
status = BTM_HCI_ERROR | err;
}
@@ -286,9 +134,7 @@ tBTM_STATUS BTM_BleSetPreferPhy(BD_ADDR bd_addr, UINT8 all_phys, UINT8 tx_phy_ma
if (!p_lcb) {
cb_params.status = BTM_ILLEGAL_VALUE;
if (ble_5_hci_cb) {
ble_5_hci_cb(BTM_BLE_5_GAP_SET_PREFERED_PHY_COMPLETE_EVT, &cb_params);
}
BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_SET_PREFERED_PHY_COMPLETE_EVT, &cb_params);
BTM_TRACE_ERROR("%s, invalid parameters", __func__);
return BTM_ILLEGAL_VALUE;
}
@@ -347,8 +193,8 @@ tBTM_STATUS BTM_BleSetExtendedAdvRandaddr(UINT8 instance, BD_ADDR rand_addr)
// set random address
if((err = btsnd_hcic_ble_set_extend_rand_address(instance, rand_addr)) != HCI_SUCCESS) {
BTM_TRACE_ERROR("%s, fail to send the hci command, the error code = %s(0x%x)",
__func__, btm_ble_hci_status_to_str(err), err);
BTM_TRACE_ERROR("%s, fail to send the hci command, the error code = 0x%x",
__func__, err);
status = BTM_HCI_ERROR | err;
} else {
// set random address success, update address info
@@ -382,6 +228,7 @@ tBTM_STATUS BTM_BleSetExtendedAdvParams(UINT8 instance, tBTM_BLE_GAP_EXT_ADV_PAR
if ((status = btm_ble_ext_adv_params_validate(params)) != BTM_SUCCESS) {
BTM_TRACE_ERROR("%s, invalid extend adv params.", __func__);
goto end;
}
if (params->type & BTM_BLE_GAP_SET_EXT_ADV_PROP_CONNECTABLE) {
@@ -529,13 +376,21 @@ tBTM_STATUS BTM_BleStartExtAdv(BOOLEAN enable, UINT8 num, tBTM_BLE_EXT_ADV *ext_
UINT8 *max_events = NULL;
// when enable = true, ext_adv = NULL or num = 0, goto end
if ((!ext_adv || num == 0) && enable) {
if (num > MAX_BLE_ADV_INSTANCE || (num > 0 && !ext_adv) || (enable && num == 0)) {
status = BTM_ILLEGAL_VALUE;
BTM_TRACE_ERROR("%s invalid parameters", __func__);
goto end;
}
if (num != 0 && ext_adv != NULL) {
for (int i = 0; i < num; i++) {
if (ext_adv[i].instance >= MAX_BLE_ADV_INSTANCE) {
status = BTM_ILLEGAL_VALUE;
BTM_TRACE_ERROR("%s instance ID %d out of range", __func__, ext_adv[i].instance);
goto end;
}
}
instance = osi_malloc(num);
duration = osi_malloc(num*sizeof(UINT16));
max_events = osi_malloc(num*sizeof(UINT8));
@@ -557,10 +412,6 @@ tBTM_STATUS BTM_BleStartExtAdv(BOOLEAN enable, UINT8 num, tBTM_BLE_EXT_ADV *ext_
BTM_TRACE_ERROR("LE EA En=%d: cmd err=0x%x", enable, err);
status = BTM_HCI_ERROR | err;
}
osi_free(instance);
osi_free(duration);
osi_free(max_events);
} else {
// enable = false, num == 0 or ext_adv = NULL
@@ -574,6 +425,15 @@ tBTM_STATUS BTM_BleStartExtAdv(BOOLEAN enable, UINT8 num, tBTM_BLE_EXT_ADV *ext_
end:
if (instance) {
osi_free(instance);
}
if (duration) {
osi_free(duration);
}
if (max_events) {
osi_free(max_events);
}
if (!enable && status == BTM_SUCCESS) {
// disable all ext adv
@@ -583,20 +443,23 @@ end:
{
adv_record[i].invalid = false;
adv_record[i].enabled = false;
adv_record[i].instance = INVALID_VALUE;
adv_record[i].duration = INVALID_VALUE;
adv_record[i].max_events = INVALID_VALUE;
adv_record[i].instance = INVALID_VALUE_8BIT;
adv_record[i].duration = INVALID_VALUE_32BIT;
adv_record[i].max_events = INVALID_VALUE_32BIT;
adv_record[i].retry_count = 0;
}
} else {
for (uint8_t i = 0; i < num; i++)
{
uint8_t index = ext_adv[i].instance;
if (index >= MAX_BLE_ADV_INSTANCE) {
continue;
}
adv_record[index].invalid = false;
adv_record[index].enabled = false;
adv_record[index].instance = INVALID_VALUE;
adv_record[index].duration = INVALID_VALUE;
adv_record[index].max_events = INVALID_VALUE;
adv_record[index].instance = INVALID_VALUE_8BIT;
adv_record[index].duration = INVALID_VALUE_32BIT;
adv_record[index].max_events = INVALID_VALUE_32BIT;
adv_record[index].retry_count = 0;
}
}
@@ -606,6 +469,9 @@ end:
for (uint8_t i = 0; i < num; i++)
{
uint8_t index = ext_adv[i].instance;
if (index >= MAX_BLE_ADV_INSTANCE) {
continue;
}
adv_record[index].invalid = true;
adv_record[index].enabled = true;
adv_record[index].instance = ext_adv[i].instance;
@@ -616,9 +482,12 @@ end:
}
cb_params.adv_start.status = status;
num = (num > MAX_BLE_ADV_INSTANCE) ? MAX_BLE_ADV_INSTANCE : num;
cb_params.adv_start.instance_num = num;
for (uint8_t i = 0; i < num; i++) {
cb_params.adv_start.instance[i] = ext_adv[i].instance;
if (ext_adv) {
for (uint8_t i = 0; i < num; i++) {
cb_params.adv_start.instance[i] = ext_adv[i].instance;
}
}
BTM_ExtBleCallbackTrigger(enable ? BTM_BLE_5_GAP_EXT_ADV_START_COMPLETE_EVT : BTM_BLE_5_GAP_EXT_ADV_STOP_COMPLETE_EVT, &cb_params);
@@ -626,10 +495,10 @@ end:
return status;
}
tBTM_STATUS BTM_BleStartExtAdvRestart(uint8_t con_handle)
tBTM_STATUS BTM_BleStartExtAdvRestart(uint16_t con_handle)
{
tBTM_BLE_EXT_ADV ext_adv;
uint8_t index = INVALID_VALUE;
uint8_t index = INVALID_VALUE_8BIT;
for (uint8_t i = 0; i < MAX_BLE_ADV_INSTANCE; i++)
{
if(adv_record[i].ter_con_handle == con_handle) {
@@ -798,7 +667,7 @@ tBTM_STATUS BTM_BlePeriodicAdvCfgDataRaw(UINT8 instance, UINT16 len, UINT8 *data
}
}
if ((err = btsnd_hcic_ble_set_periodic_adv_data(instance, operation, send_data_len, &data[data_offset])) != HCI_SUCCESS) {
if ((err = btsnd_hcic_ble_set_periodic_adv_data(instance, operation, send_data_len, (data == NULL)? NULL : &data[data_offset])) != HCI_SUCCESS) {
BTM_TRACE_ERROR("LE PA SetData: cmd err=0x%x", err);
status = BTM_HCI_ERROR | err;
break;
@@ -900,7 +769,7 @@ tBTM_STATUS BTM_BlePeriodicAdvCreateSync(tBTM_BLE_Periodic_Sync_Params *params)
sync_retry_cb.in_use = true;
#endif // #if (BLE_FEAT_CREATE_SYNC_RETRY_MAX > 0)
if (!btsnd_hcic_ble_periodic_adv_create_sync(option, params->sid, params->addr_type,
params->addr, params->sync_timeout, params->sync_cte_type)) {
params->addr, params->skip, params->sync_timeout, params->sync_cte_type)) {
BTM_TRACE_ERROR("LE PA CreateSync cmd failed");
status = BTM_ILLEGAL_VALUE;
#if (BLE_FEAT_CREATE_SYNC_RETRY_MAX > 0)
@@ -1097,7 +966,7 @@ tBTM_STATUS BTM_BleSetExtendedScanParams(tBTM_BLE_EXT_SCAN_PARAMS *params)
phy_count++;
}
if (BTM_BleUpdateOwnType(&params->own_addr_type, NULL) != 0 ) {
if (BTM_BleUpdateOwnType(&params->own_addr_type) != 0 ) {
status = BTM_ILLEGAL_VALUE;
BTM_TRACE_ERROR("LE UpdateOwnType err");
goto end;
@@ -1310,7 +1179,7 @@ void btm_ble_adv_set_terminated_evt(tBTM_BLE_ADV_TERMINAT *params)
if(params->status == 0x00) {
adv_record[params->adv_handle].ter_con_handle = params->conn_handle;
} else {
adv_record[params->adv_handle].ter_con_handle = INVALID_VALUE;
adv_record[params->adv_handle].ter_con_handle = INVALID_VALUE_16BIT;
adv_record[params->adv_handle].invalid = false;
}
adv_record[params->adv_handle].enabled = false;
@@ -1573,6 +1442,7 @@ void btm_ble_periodic_adv_sync_establish_evt(tBTM_BLE_PERIOD_ADV_SYNC_ESTAB *par
sync_retry_cb.params.sid,
sync_retry_cb.params.addr_type,
sync_retry_cb.params.addr,
sync_retry_cb.params.skip,
sync_retry_cb.params.sync_timeout,
sync_retry_cb.params.sync_cte_type)) {
/* Retry command sent successfully, wait for next event */
@@ -2110,6 +1980,7 @@ void btm_ble_cs_security_enable_cmd_status(UINT8 status)
tBTM_BLE_CS_SEC_ENABLE_CMPL_EVT cs_security_enable = {0};
if (status != HCI_SUCCESS) {
cs_security_enable.status = (status | BTM_HCI_ERROR);
cs_security_enable.conn_handle = 0xFFFF; // Invalid handle
BTM_ExtBleCallbackTrigger(BTM_BLE_GAP_CS_SECURITY_ENABLE_CMPL_EVT, (tBTM_BLE_5_GAP_CB_PARAMS *)&cs_security_enable);
}
}
components/bt/host/bluedroid/stack/btm/btm_ble_addr.c
+13 -12
View File
@@ -34,6 +34,7 @@
#if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE)
#include "btm_ble_int.h"
#include "stack/smp_api.h"
#include "bta_dm_gap.h"
/*******************************************************************************
@@ -50,6 +51,7 @@ static void btm_gen_resolve_paddr_cmpl(tSMP_ENC *p)
{
tBTM_LE_RANDOM_CB *p_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
BTM_TRACE_EVENT ("btm_gen_resolve_paddr_cmpl");
tBTM_STATUS status = BTM_SUCCESS;
if (p) {
/* set hash to be LSB of rpAddress */
@@ -62,10 +64,7 @@ static void btm_gen_resolve_paddr_cmpl(tSMP_ENC *p)
p_cb->exist_addr_bit |= BTM_BLE_GAP_ADDR_BIT_RESOLVABLE;
memcpy(p_cb->resolvale_addr, p_cb->private_addr, BD_ADDR_LEN);
if (p_cb->set_local_privacy_cback){
(*p_cb->set_local_privacy_cback)(BTM_SET_PRIVACY_SUCCESS);
p_cb->set_local_privacy_cback = NULL;
}
status = BTM_SET_PRIVACY_SUCCESS;
/* start a periodical timer to refresh random addr */
btu_stop_timer_oneshot(&p_cb->raddr_timer_ent);
@@ -79,11 +78,11 @@ static void btm_gen_resolve_paddr_cmpl(tSMP_ENC *p)
} else {
/* random address set failure */
BTM_TRACE_DEBUG("set random address failed");
if (p_cb->set_local_privacy_cback){
(*p_cb->set_local_privacy_cback)(BTM_SET_PRIVACY_FAIL);
p_cb->set_local_privacy_cback = NULL;
}
status = BTM_SET_PRIVACY_FAIL;
}
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params = {0};
cb_params.status = status;
BTM_BleLegacyGapOneshotFireIfArmed(BTM_BLE_LEGACY_GAP_SET_PRIVACY_EVT, &cb_params);
}
/*******************************************************************************
**
@@ -221,7 +220,7 @@ static void btm_ble_resolve_address_cmpl(void)
{
tBTM_LE_RANDOM_CB *p_mgnt_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
BTM_TRACE_EVENT ("btm_ble_resolve_address_cmpl p_mgnt_cb->p_dev_rec = 0x%08x", (uint32_t)p_mgnt_cb->p_dev_rec);
BTM_TRACE_EVENT ("btm_ble_resolve_address_cmpl p_mgnt_cb->p_dev_rec = 0x%08x", p_mgnt_cb->p_dev_rec ? (uint32_t)p_mgnt_cb->p_dev_rec : 0);
p_mgnt_cb->busy = FALSE;
@@ -405,7 +404,9 @@ void btm_ble_resolve_random_addr(BD_ADDR random_bda, tBTM_BLE_RESOLVE_CBACK *p_c
p_dev_rec = list_node(p_node);
p_mgnt_cb->p_dev_rec = p_dev_rec;
if (btm_ble_match_random_bda(p_dev_rec)) {
break;
// if matched, btm_ble_match_random_bda->btm_ble_proc_resolve_x->btm_ble_resolve_address_cmpl
p_mgnt_cb->p_dev_rec = NULL;
return;
}
p_mgnt_cb->p_dev_rec = NULL;
}
@@ -439,12 +440,12 @@ tBTM_SEC_DEV_REC *btm_find_dev_by_identity_addr(BD_ADDR bd_addr, UINT8 addr_type
context.free_check = FALSE;
p_node = list_foreach(btm_cb.p_sec_dev_rec_list, btm_find_sec_dev_in_list, &context);
if (p_node) {
p_dev_rec = list_node(p_node);
p_dev_rec = list_node(p_node);
if ((p_dev_rec->ble.static_addr_type & (~BLE_ADDR_TYPE_ID_BIT)) !=
(addr_type & (~BLE_ADDR_TYPE_ID_BIT))) {
BTM_TRACE_WARNING("%s find pseudo->random match with diff addr type: %d vs %d",
__func__, p_dev_rec->ble.static_addr_type, addr_type);
}
}
}
return p_dev_rec;
#endif
components/bt/host/bluedroid/stack/btm/btm_ble_bgconn.c
+47 -51
View File
@@ -33,6 +33,7 @@
#include "l2c_int.h"
#include "stack/hcimsgs.h"
//#include "bt_utils.h"
#include "bta_dm_gap.h"
#ifndef BTM_BLE_SCAN_PARAM_TOUT
#define BTM_BLE_SCAN_PARAM_TOUT 50 /* 50 seconds */
@@ -278,8 +279,11 @@ void btm_enq_wl_dev_operation(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_TYPE ad
** the white list.
**
*******************************************************************************/
BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type, tBTM_UPDATE_WHITELIST_CBACK *update_wl_cb)
BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type)
{
BOOLEAN result = TRUE;
UINT8 status;
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params;
#if (BLE_50_FEATURE_SUPPORT == TRUE)
if (addr_type > BLE_ADDR_RANDOM && addr_type != BLE_ADDR_ANONYMOUS)
#else
@@ -287,10 +291,9 @@ BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_
#endif // #if (BLE_50_FEATURE_SUPPORT == TRUE)
{
BTM_TRACE_ERROR("%s address type is error, unable to add device", __func__);
if (update_wl_cb){
update_wl_cb(HCI_ERR_ILLEGAL_PARAMETER_FMT,to_add);
}
return FALSE;
status = HCI_ERR_ILLEGAL_PARAMETER_FMT;
result = FALSE;
goto _wl_end;
}
BD_ADDR invalid_rand_addr_a, invalid_rand_addr_b;
@@ -319,10 +322,9 @@ BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_
// do nothing
} else {
BTC_TRACE_ERROR(" controller not support resolvable address");
if (update_wl_cb){
update_wl_cb(HCI_ERR_ILLEGAL_PARAMETER_FMT,to_add);
}
return FALSE;
status = HCI_ERR_ILLEGAL_PARAMETER_FMT;
result = FALSE;
goto _wl_end;
}
}
@@ -331,10 +333,9 @@ BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_
if (to_add && p_cb->white_list_avail_size == 0) {
BTM_TRACE_ERROR("%s Whitelist full, unable to add device", __func__);
if (update_wl_cb){
update_wl_cb(HCI_ERR_MEMORY_FULL,to_add);
}
return FALSE;
status = HCI_ERR_MEMORY_FULL;
result = FALSE;
goto _wl_end;
}
#if (BLE_GATT_BGCONN == TRUE)
@@ -342,27 +343,21 @@ BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_
/* added the bd_addr to the connection hash map queue */
if(!background_connection_add((bt_bdaddr_t *)bd_addr)) {
/* if the bd_addr already exist in whitelist, just callback return TRUE */
if (update_wl_cb){
update_wl_cb(HCI_SUCCESS,to_add);
}
return TRUE;
status = HCI_SUCCESS;
result = TRUE;
goto _wl_end;
}
} else {
/* remove the bd_addr to the connection hash map queue */
if(!background_connection_remove((bt_bdaddr_t *)bd_addr)){
/* if the bd_addr don't exist in whitelist, just callback return TRUE */
if (update_wl_cb){
update_wl_cb(HCI_SUCCESS,to_add);
}
return TRUE;
status = HCI_SUCCESS;
result = TRUE;
goto _wl_end;
}
}
#endif // (BLE_GATT_BGCONN == TRUE)
if (update_wl_cb){
//save add whitelist complete callback
p_cb->update_wl_cb = update_wl_cb;
}
/* stop the auto connect */
btm_suspend_wl_activity(p_cb->wl_state);
/* save the bd_addr to the btm_cb env */
@@ -370,6 +365,13 @@ BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_
/* save the ba_addr to the controller white list */
btm_wl_update_to_controller();
return TRUE;
_wl_end:
memset(&cb_params, 0, sizeof(cb_params));
cb_params.white_list_update.status = status;
cb_params.white_list_update.operation = to_add ? BTM_WHITELIST_ADD : BTM_WHITELIST_REMOVE;
BTM_LegacyBleCallbackTrigger(BTM_BLE_LEGACY_GAP_WHITE_LIST_UPDATE_EVT, &cb_params);
return result;
}
/*******************************************************************************
@@ -379,20 +381,14 @@ BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_
** Description This function clears the white list.
**
*******************************************************************************/
void btm_ble_clear_white_list (tBTM_UPDATE_WHITELIST_CBACK *update_wl_cb)
void btm_ble_clear_white_list (void)
{
tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
BTM_TRACE_EVENT ("btm_ble_clear_white_list");
btsnd_hcic_ble_clear_white_list();
#if (BLE_GATT_BGCONN == TRUE)
background_connections_clear();
#endif // (BLE_GATT_BGCONN == TRUE)
if (update_wl_cb) {
p_cb->update_wl_cb = update_wl_cb;
}
}
/*******************************************************************************
@@ -417,9 +413,10 @@ void btm_ble_clear_white_list_complete(UINT8 *p_data, UINT16 evt_len)
BTM_TRACE_ERROR ("%s failed, status 0x%x\n", __func__, status);
}
if (p_cb->update_wl_cb) {
(*p_cb->update_wl_cb)(status, BTM_WHITELIST_CLEAR);
}
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params = {0};
cb_params.white_list_update.status = status;
cb_params.white_list_update.operation = BTM_WHITELIST_CLEAR;
BTM_LegacyBleCallbackTrigger(BTM_BLE_LEGACY_GAP_WHITE_LIST_UPDATE_EVT, &cb_params);
}
/*******************************************************************************
@@ -462,7 +459,6 @@ void btm_ble_periodic_adv_list_init(UINT8 periodic_adv_size)
void btm_ble_add_2_white_list_complete(UINT8 status)
{
BTM_TRACE_EVENT("%s status=%d", __func__, status);
tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
if (status == HCI_SUCCESS) {
// --btm_cb.ble_ctr_cb.white_list_avail_size;
/*
@@ -475,10 +471,10 @@ void btm_ble_add_2_white_list_complete(UINT8 status)
*/
}
// add whitelist complete callback
if (p_cb->update_wl_cb)
{
(*p_cb->update_wl_cb)(status, BTM_WHITELIST_ADD);
}
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params = {0};
cb_params.white_list_update.status = status;
cb_params.white_list_update.operation = BTM_WHITELIST_ADD;
BTM_LegacyBleCallbackTrigger(BTM_BLE_LEGACY_GAP_WHITE_LIST_UPDATE_EVT, &cb_params);
}
@@ -491,16 +487,16 @@ void btm_ble_add_2_white_list_complete(UINT8 status)
*******************************************************************************/
void btm_ble_remove_from_white_list_complete(UINT8 *p, UINT16 evt_len)
{
tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
UNUSED(evt_len);
BTM_TRACE_EVENT ("%s status=%d", __func__, *p);
if (*p == HCI_SUCCESS) {
// ++btm_cb.ble_ctr_cb.white_list_avail_size;
}
if (p_cb->update_wl_cb)
{
(*p_cb->update_wl_cb)(*p, BTM_WHITELIST_REMOVE);
}
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params = {0};
cb_params.white_list_update.status = *p;
cb_params.white_list_update.operation = BTM_WHITELIST_REMOVE;
BTM_LegacyBleCallbackTrigger(BTM_BLE_LEGACY_GAP_WHITE_LIST_UPDATE_EVT, &cb_params);
}
#if (BLE_GATT_BGCONN == TRUE)
@@ -619,11 +615,11 @@ BOOLEAN btm_ble_start_select_conn(BOOLEAN start, tBTM_BLE_SEL_CBACK *p_select_cb
/* Process advertising packets only from devices in the white list */
/* use passive scan by default */
if (!btsnd_hcic_ble_set_scan_params(BTM_BLE_SCAN_MODE_PASS,
scan_int,
scan_win,
p_cb->addr_mgnt_cb.own_addr_type,
SP_ADV_WL)) {
if (btsnd_hcic_ble_set_scan_params(BTM_BLE_SCAN_MODE_PASS,
scan_int,
scan_win,
p_cb->addr_mgnt_cb.own_addr_type,
SP_ADV_WL) != HCI_SUCCESS) {
return FALSE;
}
#if (BLE_TOPOLOGY_CHECK == TRUE)
@@ -636,7 +632,7 @@ BOOLEAN btm_ble_start_select_conn(BOOLEAN start, tBTM_BLE_SEL_CBACK *p_select_cb
#if BLE_PRIVACY_SPT == TRUE
btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_SCAN);
#endif
if (!btsnd_hcic_ble_set_scan_enable(TRUE, TRUE)) { /* duplicate filtering enabled */
if (btsnd_hcic_ble_set_scan_enable(TRUE, TRUE) != HCI_SUCCESS) { /* duplicate filtering enabled */
return FALSE;
}
/* mark up inquiry status flag */
components/bt/host/bluedroid/stack/btm/btm_ble_gap.c
+194 -349
View File
File diff suppressed because it is too large Load Diff
components/bt/host/bluedroid/stack/btm/btm_ble_iso.c
+26 -22
View File
@@ -46,7 +46,7 @@ void btm_ble_iso_read_iso_tx_sync_complete(UINT8 *p)
if (cb_params.btm_read_tx_sync.status != HCI_SUCCESS) {
cb_params.btm_read_tx_sync.status = (BTM_HCI_ERROR | cb_params.btm_read_tx_sync.status);
}
cb_params.btm_read_tx_sync.conn_hdl = (cb_params.btm_read_tx_sync.conn_hdl & 0xEFF);
cb_params.btm_read_tx_sync.conn_hdl = (cb_params.btm_read_tx_sync.conn_hdl & 0x0FFF);
cb_params.btm_read_tx_sync.time_offset = (cb_params.btm_read_tx_sync.time_offset & 0xFFFFFF);
BTM_TRACE_DEBUG("read tx sync cmpl, status 0x%x conn_hdl 0x%x pkt_seq_num %d tx_time_stamp %ld time_offset %ld\n",
cb_params.btm_read_tx_sync.status, cb_params.btm_read_tx_sync.conn_hdl, cb_params.btm_read_tx_sync.pkt_seq_num,
@@ -162,7 +162,7 @@ void btm_ble_cis_request_evt(tBTM_BLE_CIS_REQUEST_CMPL *params)
}
#endif // #if (BLE_FEAT_ISO_CIG_PERIPHERAL_EN == TRUE)
#if (BLE_FEAT_ISO_BIG_BROCASTER_EN == TRUE)
#if (BLE_FEAT_ISO_BIG_BROADCASTER_EN == TRUE)
void btm_ble_big_create_cmpl_evt(tBTM_BLE_BIG_CREATE_CMPL *params)
{
BTM_TRACE_DEBUG("%s", __func__);
@@ -217,7 +217,7 @@ void btm_ble_big_terminate_cmpl_evt(tBTM_BLE_BIG_TERMINATE_CMPL *params)
BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_BIG_TERMINATE_COMPLETE_EVT, &cb_params);
}
#endif // #if (BLE_FEAT_ISO_BIG_BROCASTER_EN == TRUE)
#endif // #if (BLE_FEAT_ISO_BIG_BROADCASTER_EN == TRUE)
#if (BLE_FEAT_ISO_BIG_SYNCER_EN == TRUE)
void btm_ble_big_sync_estab_evt(tBTM_BLE_BIG_SYNC_ESTAB_CMPL *params)
@@ -315,7 +315,7 @@ void btm_ble_iso_data_path_update_complete(UINT16 opcode, UINT8 hci_status, UINT
BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_DATA_PATH_UPFATE_EVT, &cb_params);
}
#if (BLE_FEAT_ISO_BIG_BROCASTER_EN == TRUE)
#if (BLE_FEAT_ISO_BIG_BROADCASTER_EN == TRUE)
tBTM_STATUS BTM_BleBigCreate(uint8_t big_handle, uint8_t adv_handle, uint8_t num_bis,
uint32_t sdu_interval, uint16_t max_sdu, uint16_t max_transport_latency,
uint8_t rtn, uint8_t phy, uint8_t packing, uint8_t framing,
@@ -356,23 +356,11 @@ tBTM_STATUS BTM_BleBigCreateTest(uint8_t big_handle, uint8_t adv_handle, uint8_t
tBTM_STATUS BTM_BleBigTerminate(UINT8 big_handle, UINT8 reason)
{
tHCI_STATUS err = HCI_SUCCESS;
tBTM_STATUS status = BTM_SUCCESS;
tBTM_BLE_ISO_CB_PARAMS cb_params = {0};
if ((err = btsnd_hcic_ble_big_terminate(big_handle, reason)) != TRUE) {
BTM_TRACE_ERROR("LE PA SyncCancel, cmd err=0x%x", err);
status = BTM_HCI_ERROR | err;
}
if (status != BTM_SUCCESS) {
cb_params.status = status;
BTM_IsoBleCallbackTrigger(BTM_BLE_ISO_BIG_TERMINATE_COMPLETE_EVT, &cb_params);
}
return status;
// event will be triggered in command status and complete event
btsnd_hcic_ble_big_terminate(big_handle, reason);
return BTM_SUCCESS;
}
#endif // #if (BLE_FEAT_ISO_BIG_BROCASTER_EN == TRUE)
#endif // #if (BLE_FEAT_ISO_BIG_BROADCASTER_EN == TRUE)
#if (BLE_FEAT_ISO_BIG_SYNCER_EN == TRUE)
tBTM_STATUS BTM_BleBigSyncCreate(uint8_t big_handle, uint16_t sync_handle,
@@ -488,6 +476,11 @@ tBTM_STATUS BTM_BleSetCigParams(uint8_t cig_id, uint32_t sdu_int_c_to_p, uint32_
BTM_TRACE_ERROR("%s, cis_cnt %d exceeds BLE_ISO_CIS_MAX_COUNT %d", __func__, cis_cnt, BLE_ISO_CIS_MAX_COUNT);
return BTM_ILLEGAL_VALUE;
}
// HCI_LE_Set_CIG_Parameters param length = 15 + 9*cis_cnt (UINT8). Max 255 => cis_cnt <= 26.
if (cis_cnt > 26) {
BTM_TRACE_ERROR("%s, cis_cnt %d exceeds HCI transport limit", __func__, cis_cnt);
return BTM_ILLEGAL_VALUE;
}
if ((err = btsnd_hcic_ble_iso_set_cig_params(cig_id, sdu_int_c_to_p, sdu_int_p_to_c, worse_case_SCA, packing,
framing, mtl_c_to_p, mtl_p_to_c, cis_cnt, (struct ble_hci_le_cis_params *)cis_params)) != HCI_SUCCESS) {
@@ -508,6 +501,11 @@ tBTM_STATUS BTM_BleSetCigParamsTest(uint8_t cig_id, uint32_t sdu_int_c_to_p, uin
BTM_TRACE_ERROR("%s, cis_cnt %d exceeds BLE_ISO_CIS_MAX_COUNT %d", __func__, cis_cnt, BLE_ISO_CIS_MAX_COUNT);
return BTM_ILLEGAL_VALUE;
}
// HCI_LE_Set_CIG_Parameters_Test param length = 15 + 14*cis_cnt (UINT8). Max 255 => cis_cnt <= 17.
if (cis_cnt > 17) {
BTM_TRACE_ERROR("%s, cis_cnt %d exceeds HCI transport limit", __func__, cis_cnt);
return BTM_ILLEGAL_VALUE;
}
if ((err = btsnd_hcic_ble_iso_set_cig_params_test(cig_id, sdu_int_c_to_p, sdu_int_p_to_c,ft_c_to_p, ft_p_to_c, iso_interval,
worse_case_SCA, packing, framing, cis_cnt, (struct ble_hci_le_cis_params_test *)cis_params)) != HCI_SUCCESS) {
@@ -562,8 +560,14 @@ void btm_ble_accept_cis_req_cmd_status(tBTM_BLE_ISO_CB_PARAMS *cb_params)
tBTM_STATUS BTM_BleAcceptCisReq(uint16_t cis_handle)
{
btsnd_hcic_ble_iso_accept_cis_req(cis_handle);
return BTM_SUCCESS;
if (btsnd_hcic_ble_iso_accept_cis_req(cis_handle)) {
return BTM_SUCCESS;
}
// failed to send command
tBTM_BLE_ISO_CB_PARAMS cb_params = {0};
cb_params.status = BTM_NO_RESOURCES;
btm_ble_accept_cis_req_cmd_status(&cb_params);
return BTM_NO_RESOURCES;
}
tBTM_STATUS BTM_BleRejectCisReq(uint16_t cis_handle, uint8_t reason)
components/bt/host/bluedroid/stack/btm/btm_ble_privacy.c
+64 -41
View File
@@ -32,6 +32,7 @@
#include "btm_int.h"
#include "device/controller.h"
#include "stack/hcidefs.h"
#include "bta_dm_gap.h"
#define HCI_VENDOR_BLE_RPA_VSC (0x0155 | HCI_GRP_VENDOR_SPECIFIC)
@@ -49,6 +50,7 @@
#define BTM_BLE_META_CLEAR_IRK_LEN 1
#define BTM_BLE_META_READ_IRK_LEN 2
#define BTM_BLE_META_ADD_WL_ATTR_LEN 9
#define BTM_BLE_IRK_LIST_INVALID_INDEX 0xFF
#if CONTROLLER_RPA_LIST_ENABLE && BLE_SMP_ID_RESET_ENABLE
static bool is_deleting_zero_addr;
@@ -71,7 +73,14 @@ static bool is_deleting_zero_addr;
void btm_ble_enq_resolving_list_pending(BD_ADDR pseudo_bda, UINT8 op_code)
{
tBTM_BLE_RESOLVE_Q *p_q = &btm_cb.ble_ctr_cb.resolving_list_pend_q;
UINT8 max_size = controller_get_interface()->get_ble_resolving_list_max_size();
if (max_size <= 1) {
return;
}
if (((p_q->q_next + 1) % max_size) == p_q->q_pending) {
BTM_TRACE_ERROR("%s, resolving pending queue full\n", __func__);
return;
}
memcpy(p_q->resolve_q_random_pseudo[p_q->q_next], pseudo_bda, BD_ADDR_LEN);
p_q->resolve_q_action[p_q->q_next] = op_code;
p_q->q_next ++;
@@ -159,7 +168,7 @@ void btm_ble_clear_irk_index(UINT8 index)
**
** Description find the first available IRK list index
**
** Returns index from 0 ~ max (127 default)
** Returns index from 0 ~ max-1, or BTM_BLE_IRK_LIST_INVALID_INDEX if full
**
*******************************************************************************/
UINT8 btm_ble_find_irk_index(void)
@@ -180,7 +189,7 @@ UINT8 btm_ble_find_irk_index(void)
}
BTM_TRACE_ERROR ("%s failed, list full", __func__);
return i;
return BTM_BLE_IRK_LIST_INVALID_INDEX;
}
/*******************************************************************************
@@ -202,7 +211,13 @@ void btm_ble_update_resolving_list(BD_ADDR pseudo_bda, BOOLEAN add)
if (add) {
p_dev_rec->ble.in_controller_list |= BTM_RESOLVING_LIST_BIT;
if (!controller_get_interface()->supports_ble_privacy()) {
p_dev_rec->ble.resolving_list_index = btm_ble_find_irk_index();
UINT8 irk_index = btm_ble_find_irk_index();
if (irk_index != BTM_BLE_IRK_LIST_INVALID_INDEX) {
p_dev_rec->ble.resolving_list_index = irk_index;
} else {
p_dev_rec->ble.in_controller_list &= ~BTM_RESOLVING_LIST_BIT;
BTM_TRACE_WARNING("%s: IRK list full, cannot add to resolving list", __func__);
}
}
} else {
p_dev_rec->ble.in_controller_list &= ~BTM_RESOLVING_LIST_BIT;
@@ -244,10 +259,11 @@ void btm_ble_clear_resolving_list_complete(UINT8 *p, UINT16 evt_len)
if (controller_get_interface()->get_ble_resolving_list_max_size() == 0) {
btm_ble_resolving_list_init(irk_list_sz_max);
}
uint8_t irk_mask_size = (irk_list_sz_max % 8) ?
if (btm_cb.ble_ctr_cb.irk_list_mask != NULL) {
uint8_t irk_mask_size = (irk_list_sz_max % 8) ?
(irk_list_sz_max / 8 + 1) : (irk_list_sz_max / 8);
memset(btm_cb.ble_ctr_cb.irk_list_mask, 0, irk_mask_size);
memset(btm_cb.ble_ctr_cb.irk_list_mask, 0, irk_mask_size);
}
}
btm_cb.ble_ctr_cb.resolving_list_avail_size =
@@ -279,14 +295,10 @@ void btm_ble_add_resolving_list_entry_complete(UINT8 *p, UINT16 evt_len)
{
UINT8 status;
STREAM_TO_UINT8(status, p);
if (btm_cb.devcb.p_add_dev_to_resolving_list_cmpl_cb) {
tBTM_ADD_DEV_TO_RESOLVING_LIST_CMPL_CBACK *p_cb = btm_cb.devcb.p_add_dev_to_resolving_list_cmpl_cb;
if (p_cb) {
(*p_cb)(status);
}
} else {
BTM_TRACE_DEBUG("no resolving list callback");
}
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params = {0};
cb_params.status = status;
BTM_BleLegacyGapOneshotFireIfArmed(BTM_BLE_LEGACY_GAP_ADD_DEV_TO_RPA_LIST_EVT, &cb_params);
BTM_TRACE_DEBUG("%s status = %d", __func__, status);
@@ -424,21 +436,12 @@ void btm_ble_set_addr_resolution_enable_complete(UINT8 *p, UINT16 evt_len)
BTM_TRACE_DEBUG("%s status = %d", __func__, status);
tBTM_LE_RANDOM_CB *random_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;
if (!(random_cb && random_cb->set_local_privacy_cback)) {
return;
if (status != HCI_SUCCESS) {
BTM_TRACE_ERROR("set local privacy failed with status: 0x%x", status);
}
if (status == HCI_SUCCESS) {
random_cb->set_local_privacy_cback(BTM_SUCCESS);
return;
} else if (status == HCI_ERR_COMMAND_DISALLOWED) {
BTM_TRACE_ERROR("a non-connected activity is ongoing, such as advertising and scanning");
} else {
BTM_TRACE_ERROR("set local privacy failed");
}
random_cb->set_local_privacy_cback(BTM_ILLEGAL_VALUE);
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params = {0};
cb_params.status = (status == HCI_SUCCESS)? BTM_SUCCESS : BTM_ILLEGAL_VALUE;
BTM_BleLegacyGapOneshotFireIfArmed(BTM_BLE_LEGACY_GAP_SET_PRIVACY_EVT, &cb_params);
}
/*******************************************************************************
@@ -463,11 +466,9 @@ void btm_ble_set_rpa_timeout_complete(UINT8 *p, UINT16 evt_len)
BTM_TRACE_DEBUG("%s status = %d", __func__, status);
tBTM_SET_RPA_TIMEOUT_CMPL_CBACK *p_cb = btm_cb.devcb.p_ble_set_rpa_timeout_cmpl_cb;
if (p_cb) {
(*p_cb)(status);
}
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params = {0};
cb_params.status = status;
BTM_LegacyBleCallbackTrigger(BTM_BLE_LEGACY_GAP_RPA_TIMEOUT_EVT, &cb_params);
}
@@ -492,11 +493,9 @@ void btm_ble_set_privacy_mode_complete(UINT8 *p, UINT16 evt_len)
BTM_TRACE_DEBUG("%s status = 0x%x", __func__, status);
tBTM_SET_PRIVACY_MODE_CMPL_CBACK *p_cb = btm_cb.devcb.p_set_privacy_mode_cmpl_cb;
if (p_cb) {
(*p_cb)(status);
}
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params = {0};
cb_params.status = status;
BTM_LegacyBleCallbackTrigger(BTM_BLE_LEGACY_GAP_SET_PRIVACY_MODE_COMPLETE_EVT, &cb_params);
}
#if (0)
@@ -709,8 +708,9 @@ BOOLEAN btm_ble_suspend_resolving_list_activity(void)
#if (BLE_42_ADV_EN == TRUE)
if (p_ble_cb->inq_var.adv_mode == BTM_BLE_ADV_ENABLE) {
btm_ble_stop_adv();
p_ble_cb->suspended_rl_state |= BTM_BLE_RL_ADV;
if (btm_ble_stop_adv() == BTM_SUCCESS) {
p_ble_cb->suspended_rl_state |= BTM_BLE_RL_ADV;
}
}
#endif // #if (BLE_42_ADV_EN == TRUE)
@@ -1124,14 +1124,31 @@ void btm_ble_resolving_list_init(UINT8 max_irk_list_sz)
tBTM_BLE_RESOLVE_Q *p_q = &btm_cb.ble_ctr_cb.resolving_list_pend_q;
UINT8 irk_mask_size = (max_irk_list_sz % 8) ?
(max_irk_list_sz / 8 + 1) : (max_irk_list_sz / 8);
// free them if they are already allocated.
btm_ble_resolving_list_cleanup();
p_q->q_next = 0;
p_q->q_pending = 0;
if (max_irk_list_sz > 0) {
p_q->resolve_q_random_pseudo = (BD_ADDR *)osi_malloc(sizeof(BD_ADDR) * max_irk_list_sz);
if (p_q->resolve_q_random_pseudo == NULL) {
BTM_TRACE_ERROR("%s - Out of memory for random pseudo address", __FUNCTION__);
goto _mem_error;
}
p_q->resolve_q_action = (UINT8 *)osi_malloc(max_irk_list_sz);
if (p_q->resolve_q_action == NULL) {
BTM_TRACE_ERROR("%s - Out of memory for resolve action", __FUNCTION__);
goto _mem_error;
}
/* RPA offloading feature */
if (btm_cb.ble_ctr_cb.irk_list_mask == NULL) {
btm_cb.ble_ctr_cb.irk_list_mask = (UINT8 *)osi_malloc(irk_mask_size);
if (btm_cb.ble_ctr_cb.irk_list_mask == NULL) {
BTM_TRACE_ERROR("%s - Out of memory for IRK list mask", __FUNCTION__);
goto _mem_error;
}
}
BTM_TRACE_DEBUG ("%s max_irk_list_sz = %d", __func__, max_irk_list_sz);
@@ -1140,6 +1157,12 @@ void btm_ble_resolving_list_init(UINT8 max_irk_list_sz)
controller_get_interface()->set_ble_resolving_list_max_size(max_irk_list_sz);
btm_ble_clear_resolving_list();
btm_cb.ble_ctr_cb.resolving_list_avail_size = max_irk_list_sz;
return;
_mem_error:
btm_ble_resolving_list_cleanup();
btm_cb.ble_ctr_cb.resolving_list_avail_size = 0;
}
/*******************************************************************************
components/bt/host/bluedroid/stack/btm/btm_devctl.c
+33 -43
View File
@@ -42,6 +42,7 @@
#if BLE_INCLUDED == TRUE
#include "gatt_int.h"
#endif /* BLE_INCLUDED */
#include "bta_dm_gap.h"
//extern thread_t *bt_workqueue_thread;
@@ -769,7 +770,6 @@ void btm_vsc_complete (UINT8 *p, UINT16 opcode, UINT16 evt_len,
tBTM_CMPL_CB *p_vsc_cplt_cback)
{
#if (BLE_INCLUDED == TRUE)
tBTM_BLE_CB *ble_cb = &btm_cb.ble_ctr_cb;
switch(opcode) {
case HCI_VENDOR_BLE_UPDATE_DUPLICATE_EXCEPTIONAL_LIST: {
#if ((BLE_42_SCAN_EN == TRUE) || (BLE_50_EXTEND_SCAN_EN == TRUE))
@@ -777,34 +777,38 @@ void btm_vsc_complete (UINT8 *p, UINT16 opcode, UINT16 evt_len,
STREAM_TO_UINT8(status, p);
STREAM_TO_UINT8(subcode, p);
STREAM_TO_UINT32(length, p);
if(ble_cb && ble_cb->update_exceptional_list_cmp_cb) {
(*ble_cb->update_exceptional_list_cmp_cb)(status, subcode, length, p);
}
break;
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params = {0};
cb_params.exception_list_up.status = status;
cb_params.exception_list_up.subcode = subcode;
cb_params.exception_list_up.length = length;
cb_params.exception_list_up.device_info = p;
BTM_LegacyBleCallbackTrigger(BTM_BLE_LEGACY_GAP_EXCEPTION_LIST_UPDATE_EVT, &cb_params);
#endif // ((BLE_42_SCAN_EN == TRUE) || (BLE_50_EXTEND_SCAN_EN == TRUE))
break;
}
case HCI_VENDOR_BLE_CLEAR_ADV: {
uint8_t status;
STREAM_TO_UINT8(status, p);
if (ble_cb && ble_cb->inq_var.p_clear_adv_cb) {
ble_cb->inq_var.p_clear_adv_cb(status);
}
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params = {0};
cb_params.status = status;
BTM_LegacyBleCallbackTrigger(BTM_BLE_LEGACY_GAP_CLEAR_ADV_COMPLETE_EVT, &cb_params);
break;
}
case HCI_VENDOR_BLE_SET_CSA_SUPPORT: {
uint8_t status;
STREAM_TO_UINT8(status, p);
if (ble_cb && ble_cb->set_csa_support_cmpl_cb) {
ble_cb->set_csa_support_cmpl_cb(status);
}
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params = {0};
cb_params.status = status;
BTM_LegacyBleCallbackTrigger(BTM_BLE_LEGACY_GAP_SET_CSA_SUPPORT_COMPLETE_EVT, &cb_params);
break;
}
case HCI_VENDOR_BLE_SET_EVT_MASK: {
uint8_t status;
STREAM_TO_UINT8(status, p);
if (ble_cb && ble_cb->set_vendor_evt_mask_cmpl_cb) {
ble_cb->set_vendor_evt_mask_cmpl_cb(status);
}
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params = {0};
cb_params.status = status;
BTM_LegacyBleCallbackTrigger(BTM_BLE_LEGACY_GAP_SET_VENDOR_EVT_MASK_COMPLETE_EVT, &cb_params);
break;
}
default:
@@ -1286,20 +1290,12 @@ void btm_set_afh_channels_complete (UINT8 *p)
** Returns status of the operation
**
*******************************************************************************/
tBTM_STATUS BTM_BleSetChannels (BLE_CHANNELS channels, tBTM_CMPL_CB *p_ble_channels_cmpl_cback)
tBTM_STATUS BTM_BleSetChannels (BLE_CHANNELS channels)
{
if (!controller_get_interface()->get_is_ready()) {
return (BTM_DEV_RESET);
}
/* Check if set afh already in progress */
if (btm_cb.devcb.p_ble_channels_cmpl_cb) {
return (BTM_NO_RESOURCES);
}
/* Save callback */
btm_cb.devcb.p_ble_channels_cmpl_cb = p_ble_channels_cmpl_cback;
if (!btsnd_hcic_ble_set_channels (channels)) {
return (BTM_NO_RESOURCES);
}
@@ -1321,30 +1317,24 @@ tBTM_STATUS BTM_BleSetChannels (BLE_CHANNELS channels, tBTM_CMPL_CB *p_ble_chann
*******************************************************************************/
void btm_ble_set_channels_complete (UINT8 *p)
{
tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_ble_channels_cmpl_cb;
tBTM_BLE_SET_CHANNELS_RESULTS results;
tBTM_BLE_LEGACY_GAP_CB_PARAMS cb_params = {0};
btu_free_timer (&btm_cb.devcb.ble_channels_timer);
/* If there is a callback address for setting AFH channels, call it */
btm_cb.devcb.p_ble_channels_cmpl_cb = NULL;
STREAM_TO_UINT8 (cb_params.set_channels.hci_status, p);
if (p_cb) {
STREAM_TO_UINT8 (results.hci_status, p);
switch (results.hci_status){
case HCI_SUCCESS:
results.status = BTM_SUCCESS;
break;
case HCI_ERR_UNSUPPORTED_VALUE:
case HCI_ERR_ILLEGAL_PARAMETER_FMT:
results.status = BTM_ILLEGAL_VALUE;
break;
default:
results.status = BTM_ERR_PROCESSING;
break;
}
(*p_cb)(&results);
switch (cb_params.set_channels.hci_status){
case HCI_SUCCESS:
cb_params.set_channels.status = BTM_SUCCESS;
break;
case HCI_ERR_UNSUPPORTED_VALUE:
case HCI_ERR_ILLEGAL_PARAMETER_FMT:
cb_params.set_channels.status = BTM_ILLEGAL_VALUE;
break;
default:
cb_params.set_channels.status = BTM_ERR_PROCESSING;
break;
}
BTM_LegacyBleCallbackTrigger(BTM_BLE_LEGACY_GAP_SET_CHANNELS_COMPLETE_EVT, &cb_params);
}
#endif /// BLE_INCLUDED == TRUE
components/bt/host/bluedroid/stack/btm/btm_main.c
-2
View File
@@ -88,7 +88,6 @@ void btm_init (void)
btm_dev_init(); /* Device Manager Structures & HCI_Reset */
#if BLE_INCLUDED == TRUE
btm_ble_lock_init();
btm_ble_sem_init();
#if ((SMP_INCLUDED == TRUE) || (BLE_PRIVACY_SPT == TRUE))
btm_cb.addr_res_en = TRUE;
#endif // ((SMP_INCLUDED == TRUE) || (BLE_PRIVACY_SPT == TRUE))
@@ -131,7 +130,6 @@ void btm_free(void)
#endif
#if BLE_INCLUDED == TRUE
btm_ble_lock_free();
btm_ble_sem_free();
#endif
}
components/bt/host/bluedroid/stack/btm/btm_sco.c
+14 -1
View File
@@ -322,7 +322,7 @@ void btm_sco_check_send_pkts (UINT16 sco_inx)
}
}
void btm_sco_process_num_completed_pkts (UINT8 *p)
void btm_sco_process_num_completed_pkts (UINT8 *p, UINT8 evt_len)
{
UINT8 num_handles, xx;
UINT16 handle;
@@ -330,7 +330,20 @@ void btm_sco_process_num_completed_pkts (UINT8 *p)
UINT16 sco_inx;
tSCO_CB *p_cb = &btm_cb.sco_cb;
tSCO_CONN * p_ccb;
if (evt_len < 1) {
BTM_TRACE_ERROR ("btm_sco_process_num_completed_pkts: evt too short (len=%u)", evt_len);
return;
}
STREAM_TO_UINT8 (num_handles, p);
if (num_handles > (evt_len - 1) / 4) {
BTM_TRACE_ERROR ("btm_sco_process_num_completed_pkts: num_handles %u exceeds evt_len %u, truncating",
num_handles, evt_len);
num_handles = (evt_len - 1) / 4;
}
for (xx = 0; xx < num_handles; xx++) {
STREAM_TO_UINT16 (handle, p);
STREAM_TO_UINT16 (num_sent, p);
components/bt/host/bluedroid/stack/btm/btm_sec.c
+33 -32
View File
@@ -3491,6 +3491,12 @@ void btm_io_capabilities_rsp (UINT8 *p)
/* Allocate a new device record or reuse the oldest one */
p_dev_rec = btm_find_or_alloc_dev (evt_data.bd_addr);
if (p_dev_rec == NULL) {
BTM_TRACE_ERROR ("%s: no device record available\n", __FUNCTION__);
return;
}
/* If no security is in progress, this indicates incoming security */
if (btm_cb.pairing_state == BTM_PAIR_STATE_IDLE) {
memcpy (btm_cb.pairing_bda, evt_data.bd_addr, BD_ADDR_LEN);
@@ -4337,6 +4343,16 @@ void btm_sec_connected (UINT8 *bda, UINT16 handle, UINT8 status, UINT8 enc_mode)
/* There is no device record for new connection. Allocate one */
if (status == HCI_SUCCESS) {
p_dev_rec = btm_sec_alloc_dev (bda);
// no memory to allocate device record
if (p_dev_rec == NULL) {
if ((btm_cb.pairing_state != BTM_PAIR_STATE_IDLE) &&
(memcmp (btm_cb.pairing_bda, bda, BD_ADDR_LEN) == 0)) {
btm_sec_change_pairing_state(BTM_PAIR_STATE_IDLE);
}
BTM_TRACE_ERROR ("%s: no device record available\n", __FUNCTION__);
return;
}
} else {
/* If the device matches with stored paring address
* reset the paring state to idle */
@@ -4899,6 +4915,12 @@ void btm_sec_link_key_notification (UINT8 *p_bda, UINT8 *p_link_key, UINT8 key_t
void btm_sec_link_key_request (UINT8 *p_bda)
{
tBTM_SEC_DEV_REC *p_dev_rec = btm_find_or_alloc_dev (p_bda);
// no memory to allocate device record
if (p_dev_rec == NULL) {
btsnd_hcic_link_key_neg_reply (p_bda);
BTM_TRACE_ERROR ("%s: no device record available\n", __FUNCTION__);
return;
}
BTM_TRACE_EVENT ("btm_sec_link_key_request() BDA: %02x:%02x:%02x:%02x:%02x:%02x\n",
p_bda[0], p_bda[1], p_bda[2], p_bda[3], p_bda[4], p_bda[5]);
@@ -6011,13 +6033,22 @@ static BOOLEAN btm_sec_queue_encrypt_request (BD_ADDR bd_addr, tBT_TRANSPORT tra
tBTM_SEC_CALLBACK *p_callback, void *p_ref_data)
{
tBTM_SEC_QUEUE_ENTRY *p_e;
if (bd_addr == NULL) {
BTM_TRACE_ERROR("%s: bd_addr is NULL\n", __func__);
return FALSE;
}
p_e = (tBTM_SEC_QUEUE_ENTRY *)osi_malloc(sizeof(tBTM_SEC_QUEUE_ENTRY) + 1);
if (p_e) {
p_e->psm = 0; /* if PSM 0, encryption request */
p_e->p_callback = p_callback;
p_e->p_ref_data = (void *)(p_e + 1);
*(UINT8 *)p_e->p_ref_data = *(UINT8 *)(p_ref_data);
if (p_ref_data != NULL) {
p_e->p_ref_data = (void *)(p_e + 1);
*(UINT8 *)p_e->p_ref_data = *(UINT8 *)p_ref_data;
} else {
p_e->p_ref_data = NULL;
}
p_e->transport = transport;
memcpy(p_e->bd_addr, bd_addr, BD_ADDR_LEN);
fixed_queue_enqueue(btm_cb.sec_pending_q, p_e, FIXED_QUEUE_MAX_TIMEOUT);
@@ -6256,36 +6287,6 @@ BOOLEAN btm_sec_is_le_capable_dev (BD_ADDR bda)
return le_capable;
}
/*******************************************************************************
**
** Function btm_sec_find_bonded_dev
**
** Description Find a bonded device starting from the specified index
**
** Returns TRUE - found a bonded device
**
*******************************************************************************/
#if (BLE_INCLUDED == TRUE)
BOOLEAN btm_sec_find_bonded_dev (UINT8 start_idx, UINT16 *p_found_handle, tBTM_SEC_DEV_REC **p_rec)
{
BOOLEAN found = FALSE;
#if (SMP_INCLUDED== TRUE)
tBTM_SEC_DEV_REC *p_dev_rec;
list_node_t *p_node = NULL;
for (p_node = list_begin(btm_cb.p_sec_dev_rec_list); p_node; p_node = list_next(p_node)) {
p_dev_rec = list_node(p_node);
if (p_dev_rec->ble.key_type || (p_dev_rec->sec_flags & BTM_SEC_LINK_KEY_KNOWN)) {
*p_found_handle = p_dev_rec->hci_handle;
*p_rec = p_dev_rec;
break;
}
}
BTM_TRACE_DEBUG ("%s() found=%d\n", __func__, found);
#endif
return (found);
}
#endif ///BLE_INCLUDED == TRUE
/*******************************************************************************
**
** Function btm_sec_use_smp_br_chnl
components/bt/host/bluedroid/stack/btm/include/btm_ble_int.h
+5 -17
View File
@@ -157,9 +157,6 @@ typedef struct {
UINT16 adv_interval_max;
tBTM_BLE_AFP afp; /* advertising filter policy */
tBTM_BLE_SFP sfp; /* scanning filter policy */
tBTM_START_ADV_CMPL_CBACK *p_adv_cb;
tBTM_START_STOP_ADV_CMPL_CBACK *p_stop_adv_cb;
tBTM_CLEAR_ADV_CMPL_CBACK *p_clear_adv_cb;
tBLE_ADDR_TYPE adv_addr_type;
UINT8 evt_type;
UINT8 adv_mode;
@@ -206,7 +203,6 @@ typedef struct {
tBTM_BLE_ADDR_CBACK *p_generate_cback;
void *p;
TIMER_LIST_ENT raddr_timer_ent;
tBTM_SET_LOCAL_PRIVACY_CBACK *set_local_privacy_cback;
} tBTM_LE_RANDOM_CB;
#define BTM_BLE_MAX_BG_CONN_DEV_NUM 10
@@ -358,7 +354,6 @@ typedef struct {
/* periodic list information */
UINT8 periodic_adv_list_size;
#endif //#if (BLE_50_EXTEND_SYNC_EN == TRUE)
tBTM_UPDATE_WHITELIST_CBACK *update_wl_cb;
tBTM_BLE_WL_STATE wl_state;
fixed_queue_t *conn_pending_q;
@@ -386,13 +381,6 @@ typedef struct {
tBTM_BLE_STATE_MASK cur_states; /* bit mask of tBTM_BLE_STATE */
UINT8 link_count[2]; /* total link count master and slave*/
#endif // (BLE_TOPOLOGY_CHECK == TRUE)
#if ((BLE_42_SCAN_EN == TRUE) || (BLE_50_EXTEND_SCAN_EN == TRUE))
tBTM_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_CMPL_CBACK *update_exceptional_list_cmp_cb;
#endif // ((BLE_42_SCAN_EN == TRUE) || (BLE_50_EXTEND_SCAN_EN == TRUE))
#if (BLE_VENDOR_HCI_EN == TRUE)
tBTM_SET_CSA_SUPPORT_CMPL_CBACK *set_csa_support_cmpl_cb;
tBTM_SET_VENDOR_EVT_MASK_CBACK *set_vendor_evt_mask_cmpl_cb;
#endif // (BLE_VENDOR_HCI_EN == TRUE)
} tBTM_BLE_CB;
#ifdef __cplusplus
@@ -401,7 +389,7 @@ extern "C" {
void btm_ble_timeout(TIMER_LIST_ENT *p_tle);
#if (BLE_42_SCAN_EN == TRUE)
void btm_ble_process_adv_pkt (UINT8 *p);
void btm_ble_process_adv_pkt (UINT8 *p, UINT8 evt_len);
void btm_ble_process_adv_discard_evt(UINT8 *p);
void btm_ble_process_direct_adv_pkt (UINT8 *p);
bool btm_ble_adv_pkt_ready(void);
@@ -464,10 +452,10 @@ void btm_ble_update_sec_key_size(BD_ADDR bd_addr, UINT8 enc_key_size);
UINT8 btm_ble_read_sec_key_size(BD_ADDR bd_addr);
/* white list function */
BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type, tBTM_UPDATE_WHITELIST_CBACK *update_wl_cb);
BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr, tBLE_ADDR_TYPE addr_type);
void btm_update_scanner_filter_policy(tBTM_BLE_SFP scan_policy);
void btm_update_adv_filter_policy(tBTM_BLE_AFP adv_policy);
void btm_ble_clear_white_list (tBTM_UPDATE_WHITELIST_CBACK *update_wl_cb);
void btm_ble_clear_white_list (void);
void btm_read_white_list_size_complete(UINT8 *p, UINT16 evt_len);
void btm_ble_add_2_white_list_complete(UINT8 status);
void btm_ble_remove_from_white_list_complete(UINT8 *p, UINT16 evt_len);
@@ -578,10 +566,10 @@ void btm_ble_accept_cis_req_cmd_status(tBTM_BLE_ISO_CB_PARAMS *cb_params);
void btm_ble_create_cis_cmd_status(tBTM_BLE_ISO_CB_PARAMS *cb_params);
void btm_ble_iso_set_cig_params_complete(UINT8 *p);
#endif // #if (BLE_FEAT_ISO_CIG_CENTRAL_EN == TRUE)
#if (BLE_FEAT_ISO_BIG_BROCASTER_EN == TRUE)
#if (BLE_FEAT_ISO_BIG_BROADCASTER_EN == TRUE)
void btm_ble_big_create_cmpl_evt(tBTM_BLE_BIG_CREATE_CMPL *param);
void btm_ble_big_terminate_cmpl_evt(tBTM_BLE_BIG_TERMINATE_CMPL *params);
#endif // #if (BLE_FEAT_ISO_BIG_BROCASTER_EN == TRUE)
#endif // #if (BLE_FEAT_ISO_BIG_BROADCASTER_EN == TRUE)
#if (BLE_FEAT_ISO_BIG_SYNCER_EN == TRUE)
void btm_ble_big_sync_estab_evt(tBTM_BLE_BIG_SYNC_ESTAB_CMPL *params);
void btm_ble_big_sync_lost_evt(tBTM_BLE_BIG_SYNC_LOST_EVT *params);
components/bt/host/bluedroid/stack/btm/include/btm_int.h
+2 -26
View File
@@ -158,12 +158,10 @@ UINT8 conn_addr_type; /* local device address type for this co
BD_ADDR active_remote_addr; /* remote address used on this connection */
UINT8 active_remote_addr_type; /* local device address type for this connection */
BD_FEATURES peer_le_features; /* Peer LE Used features mask for the device */
tBTM_SET_PKT_DATA_LENGTH_CBACK *p_set_pkt_data_cback;
tBTM_LE_SET_PKT_DATA_LENGTH_PARAMS data_length_params;
BOOLEAN data_len_updating;
// data len update cmd cache
BOOLEAN data_len_waiting;
tBTM_SET_PKT_DATA_LENGTH_CBACK *p_set_data_len_cback_waiting;
UINT16 tx_len_waiting;
#endif
tBTM_PM_MCB *p_pm_mode_db; /* Pointer to PM mode control block per ACL link */
@@ -241,7 +239,7 @@ tBTM_CMPL_CB *p_write_iscan_tx_pwr_lvl_cmpl_cb; /* Callback function t
#endif // (CLASSIC_BT_INCLUDED == TRUE)
#if BLE_INCLUDED == TRUE
tBTM_CMPL_CB *p_ble_ch_map_cmpl_cb; /* Callback function to be called when */
BOOLEAN is_ch_map_cb;
#endif // #if BLE_INCLUDED == TRUE
/* read channel map function completes */
#if (CLASSIC_BT_INCLUDED == TRUE)
@@ -292,15 +290,6 @@ DEV_CLASS dev_class; /* Local device class
#if BLE_INCLUDED == TRUE
TIMER_LIST_ENT ble_channels_timer;
tBTM_CMPL_CB *p_ble_channels_cmpl_cb; /* Callback function to be called When
ble set host channels is completed */
tBTM_SET_RPA_TIMEOUT_CMPL_CBACK *p_ble_set_rpa_timeout_cmpl_cb; /* Callback function to be called When
ble set rpa timeout is completed */
tBTM_ADD_DEV_TO_RESOLVING_LIST_CMPL_CBACK *p_add_dev_to_resolving_list_cmpl_cb;
tBTM_SET_PRIVACY_MODE_CMPL_CBACK *p_set_privacy_mode_cmpl_cb;
tBTM_CMPL_CB *p_le_test_cmd_cmpl_cb; /* Callback function to be called when
LE test mode command has been sent successfully */
@@ -1053,14 +1042,6 @@ typedef struct {
#endif
} tBTM_CB;
typedef struct{
//connection parameters update callback
tBTM_UPDATE_CONN_PARAM_CBACK *update_conn_param_cb;
// setting packet data length callback
tBTM_SET_PKT_DATA_LENGTH_CBACK *set_pkt_data_length_cb;
}tBTM_CallbackFunc;
extern tBTM_CallbackFunc conn_callback_func;
/* security action for L2CAP COC channels */
#define BTM_SEC_OK 1
#define BTM_SEC_ENCRYPT 2 /* encrypt the link with current key */
@@ -1192,7 +1173,7 @@ void btm_pm_proc_ssr_evt (UINT8 *p, UINT16 evt_len);
void btm_sco_chk_pend_unpark (UINT8 hci_status, UINT16 hci_handle);
#if (BTM_SCO_HCI_INCLUDED == TRUE )
void btm_sco_process_num_bufs (UINT16 num_lm_sco_bufs);
void btm_sco_process_num_completed_pkts (UINT8 *p);
void btm_sco_process_num_completed_pkts (UINT8 *p, UINT8 evt_len);
#endif /* (BTM_SCO_HCI_INCLUDED == TRUE ) */
#else
#define btm_sco_chk_pend_unpark(hci_status, hci_handle)
@@ -1337,7 +1318,6 @@ void btm_sec_set_peer_sec_caps (tACL_CONN *p_acl_cb, tBTM_SEC_DEV_REC *p_dev_rec
#if BLE_INCLUDED == TRUE
void btm_sec_clear_ble_keys (tBTM_SEC_DEV_REC *p_dev_rec);
BOOLEAN btm_sec_find_bonded_dev (UINT8 start_idx, UINT16 *p_found_handle, tBTM_SEC_DEV_REC **p_rec);
BOOLEAN btm_sec_is_a_bonded_dev (BD_ADDR bda);
void btm_consolidate_dev(tBTM_SEC_DEV_REC *p_target_rec);
BOOLEAN btm_sec_is_le_capable_dev (BD_ADDR bda);
@@ -1366,10 +1346,6 @@ void btm_sec_clr_temp_auth_service (BD_ADDR bda);
void btm_ble_lock_init(void);
void btm_ble_sem_init(void);
void btm_ble_sem_free(void);
void btm_ble_lock_free(void);
void btm_sec_handle_remote_legacy_auth_cmp(UINT16 handle);