start adding argument and response module

Author: robamu

Cargo.toml

@@ -32,6 +32,7 @@ env_logger = "0.11.8"
 flate2 = "1.0"
 hex-literal = "1.0.0"
 sha2 = "0.10"
+anyhow = "1"
 
 [features]
 default = ["log"]

examples/sd_card_init.rs

@@ -0,0 +1,159 @@
+use anyhow::{Context as _, bail};
+use embedded_sdmmc::sdcard::argument::{Acmd6, Cmd7, Cmd9, Cmd13, OcrLower, VoltageSuppliedSelect};
+use embedded_sdmmc::sdcard::mock::SdCardMock;
+use embedded_sdmmc::sdcard::response::{self, R1, R3, R6, R7};
+use embedded_sdmmc::sdcard::{AcmdId, CmdId, argument};
+use embedded_sdmmc::sdcard::{cid::Cid, csd::Csd};
+
+/// Negotiated as part of ACMD41 during SD card initialization.
+pub const VOLTAGE_LEVEL_CAPABILITIES: OcrLower = OcrLower::builder()
+    .with__3_5_to_3_6v(false)
+    .with__3_4_to_3_5v(false)
+    .with__3_3_to_3_4v(false)
+    .with__3_2_to_3_3v(true)
+    .with__3_1_to_3_2v(false)
+    .with__3_0_to_3_1v(false)
+    .with__2_9_to_3_0v(false)
+    .with__2_8_to_2_9v(false)
+    .with__2_7_to_2_8v(false)
+    .with_reserved_low_voltage(false)
+    .build();
+
+pub struct SdCardUninitialized(SdCardMock);
+
+impl SdCardUninitialized {
+    pub fn new(sd_mock: SdCardMock) -> Self {
+        Self(sd_mock)
+    }
+
+    /// Example initialization sequence for a SD card which can provide
+    /// a reference example for a real driver.
+    ///
+    /// It performs the initialization sequence specified in the SD card
+    /// physical layer specification Ver9.10, p.68 and p.70.
+    pub fn initialize(mut self) -> Result<SdCard, anyhow::Error> {
+        self.0.insert_command(CmdId::CMD0_GoIdleState, 0);
+
+        // Voltage level negotiation. Send CMD8 first.
+        self.0.insert_command(
+            CmdId::CMD8_SendIfCond,
+            argument::Cmd8::ZERO
+                .with_voltage_supplied(
+                    embedded_sdmmc::sdcard::argument::VoltageSuppliedSelect::_2_7To3_6V,
+                )
+                .with_check_pattern(0xAA)
+                .raw_value(),
+        );
+
+        let r7 = R7::new_with_raw_value(self.0.read_reply_u32());
+        if r7
+            .voltage_accepted()
+            .is_ok_and(|val| val != VoltageSuppliedSelect::_2_7To3_6V)
+        {
+            bail!("CMD8 reply R7: Voltage not accepted");
+        }
+        if r7.echo_check_pattern() != 0xAA {
+            bail!("CMD8 reply R7: Check pattern missmatch");
+        }
+
+        // Now send ACMD41.
+        self.0.insert_acmd(
+            AcmdId::ACMD41_SdSendOpCond,
+            argument::Acmd41::builder()
+                .with_host_capacity_support(
+                    embedded_sdmmc::sdcard::argument::HostCapacitySupport::SdhcOrSdxc,
+                )
+                .with_fast_boot(false)
+                .with_xpc(embedded_sdmmc::sdcard::argument::PowerControl::MaximumPerformance)
+                .with_s18r(false)
+                .with_ocr(VOLTAGE_LEVEL_CAPABILITIES)
+                .build()
+                .raw_value(),
+        );
+        loop {
+            // Now poll until the card initialization is complete. In real driver code, timeout
+            // handling or an upper polling limit might be a good idea.
+            self.0.insert_acmd(AcmdId::ACMD41_SdSendOpCond, 0);
+            let r3 = R3::new_with_raw_value(self.0.read_reply_u32());
+            if r3.initialization_complete() {
+                break;
+            }
+        }
+
+        // Retrieve and cache the CID. This puts it into identification mode.
+        self.0.insert_command(CmdId::CMD2_AllSendCid, 0);
+        let cid_raw = self.0.read_reply_u128();
+        let cid = embedded_sdmmc::sdcard::cid::Cid::new_with_raw_value(cid_raw);
+
+        // Send CMD3 to retrieve RCA required for card addressing, as well as put the card
+        // into standby mode.
+        self.0.insert_command(CmdId::CMD3_SendRelativeAddr, 0);
+        let r6 = R6::new_with_raw_value(self.0.read_reply_u32());
+        let rca = r6.rca();
+
+        // Retrieve and cache CSD, which also contains card specific data.
+        self.0
+            .insert_command(CmdId::CMD9_SendCsd, Cmd9::ZERO.with_rca(rca).raw_value());
+        let cid_raw = self.0.read_reply_u128();
+        let csd = Csd::new(&cid_raw.to_be_bytes()).with_context(|| "failed to parse CSD")?;
+
+        // CMD7 to put the SD card into transfer state.
+        self.0
+            .insert_command(CmdId::CMD7_SelectCard, Cmd7::ZERO.with_rca(rca).raw_value());
+
+        // Check that the card is in transfer mode.
+        self.0.insert_command(
+            CmdId::CMD13_SendStatus,
+            Cmd13::ZERO.with_rca(rca).raw_value(),
+        );
+        let r1 = R1::new_with_raw_value(self.0.read_reply_u32());
+
+        if r1.state().is_ok_and(|state| state != response::State::Tran) {
+            bail!("CMD8 reply R1: Not in transfer state");
+        }
+
+        // In this example, we put the SD card into 4-bit mode. On real hardware, you usually
+        // have to configure register bits on the controller side as well.
+        self.0.insert_acmd(
+            AcmdId::ACMD6_SetBusWidth,
+            Acmd6::builder()
+                .with_bus_width(argument::BusWidth::_4bits)
+                .build()
+                .raw_value(),
+        );
+
+        Ok(SdCard {
+            cid,
+            csd,
+            rca,
+            sd_mock: self.0,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct SdCard {
+    cid: Cid,
+    csd: Csd,
+    rca: u16,
+    #[allow(unused)]
+    sd_mock: SdCardMock,
+}
+
+const MOCK_SD_RCA: u16 = 1;
+
+fn main() -> Result<(), anyhow::Error> {
+    let sd_mock = SdCardMock::new(MOCK_SD_RCA);
+    let sd_card_uninit = SdCardUninitialized::new(sd_mock);
+    let sd_card = sd_card_uninit
+        .initialize()
+        .context("failed to initialize SD card")?;
+    println!("SD card initialized successfully",);
+    println!("--------");
+    println!("Relative Card Address: {}", sd_card.rca);
+    println!("--------");
+    println!("CSD: {:?}", sd_card.csd);
+    println!("--------");
+    println!("CID: {:?}", sd_card.cid);
+    Ok(())
+}

src/sdcard/argument.rs

@@ -0,0 +1,179 @@
+//! # Argument module
+//!
+//! Arguments are additional command parameters.
+
+use arbitrary_int::u24;
+
+/// Voltage settings supplied in CMD8.
+#[bitbybit::bitenum(u4, exhaustive = false)]
+#[derive(Debug, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt-log", derive(defmt::Format))]
+pub enum VoltageSuppliedSelect {
+    /// Regular voltage range.
+    #[default]
+    _2_7To3_6V = 0b0001,
+    /// Reserved for low voltage.
+    LowVoltageRange = 0b0010,
+}
+
+/// CMD8 argument.
+#[bitbybit::bitfield(u32, default = 0x0, debug, defmt_fields(feature = "defmt-log"))]
+pub struct Cmd8 {
+    /// PCIe v1.2 support.
+    #[bit(13, rw)]
+    pcie_1_2v_support: bool,
+    /// PCIe available.
+    #[bit(12, rw)]
+    pcie_availability: bool,
+    /// Voltage settings.
+    #[bits(8..=11, rw)]
+    voltage_supplied: Option<VoltageSuppliedSelect>,
+    /// Check pattern which is echoed.
+    #[bits(0..=7, rw)]
+    check_pattern: u8,
+}
+
+/// Power control (XPC) settings.
+#[bitbybit::bitenum(u1, exhaustive = true)]
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt-log", derive(defmt::Format))]
+pub enum PowerControl {
+    /// Power saving.
+    PowerSaving = 0,
+    /// Maximum performance.
+    MaximumPerformance = 1,
+}
+
+/// HPC.
+#[bitbybit::bitenum(u1, exhaustive = true)]
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt-log", derive(defmt::Format))]
+pub enum HostCapacitySupport {
+    /// SDSC only.
+    SdscOnly = 0,
+    /// Extended capacity - SDHC or SDXC.
+    SdhcOrSdxc = 1,
+}
+
+/// Lower OCR bits used to negotiate voltage capabilities.
+#[bitbybit::bitfield(u24, default = 0x0, debug, defmt_fields(feature = "defmt-log"))]
+pub struct OcrLower {
+    /// 3.5 to 3.6V
+    #[bit(23, rw)]
+    _3_5_to_3_6v: bool,
+    /// 3.4 to 3.5V
+    #[bit(22, rw)]
+    _3_4_to_3_5v: bool,
+    /// 3.3 to 3.4V
+    #[bit(21, rw)]
+    _3_3_to_3_4v: bool,
+    /// 3.2 to 3.3V
+    #[bit(20, rw)]
+    _3_2_to_3_3v: bool,
+    /// 3.1 to 3.2V
+    #[bit(19, rw)]
+    _3_1_to_3_2v: bool,
+    /// 3.0 to 3.1V
+    #[bit(18, rw)]
+    _3_0_to_3_1v: bool,
+    /// 2.9 to 3.0V
+    #[bit(17, rw)]
+    _2_9_to_3_0v: bool,
+    /// 2.8 to 2.9V
+    #[bit(16, rw)]
+    _2_8_to_2_9v: bool,
+    /// 2.7 to 2.8V
+    #[bit(15, rw)]
+    _2_7_to_2_8v: bool,
+    /// Reserved for low voltage
+    #[bit(7, rw)]
+    reserved_low_voltage: bool,
+}
+
+/// Bus width setting.
+#[bitbybit::bitenum(u2, exhaustive = false)]
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt-log", derive(defmt::Format))]
+pub enum BusWidth {
+    /// 1 bit bus.
+    _1bit = 0b00,
+    /// 4 bit bus.
+    _4bits = 0b10,
+}
+
+/// ACMD6 - Set bus width.
+#[bitbybit::bitfield(
+    u32,
+    default = 0x0,
+    debug,
+    defmt_fields(feature = "defmt-log"),
+    forbid_overlaps
+)]
+pub struct Acmd6 {
+    /// Bus width.
+    #[bits(0..=1, rw)]
+    bus_width: Option<BusWidth>,
+}
+
+/// ACMD41 argument - Capability negotiation.
+#[bitbybit::bitfield(
+    u32,
+    default = 0x0,
+    debug,
+    defmt_fields(feature = "defmt-log"),
+    forbid_overlaps
+)]
+pub struct Acmd41 {
+    /// HPC.
+    #[bit(30, rw)]
+    host_capacity_support: HostCapacitySupport,
+    /// FB.
+    #[bit(29, rw)]
+    fast_boot: bool,
+    /// XPC.
+    #[bit(28, rw)]
+    xpc: PowerControl,
+    /// Switch to 1.8V signal voltage request.
+    #[bit(24, rw)]
+    s18r: bool,
+    /// If this is set to 0. ACMD41 is called "inquire CMD41" that does not start
+    /// initialization and is used for getting OCR. Bits 24 to 31 are ignored.
+    #[bits(0..=23, rw)]
+    ocr: OcrLower,
+}
+
+/// Relative Card Address (RCA) select.
+#[bitbybit::bitfield(
+    u32,
+    default = 0x0,
+    debug,
+    defmt_bitfields(feature = "defmt-log"),
+    forbid_overlaps
+)]
+pub struct RcaSelect {
+    /// RCA.
+    #[bits(16..=31, rw)]
+    rca: u16,
+}
+
+/// CMD9 argument.
+pub type Cmd9 = RcaSelect;
+/// CMD7 argument.
+pub type Cmd7 = RcaSelect;
+
+/// CMD13 argument.
+#[bitbybit::bitfield(
+    u32,
+    default = 0x0,
+    debug,
+    defmt_bitfields(feature = "defmt-log"),
+    forbid_overlaps
+)]
+pub struct Cmd13 {
+    /// RCA.
+    #[bits(16..=31, rw)]
+    rca: u16,
+    /// Send task status instead of regular card status.
+    #[bit(15, rw)]
+    send_task_status: bool,
+}