Merge branch 'feature/drivers_use_creation_with_caps_functions' into …

…'master'

Drivers: Update drivers to use CreateWithCaps() API

See merge request espressif/esp-idf!24378

components/driver/dac/dac_continuous.c

@@ -10,6 +10,7 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/queue.h"
 #include "freertos/semphr.h"
+#include "freertos/idf_additions.h"
 #include "sdkconfig.h"
 
 #include "rom/lldesc.h"
@@ -70,12 +71,8 @@ struct dac_continuous_s {
     esp_pm_lock_handle_t    pm_lock;
 #endif
     SemaphoreHandle_t       mutex;
-    StaticSemaphore_t       mutex_struct;               /* Static mutex struct */
-
     QueueHandle_t           desc_pool;                  /* The pool of available descriptors
                                                          * The descriptors in the pool are not linked in to pending chain */
-    StaticQueue_t           desc_pool_struct;           /* Static message queue struct */
-    void                    *desc_pool_storage;         /* Static message queue storage */
 
     lldesc_t                **desc;
     uint8_t                 **bufs;
@@ -224,14 +221,10 @@ esp_err_t dac_continuous_new_channels(const dac_continuous_config_t *cont_cfg, d
     dac_continuous_handle_t handle = heap_caps_calloc(1, sizeof(struct dac_continuous_s), DAC_MEM_ALLOC_CAPS);
     ESP_RETURN_ON_FALSE(handle, ESP_ERR_NO_MEM, TAG, "no memory for the dac continuous mode structure");
 
-    /* Allocate static queue */
-    handle->desc_pool_storage = (uint8_t *)heap_caps_calloc(cont_cfg->desc_num, sizeof(lldesc_t *), DAC_MEM_ALLOC_CAPS);
-    ESP_GOTO_ON_FALSE(handle->desc_pool_storage, ESP_ERR_NO_MEM, err3, TAG, "no memory for message queue storage");
-    handle->desc_pool = xQueueCreateStatic(cont_cfg->desc_num, sizeof(lldesc_t *), handle->desc_pool_storage, &handle->desc_pool_struct);
+    /* Allocate queue and mutex*/
+    handle->desc_pool = xQueueCreateWithCaps(cont_cfg->desc_num, sizeof(lldesc_t *), DAC_MEM_ALLOC_CAPS);
+    handle->mutex = xSemaphoreCreateMutexWithCaps(DAC_MEM_ALLOC_CAPS);
     ESP_GOTO_ON_FALSE(handle->desc_pool, ESP_ERR_NO_MEM, err3, TAG, "no memory for message queue");
-
-    /* Allocate static mutex */
-    handle->mutex = xSemaphoreCreateMutexStatic(&handle->mutex_struct);
     ESP_GOTO_ON_FALSE(handle->mutex, ESP_ERR_NO_MEM, err3, TAG, "no memory for channels mutex");
 
     /* Create PM lock */
@@ -273,13 +266,10 @@ esp_err_t dac_continuous_new_channels(const dac_continuous_config_t *cont_cfg, d
     s_dac_free_dma_desc(handle);
 err3:
     if (handle->desc_pool) {
-        vQueueDelete(handle->desc_pool);
-    }
-    if (handle->desc_pool_storage) {
-        free(handle->desc_pool_storage);
+        vQueueDeleteWithCaps(handle->desc_pool);
     }
     if (handle->mutex) {
-        vSemaphoreDelete(handle->mutex);
+        vSemaphoreDeleteWithCaps(handle->mutex);
     }
     free(handle);
 err4:
@@ -312,15 +302,11 @@ esp_err_t dac_continuous_del_channels(dac_continuous_handle_t handle)
     /* Free allocated resources */
     s_dac_free_dma_desc(handle);
     if (handle->desc_pool) {
-        vQueueDelete(handle->desc_pool);
+        vQueueDeleteWithCaps(handle->desc_pool);
         handle->desc_pool = NULL;
     }
-    if (handle->desc_pool_storage) {
-        free(handle->desc_pool_storage);
-        handle->desc_pool_storage = NULL;
-    }
     if (handle->mutex) {
-        vSemaphoreDelete(handle->mutex);
+        vSemaphoreDeleteWithCaps(handle->mutex);
         handle->mutex = NULL;
     }
 #if CONFIG_PM_ENABLE

components/driver/i2c/i2c.c

@@ -16,6 +16,7 @@
 #include "freertos/semphr.h"
 #include "freertos/task.h"
 #include "freertos/ringbuf.h"
+#include "freertos/idf_additions.h"
 #include "esp_pm.h"
 #include "soc/soc_memory_layout.h"
 #include "hal/i2c_hal.h"
@@ -104,6 +105,11 @@ static const char *I2C_TAG = "i2c";
 
 #define I2C_CLOCK_INVALID                 (-1)
 
+#if CONFIG_SPIRAM_USE_MALLOC
+#define I2C_MEM_ALLOC_CAPS_INTERNAL     (MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT)
+#endif
+#define I2C_MEM_ALLOC_CAPS_DEFAULT      MALLOC_CAP_DEFAULT
+
 /**
  * I2C bus are defined in the header files, let's check that the values are correct
  */
@@ -169,9 +175,7 @@ typedef struct {
     i2c_cmd_desc_t cmd_link;         /*!< I2C command link */
     QueueHandle_t cmd_evt_queue;     /*!< I2C command event queue */
 #if CONFIG_SPIRAM_USE_MALLOC
-    uint8_t *evt_queue_storage;      /*!< The buffer that will hold the items in the queue */
     int intr_alloc_flags;            /*!< Used to allocate the interrupt */
-    StaticQueue_t evt_queue_buffer;  /*!< The buffer that will hold the queue structure*/
 #endif
     SemaphoreHandle_t cmd_mux;        /*!< semaphore to lock command process */
 #ifdef CONFIG_PM_ENABLE
@@ -274,16 +278,13 @@ esp_err_t i2c_driver_install(i2c_port_t i2c_num, i2c_mode_t mode, size_t slv_rx_
     esp_err_t ret = ESP_OK;
 
     if (p_i2c_obj[i2c_num] == NULL) {
-
-#if !CONFIG_SPIRAM_USE_MALLOC
-        p_i2c_obj[i2c_num] = (i2c_obj_t *) calloc(1, sizeof(i2c_obj_t));
+        uint32_t alloc_caps;
+#if CONFIG_SPIRAM_USE_MALLOC
+        alloc_caps = (intr_alloc_flags & ESP_INTR_FLAG_IRAM) ? I2C_MEM_ALLOC_CAPS_INTERNAL : I2C_MEM_ALLOC_CAPS_DEFAULT;
 #else
-        if ( !(intr_alloc_flags & ESP_INTR_FLAG_IRAM) ) {
-            p_i2c_obj[i2c_num] = (i2c_obj_t *) calloc(1, sizeof(i2c_obj_t));
-        } else {
-            p_i2c_obj[i2c_num] = (i2c_obj_t *) heap_caps_calloc(1, sizeof(i2c_obj_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
-        }
+        alloc_caps = I2C_MEM_ALLOC_CAPS_DEFAULT;
 #endif
+        p_i2c_obj[i2c_num] = (i2c_obj_t *) heap_caps_calloc(1, sizeof(i2c_obj_t), alloc_caps);
         if (p_i2c_obj[i2c_num] == NULL) {
             ESP_LOGE(I2C_TAG, I2C_DRIVER_MALLOC_ERR_STR);
             return ESP_FAIL;
@@ -348,21 +349,13 @@ esp_err_t i2c_driver_install(i2c_port_t i2c_num, i2c_mode_t mode, size_t slv_rx_
                 goto err;
             }
 #endif
-#if !CONFIG_SPIRAM_USE_MALLOC
-            p_i2c->cmd_evt_queue = xQueueCreate(I2C_EVT_QUEUE_LEN, sizeof(i2c_cmd_evt_t));
+            uint32_t alloc_caps;
+#if CONFIG_SPIRAM_USE_MALLOC
+            alloc_caps = (intr_alloc_flags & ESP_INTR_FLAG_IRAM) ? I2C_MEM_ALLOC_CAPS_INTERNAL : I2C_MEM_ALLOC_CAPS_DEFAULT;
 #else
-            if ( !(intr_alloc_flags & ESP_INTR_FLAG_IRAM) ) {
-                p_i2c->cmd_evt_queue = xQueueCreate(I2C_EVT_QUEUE_LEN, sizeof(i2c_cmd_evt_t));
-            } else {
-                p_i2c->evt_queue_storage = (uint8_t *)heap_caps_calloc(I2C_EVT_QUEUE_LEN, sizeof(i2c_cmd_evt_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
-                if ( p_i2c->evt_queue_storage == NULL ) {
-                    ESP_LOGE(I2C_TAG, I2C_DRIVER_MALLOC_ERR_STR);
-                    goto err;
-                }
-                memset(&p_i2c->evt_queue_buffer, 0, sizeof(StaticQueue_t));
-                p_i2c->cmd_evt_queue =  xQueueCreateStatic(I2C_EVT_QUEUE_LEN, sizeof(i2c_cmd_evt_t), p_i2c->evt_queue_storage, &p_i2c->evt_queue_buffer);
-            }
+            alloc_caps = I2C_MEM_ALLOC_CAPS_DEFAULT;
 #endif
+            p_i2c->cmd_evt_queue = xQueueCreateWithCaps(I2C_EVT_QUEUE_LEN, sizeof(i2c_cmd_evt_t), alloc_caps);
             if (p_i2c->cmd_mux == NULL || p_i2c->cmd_evt_queue == NULL) {
                 ESP_LOGE(I2C_TAG, I2C_SEM_ERR_STR);
                 goto err;
@@ -413,7 +406,7 @@ esp_err_t i2c_driver_install(i2c_port_t i2c_num, i2c_mode_t mode, size_t slv_rx_
             p_i2c_obj[i2c_num]->tx_buf_length = 0;
         }
         if (p_i2c_obj[i2c_num]->cmd_evt_queue) {
-            vQueueDelete(p_i2c_obj[i2c_num]->cmd_evt_queue);
+            vQueueDeleteWithCaps(p_i2c_obj[i2c_num]->cmd_evt_queue);
             p_i2c_obj[i2c_num]->cmd_evt_queue = NULL;
         }
         if (p_i2c_obj[i2c_num]->cmd_mux) {
@@ -432,12 +425,6 @@ esp_err_t i2c_driver_install(i2c_port_t i2c_num, i2c_mode_t mode, size_t slv_rx_
             esp_pm_lock_delete(p_i2c_obj[i2c_num]->pm_lock);
             p_i2c_obj[i2c_num]->pm_lock = NULL;
         }
-#endif
-#if CONFIG_SPIRAM_USE_MALLOC
-        if (p_i2c_obj[i2c_num]->evt_queue_storage) {
-            free(p_i2c_obj[i2c_num]->evt_queue_storage);
-            p_i2c_obj[i2c_num]->evt_queue_storage = NULL;
-        }
 #endif
     }
     free(p_i2c_obj[i2c_num]);
@@ -462,7 +449,7 @@ esp_err_t i2c_driver_delete(i2c_port_t i2c_num)
         vSemaphoreDelete(p_i2c->cmd_mux);
     }
     if (p_i2c_obj[i2c_num]->cmd_evt_queue) {
-        vQueueDelete(p_i2c_obj[i2c_num]->cmd_evt_queue);
+        vQueueDeleteWithCaps(p_i2c_obj[i2c_num]->cmd_evt_queue);
         p_i2c_obj[i2c_num]->cmd_evt_queue = NULL;
     }
 #if SOC_I2C_SUPPORT_SLAVE
@@ -490,12 +477,6 @@ esp_err_t i2c_driver_delete(i2c_port_t i2c_num)
         p_i2c->pm_lock = NULL;
     }
 #endif
-#if CONFIG_SPIRAM_USE_MALLOC
-    if (p_i2c_obj[i2c_num]->evt_queue_storage) {
-        free(p_i2c_obj[i2c_num]->evt_queue_storage);
-        p_i2c_obj[i2c_num]->evt_queue_storage = NULL;
-    }
-#endif
 
     i2c_hal_deinit(&i2c_context[i2c_num].hal);
     free(p_i2c_obj[i2c_num]);
@@ -1122,11 +1103,13 @@ i2c_cmd_handle_t i2c_cmd_link_create_static(uint8_t* buffer, uint32_t size)
 
 i2c_cmd_handle_t i2c_cmd_link_create(void)
 {
-#if !CONFIG_SPIRAM_USE_MALLOC
-    i2c_cmd_desc_t *cmd_desc = (i2c_cmd_desc_t *) calloc(1, sizeof(i2c_cmd_desc_t));
+    uint32_t alloc_caps;
+#if CONFIG_SPIRAM_USE_MALLOC
+    alloc_caps = I2C_MEM_ALLOC_CAPS_INTERNAL;
 #else
-    i2c_cmd_desc_t *cmd_desc = (i2c_cmd_desc_t *) heap_caps_calloc(1, sizeof(i2c_cmd_desc_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+    alloc_caps = I2C_MEM_ALLOC_CAPS_DEFAULT;
 #endif
+    i2c_cmd_desc_t *cmd_desc = (i2c_cmd_desc_t *) heap_caps_calloc(1, sizeof(i2c_cmd_desc_t), alloc_caps);
     return (i2c_cmd_handle_t) cmd_desc;
 }
 
@@ -1182,11 +1165,13 @@ static esp_err_t i2c_cmd_allocate(i2c_cmd_desc_t *cmd_desc, size_t n, size_t siz
             cmd_desc->free_size -= required;
         }
     } else {
-#if !CONFIG_SPIRAM_USE_MALLOC
-        *outptr = calloc(n, size);
+        uint32_t alloc_caps;
+#if CONFIG_SPIRAM_USE_MALLOC
+        alloc_caps = I2C_MEM_ALLOC_CAPS_INTERNAL;
 #else
-        *outptr = heap_caps_calloc(n, size, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+        alloc_caps = I2C_MEM_ALLOC_CAPS_DEFAULT;
 #endif
+        *outptr = heap_caps_calloc(n, size, alloc_caps);
         if (*outptr == NULL) {
             err = ESP_FAIL;
         }

components/driver/i2s/i2s_common.c

@@ -10,6 +10,7 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/queue.h"
 #include "freertos/task.h"
+#include "freertos/idf_additions.h"
 
 #include "sdkconfig.h"
 
@@ -246,29 +247,12 @@ static esp_err_t i2s_register_channel(i2s_controller_t *i2s_obj, i2s_dir_t dir,
 #if CONFIG_PM_ENABLE
     new_chan->pm_lock = NULL; // Init in i2s_set_clock according to clock source
 #endif
-#if CONFIG_I2S_ISR_IRAM_SAFE
-    new_chan->msg_que_storage = (uint8_t *)heap_caps_calloc(desc_num - 1, sizeof(uint8_t *), I2S_MEM_ALLOC_CAPS);
-    ESP_GOTO_ON_FALSE(new_chan->msg_que_storage, ESP_ERR_NO_MEM, err, TAG, "No memory for message queue storage");
-    new_chan->msg_que_struct = (StaticQueue_t *)heap_caps_calloc(1, sizeof(StaticQueue_t), I2S_MEM_ALLOC_CAPS);
-    ESP_GOTO_ON_FALSE(new_chan->msg_que_struct, ESP_ERR_NO_MEM, err, TAG, "No memory for message queue struct");
-    new_chan->msg_queue =  xQueueCreateStatic(desc_num - 1, sizeof(uint8_t *), new_chan->msg_que_storage, new_chan->msg_que_struct);
-    ESP_GOTO_ON_FALSE(new_chan->msg_queue, ESP_ERR_NO_MEM, err, TAG, "No memory for message queue");
-    new_chan->mutex_struct = (StaticSemaphore_t *)heap_caps_calloc(1, sizeof(StaticSemaphore_t), I2S_MEM_ALLOC_CAPS);
-    ESP_GOTO_ON_FALSE(new_chan->mutex_struct, ESP_ERR_NO_MEM, err, TAG, "No memory for mutex struct");
-    new_chan->mutex = xSemaphoreCreateMutexStatic(new_chan->mutex_struct);
-    ESP_GOTO_ON_FALSE(new_chan->mutex, ESP_ERR_NO_MEM, err, TAG, "No memory for mutex");
-    new_chan->binary_struct = (StaticSemaphore_t *)heap_caps_calloc(1, sizeof(StaticSemaphore_t), I2S_MEM_ALLOC_CAPS);
-    ESP_GOTO_ON_FALSE(new_chan->binary_struct, ESP_ERR_NO_MEM, err, TAG, "No memory for binary struct");
-    new_chan->binary = xSemaphoreCreateBinaryStatic(new_chan->binary_struct);
-    ESP_GOTO_ON_FALSE(new_chan->binary, ESP_ERR_NO_MEM, err, TAG, "No memory for binary");
-#else
-    new_chan->msg_queue = xQueueCreate(desc_num - 1, sizeof(uint8_t *));
+    new_chan->msg_queue = xQueueCreateWithCaps(desc_num - 1, sizeof(uint8_t *), I2S_MEM_ALLOC_CAPS);
     ESP_GOTO_ON_FALSE(new_chan->msg_queue, ESP_ERR_NO_MEM, err, TAG, "No memory for message queue");
-    new_chan->mutex = xSemaphoreCreateMutex();
+    new_chan->mutex = xSemaphoreCreateMutexWithCaps(I2S_MEM_ALLOC_CAPS);
     ESP_GOTO_ON_FALSE(new_chan->mutex, ESP_ERR_NO_MEM, err, TAG, "No memory for mutex semaphore");
-    new_chan->binary = xSemaphoreCreateBinary();
+    new_chan->binary = xSemaphoreCreateBinaryWithCaps(I2S_MEM_ALLOC_CAPS);
     ESP_GOTO_ON_FALSE(new_chan->binary, ESP_ERR_NO_MEM, err, TAG, "No memory for binary semaphore");
-#endif
 
     new_chan->callbacks.on_recv = NULL;
     new_chan->callbacks.on_recv_q_ovf = NULL;
@@ -293,28 +277,14 @@ static esp_err_t i2s_register_channel(i2s_controller_t *i2s_obj, i2s_dir_t dir,
     }
     return ret;
 err:
-#if CONFIG_I2S_ISR_IRAM_SAFE
-    if (new_chan->msg_que_storage) {
-        free(new_chan->msg_que_storage);
-    }
-    if (new_chan->msg_que_struct) {
-        free(new_chan->msg_que_struct);
-    }
-    if (new_chan->mutex_struct) {
-        free(new_chan->mutex_struct);
-    }
-    if (new_chan->binary_struct) {
-        free(new_chan->binary_struct);
-    }
-#endif
     if (new_chan->msg_queue) {
-        vQueueDelete(new_chan->msg_queue);
+        vQueueDeleteWithCaps(new_chan->msg_queue);
     }
     if (new_chan->mutex) {
-        vSemaphoreDelete(new_chan->mutex);
+        vSemaphoreDeleteWithCaps(new_chan->mutex);
     }
     if (new_chan->binary) {
-        vSemaphoreDelete(new_chan->binary);
+        vSemaphoreDeleteWithCaps(new_chan->binary);
     }
     free(new_chan);
 
@@ -895,28 +865,14 @@ esp_err_t i2s_del_channel(i2s_chan_handle_t handle)
     if (handle->dma.desc) {
         i2s_free_dma_desc(handle);
     }
-#if CONFIG_I2S_ISR_IRAM_SAFE
-    if (handle->msg_que_storage) {
-        free(handle->msg_que_storage);
-    }
-    if (handle->msg_que_struct) {
-        free(handle->msg_que_struct);
-    }
-    if (handle->mutex) {
-        free(handle->mutex_struct);
-    }
-    if (handle->binary_struct) {
-        free(handle->binary_struct);
-    }
-#endif
     if (handle->msg_queue) {
-        vQueueDelete(handle->msg_queue);
+        vQueueDeleteWithCaps(handle->msg_queue);
     }
     if (handle->mutex) {
-        vSemaphoreDelete(handle->mutex);
+        vSemaphoreDeleteWithCaps(handle->mutex);
     }
     if (handle->binary) {
-        vSemaphoreDelete(handle->binary);
+        vSemaphoreDeleteWithCaps(handle->binary);
     }
 #if SOC_I2S_HW_VERSION_1
     i2s_obj->chan_occupancy = 0;

components/driver/i2s/i2s_private.h

@@ -99,12 +99,6 @@ struct i2s_channel_obj_t {
     SemaphoreHandle_t       binary;         /*!< Binary semaphore for writing / reading / enabling / disabling */
 #if CONFIG_PM_ENABLE
     esp_pm_lock_handle_t    pm_lock;        /*!< Power management lock, to avoid apb clock frequency changes while i2s is working */
-#endif
-#if CONFIG_I2S_ISR_IRAM_SAFE
-    StaticSemaphore_t       *mutex_struct;      /*!< Static mutex struct */
-    StaticSemaphore_t       *binary_struct;     /*!< Static binary struct */
-    StaticQueue_t           *msg_que_struct;    /*!< Static message queue struct */
-    void                    *msg_que_storage;   /*!< Static message queue storage */
 #endif
     QueueHandle_t           msg_queue;      /*!< Message queue handler, used for transporting data between interrupt and read/write task */
     i2s_event_callbacks_t   callbacks;      /*!< Callback functions */