stm32: Add async flash write/erase to f4

1 files changed, 141 insertions, 114 deletions

diff --git a/embassy-stm32/src/flash/common.rs b/embassy-stm32/src/flash/common.rs
index 432c8a43b..990104a38 100644
--- a/embassy-stm32/src/flash/common.rs
+++ b/embassy-stm32/src/flash/common.rs
@@ -1,44 +1,55 @@
 use atomic_polyfill::{fence, Ordering};
+use embassy_cortex_m::interrupt::InterruptExt;
+use embassy_futures::block_on;
 use embassy_hal_common::drop::OnDrop;
 use embassy_hal_common::{into_ref, PeripheralRef};
-
-use super::{family, Error, FlashLayout, FlashRegion, FlashSector, FLASH_BASE, FLASH_SIZE, MAX_ERASE_SIZE, WRITE_SIZE};
-use crate::flash::FlashBank;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::mutex::Mutex;
+use stm32_metapac::FLASH_BASE;
+
+use super::{
+    ensure_sector_aligned, family, get_sector, Error, FlashLayout, FlashRegion, FLASH_SIZE, MAX_ERASE_SIZE, READ_SIZE,
+    WRITE_SIZE,
+};
+use crate::peripherals::FLASH;
 use crate::Peripheral;
 
 pub struct Flash<'d> {
-    inner: PeripheralRef<'d, crate::peripherals::FLASH>,
+    pub(crate) inner: PeripheralRef<'d, FLASH>,
 }
 
+pub(crate) static REGION_ACCESS: Mutex<CriticalSectionRawMutex, ()> = Mutex::new(());
+
 impl<'d> Flash<'d> {
-    pub fn new(p: impl Peripheral<P = crate::peripherals::FLASH> + 'd) -> Self {
-        into_ref!(p);
+    pub fn new(p: impl Peripheral<P = FLASH> + 'd, irq: impl Peripheral<P = crate::interrupt::FLASH> + 'd) -> Self {
+        into_ref!(p, irq);
+
+        irq.set_handler(family::on_interrupt);
+        irq.unpend();
+        irq.enable();
+
         Self { inner: p }
     }
 
     pub fn into_regions(self) -> FlashLayout<'d> {
         family::set_default_layout();
-        FlashLayout::new(self.release())
+        FlashLayout::new(self.inner)
     }
 
-    pub fn blocking_read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Error> {
-        blocking_read(FLASH_BASE as u32, FLASH_SIZE as u32, offset, bytes)
+    pub fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Error> {
+        read_blocking(FLASH_BASE as u32, FLASH_SIZE as u32, offset, bytes)
     }
 
-    pub fn blocking_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error> {
-        unsafe { blocking_write_chunked(FLASH_BASE as u32, FLASH_SIZE as u32, offset, bytes) }
+    pub fn write_blocking(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error> {
+        unsafe { write_chunked_blocking(FLASH_BASE as u32, FLASH_SIZE as u32, offset, bytes) }
     }
 
-    pub fn blocking_erase(&mut self, from: u32, to: u32) -> Result<(), Error> {
-        unsafe { blocking_erase_sectored(FLASH_BASE as u32, from, to) }
-    }
-
-    pub(crate) fn release(self) -> PeripheralRef<'d, crate::peripherals::FLASH> {
-        unsafe { self.inner.clone_unchecked() }
+    pub fn erase_blocking(&mut self, from: u32, to: u32) -> Result<(), Error> {
+        unsafe { erase_sectored_blocking(FLASH_BASE as u32, from, to) }
     }
 }
 
-pub(super) fn blocking_read(base: u32, size: u32, offset: u32, bytes: &mut [u8]) -> Result<(), Error> {
+pub(super) fn read_blocking(base: u32, size: u32, offset: u32, bytes: &mut [u8]) -> Result<(), Error> {
     if offset + bytes.len() as u32 > size {
         return Err(Error::Size);
     }
@@ -49,7 +60,7 @@ pub(super) fn blocking_read(base: u32, size: u32, offset: u32, bytes: &mut [u8])
     Ok(())
 }
 
-pub(super) unsafe fn blocking_write_chunked(base: u32, size: u32, offset: u32, bytes: &[u8]) -> Result<(), Error> {
+pub(super) unsafe fn write_chunked_blocking(base: u32, size: u32, offset: u32, bytes: &[u8]) -> Result<(), Error> {
     if offset + bytes.len() as u32 > size {
         return Err(Error::Size);
     }
@@ -61,44 +72,31 @@ pub(super) unsafe fn blocking_write_chunked(base: u32, size: u32, offset: u32, b
     trace!("Writing {} bytes at 0x{:x}", bytes.len(), address);
 
     for chunk in bytes.chunks(WRITE_SIZE) {
-        critical_section::with(|_| {
-            family::clear_all_err();
-            fence(Ordering::SeqCst);
-            family::unlock();
+        family::clear_all_err();
+        fence(Ordering::SeqCst);
+        family::unlock();
+        fence(Ordering::SeqCst);
+        family::enable_blocking_write();
+        fence(Ordering::SeqCst);
+
+        let _on_drop = OnDrop::new(|| {
+            family::disable_blocking_write();
             fence(Ordering::SeqCst);
-            family::begin_write();
-            fence(Ordering::SeqCst);
-
-            let _on_drop = OnDrop::new(|| {
-                family::end_write();
-                fence(Ordering::SeqCst);
-                family::lock();
-            });
+            family::lock();
+        });
 
-            family::blocking_write(address, chunk.try_into().unwrap())
-        })?;
+        family::write_blocking(address, chunk.try_into().unwrap())?;
         address += WRITE_SIZE as u32;
     }
     Ok(())
 }
 
-pub(super) unsafe fn blocking_erase_sectored(base: u32, from: u32, to: u32) -> Result<(), Error> {
+pub(super) unsafe fn erase_sectored_blocking(base: u32, from: u32, to: u32) -> Result<(), Error> {
     let start_address = base + from;
     let end_address = base + to;
     let regions = family::get_flash_regions();
 
-    // Test if the address range is aligned at sector base addresses
-    let mut address = start_address;
-    while address < end_address {
-        let sector = get_sector(address, regions);
-        if sector.start != address {
-            return Err(Error::Unaligned);
-        }
-        address += sector.size;
-    }
-    if address != end_address {
-        return Err(Error::Unaligned);
-    }
+    ensure_sector_aligned(start_address, end_address, regions)?;
 
     trace!("Erasing from 0x{:x} to 0x{:x}", start_address, end_address);
 
@@ -107,104 +105,146 @@ pub(super) unsafe fn blocking_erase_sectored(base: u32, from: u32, to: u32) -> R
         let sector = get_sector(address, regions);
         trace!("Erasing sector: {:?}", sector);
 
-        critical_section::with(|_| {
-            family::clear_all_err();
-            fence(Ordering::SeqCst);
-            family::unlock();
-            fence(Ordering::SeqCst);
+        family::clear_all_err();
+        fence(Ordering::SeqCst);
+        family::unlock();
+        fence(Ordering::SeqCst);
 
-            let _on_drop = OnDrop::new(|| {
-                family::lock();
-            });
+        let _on_drop = OnDrop::new(|| family::lock());
 
-            family::blocking_erase_sector(&sector)
-        })?;
+        family::erase_sector_blocking(&sector)?;
         address += sector.size;
     }
     Ok(())
 }
 
-pub(crate) fn get_sector(address: u32, regions: &[&FlashRegion]) -> FlashSector {
-    let mut current_bank = FlashBank::Bank1;
-    let mut bank_offset = 0;
-    for region in regions {
-        if region.bank != current_bank {
-            current_bank = region.bank;
-            bank_offset = 0;
-        }
+impl embedded_storage::nor_flash::ErrorType for Flash<'_> {
+    type Error = Error;
+}
 
-        if address < region.end() {
-            let index_in_region = (address - region.base) / region.erase_size;
-            return FlashSector {
-                bank: region.bank,
-                index_in_bank: bank_offset + index_in_region as u8,
-                start: region.base + index_in_region * region.erase_size,
-                size: region.erase_size,
-            };
-        }
+impl embedded_storage::nor_flash::ReadNorFlash for Flash<'_> {
+    const READ_SIZE: usize = READ_SIZE;
 
-        bank_offset += region.sectors();
+    fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error> {
+        self.read(offset, bytes)
     }
 
-    panic!("Flash sector not found");
+    fn capacity(&self) -> usize {
+        FLASH_SIZE
+    }
 }
 
-impl FlashRegion {
-    pub fn blocking_read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Error> {
-        blocking_read(self.base, self.size, offset, bytes)
+impl embedded_storage::nor_flash::NorFlash for Flash<'_> {
+    const WRITE_SIZE: usize = WRITE_SIZE;
+    const ERASE_SIZE: usize = MAX_ERASE_SIZE;
+
+    fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error> {
+        self.write_blocking(offset, bytes)
+    }
+
+    fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
+        self.erase_blocking(from, to)
     }
+}
+
+#[cfg(feature = "nightly")]
+impl embedded_storage_async::nor_flash::ReadNorFlash for Flash<'_> {
+    const READ_SIZE: usize = READ_SIZE;
 
-    pub fn blocking_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error> {
-        unsafe { blocking_write_chunked(self.base, self.size, offset, bytes) }
+    async fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error> {
+        self.read(offset, bytes)
     }
 
-    pub fn blocking_erase(&mut self, from: u32, to: u32) -> Result<(), Error> {
-        unsafe { blocking_erase_sectored(self.base, from, to) }
+    fn capacity(&self) -> usize {
+        FLASH_SIZE
     }
 }
 
-impl embedded_storage::nor_flash::ErrorType for Flash<'_> {
+pub struct BlockingFlashRegion<'d, const WRITE_SIZE: u32, const ERASE_SIZE: u32>(
+    &'static FlashRegion,
+    PeripheralRef<'d, FLASH>,
+);
+
+impl<const WRITE_SIZE: u32, const ERASE_SIZE: u32> BlockingFlashRegion<'_, WRITE_SIZE, ERASE_SIZE> {
+    pub fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Error> {
+        read_blocking(self.0.base, self.0.size, offset, bytes)
+    }
+
+    pub fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error> {
+        let _guard = block_on(REGION_ACCESS.lock());
+        unsafe { write_chunked_blocking(self.0.base, self.0.size, offset, bytes) }
+    }
+
+    pub fn erase(&mut self, from: u32, to: u32) -> Result<(), Error> {
+        let _guard = block_on(REGION_ACCESS.lock());
+        unsafe { erase_sectored_blocking(self.0.base, from, to) }
+    }
+}
+
+impl<const WRITE_SIZE: u32, const ERASE_SIZE: u32> embedded_storage::nor_flash::ErrorType
+    for BlockingFlashRegion<'_, WRITE_SIZE, ERASE_SIZE>
+{
     type Error = Error;
 }
 
-impl embedded_storage::nor_flash::ReadNorFlash for Flash<'_> {
-    const READ_SIZE: usize = 1;
+impl<const WRITE_SIZE: u32, const ERASE_SIZE: u32> embedded_storage::nor_flash::ReadNorFlash
+    for BlockingFlashRegion<'_, WRITE_SIZE, ERASE_SIZE>
+{
+    const READ_SIZE: usize = READ_SIZE;
 
     fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error> {
-        self.blocking_read(offset, bytes)
+        self.read(offset, bytes)
     }
 
     fn capacity(&self) -> usize {
-        FLASH_SIZE
+        self.0.size as usize
     }
 }
 
-impl embedded_storage::nor_flash::NorFlash for Flash<'_> {
-    const WRITE_SIZE: usize = WRITE_SIZE;
-    const ERASE_SIZE: usize = MAX_ERASE_SIZE;
+impl<const WRITE_SIZE: u32, const ERASE_SIZE: u32> embedded_storage::nor_flash::NorFlash
+    for BlockingFlashRegion<'_, WRITE_SIZE, ERASE_SIZE>
+{
+    const WRITE_SIZE: usize = WRITE_SIZE as usize;
+    const ERASE_SIZE: usize = ERASE_SIZE as usize;
 
     fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error> {
-        self.blocking_write(offset, bytes)
+        self.write(offset, bytes)
     }
 
     fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
-        self.blocking_erase(from, to)
+        self.erase(from, to)
     }
 }
 
 foreach_flash_region! {
     ($type_name:ident, $write_size:literal, $erase_size:literal) => {
-        impl crate::_generated::flash_regions::$type_name<'_> {
-            pub fn blocking_read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Error> {
-                blocking_read(self.0.base, self.0.size, offset, bytes)
+        paste::paste! {
+            pub type [<Blocking $type_name>]<'d> = BlockingFlashRegion<'d, $write_size, $erase_size>;
+        }
+
+        impl<'d> crate::_generated::flash_regions::$type_name<'d> {
+            /// Make this flash region work in a blocking context.
+            ///
+            /// SAFETY
+            ///
+            /// This function is unsafe as incorect usage of parallel blocking operations
+            /// on multiple regions may cause a deadlock because each region requires mutual access to the flash.
+            pub unsafe fn into_blocking(self) -> BlockingFlashRegion<'d, $write_size, $erase_size> {
+                BlockingFlashRegion(self.0, self.1)
             }
 
-            pub fn blocking_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error> {
-                unsafe { blocking_write_chunked(self.0.base, self.0.size, offset, bytes) }
+            pub fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Error> {
+                read_blocking(self.0.base, self.0.size, offset, bytes)
             }
 
-            pub fn blocking_erase(&mut self, from: u32, to: u32) -> Result<(), Error> {
-                unsafe { blocking_erase_sectored(self.0.base, from, to) }
+            pub fn try_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error> {
+                let _guard = REGION_ACCESS.try_lock().map_err(|_| Error::TryLockError)?;
+                unsafe { write_chunked_blocking(self.0.base, self.0.size, offset, bytes) }
+            }
+
+            pub fn try_erase(&mut self, from: u32, to: u32) -> Result<(), Error> {
+                let _guard = REGION_ACCESS.try_lock().map_err(|_| Error::TryLockError)?;
+                unsafe { erase_sectored_blocking(self.0.base, from, to) }
             }
         }
 
@@ -213,28 +253,15 @@ foreach_flash_region! {
         }
 
         impl embedded_storage::nor_flash::ReadNorFlash for crate::_generated::flash_regions::$type_name<'_> {
-            const READ_SIZE: usize = 1;
+            const READ_SIZE: usize = READ_SIZE;
 
             fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error> {
-                self.blocking_read(offset, bytes)
+                self.read(offset, bytes)
             }
 
             fn capacity(&self) -> usize {
                 self.0.size as usize
             }
         }
-
-        impl embedded_storage::nor_flash::NorFlash for crate::_generated::flash_regions::$type_name<'_> {
-            const WRITE_SIZE: usize = $write_size;
-            const ERASE_SIZE: usize = $erase_size;
-
-            fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error> {
-                self.blocking_write(offset, bytes)
-            }
-
-            fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
-                self.blocking_erase(from, to)
-            }
-        }
     };
 }