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

Closes https://github.com/espressif/esp-idf/issues/15228

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

@@ -341,11 +341,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
@@ -380,10 +385,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

@@ -126,6 +126,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