feedc0de/esp-idf
1
0
Fork 0
forked from espressif/esp-idf
Code Pull Requests Activity

fix(ble): fixed hci assertion issue when uart interference occurs

Browse Source 
(cherry picked from commit 84f0b39e4d)

Co-authored-by: zwl <zhaoweiliang@espressif.com>
This commit is contained in:
Zhao Wei Liang
2025-03-18 16:04:40 +08:00
parent 5cbd2a3877
commit abc7beac70
8 changed files with 138 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
components/bt/porting/transport/driver/common/hci_driver_h4.c
View File

@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@ -27,7 +27,9 @@
#include <string.h> #include <string.h>
#include <os/os.h> #include <os/os.h>
#include <os/os_mbuf.h> #include <os/os_mbuf.h>
#include "esp_hci_driver.h"
#include "common/hci_driver_h4.h" #include "common/hci_driver_h4.h"
#include "common/hci_driver_util.h"
#ifndef min #ifndef min
#define min(a, b) ((a) < (b) ? (a) : (b)) #define min(a, b) ((a) < (b) ? (a) : (b))
@ -62,9 +64,11 @@ hci_h4_frame_start(struct hci_h4_sm *rxs, uint8_t pkt_type)
case HCI_H4_ISO: case HCI_H4_ISO:
rxs->min_len = 4; rxs->min_len = 4;
break; break;
#if (!CONFIG_BT_CONTROLLER_ENABLED)
case HCI_H4_EVT: case HCI_H4_EVT:
rxs->min_len = 2; rxs->min_len = 2;
break; break;
#endif // (!CONFIG_BT_CONTROLLER_ENABLED)
default: default:
/* !TODO: Sync loss. Need to wait for reset. */ /* !TODO: Sync loss. Need to wait for reset. */
return -1; return -1;
@ -76,7 +80,7 @@ hci_h4_frame_start(struct hci_h4_sm *rxs, uint8_t pkt_type)
static int static int
hci_h4_ib_consume(struct hci_h4_input_buffer *ib, uint16_t len) hci_h4_ib_consume(struct hci_h4_input_buffer *ib, uint16_t len)
{ {
assert(ib->len >= len); HCI_TRANS_ASSERT((ib->len >= len), ib->len, len);
ib->buf += len; ib->buf += len;
ib->len -= len; ib->len -= len;
@ -113,7 +117,7 @@ hci_h4_sm_w4_header(struct hci_h4_sm *h4sm, struct hci_h4_input_buffer *ib)
switch (h4sm->pkt_type) { switch (h4sm->pkt_type) {
case HCI_H4_CMD: case HCI_H4_CMD:
assert(h4sm->allocs && h4sm->allocs->cmd); HCI_TRANS_ASSERT(h4sm->allocs && h4sm->allocs->cmd, 0, 0);
h4sm->buf = h4sm->allocs->cmd(); h4sm->buf = h4sm->allocs->cmd();
if (!h4sm->buf) { if (!h4sm->buf) {
return -1; return -1;
@ -124,7 +128,7 @@ hci_h4_sm_w4_header(struct hci_h4_sm *h4sm, struct hci_h4_input_buffer *ib)
break; break;
case HCI_H4_ACL: case HCI_H4_ACL:
assert(h4sm->allocs && h4sm->allocs->acl); HCI_TRANS_ASSERT(h4sm->allocs && h4sm->allocs->acl, 0, 0);
h4sm->om = h4sm->allocs->acl(); h4sm->om = h4sm->allocs->acl();
if (!h4sm->om) { if (!h4sm->om) {
return -1; return -1;
@ -145,7 +149,7 @@ hci_h4_sm_w4_header(struct hci_h4_sm *h4sm, struct hci_h4_input_buffer *ib)
} }
} }
assert(h4sm->allocs && h4sm->allocs->evt); HCI_TRANS_ASSERT(h4sm->allocs && h4sm->allocs->evt, 0, 0);
/* We can drop legacy advertising events if there's no free buffer in /* We can drop legacy advertising events if there's no free buffer in
* discardable pool. * discardable pool.
@ -167,7 +171,7 @@ hci_h4_sm_w4_header(struct hci_h4_sm *h4sm, struct hci_h4_input_buffer *ib)
break; break;
#endif // !CONFIG_BT_CONTROLLER_ENABLED #endif // !CONFIG_BT_CONTROLLER_ENABLED
case HCI_H4_ISO: case HCI_H4_ISO:
assert(h4sm->allocs && h4sm->allocs->iso); HCI_TRANS_ASSERT(h4sm->allocs && h4sm->allocs->iso, 0, 0);
h4sm->om = h4sm->allocs->iso(); h4sm->om = h4sm->allocs->iso();
if (!h4sm->om) { if (!h4sm->om) {
return -1; return -1;
@ -177,8 +181,7 @@ hci_h4_sm_w4_header(struct hci_h4_sm *h4sm, struct hci_h4_input_buffer *ib)
h4sm->exp_len = (get_le16(&h4sm->hdr[2]) & 0x7fff) + 4; h4sm->exp_len = (get_le16(&h4sm->hdr[2]) & 0x7fff) + 4;
break; break;
default: default:
assert(0); return -2;
break;
} }
return 0; return 0;
@ -193,19 +196,18 @@ hci_h4_sm_w4_payload(struct hci_h4_sm *h4sm,
int rc; int rc;
len = min(ib->len, h4sm->exp_len - h4sm->len); len = min(ib->len, h4sm->exp_len - h4sm->len);
switch (h4sm->pkt_type) { switch (h4sm->pkt_type) {
case HCI_H4_CMD: case HCI_H4_CMD:
#if (!CONFIG_BT_CONTROLLER_ENABLED)
case HCI_H4_EVT: case HCI_H4_EVT:
#endif // (!CONFIG_BT_CONTROLLER_ENABLED)
if (h4sm->buf) { if (h4sm->buf) {
memcpy(&h4sm->buf[h4sm->len], ib->buf, len); memcpy(&h4sm->buf[h4sm->len], ib->buf, len);
} }
break; break;
case HCI_H4_ACL: case HCI_H4_ACL:
case HCI_H4_ISO: case HCI_H4_ISO:
assert(h4sm->om); HCI_TRANS_ASSERT(h4sm->om, h4sm->pkt_type, len);
mbuf_len = OS_MBUF_PKTLEN(h4sm->om); mbuf_len = OS_MBUF_PKTLEN(h4sm->om);
rc = os_mbuf_append(h4sm->om, ib->buf, len); rc = os_mbuf_append(h4sm->om, ib->buf, len);
if (rc) { if (rc) {
@ -215,13 +217,11 @@ hci_h4_sm_w4_payload(struct hci_h4_sm *h4sm,
len = OS_MBUF_PKTLEN(h4sm->om) - mbuf_len; len = OS_MBUF_PKTLEN(h4sm->om) - mbuf_len;
h4sm->len += len; h4sm->len += len;
hci_h4_ib_consume(ib, len); hci_h4_ib_consume(ib, len);
return -1; return -1;
} }
break; break;
default: default:
assert(0); return -2;
break;
} }
h4sm->len += len; h4sm->len += len;
@ -240,51 +240,110 @@ hci_h4_sm_completed(struct hci_h4_sm *h4sm)
#if CONFIG_BT_CONTROLLER_ENABLED #if CONFIG_BT_CONTROLLER_ENABLED
case HCI_H4_CMD: case HCI_H4_CMD:
if (h4sm->buf) { if (h4sm->buf) {
assert(h4sm->frame_cb); HCI_TRANS_ASSERT(h4sm->frame_cb, 0, 0);
rc = h4sm->frame_cb(h4sm->pkt_type, h4sm->buf); rc = h4sm->frame_cb(h4sm->pkt_type, h4sm->buf);
assert(rc == 0); HCI_TRANS_ASSERT(rc == 0, rc, 0);
h4sm->buf = NULL; h4sm->buf = NULL;
} }
break; break;
case HCI_H4_ACL: case HCI_H4_ACL:
case HCI_H4_ISO: case HCI_H4_ISO:
if (h4sm->om) { if (h4sm->om) {
assert(h4sm->frame_cb); HCI_TRANS_ASSERT(h4sm->frame_cb, 0, 0);
rc = h4sm->frame_cb(h4sm->pkt_type, h4sm->om); rc = h4sm->frame_cb(h4sm->pkt_type, h4sm->om);
assert(rc == 0); HCI_TRANS_ASSERT(rc == 0, rc, 0);
h4sm->om = NULL; h4sm->om = NULL;
} }
break; break;
#else #else
case HCI_H4_CMD: case HCI_H4_CMD:
case HCI_H4_EVT:
if (h4sm->buf) { if (h4sm->buf) {
assert(h4sm->frame_cb); HCI_TRANS_ASSERT(h4sm->frame_cb, 0, 0);
rc = h4sm->frame_cb(h4sm->pkt_type, h4sm->buf); rc = h4sm->frame_cb(h4sm->pkt_type, h4sm->buf);
if (rc != 0) { if (rc != 0) {
ble_transport_free(h4sm->buf); HCI_TRANS_ASSERT(h4sm->frees && h4sm->frees->cmd, rc, (uint32_t)h4sm->frees);
h4sm->frees->cmd(h4sm->buf);
}
h4sm->buf = NULL;
}
break;
case HCI_H4_EVT:
if (h4sm->buf) {
HCI_TRANS_ASSERT(h4sm->frame_cb, 0, 0);
rc = h4sm->frame_cb(h4sm->pkt_type, h4sm->buf);
if (rc != 0) {
HCI_TRANS_ASSERT(h4sm->frees && h4sm->frees->evt, rc, (uint32_t)h4sm->frees);
h4sm->frees->evt(h4sm->buf);
} }
h4sm->buf = NULL; h4sm->buf = NULL;
} }
break; break;
case HCI_H4_ACL: case HCI_H4_ACL:
case HCI_H4_ISO:
if (h4sm->om) { if (h4sm->om) {
assert(h4sm->frame_cb); HCI_TRANS_ASSERT(h4sm->frame_cb, 0, 0);
rc = h4sm->frame_cb(h4sm->pkt_type, h4sm->om); rc = h4sm->frame_cb(h4sm->pkt_type, h4sm->om);
if (rc != 0) { if (rc != 0) {
os_mbuf_free_chain(h4sm->om); HCI_TRANS_ASSERT(h4sm->frees && h4sm->frees->acl, rc, (uint32_t)h4sm->frees);
h4sm->frees->acl(h4sm->om);
}
h4sm->om = NULL;
}
break;
case HCI_H4_ISO:
if (h4sm->om) {
HCI_TRANS_ASSERT(h4sm->frame_cb, 0, 0);
rc = h4sm->frame_cb(h4sm->pkt_type, h4sm->om);
if (rc != 0) {
HCI_TRANS_ASSERT(h4sm->frees && h4sm->frees->iso, rc, (uint32_t)h4sm->frees);
h4sm->frees->iso(h4sm->om);
} }
h4sm->om = NULL; h4sm->om = NULL;
} }
break; break;
#endif // CONFIG_BT_CONTROLLER_ENABLED #endif // CONFIG_BT_CONTROLLER_ENABLED
default: default:
assert(0); HCI_TRANS_ASSERT(0, h4sm->pkt_type, 0);
break; break;
} }
} }
static int
hci_h4_sm_free_buf(struct hci_h4_sm *h4sm)
{
switch (h4sm->pkt_type) {
case HCI_H4_CMD:
if (h4sm->buf) {
h4sm->frees->cmd(h4sm->buf);
h4sm->buf = NULL;
}
break;
#if (!CONFIG_BT_CONTROLLER_ENABLED)
case HCI_H4_EVT:
if (h4sm->buf) {
h4sm->frees->evt(h4sm->buf);
h4sm->buf = NULL;
}
break;
#endif // (!CONFIG_BT_CONTROLLER_ENABLED)
case HCI_H4_ACL:
if (h4sm->om) {
h4sm->frees->acl(h4sm->om);
h4sm->om = NULL;
}
break;
case HCI_H4_ISO:
if (h4sm->om) {
h4sm->frees->iso(h4sm->om);
h4sm->om = NULL;
}
break;
default:
break;
}
return 0;
}
int int
hci_h4_sm_rx(struct hci_h4_sm *h4sm, const uint8_t *buf, uint16_t len) hci_h4_sm_rx(struct hci_h4_sm *h4sm, const uint8_t *buf, uint16_t len)
{ {
@ -307,18 +366,18 @@ hci_h4_sm_rx(struct hci_h4_sm *h4sm, const uint8_t *buf, uint16_t len)
/* no break */ /* no break */
case HCI_H4_SM_W4_HEADER: case HCI_H4_SM_W4_HEADER:
rc = hci_h4_sm_w4_header(h4sm, &ib); rc = hci_h4_sm_w4_header(h4sm, &ib);
assert(rc >= 0);
if (rc) { if (rc) {
break; break;
} }
h4sm->state = HCI_H4_SM_W4_PAYLOAD; h4sm->state = HCI_H4_SM_W4_PAYLOAD;
/* no break */ /* no break */
case HCI_H4_SM_W4_PAYLOAD: case HCI_H4_SM_W4_PAYLOAD:
rc = hci_h4_sm_w4_payload(h4sm, &ib); rc = hci_h4_sm_w4_payload(h4sm, &ib);
assert(rc >= 0);
if (rc) { if (rc) {
break; break;
} }
h4sm->state = HCI_H4_SM_COMPLETED; h4sm->state = HCI_H4_SM_COMPLETED;
/* no break */ /* no break */
case HCI_H4_SM_COMPLETED: case HCI_H4_SM_COMPLETED:
@ -330,6 +389,11 @@ hci_h4_sm_rx(struct hci_h4_sm *h4sm, const uint8_t *buf, uint16_t len)
} }
} }
if (rc < 0) {
hci_h4_sm_free_buf(h4sm);
h4sm->state = HCI_H4_SM_W4_PKT_TYPE;
return -1;
}
/* Calculate consumed bytes /* Calculate consumed bytes
* *
* Note: we should always consume some bytes unless there is an oom error. * Note: we should always consume some bytes unless there is an oom error.
@ -339,7 +403,7 @@ hci_h4_sm_rx(struct hci_h4_sm *h4sm, const uint8_t *buf, uint16_t len)
*/ */
len = len - ib.len; len = len - ib.len;
if (len == 0) { if (len == 0) {
assert(rc < 0); HCI_TRANS_ASSERT((rc < 0), rc, ib.len);
return -1; return -1;
} }
@ -347,10 +411,11 @@ hci_h4_sm_rx(struct hci_h4_sm *h4sm, const uint8_t *buf, uint16_t len)
} }
void void
hci_h4_sm_init(struct hci_h4_sm *h4sm, const struct hci_h4_allocators *allocs, hci_h4_sm_init(struct hci_h4_sm *h4sm, const struct hci_h4_allocators *allocs, const struct hci_h4_frees *frees,
hci_h4_frame_cb *frame_cb) hci_h4_frame_cb *frame_cb)
{ {
memset(h4sm, 0, sizeof(*h4sm)); memset(h4sm, 0, sizeof(*h4sm));
h4sm->allocs = allocs; h4sm->allocs = allocs;
h4sm->frees = frees;
h4sm->frame_cb = frame_cb; h4sm->frame_cb = frame_cb;
} }

9
components/bt/porting/transport/driver/common/hci_driver_mem.c
View File

@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@ -53,3 +53,10 @@ const struct hci_h4_allocators s_hci_driver_mem_alloc = {
.acl = hci_driver_mem_acl_alloc, .acl = hci_driver_mem_acl_alloc,
.iso = hci_driver_mem_iso_alloc, .iso = hci_driver_mem_iso_alloc,
}; };
const struct hci_h4_frees s_hci_driver_mem_free = {
.cmd = r_ble_hci_trans_buf_free,
.evt = r_ble_hci_trans_buf_free,
.acl = os_mbuf_free_chain,
.iso = os_mbuf_free_chain,
};

13
components/bt/porting/transport/driver/common/hci_driver_util.c
View File

@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@ -96,7 +96,7 @@ hci_driver_util_tx_list_enqueue(hci_driver_data_type_t type, uint8_t *data, uint
hci_driver_util_tx_entry_t *tx_entry; hci_driver_util_tx_entry_t *tx_entry;
tx_entry = os_memblock_get(s_hci_driver_util_env.tx_entry_pool); tx_entry = os_memblock_get(s_hci_driver_util_env.tx_entry_pool);
assert(tx_entry != NULL); HCI_TRANS_ASSERT((tx_entry != NULL), 0, 0);
tx_entry->data_type = type; tx_entry->data_type = type;
tx_entry->data = data; tx_entry->data = data;
tx_entry->length = len; tx_entry->length = len;
@ -149,7 +149,7 @@ hci_driver_util_tx_list_dequeue(uint32_t max_tx_len, void **tx_data, bool *last_
*tx_data = &tx_entry->data[s_hci_driver_util_env.cur_tx_off]; *tx_data = &tx_entry->data[s_hci_driver_util_env.cur_tx_off];
} }
} else { } else {
assert(0); HCI_TRANS_ASSERT(0, tx_entry->data_type, data_len);
} }
/* If this is the last frame, inform the invoker not to call this API until the current data /* If this is the last frame, inform the invoker not to call this API until the current data
* has been completely sent. * has been completely sent.
@ -223,3 +223,10 @@ hci_driver_util_deinit(void)
memset(&s_hci_driver_util_env, 0, sizeof(hci_driver_util_env_t)); memset(&s_hci_driver_util_env, 0, sizeof(hci_driver_util_env_t));
} }
void
hci_driver_util_assert_check(const uint32_t ln, const char *fn, uint32_t param1, uint32_t param2)
{
ESP_LOGE(TAG, "hci driver assert: line %d in function %s, param: 0x%x, 0x%x", ln, fn, param1, param2);
}

3
components/bt/porting/transport/driver/uart/hci_driver_uart.c
View File

@ -111,6 +111,7 @@ hci_driver_uart_rx_task(void *p)
ESP_LOG_BUFFER_HEXDUMP(TAG, data, read_len, ESP_LOG_DEBUG); ESP_LOG_BUFFER_HEXDUMP(TAG, data, read_len, ESP_LOG_DEBUG);
ret = hci_h4_sm_rx(s_hci_driver_uart_env.h4_sm, data, read_len); ret = hci_h4_sm_rx(s_hci_driver_uart_env.h4_sm, data, read_len);
if (ret < 0) { if (ret < 0) {
ESP_LOGE(TAG, "parse rx data error! sm_state:%d\n", s_hci_driver_uart_env.h4_sm->state);
r_ble_ll_hci_ev_hw_err(ESP_HCI_SYNC_LOSS_ERR); r_ble_ll_hci_ev_hw_err(ESP_HCI_SYNC_LOSS_ERR);
} }
} }
@ -175,7 +176,7 @@ hci_driver_uart_init(hci_driver_forward_fn *cb)
memset(&s_hci_driver_uart_env, 0, sizeof(hci_driver_uart_env_t)); memset(&s_hci_driver_uart_env, 0, sizeof(hci_driver_uart_env_t));
s_hci_driver_uart_env.h4_sm = &s_hci_driver_uart_h4_sm; s_hci_driver_uart_env.h4_sm = &s_hci_driver_uart_h4_sm;
hci_h4_sm_init(s_hci_driver_uart_env.h4_sm, &s_hci_driver_mem_alloc, hci_driver_uart_h4_frame_cb); hci_h4_sm_init(s_hci_driver_uart_env.h4_sm, &s_hci_driver_mem_alloc, &s_hci_driver_mem_free, hci_driver_uart_h4_frame_cb);
rc = hci_driver_util_init(); rc = hci_driver_util_init();
if (rc) { if (rc) {

4
components/bt/porting/transport/driver/uart/hci_driver_uart_dma.c
View File

@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@ -609,7 +609,7 @@ hci_driver_uart_dma_init(hci_driver_forward_fn *cb)
memset(&s_hci_driver_uart_dma_env, 0, sizeof(hci_driver_uart_dma_env_t)); memset(&s_hci_driver_uart_dma_env, 0, sizeof(hci_driver_uart_dma_env_t));
s_hci_driver_uart_dma_env.h4_sm = &s_hci_driver_uart_h4_sm; s_hci_driver_uart_dma_env.h4_sm = &s_hci_driver_uart_h4_sm;
hci_h4_sm_init(s_hci_driver_uart_dma_env.h4_sm, &s_hci_driver_mem_alloc, hci_driver_uart_dma_h4_frame_cb); hci_h4_sm_init(s_hci_driver_uart_dma_env.h4_sm, &s_hci_driver_mem_alloc, &s_hci_driver_mem_free, hci_driver_uart_dma_h4_frame_cb);
rc = hci_driver_util_init(); rc = hci_driver_util_init();
if (rc) { if (rc) {

15
components/bt/porting/transport/include/common/hci_driver_h4.h
View File

@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@ -48,6 +48,17 @@ struct hci_h4_allocators {
extern const struct hci_h4_allocators hci_h4_allocs_from_ll; extern const struct hci_h4_allocators hci_h4_allocs_from_ll;
extern const struct hci_h4_allocators hci_h4_allocs_from_hs; extern const struct hci_h4_allocators hci_h4_allocs_from_hs;
typedef void (hci_h4_free_cmd)(uint8_t *buf);
typedef void (hci_h4_free_evt)(uint8_t *buf);
typedef int (hci_h4_free_acl)(struct os_mbuf *om);
typedef int (hci_h4_free_iso)(struct os_mbuf *om);
struct hci_h4_frees {
hci_h4_free_cmd *cmd;
hci_h4_free_acl *acl;
hci_h4_free_evt *evt;
hci_h4_free_iso *iso;
};
typedef int (hci_h4_frame_cb)(uint8_t pkt_type, void *data); typedef int (hci_h4_frame_cb)(uint8_t pkt_type, void *data);
struct hci_h4_sm { struct hci_h4_sm {
@ -63,11 +74,13 @@ struct hci_h4_sm {
}; };
const struct hci_h4_allocators *allocs; const struct hci_h4_allocators *allocs;
const struct hci_h4_frees *frees;
hci_h4_frame_cb *frame_cb; hci_h4_frame_cb *frame_cb;
}; };
void hci_h4_sm_init(struct hci_h4_sm *h4sm, void hci_h4_sm_init(struct hci_h4_sm *h4sm,
const struct hci_h4_allocators *allocs, const struct hci_h4_allocators *allocs,
const struct hci_h4_frees *frees,
hci_h4_frame_cb *frame_cb); hci_h4_frame_cb *frame_cb);
int hci_h4_sm_rx(struct hci_h4_sm *h4sm, const uint8_t *buf, uint16_t len); int hci_h4_sm_rx(struct hci_h4_sm *h4sm, const uint8_t *buf, uint16_t len);

2
components/bt/porting/transport/include/common/hci_driver_mem.h
View File

@ -21,5 +21,5 @@ struct os_mbuf *hci_driver_mem_iso_alloc(void);
struct os_mbuf *hci_driver_mem_iso_len_alloc(uint32_t len); struct os_mbuf *hci_driver_mem_iso_len_alloc(uint32_t len);
extern const struct hci_h4_allocators s_hci_driver_mem_alloc; extern const struct hci_h4_allocators s_hci_driver_mem_alloc;
extern const struct hci_h4_frees s_hci_driver_mem_free;
#endif // _H_HCI_DRIVER_MEM_ #endif // _H_HCI_DRIVER_MEM_

7
components/bt/porting/transport/include/common/hci_driver_util.h
View File

@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@ -15,4 +15,9 @@ void hci_driver_util_tx_list_enqueue(hci_driver_data_type_t type, uint8_t *data,
uint32_t hci_driver_util_tx_list_dequeue(uint32_t max_tx_len, void **tx_data, bool *last_frame); uint32_t hci_driver_util_tx_list_dequeue(uint32_t max_tx_len, void **tx_data, bool *last_frame);
void hci_driver_util_assert_check(const uint32_t ln, const char *fn, uint32_t param1, uint32_t param2);
#define HCI_TRANS_ASSERT(cond, p1, p2) \
if (!(cond)) { \
hci_driver_util_assert_check(__LINE__, __func__, p1, p2); \
}
#endif // _H_HCI_DRIVER_UTIL_ #endif // _H_HCI_DRIVER_UTIL_