Remove legacy Partition type and use the one from embedded-hal

embassy-boot/boot/Cargo.toml

@@ -27,9 +27,10 @@ defmt = { version = "0.3", optional = true }
 digest = "0.10"
 log = { version = "0.4", optional = true  }
 ed25519-dalek = { version = "1.0.1", default_features = false, features = ["u32_backend"], optional = true }
+embassy-embedded-hal = { version = "0.1.0", path = "../../embassy-embedded-hal" }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync" }
 embedded-storage = "0.3.0"
-embedded-storage-async = { version = "0.4.0", optional = true}
+embedded-storage-async = { version = "0.4.0", optional = true }
 salty = { git = "https://github.com/ycrypto/salty.git", rev = "a9f17911a5024698406b75c0fac56ab5ccf6a8c7", optional = true }
 signature = { version = "1.6.4", default-features = false }
 
@@ -39,7 +40,7 @@ env_logger = "0.9"
 rand = "0.7" # ed25519-dalek v1.0.1 depends on this exact version
 futures = { version = "0.3", features = ["executor"] }
 sha1 = "0.10.5"
-embassy-embedded-hal = { version = "0.1.0", path = "../../embassy-embedded-hal" }
+critical-section = { version = "1.1.1", features = ["std"] }
 
 [dev-dependencies.ed25519-dalek]
 default_features = false
@@ -49,7 +50,7 @@ features = ["rand", "std", "u32_backend"]
 ed25519-dalek = ["dep:ed25519-dalek", "_verify"]
 ed25519-salty = ["dep:salty", "_verify"]
 
-nightly = ["dep:embedded-storage-async"]
+nightly = ["dep:embedded-storage-async", "embassy-embedded-hal/nightly"]
 
 #Internal features
 _verify = []

embassy-boot/boot/src/lib.rs

@@ -9,11 +9,9 @@ mod digest_adapters;
 mod firmware_updater;
 #[cfg(test)]
 mod mem_flash;
-mod partition;
 #[cfg(test)]
 mod test_flash;
 
-pub use partition::Partition;
 // The expected value of the flash after an erase
 // TODO: Use the value provided by NorFlash when available
 pub(crate) const STATE_ERASE_VALUE: u8 = 0xFF;

embassy-boot/boot/src/partition.rs

@@ -1,144 +0,0 @@
-use embedded_storage::nor_flash::{NorFlash, ReadNorFlash};
-#[cfg(feature = "nightly")]
-use embedded_storage_async::nor_flash::{NorFlash as AsyncNorFlash, ReadNorFlash as AsyncReadNorFlash};
-
-/// A region in flash used by the bootloader.
-#[derive(Copy, Clone, Debug)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub struct Partition {
-    /// The offset into the flash where the partition starts.
-    pub from: u32,
-    /// The offset into the flash where the partition ends.
-    pub to: u32,
-}
-
-impl Partition {
-    /// Create a new partition with the provided range
-    pub const fn new(from: u32, to: u32) -> Self {
-        Self { from, to }
-    }
-
-    /// Return the size of the partition
-    pub const fn size(&self) -> u32 {
-        self.to - self.from
-    }
-
-    /// Read from the partition on the provided flash
-    #[cfg(feature = "nightly")]
-    pub async fn read<F: AsyncReadNorFlash>(
-        &self,
-        flash: &mut F,
-        offset: u32,
-        bytes: &mut [u8],
-    ) -> Result<(), F::Error> {
-        let offset = self.from as u32 + offset;
-        flash.read(offset, bytes).await
-    }
-
-    /// Write to the partition on the provided flash
-    #[cfg(feature = "nightly")]
-    pub async fn write<F: AsyncNorFlash>(&self, flash: &mut F, offset: u32, bytes: &[u8]) -> Result<(), F::Error> {
-        let offset = self.from as u32 + offset;
-        flash.write(offset, bytes).await?;
-        trace!("Wrote from 0x{:x} len {}", offset, bytes.len());
-        Ok(())
-    }
-
-    /// Erase part of the partition on the provided flash
-    #[cfg(feature = "nightly")]
-    pub async fn erase<F: AsyncNorFlash>(&self, flash: &mut F, from: u32, to: u32) -> Result<(), F::Error> {
-        let from = self.from as u32 + from;
-        let to = self.from as u32 + to;
-        flash.erase(from, to).await?;
-        trace!("Erased from 0x{:x} to 0x{:x}", from, to);
-        Ok(())
-    }
-
-    /// Erase the entire partition
-    #[cfg(feature = "nightly")]
-    pub(crate) async fn wipe<F: AsyncNorFlash>(&self, flash: &mut F) -> Result<(), F::Error> {
-        let from = self.from as u32;
-        let to = self.to as u32;
-        flash.erase(from, to).await?;
-        trace!("Wiped from 0x{:x} to 0x{:x}", from, to);
-        Ok(())
-    }
-
-    /// Read from the partition on the provided flash
-    pub fn read_blocking<F: ReadNorFlash>(&self, flash: &mut F, offset: u32, bytes: &mut [u8]) -> Result<(), F::Error> {
-        let offset = self.from as u32 + offset;
-        flash.read(offset, bytes)
-    }
-
-    /// Write to the partition on the provided flash
-    pub fn write_blocking<F: NorFlash>(&self, flash: &mut F, offset: u32, bytes: &[u8]) -> Result<(), F::Error> {
-        let offset = self.from as u32 + offset;
-        flash.write(offset, bytes)?;
-        trace!("Wrote from 0x{:x} len {}", offset, bytes.len());
-        Ok(())
-    }
-
-    /// Erase part of the partition on the provided flash
-    pub fn erase_blocking<F: NorFlash>(&self, flash: &mut F, from: u32, to: u32) -> Result<(), F::Error> {
-        let from = self.from as u32 + from;
-        let to = self.from as u32 + to;
-        flash.erase(from, to)?;
-        trace!("Erased from 0x{:x} to 0x{:x}", from, to);
-        Ok(())
-    }
-
-    /// Erase the entire partition
-    pub(crate) fn wipe_blocking<F: NorFlash>(&self, flash: &mut F) -> Result<(), F::Error> {
-        let from = self.from as u32;
-        let to = self.to as u32;
-        flash.erase(from, to)?;
-        trace!("Wiped from 0x{:x} to 0x{:x}", from, to);
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::mem_flash::MemFlash;
-    use crate::Partition;
-
-    #[test]
-    fn can_erase() {
-        let mut flash = MemFlash::<1024, 64, 4>::new(0x00);
-        let partition = Partition::new(256, 512);
-
-        partition.erase_blocking(&mut flash, 64, 192).unwrap();
-
-        for (index, byte) in flash.mem.iter().copied().enumerate().take(256 + 64) {
-            assert_eq!(0x00, byte, "Index {}", index);
-        }
-
-        for (index, byte) in flash.mem.iter().copied().enumerate().skip(256 + 64).take(128) {
-            assert_eq!(0xFF, byte, "Index {}", index);
-        }
-
-        for (index, byte) in flash.mem.iter().copied().enumerate().skip(256 + 64 + 128) {
-            assert_eq!(0x00, byte, "Index {}", index);
-        }
-    }
-
-    #[test]
-    fn can_wipe() {
-        let mut flash = MemFlash::<1024, 64, 4>::new(0x00);
-        let partition = Partition::new(256, 512);
-
-        partition.wipe_blocking(&mut flash).unwrap();
-
-        for (index, byte) in flash.mem.iter().copied().enumerate().take(256) {
-            assert_eq!(0x00, byte, "Index {}", index);
-        }
-
-        for (index, byte) in flash.mem.iter().copied().enumerate().skip(256).take(256) {
-            assert_eq!(0xFF, byte, "Index {}", index);
-        }
-
-        for (index, byte) in flash.mem.iter().copied().enumerate().skip(512) {
-            assert_eq!(0x00, byte, "Index {}", index);
-        }
-    }
-}