Merge branch 'bugfix/lcd_driver_with_flash_encryption' into 'master'

fix(dma): also consider buffer alignment when calculating the DMA nodes

Closes IDFGH-14453 and IDF-12101

See merge request espressif/esp-idf!36617

components/esp_hw_support/dma/async_memcpy_cp_dma.c

@@ -20,6 +20,7 @@
 #include "esp_async_memcpy.h"
 #include "esp_async_memcpy_priv.h"
 #include "esp_private/gdma_link.h"
+#include "esp_private/esp_dma_utils.h"
 #include "hal/cp_dma_hal.h"
 #include "hal/cp_dma_ll.h"
 
@@ -211,11 +212,13 @@ static esp_err_t mcp_cpdma_memcpy(async_memcpy_context_t *ctx, void *dst, void *
         trans->rx_link_list = NULL;
     }
 
+    size_t num_dma_nodes = esp_dma_calculate_node_count(n, 1, MCP_DMA_DESCRIPTOR_BUFFER_MAX_SIZE);
+
     // allocate gdma TX link
     gdma_link_list_config_t tx_link_cfg = {
         .buffer_alignment = 1, // CP_DMA doesn't have alignment requirement for internal memory
         .item_alignment = 4,   // CP_DMA requires 4 bytes alignment for each descriptor
-        .num_items = n / MCP_DMA_DESCRIPTOR_BUFFER_MAX_SIZE + 1,
+        .num_items = num_dma_nodes,
         .flags = {
             .check_owner = true,
             .items_in_ext_mem = false,
@@ -239,7 +242,7 @@ static esp_err_t mcp_cpdma_memcpy(async_memcpy_context_t *ctx, void *dst, void *
     gdma_link_list_config_t rx_link_cfg = {
         .buffer_alignment = 1, // CP_DMA doesn't have alignment requirement for internal memory
         .item_alignment = 4,   // CP_DMA requires 4 bytes alignment for each descriptor
-        .num_items = n / MCP_DMA_DESCRIPTOR_BUFFER_MAX_SIZE + 1,
+        .num_items = num_dma_nodes,
         .flags = {
             .check_owner = true,
             .items_in_ext_mem = false,

components/esp_hw_support/dma/async_memcpy_gdma.c

@@ -342,11 +342,16 @@ static esp_err_t mcp_gdma_memcpy(async_memcpy_context_t *ctx, void *dst, void *s
         trans->stash_buffer = NULL;
     }
 
+    size_t buffer_alignment = 0;
+    size_t num_dma_nodes = 0;
+
     // allocate gdma TX link
+    buffer_alignment = esp_ptr_internal(src) ? mcp_gdma->tx_int_mem_alignment : mcp_gdma->tx_ext_mem_alignment;
+    num_dma_nodes = esp_dma_calculate_node_count(n, buffer_alignment, MCP_DMA_DESCRIPTOR_BUFFER_MAX_SIZE);
     gdma_link_list_config_t tx_link_cfg = {
-        .buffer_alignment = esp_ptr_internal(src) ? mcp_gdma->tx_int_mem_alignment : mcp_gdma->tx_ext_mem_alignment,
+        .buffer_alignment = buffer_alignment,
         .item_alignment = dma_link_item_alignment,
-        .num_items = n / MCP_DMA_DESCRIPTOR_BUFFER_MAX_SIZE + 1,
+        .num_items = num_dma_nodes,
         .flags = {
             .check_owner = true,
             .items_in_ext_mem = false, // TODO: if the memcopy size is too large, we may need to allocate the link list items from external memory
@@ -381,10 +386,12 @@ static esp_err_t mcp_gdma_memcpy(async_memcpy_context_t *ctx, void *dst, void *s
     }
 
     // allocate gdma RX link
+    buffer_alignment = esp_ptr_internal(dst) ? mcp_gdma->rx_int_mem_alignment : mcp_gdma->rx_ext_mem_alignment;
+    num_dma_nodes = esp_dma_calculate_node_count(n, buffer_alignment, MCP_DMA_DESCRIPTOR_BUFFER_MAX_SIZE);
     gdma_link_list_config_t rx_link_cfg = {
-        .buffer_alignment = esp_ptr_internal(dst) ? mcp_gdma->rx_int_mem_alignment : mcp_gdma->rx_ext_mem_alignment,
+        .buffer_alignment = buffer_alignment,
         .item_alignment = dma_link_item_alignment,
-        .num_items = n / MCP_DMA_DESCRIPTOR_BUFFER_MAX_SIZE + 3,
+        .num_items = num_dma_nodes + 3, // add 3 extra items for the cache aligned buffers
         .flags = {
             .check_owner = true,
             .items_in_ext_mem = false, // TODO: if the memcopy size is too large, we may need to allocate the link list items from external memory

components/esp_hw_support/dma/esp_dma_utils.c

@@ -27,6 +27,8 @@ static const char *TAG = "dma_utils";
 
 esp_err_t esp_dma_split_rx_buffer_to_cache_aligned(void *rx_buffer, size_t buffer_len, dma_buffer_split_array_t *align_buf_array, uint8_t** ret_stash_buffer)
 {
+    esp_err_t ret = ESP_OK;
+    uint8_t* stash_buffer = NULL;
     ESP_RETURN_ON_FALSE(rx_buffer && buffer_len && align_buf_array, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
 
     // read the cache line size of internal and external memory, we also use this information to check if a given memory is behind the cache
@@ -43,7 +45,7 @@ esp_err_t esp_dma_split_rx_buffer_to_cache_aligned(void *rx_buffer, size_t buffe
 
     // allocate the stash buffer from internal RAM
     // Note, the split_line_size can be 0, in this case, the stash_buffer is also NULL, which is fine
-    uint8_t* stash_buffer = heap_caps_calloc(2, split_line_size, MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+    stash_buffer = heap_caps_calloc(2, split_line_size, MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
     ESP_RETURN_ON_FALSE(!(split_line_size && !stash_buffer), ESP_ERR_NO_MEM, TAG, "no mem for stash buffer");
 
     // clear align_array to avoid garbage data
@@ -99,12 +101,18 @@ esp_err_t esp_dma_split_rx_buffer_to_cache_aligned(void *rx_buffer, size_t buffe
     // invalidate the aligned buffer if necessary
     for (int i = 0; i < 3; i++) {
         if (need_cache_sync[i]) {
-            esp_cache_msync(align_buf_array->aligned_buffer[i].aligned_buffer, align_buf_array->aligned_buffer[i].length, ESP_CACHE_MSYNC_FLAG_DIR_M2C);
+            esp_err_t res = esp_cache_msync(align_buf_array->aligned_buffer[i].aligned_buffer, align_buf_array->aligned_buffer[i].length, ESP_CACHE_MSYNC_FLAG_DIR_M2C);
+            ESP_GOTO_ON_ERROR(res, err, TAG, "failed to do cache sync");
         }
     }
 
     *ret_stash_buffer = stash_buffer;
     return ESP_OK;
+err:
+    if (stash_buffer) {
+        free(stash_buffer);
+    }
+    return ret;
 }
 
 esp_err_t esp_dma_merge_aligned_rx_buffers(dma_buffer_split_array_t *align_array)
@@ -121,6 +129,16 @@ esp_err_t esp_dma_merge_aligned_rx_buffers(dma_buffer_split_array_t *align_array
     return ESP_OK;
 }
 
+size_t esp_dma_calculate_node_count(size_t buffer_size, size_t buffer_alignment, size_t max_buffer_size_per_node)
+{
+    // buffer_alignment should be power of 2
+    ESP_RETURN_ON_FALSE(buffer_alignment && ((buffer_alignment & (buffer_alignment - 1)) == 0), 0, TAG, "invalid buffer alignment");
+    // align down the max_buffer_size_per_node
+    max_buffer_size_per_node = max_buffer_size_per_node & ~(buffer_alignment - 1);
+    // calculate the number of nodes
+    return (buffer_size + max_buffer_size_per_node - 1) / max_buffer_size_per_node;
+}
+
 esp_err_t esp_dma_capable_malloc(size_t size, const esp_dma_mem_info_t *dma_mem_info, void **out_ptr, size_t *actual_size)
 {
     ESP_RETURN_ON_FALSE_ISR(dma_mem_info && out_ptr, ESP_ERR_INVALID_ARG, TAG, "null pointer");

components/esp_hw_support/dma/include/esp_private/esp_dma_utils.h

@@ -83,6 +83,16 @@ esp_err_t esp_dma_split_rx_buffer_to_cache_aligned(void *rx_buffer, size_t buffe
  */
 esp_err_t esp_dma_merge_aligned_rx_buffers(dma_buffer_split_array_t *align_buf_array);
 
+/**
+ * @brief Calculate the number of DMA linked list nodes required for a given buffer size
+ *
+ * @param[in] buffer_size Total size of the buffer
+ * @param[in] buffer_alignment Alignment requirement for the buffer
+ * @param[in] max_buffer_size_per_node Maximum buffer size that each node can handle
+ * @return Number of DMA linked list nodes required
+ */
+size_t esp_dma_calculate_node_count(size_t buffer_size, size_t buffer_alignment, size_t max_buffer_size_per_node);
+
 #ifdef __cplusplus
 }
 #endif

components/esp_hw_support/test_apps/dma/main/test_gdma.c

@@ -557,7 +557,7 @@ TEST_CASE("GDMA M2M Unaligned RX Buffer Test", "[GDMA][M2M]")
 
     gdma_link_list_handle_t tx_link_list = NULL;
     gdma_link_list_handle_t rx_link_list = NULL;
-    // create DMA link list for TX channel (a singly link with 3 nodes)
+    // create DMA link list for TX channel
     gdma_link_list_config_t tx_link_list_config = {
         .buffer_alignment = 32,
         .item_alignment = 8, // 8-byte alignment required by the AXI-GDMA