sdio: initial SDIO HAL implementation

Provides the initial skeleton for the `embedded_hal::mmc::MmcOps`
implementation for the SDIO peripherals on the ESP32C6 microcontroller.

Author: rmsyn

esp-hal/Cargo.toml

@@ -27,8 +27,8 @@ bitflags                 = "2.9.0"
 bytemuck                 = "1.22.0"
 cfg-if                   = "1.0.0"
 critical-section         = { version = "1.2.0", features = ["restore-state-u32"] }
-embedded-hal             = "1.0.0"
-embedded-hal-async       = "1.0.0"
+embedded-hal             = { version = "1.0.0", git = "https://github.com/rmsyn/embedded-hal", branch = "embedded-hal/mmc" }
+embedded-hal-async       = { version = "1.0.0", git = "https://github.com/rmsyn/embedded-hal", branch = "embedded-hal/mmc" }
 enumset                  = "1.1.5"
 paste                    = "1.0.15"
 portable-atomic          = { version = "1.11.0", default-features = false }

esp-hal/src/lib.rs

@@ -226,6 +226,7 @@ pub mod i2c;
 pub mod peripheral;
 #[cfg(all(feature = "unstable", any(hmac, sha)))]
 mod reg_access;
+pub mod sdio;
 #[cfg(any(spi0, spi1, spi2, spi3))]
 pub mod spi;
 pub mod system;

esp-hal/src/sdio.rs

@@ -0,0 +1,140 @@
+//! # Secure Digital I/O - Slave Mode
+//!
+//! ## Overiew
+//!
+//! The peripheral can be used to transfer data over the SDIO bus in `Slave` mode.
+
+use embedded_hal::mmc::command::MmcCommand;
+use embedded_hal::mmc::response::MmcResponse;
+use embedded_hal::mmc::tuning::{TuningMode, TuningWidth};
+use embedded_hal::mmc::{CardMode, CardType, FifoStatus, MmcOps, Reset};
+
+pub mod error;
+
+use error::Error;
+
+mod slc;
+mod slchost;
+
+pub use slc::*;
+pub use slchost::*;
+
+/// SDIO peripheral instance.
+pub trait PeripheralInstance: crate::private::Sealed {
+    /// Represents the peripheral information type containing the register block.
+    type Info;
+
+    /// Gets a static shared reference to the peripheral information.
+    fn info(&self) -> &'static Self::Info;
+}
+
+/// Represents the SDIO 2.0 peripheral for the microcontroller.
+#[derive(Debug)]
+pub struct Sdio<'d> {
+    slc: AnySlc<'d>,
+    slchost: AnySlchost<'d>,
+}
+
+impl<'d> Sdio<'d> {
+    /// Creates a new [Sdio].
+    ///
+    /// # Example
+    ///
+    /// ```rust,no_run
+    /// use crate::peripheral::Peripherals;
+    /// use esp_hal::sdio::Sdio;
+    ///
+    /// let dp = Peripheral::take().unwrap();
+    /// let _sdio = Sdio::new(dp.slc, dp.slchost);
+    /// ```
+    pub fn new(slc: impl SlcInstance + 'd, slchost: impl SlchostInstance + 'd) -> Self {
+        Self {
+            slc: slc.degrade(),
+            slchost: slchost.degrade(),
+        }
+    }
+
+    /// Gets a static reference to the SLC information.
+    pub fn slc(&self) -> &'static SlcInfo {
+        self.slc.info()
+    }
+
+    /// Gets a static reference to the SLCHOST information.
+    pub fn slchost(&self) -> &'static SlchostInfo {
+        self.slchost.info()
+    }
+}
+
+impl<'d> MmcOps for Sdio<'d> {
+    type Error = Error;
+
+    fn card_type(&self) -> CardType {
+        CardType::Sd
+    }
+
+    fn card_mode(&self) -> CardMode {
+        CardMode::Sdio
+    }
+
+    fn setup_bus(&mut self) -> Result<(), Self::Error> {
+        Err(Error::unimplemented())
+    }
+
+    fn init(&mut self) -> Result<(), Self::Error> {
+        Err(Error::unimplemented())
+    }
+
+    fn set_sample_phase(&mut self, _sample_phase: u8) {}
+
+    fn fifo_ready(&self, _fifo_status: FifoStatus) -> Result<(), Self::Error> {
+        Err(Error::unimplemented())
+    }
+
+    fn wait_for_reset(&mut self, _reset: Reset, _timeout: u64) -> Result<(), Self::Error> {
+        Err(Error::unimplemented())
+    }
+
+    fn wait_while_busy(&mut self, _timout_us: u64) -> Result<(), Self::Error> {
+        Err(Error::unimplemented())
+    }
+
+    fn write_command<C: MmcCommand>(&mut self, _cmd: &C) -> Result<(), Self::Error> {
+        Err(Error::unimplemented())
+    }
+
+    fn read_response<C: MmcCommand, R: MmcResponse>(&mut self, _cmd: &C) -> Result<R, Self::Error> {
+        Err(Error::unimplemented())
+    }
+
+    fn response_bytes<const N: usize>(&mut self, _exp_crc: bool) -> Result<[u8; N], Self::Error> {
+        Err(Error::unimplemented())
+    }
+
+    fn read_data(&mut self, _data: &mut [u8]) -> Result<(), Self::Error> {
+        Err(Error::unimplemented())
+    }
+
+    fn write_data(&mut self, _data: &[u8]) -> Result<(), Self::Error> {
+        Err(Error::unimplemented())
+    }
+
+    fn send_tuning(&mut self, _mode: TuningMode, _width: TuningWidth) -> Result<(), Self::Error> {
+        Err(Error::unimplemented())
+    }
+
+    fn interrupt(&self) -> u32 {
+        0
+    }
+
+    fn set_interrupt(&mut self, _int: u32) {}
+
+    fn clear_all_interrupt(&mut self) {}
+
+    fn response_interrupt(&self) -> u32 {
+        0
+    }
+
+    fn set_response_interrupt(&mut self, _int: u32) {}
+
+    fn clear_all_response_interrupt(&mut self) {}
+}

esp-hal/src/sdio/error.rs

@@ -0,0 +1,36 @@
+//! Error and result types for SDIO peripherals.
+
+/// Represents the error variants for SDIO peripherals.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Error {
+    /// The function and/or type is unimplemented.
+    Unimplemented,
+}
+
+impl Error {
+    /// Creates a new [Error].
+    pub const fn new() -> Self {
+        Self::Unimplemented
+    }
+
+    /// Creates an unimplemented [Error].
+    pub const fn unimplemented() -> Self {
+        Self::Unimplemented
+    }
+}
+
+impl Default for Error {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Unimplemented => write!(f, "unimplemented"),
+        }
+    }
+}
+
+impl core::error::Error for Error {}

esp-hal/src/sdio/slc.rs

@@ -0,0 +1,35 @@
+use crate::pac::slc;
+
+use super::PeripheralInstance;
+
+crate::any_peripheral! {
+    /// Any SDIO SLC peripheral.
+    pub peripheral AnySlc<'d> {
+        Slc(crate::peripherals::SLC<'d>)
+    }
+}
+
+/// Represents the SLC registers for SDIO peripherals.
+pub struct SlcInfo {
+    /// Represents the SLC register block.
+    pub register_block: *const slc::RegisterBlock,
+}
+
+unsafe impl Sync for SlcInfo {}
+
+impl PeripheralInstance for AnySlc<'_> {
+    type Info = SlcInfo;
+
+    fn info(&self) -> &'static Self::Info {
+        static INFO: SlcInfo = SlcInfo {
+            register_block: crate::peripherals::SLC::ptr(),
+        };
+
+        &INFO
+    }
+}
+
+/// A peripheral singleton compatible with the SDIO SLC driver.
+pub trait SlcInstance: PeripheralInstance + IntoAnySlc {}
+
+impl<'d> SlcInstance for AnySlc<'d> {}

esp-hal/src/sdio/slchost.rs

@@ -0,0 +1,35 @@
+use crate::pac::slchost;
+
+use super::PeripheralInstance;
+
+crate::any_peripheral! {
+    /// Any SDIO peripheral.
+    pub peripheral AnySlchost<'d> {
+        Slchost(crate::peripherals::SLCHOST<'d>)
+    }
+}
+
+/// Represents the SLCHOST registers for SDIO peripherals.
+pub struct SlchostInfo {
+    /// Represents the SLCHOST register block.
+    pub register_block: *const slchost::RegisterBlock,
+}
+
+unsafe impl Sync for SlchostInfo {}
+
+impl PeripheralInstance for AnySlchost<'_> {
+    type Info = SlchostInfo;
+
+    fn info(&self) -> &'static Self::Info {
+        static INFO: SlchostInfo = SlchostInfo {
+            register_block: crate::peripherals::SLCHOST::ptr(),
+        };
+
+        &INFO
+    }
+}
+
+/// A peripheral singleton compatible with the SDIO SLCHOST driver.
+pub trait SlchostInstance: PeripheralInstance + IntoAnySlchost {}
+
+impl<'d> SlchostInstance for AnySlchost<'d> {}

esp-hal/src/soc/esp32c6/peripherals.rs

@@ -79,6 +79,7 @@ crate::peripherals! {
         RNG <= RNG,
         RSA <= RSA,
         SHA <= SHA,
+        SLC <= SLC,
         SLCHOST <= SLCHOST,
         SOC_ETM <= SOC_ETM,
         SPI0 <= SPI0,