espressif/esp-idf
1
0
Fork 1
mirror of https://github.com/espressif/esp-idf.git synced 2025-08-04 05:04:33 +02:00
Code Issues Packages Projects Releases Wiki Activity

change(ble): support task buffer number configuration

Browse Source
This commit is contained in:
Zhou Xiao
2025-07-01 14:50:18 +08:00
parent b8b7e153a7
commit 4946a1fe8d
2 changed files with 214 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -35,6 +35,13 @@ config BT_BLE_LOG_SPI_OUT_HCI_BUF_SIZE
SPI transaction buffer size for HCI logs. SPI transaction buffer size for HCI logs.
There will be 2 SPI DMA buffers with the same size. There will be 2 SPI DMA buffers with the same size.
config BT_BLE_LOG_SPI_OUT_HCI_TASK_CNT
int "HCI task count"
depends on BT_BLE_LOG_SPI_OUT_HCI_ENABLED
default 1
help
HCI task count
config BT_BLE_LOG_SPI_OUT_HOST_ENABLED config BT_BLE_LOG_SPI_OUT_HOST_ENABLED
bool "Enable Host log output to SPI" bool "Enable Host log output to SPI"
depends on BT_BLE_LOG_SPI_OUT_ENABLED depends on BT_BLE_LOG_SPI_OUT_ENABLED
@@ -51,6 +58,13 @@ config BT_BLE_LOG_SPI_OUT_HOST_BUF_SIZE
SPI transaction buffer size for host logs. SPI transaction buffer size for host logs.
There will be 2 SPI DMA buffers with the same size. There will be 2 SPI DMA buffers with the same size.
config BT_BLE_LOG_SPI_OUT_HOST_TASK_CNT
int "Host task count"
depends on BT_BLE_LOG_SPI_OUT_HOST_ENABLED
default 2
help
Host task count.
config BT_BLE_LOG_SPI_OUT_LL_ENABLED config BT_BLE_LOG_SPI_OUT_LL_ENABLED
bool "Enable Controller log output to SPI" bool "Enable Controller log output to SPI"
depends on BT_BLE_LOG_SPI_OUT_ENABLED depends on BT_BLE_LOG_SPI_OUT_ENABLED
@@ -155,6 +169,13 @@ config BT_BLE_LOG_SPI_OUT_LE_AUDIO_BUF_SIZE
SPI transaction buffer size for LE Audio logs. SPI transaction buffer size for LE Audio logs.
There will be 2 SPI DMA buffers with the same size. There will be 2 SPI DMA buffers with the same size.
config BT_BLE_LOG_SPI_OUT_LE_AUDIO_TASK_CNT
int "LE audio task count"
depends on BT_BLE_LOG_SPI_OUT_LE_AUDIO_ENABLED
default 1
help
LE audio task count
config BT_BLE_LOG_SPI_OUT_MESH_ENABLED config BT_BLE_LOG_SPI_OUT_MESH_ENABLED
bool "Enable BLE mesh log output to SPI" bool "Enable BLE mesh log output to SPI"
depends on BT_BLE_LOG_SPI_OUT_ENABLED depends on BT_BLE_LOG_SPI_OUT_ENABLED
@@ -169,3 +190,10 @@ config BT_BLE_LOG_SPI_OUT_MESH_BUF_SIZE
help help
SPI transaction buffer size for BLE mesh logs. SPI transaction buffer size for BLE mesh logs.
There will be 2 SPI DMA buffers with the same size. There will be 2 SPI DMA buffers with the same size.
config BT_BLE_LOG_SPI_OUT_MESH_TASK_CNT
int "Mesh task count"
depends on BT_BLE_LOG_SPI_OUT_MESH_ENABLED
default 3
help
Mesh task count

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

@@ -26,12 +26,16 @@
#define SPI_OUT_FLUSH_TIMEOUT_US (CONFIG_BT_BLE_LOG_SPI_OUT_FLUSH_TIMEOUT * 1000) #define SPI_OUT_FLUSH_TIMEOUT_US (CONFIG_BT_BLE_LOG_SPI_OUT_FLUSH_TIMEOUT * 1000)
#define SPI_OUT_LE_AUDIO_ENABLED CONFIG_BT_BLE_LOG_SPI_OUT_LE_AUDIO_ENABLED #define SPI_OUT_LE_AUDIO_ENABLED CONFIG_BT_BLE_LOG_SPI_OUT_LE_AUDIO_ENABLED
#define SPI_OUT_LE_AUDIO_BUF_SIZE CONFIG_BT_BLE_LOG_SPI_OUT_LE_AUDIO_BUF_SIZE #define SPI_OUT_LE_AUDIO_BUF_SIZE CONFIG_BT_BLE_LOG_SPI_OUT_LE_AUDIO_BUF_SIZE
#define SPI_OUT_LE_AUDIO_TASK_CNT CONFIG_BT_BLE_LOG_SPI_OUT_LE_AUDIO_TASK_CNT
#define SPI_OUT_HOST_ENABLED CONFIG_BT_BLE_LOG_SPI_OUT_HOST_ENABLED #define SPI_OUT_HOST_ENABLED CONFIG_BT_BLE_LOG_SPI_OUT_HOST_ENABLED
#define SPI_OUT_HOST_BUF_SIZE CONFIG_BT_BLE_LOG_SPI_OUT_HOST_BUF_SIZE #define SPI_OUT_HOST_BUF_SIZE CONFIG_BT_BLE_LOG_SPI_OUT_HOST_BUF_SIZE
#define SPI_OUT_HOST_TASK_CNT CONFIG_BT_BLE_LOG_SPI_OUT_HOST_TASK_CNT
#define SPI_OUT_HCI_ENABLED CONFIG_BT_BLE_LOG_SPI_OUT_HCI_ENABLED #define SPI_OUT_HCI_ENABLED CONFIG_BT_BLE_LOG_SPI_OUT_HCI_ENABLED
#define SPI_OUT_HCI_BUF_SIZE CONFIG_BT_BLE_LOG_SPI_OUT_HCI_BUF_SIZE #define SPI_OUT_HCI_BUF_SIZE CONFIG_BT_BLE_LOG_SPI_OUT_HCI_BUF_SIZE
#define SPI_OUT_HCI_TASK_CNT CONFIG_BT_BLE_LOG_SPI_OUT_HCI_TASK_CNT
#define SPI_OUT_MESH_ENABLED CONFIG_BT_BLE_LOG_SPI_OUT_MESH_ENABLED #define SPI_OUT_MESH_ENABLED CONFIG_BT_BLE_LOG_SPI_OUT_MESH_ENABLED
#define SPI_OUT_MESH_BUF_SIZE CONFIG_BT_BLE_LOG_SPI_OUT_MESH_BUF_SIZE #define SPI_OUT_MESH_BUF_SIZE CONFIG_BT_BLE_LOG_SPI_OUT_MESH_BUF_SIZE
#define SPI_OUT_MESH_TASK_CNT CONFIG_BT_BLE_LOG_SPI_OUT_MESH_TASK_CNT
// Private defines // Private defines
#define BLE_LOG_TAG "BLE_LOG" #define BLE_LOG_TAG "BLE_LOG"
@@ -110,6 +114,12 @@ typedef struct {
uint8_t type; uint8_t type;
} spi_out_log_cb_t; } spi_out_log_cb_t;
typedef struct {
TaskHandle_t task_handle;
spi_out_log_cb_t *log_cb;
uint8_t *str_buf;
} task_map_t;
typedef struct { typedef struct {
uint16_t length; uint16_t length;
uint8_t source; uint8_t source;
@@ -137,9 +147,7 @@ enum {
enum { enum {
LOG_CB_TYPE_UL = 0, LOG_CB_TYPE_UL = 0,
LOG_CB_TYPE_LL_TASK, LOG_CB_TYPE_LL,
LOG_CB_TYPE_LL_ISR,
LOG_CB_TYPE_LL_HCI,
LOG_CB_TYPE_LE_AUDIO, LOG_CB_TYPE_LE_AUDIO,
LOG_CB_TYPE_HOST, LOG_CB_TYPE_HOST,
LOG_CB_TYPE_HCI, LOG_CB_TYPE_HCI,
@@ -199,7 +207,7 @@ static void spi_out_deinit_trans(spi_out_trans_cb_t **trans_cb);
static void spi_out_tx_done_cb(spi_transaction_t *ret_trans); static void spi_out_tx_done_cb(spi_transaction_t *ret_trans);
static inline void spi_out_append_trans(spi_out_trans_cb_t *trans_cb); static inline void spi_out_append_trans(spi_out_trans_cb_t *trans_cb);
static int spi_out_log_cb_init(spi_out_log_cb_t **log_cb, uint16_t buf_size, uint8_t type); static int spi_out_log_cb_init(spi_out_log_cb_t **log_cb, uint16_t buf_size, uint8_t type, uint8_t idx);
static void spi_out_log_cb_deinit(spi_out_log_cb_t **log_cb); static void spi_out_log_cb_deinit(spi_out_log_cb_t **log_cb);
static inline bool spi_out_log_cb_check_trans(spi_out_log_cb_t *log_cb, uint16_t len, bool *need_append); static inline bool spi_out_log_cb_check_trans(spi_out_log_cb_t *log_cb, uint16_t len, bool *need_append);
static inline void spi_out_log_cb_append_trans(spi_out_log_cb_t *log_cb); static inline void spi_out_log_cb_append_trans(spi_out_log_cb_t *log_cb);
@@ -209,6 +217,8 @@ static bool spi_out_log_cb_write(spi_out_log_cb_t *log_cb, const uint8_t *addr,
bool with_checksum); bool with_checksum);
static void spi_out_log_cb_write_loss(spi_out_log_cb_t *log_cb); static void spi_out_log_cb_write_loss(spi_out_log_cb_t *log_cb);
static void spi_out_log_cb_dump(spi_out_log_cb_t *log_cb); static void spi_out_log_cb_dump(spi_out_log_cb_t *log_cb);
static bool spi_out_get_task_mapping(task_map_t *map, size_t num,
spi_out_log_cb_t **log_cb, uint8_t **str_buf);
static void spi_out_log_flush(void); static void spi_out_log_flush(void);
static void spi_out_write_hex(spi_out_log_cb_t *log_cb, uint8_t source, static void spi_out_write_hex(spi_out_log_cb_t *log_cb, uint8_t source,
@@ -259,18 +269,34 @@ static void esp_timer_cb_ts_sync(void);
#define IF_0(...) #define IF_0(...)
#define LOG_MODULE_INIT_FLAG(ID) (ID##_log_inited) #define LOG_MODULE_INIT_FLAG(ID) (ID##_log_inited)
#define LOG_MODULE_CB(ID) (ID##_log_cb) #define LOG_MODULE_CB_ARR(ID) (ID##_log_cb)
#define LOG_MODULE_CB_CNT(ID) (ID##_log_cb_cnt)
#define LOG_MODULE_CB(ID, IDX) (ID##_log_cb[IDX])
#define LOG_MODULE_TASK_MAP(ID) (ID##_task_map)
#define LOG_MODULE_MUTEX(ID) (ID##_log_mutex) #define LOG_MODULE_MUTEX(ID) (ID##_log_mutex)
#define LOG_MODULE_STR_BUF(ID) (ID##_log_str_buf) #define LOG_MODULE_STR_BUF_ARR(ID) (ID##_log_str_buf)
#define LOG_MODULE_STR_BUF(ID, IDX) (ID##_log_str_buf[IDX])
#define LOG_MODULE_INIT(ID) (spi_out_##ID##_log_init) #define LOG_MODULE_INIT(ID) (spi_out_##ID##_log_init)
#define LOG_MODULE_DEINIT(ID) (spi_out_##ID##_log_deinit) #define LOG_MODULE_DEINIT(ID) (spi_out_##ID##_log_deinit)
#define LOG_MODULE_FLUSH(ID) (spi_out_##ID##_log_flush) #define LOG_MODULE_FLUSH(ID) (spi_out_##ID##_log_flush)
#define LOG_MODULE_DUMP(ID) \
do { \
if (LOG_MODULE_INIT_FLAG(ID)) { \
esp_rom_printf("[DUMP_START:\n"); \
for (int i = 0; i < LOG_MODULE_CB_CNT(ID); i++) { \
spi_out_log_cb_dump(LOG_MODULE_CB(ID, i)); \
} \
esp_rom_printf("\n:DUMP_END]\n"); \
} \
} while (0)
#define DECLARE_LOG_MODULE(ID, TYPE, BUF_SIZE, USE_MUTEX, USE_STR) \ #define DECLARE_LOG_MODULE(ID, TYPE, BUF_SIZE, NUM_CB, USE_MUTEX, USE_STR) \
static bool LOG_MODULE_INIT_FLAG(ID) = false; \ static bool LOG_MODULE_INIT_FLAG(ID) = false; \
static spi_out_log_cb_t *LOG_MODULE_CB(ID) = NULL; \ static spi_out_log_cb_t *LOG_MODULE_CB_ARR(ID)[NUM_CB] = { NULL }; \
static const size_t LOG_MODULE_CB_CNT(ID) = (NUM_CB); \
static task_map_t LOG_MODULE_TASK_MAP(ID)[NUM_CB] = {0}; \
IF_##USE_MUTEX(static SemaphoreHandle_t LOG_MODULE_MUTEX(ID) = NULL;) \ IF_##USE_MUTEX(static SemaphoreHandle_t LOG_MODULE_MUTEX(ID) = NULL;) \
IF_##USE_STR(static uint8_t *LOG_MODULE_STR_BUF(ID) = NULL;) \ IF_##USE_STR(static uint8_t *LOG_MODULE_STR_BUF_ARR(ID)[NUM_CB] = {0};) \
\ \
static int LOG_MODULE_INIT(ID)(void); \ static int LOG_MODULE_INIT(ID)(void); \
static void LOG_MODULE_DEINIT(ID)(void); \ static void LOG_MODULE_DEINIT(ID)(void); \
@@ -287,13 +313,22 @@ static void esp_timer_cb_ts_sync(void);
} \ } \
) \ ) \
IF_##USE_STR( \ IF_##USE_STR( \
LOG_MODULE_STR_BUF(ID) = (uint8_t *)SPI_OUT_MALLOC(SPI_OUT_LOG_STR_BUF_SIZE); \ for (size_t i = 0; i < LOG_MODULE_CB_CNT(ID); i++) { \
if (!LOG_MODULE_STR_BUF(ID)) { \ LOG_MODULE_STR_BUF(ID, i) = (uint8_t *)SPI_OUT_MALLOC( \
goto failed; \ SPI_OUT_LOG_STR_BUF_SIZE \
); \
if (!LOG_MODULE_STR_BUF(ID, i)) { \
goto failed; \
} \
LOG_MODULE_TASK_MAP(ID)[i].str_buf = LOG_MODULE_STR_BUF(ID, i); \
} \ } \
) \ ) \
if (spi_out_log_cb_init(&LOG_MODULE_CB(ID), BUF_SIZE, TYPE) != 0) { \ for (size_t i = 0; i < LOG_MODULE_CB_CNT(ID); i++) { \
goto failed; \ if (spi_out_log_cb_init(&LOG_MODULE_CB(ID, i), BUF_SIZE, TYPE, i) != 0) \
{ \
goto failed; \
} \
LOG_MODULE_TASK_MAP(ID)[i].log_cb = LOG_MODULE_CB(ID, i); \
} \ } \
LOG_MODULE_INIT_FLAG(ID) = true; \ LOG_MODULE_INIT_FLAG(ID) = true; \
return 0; \ return 0; \
@@ -310,13 +345,20 @@ static void esp_timer_cb_ts_sync(void);
xSemaphoreTake(LOG_MODULE_MUTEX(ID), portMAX_DELAY); \ xSemaphoreTake(LOG_MODULE_MUTEX(ID), portMAX_DELAY); \
) \ ) \
IF_##USE_STR( \ IF_##USE_STR( \
if (LOG_MODULE_STR_BUF(ID)) { \ for (size_t i = 0; i < LOG_MODULE_CB_CNT(ID); i++) { \
free(LOG_MODULE_STR_BUF(ID)); \ if (LOG_MODULE_STR_BUF(ID, i)) { \
LOG_MODULE_STR_BUF(ID) = NULL; \ free(LOG_MODULE_STR_BUF(ID, i)); \
LOG_MODULE_STR_BUF(ID, i) = NULL; \
} \
} \ } \
) \ ) \
spi_out_log_cb_deinit(&LOG_MODULE_CB(ID)); \ for (size_t i = 0; i < LOG_MODULE_CB_CNT(ID); i++) { \
\ spi_out_log_cb_deinit(&LOG_MODULE_CB(ID, i)); \
LOG_MODULE_CB(ID, i) = NULL; \
} \
for (size_t i = 0; i < LOG_MODULE_CB_CNT(ID); i++) { \
memset(&LOG_MODULE_TASK_MAP(ID)[i], 0, sizeof(task_map_t)); \
} \
IF_##USE_MUTEX( \ IF_##USE_MUTEX( \
xSemaphoreGive(LOG_MODULE_MUTEX(ID)); \ xSemaphoreGive(LOG_MODULE_MUTEX(ID)); \
vSemaphoreDelete(LOG_MODULE_MUTEX(ID)); \ vSemaphoreDelete(LOG_MODULE_MUTEX(ID)); \
@@ -330,30 +372,36 @@ static void esp_timer_cb_ts_sync(void);
IF_##USE_MUTEX( \ IF_##USE_MUTEX( \
xSemaphoreTake(LOG_MODULE_MUTEX(ID), portMAX_DELAY); \ xSemaphoreTake(LOG_MODULE_MUTEX(ID), portMAX_DELAY); \
) \ ) \
spi_out_log_cb_write_loss(LOG_MODULE_CB(ID)); \ for (size_t i = 0; i < LOG_MODULE_CB_CNT(ID); ++i) { \
spi_out_log_cb_flush_trans(LOG_MODULE_CB(ID)); \ spi_out_log_cb_write_loss(LOG_MODULE_CB(ID, i)); \
spi_out_log_cb_append_trans(LOG_MODULE_CB(ID)); \ spi_out_log_cb_flush_trans(LOG_MODULE_CB(ID, i)); \
spi_out_log_cb_append_trans(LOG_MODULE_CB(ID, i)); \
} \
IF_##USE_MUTEX( \ IF_##USE_MUTEX( \
xSemaphoreGive(LOG_MODULE_MUTEX(ID)); \ xSemaphoreGive(LOG_MODULE_MUTEX(ID)); \
) \ ) \
} \ }
DECLARE_LOG_MODULE(ul, LOG_CB_TYPE_UL, SPI_OUT_UL_TASK_BUF_SIZE, 1, 1) DECLARE_LOG_MODULE(ul, LOG_CB_TYPE_UL, SPI_OUT_UL_TASK_BUF_SIZE, 1, 1, 1)
#if SPI_OUT_LE_AUDIO_ENABLED #if SPI_OUT_LE_AUDIO_ENABLED
DECLARE_LOG_MODULE(le_audio, LOG_CB_TYPE_LE_AUDIO, SPI_OUT_LE_AUDIO_BUF_SIZE, 0, 0) DECLARE_LOG_MODULE(le_audio, LOG_CB_TYPE_LE_AUDIO, SPI_OUT_LE_AUDIO_BUF_SIZE,
SPI_OUT_LE_AUDIO_TASK_CNT, 0, 0)
#endif // SPI_OUT_LE_AUDIO_ENABLED #endif // SPI_OUT_LE_AUDIO_ENABLED
#if SPI_OUT_HOST_ENABLED #if SPI_OUT_HOST_ENABLED
DECLARE_LOG_MODULE(host, LOG_CB_TYPE_HOST, SPI_OUT_HOST_BUF_SIZE, 0, 1) DECLARE_LOG_MODULE(host, LOG_CB_TYPE_HOST, SPI_OUT_HOST_BUF_SIZE,
SPI_OUT_HOST_TASK_CNT, 0, 1)
#endif // SPI_OUT_HOST_ENABLED #endif // SPI_OUT_HOST_ENABLED
#if SPI_OUT_HCI_ENABLED #if SPI_OUT_HCI_ENABLED
DECLARE_LOG_MODULE(hci, LOG_CB_TYPE_HCI, SPI_OUT_HCI_BUF_SIZE, 0, 0) DECLARE_LOG_MODULE(hci, LOG_CB_TYPE_HCI, SPI_OUT_HCI_BUF_SIZE,
SPI_OUT_HCI_TASK_CNT, 0, 0)
#endif // SPI_OUT_HCI_ENABLED #endif // SPI_OUT_HCI_ENABLED
#if SPI_OUT_MESH_ENABLED #if SPI_OUT_MESH_ENABLED
DECLARE_LOG_MODULE(mesh, LOG_CB_TYPE_MESH, SPI_OUT_MESH_BUF_SIZE, 0, 1) DECLARE_LOG_MODULE(mesh, LOG_CB_TYPE_MESH, SPI_OUT_MESH_BUF_SIZE,
SPI_OUT_MESH_TASK_CNT, 0, 1)
#endif // SPI_OUT_MESH_ENABLED #endif // SPI_OUT_MESH_ENABLED
// Private functions // Private functions
@@ -436,7 +484,7 @@ recycle:
return; return;
} }
static int spi_out_log_cb_init(spi_out_log_cb_t **log_cb, uint16_t buf_size, uint8_t type) static int spi_out_log_cb_init(spi_out_log_cb_t **log_cb, uint16_t buf_size, uint8_t type, uint8_t idx)
{ {
// Initialize log control block // Initialize log control block
*log_cb = (spi_out_log_cb_t *)SPI_OUT_MALLOC(sizeof(spi_out_log_cb_t)); *log_cb = (spi_out_log_cb_t *)SPI_OUT_MALLOC(sizeof(spi_out_log_cb_t));
@@ -455,7 +503,7 @@ static int spi_out_log_cb_init(spi_out_log_cb_t **log_cb, uint16_t buf_size, uin
return -1; return -1;
} }
(*log_cb)->type = type; (*log_cb)->type = (type << 4) | (idx);
return 0; return 0;
} }
@@ -607,6 +655,67 @@ static void spi_out_log_cb_dump(spi_out_log_cb_t *log_cb)
} }
} }
static void spi_out_update_task_mapping(int idx, void *ptr)
{
// It is a must to clear task handle after task deletion
task_map_t *entry = (task_map_t *)ptr;
entry->task_handle = NULL;
}
static bool spi_out_get_task_mapping(task_map_t *map, size_t num,
spi_out_log_cb_t **log_cb, uint8_t **str_buf)
{
if (!map || !log_cb) {
return false;
}
// Shall not be called in ISR
TaskHandle_t handle = xTaskGetCurrentTaskHandle();
if (!handle) {
return false;
}
// Check if the given task handle is already in map
for (size_t i = 0; i < num; i++) {
task_map_t *entry = &map[i];
if (entry->task_handle == handle) {
*log_cb = entry->log_cb;
if (str_buf) {
*str_buf = entry->str_buf;
}
return true;
}
}
// Task handle not in map, try to allocate free slot
bool ret = false;
portMUX_TYPE spinlock = portMUX_INITIALIZER_UNLOCKED;
portENTER_CRITICAL_SAFE(&spinlock);
for (size_t i = 0; i < num; i++) {
task_map_t *entry = &map[i];
if (entry->task_handle == NULL) {
vTaskSetThreadLocalStoragePointerAndDelCallback(
NULL, 0, (void *)entry, spi_out_update_task_mapping
);
entry->task_handle = handle;
*log_cb = entry->log_cb;
if (str_buf) {
*str_buf = entry->str_buf;
}
ret = true;
break;
}
}
portEXIT_CRITICAL_SAFE(&spinlock);
if (!ret) {
// Shall not be here in normal case
const char *task_name = pcTaskGetName(NULL);
esp_rom_printf("@EW: Failed to assign slot in task map for task %s\n", task_name);
}
return ret;
}
static void spi_out_log_flush(void) static void spi_out_log_flush(void)
{ {
LOG_MODULE_FLUSH(ul)(); LOG_MODULE_FLUSH(ul)();
@@ -687,13 +796,13 @@ static int spi_out_ll_log_init(void)
} }
// Initialize log control blocks for controller task & ISR logs // Initialize log control blocks for controller task & ISR logs
if (spi_out_log_cb_init(&ll_task_log_cb, SPI_OUT_LL_TASK_BUF_SIZE, LOG_CB_TYPE_LL_TASK) != 0) { if (spi_out_log_cb_init(&ll_task_log_cb, SPI_OUT_LL_TASK_BUF_SIZE, LOG_CB_TYPE_LL, 0) != 0) {
goto task_log_cb_init_failed; goto task_log_cb_init_failed;
} }
if (spi_out_log_cb_init(&ll_isr_log_cb, SPI_OUT_LL_ISR_BUF_SIZE, LOG_CB_TYPE_LL_ISR) != 0) { if (spi_out_log_cb_init(&ll_isr_log_cb, SPI_OUT_LL_ISR_BUF_SIZE, LOG_CB_TYPE_LL, 1) != 0) {
goto isr_log_cb_init_failed; goto isr_log_cb_init_failed;
} }
if (spi_out_log_cb_init(&ll_hci_log_cb, SPI_OUT_LL_HCI_BUF_SIZE, LOG_CB_TYPE_LL_HCI) != 0) { if (spi_out_log_cb_init(&ll_hci_log_cb, SPI_OUT_LL_HCI_BUF_SIZE, LOG_CB_TYPE_LL, 2) != 0) {
goto hci_log_cb_init_failed; goto hci_log_cb_init_failed;
} }
@@ -1175,7 +1284,7 @@ int ble_log_spi_out_write(uint8_t source, const uint8_t *addr, uint16_t len)
} }
xSemaphoreTake(LOG_MODULE_MUTEX(ul), portMAX_DELAY); xSemaphoreTake(LOG_MODULE_MUTEX(ul), portMAX_DELAY);
spi_out_write_hex(LOG_MODULE_CB(ul), source, addr, len, false); spi_out_write_hex(LOG_MODULE_CB(ul, 0), source, addr, len, false);
xSemaphoreGive(LOG_MODULE_MUTEX(ul)); xSemaphoreGive(LOG_MODULE_MUTEX(ul));
return 0; return 0;
} }
@@ -1191,59 +1300,30 @@ void ble_log_spi_out_dump_all(void)
#if SPI_OUT_LL_ENABLED #if SPI_OUT_LL_ENABLED
if (ll_log_inited) { if (ll_log_inited) {
// Dump lower layer log buffer esp_rom_printf("[DUMP_START:\n");
esp_rom_printf("[LL_ISR_LOG_DUMP_START:\n");
spi_out_log_cb_dump(ll_isr_log_cb); spi_out_log_cb_dump(ll_isr_log_cb);
esp_rom_printf("\n:LL_ISR_LOG_DUMP_END]\n\n");
esp_rom_printf("[LL_TASK_LOG_DUMP_START:\n");
spi_out_log_cb_dump(ll_task_log_cb); spi_out_log_cb_dump(ll_task_log_cb);
esp_rom_printf("\n:LL_TASK_LOG_DUMP_END]\n\n");
esp_rom_printf("[LL_HCI_LOG_DUMP_START:\n");
spi_out_log_cb_dump(ll_hci_log_cb); spi_out_log_cb_dump(ll_hci_log_cb);
esp_rom_printf("\n:LL_HCI_LOG_DUMP_END]\n\n"); esp_rom_printf("\n:DUMP_END]\n\n");
} }
#endif // SPI_OUT_LL_ENABLED #endif // SPI_OUT_LL_ENABLED
if (LOG_MODULE_INIT_FLAG(ul)) { LOG_MODULE_DUMP(ul);
// Dump upper layer log buffer
esp_rom_printf("[UL_LOG_DUMP_START:\n");
spi_out_log_cb_dump(LOG_MODULE_CB(ul));
esp_rom_printf("\n:UL_LOG_DUMP_END]\n\n");
}
#if SPI_OUT_LE_AUDIO_ENABLED #if SPI_OUT_LE_AUDIO_ENABLED
if (LOG_MODULE_INIT_FLAG(le_audio)) { LOG_MODULE_DUMP(le_audio);
esp_rom_printf("[LE_AUDIO_LOG_DUMP_START:\n");
spi_out_log_cb_dump(LOG_MODULE_CB(le_audio));
esp_rom_printf("\n:LE_AUDIO_LOG_DUMP_END]\n\n");
}
#endif // SPI_OUT_LE_AUDIO_ENABLED #endif // SPI_OUT_LE_AUDIO_ENABLED
#if SPI_OUT_HOST_ENABLED #if SPI_OUT_HOST_ENABLED
if (LOG_MODULE_INIT_FLAG(host)) { LOG_MODULE_DUMP(host);
esp_rom_printf("[HOST_LOG_DUMP_START:\n");
spi_out_log_cb_dump(LOG_MODULE_CB(host));
esp_rom_printf("\n:HOST_LOG_DUMP_END]\n\n");
}
#endif // SPI_OUT_HOST_ENABLED #endif // SPI_OUT_HOST_ENABLED
#if SPI_OUT_HCI_ENABLED #if SPI_OUT_HCI_ENABLED
if (LOG_MODULE_INIT_FLAG(hci)) { LOG_MODULE_DUMP(hci);
esp_rom_printf("[HCI_LOG_DUMP_START:\n");
spi_out_log_cb_dump(LOG_MODULE_CB(hci));
esp_rom_printf("\n:HCI_LOG_DUMP_END]\n\n");
}
#endif // SPI_OUT_HCI_ENABLED #endif // SPI_OUT_HCI_ENABLED
#if SPI_OUT_MESH_ENABLED #if SPI_OUT_MESH_ENABLED
if (LOG_MODULE_INIT_FLAG(mesh)) { LOG_MODULE_DUMP(mesh);
esp_rom_printf("[MESH_LOG_DUMP_START:\n");
spi_out_log_cb_dump(LOG_MODULE_CB(mesh));
esp_rom_printf("\n:MESH_LOG_DUMP_END]\n\n");
}
#endif // SPI_OUT_MESH_ENABLED #endif // SPI_OUT_MESH_ENABLED
portEXIT_CRITICAL_SAFE(&spinlock); portEXIT_CRITICAL_SAFE(&spinlock);
@@ -1280,15 +1360,21 @@ IRAM_ATTR void ble_log_spi_out_le_audio_write(const uint8_t *addr, uint16_t len)
return; return;
} }
spi_out_log_cb_t *log_cb;
if (!spi_out_get_task_mapping(LOG_MODULE_TASK_MAP(le_audio),
LOG_MODULE_CB_CNT(le_audio), &log_cb, NULL)) {
return;
}
bool need_append; bool need_append;
if (spi_out_log_cb_check_trans(LOG_MODULE_CB(le_audio), len, &need_append)) { if (spi_out_log_cb_check_trans(log_cb, len, &need_append)) {
need_append |= spi_out_log_cb_write(LOG_MODULE_CB(le_audio), addr, len, NULL, 0, need_append |= spi_out_log_cb_write(log_cb, addr, len, NULL, 0,
BLE_LOG_SPI_OUT_SOURCE_LE_AUDIO, false); BLE_LOG_SPI_OUT_SOURCE_LE_AUDIO, false);
} }
if (need_append) { if (need_append) {
spi_out_log_cb_append_trans(LOG_MODULE_CB(le_audio)); spi_out_log_cb_append_trans(log_cb);
} }
spi_out_log_cb_write_loss(LOG_MODULE_CB(le_audio)); spi_out_log_cb_write_loss(log_cb);
return; return;
} }
#endif // CONFIG_BT_BLE_LOG_SPI_OUT_LE_AUDIO_ENABLED #endif // CONFIG_BT_BLE_LOG_SPI_OUT_LE_AUDIO_ENABLED
@@ -1300,25 +1386,31 @@ int ble_log_spi_out_host_write(uint8_t source, const char *prefix, const char *f
return -1; return -1;
} }
spi_out_log_cb_t *log_cb;
uint8_t *str_buf;
if (!spi_out_get_task_mapping(LOG_MODULE_TASK_MAP(host),
LOG_MODULE_CB_CNT(host), &log_cb, &str_buf)) {
return -1;
}
// Copy prefix to string buffer // Copy prefix to string buffer
int prefix_len = strlen(prefix); int prefix_len = strlen(prefix);
if (prefix_len >= SPI_OUT_LOG_STR_BUF_SIZE) { if (prefix_len >= SPI_OUT_LOG_STR_BUF_SIZE) {
return -1; return -1;
} }
memcpy(LOG_MODULE_STR_BUF(host), prefix, prefix_len); memcpy(str_buf, prefix, prefix_len);
// Write string buffer // Write string buffer
va_list args; va_list args;
va_start(args, format); va_start(args, format);
int total_len = spi_out_write_str(LOG_MODULE_STR_BUF(host), format, args, prefix_len); int total_len = spi_out_write_str(str_buf, format, args, prefix_len);
va_end(args); va_end(args);
if (total_len == 0) { if (total_len == 0) {
return -1; return -1;
} }
// Write log control block buffer // Write log control block buffer
spi_out_write_hex(LOG_MODULE_CB(host), source, spi_out_write_hex(log_cb, source, str_buf, (uint16_t)total_len, true);
LOG_MODULE_STR_BUF(host), (uint16_t)total_len, true);
return 0; return 0;
} }
#endif // SPI_OUT_HOST_ENABLED #endif // SPI_OUT_HOST_ENABLED
@@ -1336,7 +1428,12 @@ int ble_log_spi_out_hci_write(uint8_t source, const uint8_t *addr, uint16_t len)
#endif // SPI_OUT_LL_ENABLED #endif // SPI_OUT_LL_ENABLED
} }
if (source == BLE_LOG_SPI_OUT_SOURCE_HCI_DOWNSTREAM) { if (source == BLE_LOG_SPI_OUT_SOURCE_HCI_DOWNSTREAM) {
spi_out_write_hex(LOG_MODULE_CB(hci), source, addr, len, true); spi_out_log_cb_t *log_cb;
if (!spi_out_get_task_mapping(LOG_MODULE_TASK_MAP(hci),
LOG_MODULE_CB_CNT(hci), &log_cb, NULL)) {
return -1;
}
spi_out_write_hex(log_cb, source, addr, len, true);
} }
return 0; return 0;
} }
@@ -1349,25 +1446,31 @@ int ble_log_spi_out_mesh_write(const char *prefix, const char *format, ...)
return -1; return -1;
} }
spi_out_log_cb_t *log_cb;
uint8_t *str_buf;
if (!spi_out_get_task_mapping(LOG_MODULE_TASK_MAP(mesh),
LOG_MODULE_CB_CNT(mesh), &log_cb, &str_buf)) {
return -1;
}
// Copy prefix to string buffer // Copy prefix to string buffer
int prefix_len = strlen(prefix); int prefix_len = strlen(prefix);
if (prefix_len >= SPI_OUT_LOG_STR_BUF_SIZE) { if (prefix_len >= SPI_OUT_LOG_STR_BUF_SIZE) {
return -1; return -1;
} }
memcpy(LOG_MODULE_STR_BUF(mesh), prefix, prefix_len); memcpy(str_buf, prefix, prefix_len);
// Write string buffer // Write string buffer
va_list args; va_list args;
va_start(args, format); va_start(args, format);
int total_len = spi_out_write_str(LOG_MODULE_STR_BUF(mesh), format, args, prefix_len); int total_len = spi_out_write_str(str_buf, format, args, prefix_len);
va_end(args); va_end(args);
if (total_len == 0) { if (total_len == 0) {
return -1; return -1;
} }
// Write log control block buffer // Write log control block buffer
spi_out_write_hex(LOG_MODULE_CB(mesh), BLE_LOG_SPI_OUT_SOURCE_MESH, spi_out_write_hex(log_cb, BLE_LOG_SPI_OUT_SOURCE_MESH, str_buf, (uint16_t)total_len, true);
LOG_MODULE_STR_BUF(mesh), (uint16_t)total_len, true);
return 0; return 0;
} }
#endif // SPI_OUT_MESH_ENABLED #endif // SPI_OUT_MESH_ENABLED