blackbeard420/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf synced 2025-03-09 09:09:10 -04:00
Code Issues Projects Releases Wiki Activity

Merge branch 'feat/improve_bt_log_spi_output_interface' into 'master'

Browse Source 
Feat/improve bt log spi output interface

See merge request espressif/esp-idf!36912
This commit is contained in:
Island 2025-02-19 10:55:25 +08:00
commit 2c0381d23b
10 changed files with 355 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
components/bt/CMakeLists.txt
View File

@ -131,12 +131,9 @@ if(CONFIG_BT_ENABLED)
"common/osi/osi.c"
"common/osi/semaphore.c"
"porting/mem/bt_osi_mem.c"
"common/ble_log/ble_log_spi_out.c"
)
if(CONFIG_BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED)
list(APPEND srcs "common/ble_log/ble_log_spi_out.c")
endif()
# Host Bluedroid
if(CONFIG_BT_BLUEDROID_ENABLED)
@ -877,7 +874,7 @@ idf_component_register(SRCS "${srcs}"
PRIV_INCLUDE_DIRS "${priv_include_dirs}"
REQUIRES esp_timer esp_wifi
PRIV_REQUIRES nvs_flash soc esp_pm esp_phy esp_coex mbedtls esp_driver_uart vfs esp_ringbuf
esp_driver_spi
esp_driver_spi esp_driver_gpio
LDFRAGMENTS "${ldscripts}")
if(CONFIG_BT_ENABLED)

55
components/bt/common/Kconfig.in
View File

@ -4,3 +4,58 @@ config BT_ALARM_MAX_NUM
help
This option decides the maximum number of alarms which
could be used by Bluetooth host.
config BT_BLE_LOG_SPI_OUT_ENABLED
bool "Output ble logs to SPI bus (Experimental)"
default n
help
Output ble logs to SPI bus
config BT_BLE_LOG_SPI_OUT_QUEUE_SIZE
int "Number of ble log async SPI output queues"
depends on BT_BLE_LOG_SPI_OUT_ENABLED
default 4
help
The number of ble log async SPI output queues
config BT_BLE_LOG_SPI_OUT_TRANS_BUF_SIZE
int "Size of ble log async SPI output transaction buffer size"
depends on BT_BLE_LOG_SPI_OUT_ENABLED
default 2048
help
The size of ble log async SPI output transaction buffer size
config BT_BLE_LOG_SPI_OUT_MOSI_IO_NUM
int "GPIO number of SPI MOSI"
depends on BT_BLE_LOG_SPI_OUT_ENABLED
default 0
help
GPIO number of SPI MOSI
config BT_BLE_LOG_SPI_OUT_SCLK_IO_NUM
int "GPIO number of SPI SCLK"
depends on BT_BLE_LOG_SPI_OUT_ENABLED
default 1
help
GPIO number of SPI SCLK
config BT_BLE_LOG_SPI_OUT_CS_IO_NUM
int "GPIO number of SPI CS"
depends on BT_BLE_LOG_SPI_OUT_ENABLED
default 2
help
GPIO number of SPI CS
config BT_BLE_LOG_SPI_OUT_TS_SYNC_ENABLED
bool "Enable ble log & logic analyzer log time sync"
depends on BT_BLE_LOG_SPI_OUT_ENABLED
default y
help
Enable ble log & logic analyzer log time sync
config BT_BLE_LOG_SPI_OUT_SYNC_IO_NUM
int "GPIO number of SYNC IO"
depends on BT_BLE_LOG_SPI_OUT_TS_SYNC_ENABLED
default 3
help
GPIO number of SYNC IO

331
components/bt/common/ble_log/ble_log_spi_out.c
View File

@ -5,12 +5,16 @@
*/
#include "ble_log/ble_log_spi_out.h"
#if CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED
// Private defines
#define SPI_OUT_BUS SPI2_HOST
#define SPI_OUT_TAIL 0xAA
#define SPI_OUT_FLUSHOUT_TIMEOUT (1000 * 1000)
#define SPI_OUT_TS_SYNC_TIMEOUT (1000 * 1000)
// Private typedefs
typedef struct spi_out_trans
{
typedef struct spi_out_trans {
spi_transaction_t trans;
struct spi_out_trans *next;
} spi_out_trans_t;
@ -20,20 +24,38 @@ static spi_device_handle_t spi_handle = NULL;
static spi_out_trans_t *trans_head = NULL;
static SemaphoreHandle_t mutex_handle = NULL;
static bool spi_out_inited = false;
static esp_timer_handle_t flushout_timer_handle = NULL;
static uint32_t loss_frame_cnt = 0;
#if CONFIG_BT_BLE_LOG_SPI_OUT_TS_SYNC_ENABLED
static bool sync_io_level = false;
static esp_timer_handle_t ts_sync_timer_handle = NULL;
#endif // CONFIG_BT_BLE_LOG_SPI_OUT_TS_SYNC_ENABLED
// Private function declarations
static void spi_out_init_trans(void);
static void spi_out_deinit_trans(void);
static void spi_out_recycle_trans(uint32_t ms_to_wait);
static void spi_out_append_trans(void);
static int spi_out_write(const uint8_t *addr, uint16_t len);
static void esp_timer_cb_flushout(void);
static void esp_timer_cb_ts_sync(void);
#if CONFIG_BT_BLE_LOG_SPI_OUT_TS_SYNC_ENABLED
#if defined(CONFIG_IDF_TARGET_ESP32H2) || defined(CONFIG_IDF_TARGET_ESP32C6)
extern uint32_t r_ble_lll_timer_current_tick_get(void);
#endif // CONFIG_IDF_TARGET_ESP32H2 || CONFIG_IDF_TARGET_ESP32C6
#if defined(CONFIG_IDF_TARGET_ESP32C2)
extern uint32_t r_os_cputime_get32(void);
#endif // CONFIG_IDF_TARGET_ESP32C2
#endif // CONFIG_BT_BLE_LOG_SPI_OUT_TS_SYNC_ENABLED
// Private functions
static void spi_out_init_trans(void)
{
for (int i = 0; i < CONFIG_BT_LE_CONTROLLER_LOG_SPI_OUT_QUEUE_SIZE; i++)
{
for (int i = 0; i < CONFIG_BT_BLE_LOG_SPI_OUT_QUEUE_SIZE; i++) {
// Allocate memory for SPI transaction
uint8_t *buf = (uint8_t *)spi_bus_dma_memory_alloc(SPI_OUT_BUS, CONFIG_BT_LE_CONTROLLER_LOG_SPI_OUT_TRANS_BUF_SIZE, 0);
uint8_t *buf = (uint8_t *)spi_bus_dma_memory_alloc(SPI_OUT_BUS, CONFIG_BT_BLE_LOG_SPI_OUT_TRANS_BUF_SIZE, 0);
assert(buf);
// Initialize new trans
@ -57,8 +79,7 @@ static void spi_out_deinit_trans(void)
// Release memory
spi_out_trans_t *next;
while (trans_head != NULL)
{
while (trans_head != NULL) {
next = trans_head->next;
free((uint8_t *)trans_head->trans.tx_buffer);
free(trans_head);
@ -68,52 +89,159 @@ static void spi_out_deinit_trans(void)
return;
}
// CRITICAL: Do not recycle trans when trans_head is not empty!
IRAM_ATTR static void spi_out_recycle_trans(uint32_t ms_to_wait)
{
// Try to recycle transaction
spi_transaction_t *ret_trans;
spi_out_trans_t *recycled_trans;
while (ESP_OK == spi_device_get_trans_result(spi_handle, &ret_trans, pdMS_TO_TICKS(ms_to_wait)))
{
while (ESP_OK == spi_device_get_trans_result(spi_handle, &ret_trans, pdMS_TO_TICKS(ms_to_wait))) {
recycled_trans = __containerof(ret_trans, spi_out_trans_t, trans);
recycled_trans->next = trans_head;
trans_head = recycled_trans;
trans_head->trans.length = 0;
trans_head->trans.rxlength = 0;
}
}
IRAM_ATTR static void spi_out_append_trans(void)
{
// Stop flushout timer
esp_timer_stop(flushout_timer_handle);
// Transaction head shall not be NULL for appending
assert(trans_head);
if (trans_head) {
// Detach transaction head
spi_out_trans_t *trans_to_append = trans_head;
trans_head = trans_head->next;
trans_to_append->next = NULL;
// Detach transaction head
spi_out_trans_t *trans_to_append = trans_head;
trans_head = trans_head->next;
trans_to_append->next = NULL;
// CRITICAL: Length unit conversion from bytes to bits
trans_to_append->trans.length *= 8;
assert(ESP_OK == spi_device_queue_trans(spi_handle, &trans_to_append->trans, 0));
// CRITICAL: Length unit conversion from bytes to bits
trans_to_append->trans.length *= 8;
ESP_ERROR_CHECK(spi_device_queue_trans(spi_handle, &trans_to_append->trans, 0));
}
// Try to recycle trans
spi_out_recycle_trans(0);
// Restart flushout timer
esp_timer_start_once(flushout_timer_handle, SPI_OUT_FLUSHOUT_TIMEOUT);
}
IRAM_ATTR static int spi_out_write(const uint8_t *addr, uint16_t len)
{
// Recycle trans if free buffer list is empty
if (!trans_head) {
spi_out_recycle_trans(0);
}
// Copy user data to buffer
uint16_t copy_buf_len;
uint16_t data_left_len = len;
uint16_t empty_buf_len = CONFIG_BT_BLE_LOG_SPI_OUT_TRANS_BUF_SIZE - trans_head->trans.length;
while (data_left_len) {
// There shall always be available buffer in free buffer list during write operation
if (!trans_head) {
return -1;
}
// Copy data to buffer and update length
copy_buf_len = (data_left_len > empty_buf_len) ? empty_buf_len : data_left_len;
memcpy((uint8_t *)trans_head->trans.tx_buffer + trans_head->trans.length, addr + (len - data_left_len), copy_buf_len);
trans_head->trans.length += copy_buf_len;
data_left_len -= copy_buf_len;
// If buffer is full, append transaction and reset buffer length
if (trans_head->trans.length == CONFIG_BT_BLE_LOG_SPI_OUT_TRANS_BUF_SIZE) {
spi_out_append_trans();
empty_buf_len = CONFIG_BT_BLE_LOG_SPI_OUT_TRANS_BUF_SIZE;
}
}
return 0;
}
// CRITICAL: This function is called in ESP Timer task
IRAM_ATTR static void esp_timer_cb_flushout(void)
{
// Take semaphore
assert(xSemaphoreTakeRecursive(mutex_handle, portMAX_DELAY) == pdTRUE);
// Flushout
if (trans_head) {
// Make sure there's enough space for loss frame counter
if (trans_head->next && loss_frame_cnt) {
ble_log_spi_out_write(BLE_LOG_SPI_OUT_SOURCE_LOSS, (uint8_t *)&loss_frame_cnt, sizeof(loss_frame_cnt));
loss_frame_cnt = 0;
}
if (trans_head->trans.length) {
spi_out_append_trans();
}
}
else {
// Restart flushout timer
esp_timer_start_once(flushout_timer_handle, SPI_OUT_FLUSHOUT_TIMEOUT);
}
// Release semaphore
xSemaphoreGiveRecursive(mutex_handle);
}
#if CONFIG_BT_BLE_LOG_SPI_OUT_TS_SYNC_ENABLED
// CRITICAL: This function is called in ESP Timer task
IRAM_ATTR static void esp_timer_cb_ts_sync(void)
{
// Initialize variables
uint32_t lc_ts = 0;
uint32_t esp_ts = 0;
// Enter critical
portMUX_TYPE spinlock = portMUX_INITIALIZER_UNLOCKED;
portENTER_CRITICAL_SAFE(&spinlock);
// Get LC timestamp
#if defined(CONFIG_IDF_TARGET_ESP32H2) || defined(CONFIG_IDF_TARGET_ESP32C6)
lc_ts = r_ble_lll_timer_current_tick_get();
#endif // CONFIG_IDF_TARGET_ESP32H2 || CONFIG_IDF_TARGET_ESP32C6
#if defined(CONFIG_IDF_TARGET_ESP32C2)
lc_ts = r_os_cputime_get32();
#endif // CONFIG_IDF_TARGET_ESP32C2
// Toggle Sync IO
gpio_set_level(CONFIG_BT_BLE_LOG_SPI_OUT_SYNC_IO_NUM, (uint32_t)sync_io_level);
// Get ESP timestamp
esp_ts = esp_timer_get_time();
portEXIT_CRITICAL_SAFE(&spinlock);
// Exit critical
// Write timestamp sync log
uint8_t sync_frame[9];
sync_frame[0] = ((uint8_t)sync_io_level & 0xFF);
memcpy(sync_frame + 1, &lc_ts, sizeof(lc_ts));
memcpy(sync_frame + 5, &esp_ts, sizeof(esp_ts));
ble_log_spi_out_write(BLE_LOG_SPI_OUT_SOURCE_SYNC, sync_frame, 9);
// Update IO level
sync_io_level = !sync_io_level;
}
#endif // CONFIG_BT_BLE_LOG_SPI_OUT_TS_SYNC_ENABLED
// Public functions
void ble_log_spi_out_init(void)
{
// Avoid double init
if (spi_out_inited)
{
if (spi_out_inited) {
return;
}
// Initialize mutex
mutex_handle = xSemaphoreCreateRecursiveMutex();
// Initialize SPI
spi_bus_config_t bus_config = {
.miso_io_num = -1,
.mosi_io_num = CONFIG_BT_LE_CONTROLLER_LOG_SPI_OUT_MOSI_IO_NUM,
.sclk_io_num = CONFIG_BT_LE_CONTROLLER_LOG_SPI_OUT_SCLK_IO_NUM,
.mosi_io_num = CONFIG_BT_BLE_LOG_SPI_OUT_MOSI_IO_NUM,
.sclk_io_num = CONFIG_BT_BLE_LOG_SPI_OUT_SCLK_IO_NUM,
.quadwp_io_num = -1,
.quadhd_io_num = -1,
.max_transfer_sz = 10240
@ -121,8 +249,8 @@ void ble_log_spi_out_init(void)
spi_device_interface_config_t dev_config = {
.clock_speed_hz = SPI_MASTER_FREQ_20M,
.mode = 0,
.spics_io_num = CONFIG_BT_LE_CONTROLLER_LOG_SPI_OUT_CS_IO_NUM,
.queue_size = CONFIG_BT_LE_CONTROLLER_LOG_SPI_OUT_QUEUE_SIZE
.spics_io_num = CONFIG_BT_BLE_LOG_SPI_OUT_CS_IO_NUM,
.queue_size = CONFIG_BT_BLE_LOG_SPI_OUT_QUEUE_SIZE
};
ESP_ERROR_CHECK(spi_bus_initialize(SPI_OUT_BUS, &bus_config, SPI_DMA_CH_AUTO));
ESP_ERROR_CHECK(spi_bus_add_device(SPI_OUT_BUS, &dev_config, &spi_handle));
@ -130,8 +258,33 @@ void ble_log_spi_out_init(void)
// Initialize transaction link nodes
spi_out_init_trans();
// Initialize mutex
mutex_handle = xSemaphoreCreateMutex();
// Initialize flushout timer
esp_timer_create_args_t timer_args = {
.callback = (esp_timer_cb_t)esp_timer_cb_flushout,
.dispatch_method = ESP_TIMER_TASK
};
ESP_ERROR_CHECK(esp_timer_create(&timer_args, &flushout_timer_handle));
esp_timer_start_once(flushout_timer_handle, SPI_OUT_FLUSHOUT_TIMEOUT);
loss_frame_cnt = 0;
#if CONFIG_BT_BLE_LOG_SPI_OUT_TS_SYNC_ENABLED
// Initialize timestamp synchronizer
gpio_config_t io_conf = {
.intr_type = GPIO_INTR_DISABLE,
.mode = GPIO_MODE_OUTPUT,
.pin_bit_mask = (1UL << CONFIG_BT_BLE_LOG_SPI_OUT_SYNC_IO_NUM),
.pull_down_en = 0,
.pull_up_en = 0
};
ESP_ERROR_CHECK(gpio_config(&io_conf));
sync_io_level = false;
gpio_set_level(CONFIG_BT_BLE_LOG_SPI_OUT_SYNC_IO_NUM, sync_io_level);
esp_timer_create_args_t ts_sync_timer_args = {
.callback = (esp_timer_cb_t)esp_timer_cb_ts_sync,
.dispatch_method = ESP_TIMER_TASK
};
ESP_ERROR_CHECK(esp_timer_create(&ts_sync_timer_args, &ts_sync_timer_handle));
#endif // CONFIG_BT_BLE_LOG_SPI_OUT_TS_SYNC_ENABLED
// Set init flag
spi_out_inited = true;
@ -140,11 +293,21 @@ void ble_log_spi_out_init(void)
void ble_log_spi_out_deinit(void)
{
// Avoid double deinit
if (!spi_out_inited)
{
if (!spi_out_inited) {
return;
}
#if CONFIG_BT_BLE_LOG_SPI_OUT_TS_SYNC_ENABLED
// Deinitialize timestamp synchronizer
esp_timer_stop(ts_sync_timer_handle);
esp_timer_delete(ts_sync_timer_handle);
gpio_reset_pin(CONFIG_BT_BLE_LOG_SPI_OUT_SYNC_IO_NUM);
#endif // CONFIG_BT_BLE_LOG_SPI_OUT_TS_SYNC_ENABLED
// Deinitialize flushout timer
esp_timer_stop(flushout_timer_handle);
esp_timer_delete(flushout_timer_handle);
// Deinitialize transaction link nodes
spi_out_deinit_trans();
@ -161,60 +324,78 @@ void ble_log_spi_out_deinit(void)
spi_out_inited = false;
}
IRAM_ATTR void ble_log_spi_out_write(uint32_t len, const uint8_t *addr, spi_out_source_t source)
#if CONFIG_BT_BLE_LOG_SPI_OUT_TS_SYNC_ENABLED
void ble_log_spi_out_ts_sync_start(void)
{
// Take semaphore
assert(xSemaphoreTake(mutex_handle, portMAX_DELAY) == pdTRUE);
// Recycle trans if free buffer list is empty
if (!trans_head)
{
spi_out_recycle_trans(0);
// Check if SPI out is initialized
if (!spi_out_inited) {
return;
}
// Length of 0 means flush out
if (!len)
{
assert(trans_head);
if (trans_head->trans.length)
{
spi_out_append_trans();
}
goto release;
}
// Copy user data to buffer
uint32_t copy_buf_len;
uint32_t data_left_len = len;
uint32_t empty_buf_len = CONFIG_BT_LE_CONTROLLER_LOG_SPI_OUT_TRANS_BUF_SIZE - trans_head->trans.length;
while (data_left_len)
{
// There shall always be available buffer in free buffer list during write operation
assert(trans_head);
// Copy data to buffer and update length
copy_buf_len = (data_left_len > empty_buf_len) ? empty_buf_len : data_left_len;
memcpy((uint8_t *)trans_head->trans.tx_buffer + trans_head->trans.length, addr + (len - data_left_len), copy_buf_len);
trans_head->trans.length += copy_buf_len;
data_left_len -= copy_buf_len;
// Transaction buffer length shall never exceed buffer size
assert(trans_head->trans.length <= CONFIG_BT_LE_CONTROLLER_LOG_SPI_OUT_TRANS_BUF_SIZE);
// If buffer is full, append transaction and reset buffer length
if (trans_head->trans.length == CONFIG_BT_LE_CONTROLLER_LOG_SPI_OUT_TRANS_BUF_SIZE)
{
spi_out_append_trans();
empty_buf_len = CONFIG_BT_LE_CONTROLLER_LOG_SPI_OUT_TRANS_BUF_SIZE;
// Start timestamp sync timer
if (ts_sync_timer_handle) {
if (!esp_timer_is_active(ts_sync_timer_handle)) {
esp_timer_start_periodic(ts_sync_timer_handle, SPI_OUT_TS_SYNC_TIMEOUT);
}
}
release:
xSemaphoreGive(mutex_handle);
return;
}
void ble_log_spi_out_ts_sync_stop(void)
{
// Check if SPI out is initialized
if (!spi_out_inited) {
return;
}
// Stop timestamp sync timer
if (ts_sync_timer_handle) {
if (esp_timer_is_active(ts_sync_timer_handle)) {
esp_timer_stop(ts_sync_timer_handle);
}
}
}
#endif // CONFIG_BT_BLE_LOG_SPI_OUT_TS_SYNC_ENABLED
IRAM_ATTR void ble_log_spi_out_write_esp(uint32_t len, const uint8_t *addr, bool end)
{
ble_log_spi_out_write(len, addr, esp_controller);
return ble_log_spi_out_write(BLE_LOG_SPI_OUT_SOURCE_ESP, addr, len);
}
IRAM_ATTR void ble_log_spi_out_write(uint8_t source, const uint8_t *addr, uint16_t len)
{
// Initialize frame sequence number
static uint8_t frame_sn = 0;
// Take semaphore
assert(xSemaphoreTakeRecursive(mutex_handle, portMAX_DELAY) == pdTRUE);
// Prepare frame head and frame tail
const uint8_t head[4] = {len & 0xFF, (len >> 8) & 0xFF, (uint8_t)source, frame_sn};
const uint8_t tail = SPI_OUT_TAIL;
// Write frame head first, then payload, finally frame tail
do
{
if (spi_out_write(head, 4) != 0) {
loss_frame_cnt++;
break;
}
if (spi_out_write(addr, len) != 0) {
loss_frame_cnt++;
break;
}
if (spi_out_write(&tail, 1) != 0) {
loss_frame_cnt++;
break;
}
} while (0);
// Update frame sequence number
frame_sn++;
// Release semaphore
xSemaphoreGiveRecursive(mutex_handle);
return;
}
#endif // CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED

19
components/bt/common/ble_log/include/ble_log/ble_log_spi_out.h
View File

@ -8,19 +8,26 @@
#include <string.h>
#include "driver/spi_master.h"
#include "driver/gpio.h"
#include "esp_timer.h"
#include "freertos/semphr.h"
// Public typedefs
typedef enum
{
esp_controller = 0,
ceva_controller = 1
} spi_out_source_t;
#define BLE_LOG_SPI_OUT_SOURCE_ESP 0
#define BLE_LOG_SPI_OUT_SOURCE_ESP_LEGACY 1
#define BLE_LOG_SPI_OUT_SOURCE_BLUEDROID 2
#define BLE_LOG_SPI_OUT_SOURCE_NIMBLE 3
#define BLE_LOG_SPI_OUT_SOURCE_HCI_UPSTREAM 4
#define BLE_LOG_SPI_OUT_SOURCE_HCI_DOWNSTREAM 5
#define BLE_LOG_SPI_OUT_SOURCE_SYNC 0xFE
#define BLE_LOG_SPI_OUT_SOURCE_LOSS 0xFF
// Public functions
void ble_log_spi_out_init(void);
void ble_log_spi_out_deinit(void);
void ble_log_spi_out_write(uint32_t len, const uint8_t *addr, spi_out_source_t source);
void ble_log_spi_out_write(uint8_t source, const uint8_t *addr, uint16_t len);
void ble_log_spi_out_write_esp(uint32_t len, const uint8_t *addr, bool end);
void ble_log_spi_out_ts_sync_start(void);
void ble_log_spi_out_ts_sync_stop(void);
#endif // __BT_SPI_OUT_H__

14
components/bt/controller/esp32/bt.c
View File

@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@ -48,6 +48,10 @@
#include "esp_rom_sys.h"
#include "hli_api.h"
#if CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED
#include "ble_log/ble_log_spi_out.h"
#endif // CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED
#if CONFIG_BT_ENABLED
/* Macro definition
@ -1686,6 +1690,10 @@ esp_err_t esp_bt_controller_init(esp_bt_controller_config_t *cfg)
coex_init();
#endif
#if CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED
ble_log_spi_out_init();
#endif // CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED
btdm_cfg_mask = btdm_config_mask_load();
err = btdm_controller_init(btdm_cfg_mask, cfg);
@ -1713,6 +1721,10 @@ esp_err_t esp_bt_controller_deinit(void)
return ESP_ERR_INVALID_STATE;
}
#if CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED
ble_log_spi_out_deinit();
#endif // CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED
btdm_controller_deinit();
bt_controller_deinit_internal();

36
components/bt/controller/esp32c2/Kconfig.in
View File

@ -312,45 +312,11 @@ config BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
bool "Output ble controller logs to SPI bus (Experimental)"
depends on BT_LE_CONTROLLER_LOG_ENABLED
depends on !BT_LE_CONTROLLER_LOG_DUMP_ONLY
select BT_BLE_LOG_SPI_OUT_ENABLED
default n
help
Output ble controller logs to SPI bus
config BT_LE_CONTROLLER_LOG_SPI_OUT_QUEUE_SIZE
int "Number of ble controller log async SPI output queues"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 4
help
The number of ble controller log async SPI output queues
config BT_LE_CONTROLLER_LOG_SPI_OUT_TRANS_BUF_SIZE
int "Size of ble controller log async SPI output transaction buffer size"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 512
help
The size of ble controller log async SPI output transaction buffer size
config BT_LE_CONTROLLER_LOG_SPI_OUT_MOSI_IO_NUM
int "GPIO number of SPI MOSI"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 1
help
GPIO number of SPI MOSI
config BT_LE_CONTROLLER_LOG_SPI_OUT_SCLK_IO_NUM
int "GPIO number of SPI SCLK"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 6
help
GPIO number of SPI SCLK
config BT_LE_CONTROLLER_LOG_SPI_OUT_CS_IO_NUM
int "GPIO number of SPI CS"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 7
help
GPIO number of SPI CS
config BT_LE_CONTROLLER_LOG_STORAGE_ENABLE
bool "Store ble controller logs to flash(Experimental)"
depends on !BT_LE_CONTROLLER_LOG_DUMP_ONLY

13
components/bt/controller/esp32c3/bt.c
View File

@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@ -49,6 +49,9 @@
#else //CONFIG_IDF_TARGET_ESP32S3
#include "esp32s3/rom/rom_layout.h"
#endif
#if CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED
#include "ble_log/ble_log_spi_out.h"
#endif // CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED
#if CONFIG_BT_ENABLED
/* Macro definition
@ -1446,6 +1449,10 @@ esp_err_t esp_bt_controller_init(esp_bt_controller_config_t *cfg)
coex_init();
#endif
#if CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED
ble_log_spi_out_init();
#endif // CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED
periph_module_enable(PERIPH_BT_MODULE);
periph_module_reset(PERIPH_BT_MODULE);
@ -1474,6 +1481,10 @@ esp_err_t esp_bt_controller_deinit(void)
return ESP_ERR_INVALID_STATE;
}
#if CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED
ble_log_spi_out_deinit();
#endif // CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED
btdm_controller_deinit();
bt_controller_deinit_internal();

36
components/bt/controller/esp32c5/Kconfig.in
View File

@ -314,45 +314,11 @@ config BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
bool "Output ble controller logs to SPI bus (Experimental)"
depends on BT_LE_CONTROLLER_LOG_ENABLED
depends on !BT_LE_CONTROLLER_LOG_DUMP_ONLY
select BT_BLE_LOG_SPI_OUT_ENABLED
default n
help
Output ble controller logs to SPI bus
config BT_LE_CONTROLLER_LOG_SPI_OUT_QUEUE_SIZE
int "Number of ble controller log async SPI output queues"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 4
help
The number of ble controller log async SPI output queues
config BT_LE_CONTROLLER_LOG_SPI_OUT_TRANS_BUF_SIZE
int "Size of ble controller log async SPI output transaction buffer size"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 512
help
The size of ble controller log async SPI output transaction buffer size
config BT_LE_CONTROLLER_LOG_SPI_OUT_MOSI_IO_NUM
int "GPIO number of SPI MOSI"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 25
help
GPIO number of SPI MOSI
config BT_LE_CONTROLLER_LOG_SPI_OUT_SCLK_IO_NUM
int "GPIO number of SPI SCLK"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 26
help
GPIO number of SPI SCLK
config BT_LE_CONTROLLER_LOG_SPI_OUT_CS_IO_NUM
int "GPIO number of SPI CS"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 27
help
GPIO number of SPI CS
config BT_LE_CONTROLLER_LOG_STORAGE_ENABLE
bool "Store ble controller logs to flash(Experimental)"
depends on !BT_LE_CONTROLLER_LOG_DUMP_ONLY

36
components/bt/controller/esp32c6/Kconfig.in
View File

@ -346,45 +346,11 @@ config BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
bool "Output ble controller logs to SPI bus (Experimental)"
depends on BT_LE_CONTROLLER_LOG_ENABLED
depends on !BT_LE_CONTROLLER_LOG_DUMP_ONLY
select BT_BLE_LOG_SPI_OUT_ENABLED
default n
help
Output ble controller logs to SPI bus
config BT_LE_CONTROLLER_LOG_SPI_OUT_QUEUE_SIZE
int "Number of ble controller log async SPI output queues"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 4
help
The number of ble controller log async SPI output queues
config BT_LE_CONTROLLER_LOG_SPI_OUT_TRANS_BUF_SIZE
int "Size of ble controller log async SPI output transaction buffer size"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 512
help
The size of ble controller log async SPI output transaction buffer size
config BT_LE_CONTROLLER_LOG_SPI_OUT_MOSI_IO_NUM
int "GPIO number of SPI MOSI"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 1
help
GPIO number of SPI MOSI
config BT_LE_CONTROLLER_LOG_SPI_OUT_SCLK_IO_NUM
int "GPIO number of SPI SCLK"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 6
help
GPIO number of SPI SCLK
config BT_LE_CONTROLLER_LOG_SPI_OUT_CS_IO_NUM
int "GPIO number of SPI CS"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 7
help
GPIO number of SPI CS
config BT_LE_CONTROLLER_LOG_STORAGE_ENABLE
bool "Store ble controller logs to flash(Experimental)"
depends on !BT_LE_CONTROLLER_LOG_DUMP_ONLY

36
components/bt/controller/esp32h2/Kconfig.in
View File

@ -337,45 +337,11 @@ config BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
bool "Output ble controller logs to SPI bus (Experimental)"
depends on BT_LE_CONTROLLER_LOG_ENABLED
depends on !BT_LE_CONTROLLER_LOG_DUMP_ONLY
select BT_BLE_LOG_SPI_OUT_ENABLED
default n
help
Output ble controller logs to SPI bus
config BT_LE_CONTROLLER_LOG_SPI_OUT_QUEUE_SIZE
int "Number of ble controller log async SPI output queues"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 4
help
The number of ble controller log async SPI output queues
config BT_LE_CONTROLLER_LOG_SPI_OUT_TRANS_BUF_SIZE
int "Size of ble controller log async SPI output transaction buffer size"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 512
help
The size of ble controller log async SPI output transaction buffer size
config BT_LE_CONTROLLER_LOG_SPI_OUT_MOSI_IO_NUM
int "GPIO number of SPI MOSI"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 25
help
GPIO number of SPI MOSI
config BT_LE_CONTROLLER_LOG_SPI_OUT_SCLK_IO_NUM
int "GPIO number of SPI SCLK"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 26
help
GPIO number of SPI SCLK
config BT_LE_CONTROLLER_LOG_SPI_OUT_CS_IO_NUM
int "GPIO number of SPI CS"
depends on BT_LE_CONTROLLER_LOG_SPI_OUT_ENABLED
default 27
help
GPIO number of SPI CS
config BT_LE_CONTROLLER_LOG_STORAGE_ENABLE
bool "Store ble controller logs to flash(Experimental)"
depends on !BT_LE_CONTROLLER_LOG_DUMP_ONLY