Merge branch 'refa/replce_esp_dma_xxx_malloc_api' into 'master'

refa(spi): clean up esp_dma_xxx memory allocation code

Closes IDF-9656

See merge request espressif/esp-idf!31239

Author: wanckl

components/esp_driver_spi/include/driver/spi_common.h

@@ -174,18 +174,13 @@ esp_err_t spi_bus_free(spi_host_device_t host_id);
  * @note This API will take care of the cache and hardware alignment internally.
  *       To free/release memory allocated by this helper function, simply calling `free()`
  *
- * @param[in]  size          Size in bytes, the amount of memory to allocate
- * @param[out] out_ptr       Pointer to the memory if allocated successfully
- * @param[in]  extra_heap_caps Extra heap caps based on MALLOC_CAP_DMA
- * @param[out] actual_size   Optional, Actual size for allocation in bytes, when the size you specified doesn't meet the internal alignment requirements,
- *                           This value might be bigger than the size you specified. Set NULL if don't care this value.
+ * @param[in]  host_id          SPI peripheral who will using the memory
+ * @param[in]  size             Size in bytes, the amount of memory to allocate
+ * @param[in]  extra_heap_caps  Extra heap caps based on MALLOC_CAP_DMA
  *
- * @return
- *        - ESP_ERR_INVALID_ARG     Invalid argument
- *        - ESP_ERR_NO_MEM          No enough memory for allocation
- *        - ESP_OK                  on success
+ * @return                      Pointer to the memory if allocated successfully
  */
-esp_err_t spi_bus_dma_memory_malloc(size_t size, void **out_ptr, uint32_t extra_heap_caps, size_t *actual_size);
+void *spi_bus_dma_memory_alloc(spi_host_device_t host_id, size_t size, uint32_t extra_heap_caps);
 
 #ifdef __cplusplus
 }

components/esp_driver_spi/include/esp_private/spi_common_internal.h

@@ -50,7 +50,7 @@ typedef struct {
     uint32_t flags;                     ///< Flags (attributes) of the bus
     int max_transfer_sz;                ///< Maximum length of bytes available to send
     bool dma_enabled;                   ///< To enable DMA or not
-    uint16_t internal_mem_align_size;   ///< Buffer align byte requirement for internal memory
+    size_t internal_mem_align_size;     ///< Buffer align byte requirement for internal memory
     spi_bus_lock_handle_t lock;
 #ifdef CONFIG_PM_ENABLE
     esp_pm_lock_handle_t pm_lock;       ///< Power management lock

components/esp_driver_spi/src/gpspi/spi_common.c

@@ -287,12 +287,8 @@ esp_err_t spicommon_dma_desc_alloc(spi_dma_ctx_t *dma_ctx, int cfg_max_sz, int *
         dma_desc_ct = 1;    //default to 4k when max is not given
     }
 
-    esp_dma_mem_info_t dma_mem_info = {
-        .dma_alignment_bytes = DMA_DESC_MEM_ALIGN_SIZE,
-    };
-    esp_dma_capable_malloc(sizeof(spi_dma_desc_t) * dma_desc_ct, &dma_mem_info, (void*)&dma_ctx->dmadesc_tx, NULL);
-    esp_dma_capable_malloc(sizeof(spi_dma_desc_t) * dma_desc_ct, &dma_mem_info, (void*)&dma_ctx->dmadesc_rx, NULL);
-
+    dma_ctx->dmadesc_tx = heap_caps_aligned_calloc(DMA_DESC_MEM_ALIGN_SIZE, 1, sizeof(spi_dma_desc_t) * dma_desc_ct, MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL);
+    dma_ctx->dmadesc_rx = heap_caps_aligned_calloc(DMA_DESC_MEM_ALIGN_SIZE, 1, sizeof(spi_dma_desc_t) * dma_desc_ct, MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL);
     if (dma_ctx->dmadesc_tx == NULL || dma_ctx->dmadesc_rx == NULL) {
         if (dma_ctx->dmadesc_tx) {
             free(dma_ctx->dmadesc_tx);
@@ -886,13 +882,13 @@ esp_err_t spi_bus_initialize(spi_host_device_t host_id, const spi_bus_config_t *
     return err;
 }
 
-esp_err_t spi_bus_dma_memory_malloc(size_t size, void **out_ptr, uint32_t extra_heap_caps, size_t *actual_size)
+void *spi_bus_dma_memory_alloc(spi_host_device_t host_id, size_t size, uint32_t extra_heap_caps)
 {
-    esp_dma_mem_info_t dma_mem_info = {
-        .extra_heap_caps = extra_heap_caps,
-        .dma_alignment_bytes = DMA_DESC_MEM_ALIGN_SIZE,
-    };
-    return esp_dma_capable_malloc(size, &dma_mem_info, out_ptr, actual_size);
+    (void) host_id; //remain for extendability
+    ESP_RETURN_ON_FALSE((extra_heap_caps & MALLOC_CAP_SPIRAM) == 0, NULL, SPI_TAG, "external memory is not supported now");
+
+    size_t dma_requir = 16;  //TODO: IDF-10111, using max alignment temp, refactor to "gdma_get_alignment_constraints" instead
+    return heap_caps_aligned_calloc(dma_requir, 1, size, extra_heap_caps | MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL);
 }
 
 const spi_bus_attr_t* spi_bus_get_attr(spi_host_device_t host_id)

components/esp_driver_spi/test_apps/master/main/test_spi_master.c

@@ -1092,10 +1092,10 @@ TEST_CASE("SPI master hd dma TX without RX test", "[spi]")
     same_pin_func_sel(bus_cfg, dev_cfg, 0);
 
     uint32_t buf_size = 32;
-    uint8_t *mst_send_buf = heap_caps_malloc(buf_size, MALLOC_CAP_DMA);
-    uint8_t *mst_recv_buf = heap_caps_calloc(buf_size, 1, MALLOC_CAP_DMA);
-    uint8_t *slv_send_buf = heap_caps_malloc(buf_size, MALLOC_CAP_DMA);
-    uint8_t *slv_recv_buf = heap_caps_calloc(buf_size, 1, MALLOC_CAP_DMA);
+    uint8_t *mst_send_buf = spi_bus_dma_memory_alloc(TEST_SPI_HOST, buf_size, 0);
+    uint8_t *mst_recv_buf = spi_bus_dma_memory_alloc(TEST_SPI_HOST, buf_size, 0);
+    uint8_t *slv_send_buf = spi_bus_dma_memory_alloc(TEST_SLAVE_HOST, buf_size, 0);
+    uint8_t *slv_recv_buf = spi_bus_dma_memory_alloc(TEST_SLAVE_HOST, buf_size, 0);
 
     srand(199);
     for (int i = 0; i < buf_size; i++) {

examples/peripherals/spi_master/lcd/main/spi_master_example_main.c

@@ -100,7 +100,7 @@ DRAM_ATTR static const lcd_init_cmd_t st_init_cmds[] = {
 };
 
 DRAM_ATTR static const lcd_init_cmd_t ili_init_cmds[] = {
-    /* Power contorl B, power control = 0, DC_ENA = 1 */
+    /* Power control B, power control = 0, DC_ENA = 1 */
     {0xCF, {0x00, 0x83, 0X30}, 3},
     /* Power on sequence control,
      * cp1 keeps 1 frame, 1st frame enable
@@ -128,7 +128,7 @@ DRAM_ATTR static const lcd_init_cmd_t ili_init_cmds[] = {
     {0xC5, {0x35, 0x3E}, 2},
     /* VCOM control 2, VCOMH=VMH-2, VCOML=VML-2 */
     {0xC7, {0xBE}, 1},
-    /* Memory access contorl, MX=MY=0, MV=1, ML=0, BGR=1, MH=0 */
+    /* Memory access control, MX=MY=0, MV=1, ML=0, BGR=1, MH=0 */
     {0x36, {0x28}, 1},
     /* Pixel format, 16bits/pixel for RGB/MCU interface */
     {0x3A, {0x55}, 1},
@@ -377,7 +377,7 @@ static void display_pretty_colors(spi_device_handle_t spi)
     uint16_t *lines[2];
     //Allocate memory for the pixel buffers
     for (int i = 0; i < 2; i++) {
-        lines[i] = heap_caps_malloc(320 * PARALLEL_LINES * sizeof(uint16_t), MALLOC_CAP_DMA);
+        lines[i] = spi_bus_dma_memory_alloc(LCD_HOST, 320 * PARALLEL_LINES * sizeof(uint16_t), 0);
         assert(lines[i] != NULL);
     }
     int frame = 0;

examples/peripherals/spi_slave_hd/segment_mode/seg_master/main/app_main.c

@@ -203,12 +203,12 @@ void app_main(void)
     printf("Slave MAX Send Buffer Size:       %"PRIu32"\n", slave_max_tx_buf_size);
     printf("Slave MAX Receive Buffer Size:    %"PRIu32"\n", slave_max_rx_buf_size);
 
-    uint8_t *recv_buf = heap_caps_calloc(1, rx_buf_size, MALLOC_CAP_DMA);
+    uint8_t *recv_buf = spi_bus_dma_memory_alloc(MASTER_HOST, rx_buf_size, 0);
     if (!recv_buf) {
         ESP_LOGE(TAG, "No enough memory!");
         abort();
     }
-    uint8_t *send_buf = heap_caps_calloc(1, slave_max_rx_buf_size, MALLOC_CAP_DMA);
+    uint8_t *send_buf = spi_bus_dma_memory_alloc(MASTER_HOST, slave_max_rx_buf_size, 0);
     if (!send_buf) {
         ESP_LOGE(TAG, "No enough memory!");
         abort();