Add init function

Author: avsaase

src/sdcard/mod.rs

@@ -132,6 +132,18 @@ where
         inner.card_type
     }
 
+    /// Initialize the SD card.
+    ///
+    /// This must be called before performing any operations on the card, with
+    /// SPI frequency of 100 to 400 KHz. After this method returns
+    /// successfully, the SPI frequency can be increased to the maximum
+    /// supported by the card.
+    pub fn init_card(&self) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        inner.init()?;
+        Ok(())
+    }
+
     /// Tell the driver the card has been initialised.
     ///
     /// This is here in case you were previously using the SD Card, and then a
@@ -563,6 +575,13 @@ where
         }
         Ok(())
     }
+
+    fn init(&mut self) -> Result<(), Error> {
+        self.spi
+            .send_clock_pulses()
+            .map_err(|_e| Error::Transport)?;
+        Ok(())
+    }
 }
 
 /// Options for acquiring the card.

src/sdcard/sd_card_device.rs

@@ -19,6 +19,9 @@ pub trait SdCardDevice {
         operations: &mut [Operation<'_, u8>],
     ) -> Result<(), SdCardDeviceError>;
 
+    /// Send 80 clock pulses to the device with CS deasserted.
+    fn send_clock_pulses(&mut self) -> Result<(), SdCardDeviceError>;
+
     /// Do a read within a transaction.
     ///
     /// This is a convenience method equivalent to `device.transaction(&mut [Operation::Read(buf)])`.
@@ -84,6 +87,12 @@ where
         let mut bus = bus.borrow_mut();
         bus_transaction(&mut *bus, cs, operations)
     }
+
+    fn send_clock_pulses(&mut self) -> Result<(), SdCardDeviceError> {
+        let (bus, cs) = self;
+        let mut bus = bus.borrow_mut();
+        send_clock_pulses(&mut *bus, cs)
+    }
 }
 
 #[cfg(feature = "embassy-sync-06")]
@@ -103,6 +112,14 @@ where
             bus_transaction(&mut *bus, cs, operations)
         })
     }
+
+    fn send_clock_pulses(&mut self) -> Result<(), SdCardDeviceError> {
+        let (bus, cs) = self;
+        bus.lock(|bus| {
+            let mut bus = bus.borrow_mut();
+            send_clock_pulses(&mut *bus, cs)
+        })
+    }
 }
 
 // `ExclusiveDevice` represents exclusive access to the bus so there's no need to send the dummy
@@ -121,6 +138,21 @@ where
         <Self as embedded_hal::spi::SpiDevice>::transaction(self, operations)
             .map_err(|_| SdCardDeviceError::Spi)
     }
+
+    fn send_clock_pulses(&mut self) -> Result<(), SdCardDeviceError> {
+        let bus = self.bus_mut();
+
+        // There's no way to access the CS pin here so we can't set it high. Most like it already high so this is probbaly fine(?)
+
+        let send_res = bus.write(&[0xFF; 10]);
+
+        // On failure, it's important to still flush.
+        let flush_res = bus.flush().map_err(|_| SdCardDeviceError::Spi);
+
+        send_res.map_err(|_| SdCardDeviceError::Spi)?;
+        flush_res.map_err(|_| SdCardDeviceError::Spi)?;
+        Ok(())
+    }
 }
 
 fn bus_transaction<BUS, CS>(
@@ -162,3 +194,20 @@ where
 
     Ok(())
 }
+
+fn send_clock_pulses<BUS, CS>(bus: &mut BUS, cs: &mut CS) -> Result<(), SdCardDeviceError>
+where
+    BUS: SpiBus,
+    CS: OutputPin,
+{
+    cs.set_high().map_err(|_| SdCardDeviceError::Cs)?;
+    let send_res = bus.write(&[0xFF; 10]);
+
+    // On failure, it's important to still flush.
+    let flush_res = bus.flush().map_err(|_| SdCardDeviceError::Spi);
+
+    send_res.map_err(|_| SdCardDeviceError::Spi)?;
+    flush_res.map_err(|_| SdCardDeviceError::Spi)?;
+
+    Ok(())
+}