1475: Add YieldingAsync adapter r=Dirbaio a=rmja

This PR calls `yield_now()` for long blocking `NorFlash` read and erase operations.
The motivation for this change is to allow for other tasks on the same executor to get something done between these long running operations, for example a task that feeds a watchdog. This will allow the watchdog to have a timer relative to e.g. one sector erase, instead of all sector erase.

1478: stm32: Minor fixes in flash regions for F4 dual bank layout r=Dirbaio a=rmja

This PR has the following fixes:
* Ensure that `FlashRegion` instances can only be created within the embassy-stm32 crate.
* Remove `Drop` trait for `AltFlashLayout`, as it is hard to use, as one cannot take the individual regions out from the struct. Instead of going back to single bank mode on `Drop`, we instead transition to single bank mode when calling `Flash::into_regions()`.
* Add missing `otp_region` to the dual bank layout and implement `NorFlash` for the alternate regions.

1482: Add ConcatFlash utility r=Dirbaio a=rmja

This PR adds a `ConcatFlash` utility that can be used to concatenate two `NorFlash` flashes. This is especially useful when concatenating multiple flash regions with unequal erase size.


Co-authored-by: Rasmus Melchior Jacobsen <rmja@laesoe.org>
This commit is contained in:
bors[bot] 2023-05-25 01:05:32 +00:00 committed by GitHub
commit 5f10eadb8d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 628 additions and 28 deletions

View File

@ -14,11 +14,14 @@ target = "x86_64-unknown-linux-gnu"
[features] [features]
std = [] std = []
# Enable nightly-only features # Enable nightly-only features
nightly = ["embedded-hal-async", "embedded-storage-async"] nightly = ["embassy-futures", "embedded-hal-async", "embedded-storage-async"]
[dependencies] [dependencies]
embassy-futures = { version = "0.1.0", path = "../embassy-futures", optional = true }
embassy-sync = { version = "0.2.0", path = "../embassy-sync" } embassy-sync = { version = "0.2.0", path = "../embassy-sync" }
embedded-hal-02 = { package = "embedded-hal", version = "0.2.6", features = ["unproven"] } embedded-hal-02 = { package = "embedded-hal", version = "0.2.6", features = [
"unproven",
] }
embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-alpha.10" } embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-alpha.10" }
embedded-hal-async = { version = "=0.2.0-alpha.1", optional = true } embedded-hal-async = { version = "=0.2.0-alpha.1", optional = true }
embedded-storage = "0.3.0" embedded-storage = "0.3.0"
@ -26,3 +29,6 @@ embedded-storage-async = { version = "0.4.0", optional = true }
nb = "1.0.0" nb = "1.0.0"
defmt = { version = "0.3", optional = true } defmt = { version = "0.3", optional = true }
[dev-dependencies]
futures-test = "0.3.17"

View File

@ -1,5 +1,3 @@
//! Adapters between embedded-hal traits.
use embedded_hal_02::{blocking, serial}; use embedded_hal_02::{blocking, serial};
/// Wrapper that implements async traits using blocking implementations. /// Wrapper that implements async traits using blocking implementations.

View File

@ -0,0 +1,7 @@
//! Adapters between embedded-hal traits.
mod blocking_async;
mod yielding_async;
pub use blocking_async::BlockingAsync;
pub use yielding_async::YieldingAsync;

View File

@ -0,0 +1,232 @@
use embassy_futures::yield_now;
/// Wrapper that yields for each operation to the wrapped instance
///
/// This can be used in combination with BlockingAsync<T> to enforce yields
/// between long running blocking operations.
pub struct YieldingAsync<T> {
wrapped: T,
}
impl<T> YieldingAsync<T> {
/// Create a new instance of a wrapper that yields after each operation.
pub fn new(wrapped: T) -> Self {
Self { wrapped }
}
}
//
// I2C implementations
//
impl<T> embedded_hal_1::i2c::ErrorType for YieldingAsync<T>
where
T: embedded_hal_1::i2c::ErrorType,
{
type Error = T::Error;
}
impl<T> embedded_hal_async::i2c::I2c for YieldingAsync<T>
where
T: embedded_hal_async::i2c::I2c,
{
async fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
self.wrapped.read(address, read).await?;
yield_now().await;
Ok(())
}
async fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
self.wrapped.write(address, write).await?;
yield_now().await;
Ok(())
}
async fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
self.wrapped.write_read(address, write, read).await?;
yield_now().await;
Ok(())
}
async fn transaction(
&mut self,
address: u8,
operations: &mut [embedded_hal_1::i2c::Operation<'_>],
) -> Result<(), Self::Error> {
self.wrapped.transaction(address, operations).await?;
yield_now().await;
Ok(())
}
}
//
// SPI implementations
//
impl<T> embedded_hal_async::spi::ErrorType for YieldingAsync<T>
where
T: embedded_hal_async::spi::ErrorType,
{
type Error = T::Error;
}
impl<T> embedded_hal_async::spi::SpiBus<u8> for YieldingAsync<T>
where
T: embedded_hal_async::spi::SpiBus,
{
async fn transfer<'a>(&'a mut self, read: &'a mut [u8], write: &'a [u8]) -> Result<(), Self::Error> {
self.wrapped.transfer(read, write).await?;
yield_now().await;
Ok(())
}
async fn transfer_in_place<'a>(&'a mut self, words: &'a mut [u8]) -> Result<(), Self::Error> {
self.wrapped.transfer_in_place(words).await?;
yield_now().await;
Ok(())
}
}
impl<T> embedded_hal_async::spi::SpiBusFlush for YieldingAsync<T>
where
T: embedded_hal_async::spi::SpiBusFlush,
{
async fn flush(&mut self) -> Result<(), Self::Error> {
self.wrapped.flush().await?;
yield_now().await;
Ok(())
}
}
impl<T> embedded_hal_async::spi::SpiBusWrite<u8> for YieldingAsync<T>
where
T: embedded_hal_async::spi::SpiBusWrite<u8>,
{
async fn write(&mut self, data: &[u8]) -> Result<(), Self::Error> {
self.wrapped.write(data).await?;
yield_now().await;
Ok(())
}
}
impl<T> embedded_hal_async::spi::SpiBusRead<u8> for YieldingAsync<T>
where
T: embedded_hal_async::spi::SpiBusRead<u8>,
{
async fn read(&mut self, data: &mut [u8]) -> Result<(), Self::Error> {
self.wrapped.read(data).await?;
yield_now().await;
Ok(())
}
}
///
/// NOR flash implementations
///
impl<T: embedded_storage::nor_flash::ErrorType> embedded_storage::nor_flash::ErrorType for YieldingAsync<T> {
type Error = T::Error;
}
impl<T: embedded_storage_async::nor_flash::ReadNorFlash> embedded_storage_async::nor_flash::ReadNorFlash
for YieldingAsync<T>
{
const READ_SIZE: usize = T::READ_SIZE;
async fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error> {
self.wrapped.read(offset, bytes).await?;
Ok(())
}
fn capacity(&self) -> usize {
self.wrapped.capacity()
}
}
impl<T: embedded_storage_async::nor_flash::NorFlash> embedded_storage_async::nor_flash::NorFlash for YieldingAsync<T> {
const WRITE_SIZE: usize = T::WRITE_SIZE;
const ERASE_SIZE: usize = T::ERASE_SIZE;
async fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error> {
self.wrapped.write(offset, bytes).await?;
yield_now().await;
Ok(())
}
async fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
// Yield between each actual erase
for from in (from..to).step_by(T::ERASE_SIZE) {
let to = core::cmp::min(from + T::ERASE_SIZE as u32, to);
self.wrapped.erase(from, to).await?;
yield_now().await;
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use embedded_storage_async::nor_flash::NorFlash;
use super::*;
extern crate std;
#[derive(Default)]
struct FakeFlash(Vec<(u32, u32)>);
impl embedded_storage::nor_flash::ErrorType for FakeFlash {
type Error = std::convert::Infallible;
}
impl embedded_storage_async::nor_flash::ReadNorFlash for FakeFlash {
const READ_SIZE: usize = 1;
async fn read(&mut self, _offset: u32, _bytes: &mut [u8]) -> Result<(), Self::Error> {
unimplemented!()
}
fn capacity(&self) -> usize {
unimplemented!()
}
}
impl embedded_storage_async::nor_flash::NorFlash for FakeFlash {
const WRITE_SIZE: usize = 4;
const ERASE_SIZE: usize = 128;
async fn write(&mut self, _offset: u32, _bytes: &[u8]) -> Result<(), Self::Error> {
unimplemented!()
}
async fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
self.0.push((from, to));
Ok(())
}
}
#[futures_test::test]
async fn can_erase() {
let fake = FakeFlash::default();
let mut yielding = YieldingAsync::new(fake);
yielding.erase(0, 256).await.unwrap();
let fake = yielding.wrapped;
assert_eq!(2, fake.0.len());
assert_eq!((0, 128), fake.0[0]);
assert_eq!((128, 256), fake.0[1]);
}
#[futures_test::test]
async fn can_erase_wrong_erase_size() {
let fake = FakeFlash::default();
let mut yielding = YieldingAsync::new(fake);
yielding.erase(0, 257).await.unwrap();
let fake = yielding.wrapped;
assert_eq!(3, fake.0.len());
assert_eq!((0, 128), fake.0[0]);
assert_eq!((128, 256), fake.0[1]);
assert_eq!((256, 257), fake.0[2]);
}
}

View File

@ -0,0 +1,286 @@
//! Utilities related to flash.
use embedded_storage::nor_flash::{ErrorType, NorFlash, NorFlashError, ReadNorFlash};
#[cfg(feature = "nightly")]
use embedded_storage_async::nor_flash::{NorFlash as AsyncNorFlash, ReadNorFlash as AsyncReadNorFlash};
/// Convenience helper for concatenating two consecutive flashes into one.
/// This is especially useful if used with "flash regions", where one may
/// want to concatenate multiple regions into one larger region.
pub struct ConcatFlash<First, Second>(First, Second);
impl<First, Second> ConcatFlash<First, Second> {
/// Create a new flash that concatenates two consecutive flashes.
pub fn new(first: First, second: Second) -> Self {
Self(first, second)
}
}
const fn get_read_size(first_read_size: usize, second_read_size: usize) -> usize {
if first_read_size != second_read_size {
panic!("The read size for the concatenated flashes must be the same");
}
first_read_size
}
const fn get_write_size(first_write_size: usize, second_write_size: usize) -> usize {
if first_write_size != second_write_size {
panic!("The write size for the concatenated flashes must be the same");
}
first_write_size
}
const fn get_max_erase_size(first_erase_size: usize, second_erase_size: usize) -> usize {
let max_erase_size = if first_erase_size > second_erase_size {
first_erase_size
} else {
second_erase_size
};
if max_erase_size % first_erase_size != 0 || max_erase_size % second_erase_size != 0 {
panic!("The erase sizes for the concatenated flashes must have have a gcd equal to the max erase size");
}
max_erase_size
}
impl<First, Second, E> ErrorType for ConcatFlash<First, Second>
where
First: ErrorType<Error = E>,
Second: ErrorType<Error = E>,
E: NorFlashError,
{
type Error = E;
}
impl<First, Second, E> ReadNorFlash for ConcatFlash<First, Second>
where
First: ReadNorFlash<Error = E>,
Second: ReadNorFlash<Error = E>,
E: NorFlashError,
{
const READ_SIZE: usize = get_read_size(First::READ_SIZE, Second::READ_SIZE);
fn read(&mut self, mut offset: u32, mut bytes: &mut [u8]) -> Result<(), E> {
if offset < self.0.capacity() as u32 {
let len = core::cmp::min(self.0.capacity() - offset as usize, bytes.len());
self.0.read(offset, &mut bytes[..len])?;
offset += len as u32;
bytes = &mut bytes[len..];
}
if !bytes.is_empty() {
self.1.read(offset - self.0.capacity() as u32, bytes)?;
}
Ok(())
}
fn capacity(&self) -> usize {
self.0.capacity() + self.1.capacity()
}
}
impl<First, Second, E> NorFlash for ConcatFlash<First, Second>
where
First: NorFlash<Error = E>,
Second: NorFlash<Error = E>,
E: NorFlashError,
{
const WRITE_SIZE: usize = get_write_size(First::WRITE_SIZE, Second::WRITE_SIZE);
const ERASE_SIZE: usize = get_max_erase_size(First::ERASE_SIZE, Second::ERASE_SIZE);
fn write(&mut self, mut offset: u32, mut bytes: &[u8]) -> Result<(), E> {
if offset < self.0.capacity() as u32 {
let len = core::cmp::min(self.0.capacity() - offset as usize, bytes.len());
self.0.write(offset, &bytes[..len])?;
offset += len as u32;
bytes = &bytes[len..];
}
if !bytes.is_empty() {
self.1.write(offset - self.0.capacity() as u32, bytes)?;
}
Ok(())
}
fn erase(&mut self, mut from: u32, to: u32) -> Result<(), E> {
if from < self.0.capacity() as u32 {
let to = core::cmp::min(self.0.capacity() as u32, to);
self.0.erase(from, to)?;
from = self.0.capacity() as u32;
}
if from < to {
self.1
.erase(from - self.0.capacity() as u32, to - self.0.capacity() as u32)?;
}
Ok(())
}
}
#[cfg(feature = "nightly")]
impl<First, Second, E> AsyncReadNorFlash for ConcatFlash<First, Second>
where
First: AsyncReadNorFlash<Error = E>,
Second: AsyncReadNorFlash<Error = E>,
E: NorFlashError,
{
const READ_SIZE: usize = get_read_size(First::READ_SIZE, Second::READ_SIZE);
async fn read(&mut self, mut offset: u32, mut bytes: &mut [u8]) -> Result<(), E> {
if offset < self.0.capacity() as u32 {
let len = core::cmp::min(self.0.capacity() - offset as usize, bytes.len());
self.0.read(offset, &mut bytes[..len]).await?;
offset += len as u32;
bytes = &mut bytes[len..];
}
if !bytes.is_empty() {
self.1.read(offset - self.0.capacity() as u32, bytes).await?;
}
Ok(())
}
fn capacity(&self) -> usize {
self.0.capacity() + self.1.capacity()
}
}
#[cfg(feature = "nightly")]
impl<First, Second, E> AsyncNorFlash for ConcatFlash<First, Second>
where
First: AsyncNorFlash<Error = E>,
Second: AsyncNorFlash<Error = E>,
E: NorFlashError,
{
const WRITE_SIZE: usize = get_write_size(First::WRITE_SIZE, Second::WRITE_SIZE);
const ERASE_SIZE: usize = get_max_erase_size(First::ERASE_SIZE, Second::ERASE_SIZE);
async fn write(&mut self, mut offset: u32, mut bytes: &[u8]) -> Result<(), E> {
if offset < self.0.capacity() as u32 {
let len = core::cmp::min(self.0.capacity() - offset as usize, bytes.len());
self.0.write(offset, &bytes[..len]).await?;
offset += len as u32;
bytes = &bytes[len..];
}
if !bytes.is_empty() {
self.1.write(offset - self.0.capacity() as u32, bytes).await?;
}
Ok(())
}
async fn erase(&mut self, mut from: u32, to: u32) -> Result<(), E> {
if from < self.0.capacity() as u32 {
let to = core::cmp::min(self.0.capacity() as u32, to);
self.0.erase(from, to).await?;
from = self.0.capacity() as u32;
}
if from < to {
self.1
.erase(from - self.0.capacity() as u32, to - self.0.capacity() as u32)
.await?;
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn can_write_and_read_across_flashes() {
let first = MemFlash::<64, 16, 4>::new();
let second = MemFlash::<64, 64, 4>::new();
let mut f = ConcatFlash::new(first, second);
f.write(60, &[0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88]).unwrap();
assert_eq!(&[0x11, 0x22, 0x33, 0x44], &f.0 .0[60..]);
assert_eq!(&[0x55, 0x66, 0x77, 0x88], &f.1 .0[0..4]);
let mut read_buf = [0; 8];
f.read(60, &mut read_buf).unwrap();
assert_eq!(&[0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88], &read_buf);
}
#[test]
fn can_erase_across_flashes() {
let mut first = MemFlash::<128, 16, 4>::new();
let mut second = MemFlash::<128, 64, 4>::new();
first.0.fill(0x00);
second.0.fill(0x00);
let mut f = ConcatFlash::new(first, second);
f.erase(64, 192).unwrap();
assert_eq!(&[0x00; 64], &f.0 .0[0..64]);
assert_eq!(&[0xff; 64], &f.0 .0[64..128]);
assert_eq!(&[0xff; 64], &f.1 .0[0..64]);
assert_eq!(&[0x00; 64], &f.1 .0[64..128]);
}
pub struct MemFlash<const SIZE: usize, const ERASE_SIZE: usize, const WRITE_SIZE: usize>([u8; SIZE]);
impl<const SIZE: usize, const ERASE_SIZE: usize, const WRITE_SIZE: usize> MemFlash<SIZE, ERASE_SIZE, WRITE_SIZE> {
pub const fn new() -> Self {
Self([0xff; SIZE])
}
}
impl<const SIZE: usize, const ERASE_SIZE: usize, const WRITE_SIZE: usize> ErrorType
for MemFlash<SIZE, ERASE_SIZE, WRITE_SIZE>
{
type Error = core::convert::Infallible;
}
impl<const SIZE: usize, const ERASE_SIZE: usize, const WRITE_SIZE: usize> ReadNorFlash
for MemFlash<SIZE, ERASE_SIZE, WRITE_SIZE>
{
const READ_SIZE: usize = 1;
fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error> {
let len = bytes.len();
bytes.copy_from_slice(&self.0[offset as usize..offset as usize + len]);
Ok(())
}
fn capacity(&self) -> usize {
SIZE
}
}
impl<const SIZE: usize, const ERASE_SIZE: usize, const WRITE_SIZE: usize> NorFlash
for MemFlash<SIZE, ERASE_SIZE, WRITE_SIZE>
{
const WRITE_SIZE: usize = WRITE_SIZE;
const ERASE_SIZE: usize = ERASE_SIZE;
fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
let from = from as usize;
let to = to as usize;
assert_eq!(0, from % ERASE_SIZE);
assert_eq!(0, to % ERASE_SIZE);
self.0[from..to].fill(0xff);
Ok(())
}
fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error> {
let offset = offset as usize;
assert_eq!(0, bytes.len() % WRITE_SIZE);
assert_eq!(0, offset % WRITE_SIZE);
assert!(offset + bytes.len() <= SIZE);
self.0[offset..offset + bytes.len()].copy_from_slice(bytes);
Ok(())
}
}
}

View File

@ -7,6 +7,8 @@
#[cfg(feature = "nightly")] #[cfg(feature = "nightly")]
pub mod adapter; pub mod adapter;
pub mod flash;
pub mod shared_bus; pub mod shared_bus;
/// Set the configuration of a peripheral driver. /// Set the configuration of a peripheral driver.

View File

@ -206,6 +206,7 @@ fn main() {
erase_size: #erase_size, erase_size: #erase_size,
write_size: #write_size, write_size: #write_size,
erase_value: #erase_value, erase_value: #erase_value,
_ensure_internal: (),
}; };
}); });

View File

@ -17,6 +17,7 @@ impl<'d> Flash<'d> {
} }
pub fn into_regions(self) -> FlashLayout<'d> { pub fn into_regions(self) -> FlashLayout<'d> {
family::set_default_layout();
FlashLayout::new(self.release()) FlashLayout::new(self.release())
} }
@ -25,11 +26,11 @@ impl<'d> Flash<'d> {
} }
pub fn blocking_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error> { pub fn blocking_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error> {
unsafe { blocking_write(FLASH_BASE as u32, FLASH_SIZE as u32, offset, bytes) } unsafe { blocking_write_chunked(FLASH_BASE as u32, FLASH_SIZE as u32, offset, bytes) }
} }
pub fn blocking_erase(&mut self, from: u32, to: u32) -> Result<(), Error> { pub fn blocking_erase(&mut self, from: u32, to: u32) -> Result<(), Error> {
unsafe { blocking_erase(FLASH_BASE as u32, from, to) } unsafe { blocking_erase_sectored(FLASH_BASE as u32, from, to) }
} }
pub(crate) fn release(self) -> PeripheralRef<'d, crate::peripherals::FLASH> { pub(crate) fn release(self) -> PeripheralRef<'d, crate::peripherals::FLASH> {
@ -37,7 +38,7 @@ impl<'d> Flash<'d> {
} }
} }
fn blocking_read(base: u32, size: u32, offset: u32, bytes: &mut [u8]) -> Result<(), Error> { pub(super) fn blocking_read(base: u32, size: u32, offset: u32, bytes: &mut [u8]) -> Result<(), Error> {
if offset + bytes.len() as u32 > size { if offset + bytes.len() as u32 > size {
return Err(Error::Size); return Err(Error::Size);
} }
@ -48,7 +49,7 @@ fn blocking_read(base: u32, size: u32, offset: u32, bytes: &mut [u8]) -> Result<
Ok(()) Ok(())
} }
unsafe fn blocking_write(base: u32, size: u32, offset: u32, bytes: &[u8]) -> Result<(), Error> { pub(super) unsafe fn blocking_write_chunked(base: u32, size: u32, offset: u32, bytes: &[u8]) -> Result<(), Error> {
if offset + bytes.len() as u32 > size { if offset + bytes.len() as u32 > size {
return Err(Error::Size); return Err(Error::Size);
} }
@ -81,7 +82,7 @@ unsafe fn blocking_write(base: u32, size: u32, offset: u32, bytes: &[u8]) -> Res
Ok(()) Ok(())
} }
unsafe fn blocking_erase(base: u32, from: u32, to: u32) -> Result<(), Error> { pub(super) unsafe fn blocking_erase_sectored(base: u32, from: u32, to: u32) -> Result<(), Error> {
let start_address = base + from; let start_address = base + from;
let end_address = base + to; let end_address = base + to;
let regions = family::get_flash_regions(); let regions = family::get_flash_regions();
@ -154,11 +155,11 @@ impl FlashRegion {
} }
pub fn blocking_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error> { pub fn blocking_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error> {
unsafe { blocking_write(self.base, self.size, offset, bytes) } unsafe { blocking_write_chunked(self.base, self.size, offset, bytes) }
} }
pub fn blocking_erase(&mut self, from: u32, to: u32) -> Result<(), Error> { pub fn blocking_erase(&mut self, from: u32, to: u32) -> Result<(), Error> {
unsafe { blocking_erase(self.base, from, to) } unsafe { blocking_erase_sectored(self.base, from, to) }
} }
} }
@ -199,11 +200,11 @@ foreach_flash_region! {
} }
pub fn blocking_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error> { pub fn blocking_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error> {
unsafe { blocking_write(self.0.base, self.0.size, offset, bytes) } unsafe { blocking_write_chunked(self.0.base, self.0.size, offset, bytes) }
} }
pub fn blocking_erase(&mut self, from: u32, to: u32) -> Result<(), Error> { pub fn blocking_erase(&mut self, from: u32, to: u32) -> Result<(), Error> {
unsafe { blocking_erase(self.0.base, from, to) } unsafe { blocking_erase_sectored(self.0.base, from, to) }
} }
} }

View File

@ -7,6 +7,8 @@ use super::{FlashRegion, FlashSector, FLASH_REGIONS, WRITE_SIZE};
use crate::flash::Error; use crate::flash::Error;
use crate::pac; use crate::pac;
pub const fn set_default_layout() {}
pub const fn get_flash_regions() -> &'static [&'static FlashRegion] { pub const fn get_flash_regions() -> &'static [&'static FlashRegion] {
&FLASH_REGIONS &FLASH_REGIONS
} }

View File

@ -7,6 +7,8 @@ use super::{FlashRegion, FlashSector, FLASH_REGIONS, WRITE_SIZE};
use crate::flash::Error; use crate::flash::Error;
use crate::pac; use crate::pac;
pub const fn set_default_layout() {}
pub const fn get_flash_regions() -> &'static [&'static FlashRegion] { pub const fn get_flash_regions() -> &'static [&'static FlashRegion] {
&FLASH_REGIONS &FLASH_REGIONS
} }

View File

@ -11,8 +11,11 @@ mod alt_regions {
use embassy_hal_common::PeripheralRef; use embassy_hal_common::PeripheralRef;
use stm32_metapac::FLASH_SIZE; use stm32_metapac::FLASH_SIZE;
use crate::_generated::flash_regions::{BANK1_REGION1, BANK1_REGION2, BANK1_REGION3}; use crate::_generated::flash_regions::{OTPRegion, BANK1_REGION1, BANK1_REGION2, BANK1_REGION3, OTP_REGION};
use crate::flash::{Bank1Region1, Bank1Region2, Flash, FlashBank, FlashRegion}; use crate::flash::{
blocking_erase_sectored, blocking_read, blocking_write_chunked, Bank1Region1, Bank1Region2, Error, Flash,
FlashBank, FlashRegion,
};
use crate::peripherals::FLASH; use crate::peripherals::FLASH;
pub const ALT_BANK1_REGION3: FlashRegion = FlashRegion { pub const ALT_BANK1_REGION3: FlashRegion = FlashRegion {
@ -45,20 +48,19 @@ mod alt_regions {
&ALT_BANK2_REGION3, &ALT_BANK2_REGION3,
]; ];
pub type AltBank1Region1<'d> = Bank1Region1<'d>;
pub type AltBank1Region2<'d> = Bank1Region2<'d>;
pub struct AltBank1Region3<'d>(pub &'static FlashRegion, PeripheralRef<'d, FLASH>); pub struct AltBank1Region3<'d>(pub &'static FlashRegion, PeripheralRef<'d, FLASH>);
pub struct AltBank2Region1<'d>(pub &'static FlashRegion, PeripheralRef<'d, FLASH>); pub struct AltBank2Region1<'d>(pub &'static FlashRegion, PeripheralRef<'d, FLASH>);
pub struct AltBank2Region2<'d>(pub &'static FlashRegion, PeripheralRef<'d, FLASH>); pub struct AltBank2Region2<'d>(pub &'static FlashRegion, PeripheralRef<'d, FLASH>);
pub struct AltBank2Region3<'d>(pub &'static FlashRegion, PeripheralRef<'d, FLASH>); pub struct AltBank2Region3<'d>(pub &'static FlashRegion, PeripheralRef<'d, FLASH>);
pub struct AltFlashLayout<'d> { pub struct AltFlashLayout<'d> {
pub bank1_region1: AltBank1Region1<'d>, pub bank1_region1: Bank1Region1<'d>,
pub bank1_region2: AltBank1Region2<'d>, pub bank1_region2: Bank1Region2<'d>,
pub bank1_region3: AltBank1Region3<'d>, pub bank1_region3: AltBank1Region3<'d>,
pub bank2_region1: AltBank2Region1<'d>, pub bank2_region1: AltBank2Region1<'d>,
pub bank2_region2: AltBank2Region2<'d>, pub bank2_region2: AltBank2Region2<'d>,
pub bank2_region3: AltBank2Region3<'d>, pub bank2_region3: AltBank2Region3<'d>,
pub otp_region: OTPRegion<'d>,
} }
impl<'d> Flash<'d> { impl<'d> Flash<'d> {
@ -66,7 +68,7 @@ mod alt_regions {
unsafe { crate::pac::FLASH.optcr().modify(|r| r.set_db1m(true)) }; unsafe { crate::pac::FLASH.optcr().modify(|r| r.set_db1m(true)) };
// SAFETY: We never expose the cloned peripheral references, and their instance is not public. // SAFETY: We never expose the cloned peripheral references, and their instance is not public.
// Also, all flash region operations are protected with a cs. // Also, all blocking flash region operations are protected with a cs.
let p = self.release(); let p = self.release();
AltFlashLayout { AltFlashLayout {
bank1_region1: Bank1Region1(&BANK1_REGION1, unsafe { p.clone_unchecked() }), bank1_region1: Bank1Region1(&BANK1_REGION1, unsafe { p.clone_unchecked() }),
@ -75,22 +77,74 @@ mod alt_regions {
bank2_region1: AltBank2Region1(&ALT_BANK2_REGION1, unsafe { p.clone_unchecked() }), bank2_region1: AltBank2Region1(&ALT_BANK2_REGION1, unsafe { p.clone_unchecked() }),
bank2_region2: AltBank2Region2(&ALT_BANK2_REGION2, unsafe { p.clone_unchecked() }), bank2_region2: AltBank2Region2(&ALT_BANK2_REGION2, unsafe { p.clone_unchecked() }),
bank2_region3: AltBank2Region3(&ALT_BANK2_REGION3, unsafe { p.clone_unchecked() }), bank2_region3: AltBank2Region3(&ALT_BANK2_REGION3, unsafe { p.clone_unchecked() }),
otp_region: OTPRegion(&OTP_REGION, unsafe { p.clone_unchecked() }),
} }
} }
} }
impl Drop for AltFlashLayout<'_> { macro_rules! foreach_altflash_region {
fn drop(&mut self) { ($type_name:ident, $region:ident) => {
unsafe { impl $type_name<'_> {
super::lock(); pub fn blocking_read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Error> {
crate::pac::FLASH.optcr().modify(|r| r.set_db1m(false)) blocking_read(self.0.base, self.0.size, offset, bytes)
}
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 blocking_erase(&mut self, from: u32, to: u32) -> Result<(), Error> {
unsafe { blocking_erase_sectored(self.0.base, from, to) }
}
}
impl embedded_storage::nor_flash::ErrorType for $type_name<'_> {
type Error = Error;
}
impl embedded_storage::nor_flash::ReadNorFlash for $type_name<'_> {
const READ_SIZE: usize = 1;
fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error> {
self.blocking_read(offset, bytes)
}
fn capacity(&self) -> usize {
self.0.size as usize
}
}
impl embedded_storage::nor_flash::NorFlash for $type_name<'_> {
const WRITE_SIZE: usize = $region.write_size as usize;
const ERASE_SIZE: usize = $region.erase_size as usize;
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)
}
}
}; };
} }
}
foreach_altflash_region!(AltBank1Region3, ALT_BANK1_REGION3);
foreach_altflash_region!(AltBank2Region1, ALT_BANK2_REGION1);
foreach_altflash_region!(AltBank2Region2, ALT_BANK2_REGION2);
foreach_altflash_region!(AltBank2Region3, ALT_BANK2_REGION3);
} }
#[cfg(any(stm32f427, stm32f429, stm32f437, stm32f439, stm32f469, stm32f479))] #[cfg(any(stm32f427, stm32f429, stm32f437, stm32f439, stm32f469, stm32f479))]
pub use alt_regions::{AltFlashLayout, ALT_FLASH_REGIONS}; pub use alt_regions::*;
#[cfg(any(stm32f427, stm32f429, stm32f437, stm32f439, stm32f469, stm32f479))]
pub fn set_default_layout() {
unsafe { crate::pac::FLASH.optcr().modify(|r| r.set_db1m(false)) };
}
#[cfg(not(any(stm32f427, stm32f429, stm32f437, stm32f439, stm32f469, stm32f479)))]
pub const fn set_default_layout() {}
#[cfg(any(stm32f427, stm32f429, stm32f437, stm32f439, stm32f469, stm32f479))] #[cfg(any(stm32f427, stm32f429, stm32f437, stm32f439, stm32f469, stm32f479))]
pub fn get_flash_regions() -> &'static [&'static FlashRegion] { pub fn get_flash_regions() -> &'static [&'static FlashRegion] {

View File

@ -6,6 +6,8 @@ use super::{FlashRegion, FlashSector, FLASH_REGIONS, WRITE_SIZE};
use crate::flash::Error; use crate::flash::Error;
use crate::pac; use crate::pac;
pub const fn set_default_layout() {}
pub const fn get_flash_regions() -> &'static [&'static FlashRegion] { pub const fn get_flash_regions() -> &'static [&'static FlashRegion] {
&FLASH_REGIONS &FLASH_REGIONS
} }

View File

@ -7,6 +7,8 @@ use super::{FlashRegion, FlashSector, BANK1_REGION, FLASH_REGIONS, WRITE_SIZE};
use crate::flash::Error; use crate::flash::Error;
use crate::pac; use crate::pac;
pub const fn set_default_layout() {}
const fn is_dual_bank() -> bool { const fn is_dual_bank() -> bool {
FLASH_REGIONS.len() == 2 FLASH_REGIONS.len() == 2
} }

View File

@ -6,6 +6,8 @@ use super::{FlashRegion, FlashSector, FLASH_REGIONS, WRITE_SIZE};
use crate::flash::Error; use crate::flash::Error;
use crate::pac; use crate::pac;
pub const fn set_default_layout() {}
pub const fn get_flash_regions() -> &'static [&'static FlashRegion] { pub const fn get_flash_regions() -> &'static [&'static FlashRegion] {
&FLASH_REGIONS &FLASH_REGIONS
} }

View File

@ -19,6 +19,7 @@ pub struct FlashRegion {
pub erase_size: u32, pub erase_size: u32,
pub write_size: u32, pub write_size: u32,
pub erase_value: u8, pub erase_value: u8,
pub(crate) _ensure_internal: (),
} }
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]

View File

@ -2,6 +2,8 @@
use super::{Error, FlashRegion, FlashSector, FLASH_REGIONS, WRITE_SIZE}; use super::{Error, FlashRegion, FlashSector, FLASH_REGIONS, WRITE_SIZE};
pub const fn set_default_layout() {}
pub const fn get_flash_regions() -> &'static [&'static FlashRegion] { pub const fn get_flash_regions() -> &'static [&'static FlashRegion] {
&FLASH_REGIONS &FLASH_REGIONS
} }