pioduino/esp-idf
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(bt/bluedroid): Support BLE CTE in bluedroid host

Browse Source
This commit is contained in:
zhiweijian
2025-02-07 10:15:25 +08:00
parent 7128087646
commit fcad8b7ebd
22 changed files with 2316 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/bt/host/bluedroid/stack/btm/btm_ble_cte.c
+237
View File
@@ -0,0 +1,237 @@
/*
* SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "btm_int.h"
#include "stack/hcimsgs.h"
#include "osi/allocator.h"
#include "device/controller.h"
#include <string.h>
#include "l2c_int.h"
tBTM_BLE_CTE_CBACK ble_cte_cb;
extern void btm_ble_inter_set(bool extble_inter);
void BTM_BleCteRegisterCallback(tBTM_BLE_CTE_CBACK cb)
{
if (cb) {
ble_cte_cb = cb;
} else {
BTM_TRACE_ERROR("%s, register fail, the cb function is NULL.", __func__);
}
}
void BTM_CteBleCallbackTrigger(tBTM_BLE_5_GAP_EVENT event, tBTM_BLE_CTE_CB_PARAMS *params)
{
BTM_TRACE_DEBUG("%s event %x", __func__, event);
if(params && params->status == BTM_SUCCESS) {
btm_ble_inter_set(true);
}
if (ble_cte_cb) {
ble_cte_cb(event, params);
}
}
#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
tBTM_STATUS BTM_BleSetCteTransParams(uint8_t adv_handle, uint8_t cte_len, uint8_t cte_type, uint8_t cte_count, uint8_t switching_pattern_len, uint8_t *antenna_ids)
{
tHCI_STATUS err = HCI_SUCCESS;
tBTM_STATUS status = BTM_SUCCESS;
tBTM_BLE_CTE_CB_PARAMS cb_params = {0};
if ((err = btsnd_hcic_ble_set_connless_cte_trans_params(adv_handle, cte_len, cte_type, cte_count, switching_pattern_len, antenna_ids)) != HCI_SUCCESS) {
BTM_TRACE_ERROR("cte set trans params, cmd err=0x%x", err);
status = BTM_HCI_ERROR | err;
}
cb_params.cte_trans_params_cmpl.status = status;
BTM_CteBleCallbackTrigger(BTM_BLE_CTE_SET_TRANS_PARAMS_EVT, &cb_params);
return status;
}
tBTM_STATUS BTM_BleCteSetConnectionlessTransEnable(uint8_t adv_handle, uint8_t cte_en)
{
tHCI_STATUS err = HCI_SUCCESS;
tBTM_STATUS status = BTM_SUCCESS;
tBTM_BLE_CTE_CB_PARAMS cb_params = {0};
if ((err = btsnd_hcic_ble_set_connless_cte_enable(adv_handle, cte_en)) != HCI_SUCCESS) {
BTM_TRACE_ERROR("cte set trans enable, cmd err=0x%x", err);
status = BTM_HCI_ERROR | err;
}
cb_params.cte_trans_en_cmpl.status = status;
BTM_CteBleCallbackTrigger(BTM_BLE_CTE_SET_TRANS_ENABLE_EVT, &cb_params);
return status;
}
tBTM_STATUS BTM_BleCteSetConnectionlessIqSamplingEnable(uint16_t sync_handle, uint8_t sampling_en, uint8_t slot_dur,
uint8_t max_sampled_ctes, uint8_t switching_pattern_len, uint8_t *ant_ids)
{
tHCI_STATUS err = HCI_SUCCESS;
tBTM_STATUS status = BTM_SUCCESS;
tBTM_BLE_CTE_CB_PARAMS cb_params = {0};
if ((err = btsnd_hcic_ble_set_connless_iq_sampling_enable(sync_handle, sampling_en, slot_dur, max_sampled_ctes, switching_pattern_len, ant_ids)) != HCI_SUCCESS) {
BTM_TRACE_ERROR("cte set trans enable, cmd err=0x%x", err);
status = BTM_HCI_ERROR | err;
}
cb_params.cte_iq_samp_en_cmpl.status = status;
cb_params.cte_iq_samp_en_cmpl.sync_handle = sync_handle;
BTM_CteBleCallbackTrigger(BTM_BLE_CTE_SET_IQ_SAMP_ENABLE_EVT, &cb_params);
return status;
}
#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
tBTM_STATUS BTM_BleCteSetConnectionReceiveParams(uint16_t conn_handle, uint8_t sampling_en, uint8_t slot_dur,
uint8_t switching_pattern_len, uint8_t *ant_ids)
{
tHCI_STATUS err = HCI_SUCCESS;
tBTM_STATUS status = BTM_SUCCESS;
tBTM_BLE_CTE_CB_PARAMS cb_params = {0};
if ((err = btsnd_hcic_ble_set_conn_cte_receive_params(conn_handle, sampling_en, slot_dur, switching_pattern_len, ant_ids)) != HCI_SUCCESS) {
BTM_TRACE_ERROR("cte set conn recv params, cmd err=0x%x", err);
status = BTM_HCI_ERROR | err;
}
cb_params.cte_recv_params_cmpl.status = status;
cb_params.cte_recv_params_cmpl.conn_handle = conn_handle;
BTM_CteBleCallbackTrigger(BTM_BLE_CTE_SET_CONN_RECV_PARAMS_EVT, &cb_params);
return status;
}
tBTM_STATUS BTM_BleCteSetConnectionTransParams(uint16_t conn_handle, uint8_t cte_types, uint8_t switching_pattern_len, uint8_t *ant_ids)
{
tHCI_STATUS err = HCI_SUCCESS;
tBTM_STATUS status = BTM_SUCCESS;
tBTM_BLE_CTE_CB_PARAMS cb_params = {0};
if ((err = btsnd_hcic_ble_set_conn_cte_trans_params(conn_handle, cte_types, switching_pattern_len, ant_ids)) != HCI_SUCCESS) {
BTM_TRACE_ERROR("cte set conn trans params, cmd err=0x%x", err);
status = BTM_HCI_ERROR | err;
}
cb_params.cte_conn_trans_params_cmpl.status = status;
cb_params.cte_conn_trans_params_cmpl.conn_handle = conn_handle;
BTM_CteBleCallbackTrigger(BTM_BLE_CTE_SET_CONN_TRANS_PARAMS_EVT, &cb_params);
return status;
}
tBTM_STATUS BTM_BleCteSetConnectionRequestEnable(uint16_t conn_handle, uint8_t enable, uint16_t cte_req_int,
uint8_t req_cte_len, uint8_t req_cte_type)
{
tHCI_STATUS err = HCI_SUCCESS;
tBTM_STATUS status = BTM_SUCCESS;
tBTM_BLE_CTE_CB_PARAMS cb_params = {0};
if ((err = btsnd_hcic_ble_conn_cte_req_enable(conn_handle, enable, cte_req_int, req_cte_len, req_cte_type)) != HCI_SUCCESS) {
BTM_TRACE_ERROR("cte set conn req en, cmd err=0x%x", err);
status = BTM_HCI_ERROR | err;
}
cb_params.cte_conn_req_en_cmpl.status = status;
cb_params.cte_conn_req_en_cmpl.conn_handle = conn_handle;
BTM_CteBleCallbackTrigger(BTM_BLE_CTE_SET_CONN_REQ_ENABLE_EVT, &cb_params);
return status;
}
tBTM_STATUS BTM_BleCteSetConnectionRspEnable(uint16_t conn_handle, uint8_t enable)
{
tHCI_STATUS err = HCI_SUCCESS;
tBTM_STATUS status = BTM_SUCCESS;
tBTM_BLE_CTE_CB_PARAMS cb_params = {0};
if ((err = btsnd_hcic_ble_conn_cte_rsp_enable(conn_handle, enable)) != HCI_SUCCESS) {
BTM_TRACE_ERROR("cte set conn rsp en, cmd err=0x%x", err);
status = BTM_HCI_ERROR | err;
}
cb_params.cte_conn_rsp_en_cmpl.status = status;
cb_params.cte_conn_rsp_en_cmpl.conn_handle = conn_handle;
BTM_CteBleCallbackTrigger(BTM_BLE_CTE_SET_CONN_RSP_ENABLE_EVT, &cb_params);
return status;
}
#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
tBTM_STATUS BTM_BleCteReadAntInfor(void)
{
tHCI_STATUS err = HCI_SUCCESS;
tBTM_STATUS status = BTM_SUCCESS;
if ((err = btsnd_hcic_ble_read_antenna_info()) != HCI_SUCCESS) {
BTM_TRACE_ERROR("cte read ant information, cmd err=0x%x", err);
status = BTM_HCI_ERROR | err;
}
return status;
}
void btm_ble_cte_read_ant_infor_complete(UINT8 *p)
{
tBTM_BLE_CTE_CB_PARAMS cb_params = {0};
STREAM_TO_UINT8(cb_params.cte_read_ant_infor_cmpl.status, p);
STREAM_TO_UINT8(cb_params.cte_read_ant_infor_cmpl.supported_switching_sampling_rates, p);
STREAM_TO_UINT8(cb_params.cte_read_ant_infor_cmpl.num_ant, p);
STREAM_TO_UINT8(cb_params.cte_read_ant_infor_cmpl.max_switching_pattern_len, p);
STREAM_TO_UINT8(cb_params.cte_read_ant_infor_cmpl.max_cte_len, p);
if (cb_params.cte_read_ant_infor_cmpl.status != HCI_SUCCESS) {
cb_params.cte_read_ant_infor_cmpl.status = (BTM_HCI_ERROR | cb_params.cte_read_ant_infor_cmpl.status);
}
BTM_CteBleCallbackTrigger(BTM_BLE_CTE_READ_ANT_INFOR_EVT, &cb_params);
}
#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
void btm_ble_connless_iq_report_evt(tBTM_BLE_CTE_CONNLESS_IQ_REPORT_EVT *params)
{
if (!params) {
BTM_TRACE_ERROR("%s, Invalid params.", __func__);
return;
}
BTM_CteBleCallbackTrigger(BTM_BLE_CTE_CONNLESS_IQ_REPORT_EVT, (tBTM_BLE_CTE_CB_PARAMS *)params);
}
#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
void btm_ble_conn_iq_report_evt(tBTM_BLE_CTE_CONN_IQ_REPORT_EVT *params)
{
if (!params) {
BTM_TRACE_ERROR("%s, Invalid params.", __func__);
return;
}
BTM_CteBleCallbackTrigger(BTM_BLE_CTE_CONN_IQ_REPORT_EVT, (tBTM_BLE_CTE_CB_PARAMS *)params);
}
void btm_ble_cte_req_failed_evt(tBTM_BLE_CTE_REQ_FAILED_EVT *params)
{
if (!params) {
BTM_TRACE_ERROR("%s, Invalid params.", __func__);
return;
}
if (params->status != HCI_SUCCESS) {
params->status = (params->status | BTM_HCI_ERROR);
}
BTM_CteBleCallbackTrigger(BTM_BLE_CTE_REQUEST_FAILED_EVT, (tBTM_BLE_CTE_CB_PARAMS *)params);
}
#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
components/bt/host/bluedroid/stack/btm/include/btm_ble_int.h
+7
View File
@@ -591,6 +591,13 @@ void btm_ble_biginfo_adv_report_evt(tBTM_BLE_BIGINFO_ADV_REPORT_EVT *params);
#endif // #if (BLE_FEAT_ISO_BIG_SYNCER_EN == TRUE)
void btm_ble_iso_data_path_update_complete(UINT16 opcode, UINT8 hci_status, UINT16 conn_handle);
#endif // #if (BLE_FEAT_ISO_EN == TRUE)
#if (BLE_FEAT_CTE_EN == TRUE)
void btm_ble_cte_read_ant_infor_complete(UINT8 *p);
void btm_ble_connless_iq_report_evt(tBTM_BLE_CTE_CONNLESS_IQ_REPORT_EVT *params);
void btm_ble_conn_iq_report_evt(tBTM_BLE_CTE_CONN_IQ_REPORT_EVT *params);
void btm_ble_cte_req_failed_evt(tBTM_BLE_CTE_REQ_FAILED_EVT *params);
#endif // #if (BLE_FEAT_CTE_EN == TRUE)
/*
#ifdef __cplusplus
}
components/bt/host/bluedroid/stack/btu/btu_hcif.c
+113
View File
@@ -208,6 +208,17 @@ static void btu_ble_cis_disconnected(UINT16 handle, UINT8 reason);
#endif // #if (BLE_FEAT_ISO_EN == TRUE)
#if (BLE_FEAT_CTE_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
static void btu_ble_cte_connless_iq_report_evt(UINT8 *p);
#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
static void btu_ble_cte_conn_iq_report_evt(UINT8 *p);
static void btu_ble_cte_req_failed_evt(UINT8 *p);
#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
#endif // #if (BLE_FEAT_CTE_EN == TRUE)
#if (BLE_42_ADV_EN == TRUE)
extern osi_sem_t adv_enable_sem;
extern osi_sem_t adv_data_sem;
@@ -536,6 +547,23 @@ void btu_hcif_process_event (UNUSED_ATTR UINT8 controller_id, BT_HDR *p_msg)
break;
#endif // #if (BLE_FEAT_ISO_BIG_SYNCER_EN == TRUE)
#endif // #if (BLE_FEAT_ISO_EN == TRUE)
#if (BLE_FEAT_CTE_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
case HCI_BLE_CONNLESS_IQ_REPORT_EVT:
btu_ble_cte_connless_iq_report_evt(p);
break;
#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
case HCI_BLE_CONN_IQ_REPORT_EVT:
btu_ble_cte_conn_iq_report_evt(p);
break;
case HCI_BLE_CTE_REQUEST_FAILED_EVT:
btu_ble_cte_req_failed_evt(p);
break;
#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
#endif // #if (BLE_FEAT_CTE_EN == TRUE)
}
break;
#endif /* BLE_INCLUDED */
@@ -1325,6 +1353,11 @@ static void btu_hcif_hdl_command_complete (UINT16 opcode, UINT8 *p, UINT16 evt_l
#endif // #if (BLE_FEAT_ISO_CIG_PERIPHERAL_EN == TRUE)
#endif // #if (BLE_FEAT_ISO_EN == TRUE)
#if (BLE_FEAT_CTE_EN == TRUE)
case HCI_BLE_READ_ANT_INFOR:
btm_ble_cte_read_ant_infor_complete(p);
break;
#endif // #if (BLE_FEAT_CTE_EN == TRUE)
#endif /* (BLE_INCLUDED == TRUE) */
default: {
@@ -2872,6 +2905,86 @@ static void btu_ble_biginfo_adv_report_evt(UINT8 *p)
}
#endif // #if (BLE_FEAT_ISO_BIG_SYNCER_EN == TRUE)
#endif // #if (BLE_FEAT_ISO_EN == TRUE)
#if (BLE_FEAT_CTE_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
static void btu_ble_cte_connless_iq_report_evt(UINT8 *p)
{
tBTM_BLE_CTE_CONNLESS_IQ_REPORT_EVT connless_iq_rpt = {0};
if (!p) {
HCI_TRACE_ERROR("%s, Invalid params.", __func__);
return;
}
STREAM_TO_UINT16(connless_iq_rpt.sync_handle, p);
STREAM_TO_UINT8(connless_iq_rpt.channel_idx, p);
STREAM_TO_UINT16(connless_iq_rpt.rssi, p);
STREAM_TO_UINT8(connless_iq_rpt.rssi_ant_id, p);
STREAM_TO_UINT8(connless_iq_rpt.cte_type, p);
STREAM_TO_UINT8(connless_iq_rpt.slot_dur, p);
STREAM_TO_UINT8(connless_iq_rpt.pkt_status, p);
STREAM_TO_UINT16(connless_iq_rpt.periodic_evt_counter, p);
STREAM_TO_UINT8(connless_iq_rpt.sample_count, p);
for (uint8_t i = 0; i < connless_iq_rpt.sample_count; i++)
{
STREAM_TO_UINT8(connless_iq_rpt.i_sample[i], p);
STREAM_TO_UINT8(connless_iq_rpt.q_sample[i], p);
}
btm_ble_connless_iq_report_evt(&connless_iq_rpt);
}
#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
static void btu_ble_cte_conn_iq_report_evt(UINT8 *p)
{
tBTM_BLE_CTE_CONN_IQ_REPORT_EVT conn_iq_rpt = {0};
if (!p) {
HCI_TRACE_ERROR("%s, Invalid params.", __func__);
return;
}
STREAM_TO_UINT16(conn_iq_rpt.conn_handle, p);
STREAM_TO_UINT8(conn_iq_rpt.rx_phy, p);
STREAM_TO_UINT8(conn_iq_rpt.data_channel_idx, p);
STREAM_TO_UINT16(conn_iq_rpt.rssi, p);
STREAM_TO_UINT8(conn_iq_rpt.rssi_ant_id, p);
STREAM_TO_UINT8(conn_iq_rpt.cte_type, p);
STREAM_TO_UINT8(conn_iq_rpt.slot_dur, p);
STREAM_TO_UINT8(conn_iq_rpt.pkt_status, p);
STREAM_TO_UINT16(conn_iq_rpt.conn_evt_counter, p);
STREAM_TO_UINT8(conn_iq_rpt.sample_count, p);
for (uint8_t i = 0; i < conn_iq_rpt.sample_count; i++)
{
STREAM_TO_UINT8(conn_iq_rpt.i_sample[i], p);
STREAM_TO_UINT8(conn_iq_rpt.q_sample[i], p);
}
btm_ble_conn_iq_report_evt(&conn_iq_rpt);
}
static void btu_ble_cte_req_failed_evt(UINT8 *p)
{
tBTM_BLE_CTE_REQ_FAILED_EVT cte_req_failed = {0};
if (!p) {
HCI_TRACE_ERROR("%s, Invalid params.", __func__);
return;
}
STREAM_TO_UINT8(cte_req_failed.status, p);
STREAM_TO_UINT16(cte_req_failed.conn_handle, p);
btm_ble_cte_req_failed_evt(&cte_req_failed);
}
#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
#endif // #if (BLE_FEAT_CTE_EN == TRUE)
/**********************************************
** End of BLE Events Handler
***********************************************/
components/bt/host/bluedroid/stack/hcic/hciblecmds.c
+194
View File
@@ -2447,3 +2447,197 @@ UINT8 btsnd_hcic_ble_iso_read_iso_link_quality(uint16_t iso_handle)
}
#endif // #if (BLE_FEAT_ISO_EN == TRUE)
#if (BLE_FEAT_CTE_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
UINT8 btsnd_hcic_ble_set_connless_cte_trans_params(uint8_t adv_hdl, uint8_t cte_len, uint8_t cte_type,
uint8_t cte_cnt, uint8_t switching_pattern_len, uint8_t *antenna_ids)
{
BT_HDR *p;
UINT8 *pp;
HCI_TRACE_DEBUG("hci set connless cte trans: adv_hdl %d cte_len %d cte_type %d cte_cnt %d", adv_hdl, cte_len, cte_type, cte_cnt);
HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_SET_CONNLESS_CTE_TRANS_PARAMS + switching_pattern_len);
pp = (UINT8 *)(p + 1);
UINT16_TO_STREAM(pp, HCI_BLE_SET_CONNLESS_CTE_TRANS_PARAMS);
UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_SET_CONNLESS_CTE_TRANS_PARAMS + switching_pattern_len);
UINT8_TO_STREAM(pp, adv_hdl);
UINT8_TO_STREAM(pp, cte_len);
UINT8_TO_STREAM(pp, cte_type);
UINT8_TO_STREAM(pp, cte_cnt);
UINT8_TO_STREAM(pp, switching_pattern_len);
for (uint8_t i = 0; i < switching_pattern_len; i++)
{
UINT8_TO_STREAM(pp, antenna_ids[i]);
}
return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
}
UINT8 btsnd_hcic_ble_set_connless_cte_enable(uint8_t adv_hdl, uint8_t cte_en)
{
BT_HDR *p;
UINT8 *pp;
HCI_TRACE_DEBUG("hci set connect cte enable: adv_hdl %d cte_en %d", adv_hdl, cte_en);
HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_SET_CONNLESS_CTE_TRANS_ENABLE);
pp = (UINT8 *)(p + 1);
UINT16_TO_STREAM(pp, HCI_BLE_SET_CONNLESS_CTE_TRANS_ENABLE);
UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_SET_CONNLESS_CTE_TRANS_ENABLE);
UINT8_TO_STREAM(pp, adv_hdl);
UINT8_TO_STREAM(pp, cte_en);
return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
}
UINT8 btsnd_hcic_ble_set_connless_iq_sampling_enable(uint16_t sync_hdl, uint8_t sampling_en, uint8_t slot_dur,
uint8_t max_sampled_ctes, uint8_t switching_pattern_len, uint8_t *antenna_ids)
{
BT_HDR *p;
UINT8 *pp;
HCI_TRACE_DEBUG("hci enable IQ sampling: sync_hdl %d sampling_en %d slot_dur %d", sync_hdl, sampling_en, slot_dur);
HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_SET_CONNLESS_IQ_SAMPLING_ENABLE + switching_pattern_len);
pp = (UINT8 *)(p + 1);
UINT16_TO_STREAM(pp, HCI_BLE_SET_CONNLESS_IQ_SAMPLING_ENABLE);
UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_SET_CONNLESS_IQ_SAMPLING_ENABLE + switching_pattern_len);
UINT16_TO_STREAM(pp, sync_hdl);
UINT8_TO_STREAM(pp, sampling_en);
UINT8_TO_STREAM(pp, slot_dur);
UINT8_TO_STREAM(pp, max_sampled_ctes);
UINT8_TO_STREAM(pp, switching_pattern_len);
for (uint8_t i = 0; i < switching_pattern_len; i++)
{
UINT8_TO_STREAM(pp, antenna_ids[i]);
}
return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
}
#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
UINT8 btsnd_hcic_ble_set_conn_cte_receive_params(uint16_t conn_hdl, uint8_t sampling_en, uint8_t slot_dur,
uint8_t switching_pattern_len, uint8_t *antenna_ids)
{
BT_HDR *p;
UINT8 *pp;
HCI_TRACE_DEBUG("hci set connection cte receive params: conn_hdl %d sampling_en %d slot_dur %d", conn_hdl, sampling_en, slot_dur);
HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_SET_CONN_CTE_RECEIVE_PARAMS + switching_pattern_len);
pp = (UINT8 *)(p + 1);
UINT16_TO_STREAM(pp, HCI_BLE_SET_CONN_CTE_RECEIVE_PARAMS);
UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_SET_CONN_CTE_RECEIVE_PARAMS + switching_pattern_len);
UINT16_TO_STREAM(pp, conn_hdl);
UINT8_TO_STREAM(pp, sampling_en);
UINT8_TO_STREAM(pp, slot_dur);
UINT8_TO_STREAM(pp, switching_pattern_len);
for (uint8_t i = 0; i < switching_pattern_len; i++)
{
UINT8_TO_STREAM(pp, antenna_ids[i]);
}
return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
}
UINT8 btsnd_hcic_ble_set_conn_cte_trans_params(uint16_t conn_hdl, uint8_t cte_type, uint8_t switching_pattern_len, uint8_t *antenna_ids)
{
BT_HDR *p;
UINT8 *pp;
HCI_TRACE_DEBUG("hci set connection cte trans params: conn_hdl %d cte_type %d len %d", conn_hdl, cte_type, switching_pattern_len);
HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_SET_CONN_CTE_TRANS_PARAMS + switching_pattern_len);
pp = (UINT8 *)(p + 1);
UINT16_TO_STREAM(pp, HCI_BLE_SET_CONN_CTE_TRANS_PARAMS);
UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_SET_CONN_CTE_TRANS_PARAMS + switching_pattern_len);
UINT16_TO_STREAM(pp, conn_hdl);
UINT8_TO_STREAM(pp, cte_type);
UINT8_TO_STREAM(pp, switching_pattern_len);
for (uint8_t i = 0; i < switching_pattern_len; i++)
{
UINT8_TO_STREAM(pp, antenna_ids[i]);
}
return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
}
UINT8 btsnd_hcic_ble_conn_cte_req_enable(uint16_t conn_hdl, uint8_t enable, uint16_t cte_req_int, uint8_t req_cte_len, uint8_t req_cte_type)
{
BT_HDR *p;
UINT8 *pp;
HCI_TRACE_DEBUG("hci set connect cte request enable: conn_hdl %d enable %d cte_req_int %d req_cte_len %d req_cte_type %d", conn_hdl, enable, cte_req_int, req_cte_len, req_cte_type);
HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_CONN_CTE_REQ_ENABLE);
pp = (UINT8 *)(p + 1);
UINT16_TO_STREAM(pp, HCI_BLE_SET_CONN_CTE_REQ_ENABLE);
UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_CONN_CTE_REQ_ENABLE);
UINT16_TO_STREAM(pp, conn_hdl);
UINT8_TO_STREAM(pp, enable);
UINT16_TO_STREAM(pp, cte_req_int);
UINT8_TO_STREAM(pp, req_cte_len);
UINT8_TO_STREAM(pp, req_cte_type);
return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
}
UINT8 btsnd_hcic_ble_conn_cte_rsp_enable(uint16_t conn_hdl, uint8_t enable)
{
BT_HDR *p;
UINT8 *pp;
HCI_TRACE_DEBUG("hci set connect cte response enable: conn_hdl %d enable %d", conn_hdl, enable);
HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_CONN_CTE_RSP_ENABLE);
pp = (UINT8 *)(p + 1);
UINT16_TO_STREAM(pp, HCI_BLE_SET_CONN_CTE_RSP_ENABLE);
UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_CONN_CTE_RSP_ENABLE);
UINT16_TO_STREAM(pp, conn_hdl);
UINT8_TO_STREAM(pp, enable);
return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
}
#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
UINT8 btsnd_hcic_ble_read_antenna_info(void)
{
BT_HDR *p;
UINT8 *pp;
HCI_TRACE_DEBUG("hci read antenna information");
HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_READ_ANT_INFO);
pp = (UINT8 *)(p + 1);
UINT16_TO_STREAM(pp, HCI_BLE_READ_ANT_INFOR);
UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_READ_ANT_INFO);
return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
}
#endif // #if (BLE_FEAT_CTE_EN == TRUE)
components/bt/host/bluedroid/stack/include/stack/btm_ble_api.h
+142
View File
@@ -1106,6 +1106,25 @@ typedef UINT8 tBTM_BLE_5_GAP_EVENT;
typedef UINT8 tBTM_BLE_ISO_EVENT;
#endif // #if (BLE_FEAT_ISO_EN == TRUE)
#if (BLE_FEAT_CTE_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#define BTM_BLE_CTE_SET_TRANS_PARAMS_EVT 1
#define BTM_BLE_CTE_SET_TRANS_ENABLE_EVT 2
#define BTM_BLE_CTE_SET_IQ_SAMP_ENABLE_EVT 3
#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
#define BTM_BLE_CTE_SET_CONN_RECV_PARAMS_EVT 4
#define BTM_BLE_CTE_SET_CONN_TRANS_PARAMS_EVT 5
#define BTM_BLE_CTE_SET_CONN_REQ_ENABLE_EVT 6
#define BTM_BLE_CTE_SET_CONN_RSP_ENABLE_EVT 7
#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
#define BTM_BLE_CTE_READ_ANT_INFOR_EVT 8
#define BTM_BLE_CTE_CONNLESS_IQ_REPORT_EVT 9
#define BTM_BLE_CTE_CONN_IQ_REPORT_EVT 10
#define BTM_BLE_CTE_REQUEST_FAILED_EVT 11
typedef UINT8 tBTM_BLE_CTE_EVENT;
#endif // #if (BLE_FEAT_CTE_EN == TRUE)
#define BTM_BLE_EXT_ADV_DATA_COMPLETE 0x00
#define BTM_BLE_EXT_ADV_DATA_INCOMPLETE 0x01
@@ -1558,6 +1577,108 @@ typedef union {
typedef void (*tBTM_BLE_ISO_CBACK)(tBTM_BLE_ISO_EVENT event, tBTM_BLE_ISO_CB_PARAMS *params);
#endif // #if (BLE_FEAT_ISO_EN == TRUE)
#if (BLE_FEAT_CTE_EN == TRUE)
typedef struct {
UINT8 status;
} __attribute__((packed)) tBTM_BLE_CTE_SET_TRANS_PARAMS_CMPL;
typedef struct {
UINT8 status;
} __attribute__((packed)) tBTM_BLE_CTE_SET_TRANS_EN_CMPL;
typedef struct {
UINT8 status;
UINT16 sync_handle;
} __attribute__((packed)) tBTM_BLE_CTE_IQ_SAMP_EN_CMPL;
typedef struct {
UINT8 status;
UINT16 conn_handle;
} __attribute__((packed)) tBTM_BLE_CTE_CONN_RECV_PARAMS_CMPL;
typedef struct {
UINT8 status;
UINT16 conn_handle;
} __attribute__((packed)) tBTM_BLE_CTE_CONN_TRANS_PARAMS_CMPL;
typedef struct {
UINT8 status;
UINT16 conn_handle;
} __attribute__((packed)) tBTM_BLE_CTE_CONN_REQ_ENABLE_CMPL;
typedef struct {
UINT8 status;
UINT16 conn_handle;
} __attribute__((packed)) tBTM_BLE_CTE_CONN_RSP_ENABLE_CMPL;
typedef struct {
UINT8 status;
UINT8 supported_switching_sampling_rates;
UINT8 num_ant;
UINT8 max_switching_pattern_len;
UINT8 max_cte_len;
} __attribute__((packed)) tBTM_BLE_CTE_READ_ANT_INFOR_CMPL;
typedef struct {
UINT16 sync_handle;
UINT8 channel_idx;
INT16 rssi;
UINT8 rssi_ant_id;
UINT8 cte_type;
UINT8 slot_dur;
UINT8 pkt_status;
UINT16 periodic_evt_counter;
UINT8 sample_count;
UINT8 i_sample[0x52];
UINT8 q_sample[0x52];
} __attribute__((packed)) tBTM_BLE_CTE_CONNLESS_IQ_REPORT_EVT;
typedef struct {
UINT16 conn_handle;
UINT8 rx_phy;
UINT8 data_channel_idx;
INT16 rssi;
UINT8 rssi_ant_id;
UINT8 cte_type;
UINT8 slot_dur;
UINT8 pkt_status;
UINT16 conn_evt_counter;
UINT8 sample_count;
UINT8 i_sample[0x52];
UINT8 q_sample[0x52];
} __attribute__((packed)) tBTM_BLE_CTE_CONN_IQ_REPORT_EVT;
typedef struct {
UINT8 status;
UINT16 conn_handle;
} __attribute__((packed)) tBTM_BLE_CTE_REQ_FAILED_EVT;
typedef union {
UINT8 status;
#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
tBTM_BLE_CTE_SET_TRANS_PARAMS_CMPL cte_trans_params_cmpl;
tBTM_BLE_CTE_SET_TRANS_EN_CMPL cte_trans_en_cmpl;
tBTM_BLE_CTE_IQ_SAMP_EN_CMPL cte_iq_samp_en_cmpl;
#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
tBTM_BLE_CTE_CONN_RECV_PARAMS_CMPL cte_recv_params_cmpl;
tBTM_BLE_CTE_CONN_TRANS_PARAMS_CMPL cte_conn_trans_params_cmpl;
tBTM_BLE_CTE_CONN_REQ_ENABLE_CMPL cte_conn_req_en_cmpl;
tBTM_BLE_CTE_CONN_RSP_ENABLE_CMPL cte_conn_rsp_en_cmpl;
#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
tBTM_BLE_CTE_READ_ANT_INFOR_CMPL cte_read_ant_infor_cmpl;
#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
tBTM_BLE_CTE_CONNLESS_IQ_REPORT_EVT cte_connless_iq_rpt;
#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
tBTM_BLE_CTE_CONN_IQ_REPORT_EVT cte_conn_iq_rpt;
tBTM_BLE_CTE_REQ_FAILED_EVT cte_req_failed;
#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
} tBTM_BLE_CTE_CB_PARAMS;
typedef void (*tBTM_BLE_CTE_CBACK)(tBTM_BLE_CTE_EVENT event, tBTM_BLE_CTE_CB_PARAMS *params);
#endif // #if (BLE_FEAT_CTE_EN == TRUE)
typedef union {
UINT8 status;
tBTM_BLE_READ_PHY_CMPL read_phy;
@@ -3114,4 +3235,25 @@ tBTM_STATUS BTM_BleRejectCisReq(uint16_t cis_handle, uint8_t reason);
tBTM_STATUS BTM_BleDisconCis(uint16_t cis_handle, uint8_t reason);
#endif // #if (BLE_FEAT_ISO_CIG_EN == TRUE)
#endif // #if (BLE_FEAT_ISO_EN == TRUE)
#if (BLE_FEAT_CTE_EN == TRUE)
void BTM_BleCteRegisterCallback(tBTM_BLE_CTE_CBACK cb);
#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
tBTM_STATUS BTM_BleSetCteTransParams(uint8_t adv_handle, uint8_t cte_len, uint8_t cte_type, uint8_t cte_count, uint8_t switching_pattern_len, uint8_t *antenna_ids);
tBTM_STATUS BTM_BleCteSetConnectionlessTransEnable(uint8_t adv_handle, uint8_t cte_en);
tBTM_STATUS BTM_BleCteSetConnectionlessIqSamplingEnable(uint16_t sync_handle, uint8_t sampling_en, uint8_t slot_dur,
uint8_t max_sampled_ctes, uint8_t switching_pattern_len, uint8_t *ant_ids);
#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
tBTM_STATUS BTM_BleCteSetConnectionReceiveParams(uint16_t conn_handle, uint8_t sampling_en, uint8_t slot_dur,
uint8_t switching_pattern_len, uint8_t *ant_ids);
tBTM_STATUS BTM_BleCteSetConnectionTransParams(uint16_t conn_handle, uint8_t cte_types, uint8_t switching_pattern_len, uint8_t *ant_ids);
tBTM_STATUS BTM_BleCteSetConnectionRequestEnable(uint16_t conn_handle, uint8_t enable, uint16_t cte_req_int,
uint8_t req_cte_len, uint8_t req_cte_type);
tBTM_STATUS BTM_BleCteSetConnectionRspEnable(uint16_t conn_handle, uint8_t enable);
#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
tBTM_STATUS BTM_BleCteReadAntInfor(void);
#endif // #if (BLE_FEAT_CTE_EN == TRUE)
#endif
components/bt/host/bluedroid/stack/include/stack/hcidefs.h
+20
View File
@@ -390,6 +390,20 @@
#define HCI_BLE_WR_RF_PATH_COMPENSATION (0x004D | HCI_GRP_BLE_CMDS)
#endif // #if (BLE_50_FEATURE_SUPPORT == TRUE)
#define HCI_BLE_SET_PRIVACY_MODE (0x004E | HCI_GRP_BLE_CMDS)
#if (BLE_FEAT_CTE_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#define HCI_BLE_SET_CONNLESS_CTE_TRANS_PARAMS (0x0051 | HCI_GRP_BLE_CMDS)
#define HCI_BLE_SET_CONNLESS_CTE_TRANS_ENABLE (0x0052 | HCI_GRP_BLE_CMDS)
#define HCI_BLE_SET_CONNLESS_IQ_SAMPLING_ENABLE (0x0053 | HCI_GRP_BLE_CMDS)
#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
#define HCI_BLE_SET_CONN_CTE_RECEIVE_PARAMS (0x0054 | HCI_GRP_BLE_CMDS)
#define HCI_BLE_SET_CONN_CTE_TRANS_PARAMS (0x0055 | HCI_GRP_BLE_CMDS)
#define HCI_BLE_SET_CONN_CTE_REQ_ENABLE (0x0056 | HCI_GRP_BLE_CMDS)
#define HCI_BLE_SET_CONN_CTE_RSP_ENABLE (0x0057 | HCI_GRP_BLE_CMDS)
#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
#define HCI_BLE_READ_ANT_INFOR (0x0058 | HCI_GRP_BLE_CMDS)
#endif // #if (BLE_FEAT_CTE_EN == TRUE)
#if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE)
#define HCI_BLE_SET_PERIOD_ADV_RECV_ENABLE (0x0059 | HCI_GRP_BLE_CMDS)
#define HCI_BLE_PERIOD_ADV_SYNC_TRANS (0x005A | HCI_GRP_BLE_CMDS)
@@ -846,6 +860,12 @@
#define HCI_BLE_PERIOD_ADV_SYNC_TRANS_RECV_EVT 0x18
#endif // #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE)
#if (BLE_FEAT_CTE_EN == TRUE)
#define HCI_BLE_CONNLESS_IQ_REPORT_EVT 0x15
#define HCI_BLE_CONN_IQ_REPORT_EVT 0x16
#define HCI_BLE_CTE_REQUEST_FAILED_EVT 0x17
#endif // #if (BLE_FEAT_CTE_EN == TRUE)
#if (BLE_FEAT_ISO_EN == TRUE)
#define HCI_BLE_CIS_ESTABLISHED_V1_EVT 0x19
#define HCI_BLE_CIS_REQUEST_EVT 0x1A
components/bt/host/bluedroid/stack/include/stack/hcimsgs.h
+30
View File
@@ -1185,4 +1185,34 @@ UINT8 btsnd_hcic_ble_iso_read_tx_sync(uint16_t iso_hdl);
UINT8 btsnd_hcic_ble_iso_read_iso_link_quality(uint16_t iso_hdl);
#endif // #if (BLE_FEAT_ISO_EN == TRUE)
#if (BLE_FEAT_CTE_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#define HCIC_PARAM_SIZE_SET_CONNLESS_CTE_TRANS_PARAMS 5
#define HCIC_PARAM_SIZE_SET_CONNLESS_CTE_TRANS_ENABLE 2
#define HCIC_PARAM_SIZE_SET_CONNLESS_IQ_SAMPLING_ENABLE 6
#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
#define HCIC_PARAM_SIZE_SET_CONN_CTE_RECEIVE_PARAMS 5
#define HCIC_PARAM_SIZE_SET_CONN_CTE_TRANS_PARAMS 4
#define HCIC_PARAM_SIZE_CONN_CTE_REQ_ENABLE 7
#define HCIC_PARAM_SIZE_CONN_CTE_RSP_ENABLE 3
#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
#define HCIC_PARAM_SIZE_READ_ANT_INFO 0
#if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
UINT8 btsnd_hcic_ble_set_connless_cte_trans_params(uint8_t adv_hdl, uint8_t cte_len, uint8_t cte_type,
uint8_t cte_cnt, uint8_t switching_pattern_len, uint8_t *antenna_ids);
UINT8 btsnd_hcic_ble_set_connless_cte_enable(uint8_t adv_hdl, uint8_t cte_en);
UINT8 btsnd_hcic_ble_set_connless_iq_sampling_enable(uint16_t sync_hdl, uint8_t sampling_en, uint8_t slot_dur,
uint8_t max_sampled_ctes, uint8_t switching_pattern_len, uint8_t *antenna_ids);
#endif // #if (BLE_FEAT_CTE_CONNECTIONLESS_EN == TRUE)
#if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
UINT8 btsnd_hcic_ble_set_conn_cte_receive_params(uint16_t conn_hdl, uint8_t sampling_en, uint8_t slot_dur,
uint8_t switching_pattern_len, uint8_t *antenna_ids);
UINT8 btsnd_hcic_ble_set_conn_cte_trans_params(uint16_t conn_hdl, uint8_t cte_type, uint8_t switching_pattern_len, uint8_t *antenna_ids);
UINT8 btsnd_hcic_ble_conn_cte_req_enable(uint16_t conn_hdl, uint8_t enable, uint16_t cte_req_int, uint8_t req_cte_len, uint8_t req_cte_type);
UINT8 btsnd_hcic_ble_conn_cte_rsp_enable(uint16_t conn_hdl, uint8_t enable);
#endif // #if (BLE_FEAT_CTE_CONNECTION_EN == TRUE)
UINT8 btsnd_hcic_ble_read_antenna_info(void);
#endif // #if (BLE_FEAT_CTE_EN == TRUE)
#endif