embassy-boot: add nightly feature gates

4 files changed, 98 insertions, 83 deletions

diff --git a/embassy-boot/boot/Cargo.toml b/embassy-boot/boot/Cargo.toml
index 39f501570..7434dce85 100644
--- a/embassy-boot/boot/Cargo.toml
+++ b/embassy-boot/boot/Cargo.toml
@@ -45,7 +45,7 @@ default_features = false
 features = ["rand", "std", "u32_backend"]
 
 [features]
-default = ["nightly"]
+#default = ["nightly"]
 ed25519-dalek = ["dep:ed25519-dalek", "_verify"]
 ed25519-salty = ["dep:salty", "_verify"]
 
diff --git a/embassy-boot/boot/src/firmware_updater.rs b/embassy-boot/boot/src/firmware_updater.rs
index a2f822f4a..f3d76a56c 100644
--- a/embassy-boot/boot/src/firmware_updater.rs
+++ b/embassy-boot/boot/src/firmware_updater.rs
@@ -1,5 +1,6 @@
 use digest::Digest;
 use embedded_storage::nor_flash::{NorFlash, NorFlashError, NorFlashErrorKind};
+#[cfg(feature = "nightly")]
 use embedded_storage_async::nor_flash::NorFlash as AsyncNorFlash;
 
 use crate::{Partition, State, BOOT_MAGIC, SWAP_MAGIC};
@@ -73,17 +74,21 @@ impl FirmwareUpdater {
         Self { dfu, state }
     }
 
+    //
+    // Blocking API
+    //
+
     /// Obtain the current state.
     ///
     /// This is useful to check if the bootloader has just done a swap, in order
     /// to do verifications and self-tests of the new image before calling
     /// `mark_booted`.
-    pub async fn get_state<F: AsyncNorFlash>(
+    pub fn get_state_blocking<F: NorFlash>(
         &mut self,
         state_flash: &mut F,
         aligned: &mut [u8],
     ) -> Result<State, FirmwareUpdaterError> {
-        self.state.read(state_flash, 0, aligned).await?;
+        self.state.read_blocking(state_flash, 0, aligned)?;
 
         if !aligned.iter().any(|&b| b != SWAP_MAGIC) {
             Ok(State::Swap)
@@ -109,7 +114,7 @@ impl FirmwareUpdater {
     /// The `_aligned` buffer must have a size of F::WRITE_SIZE, and follow the alignment rules for the flash being read from
     /// and written to.
     #[cfg(feature = "_verify")]
-    pub async fn verify_and_mark_updated<F: AsyncNorFlash>(
+    pub fn verify_and_mark_updated_blocking<F: NorFlash>(
         &mut self,
         _state_and_dfu_flash: &mut F,
         _public_key: &[u8],
@@ -132,8 +137,7 @@ impl FirmwareUpdater {
             let signature = Signature::from_bytes(_signature).map_err(into_signature_error)?;
 
             let mut message = [0; 64];
-            self.hash::<_, Sha512>(_state_and_dfu_flash, _update_len, _aligned, &mut message)
-                .await?;
+            self.hash_blocking::<_, Sha512>(_state_and_dfu_flash, _update_len, _aligned, &mut message)?;
 
             public_key.verify(&message, &signature).map_err(into_signature_error)?
         }
@@ -154,8 +158,7 @@ impl FirmwareUpdater {
             let signature = Signature::try_from(&signature).map_err(into_signature_error)?;
 
             let mut message = [0; 64];
-            self.hash::<_, Sha512>(_state_and_dfu_flash, _update_len, _aligned, &mut message)
-                .await?;
+            self.hash_blocking::<_, Sha512>(_state_and_dfu_flash, _update_len, _aligned, &mut message)?;
 
             let r = public_key.verify(&message, &signature);
             trace!(
@@ -168,11 +171,11 @@ impl FirmwareUpdater {
             r.map_err(into_signature_error)?
         }
 
-        self.set_magic(_aligned, SWAP_MAGIC, _state_and_dfu_flash).await
+        self.set_magic_blocking(_aligned, SWAP_MAGIC, _state_and_dfu_flash)
     }
 
     /// Verify the update in DFU with any digest.
-    pub async fn hash<F: AsyncNorFlash, D: Digest>(
+    pub fn hash_blocking<F: NorFlash, D: Digest>(
         &mut self,
         dfu_flash: &mut F,
         update_len: u32,
@@ -181,7 +184,7 @@ impl FirmwareUpdater {
     ) -> Result<(), FirmwareUpdaterError> {
         let mut digest = D::new();
         for offset in (0..update_len).step_by(chunk_buf.len()) {
-            self.dfu.read(dfu_flash, offset, chunk_buf).await?;
+            self.dfu.read_blocking(dfu_flash, offset, chunk_buf)?;
             let len = core::cmp::min((update_len - offset) as usize, chunk_buf.len());
             digest.update(&chunk_buf[..len]);
         }
@@ -195,13 +198,13 @@ impl FirmwareUpdater {
     ///
     /// The `aligned` buffer must have a size of F::WRITE_SIZE, and follow the alignment rules for the flash being written to.
     #[cfg(not(feature = "_verify"))]
-    pub async fn mark_updated<F: AsyncNorFlash>(
+    pub fn mark_updated_blocking<F: NorFlash>(
         &mut self,
         state_flash: &mut F,
         aligned: &mut [u8],
     ) -> Result<(), FirmwareUpdaterError> {
         assert_eq!(aligned.len(), F::WRITE_SIZE);
-        self.set_magic(aligned, SWAP_MAGIC, state_flash).await
+        self.set_magic_blocking(aligned, SWAP_MAGIC, state_flash)
     }
 
     /// Mark firmware boot successful and stop rollback on reset.
@@ -209,26 +212,26 @@ impl FirmwareUpdater {
     /// # Safety
     ///
     /// The `aligned` buffer must have a size of F::WRITE_SIZE, and follow the alignment rules for the flash being written to.
-    pub async fn mark_booted<F: AsyncNorFlash>(
+    pub fn mark_booted_blocking<F: NorFlash>(
         &mut self,
         state_flash: &mut F,
         aligned: &mut [u8],
     ) -> Result<(), FirmwareUpdaterError> {
         assert_eq!(aligned.len(), F::WRITE_SIZE);
-        self.set_magic(aligned, BOOT_MAGIC, state_flash).await
+        self.set_magic_blocking(aligned, BOOT_MAGIC, state_flash)
     }
 
-    async fn set_magic<F: AsyncNorFlash>(
+    fn set_magic_blocking<F: NorFlash>(
         &mut self,
         aligned: &mut [u8],
         magic: u8,
         state_flash: &mut F,
     ) -> Result<(), FirmwareUpdaterError> {
-        self.state.read(state_flash, 0, aligned).await?;
+        self.state.read_blocking(state_flash, 0, aligned)?;
 
         if aligned.iter().any(|&b| b != magic) {
             // Read progress validity
-            self.state.read(state_flash, F::WRITE_SIZE as u32, aligned).await?;
+            self.state.read_blocking(state_flash, F::WRITE_SIZE as u32, aligned)?;
 
             // FIXME: Do not make this assumption.
             const STATE_ERASE_VALUE: u8 = 0xFF;
@@ -238,15 +241,15 @@ impl FirmwareUpdater {
             } else {
                 // Invalidate progress
                 aligned.fill(!STATE_ERASE_VALUE);
-                self.state.write(state_flash, F::WRITE_SIZE as u32, aligned).await?;
+                self.state.write_blocking(state_flash, F::WRITE_SIZE as u32, aligned)?;
             }
 
             // Clear magic and progress
-            self.state.wipe(state_flash).await?;
+            self.state.wipe_blocking(state_flash)?;
 
             // Set magic
             aligned.fill(magic);
-            self.state.write(state_flash, 0, aligned).await?;
+            self.state.write_blocking(state_flash, 0, aligned)?;
         }
         Ok(())
     }
@@ -258,7 +261,7 @@ impl FirmwareUpdater {
     /// # Safety
     ///
     /// Failing to meet alignment and size requirements may result in a panic.
-    pub async fn write_firmware<F: AsyncNorFlash>(
+    pub fn write_firmware_blocking<F: NorFlash>(
         &mut self,
         offset: usize,
         data: &[u8],
@@ -267,10 +270,9 @@ impl FirmwareUpdater {
         assert!(data.len() >= F::ERASE_SIZE);
 
         self.dfu
-            .erase(dfu_flash, offset as u32, (offset + data.len()) as u32)
-            .await?;
+            .erase_blocking(dfu_flash, offset as u32, (offset + data.len()) as u32)?;
 
-        self.dfu.write(dfu_flash, offset as u32, data).await?;
+        self.dfu.write_blocking(dfu_flash, offset as u32, data)?;
 
         Ok(())
     }
@@ -278,32 +280,29 @@ impl FirmwareUpdater {
     /// Prepare for an incoming DFU update by erasing the entire DFU area and
     /// returning its `Partition`.
     ///
-    /// Using this instead of `write_firmware` allows for an optimized API in
-    /// exchange for added complexity.
-    pub async fn prepare_update<F: AsyncNorFlash>(
-        &mut self,
-        dfu_flash: &mut F,
-    ) -> Result<Partition, FirmwareUpdaterError> {
-        self.dfu.wipe(dfu_flash).await?;
+    /// Using this instead of `write_firmware_blocking` allows for an optimized
+    /// API in exchange for added complexity.
+    pub fn prepare_update_blocking<F: NorFlash>(&mut self, flash: &mut F) -> Result<Partition, FirmwareUpdaterError> {
+        self.dfu.wipe_blocking(flash)?;
 
         Ok(self.dfu)
     }
+}
 
-    //
-    // Blocking API
-    //
-
+// Async API
+#[cfg(feature = "nightly")]
+impl FirmwareUpdater {
     /// Obtain the current state.
     ///
     /// This is useful to check if the bootloader has just done a swap, in order
     /// to do verifications and self-tests of the new image before calling
     /// `mark_booted`.
-    pub fn get_state_blocking<F: NorFlash>(
+    pub async fn get_state<F: AsyncNorFlash>(
         &mut self,
         state_flash: &mut F,
         aligned: &mut [u8],
     ) -> Result<State, FirmwareUpdaterError> {
-        self.state.read_blocking(state_flash, 0, aligned)?;
+        self.state.read(state_flash, 0, aligned).await?;
 
         if !aligned.iter().any(|&b| b != SWAP_MAGIC) {
             Ok(State::Swap)
@@ -329,7 +328,7 @@ impl FirmwareUpdater {
     /// The `_aligned` buffer must have a size of F::WRITE_SIZE, and follow the alignment rules for the flash being read from
     /// and written to.
     #[cfg(feature = "_verify")]
-    pub fn verify_and_mark_updated_blocking<F: NorFlash>(
+    pub async fn verify_and_mark_updated<F: AsyncNorFlash>(
         &mut self,
         _state_and_dfu_flash: &mut F,
         _public_key: &[u8],
@@ -352,7 +351,8 @@ impl FirmwareUpdater {
             let signature = Signature::from_bytes(_signature).map_err(into_signature_error)?;
 
             let mut message = [0; 64];
-            self.hash_blocking::<_, Sha512>(_state_and_dfu_flash, _update_len, _aligned, &mut message)?;
+            self.hash::<_, Sha512>(_state_and_dfu_flash, _update_len, _aligned, &mut message)
+                .await?;
 
             public_key.verify(&message, &signature).map_err(into_signature_error)?
         }
@@ -373,7 +373,8 @@ impl FirmwareUpdater {
             let signature = Signature::try_from(&signature).map_err(into_signature_error)?;
 
             let mut message = [0; 64];
-            self.hash_blocking::<_, Sha512>(_state_and_dfu_flash, _update_len, _aligned, &mut message)?;
+            self.hash::<_, Sha512>(_state_and_dfu_flash, _update_len, _aligned, &mut message)
+                .await?;
 
             let r = public_key.verify(&message, &signature);
             trace!(
@@ -386,11 +387,11 @@ impl FirmwareUpdater {
             r.map_err(into_signature_error)?
         }
 
-        self.set_magic_blocking(_aligned, SWAP_MAGIC, _state_and_dfu_flash)
+        self.set_magic(_aligned, SWAP_MAGIC, _state_and_dfu_flash).await
     }
 
     /// Verify the update in DFU with any digest.
-    pub fn hash_blocking<F: NorFlash, D: Digest>(
+    pub async fn hash<F: AsyncNorFlash, D: Digest>(
         &mut self,
         dfu_flash: &mut F,
         update_len: u32,
@@ -399,7 +400,7 @@ impl FirmwareUpdater {
     ) -> Result<(), FirmwareUpdaterError> {
         let mut digest = D::new();
         for offset in (0..update_len).step_by(chunk_buf.len()) {
-            self.dfu.read_blocking(dfu_flash, offset, chunk_buf)?;
+            self.dfu.read(dfu_flash, offset, chunk_buf).await?;
             let len = core::cmp::min((update_len - offset) as usize, chunk_buf.len());
             digest.update(&chunk_buf[..len]);
         }
@@ -413,13 +414,13 @@ impl FirmwareUpdater {
     ///
     /// The `aligned` buffer must have a size of F::WRITE_SIZE, and follow the alignment rules for the flash being written to.
     #[cfg(not(feature = "_verify"))]
-    pub fn mark_updated_blocking<F: NorFlash>(
+    pub async fn mark_updated<F: AsyncNorFlash>(
         &mut self,
         state_flash: &mut F,
         aligned: &mut [u8],
     ) -> Result<(), FirmwareUpdaterError> {
         assert_eq!(aligned.len(), F::WRITE_SIZE);
-        self.set_magic_blocking(aligned, SWAP_MAGIC, state_flash)
+        self.set_magic(aligned, SWAP_MAGIC, state_flash).await
     }
 
     /// Mark firmware boot successful and stop rollback on reset.
@@ -427,26 +428,26 @@ impl FirmwareUpdater {
     /// # Safety
     ///
     /// The `aligned` buffer must have a size of F::WRITE_SIZE, and follow the alignment rules for the flash being written to.
-    pub fn mark_booted_blocking<F: NorFlash>(
+    pub async fn mark_booted<F: AsyncNorFlash>(
         &mut self,
         state_flash: &mut F,
         aligned: &mut [u8],
     ) -> Result<(), FirmwareUpdaterError> {
         assert_eq!(aligned.len(), F::WRITE_SIZE);
-        self.set_magic_blocking(aligned, BOOT_MAGIC, state_flash)
+        self.set_magic(aligned, BOOT_MAGIC, state_flash).await
     }
 
-    fn set_magic_blocking<F: NorFlash>(
+    async fn set_magic<F: AsyncNorFlash>(
         &mut self,
         aligned: &mut [u8],
         magic: u8,
         state_flash: &mut F,
     ) -> Result<(), FirmwareUpdaterError> {
-        self.state.read_blocking(state_flash, 0, aligned)?;
+        self.state.read(state_flash, 0, aligned).await?;
 
         if aligned.iter().any(|&b| b != magic) {
             // Read progress validity
-            self.state.read_blocking(state_flash, F::WRITE_SIZE as u32, aligned)?;
+            self.state.read(state_flash, F::WRITE_SIZE as u32, aligned).await?;
 
             // FIXME: Do not make this assumption.
             const STATE_ERASE_VALUE: u8 = 0xFF;
@@ -456,15 +457,15 @@ impl FirmwareUpdater {
             } else {
                 // Invalidate progress
                 aligned.fill(!STATE_ERASE_VALUE);
-                self.state.write_blocking(state_flash, F::WRITE_SIZE as u32, aligned)?;
+                self.state.write(state_flash, F::WRITE_SIZE as u32, aligned).await?;
             }
 
             // Clear magic and progress
-            self.state.wipe_blocking(state_flash)?;
+            self.state.wipe(state_flash).await?;
 
             // Set magic
             aligned.fill(magic);
-            self.state.write_blocking(state_flash, 0, aligned)?;
+            self.state.write(state_flash, 0, aligned).await?;
         }
         Ok(())
     }
@@ -476,7 +477,7 @@ impl FirmwareUpdater {
     /// # Safety
     ///
     /// Failing to meet alignment and size requirements may result in a panic.
-    pub fn write_firmware_blocking<F: NorFlash>(
+    pub async fn write_firmware<F: AsyncNorFlash>(
         &mut self,
         offset: usize,
         data: &[u8],
@@ -485,9 +486,10 @@ impl FirmwareUpdater {
         assert!(data.len() >= F::ERASE_SIZE);
 
         self.dfu
-            .erase_blocking(dfu_flash, offset as u32, (offset + data.len()) as u32)?;
+            .erase(dfu_flash, offset as u32, (offset + data.len()) as u32)
+            .await?;
 
-        self.dfu.write_blocking(dfu_flash, offset as u32, data)?;
+        self.dfu.write(dfu_flash, offset as u32, data).await?;
 
         Ok(())
     }
@@ -495,16 +497,20 @@ impl FirmwareUpdater {
     /// Prepare for an incoming DFU update by erasing the entire DFU area and
     /// returning its `Partition`.
     ///
-    /// Using this instead of `write_firmware_blocking` allows for an optimized
-    /// API in exchange for added complexity.
-    pub fn prepare_update_blocking<F: NorFlash>(&mut self, flash: &mut F) -> Result<Partition, FirmwareUpdaterError> {
-        self.dfu.wipe_blocking(flash)?;
+    /// Using this instead of `write_firmware` allows for an optimized API in
+    /// exchange for added complexity.
+    pub async fn prepare_update<F: AsyncNorFlash>(
+        &mut self,
+        dfu_flash: &mut F,
+    ) -> Result<Partition, FirmwareUpdaterError> {
+        self.dfu.wipe(dfu_flash).await?;
 
         Ok(self.dfu)
     }
 }
 
-#[cfg(test)]
+
+    #[cfg(test)]
 mod tests {
     use futures::executor::block_on;
     use sha1::{Digest, Sha1};
diff --git a/embassy-boot/boot/src/mem_flash.rs b/embassy-boot/boot/src/mem_flash.rs
index c62379b24..3ba84a92c 100644
--- a/embassy-boot/boot/src/mem_flash.rs
+++ b/embassy-boot/boot/src/mem_flash.rs
@@ -3,6 +3,7 @@
 use core::ops::{Bound, Range, RangeBounds};
 
 use embedded_storage::nor_flash::{ErrorType, NorFlash, NorFlashError, NorFlashErrorKind, ReadNorFlash};
+#[cfg(feature = "nightly")]
 use embedded_storage_async::nor_flash::{NorFlash as AsyncNorFlash, ReadNorFlash as AsyncReadNorFlash};
 
 pub struct MemFlash<const SIZE: usize, const ERASE_SIZE: usize, const WRITE_SIZE: usize> {
@@ -134,6 +135,7 @@ impl<const SIZE: usize, const ERASE_SIZE: usize, const WRITE_SIZE: usize> NorFla
     }
 }
 
+#[cfg(feature = "nightly")]
 impl<const SIZE: usize, const ERASE_SIZE: usize, const WRITE_SIZE: usize> AsyncReadNorFlash
     for MemFlash<SIZE, ERASE_SIZE, WRITE_SIZE>
 {
@@ -148,6 +150,7 @@ impl<const SIZE: usize, const ERASE_SIZE: usize, const WRITE_SIZE: usize> AsyncR
     }
 }
 
+#[cfg(feature = "nightly")]
 impl<const SIZE: usize, const ERASE_SIZE: usize, const WRITE_SIZE: usize> AsyncNorFlash
     for MemFlash<SIZE, ERASE_SIZE, WRITE_SIZE>
 {
diff --git a/embassy-boot/boot/src/partition.rs b/embassy-boot/boot/src/partition.rs
index 7529059b6..67bd7abba 100644
--- a/embassy-boot/boot/src/partition.rs
+++ b/embassy-boot/boot/src/partition.rs
@@ -1,4 +1,5 @@
 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.
@@ -23,70 +24,75 @@ impl Partition {
     }
 
     /// Read from the partition on the provided flash
-    pub async fn read<F: AsyncReadNorFlash>(
-        &self,
-        flash: &mut F,
-        offset: u32,
-        bytes: &mut [u8],
-    ) -> Result<(), F::Error> {
+    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).await
+        flash.read(offset, bytes)
     }
 
     /// Write to the partition on the provided flash
-    pub async fn write<F: AsyncNorFlash>(&self, flash: &mut F, offset: u32, bytes: &[u8]) -> Result<(), F::Error> {
+    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).await?;
+        flash.write(offset, bytes)?;
         trace!("Wrote from 0x{:x} len {}", offset, bytes.len());
         Ok(())
     }
 
     /// Erase part of the partition on the provided flash
-    pub async fn erase<F: AsyncNorFlash>(&self, flash: &mut F, from: u32, to: u32) -> Result<(), F::Error> {
+    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).await?;
+        flash.erase(from, to)?;
         trace!("Erased from 0x{:x} to 0x{:x}", from, to);
         Ok(())
     }
 
     /// Erase the entire partition
-    pub(crate) async fn wipe<F: AsyncNorFlash>(&self, flash: &mut F) -> Result<(), F::Error> {
+    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).await?;
+        flash.erase(from, to)?;
         trace!("Wiped from 0x{:x} to 0x{:x}", from, to);
         Ok(())
     }
+}
+
+// Async API
+#[cfg(feature = "nightly")]
+impl Partition {
 
     /// 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> {
+    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)
+        flash.read(offset, bytes).await
     }
 
     /// 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> {
+    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)?;
+        flash.write(offset, bytes).await?;
         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> {
+    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)?;
+        flash.erase(from, to).await?;
         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> {
+    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)?;
+        flash.erase(from, to).await?;
         trace!("Wiped from 0x{:x} to 0x{:x}", from, to);
         Ok(())
     }