refactor(sd): port legacy sd driver with NG driver

Author: Icarus113

components/esp_driver_sdmmc/CMakeLists.txt

@@ -2,12 +2,12 @@ idf_build_get_property(target IDF_TARGET)
 
 set(srcs)
 
-set(public_include "include")
+set(public_include "include" "legacy/include")
 
 # SDMMC related source files
 if(CONFIG_SOC_SDMMC_HOST_SUPPORTED)
-    list(APPEND srcs "src/sdmmc_transaction.c"
-                     "src/sdmmc_host.c")
+    list(APPEND srcs "legacy/src/sdmmc_transaction.c"
+                     "legacy/src/sdmmc_host.c"
                      "src/sd_host_sdmmc.c"
                      "src/sd_trans_sdmmc.c")
 endif()

components/esp_driver_sdmmc/include/driver/sdmmc_default_configs.h renamed to components/esp_driver_sdmmc/legacy/include/driver/sdmmc_default_configs.h

@@ -47,6 +47,7 @@ extern "C" {
     .get_real_freq = &sdmmc_host_get_real_freq, \
     .input_delay_phase = SDMMC_DELAY_PHASE_0, \
     .set_input_delay = &sdmmc_host_set_input_delay, \
+    .set_input_delayline = &sdmmc_host_set_input_delayline, \
     .dma_aligned_buffer = NULL, \
     .pwr_ctrl_handle = NULL, \
     .get_dma_info = NULL, \

components/esp_driver_sdmmc/include/driver/sdmmc_defs.h renamed to components/esp_driver_sdmmc/legacy/include/driver/sdmmc_defs.h

@@ -274,6 +274,23 @@ esp_err_t sdmmc_host_get_real_freq(int slot, int* real_freq_khz);
  */
 esp_err_t sdmmc_host_set_input_delay(int slot, sdmmc_delay_phase_t delay_phase);
 
+/**
+ * @brief set input delayline
+ *
+ * - This API sets delay when the SDMMC Host samples the signal from the SD Slave.
+ * - This API will check if the given `delay_line` is valid or not.
+ * - This API will print out the delay time, in picosecond (ps)
+ *
+ * @param slot         slot number (SDMMC_HOST_SLOT_0 or SDMMC_HOST_SLOT_1)
+ * @param delay_line   delay line, this API will convert the line into picoseconds and print it out
+ *
+ * @return
+ *        - ESP_OK:                ON success.
+ *        - ESP_ERR_INVALID_ARG:   Invalid argument.
+ *        - ESP_ERR_NOT_SUPPORTED: Some chips don't support this feature.
+ */
+esp_err_t sdmmc_host_set_input_delayline(int slot, sdmmc_delay_line_t delay_line);
+
 /**
  * @brief Get the DMA memory information for the host driver
  *

components/esp_driver_sdmmc/include/driver/sdmmc_host.h renamed to components/esp_driver_sdmmc/legacy/include/driver/sdmmc_host.h

@@ -0,0 +1,272 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+#include <sys/param.h>
+#include "esp_log.h"
+#include "esp_check.h"
+#include "driver/sdmmc_host.h"
+#include "driver/sd_host_sdmmc.h"
+#include "driver/sd_host.h"
+#include "sdmmc_internal.h"
+
+#define SLOT_CHECK(slot_num) \
+if (slot_num < 0 || slot_num >= SOC_SDMMC_NUM_SLOTS) { \
+    return ESP_ERR_INVALID_ARG; \
+}
+
+#define SDMMC_EVENT_QUEUE_LENGTH    32
+
+static const char *TAG = "sdmmc_periph";
+static sd_host_ctlr_handle_t s_ctlr = NULL;
+static sd_host_slot_handle_t s_slot0 = NULL;
+static sd_host_slot_handle_t s_slot1 = NULL;
+
+esp_err_t sdmmc_host_set_card_clk(int slot, uint32_t freq_khz)
+{
+    SLOT_CHECK(slot);
+
+    sd_host_slot_handle_t hdl = sdmmc_get_slot_handle(slot);
+    sd_host_slot_cfg_t cfg = {
+        .freq.freq_hz = freq_khz * 1000,
+        .freq.override = true,
+    };
+    ESP_RETURN_ON_ERROR(sd_host_slot_configure(hdl, &cfg), TAG, "failed to configure slot freq");
+
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_host_get_real_freq(int slot, int *real_freq_khz)
+{
+    SLOT_CHECK(slot);
+
+    sd_host_slot_handle_t hdl = sdmmc_get_slot_handle(slot);
+    sd_host_sdmmc_slot_t *slot_ctx = __containerof(hdl, sd_host_sdmmc_slot_t, drv);
+    ESP_RETURN_ON_ERROR(sd_host_slot_get_calc_real_freq(slot_ctx, real_freq_khz), TAG, "failed to get slot freq");
+
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_host_set_input_delay(int slot, sdmmc_delay_phase_t delay_phase)
+{
+    SLOT_CHECK(slot);
+    sd_host_slot_handle_t hdl = sdmmc_get_slot_handle(slot);
+    sd_host_slot_cfg_t cfg = {
+        .delay_phase.delayphase = delay_phase,
+        .delay_phase.override = true,
+    };
+    ESP_RETURN_ON_ERROR(sd_host_slot_configure(hdl, &cfg), TAG, "failed to configure slot delay phase");
+
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_host_set_input_delayline(int slot, sdmmc_delay_line_t delay_line)
+{
+    SLOT_CHECK(slot);
+    sd_host_slot_handle_t hdl = sdmmc_get_slot_handle(slot);
+    sd_host_slot_cfg_t cfg = {
+        .delay_line.delayline = delay_line,
+        .delay_line.override = true,
+    };
+    ESP_RETURN_ON_ERROR(sd_host_slot_configure(hdl, &cfg), TAG, "failed to configure slot delay line");
+
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_host_init(void)
+{
+    sd_host_sdmmc_cfg_t cfg = {
+        .event_queue_items = SDMMC_EVENT_QUEUE_LENGTH,
+    };
+    esp_err_t ret = sd_host_create_sdmmc_controller(&cfg, &s_ctlr);
+    ESP_RETURN_ON_ERROR(ret, TAG, "failed to create new SD controller");
+
+    return ESP_OK;
+}
+
+sd_host_slot_handle_t sdmmc_get_slot_handle(int slot_id)
+{
+    return slot_id == 0 ? s_slot0 : s_slot1;
+}
+
+esp_err_t sdmmc_host_is_slot_set_to_uhs1(int slot, bool *is_uhs1)
+{
+    SLOT_CHECK(slot);
+    sd_host_slot_handle_t hdl = sdmmc_get_slot_handle(slot);
+
+    sd_host_slot_info_t info = {};
+    ESP_RETURN_ON_ERROR(sd_host_slot_get_info(hdl, &info), TAG, "failed to get slot info");
+    if (info.sd_mode == SD_MODE_UHS1) {
+        *is_uhs1 = true;
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_host_init_slot(int slot, const sdmmc_slot_config_t *slot_config)
+{
+    esp_err_t ret = ESP_FAIL;
+
+    bool internal_pullup = (slot_config->flags & SDMMC_SLOT_FLAG_INTERNAL_PULLUP);
+    bool wp_active_high = (slot_config->flags & SDMMC_SLOT_FLAG_WP_ACTIVE_HIGH);
+    sd_host_slot_sdmmc_init_cfg_t cfg = {
+        .slot_id = slot,
+        .sd_mode = (slot_config->flags & SDMMC_SLOT_FLAG_UHS1) ? SD_MODE_UHS1 : SD_MODE_NORMAL,
+        .io_config = {
+            .width = slot_config->width,
+            .clk_io = slot_config->clk,
+            .cmd_io = slot_config->cmd,
+            .cd_io = slot_config->cd,
+            .wp_io = slot_config->wp,
+            .d0_io = slot_config->d0,
+            .d1_io = slot_config->d1,
+            .d2_io = slot_config->d2,
+            .d3_io = slot_config->d3,
+            .d4_io = slot_config->d4,
+            .d5_io = slot_config->d5,
+            .d6_io = slot_config->d6,
+            .d7_io = slot_config->d7,
+        },
+        .slot_flags.internal_pullup = internal_pullup,
+        .slot_flags.wp_active_high = wp_active_high,
+    };
+    if (slot == 0) {
+        ret = sd_host_sdmmc_controller_add_slot(s_ctlr, &cfg, &s_slot0);
+    } else {
+        ret = sd_host_sdmmc_controller_add_slot(s_ctlr, &cfg, &s_slot1);
+    }
+    ESP_RETURN_ON_ERROR(ret, TAG, "failed to add new SD slot");
+
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_host_deinit_slot(int slot)
+{
+    esp_err_t ret = ESP_FAIL;
+    sd_host_slot_handle_t hdl = sdmmc_get_slot_handle(slot);
+    ESP_RETURN_ON_ERROR(sd_host_remove_slot(hdl), TAG, "failed to remove slot");
+
+    ret = sd_host_del_controller(s_ctlr);
+    //for backward compatibility, return ESP_OK when only slot is removed and host is still there
+    if (ret == ESP_ERR_INVALID_STATE) {
+        ret = ESP_OK;
+    }
+
+    return ret;
+}
+
+esp_err_t sdmmc_host_deinit(void)
+{
+    esp_err_t ret = ESP_FAIL;
+    sd_host_slot_handle_t hdl[2] = {s_slot0, s_slot1};
+    for (int i = 0; i < 2; i++) {
+        if (hdl[i]) {
+            ret = sd_host_remove_slot(hdl[i]);
+            ESP_RETURN_ON_ERROR(ret, TAG, "failed to remove slot%d", i);
+        }
+    }
+    ESP_RETURN_ON_ERROR(sd_host_del_controller(s_ctlr), TAG, "failed to delete controller");
+
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_host_set_bus_width(int slot, size_t width)
+{
+    SLOT_CHECK(slot);
+
+    sd_host_slot_handle_t hdl = sdmmc_get_slot_handle(slot);
+    sd_host_slot_cfg_t cfg = {
+        .width.override = true,
+    };
+    ESP_RETURN_ON_ERROR(sd_host_slot_configure(hdl, &cfg), TAG, "failed to configure slot bus width");
+
+    return ESP_OK;
+}
+
+size_t sdmmc_host_get_slot_width(int slot)
+{
+    SLOT_CHECK(slot);
+
+    sd_host_slot_handle_t hdl = sdmmc_get_slot_handle(slot);
+    sd_host_slot_info_t info = {};
+    esp_err_t ret = sd_host_slot_get_info(hdl, &info);
+    assert(ret == ESP_OK);
+
+    return info.width;
+}
+
+esp_err_t sdmmc_host_set_bus_ddr_mode(int slot, bool ddr_enabled)
+{
+    sd_host_slot_handle_t hdl = sdmmc_get_slot_handle(slot);
+    sd_host_slot_cfg_t cfg = {
+        .sampling_mode.mode = ddr_enabled ? SD_SAMPLING_MODE_DDR : SD_SAMPLING_MODE_SDR,
+        .sampling_mode.override = true,
+    };
+    ESP_RETURN_ON_ERROR(sd_host_slot_configure(hdl, &cfg), TAG, "failed to configure slot ddr mode");
+
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_host_set_cclk_always_on(int slot, bool cclk_always_on)
+{
+    SLOT_CHECK(slot);
+
+    sd_host_slot_handle_t hdl = sdmmc_get_slot_handle(slot);
+    ESP_RETURN_ON_ERROR(sd_host_slot_set_cclk_always_on(hdl, cclk_always_on), TAG, "failed to configure slot cclk always on");
+
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_host_io_int_enable(int slot)
+{
+    sd_host_slot_handle_t hdl = sdmmc_get_slot_handle(slot);
+    return sd_host_slot_enable_io_int(hdl);
+}
+
+esp_err_t sdmmc_host_io_int_wait(int slot, TickType_t timeout_ticks)
+{
+    assert(slot == 0 || slot == 1);
+    sd_host_slot_handle_t hdl = sdmmc_get_slot_handle(slot);
+    ESP_RETURN_ON_ERROR(sd_host_slot_wait_io_int(hdl, timeout_ticks), TAG, "failed to wait io interrupt");
+
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_host_get_dma_info(int slot, esp_dma_mem_info_t *dma_mem_info)
+{
+    SLOT_CHECK(slot);
+
+    if (dma_mem_info == NULL) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    dma_mem_info->extra_heap_caps = MALLOC_CAP_DMA;
+    dma_mem_info->dma_alignment_bytes = 4;
+    return ESP_OK;
+}
+
+bool sdmmc_host_check_buffer_alignment(int slot, const void *buf, size_t size)
+{
+    assert(slot == 0 || slot == 1);
+    sd_host_slot_handle_t hdl = sdmmc_get_slot_handle(slot);
+    sd_host_sdmmc_slot_t *slot_ctx = __containerof(hdl, sd_host_sdmmc_slot_t, drv);
+
+    return sd_host_check_buffer_alignment(slot_ctx, buf, size);
+}
+
+esp_err_t sdmmc_host_get_state(sdmmc_host_state_t* state)
+{
+    ESP_RETURN_ON_FALSE(state, ESP_ERR_INVALID_ARG, TAG, "invalid argument: null pointer");
+
+    if (s_ctlr) {
+        state->host_initialized = true;
+        sd_host_sdmmc_ctlr_t *ctlr_ctx = __containerof(s_ctlr, sd_host_sdmmc_ctlr_t, drv);
+        state->num_of_init_slots = ctlr_ctx->registered_slot_nums;
+    }
+
+    return ESP_OK;
+}

components/esp_driver_sdmmc/include/driver/sdmmc_types.h renamed to components/esp_driver_sdmmc/legacy/include/driver/sdmmc_types.h

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -12,23 +12,13 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/queue.h"
 #include "soc/sdmmc_periph.h"
-
-typedef struct {
-    uint32_t sdmmc_status;      ///< masked SDMMC interrupt status
-    uint32_t dma_status;        ///< masked DMA interrupt status
-} sdmmc_event_t;
-
-#define SDMMC_HOST_CLOCK_UPDATE_CMD_TIMEOUT_US           1000 * 1000
-#define SDMMC_HOST_START_CMD_TIMEOUT_US                  1000 * 1000
-#define SDMMC_HOST_RESET_TIMEOUT_US                      5000 * 1000
+#include "esp_private/sd_host_private.h"
 
 esp_err_t sdmmc_host_reset(void);
 
 esp_err_t sdmmc_host_start_command(int slot, sdmmc_hw_cmd_t cmd, uint32_t arg);
 
-esp_err_t sdmmc_host_wait_for_event(int tick_count, sdmmc_event_t* out_event);
-
-void sdmmc_host_dma_prepare(void* data_ptr, size_t data_size, size_t block_size);
+esp_err_t sdmmc_host_wait_for_event(int tick_count, sd_host_sdmmc_event_t* out_event);
 
 void sdmmc_host_dma_stop(void);
 
@@ -41,3 +31,6 @@ void sdmmc_host_enable_clk_cmd11(int slot, bool enable);
 esp_err_t sdmmc_host_transaction_handler_init(void);
 
 void sdmmc_host_transaction_handler_deinit(void);
+
+//get slot handle, for legacy driver compatibility
+sd_host_slot_handle_t sdmmc_get_slot_handle(int slot_id);

components/esp_driver_sdmmc/legacy/src/sdmmc_host.c

@@ -0,0 +1,27 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <string.h>
+#include <unistd.h>
+#include "esp_err.h"
+#include "esp_log.h"
+#include "esp_check.h"
+#include "driver/sdmmc_types.h"
+#include "driver/sdmmc_defs.h"
+#include "driver/sdmmc_host.h"
+#include "driver/sd_host.h"
+#include "sdmmc_internal.h"
+
+static const char* TAG = "sdmmc_req";
+
+esp_err_t sdmmc_host_do_transaction(int slot, sdmmc_command_t* cmdinfo)
+{
+    sd_host_slot_handle_t slot_hdl = sdmmc_get_slot_handle(slot);
+    esp_err_t ret = sd_host_slot_do_transaction(slot_hdl, cmdinfo);
+    ESP_RETURN_ON_ERROR(ret, TAG, "failed to do SD transaction");
+
+    return ESP_OK;
+}