From e59109e6a5d0767bc8250bb6c7ffbdba23be886d Mon Sep 17 00:00:00 2001 From: ShenWeilong Date: Wed, 29 Apr 2026 19:48:26 +0800 Subject: [PATCH] change(bt): separated host mem apis from bt_osi_mem.c --- components/bt/CMakeLists.txt | 1 + .../host/bluedroid/hci/include/hci/hci_hal.h | 9 +- .../host/nimble/port/include/esp_nimble_mem.h | 108 +++++- .../bt/host/nimble/port/src/esp_nimble_mem.c | 339 ++++++++++++++++ components/bt/porting/include/bt_osi_mem.h | 88 +---- components/bt/porting/mem/bt_osi_mem.c | 364 ++---------------- components/bt/porting/mem/os_mempool.c | 2 + components/bt/porting/mem/os_msys_init.c | 33 +- .../npl/freertos/src/npl_os_freertos.c | 7 +- .../esp_hid_device/main/esp_hid_device_main.c | 7 +- .../esp_hid_host/main/esp_hid_host_main.c | 7 +- 11 files changed, 502 insertions(+), 463 deletions(-) create mode 100644 components/bt/host/nimble/port/src/esp_nimble_mem.c diff --git a/components/bt/CMakeLists.txt b/components/bt/CMakeLists.txt index b26460c9096..070461ed256 100644 --- a/components/bt/CMakeLists.txt +++ b/components/bt/CMakeLists.txt @@ -870,6 +870,7 @@ if(CONFIG_BT_ENABLED) "host/nimble/nimble/porting/nimble/src/nimble_port.c" "host/nimble/nimble/porting/npl/freertos/src/nimble_port_freertos.c" "host/nimble/port/src/nvs_port.c" + "host/nimble/port/src/esp_nimble_mem.c" ) list(APPEND include_dirs diff --git a/components/bt/host/bluedroid/hci/include/hci/hci_hal.h b/components/bt/host/bluedroid/hci/include/hci/hci_hal.h index aec926b6afb..f50bef28cd4 100644 --- a/components/bt/host/bluedroid/hci/include/hci/hci_hal.h +++ b/components/bt/host/bluedroid/hci/include/hci/hci_hal.h @@ -24,9 +24,7 @@ #include "common/bt_target.h" #include "osi/pkt_queue.h" #include "stack/bt_types.h" -#if ((BT_CONTROLLER_INCLUDED == TRUE) && SOC_ESP_NIMBLE_CONTROLLER) -#include "os/os_mbuf.h" -#endif + typedef enum { DATA_TYPE_COMMAND = 1, DATA_TYPE_ACL = 2, @@ -87,11 +85,6 @@ typedef struct hci_hal_t { // Gets the correct hal implementation, as compiled for. const hci_hal_t *hci_hal_h4_get_interface(void); -#if ((BT_CONTROLLER_INCLUDED == TRUE) && SOC_ESP_NIMBLE_CONTROLLER) -int ble_hs_hci_rx_evt(uint8_t *hci_ev, void *arg); - -int ble_hs_rx_data(struct os_mbuf *om, void *arg); -#endif #endif /* _HCI_HAL_H */ diff --git a/components/bt/host/nimble/port/include/esp_nimble_mem.h b/components/bt/host/nimble/port/include/esp_nimble_mem.h index d0c5a751850..dd60c741cfe 100644 --- a/components/bt/host/nimble/port/include/esp_nimble_mem.h +++ b/components/bt/host/nimble/port/include/esp_nimble_mem.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2015-2026 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -13,9 +13,95 @@ extern "C" { #endif -// #pragma message "This file should be replaced with bt_osi_mem.h, used here for compatibility" +void *nimble_mem_malloc(size_t size); + +void *nimble_mem_calloc(size_t n, size_t size); + +void nimble_mem_free(void *ptr); + +#if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED +size_t nimble_mem_used_size_get(void); +#endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED + +#if CONFIG_BT_NIMBLE_MEM_DEBUG +/** + * @brief Initialize NimBLE memory debug module + */ +void nimble_mem_dbg_init(void); + +/** + * @brief Record memory allocation information + * + * @param p Pointer to allocated memory + * @param size Size of allocation + * @param func Function name where allocation occurred + * @param line Line number where allocation occurred + */ +void nimble_mem_dbg_record(void *p, int size, const char *func, int line); + +/** + * @brief Clean up memory allocation record + * + * @param p Pointer to memory being freed + * @param func Function name where free occurred + * @param line Line number where free occurred + */ +void nimble_mem_dbg_clean(void *p, const char *func, int line); + +/** + * @brief Display all memory debug information + */ +void nimble_mem_dbg_show(void); + +/** + * @brief Get maximum memory size used + * + * @return Maximum memory size in bytes + */ +uint32_t nimble_mem_dbg_get_max_size(void); + +/** + * @brief Get current memory size in use + * + * @return Current memory size in bytes + */ +uint32_t nimble_mem_dbg_get_current_size(void); + +/** + * @brief Start tracking memory usage for a specific section + * + * @param index Section index (0 to NIMBLE_MEM_DBG_MAX_SECTION_NUM-1) + */ +void nimble_mem_dbg_set_section_start(uint8_t index); + +/** + * @brief Stop tracking memory usage for a specific section + * + * @param index Section index (0 to NIMBLE_MEM_DBG_MAX_SECTION_NUM-1) + */ +void nimble_mem_dbg_set_section_end(uint8_t index); + +/** + * @brief Get maximum memory size used in a specific section + * + * @param index Section index (0 to NIMBLE_MEM_DBG_MAX_SECTION_NUM-1) + * @return Maximum memory size in bytes for this section + */ +uint32_t nimble_mem_dbg_get_max_size_section(uint8_t index); + +/** + * @brief Reallocate memory with debug tracking + * + * @param ptr Pointer to memory to reallocate + * @param new_size New size of allocation + * @param func Function name where realloc occurred + * @param line Line number where realloc occurred + * @return Pointer to reallocated memory + */ +void *nimble_mem_dbg_realloc(void *ptr, size_t new_size, const char *func, int line); + +#endif // CONFIG_BT_NIMBLE_MEM_DEBUG -#include "bt_osi_mem.h" #if CONFIG_BT_NIMBLE_MEM_DEBUG @@ -23,7 +109,7 @@ extern "C" { ({ \ void *p; \ do { \ - p = bt_osi_mem_malloc(size); \ + p = nimble_mem_malloc(size); \ nimble_mem_dbg_record(p, size, __func__, __LINE__); \ } while (0); \ p; \ @@ -33,7 +119,7 @@ extern "C" { ({ \ void *p; \ do { \ - p = bt_osi_mem_calloc(count, size); \ + p = nimble_mem_calloc(count, size); \ nimble_mem_dbg_record(p, (count) * (size), __func__, __LINE__); \ } while (0); \ p; \ @@ -49,18 +135,18 @@ extern "C" { }) #define nimble_platform_mem_free(ptr) \ -do { \ - void *tmp_ptr = (void *)(ptr); \ +do { \ + void *tmp_ptr = (void *)(ptr); \ nimble_mem_dbg_clean(tmp_ptr, __func__, __LINE__); \ - bt_osi_mem_free(tmp_ptr); \ + nimble_mem_free(tmp_ptr); \ } while (0) #else -#define nimble_platform_mem_malloc bt_osi_mem_malloc -#define nimble_platform_mem_calloc bt_osi_mem_calloc +#define nimble_platform_mem_malloc nimble_mem_malloc +#define nimble_platform_mem_calloc nimble_mem_calloc #define nimble_platform_mem_realloc realloc -#define nimble_platform_mem_free bt_osi_mem_free +#define nimble_platform_mem_free nimble_mem_free #endif // CONFIG_BT_NIMBLE_MEM_DEBUG diff --git a/components/bt/host/nimble/port/src/esp_nimble_mem.c b/components/bt/host/nimble/port/src/esp_nimble_mem.c new file mode 100644 index 00000000000..3f8e8ed55d0 --- /dev/null +++ b/components/bt/host/nimble/port/src/esp_nimble_mem.c @@ -0,0 +1,339 @@ +/* + * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "esp_attr.h" +#include "esp_heap_caps.h" +#include "sdkconfig.h" +#include "esp_log.h" +#include + +static uint8_t log_count; +#if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED +static size_t host_mem_used_size = 0; +#endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED + +#if CONFIG_BT_NIMBLE_MEM_DEBUG + +#define NIMBLE_MEM_DBG_INFO_MAX (1024*3) +typedef struct { + void *p; + int size; + const char *func; + int line; +} nimble_mem_dbg_info_t; + +static uint32_t nimble_mem_dbg_count = 0; +static nimble_mem_dbg_info_t nimble_mem_dbg_info[NIMBLE_MEM_DBG_INFO_MAX]; +static uint32_t nimble_mem_dbg_current_size = 0; +static uint32_t nimble_mem_dbg_max_size = 0; + +#define NIMBLE_MEM_DBG_MAX_SECTION_NUM 5 +typedef struct { + bool used; + uint32_t max_size; +} nimble_mem_dbg_max_size_section_t; +static nimble_mem_dbg_max_size_section_t nimble_mem_dbg_max_size_section[NIMBLE_MEM_DBG_MAX_SECTION_NUM]; + +void nimble_mem_dbg_init(void) +{ + int i; + + for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) { + nimble_mem_dbg_info[i].p = NULL; + nimble_mem_dbg_info[i].size = 0; + nimble_mem_dbg_info[i].func = NULL; + nimble_mem_dbg_info[i].line = 0; + } + nimble_mem_dbg_count = 0; + nimble_mem_dbg_current_size = 0; + nimble_mem_dbg_max_size = 0; + + for (i = 0; i < NIMBLE_MEM_DBG_MAX_SECTION_NUM; i++){ + nimble_mem_dbg_max_size_section[i].used = false; + nimble_mem_dbg_max_size_section[i].max_size = 0; + } +} + +void nimble_mem_dbg_record(void *p, int size, const char *func, int line) +{ + int i; + + if (!p || size == 0) { + ESP_LOGE("BT_NIMBLE_MEM", "%s invalid !!\n", __func__); + return; + } + + for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) { + if (nimble_mem_dbg_info[i].p == NULL) { + nimble_mem_dbg_info[i].p = p; + nimble_mem_dbg_info[i].size = size; + nimble_mem_dbg_info[i].func = func; + nimble_mem_dbg_info[i].line = line; + nimble_mem_dbg_count++; + break; + } + } + + if (i >= NIMBLE_MEM_DBG_INFO_MAX) { + ESP_LOGE("BT_NIMBLE_MEM", "%s full %s %d !!\n", __func__, func, line); + } + + nimble_mem_dbg_current_size += size; + if(nimble_mem_dbg_max_size < nimble_mem_dbg_current_size) { + nimble_mem_dbg_max_size = nimble_mem_dbg_current_size; + } + + for (i = 0; i < NIMBLE_MEM_DBG_MAX_SECTION_NUM; i++){ + if (nimble_mem_dbg_max_size_section[i].used) { + if(nimble_mem_dbg_max_size_section[i].max_size < nimble_mem_dbg_current_size) { + nimble_mem_dbg_max_size_section[i].max_size = nimble_mem_dbg_current_size; + } + } + } +} + +void nimble_mem_dbg_clean(void *p, const char *func, int line) +{ + int i; + + if (!p) { + ESP_LOGE("BT_NIMBLE_MEM", "%s %d free->%p invalid\n", func, line, p); + return; + } + + for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) { + if (nimble_mem_dbg_info[i].p == p) { + nimble_mem_dbg_current_size -= nimble_mem_dbg_info[i].size; + nimble_mem_dbg_info[i].p = NULL; + nimble_mem_dbg_info[i].size = 0; + nimble_mem_dbg_info[i].func = NULL; + nimble_mem_dbg_info[i].line = 0; + nimble_mem_dbg_count--; + break; + } + } + + if (i >= NIMBLE_MEM_DBG_INFO_MAX) { + ESP_LOGE("BT_NIMBLE_MEM", "%s not found %s %d !!\n", __func__, func, line); + } +} + +void nimble_mem_dbg_show(void) +{ + int i; + + for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) { + if (nimble_mem_dbg_info[i].p || nimble_mem_dbg_info[i].size != 0 ) { + ESP_LOGE("BT_NIMBLE_MEM", "--> p %p, s %d, f %s, l %d\n", + nimble_mem_dbg_info[i].p, nimble_mem_dbg_info[i].size, + nimble_mem_dbg_info[i].func, nimble_mem_dbg_info[i].line); + } + } + ESP_LOGE("BT_NIMBLE_MEM", "--> count %ld\n", nimble_mem_dbg_count); + ESP_LOGE("BT_NIMBLE_MEM", "--> size %ldB\n--> max size %ldB\n", + nimble_mem_dbg_current_size, nimble_mem_dbg_max_size); +} + +uint32_t nimble_mem_dbg_get_max_size(void) +{ + return nimble_mem_dbg_max_size; +} + +uint32_t nimble_mem_dbg_get_current_size(void) +{ + return nimble_mem_dbg_current_size; +} + +void nimble_mem_dbg_set_section_start(uint8_t index) +{ + if (index >= NIMBLE_MEM_DBG_MAX_SECTION_NUM) { + ESP_LOGE("BT_NIMBLE_MEM", "Then range of index should be between 0 and %d, current index is %d.\n", + NIMBLE_MEM_DBG_MAX_SECTION_NUM - 1, index); + return; + } + + if (nimble_mem_dbg_max_size_section[index].used) { + ESP_LOGW("BT_NIMBLE_MEM", "This index(%d) has been started, restart it.\n", index); + } + + nimble_mem_dbg_max_size_section[index].used = true; + nimble_mem_dbg_max_size_section[index].max_size = nimble_mem_dbg_current_size; +} + +void nimble_mem_dbg_set_section_end(uint8_t index) +{ + if (index >= NIMBLE_MEM_DBG_MAX_SECTION_NUM) { + ESP_LOGE("BT_NIMBLE_MEM", "Then range of index should be between 0 and %d, current index is %d.\n", + NIMBLE_MEM_DBG_MAX_SECTION_NUM - 1, index); + return; + } + + if (!nimble_mem_dbg_max_size_section[index].used) { + ESP_LOGE("BT_NIMBLE_MEM", "This index(%d) has not been started.\n", index); + return; + } + + nimble_mem_dbg_max_size_section[index].used = false; +} + +uint32_t nimble_mem_dbg_get_max_size_section(uint8_t index) +{ + if (index >= NIMBLE_MEM_DBG_MAX_SECTION_NUM){ + ESP_LOGE("BT_NIMBLE_MEM", "Then range of index should be between 0 and %d, current index is %d.\n", + NIMBLE_MEM_DBG_MAX_SECTION_NUM - 1, index); + return 0; + } + + return nimble_mem_dbg_max_size_section[index].max_size; +} + +void *nimble_mem_dbg_realloc(void *ptr, size_t new_size, const char *func, int line) +{ + size_t old_size = 0; + int i; + + void *new_ptr = realloc(ptr, new_size); + if (new_ptr == NULL && new_size > 0) { + // realloc failed, keep old ptr record + return NULL; + } + + // Find and clean old record if ptr is not NULL + if (ptr != NULL) { + for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) { + if (nimble_mem_dbg_info[i].p == ptr) { + old_size = nimble_mem_dbg_info[i].size; + nimble_mem_dbg_current_size -= old_size; + + nimble_mem_dbg_info[i].p = NULL; + nimble_mem_dbg_info[i].size = 0; + nimble_mem_dbg_info[i].func = NULL; + nimble_mem_dbg_info[i].line = 0; + nimble_mem_dbg_count--; + break; + } + } + } + + // Record the new allocation if new_size > 0 + if (new_ptr != NULL && new_size > 0) { + for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) { + if (nimble_mem_dbg_info[i].p == NULL) { + nimble_mem_dbg_info[i].p = new_ptr; + nimble_mem_dbg_info[i].size = new_size; + nimble_mem_dbg_info[i].func = func; + nimble_mem_dbg_info[i].line = line; + nimble_mem_dbg_count++; + break; + } + } + + if (i >= NIMBLE_MEM_DBG_INFO_MAX) { + ESP_LOGE("BT_NIMBLE_MEM", "%s full %s %d !!\n", __func__, func, line); + } + + nimble_mem_dbg_current_size += new_size; + if (nimble_mem_dbg_max_size < nimble_mem_dbg_current_size) { + nimble_mem_dbg_max_size = nimble_mem_dbg_current_size; + } + + for (i = 0; i < NIMBLE_MEM_DBG_MAX_SECTION_NUM; i++) { + if (nimble_mem_dbg_max_size_section[i].used && + nimble_mem_dbg_max_size_section[i].max_size < nimble_mem_dbg_current_size) { + nimble_mem_dbg_max_size_section[i].max_size = nimble_mem_dbg_current_size; + } + } + } + + return new_ptr; +} +#endif // CONFIG_BT_NIMBLE_MEM_DEBUG + +#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE +IRAM_ATTR +#endif +void *nimble_mem_malloc(size_t size) +{ + void *mem = NULL; +#ifdef CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_INTERNAL + mem = heap_caps_malloc(size, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); +#elif CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_EXTERNAL + mem = heap_caps_malloc(size, MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT); +#elif CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_IRAM_8BIT + mem = heap_caps_malloc_prefer(size, 2, MALLOC_CAP_INTERNAL|MALLOC_CAP_IRAM_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); +#else + mem = malloc(size); +#endif + if (!mem) { + log_count ++; + if ((log_count % 100) == 0) { + ESP_EARLY_LOGI("ESP_LOG_INFO","malloc failed (size %zu)",size); + log_count = 0; + } + assert(mem != NULL); + } +#if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED + if(mem) { + host_mem_used_size += heap_caps_get_allocated_size(mem); + } +#endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED + return mem; +} + +#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE +IRAM_ATTR +#endif +void *nimble_mem_calloc(size_t n, size_t size) +{ + void *mem = NULL; +#ifdef CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_INTERNAL + mem = heap_caps_calloc(n, size, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); +#elif CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_EXTERNAL + mem = heap_caps_calloc(n, size, MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT); +#elif CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_IRAM_8BIT + mem = heap_caps_calloc_prefer(n, size, 2, MALLOC_CAP_INTERNAL|MALLOC_CAP_IRAM_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); +#else + mem = calloc(n, size); +#endif +#if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED + if(mem) { + host_mem_used_size += heap_caps_get_allocated_size(mem); + } +#endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED + return mem; +} + +#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE +IRAM_ATTR +#endif +void nimble_mem_free(void *ptr) +{ +#if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED + if (ptr) { + size_t alloc_size = heap_caps_get_allocated_size(ptr); + // assert(host_mem_used_size >= alloc_size); + host_mem_used_size -= alloc_size; + } +#endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED + if (ptr) { + heap_caps_free(ptr); + } +} + +#if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED +size_t +nimble_mem_used_size_get(void) +{ + return host_mem_used_size; +} + +#if CONFIG_BT_NIMBLE_ENABLED +uint32_t esp_host_used_heap_size_get(void) +{ + return nimble_mem_used_size_get(); +} +#endif // CONFIG_BT_NIMBLE_ENABLED +#endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED diff --git a/components/bt/porting/include/bt_osi_mem.h b/components/bt/porting/include/bt_osi_mem.h index 8a8c448b1d9..fc35c482bab 100644 --- a/components/bt/porting/include/bt_osi_mem.h +++ b/components/bt/porting/include/bt_osi_mem.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2015-2026 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -10,101 +10,21 @@ #include "esp_attr.h" #include "esp_heap_caps.h" + void *bt_osi_mem_malloc(size_t size); -void *bt_osi_mem_calloc(size_t n, size_t size); +void bt_osi_mem_free(void *ptr); void *bt_osi_mem_malloc_internal(size_t size); void *bt_osi_mem_calloc_internal(size_t n, size_t size); -void bt_osi_mem_free(void *ptr); - void bt_osi_mem_free_internal(void *ptr); + #if CONFIG_BT_LE_MEM_CHECK_ENABLED void bt_osi_mem_count_limit_set(uint16_t count_limit); #endif // CONFIG_BT_LE_MEM_CHECK_ENABLED #if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED size_t bt_osi_mem_internal_used_size_get(void); -size_t bt_osi_mem_used_size_get(void); #endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED - -#if CONFIG_BT_NIMBLE_MEM_DEBUG -/** - * @brief Initialize NimBLE memory debug module - */ -void nimble_mem_dbg_init(void); - -/** - * @brief Record memory allocation information - * - * @param p Pointer to allocated memory - * @param size Size of allocation - * @param func Function name where allocation occurred - * @param line Line number where allocation occurred - */ -void nimble_mem_dbg_record(void *p, int size, const char *func, int line); - -/** - * @brief Clean up memory allocation record - * - * @param p Pointer to memory being freed - * @param func Function name where free occurred - * @param line Line number where free occurred - */ -void nimble_mem_dbg_clean(void *p, const char *func, int line); - -/** - * @brief Display all memory debug information - */ -void nimble_mem_dbg_show(void); - -/** - * @brief Get maximum memory size used - * - * @return Maximum memory size in bytes - */ -uint32_t nimble_mem_dbg_get_max_size(void); - -/** - * @brief Get current memory size in use - * - * @return Current memory size in bytes - */ -uint32_t nimble_mem_dbg_get_current_size(void); - -/** - * @brief Start tracking memory usage for a specific section - * - * @param index Section index (0 to NIMBLE_MEM_DBG_MAX_SECTION_NUM-1) - */ -void nimble_mem_dbg_set_section_start(uint8_t index); - -/** - * @brief Stop tracking memory usage for a specific section - * - * @param index Section index (0 to NIMBLE_MEM_DBG_MAX_SECTION_NUM-1) - */ -void nimble_mem_dbg_set_section_end(uint8_t index); - -/** - * @brief Get maximum memory size used in a specific section - * - * @param index Section index (0 to NIMBLE_MEM_DBG_MAX_SECTION_NUM-1) - * @return Maximum memory size in bytes for this section - */ -uint32_t nimble_mem_dbg_get_max_size_section(uint8_t index); - -/** - * @brief Reallocate memory with debug tracking - * - * @param ptr Pointer to memory to reallocate - * @param new_size New size of allocation - * @param func Function name where realloc occurred - * @param line Line number where realloc occurred - * @return Pointer to reallocated memory - */ -void *nimble_mem_dbg_realloc(void *ptr, size_t new_size, const char *func, int line); - -#endif // CONFIG_BT_NIMBLE_MEM_DEBUG diff --git a/components/bt/porting/mem/bt_osi_mem.c b/components/bt/porting/mem/bt_osi_mem.c index e020abbf77e..537dc8def1e 100644 --- a/components/bt/porting/mem/bt_osi_mem.c +++ b/components/bt/porting/mem/bt_osi_mem.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2015-2026 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -10,311 +10,17 @@ #include "esp_log.h" #include -static uint8_t log_count; #if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED static size_t controller_mem_used_size = 0; -static size_t host_mem_used_size = 0; #endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED + #if CONFIG_BT_LE_MEM_CHECK_ENABLED static uint16_t mem_count_limit = 0; static uint16_t curr_mem_count; #endif // CONFIG_BT_LE_MEM_CHECK_ENABLED -#if CONFIG_BT_NIMBLE_MEM_DEBUG - -#define NIMBLE_MEM_DBG_INFO_MAX 1024*3 -typedef struct { - void *p; - int size; - const char *func; - int line; -} nimble_mem_dbg_info_t; - -static uint32_t nimble_mem_dbg_count = 0; -static nimble_mem_dbg_info_t nimble_mem_dbg_info[NIMBLE_MEM_DBG_INFO_MAX]; -static uint32_t nimble_mem_dbg_current_size = 0; -static uint32_t nimble_mem_dbg_max_size = 0; - -#define NIMBLE_MEM_DBG_MAX_SECTION_NUM 5 -typedef struct { - bool used; - uint32_t max_size; -} nimble_mem_dbg_max_size_section_t; -static nimble_mem_dbg_max_size_section_t nimble_mem_dbg_max_size_section[NIMBLE_MEM_DBG_MAX_SECTION_NUM]; - -void nimble_mem_dbg_init(void) -{ - int i; - - for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) { - nimble_mem_dbg_info[i].p = NULL; - nimble_mem_dbg_info[i].size = 0; - nimble_mem_dbg_info[i].func = NULL; - nimble_mem_dbg_info[i].line = 0; - } - nimble_mem_dbg_count = 0; - nimble_mem_dbg_current_size = 0; - nimble_mem_dbg_max_size = 0; - - for (i = 0; i < NIMBLE_MEM_DBG_MAX_SECTION_NUM; i++){ - nimble_mem_dbg_max_size_section[i].used = false; - nimble_mem_dbg_max_size_section[i].max_size = 0; - } -} - -void nimble_mem_dbg_record(void *p, int size, const char *func, int line) -{ - int i; - - if (!p || size == 0) { - ESP_LOGE("BT_NIMBLE_MEM", "%s invalid !!\n", __func__); - return; - } - - for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) { - if (nimble_mem_dbg_info[i].p == NULL) { - nimble_mem_dbg_info[i].p = p; - nimble_mem_dbg_info[i].size = size; - nimble_mem_dbg_info[i].func = func; - nimble_mem_dbg_info[i].line = line; - nimble_mem_dbg_count++; - break; - } - } - - if (i >= NIMBLE_MEM_DBG_INFO_MAX) { - ESP_LOGE("BT_NIMBLE_MEM", "%s full %s %d !!\n", __func__, func, line); - } - - nimble_mem_dbg_current_size += size; - if(nimble_mem_dbg_max_size < nimble_mem_dbg_current_size) { - nimble_mem_dbg_max_size = nimble_mem_dbg_current_size; - } - - for (i = 0; i < NIMBLE_MEM_DBG_MAX_SECTION_NUM; i++){ - if (nimble_mem_dbg_max_size_section[i].used) { - if(nimble_mem_dbg_max_size_section[i].max_size < nimble_mem_dbg_current_size) { - nimble_mem_dbg_max_size_section[i].max_size = nimble_mem_dbg_current_size; - } - } - } -} - -void nimble_mem_dbg_clean(void *p, const char *func, int line) -{ - int i; - - if (!p) { - ESP_LOGE("BT_NIMBLE_MEM", "%s %d free->%p invalid\n", func, line, p); - return; - } - - for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) { - if (nimble_mem_dbg_info[i].p == p) { - nimble_mem_dbg_current_size -= nimble_mem_dbg_info[i].size; - nimble_mem_dbg_info[i].p = NULL; - nimble_mem_dbg_info[i].size = 0; - nimble_mem_dbg_info[i].func = NULL; - nimble_mem_dbg_info[i].line = 0; - nimble_mem_dbg_count--; - break; - } - } - - if (i >= NIMBLE_MEM_DBG_INFO_MAX) { - ESP_LOGE("BT_NIMBLE_MEM", "%s full %s %d !!\n", __func__, func, line); - } -} - -void nimble_mem_dbg_show(void) -{ - int i; - - for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) { - if (nimble_mem_dbg_info[i].p || nimble_mem_dbg_info[i].size != 0 ) { - ESP_LOGE("BT_NIMBLE_MEM", "--> p %p, s %d, f %s, l %d\n", - nimble_mem_dbg_info[i].p, nimble_mem_dbg_info[i].size, - nimble_mem_dbg_info[i].func, nimble_mem_dbg_info[i].line); - } - } - ESP_LOGE("BT_NIMBLE_MEM", "--> count %ld\n", nimble_mem_dbg_count); - ESP_LOGE("BT_NIMBLE_MEM", "--> size %ldB\n--> max size %ldB\n", - nimble_mem_dbg_current_size, nimble_mem_dbg_max_size); -} - -uint32_t nimble_mem_dbg_get_max_size(void) -{ - return nimble_mem_dbg_max_size; -} - -uint32_t nimble_mem_dbg_get_current_size(void) -{ - return nimble_mem_dbg_current_size; -} - -void nimble_mem_dbg_set_section_start(uint8_t index) -{ - if (index >= NIMBLE_MEM_DBG_MAX_SECTION_NUM) { - ESP_LOGE("BT_NIMBLE_MEM", "Then range of index should be between 0 and %d, current index is %d.\n", - NIMBLE_MEM_DBG_MAX_SECTION_NUM - 1, index); - return; - } - - if (nimble_mem_dbg_max_size_section[index].used) { - ESP_LOGW("BT_NIMBLE_MEM", "This index(%d) has been started, restart it.\n", index); - } - - nimble_mem_dbg_max_size_section[index].used = true; - nimble_mem_dbg_max_size_section[index].max_size = nimble_mem_dbg_current_size; -} - -void nimble_mem_dbg_set_section_end(uint8_t index) -{ - if (index >= NIMBLE_MEM_DBG_MAX_SECTION_NUM) { - ESP_LOGE("BT_NIMBLE_MEM", "Then range of index should be between 0 and %d, current index is %d.\n", - NIMBLE_MEM_DBG_MAX_SECTION_NUM - 1, index); - return; - } - - if (!nimble_mem_dbg_max_size_section[index].used) { - ESP_LOGE("BT_NIMBLE_MEM", "This index(%d) has not been started.\n", index); - return; - } - - nimble_mem_dbg_max_size_section[index].used = false; -} - -uint32_t nimble_mem_dbg_get_max_size_section(uint8_t index) -{ - if (index >= NIMBLE_MEM_DBG_MAX_SECTION_NUM){ - ESP_LOGE("BT_NIMBLE_MEM", "Then range of index should be between 0 and %d, current index is %d.\n", - NIMBLE_MEM_DBG_MAX_SECTION_NUM - 1, index); - return 0; - } - - return nimble_mem_dbg_max_size_section[index].max_size; -} - -void *nimble_mem_dbg_realloc(void *ptr, size_t new_size, const char *func, int line) -{ - size_t old_size = 0; - int i; - - void *new_ptr = realloc(ptr, new_size); - if (new_ptr == NULL && new_size > 0) { - // realloc failed, keep old ptr record - return NULL; - } - - // Find and clean old record if ptr is not NULL - if (ptr != NULL) { - for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) { - if (nimble_mem_dbg_info[i].p == ptr) { - old_size = nimble_mem_dbg_info[i].size; - nimble_mem_dbg_current_size -= old_size; - - nimble_mem_dbg_info[i].p = NULL; - nimble_mem_dbg_info[i].size = 0; - nimble_mem_dbg_info[i].func = NULL; - nimble_mem_dbg_info[i].line = 0; - nimble_mem_dbg_count--; - break; - } - } - } - - // Record the new allocation if new_size > 0 - if (new_ptr != NULL && new_size > 0) { - for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) { - if (nimble_mem_dbg_info[i].p == NULL) { - nimble_mem_dbg_info[i].p = new_ptr; - nimble_mem_dbg_info[i].size = new_size; - nimble_mem_dbg_info[i].func = func; - nimble_mem_dbg_info[i].line = line; - nimble_mem_dbg_count++; - break; - } - } - - if (i >= NIMBLE_MEM_DBG_INFO_MAX) { - ESP_LOGE("BT_NIMBLE_MEM", "%s full %s %d !!\n", __func__, func, line); - } - - nimble_mem_dbg_current_size += new_size; - if (nimble_mem_dbg_max_size < nimble_mem_dbg_current_size) { - nimble_mem_dbg_max_size = nimble_mem_dbg_current_size; - } - - for (i = 0; i < NIMBLE_MEM_DBG_MAX_SECTION_NUM; i++) { - if (nimble_mem_dbg_max_size_section[i].used && - nimble_mem_dbg_max_size_section[i].max_size < nimble_mem_dbg_current_size) { - nimble_mem_dbg_max_size_section[i].max_size = nimble_mem_dbg_current_size; - } - } - } - - return new_ptr; -} -#endif // CONFIG_BT_NIMBLE_MEM_DEBUG - -#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE -IRAM_ATTR -#endif -void *bt_osi_mem_malloc(size_t size) -{ - void *mem = NULL; -#ifdef CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_INTERNAL - mem = heap_caps_malloc(size, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); -#elif CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_EXTERNAL - mem = heap_caps_malloc(size, MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT); -#elif CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_IRAM_8BIT - mem = heap_caps_malloc_prefer(size, 2, MALLOC_CAP_INTERNAL|MALLOC_CAP_IRAM_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); -#else - mem = malloc(size); -#endif - if (!mem) { - log_count ++; - if ((log_count % 100) == 0) { - ESP_EARLY_LOGI("ESP_LOG_INFO","malloc failed (size %zu)",size); - log_count = 0; - } - assert(mem != NULL); - } -#if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED - if(mem) { - host_mem_used_size += heap_caps_get_allocated_size(mem); - } -#endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED - return mem; -} - -#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE -IRAM_ATTR -#endif -void *bt_osi_mem_calloc(size_t n, size_t size) -{ - void *mem = NULL; -#ifdef CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_INTERNAL - mem = heap_caps_calloc(n, size, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); -#elif CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_EXTERNAL - mem = heap_caps_calloc(n, size, MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT); -#elif CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_IRAM_8BIT - mem = heap_caps_calloc_prefer(n, size, 2, MALLOC_CAP_INTERNAL|MALLOC_CAP_IRAM_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); -#else - mem = calloc(n, size); -#endif -#if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED - if(mem) { - host_mem_used_size += heap_caps_get_allocated_size(mem); - } -#endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED - return mem; -} - -#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE -IRAM_ATTR -#endif -void *bt_osi_mem_malloc_internal(size_t size) +void * +bt_osi_mem_malloc_internal(size_t size) { void *mem_ptr; #if CONFIG_BT_LE_MEM_CHECK_ENABLED @@ -334,10 +40,9 @@ void *bt_osi_mem_malloc_internal(size_t size) return mem_ptr; } -#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE -IRAM_ATTR -#endif -void *bt_osi_mem_calloc_internal(size_t n, size_t size) + +void * +bt_osi_mem_calloc_internal(size_t n, size_t size) { void *mem_ptr; #if CONFIG_BT_LE_MEM_CHECK_ENABLED @@ -357,10 +62,8 @@ void *bt_osi_mem_calloc_internal(size_t n, size_t size) return mem_ptr; } -#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE -IRAM_ATTR -#endif -void bt_osi_mem_free_internal(void *ptr) +void +bt_osi_mem_free_internal(void *ptr) { #if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED if (ptr) { @@ -374,21 +77,35 @@ void bt_osi_mem_free_internal(void *ptr) } } -#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE -IRAM_ATTR -#endif -void bt_osi_mem_free(void *ptr) +void * +bt_osi_mem_malloc(size_t size) { + void *mem_ptr; + +#if CONFIG_BT_LE_MEM_CHECK_ENABLED + if (mem_count_limit) { + if (curr_mem_count > mem_count_limit) { + return NULL; + } + curr_mem_count ++; + } +#endif // CONFIG_BT_LE_MEM_CHECK_ENABLED + + mem_ptr = heap_caps_malloc(size, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); + #if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED - if (ptr) { - size_t alloc_size = heap_caps_get_allocated_size(ptr); - // assert(host_mem_used_size >= alloc_size); - host_mem_used_size -= alloc_size; + if (mem_ptr) { + controller_mem_used_size += heap_caps_get_allocated_size(mem_ptr); } #endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED - if (ptr) { - heap_caps_free(ptr); - } + + return mem_ptr; +} + +void +bt_osi_mem_free(void *ptr) +{ + bt_osi_mem_free_internal(ptr); } #if CONFIG_BT_LE_MEM_CHECK_ENABLED @@ -406,21 +123,8 @@ bt_osi_mem_internal_used_size_get(void) return controller_mem_used_size; } -size_t -bt_osi_mem_used_size_get(void) -{ - return host_mem_used_size; -} - uint32_t esp_ble_controller_used_heap_size_get(void) { return bt_osi_mem_internal_used_size_get(); } - -#if CONFIG_BT_NIMBLE_ENABLED -uint32_t esp_host_used_heap_size_get(void) -{ - return bt_osi_mem_used_size_get(); -} -#endif // CONFIG_BT_NIMBLE_ENABLED #endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED diff --git a/components/bt/porting/mem/os_mempool.c b/components/bt/porting/mem/os_mempool.c index 6893ec4a0e4..6f8314c69dc 100644 --- a/components/bt/porting/mem/os_mempool.c +++ b/components/bt/porting/mem/os_mempool.c @@ -513,9 +513,11 @@ os_memblock_get(struct os_mempool *mp) // Should not happen OS_ENTER_CRITICAL(sr); mp->mp_num_free++; +#if MYNEWT_VAL(MP_BLOCK_REUSED) if (mp->mp_flags & OS_MEMPOOL_F_REUSED) { mp->mp_alloc_blocks--; } +#endif OS_EXIT_CRITICAL(sr); } } else if (block) { diff --git a/components/bt/porting/mem/os_msys_init.c b/components/bt/porting/mem/os_msys_init.c index 5465e41e535..f492b9572d3 100644 --- a/components/bt/porting/mem/os_msys_init.c +++ b/components/bt/porting/mem/os_msys_init.c @@ -12,7 +12,6 @@ #include "mem_api.h" #include "bt_osi_mem.h" #include "esp_err.h" -#include "esp_nimble_mem.h" #if CONFIG_BT_NIMBLE_ENABLED #include "syscfg/syscfg.h" @@ -122,11 +121,13 @@ ble_os_msys_ensure_ctx(void) return 0; } - os_msys_ctx = nimble_platform_mem_calloc(1, sizeof(*os_msys_ctx)); + os_msys_ctx = bt_osi_mem_malloc(sizeof(*os_msys_ctx)); if(!os_msys_ctx) { return -1; } + memset(os_msys_ctx, 0, sizeof(*os_msys_ctx)); + return 0; } #endif // !CONFIG_BT_LE_MSYS_INIT_IN_CONTROLLER && CONFIG_BT_NIMBLE_STATIC_TO_DYNAMIC @@ -230,9 +231,9 @@ os_msys_buf_alloc(void) #if CONFIG_BT_NIMBLE_STATIC_TO_DYNAMIC #if OS_MSYS_1_BLOCK_COUNT > 0 if (!os_msys_ctx->init_1_data) { - os_msys_ctx->init_1_data = nimble_platform_mem_calloc(1, (sizeof(os_membuf_t) * SYSINIT_MSYS_1_MEMPOOL_SIZE)); + os_msys_ctx->init_1_data = bt_osi_mem_malloc((sizeof(os_membuf_t) * SYSINIT_MSYS_1_MEMPOOL_SIZE)); if(!os_msys_ctx->init_1_data){ - nimble_platform_mem_free(os_msys_ctx); + bt_osi_mem_free(os_msys_ctx); os_msys_ctx = NULL; return ESP_FAIL; } @@ -241,13 +242,13 @@ os_msys_buf_alloc(void) #if OS_MSYS_2_BLOCK_COUNT > 0 if (!os_msys_ctx->init_2_data) { - os_msys_ctx->init_2_data = nimble_platform_mem_calloc(1, (sizeof(os_membuf_t) * SYSINIT_MSYS_2_MEMPOOL_SIZE)); + os_msys_ctx->init_2_data = bt_osi_mem_malloc((sizeof(os_membuf_t) * SYSINIT_MSYS_2_MEMPOOL_SIZE)); if(!os_msys_ctx->init_2_data) { #if OS_MSYS_1_BLOCK_COUNT > 0 - nimble_platform_mem_free(os_msys_ctx->init_1_data); + bt_osi_mem_free(os_msys_ctx->init_1_data); os_msys_ctx->init_1_data = NULL; #endif - nimble_platform_mem_free(os_msys_ctx); + bt_osi_mem_free(os_msys_ctx); os_msys_ctx = NULL; return ESP_FAIL; } @@ -256,17 +257,17 @@ os_msys_buf_alloc(void) #endif #else #if OS_MSYS_1_BLOCK_COUNT > 0 - os_msys_init_1_data = (os_membuf_t *)nimble_platform_mem_calloc(1, (sizeof(os_membuf_t) * SYSINIT_MSYS_1_MEMPOOL_SIZE)); + os_msys_init_1_data = (os_membuf_t *)bt_osi_mem_malloc((sizeof(os_membuf_t) * SYSINIT_MSYS_1_MEMPOOL_SIZE)); if (!os_msys_init_1_data) { return ESP_ERR_NO_MEM; } #endif #if OS_MSYS_2_BLOCK_COUNT > 0 - os_msys_init_2_data = (os_membuf_t *)nimble_platform_mem_calloc(1, (sizeof(os_membuf_t) * SYSINIT_MSYS_2_MEMPOOL_SIZE)); + os_msys_init_2_data = (os_membuf_t *)bt_osi_mem_malloc((sizeof(os_membuf_t) * SYSINIT_MSYS_2_MEMPOOL_SIZE)); if (!os_msys_init_2_data) { #if OS_MSYS_1_BLOCK_COUNT > 0 - nimble_platform_mem_free(os_msys_init_1_data); + bt_osi_mem_free(os_msys_init_1_data); os_msys_init_1_data = NULL; #endif return ESP_ERR_NO_MEM; @@ -284,34 +285,34 @@ os_msys_buf_free(void) if (os_msys_ctx) { #if OS_MSYS_1_BLOCK_COUNT > 0 if (os_msys_ctx->init_1_data) { - nimble_platform_mem_free(os_msys_ctx->init_1_data); + bt_osi_mem_free(os_msys_ctx->init_1_data); os_msys_ctx->init_1_data = NULL; } os_mempool_unregister(&os_msys_ctx->init_1_mempool); #endif #if OS_MSYS_2_BLOCK_COUNT > 0 if (os_msys_ctx->init_2_data) { - nimble_platform_mem_free(os_msys_ctx->init_2_data); + bt_osi_mem_free(os_msys_ctx->init_2_data); os_msys_ctx->init_2_data = NULL; } os_mempool_unregister(&os_msys_ctx->init_2_mempool); #endif - nimble_platform_mem_free(os_msys_ctx); + bt_osi_mem_free(os_msys_ctx); os_msys_ctx = NULL; } #else #if OS_MSYS_1_BLOCK_COUNT > 0 - nimble_platform_mem_free(os_msys_init_1_data); + bt_osi_mem_free(os_msys_init_1_data); os_msys_init_1_data = NULL; os_mempool_unregister(&os_msys_init_1_mempool); #endif #if OS_MSYS_2_BLOCK_COUNT > 0 - nimble_platform_mem_free(os_msys_init_2_data); + bt_osi_mem_free(os_msys_init_2_data); os_msys_init_2_data = NULL; - os_mempool_unregister(&os_msys_init_1_mempool); + os_mempool_unregister(&os_msys_init_2_mempool); #endif #endif // CONFIG_BT_NIMBLE_STATIC_TO_DYNAMIC } diff --git a/components/bt/porting/npl/freertos/src/npl_os_freertos.c b/components/bt/porting/npl/freertos/src/npl_os_freertos.c index 4871af528c4..d4b8fc883c5 100644 --- a/components/bt/porting/npl/freertos/src/npl_os_freertos.c +++ b/components/bt/porting/npl/freertos/src/npl_os_freertos.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2015-2026 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -323,8 +323,7 @@ IRAM_ATTR npl_freertos_eventq_remove(struct ble_npl_eventq *evq, portYIELD_FROM_ISR(); } } else { - portMUX_TYPE ble_npl_mut = portMUX_INITIALIZER_UNLOCKED; - portENTER_CRITICAL(&ble_npl_mut); + portENTER_CRITICAL(&ble_port_mutex); count = uxQueueMessagesWaiting(eventq->q); for (i = 0; i < count; i++) { @@ -339,7 +338,7 @@ IRAM_ATTR npl_freertos_eventq_remove(struct ble_npl_eventq *evq, BLE_LL_ASSERT(ret == pdPASS); } - portEXIT_CRITICAL(&ble_npl_mut); + portEXIT_CRITICAL(&ble_port_mutex); } event->queued = 0; diff --git a/examples/bluetooth/esp_hid_device/main/esp_hid_device_main.c b/examples/bluetooth/esp_hid_device/main/esp_hid_device_main.c index b44e2e259bb..0fffa8f06ec 100644 --- a/examples/bluetooth/esp_hid_device/main/esp_hid_device_main.c +++ b/examples/bluetooth/esp_hid_device/main/esp_hid_device_main.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2021-2026 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Unlicense OR CC0-1.0 */ @@ -918,9 +918,6 @@ void app_main(void) ble_hs_cfg.store_status_cb = ble_store_util_status_rr; /* Starting nimble task after gatts is initialized*/ - ret = esp_nimble_enable(ble_hid_device_host_task); - if (ret) { - ESP_LOGE(TAG, "esp_nimble_enable failed: %d", ret); - } + nimble_port_freertos_init(ble_hid_device_host_task); #endif } diff --git a/examples/bluetooth/esp_hid_host/main/esp_hid_host_main.c b/examples/bluetooth/esp_hid_host/main/esp_hid_host_main.c index 8934b60c1aa..ab9d8aa21eb 100644 --- a/examples/bluetooth/esp_hid_host/main/esp_hid_host_main.c +++ b/examples/bluetooth/esp_hid_host/main/esp_hid_host_main.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2021-2026 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Unlicense OR CC0-1.0 */ @@ -238,10 +238,7 @@ void app_main(void) ble_hs_cfg.store_status_cb = ble_store_util_status_rr; /* Starting nimble task after gatts is initialized*/ - ret = esp_nimble_enable(ble_hid_host_task); - if (ret) { - ESP_LOGE(TAG, "esp_nimble_enable failed: %d", ret); - } + nimble_port_freertos_init(ble_hid_host_task); vTaskDelay(200);