Merge branch 'bugfix/put_sempher_and_queue_used_in_isr_into_DRAM_v4.2' into 'release/v4.2'

Make sure semphr/queue used in interrupt is in DRAM

See merge request espressif/esp-idf!18990
This commit is contained in:
Jiang Jiang Jian 2022-08-02 11:32:18 +08:00
commit 4bdc7853cf
2 changed files with 141 additions and 258 deletions

View File

@ -94,11 +94,6 @@ do{\
#define OSI_VERSION 0x00010003 #define OSI_VERSION 0x00010003
#define OSI_MAGIC_VALUE 0xFADEBEAD #define OSI_MAGIC_VALUE 0xFADEBEAD
/* SPIRAM Configuration */
#if CONFIG_SPIRAM_USE_MALLOC
#define BTDM_MAX_QUEUE_NUM (5)
#endif
/* Types definition /* Types definition
************************************************************************ ************************************************************************
*/ */
@ -116,14 +111,10 @@ typedef struct {
intptr_t end; intptr_t end;
} btdm_dram_available_region_t; } btdm_dram_available_region_t;
/* PSRAM configuration */
#if CONFIG_SPIRAM_USE_MALLOC
typedef struct { typedef struct {
QueueHandle_t handle; void *handle;
void *storage; void *storage;
void *buffer;
} btdm_queue_item_t; } btdm_queue_item_t;
#endif
/* OSI function */ /* OSI function */
struct osi_funcs_t { struct osi_funcs_t {
@ -269,10 +260,6 @@ extern uint32_t _btdm_data_end;
/* Local Function Declare /* Local Function Declare
********************************************************************* *********************************************************************
*/ */
#if CONFIG_SPIRAM_USE_MALLOC
static bool btdm_queue_generic_register(const btdm_queue_item_t *queue);
static bool btdm_queue_generic_deregister(btdm_queue_item_t *queue);
#endif /* CONFIG_SPIRAM_USE_MALLOC */
static void IRAM_ATTR interrupt_disable(void); static void IRAM_ATTR interrupt_disable(void);
static void IRAM_ATTR interrupt_restore(void); static void IRAM_ATTR interrupt_restore(void);
static void IRAM_ATTR task_yield(void); static void IRAM_ATTR task_yield(void);
@ -415,11 +402,6 @@ SOC_RESERVE_MEMORY_REGION(SOC_MEM_BT_DATA_START, SOC_MEM_BT_DATA_END,
static DRAM_ATTR struct osi_funcs_t *osi_funcs_p; static DRAM_ATTR struct osi_funcs_t *osi_funcs_p;
#if CONFIG_SPIRAM_USE_MALLOC
static DRAM_ATTR btdm_queue_item_t btdm_queue_table[BTDM_MAX_QUEUE_NUM];
static DRAM_ATTR SemaphoreHandle_t btdm_queue_table_mux = NULL;
#endif /* #if CONFIG_SPIRAM_USE_MALLOC */
/* Static variable declare */ /* Static variable declare */
// timestamp when PHY/RF was switched on // timestamp when PHY/RF was switched on
static DRAM_ATTR int64_t s_time_phy_rf_just_enabled = 0; static DRAM_ATTR int64_t s_time_phy_rf_just_enabled = 0;
@ -459,52 +441,6 @@ static inline void btdm_check_and_init_bb(void)
} }
} }
#if CONFIG_SPIRAM_USE_MALLOC
static bool btdm_queue_generic_register(const btdm_queue_item_t *queue)
{
if (!btdm_queue_table_mux || !queue) {
return NULL;
}
bool ret = false;
btdm_queue_item_t *item;
xSemaphoreTake(btdm_queue_table_mux, portMAX_DELAY);
for (int i = 0; i < BTDM_MAX_QUEUE_NUM; ++i) {
item = &btdm_queue_table[i];
if (item->handle == NULL) {
memcpy(item, queue, sizeof(btdm_queue_item_t));
ret = true;
break;
}
}
xSemaphoreGive(btdm_queue_table_mux);
return ret;
}
static bool btdm_queue_generic_deregister(btdm_queue_item_t *queue)
{
if (!btdm_queue_table_mux || !queue) {
return false;
}
bool ret = false;
btdm_queue_item_t *item;
xSemaphoreTake(btdm_queue_table_mux, portMAX_DELAY);
for (int i = 0; i < BTDM_MAX_QUEUE_NUM; ++i) {
item = &btdm_queue_table[i];
if (item->handle == queue->handle) {
memcpy(queue, item, sizeof(btdm_queue_item_t));
memset(item, 0, sizeof(btdm_queue_item_t));
ret = true;
break;
}
}
xSemaphoreGive(btdm_queue_table_mux);
return ret;
}
#endif /* CONFIG_SPIRAM_USE_MALLOC */
static void IRAM_ATTR interrupt_disable(void) static void IRAM_ATTR interrupt_disable(void)
{ {
if (xPortInIsrContext()) { if (xPortInIsrContext()) {
@ -535,148 +471,74 @@ static void IRAM_ATTR task_yield_from_isr(void)
static void *semphr_create_wrapper(uint32_t max, uint32_t init) static void *semphr_create_wrapper(uint32_t max, uint32_t init)
{ {
btdm_queue_item_t *semphr = heap_caps_calloc(1, sizeof(btdm_queue_item_t), MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
assert(semphr);
#if !CONFIG_SPIRAM_USE_MALLOC #if !CONFIG_SPIRAM_USE_MALLOC
return (void *)xSemaphoreCreateCounting(max, init); semphr->handle = (void *)xSemaphoreCreateCounting(max, init);
#else #else
StaticQueue_t *queue_buffer = NULL;
QueueHandle_t handle = NULL;
queue_buffer = heap_caps_malloc(sizeof(StaticQueue_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); semphr->storage = heap_caps_malloc(sizeof(StaticQueue_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
if (!queue_buffer) { assert(semphr->storage);
goto error;
}
handle = xSemaphoreCreateCountingStatic(max, init, queue_buffer); semphr->handle = (void *)xSemaphoreCreateCountingStatic(max, init, semphr->storage);
if (!handle) {
goto error;
}
btdm_queue_item_t item = {
.handle = handle,
.storage = NULL,
.buffer = queue_buffer,
};
if (!btdm_queue_generic_register(&item)) {
goto error;
}
return handle;
error:
if (handle) {
vSemaphoreDelete(handle);
}
if (queue_buffer) {
free(queue_buffer);
}
return NULL;
#endif #endif
assert(semphr->handle);
return semphr;
} }
static void semphr_delete_wrapper(void *semphr) static void semphr_delete_wrapper(void *semphr)
{ {
#if !CONFIG_SPIRAM_USE_MALLOC if (semphr == NULL) {
vSemaphoreDelete(semphr); return;
#else
btdm_queue_item_t item = {
.handle = semphr,
.storage = NULL,
.buffer = NULL,
};
if (btdm_queue_generic_deregister(&item)) {
vSemaphoreDelete(item.handle);
free(item.buffer);
} }
return; btdm_queue_item_t *semphr_item = (btdm_queue_item_t *)semphr;
if (semphr_item->handle) {
vSemaphoreDelete(semphr_item->handle);
}
#ifdef CONFIG_SPIRAM_USE_MALLOC
if (semphr_item->storage) {
free(semphr_item->storage);
}
#endif #endif
free(semphr);
} }
static int32_t IRAM_ATTR semphr_take_from_isr_wrapper(void *semphr, void *hptw) static int32_t IRAM_ATTR semphr_take_from_isr_wrapper(void *semphr, void *hptw)
{ {
return (int32_t)xSemaphoreTakeFromISR(semphr, hptw); return (int32_t)xSemaphoreTakeFromISR(((btdm_queue_item_t *)semphr)->handle, hptw);
} }
static int32_t IRAM_ATTR semphr_give_from_isr_wrapper(void *semphr, void *hptw) static int32_t IRAM_ATTR semphr_give_from_isr_wrapper(void *semphr, void *hptw)
{ {
return (int32_t)xSemaphoreGiveFromISR(semphr, hptw); return (int32_t)xSemaphoreGiveFromISR(((btdm_queue_item_t *)semphr)->handle, hptw);
} }
static int32_t semphr_take_wrapper(void *semphr, uint32_t block_time_ms) static int32_t semphr_take_wrapper(void *semphr, uint32_t block_time_ms)
{ {
if (block_time_ms == OSI_FUNCS_TIME_BLOCKING) { if (block_time_ms == OSI_FUNCS_TIME_BLOCKING) {
return (int32_t)xSemaphoreTake(semphr, portMAX_DELAY); return (int32_t)xSemaphoreTake(((btdm_queue_item_t *)semphr)->handle, portMAX_DELAY);
} else { } else {
return (int32_t)xSemaphoreTake(semphr, block_time_ms / portTICK_PERIOD_MS); return (int32_t)xSemaphoreTake(((btdm_queue_item_t *)semphr)->handle, block_time_ms / portTICK_PERIOD_MS);
} }
} }
static int32_t semphr_give_wrapper(void *semphr) static int32_t semphr_give_wrapper(void *semphr)
{ {
return (int32_t)xSemaphoreGive(semphr); return (int32_t)xSemaphoreGive(((btdm_queue_item_t *)semphr)->handle);
} }
static void *mutex_create_wrapper(void) static void *mutex_create_wrapper(void)
{ {
#if CONFIG_SPIRAM_USE_MALLOC
StaticQueue_t *queue_buffer = NULL;
QueueHandle_t handle = NULL;
queue_buffer = heap_caps_malloc(sizeof(StaticQueue_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
if (!queue_buffer) {
goto error;
}
handle = xSemaphoreCreateMutexStatic(queue_buffer);
if (!handle) {
goto error;
}
btdm_queue_item_t item = {
.handle = handle,
.storage = NULL,
.buffer = queue_buffer,
};
if (!btdm_queue_generic_register(&item)) {
goto error;
}
return handle;
error:
if (handle) {
vSemaphoreDelete(handle);
}
if (queue_buffer) {
free(queue_buffer);
}
return NULL;
#else
return (void *)xSemaphoreCreateMutex(); return (void *)xSemaphoreCreateMutex();
#endif
} }
static void mutex_delete_wrapper(void *mutex) static void mutex_delete_wrapper(void *mutex)
{ {
#if !CONFIG_SPIRAM_USE_MALLOC
vSemaphoreDelete(mutex); vSemaphoreDelete(mutex);
#else
btdm_queue_item_t item = {
.handle = mutex,
.storage = NULL,
.buffer = NULL,
};
if (btdm_queue_generic_deregister(&item)) {
vSemaphoreDelete(item.handle);
free(item.buffer);
}
return;
#endif
} }
static int32_t mutex_lock_wrapper(void *mutex) static int32_t mutex_lock_wrapper(void *mutex)
@ -691,102 +553,71 @@ static int32_t mutex_unlock_wrapper(void *mutex)
static void *queue_create_wrapper(uint32_t queue_len, uint32_t item_size) static void *queue_create_wrapper(uint32_t queue_len, uint32_t item_size)
{ {
btdm_queue_item_t *queue = NULL;
queue = (btdm_queue_item_t*)heap_caps_malloc(sizeof(btdm_queue_item_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
assert(queue);
#if CONFIG_SPIRAM_USE_MALLOC #if CONFIG_SPIRAM_USE_MALLOC
StaticQueue_t *queue_buffer = NULL;
uint8_t *queue_storage = NULL;
QueueHandle_t handle = NULL;
queue_buffer = heap_caps_malloc(sizeof(StaticQueue_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); queue->storage = heap_caps_calloc(1, sizeof(StaticQueue_t) + (queue_len*item_size), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
if (!queue_buffer) { assert(queue->storage);
goto error;
}
queue_storage = heap_caps_malloc((queue_len*item_size), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); queue->handle = xQueueCreateStatic( queue_len, item_size, ((uint8_t*)(queue->storage)) + sizeof(StaticQueue_t), (StaticQueue_t*)(queue->storage));
if (!queue_storage ) { assert(queue->handle);
goto error;
}
handle = xQueueCreateStatic(queue_len, item_size, queue_storage, queue_buffer);
if (!handle) {
goto error;
}
btdm_queue_item_t item = {
.handle = handle,
.storage = queue_storage,
.buffer = queue_buffer,
};
if (!btdm_queue_generic_register(&item)) {
goto error;
}
return handle;
error:
if (handle) {
vQueueDelete(handle);
}
if (queue_storage) {
free(queue_storage);
}
if (queue_buffer) {
free(queue_buffer);
}
return NULL;
#else #else
return (void *)xQueueCreate(queue_len, item_size); queue->handle = xQueueCreate( queue_len, item_size);
assert(queue->handle);
#endif #endif
return queue;
} }
static void queue_delete_wrapper(void *queue) static void queue_delete_wrapper(void *queue)
{ {
#if !CONFIG_SPIRAM_USE_MALLOC btdm_queue_item_t *queue_item = (btdm_queue_item_t *)queue;
vQueueDelete(queue); if (queue_item) {
#else if(queue_item->handle){
btdm_queue_item_t item = { vQueueDelete(queue_item->handle);
.handle = queue, }
.storage = NULL,
.buffer = NULL,
};
if (btdm_queue_generic_deregister(&item)) { #if CONFIG_SPIRAM_USE_MALLOC
vQueueDelete(item.handle); if (queue_item->storage) {
free(item.storage); free(queue_item->storage);
free(item.buffer); }
}
return;
#endif #endif
free(queue_item);
}
} }
static int32_t queue_send_wrapper(void *queue, void *item, uint32_t block_time_ms) static int32_t queue_send_wrapper(void *queue, void *item, uint32_t block_time_ms)
{ {
if (block_time_ms == OSI_FUNCS_TIME_BLOCKING) { if (block_time_ms == OSI_FUNCS_TIME_BLOCKING) {
return (int32_t)xQueueSend(queue, item, portMAX_DELAY); return (int32_t)xQueueSend(((btdm_queue_item_t*)queue)->handle, item, portMAX_DELAY);
} else { } else {
return (int32_t)xQueueSend(queue, item, block_time_ms / portTICK_PERIOD_MS); return (int32_t)xQueueSend(((btdm_queue_item_t*)queue)->handle, item, block_time_ms / portTICK_PERIOD_MS);
} }
} }
static int32_t IRAM_ATTR queue_send_from_isr_wrapper(void *queue, void *item, void *hptw) static int32_t IRAM_ATTR queue_send_from_isr_wrapper(void *queue, void *item, void *hptw)
{ {
return (int32_t)xQueueSendFromISR(queue, item, hptw); return (int32_t)xQueueSendFromISR(((btdm_queue_item_t*)queue)->handle, item, hptw);
} }
static int32_t queue_recv_wrapper(void *queue, void *item, uint32_t block_time_ms) static int32_t queue_recv_wrapper(void *queue, void *item, uint32_t block_time_ms)
{ {
if (block_time_ms == OSI_FUNCS_TIME_BLOCKING) { if (block_time_ms == OSI_FUNCS_TIME_BLOCKING) {
return (int32_t)xQueueReceive(queue, item, portMAX_DELAY); return (int32_t)xQueueReceive(((btdm_queue_item_t*)queue)->handle, item, portMAX_DELAY);
} else { } else {
return (int32_t)xQueueReceive(queue, item, block_time_ms / portTICK_PERIOD_MS); return (int32_t)xQueueReceive(((btdm_queue_item_t*)queue)->handle, item, block_time_ms / portTICK_PERIOD_MS);
} }
} }
static int32_t IRAM_ATTR queue_recv_from_isr_wrapper(void *queue, void *item, void *hptw) static int32_t IRAM_ATTR queue_recv_from_isr_wrapper(void *queue, void *item, void *hptw)
{ {
return (int32_t)xQueueReceiveFromISR(queue, item, hptw); return (int32_t)xQueueReceiveFromISR(((btdm_queue_item_t*)queue)->handle, item, hptw);
} }
static int32_t task_create_wrapper(void *task_func, const char *name, uint32_t stack_depth, void *param, uint32_t prio, void *task_handle, uint32_t core_id) static int32_t task_create_wrapper(void *task_func, const char *name, uint32_t stack_depth, void *param, uint32_t prio, void *task_handle, uint32_t core_id)
@ -1378,14 +1209,6 @@ esp_err_t esp_bt_controller_init(esp_bt_controller_config_t *cfg)
ESP_LOGI(BTDM_LOG_TAG, "BT controller compile version [%s]", btdm_controller_get_compile_version()); ESP_LOGI(BTDM_LOG_TAG, "BT controller compile version [%s]", btdm_controller_get_compile_version());
#if CONFIG_SPIRAM_USE_MALLOC
btdm_queue_table_mux = xSemaphoreCreateMutex();
if (btdm_queue_table_mux == NULL) {
return ESP_ERR_NO_MEM;
}
memset(btdm_queue_table, 0, sizeof(btdm_queue_item_t) * BTDM_MAX_QUEUE_NUM);
#endif
s_wakeup_req_sem = semphr_create_wrapper(1, 0); s_wakeup_req_sem = semphr_create_wrapper(1, 0);
if (s_wakeup_req_sem == NULL) { if (s_wakeup_req_sem == NULL) {
err = ESP_ERR_NO_MEM; err = ESP_ERR_NO_MEM;
@ -1535,12 +1358,6 @@ esp_err_t esp_bt_controller_deinit(void)
semphr_delete_wrapper(s_wakeup_req_sem); semphr_delete_wrapper(s_wakeup_req_sem);
s_wakeup_req_sem = NULL; s_wakeup_req_sem = NULL;
#if CONFIG_SPIRAM_USE_MALLOC
vSemaphoreDelete(btdm_queue_table_mux);
btdm_queue_table_mux = NULL;
memset(btdm_queue_table, 0, sizeof(btdm_queue_item_t) * BTDM_MAX_QUEUE_NUM);
#endif
free(osi_funcs_p); free(osi_funcs_p);
osi_funcs_p = NULL; osi_funcs_p = NULL;

View File

@ -266,16 +266,6 @@ static void * wifi_thread_semphr_get_wrapper(void)
return (void*)sem; return (void*)sem;
} }
static int32_t IRAM_ATTR semphr_take_from_isr_wrapper(void *semphr, void *hptw)
{
return (int32_t)xSemaphoreTakeFromISR(semphr, hptw);
}
static int32_t IRAM_ATTR semphr_give_from_isr_wrapper(void *semphr, void *hptw)
{
return (int32_t)xSemaphoreGiveFromISR(semphr, hptw);
}
static int32_t semphr_take_wrapper(void *semphr, uint32_t block_time_tick) static int32_t semphr_take_wrapper(void *semphr, uint32_t block_time_tick)
{ {
if (block_time_tick == OSI_FUNCS_TIME_BLOCKING) { if (block_time_tick == OSI_FUNCS_TIME_BLOCKING) {
@ -290,6 +280,82 @@ static int32_t semphr_give_wrapper(void *semphr)
return (int32_t)xSemaphoreGive(semphr); return (int32_t)xSemaphoreGive(semphr);
} }
static void *internal_semphr_create_wrapper(uint32_t max, uint32_t init)
{
wifi_static_queue_t *semphr = heap_caps_calloc(1, sizeof(wifi_static_queue_t), MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
if (!semphr) {
return NULL;
}
#ifdef CONFIG_SPIRAM_USE_MALLOC
semphr->storage = heap_caps_calloc(1, sizeof(StaticSemaphore_t), MALLOC_CAP_8BIT|MALLOC_CAP_INTERNAL);
if (!semphr->storage) {
goto _error;
}
semphr->handle = xSemaphoreCreateCountingStatic(max, init, semphr->storage);
if (!semphr->handle) {
goto _error;
}
return (void *)semphr;
_error:
if (semphr) {
if (semphr->storage) {
free(semphr->storage);
}
free(semphr);
}
return NULL;
#else
semphr->handle = xSemaphoreCreateCounting(max, init);
return (void *)semphr;
#endif
}
void internal_semphr_delete_wrapper(void *semphr)
{
wifi_static_queue_t *semphr_item = (wifi_static_queue_t *)semphr;
if (semphr_item) {
if (semphr_item->handle) {
vSemaphoreDelete(semphr_item->handle);
}
#ifdef CONFIG_SPIRAM_USE_MALLOC
if (semphr_item->storage) {
free(semphr_item->storage);
}
#endif
free(semphr_item);
}
}
static int32_t IRAM_ATTR internal_semphr_take_from_isr_wrapper(void *semphr, void *hptw)
{
return (int32_t)xSemaphoreTakeFromISR(((wifi_static_queue_t *)semphr)->handle, hptw);
}
static int32_t IRAM_ATTR internal_semphr_give_from_isr_wrapper(void *semphr, void *hptw)
{
return (int32_t)xSemaphoreGiveFromISR(((wifi_static_queue_t *)semphr)->handle, hptw);
}
static int32_t internal_semphr_take_wrapper(void *semphr, uint32_t block_time_tick)
{
if (block_time_tick == OSI_FUNCS_TIME_BLOCKING) {
return (int32_t)xSemaphoreTake(((wifi_static_queue_t *)semphr)->handle, portMAX_DELAY);
} else {
return (int32_t)xSemaphoreTake(((wifi_static_queue_t *)semphr)->handle, block_time_tick);
}
}
static int32_t internal_semphr_give_wrapper(void *semphr)
{
return (int32_t)xSemaphoreGive(((wifi_static_queue_t *)semphr)->handle);
}
static void * recursive_mutex_create_wrapper(void) static void * recursive_mutex_create_wrapper(void)
{ {
return (void *)xSemaphoreCreateRecursiveMutex(); return (void *)xSemaphoreCreateRecursiveMutex();
@ -709,12 +775,12 @@ coex_adapter_funcs_t g_coex_adapter_funcs = {
._int_disable = wifi_int_disable_wrapper, ._int_disable = wifi_int_disable_wrapper,
._int_enable = wifi_int_restore_wrapper, ._int_enable = wifi_int_restore_wrapper,
._task_yield_from_isr = task_yield_from_isr_wrapper, ._task_yield_from_isr = task_yield_from_isr_wrapper,
._semphr_create = semphr_create_wrapper, ._semphr_create = internal_semphr_create_wrapper,
._semphr_delete = semphr_delete_wrapper, ._semphr_delete = internal_semphr_delete_wrapper,
._semphr_take_from_isr = semphr_take_from_isr_wrapper, ._semphr_take_from_isr = internal_semphr_take_from_isr_wrapper,
._semphr_give_from_isr = semphr_give_from_isr_wrapper, ._semphr_give_from_isr = internal_semphr_give_from_isr_wrapper,
._semphr_take = semphr_take_wrapper, ._semphr_take = internal_semphr_take_wrapper,
._semphr_give = semphr_give_wrapper, ._semphr_give = internal_semphr_give_wrapper,
._is_in_isr = coex_is_in_isr_wrapper, ._is_in_isr = coex_is_in_isr_wrapper,
._malloc_internal = malloc_internal_wrapper, ._malloc_internal = malloc_internal_wrapper,
._free = free, ._free = free,