Adding support for the SPI stack chips

Cargo.toml

@@ -44,9 +44,9 @@ bitflags = "1.0.4"
 [dev-dependencies]
 cortex-m = "0.6.0"
 cortex-m-rt = "0.6.8"
-cortex-m-semihosting = "0.3.3"
 stm32f4xx-hal = { version = "0.5.0", features = ["stm32f401"] }
 panic-semihosting = "0.5.2"
+cortex-m-semihosting = "0.3.4"
 
 [profile.dev]
 opt-level = "z"

src/lib.rs

@@ -13,6 +13,8 @@
 mod log;
 pub mod prelude;
 pub mod series25;
+pub mod w25m;
+pub mod w25n;
 mod utils;
 
 use core::fmt::{self, Debug};
@@ -62,34 +64,36 @@ where
 }
 
 /// A trait for reading operations from a memory chip.
-pub trait Read<Addr, SPI: Transfer<u8>, CS: OutputPin> {
+pub trait Read<SPI: Transfer<u8>, CS: OutputPin> {
     /// Reads bytes from a memory chip.
     ///
     /// # Parameters
     /// * `addr`: The address to start reading at.
     /// * `buf`: The buffer to read `buf.len()` bytes into.
-    fn read(&mut self, addr: Addr, buf: &mut [u8]) -> Result<(), Error<SPI, CS>>;
+    fn read(&mut self, addr: u32, buf: &mut [u8]) -> Result<(), Error<SPI, CS>>;
 }
 
 /// A trait for writing and erasing operations on a memory chip.
-pub trait BlockDevice<Addr, SPI: Transfer<u8>, CS: OutputPin> {
-    /// Erases sectors from the memory chip.
+pub trait BlockDevice<SPI: Transfer<u8>, CS: OutputPin> {
+    /// Erases the smallest available unit from the memory chip. For Flash this should be
+    /// blocks or sectors, for EEPROM single bytes
     ///
     /// # Parameters
-    /// * `addr`: The address to start erasing at. If the address is not on a sector boundary,
-    ///   the lower bits can be ignored in order to make it fit.
-    fn erase_sectors(&mut self, addr: Addr, amount: usize) -> Result<(), Error<SPI, CS>>;
+    /// * `addr`: The address to start erasing at. If the address is not on a block boundary,
+    /// the lower bits can be ignored in order to make it fit
+    fn erase(&mut self, addr: u32, amount: usize) -> Result<(), Error<SPI, CS>>;
 
     /// Erases the memory chip fully.
     ///
     /// Warning: Full erase operations can take a significant amount of time.
     /// Check your device's datasheet for precise numbers.
     fn erase_all(&mut self) -> Result<(), Error<SPI, CS>>;
-    /// Writes bytes onto the memory chip. This method is supposed to assume that the sectors
-    /// it is writing to have already been erased and should not do any erasing themselves.
+    /// Writes bytes onto the smallest writable unit of the memory chip. This method is
+    /// supposed to assume that the sectors it is writing to have already been erased and
+    /// should not do any erasing themselves.
     ///
     /// # Parameters
     /// * `addr`: The address to write to.
     /// * `data`: The bytes to write to `addr`.
-    fn write_bytes(&mut self, addr: Addr, data: &mut [u8]) -> Result<(), Error<SPI, CS>>;
+    fn write_bytes(&mut self, addr: u32, data: &mut [u8]) -> Result<(), Error<SPI, CS>>;
 }

src/series25.rs

@@ -138,7 +138,7 @@ impl<SPI: Transfer<u8>, CS: OutputPin> Flash<SPI, CS> {
     }
 }
 
-impl<SPI: Transfer<u8>, CS: OutputPin> Read<u32, SPI, CS> for Flash<SPI, CS> {
+impl<SPI: Transfer<u8>, CS: OutputPin> Read<SPI, CS> for Flash<SPI, CS> {
     /// Reads flash contents into `buf`, starting at `addr`.
     ///
     /// Note that `addr` is not fully decoded: Flash chips will typically only
@@ -171,8 +171,8 @@ impl<SPI: Transfer<u8>, CS: OutputPin> Read<u32, SPI, CS> for Flash<SPI, CS> {
     }
 }
 
-impl<SPI: Transfer<u8>, CS: OutputPin> BlockDevice<u32, SPI, CS> for Flash<SPI, CS> {
-    fn erase_sectors(&mut self, addr: u32, amount: usize) -> Result<(), Error<SPI, CS>> {
+impl<SPI: Transfer<u8>, CS: OutputPin> BlockDevice<SPI, CS> for Flash<SPI, CS> {
+    fn erase(&mut self, addr: u32, amount: usize) -> Result<(), Error<SPI, CS>> {
         for c in 0..amount {
             self.write_enable()?;
 

src/w25m.rs

@@ -0,0 +1,154 @@
+//! Provides an implementation for switching between the two dies stacked upon each other inside the W25M series
+use crate::{BlockDevice, Error, Read};
+use embedded_hal::blocking::spi::Transfer;
+use embedded_hal::digital::v2::OutputPin;
+use core::marker::PhantomData;
+use core::mem;
+
+#[allow(missing_debug_implementations)]
+pub struct Die0;
+#[allow(missing_debug_implementations)]
+pub struct Die1;
+
+/// All dies which are supposed to be supported by the W25M struct have to implement this trait
+pub trait Stackable<SPI: Transfer<u8>, CS: OutputPin>: BlockDevice<SPI, CS> + Read<SPI, CS> + Sized {
+    fn new(spi: SPI, cs: CS) -> Result<Self, Error<SPI, CS>>;
+    /// Returns the SPI and chip select objects so they can be used elsewhere
+    fn free(self) -> (SPI, CS);
+}
+
+#[derive(Debug)]
+pub struct Flash<DIE0, DIE1, DIE> 
+{
+    inner: Inner<DIE0, DIE1>,
+    _die: PhantomData<DIE>,
+}
+
+#[derive(Debug)]
+enum Inner<DIE0, DIE1> {
+    Die0(DIE0),
+    Die1(DIE1),
+    Dummy,
+}
+
+impl<DIE0, DIE1> Flash<DIE0, DIE1, Die0> 
+{
+    /// Creates a new W25M device
+    /// 
+    /// At 
+    /// the moment the only way to call this function is sadly
+    /// ```
+    /// let mut flash: Flash<W25N<_, _>, W25N<_, _>, _> = Flash::init(spi, cs).unwrap();
+    /// ```
+    /// TODO: Improve this API, its not very convenient
+    pub fn init<SPI, CS>(spi: SPI, cs: CS) -> Result<Flash<DIE0, DIE1, Die0>, Error<SPI, CS>> 
+        where 
+        SPI: Transfer<u8>,
+        CS: OutputPin,
+        DIE0: Stackable<SPI, CS>,
+        DIE1: Stackable<SPI, CS>,
+    {
+        Ok(Flash{
+            inner: Inner::Die0(DIE0::new(spi, cs)?),
+            _die: PhantomData
+        })
+    }
+}
+
+impl<DIE0, DIE1> Flash<DIE0, DIE1, Die0> 
+
+{
+    pub fn switch_die<SPI, CS>(mut self) -> Result<Flash<DIE0, DIE1, Die1>, Error<SPI, CS>>
+    where DIE0: Stackable<SPI, CS>,
+    DIE1: Stackable<SPI, CS>,
+    SPI: Transfer<u8>,
+    CS: OutputPin {
+        let (mut spi, mut cs) = match mem::replace(&mut self.inner, Inner::Dummy) {
+            Inner::Die0(die) => die.free(),
+            _ => unreachable!()
+        };
+        let mut command = [0xC2, 0x01];
+        cs.set_low().map_err(Error::Gpio)?;
+        let spi_result = spi.transfer(&mut command).map_err(Error::Spi);
+        cs.set_high().map_err(Error::Gpio)?;
+        spi_result?;
+
+        Ok(Flash{
+            inner: Inner::Die1(DIE1::new(spi, cs)?),
+            _die: PhantomData
+        })
+    }
+}
+
+impl<DIE0, DIE1> Flash<DIE0, DIE1, Die1> 
+{
+    pub fn switch_die<SPI, CS>(mut self) -> Result<Flash<DIE0, DIE1, Die0>, Error<SPI, CS>> 
+        where DIE0: Stackable<SPI, CS>,
+    DIE1: Stackable<SPI, CS>,
+    SPI: Transfer<u8>,
+    CS: OutputPin 
+    {
+        let (mut spi, mut cs) = match mem::replace(&mut self.inner, Inner::Dummy) {
+            Inner::Die1(die) => die.free(),
+            _ => unreachable!()
+        };
+
+        let mut command = [0xC2, 0x00];
+        cs.set_low().map_err(Error::Gpio)?;
+        let spi_result = spi.transfer(&mut command).map_err(Error::Spi);
+        cs.set_high().map_err(Error::Gpio)?;
+        spi_result?;
+
+
+        Ok(Flash{
+            inner: Inner::Die0(DIE0::new(spi, cs)?),
+            _die: PhantomData
+        })
+    }
+}
+
+impl<DIE0, DIE1, SPI, CS, DIE> BlockDevice<SPI, CS> for Flash<DIE0, DIE1, DIE>  
+where DIE0: Stackable<SPI, CS>,
+DIE1: Stackable<SPI, CS>,
+SPI: Transfer<u8>,
+CS: OutputPin
+{
+    fn erase(&mut self, addr: u32, amount: usize) -> Result<(), Error<SPI, CS>> {
+        match &mut self.inner {
+            Inner::Die0(die) => die.erase(addr, amount),
+            Inner::Die1(die) => die.erase(addr, amount),
+            _ => unreachable!()
+        }
+    }
+
+    fn erase_all(&mut self) -> Result<(), Error<SPI, CS>> {
+        match &mut self.inner {
+            Inner::Die0(die) => die.erase_all(),
+            Inner::Die1(die) => die.erase_all(),
+            _ => unreachable!()
+        }
+    }
+
+    fn write_bytes(&mut self, addr: u32, data: &mut [u8]) -> Result<(), Error<SPI, CS>> {
+        match &mut self.inner {
+            Inner::Die0(die) => die.write_bytes(addr, data),
+            Inner::Die1(die) => die.write_bytes(addr, data),
+            _ => unreachable!()
+        }
+    }
+}
+
+impl<DIE0, DIE1, SPI, CS, DIE> Read<SPI, CS> for Flash<DIE0, DIE1, DIE>  
+where DIE0: Stackable<SPI, CS>,
+DIE1: Stackable<SPI, CS>,
+SPI: Transfer<u8>,
+CS: OutputPin
+{
+    fn read(&mut self, addr: u32, buf: &mut [u8]) -> Result<(), Error<SPI, CS>> {
+        match &mut self.inner { 
+            Inner::Die0(die) => die.read(addr, buf),
+            Inner::Die1(die) => die.read(addr, buf),
+            _ => unreachable!()
+        }
+    }
+}