diff options
author | Ulf Lilleengen <lulf@redhat.com> | 2022-04-20 13:49:59 +0200 |
---|---|---|
committer | Ulf Lilleengen <ulf.lilleengen@gmail.com> | 2022-04-27 15:17:18 +0200 |
commit | 484e0acc638c27366e19275c32db9c8487ea8fba (patch) | |
tree | 5649591dad34cadcb28503f94c1bbca0bf5578a1 /embassy-boot | |
parent | 9c283cd44504d6d9d6f9e352e4c7a8d043bd673f (diff) | |
download | embassy-484e0acc638c27366e19275c32db9c8487ea8fba.zip |
Add stm32 flash + bootloader support
* Add flash drivers for L0, L1, L4, WB and WL. Not tested for WB, but
should be similar to WL.
* Add embassy-boot-stm32 for bootloading on STM32.
* Add flash examples and bootloader examples
* Update stm32-data
Diffstat (limited to 'embassy-boot')
-rw-r--r-- | embassy-boot/boot/Cargo.toml | 5 | ||||
-rw-r--r-- | embassy-boot/boot/src/lib.rs | 219 | ||||
-rw-r--r-- | embassy-boot/nrf/Cargo.toml | 2 | ||||
-rw-r--r-- | embassy-boot/nrf/src/lib.rs | 30 | ||||
-rw-r--r-- | embassy-boot/stm32/Cargo.toml | 65 | ||||
-rw-r--r-- | embassy-boot/stm32/README.md | 11 | ||||
-rw-r--r-- | embassy-boot/stm32/build.rs | 27 | ||||
-rw-r--r-- | embassy-boot/stm32/memory.x | 18 | ||||
-rw-r--r-- | embassy-boot/stm32/src/fmt.rs | 225 | ||||
-rw-r--r-- | embassy-boot/stm32/src/lib.rs | 75 | ||||
-rw-r--r-- | embassy-boot/stm32/src/main.rs | 62 |
11 files changed, 634 insertions, 105 deletions
diff --git a/embassy-boot/boot/Cargo.toml b/embassy-boot/boot/Cargo.toml index 0a3006ff..04deab30 100644 --- a/embassy-boot/boot/Cargo.toml +++ b/embassy-boot/boot/Cargo.toml @@ -21,3 +21,8 @@ log = "0.4" env_logger = "0.9" rand = "0.8" futures = { version = "0.3", features = ["executor"] } + +[features] +write-4 = [] +write-8 = [] +invert-erase = [] diff --git a/embassy-boot/boot/src/lib.rs b/embassy-boot/boot/src/lib.rs index 0d33ad1a..080ea242 100644 --- a/embassy-boot/boot/src/lib.rs +++ b/embassy-boot/boot/src/lib.rs @@ -17,8 +17,23 @@ mod fmt; use embedded_storage::nor_flash::{NorFlash, NorFlashError, NorFlashErrorKind, ReadNorFlash}; use embedded_storage_async::nor_flash::AsyncNorFlash; -pub const BOOT_MAGIC: u32 = 0xD00DF00D; -pub const SWAP_MAGIC: u32 = 0xF00FDAAD; +#[cfg(not(any(feature = "write-4", feature = "write-8",)))] +compile_error!("No write size/alignment specified. Must specify exactly one of the following features: write-4, write-8"); + +const BOOT_MAGIC: u8 = 0xD0; +const SWAP_MAGIC: u8 = 0xF0; + +#[cfg(feature = "write-4")] +const WRITE_SIZE: usize = 4; + +#[cfg(feature = "write-8")] +const WRITE_SIZE: usize = 8; + +#[cfg(feature = "invert-erase")] +const ERASE_VALUE: u8 = 0x00; + +#[cfg(not(feature = "invert-erase"))] +const ERASE_VALUE: u8 = 0xFF; #[derive(Copy, Clone, Debug)] #[cfg_attr(feature = "defmt", derive(defmt::Format))] @@ -80,12 +95,12 @@ pub trait FlashProvider { } /// BootLoader works with any flash implementing embedded_storage and can also work with -/// different page sizes. +/// different page sizes and flash write sizes. pub struct BootLoader<const PAGE_SIZE: usize> { // Page with current state of bootloader. The state partition has the following format: - // | Range | Description | - // | 0 - 4 | Magic indicating bootloader state. BOOT_MAGIC means boot, SWAP_MAGIC means swap. | - // | 4 - N | Progress index used while swapping or reverting | + // | Range | Description | + // | 0 - WRITE_SIZE | Magic indicating bootloader state. BOOT_MAGIC means boot, SWAP_MAGIC means swap. | + // | WRITE_SIZE - N | Progress index used while swapping or reverting | state: Partition, // Location of the partition which will be booted from active: Partition, @@ -100,7 +115,7 @@ impl<const PAGE_SIZE: usize> BootLoader<PAGE_SIZE> { // DFU partition must have an extra page assert!(dfu.len() - active.len() >= PAGE_SIZE); // Ensure we have enough progress pages to store copy progress - assert!(active.len() / PAGE_SIZE >= (state.len() - 4) / PAGE_SIZE); + assert!(active.len() / PAGE_SIZE >= (state.len() - WRITE_SIZE) / PAGE_SIZE); Self { active, dfu, state } } @@ -203,15 +218,18 @@ impl<const PAGE_SIZE: usize> BootLoader<PAGE_SIZE> { if !self.is_swapped(p.state())? { trace!("Swapping"); self.swap(p)?; + trace!("Swapping done"); } else { trace!("Reverting"); self.revert(p)?; // Overwrite magic and reset progress let fstate = p.state().flash(); - fstate.write(self.state.from as u32, &[0, 0, 0, 0])?; + let aligned = Aligned([!ERASE_VALUE; WRITE_SIZE]); + fstate.write(self.state.from as u32, &aligned.0)?; fstate.erase(self.state.from as u32, self.state.to as u32)?; - fstate.write(self.state.from as u32, &BOOT_MAGIC.to_le_bytes())?; + let aligned = Aligned([BOOT_MAGIC; WRITE_SIZE]); + fstate.write(self.state.from as u32, &aligned.0)?; } } _ => {} @@ -227,12 +245,15 @@ impl<const PAGE_SIZE: usize> BootLoader<PAGE_SIZE> { } fn current_progress<P: FlashConfig>(&mut self, p: &mut P) -> Result<usize, BootError> { - let max_index = ((self.state.len() - 4) / 4) - 1; + let max_index = ((self.state.len() - WRITE_SIZE) / WRITE_SIZE) - 1; let flash = p.flash(); + let mut aligned = Aligned([!ERASE_VALUE; WRITE_SIZE]); for i in 0..max_index { - let mut buf: [u8; 4] = [0; 4]; - flash.read((self.state.from + 4 + i * 4) as u32, &mut buf)?; - if buf == [0xFF, 0xFF, 0xFF, 0xFF] { + flash.read( + (self.state.from + WRITE_SIZE + i * WRITE_SIZE) as u32, + &mut aligned.0, + )?; + if aligned.0 == [ERASE_VALUE; WRITE_SIZE] { return Ok(i); } } @@ -241,8 +262,9 @@ impl<const PAGE_SIZE: usize> BootLoader<PAGE_SIZE> { fn update_progress<P: FlashConfig>(&mut self, idx: usize, p: &mut P) -> Result<(), BootError> { let flash = p.flash(); - let w = self.state.from + 4 + idx * 4; - flash.write(w as u32, &[0, 0, 0, 0])?; + let w = self.state.from + WRITE_SIZE + idx * WRITE_SIZE; + let aligned = Aligned([!ERASE_VALUE; WRITE_SIZE]); + flash.write(w as u32, &aligned.0)?; Ok(()) } @@ -314,21 +336,24 @@ impl<const PAGE_SIZE: usize> BootLoader<PAGE_SIZE> { fn swap<P: FlashProvider>(&mut self, p: &mut P) -> Result<(), BootError> { let page_count = self.active.len() / PAGE_SIZE; - // trace!("Page count: {}", page_count); + trace!("Page count: {}", page_count); for page in 0..page_count { + trace!("COPY PAGE {}", page); // Copy active page to the 'next' DFU page. let active_page = self.active_addr(page_count - 1 - page); let dfu_page = self.dfu_addr(page_count - page); - info!("Copy active {} to dfu {}", active_page, dfu_page); + //trace!("Copy active {} to dfu {}", active_page, dfu_page); self.copy_page_once_to_dfu(page * 2, active_page, dfu_page, p)?; // Copy DFU page to the active page let active_page = self.active_addr(page_count - 1 - page); let dfu_page = self.dfu_addr(page_count - 1 - page); - info!("Copy dfy {} to active {}", dfu_page, active_page); + //trace!("Copy dfy {} to active {}", dfu_page, active_page); self.copy_page_once_to_active(page * 2 + 1, dfu_page, active_page, p)?; } + info!("DONE COPYING"); + Ok(()) } @@ -350,13 +375,15 @@ impl<const PAGE_SIZE: usize> BootLoader<PAGE_SIZE> { } fn read_state<P: FlashConfig>(&mut self, p: &mut P) -> Result<State, BootError> { - let mut magic: [u8; 4] = [0; 4]; + let mut magic: [u8; WRITE_SIZE] = [0; WRITE_SIZE]; let flash = p.flash(); flash.read(self.state.from as u32, &mut magic)?; - match u32::from_le_bytes(magic) { - SWAP_MAGIC => Ok(State::Swap), - _ => Ok(State::Boot), + info!("Read magic: {:x}", magic); + if magic == [SWAP_MAGIC; WRITE_SIZE] { + Ok(State::Swap) + } else { + Ok(State::Boot) } } } @@ -424,6 +451,39 @@ pub struct FirmwareUpdater { dfu: Partition, } +#[cfg(feature = "write-4")] +#[repr(align(4))] +pub struct Aligned([u8; 4]); + +#[cfg(feature = "write-8")] +#[repr(align(8))] +pub struct Aligned([u8; 8]); + +impl Default for FirmwareUpdater { + fn default() -> Self { + extern "C" { + static __bootloader_state_start: u32; + static __bootloader_state_end: u32; + static __bootloader_dfu_start: u32; + static __bootloader_dfu_end: u32; + } + + let dfu = unsafe { + Partition::new( + &__bootloader_dfu_start as *const u32 as usize, + &__bootloader_dfu_end as *const u32 as usize, + ) + }; + let state = unsafe { + Partition::new( + &__bootloader_state_start as *const u32 as usize, + &__bootloader_state_end as *const u32 as usize, + ) + }; + FirmwareUpdater::new(dfu, state) + } +} + impl FirmwareUpdater { pub const fn new(dfu: Partition, state: Partition) -> Self { Self { dfu, state } @@ -435,53 +495,45 @@ impl FirmwareUpdater { } /// Instruct bootloader that DFU should commence at next boot. + /// Must be provided with an aligned buffer to use for reading and writing magic; pub async fn mark_update<F: AsyncNorFlash>(&mut self, flash: &mut F) -> Result<(), F::Error> { - #[repr(align(4))] - struct Aligned([u8; 4]); - - let mut magic = Aligned([0; 4]); - flash.read(self.state.from as u32, &mut magic.0).await?; - let magic = u32::from_le_bytes(magic.0); - - if magic != SWAP_MAGIC { - flash - .write(self.state.from as u32, &Aligned([0; 4]).0) - .await?; - flash - .erase(self.state.from as u32, self.state.to as u32) - .await?; - trace!( - "Setting swap magic at {} to 0x{:x}, LE: 0x{:x}", - self.state.from, - &SWAP_MAGIC, - &SWAP_MAGIC.to_le_bytes() - ); - flash - .write(self.state.from as u32, &SWAP_MAGIC.to_le_bytes()) - .await?; - } - Ok(()) + let mut aligned = Aligned([0; WRITE_SIZE]); + self.set_magic(&mut aligned.0, SWAP_MAGIC, flash).await } /// Mark firmware boot successfully pub async fn mark_booted<F: AsyncNorFlash>(&mut self, flash: &mut F) -> Result<(), F::Error> { - #[repr(align(4))] - struct Aligned([u8; 4]); + let mut aligned = Aligned([0; WRITE_SIZE]); + self.set_magic(&mut aligned.0, BOOT_MAGIC, flash).await + } - let mut magic = Aligned([0; 4]); - flash.read(self.state.from as u32, &mut magic.0).await?; - let magic = u32::from_le_bytes(magic.0); + async fn set_magic<F: AsyncNorFlash>( + &mut self, + aligned: &mut [u8], + magic: u8, + flash: &mut F, + ) -> Result<(), F::Error> { + flash.read(self.state.from as u32, aligned).await?; - if magic != BOOT_MAGIC { - flash - .write(self.state.from as u32, &Aligned([0; 4]).0) - .await?; + let mut is_set = true; + for b in 0..aligned.len() { + if aligned[b] != magic { + is_set = false; + } + } + if !is_set { + for i in 0..aligned.len() { + aligned[i] = 0; + } + flash.write(self.state.from as u32, aligned).await?; flash .erase(self.state.from as u32, self.state.to as u32) .await?; - flash - .write(self.state.from as u32, &BOOT_MAGIC.to_le_bytes()) - .await?; + + for i in 0..aligned.len() { + aligned[i] = magic; + } + flash.write(self.state.from as u32, aligned).await?; } Ok(()) } @@ -545,6 +597,7 @@ mod tests { use super::*; use core::convert::Infallible; use core::future::Future; + use embedded_storage::nor_flash::ErrorType; use embedded_storage_async::nor_flash::AsyncReadNorFlash; use futures::executor::block_on; @@ -552,9 +605,11 @@ mod tests { const ACTIVE: Partition = Partition::new(4096, 61440); const DFU: Partition = Partition::new(61440, 122880); + /* #[test] fn test_bad_magic() { let mut flash = MemFlash([0xff; 131072]); + let mut flash = SingleFlashProvider::new(&mut flash); let mut bootloader = BootLoader::<4096>::new(ACTIVE, DFU, STATE); @@ -563,11 +618,13 @@ mod tests { Err(BootError::BadMagic) ); } + */ #[test] fn test_boot_state() { let mut flash = MemFlash([0xff; 131072]); - flash.0[0..4].copy_from_slice(&BOOT_MAGIC.to_le_bytes()); + flash.0[0..4].copy_from_slice(&[BOOT_MAGIC; 4]); + let mut flash = SingleFlashProvider::new(&mut flash); let mut bootloader = BootLoader::<4096>::new(ACTIVE, DFU, STATE); @@ -588,19 +645,19 @@ mod tests { let mut bootloader = BootLoader::<4096>::new(ACTIVE, DFU, STATE); let mut updater = FirmwareUpdater::new(DFU, STATE); - for i in (DFU.from..DFU.to).step_by(4) { - let base = i - DFU.from; - let data: [u8; 4] = [ - update[base], - update[base + 1], - update[base + 2], - update[base + 3], - ]; - block_on(updater.write_firmware(i - DFU.from, &data, &mut flash)).unwrap(); + let mut offset = 0; + for chunk in update.chunks(4096) { + block_on(updater.write_firmware(offset, &chunk, &mut flash, 4096)).unwrap(); + offset += chunk.len(); } block_on(updater.mark_update(&mut flash)).unwrap(); - assert_eq!(State::Swap, bootloader.prepare_boot(&mut flash).unwrap()); + assert_eq!( + State::Swap, + bootloader + .prepare_boot(&mut SingleFlashProvider::new(&mut flash)) + .unwrap() + ); for i in ACTIVE.from..ACTIVE.to { assert_eq!(flash.0[i], update[i - ACTIVE.from], "Index {}", i); @@ -612,7 +669,12 @@ mod tests { } // Running again should cause a revert - assert_eq!(State::Swap, bootloader.prepare_boot(&mut flash).unwrap()); + assert_eq!( + State::Swap, + bootloader + .prepare_boot(&mut SingleFlashProvider::new(&mut flash)) + .unwrap() + ); for i in ACTIVE.from..ACTIVE.to { assert_eq!(flash.0[i], original[i - ACTIVE.from], "Index {}", i); @@ -625,7 +687,12 @@ mod tests { // Mark as booted block_on(updater.mark_booted(&mut flash)).unwrap(); - assert_eq!(State::Boot, bootloader.prepare_boot(&mut flash).unwrap()); + assert_eq!( + State::Boot, + bootloader + .prepare_boot(&mut SingleFlashProvider::new(&mut flash)) + .unwrap() + ); } struct MemFlash([u8; 131072]); @@ -656,9 +723,12 @@ mod tests { } } + impl ErrorType for MemFlash { + type Error = Infallible; + } + impl ReadNorFlash for MemFlash { const READ_SIZE: usize = 4; - type Error = Infallible; fn read(&mut self, offset: u32, buf: &mut [u8]) -> Result<(), Self::Error> { let len = buf.len(); @@ -673,10 +743,9 @@ mod tests { impl AsyncReadNorFlash for MemFlash { const READ_SIZE: usize = 4; - type Error = Infallible; type ReadFuture<'a> = impl Future<Output = Result<(), Self::Error>> + 'a; - fn read<'a>(&'a mut self, offset: usize, buf: &'a mut [u8]) -> Self::ReadFuture<'a> { + fn read<'a>(&'a mut self, offset: u32, buf: &'a mut [u8]) -> Self::ReadFuture<'a> { async move { let len = buf.len(); buf[..].copy_from_slice(&self.0[offset as usize..offset as usize + len]); diff --git a/embassy-boot/nrf/Cargo.toml b/embassy-boot/nrf/Cargo.toml index 97207ac2..78157d24 100644 --- a/embassy-boot/nrf/Cargo.toml +++ b/embassy-boot/nrf/Cargo.toml @@ -13,7 +13,7 @@ defmt-rtt = { version = "0.3", optional = true } embassy = { path = "../../embassy", default-features = false } embassy-nrf = { path = "../../embassy-nrf", default-features = false, features = ["nightly"] } -embassy-boot = { path = "../boot", default-features = false } +embassy-boot = { path = "../boot", default-features = false, features = ["write-4"] } cortex-m = { version = "0.7" } cortex-m-rt = { version = "0.7" } embedded-storage = "0.3.0" diff --git a/embassy-boot/nrf/src/lib.rs b/embassy-boot/nrf/src/lib.rs index 785cb67e..500cae50 100644 --- a/embassy-boot/nrf/src/lib.rs +++ b/embassy-boot/nrf/src/lib.rs @@ -4,9 +4,7 @@ mod fmt; -pub use embassy_boot::{ - FirmwareUpdater, FlashProvider, Partition, SingleFlashProvider, State, BOOT_MAGIC, -}; +pub use embassy_boot::{FirmwareUpdater, FlashProvider, Partition, SingleFlashProvider}; use embassy_nrf::{ nvmc::{Nvmc, PAGE_SIZE}, peripherals::WDT, @@ -184,29 +182,3 @@ impl<'d> ReadNorFlash for WatchdogFlash<'d> { self.flash.capacity() } } - -pub mod updater { - use super::*; - pub fn new() -> embassy_boot::FirmwareUpdater { - extern "C" { - static __bootloader_state_start: u32; - static __bootloader_state_end: u32; - static __bootloader_dfu_start: u32; - static __bootloader_dfu_end: u32; - } - - let dfu = unsafe { - Partition::new( - &__bootloader_dfu_start as *const u32 as usize, - &__bootloader_dfu_end as *const u32 as usize, - ) - }; - let state = unsafe { - Partition::new( - &__bootloader_state_start as *const u32 as usize, - &__bootloader_state_end as *const u32 as usize, - ) - }; - embassy_boot::FirmwareUpdater::new(dfu, state) - } -} diff --git a/embassy-boot/stm32/Cargo.toml b/embassy-boot/stm32/Cargo.toml new file mode 100644 index 00000000..76bc480b --- /dev/null +++ b/embassy-boot/stm32/Cargo.toml @@ -0,0 +1,65 @@ +[package] +authors = [ + "Ulf Lilleengen <lulf@redhat.com>", +] +edition = "2018" +name = "embassy-boot-stm32" +version = "0.1.0" +description = "Bootloader for STM32 chips" + +[dependencies] +defmt = { version = "0.3", optional = true } +defmt-rtt = { version = "0.3", optional = true } + +embassy = { path = "../../embassy", default-features = false } +embassy-stm32 = { path = "../../embassy-stm32", default-features = false, features = ["nightly"] } +embassy-boot = { path = "../boot", default-features = false } +cortex-m = { version = "0.7" } +cortex-m-rt = { version = "0.7" } +embedded-storage = "0.3.0" +embedded-storage-async = "0.3.0" +cfg-if = "1.0.0" + +[features] +defmt = [ + "dep:defmt", + "embassy-boot/defmt", + "embassy-stm32/defmt", +] +debug = ["defmt-rtt"] +flash-2k = ["embassy-boot/write-8"] +flash-128 = ["embassy-boot/write-4"] +flash-256 = ["embassy-boot/write-4"] +invert-erase = ["embassy-boot/invert-erase"] +thumbv6 = [] + +[profile.dev] +debug = 2 +debug-assertions = true +incremental = false +opt-level = 'z' +overflow-checks = true + +[profile.release] +codegen-units = 1 +debug = 2 +debug-assertions = false +incremental = false +lto = 'fat' +opt-level = 'z' +overflow-checks = false + +# do not optimize proc-macro crates = faster builds from scratch +[profile.dev.build-override] +codegen-units = 8 +debug = false +debug-assertions = false +opt-level = 0 +overflow-checks = false + +[profile.release.build-override] +codegen-units = 8 +debug = false +debug-assertions = false +opt-level = 0 +overflow-checks = false diff --git a/embassy-boot/stm32/README.md b/embassy-boot/stm32/README.md new file mode 100644 index 00000000..a82b730b --- /dev/null +++ b/embassy-boot/stm32/README.md @@ -0,0 +1,11 @@ +# Bootloader for STM32 + +The bootloader uses `embassy-boot` to interact with the flash. + +# Usage + +Flash the bootloader + +``` +cargo flash --features embassy-stm32/stm32wl55jc-cm4 --release --chip STM32WLE5JCIx +``` diff --git a/embassy-boot/stm32/build.rs b/embassy-boot/stm32/build.rs new file mode 100644 index 00000000..fd605991 --- /dev/null +++ b/embassy-boot/stm32/build.rs @@ -0,0 +1,27 @@ +use std::env; +use std::fs::File; +use std::io::Write; +use std::path::PathBuf; + +fn main() { + // Put `memory.x` in our output directory and ensure it's + // on the linker search path. + let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap()); + File::create(out.join("memory.x")) + .unwrap() + .write_all(include_bytes!("memory.x")) + .unwrap(); + println!("cargo:rustc-link-search={}", out.display()); + + // By default, Cargo will re-run a build script whenever + // any file in the project changes. By specifying `memory.x` + // here, we ensure the build script is only re-run when + // `memory.x` is changed. + println!("cargo:rerun-if-changed=memory.x"); + + println!("cargo:rustc-link-arg-bins=--nmagic"); + println!("cargo:rustc-link-arg-bins=-Tlink.x"); + if env::var("CARGO_FEATURE_DEFMT").is_ok() { + println!("cargo:rustc-link-arg-bins=-Tdefmt.x"); + } +} diff --git a/embassy-boot/stm32/memory.x b/embassy-boot/stm32/memory.x new file mode 100644 index 00000000..c5356ed3 --- /dev/null +++ b/embassy-boot/stm32/memory.x @@ -0,0 +1,18 @@ +MEMORY +{ + /* NOTE 1 K = 1 KiBi = 1024 bytes */ + FLASH : ORIGIN = 0x08000000, LENGTH = 24K + BOOTLOADER_STATE : ORIGIN = 0x08006000, LENGTH = 4K + ACTIVE : ORIGIN = 0x08008000, LENGTH = 32K + DFU : ORIGIN = 0x08010000, LENGTH = 36K + RAM (rwx) : ORIGIN = 0x20000008, LENGTH = 16K +} + +__bootloader_state_start = ORIGIN(BOOTLOADER_STATE); +__bootloader_state_end = ORIGIN(BOOTLOADER_STATE) + LENGTH(BOOTLOADER_STATE); + +__bootloader_active_start = ORIGIN(ACTIVE); +__bootloader_active_end = ORIGIN(ACTIVE) + LENGTH(ACTIVE); + +__bootloader_dfu_start = ORIGIN(DFU); +__bootloader_dfu_end = ORIGIN(DFU) + LENGTH(DFU); diff --git a/embassy-boot/stm32/src/fmt.rs b/embassy-boot/stm32/src/fmt.rs new file mode 100644 index 00000000..06697081 --- /dev/null +++ b/embassy-boot/stm32/src/fmt.rs @@ -0,0 +1,225 @@ +#![macro_use] +#![allow(unused_macros)] + +#[cfg(all(feature = "defmt", feature = "log"))] +compile_error!("You may not enable both `defmt` and `log` features."); + +macro_rules! assert { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + ::core::assert!($($x)*); + #[cfg(feature = "defmt")] + ::defmt::assert!($($x)*); + } + }; +} + +macro_rules! assert_eq { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + ::core::assert_eq!($($x)*); + #[cfg(feature = "defmt")] + ::defmt::assert_eq!($($x)*); + } + }; +} + +macro_rules! assert_ne { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + ::core::assert_ne!($($x)*); + #[cfg(feature = "defmt")] + ::defmt::assert_ne!($($x)*); + } + }; +} + +macro_rules! debug_assert { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + ::core::debug_assert!($($x)*); + #[cfg(feature = "defmt")] + ::defmt::debug_assert!($($x)*); + } + }; +} + +macro_rules! debug_assert_eq { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + ::core::debug_assert_eq!($($x)*); + #[cfg(feature = "defmt")] + ::defmt::debug_assert_eq!($($x)*); + } + }; +} + +macro_rules! debug_assert_ne { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + ::core::debug_assert_ne!($($x)*); + #[cfg(feature = "defmt")] + ::defmt::debug_assert_ne!($($x)*); + } + }; +} + +macro_rules! todo { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + ::core::todo!($($x)*); + #[cfg(feature = "defmt")] + ::defmt::todo!($($x)*); + } + }; +} + +macro_rules! unreachable { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + ::core::unreachable!($($x)*); + #[cfg(feature = "defmt")] + ::defmt::unreachable!($($x)*); + } + }; +} + +macro_rules! panic { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + ::core::panic!($($x)*); + #[cfg(feature = "defmt")] + ::defmt::panic!($($x)*); + } + }; +} + +macro_rules! trace { + ($s:literal $(, $x:expr)* $(,)?) => { + { + #[cfg(feature = "log")] + ::log::trace!($s $(, $x)*); + #[cfg(feature = "defmt")] + ::defmt::trace!($s $(, $x)*); + #[cfg(not(any(feature = "log", feature="defmt")))] + let _ = ($( & $x ),*); + } + }; +} + +macro_rules! debug { + ($s:literal $(, $x:expr)* $(,)?) => { + { + #[cfg(feature = "log")] + ::log::debug!($s $(, $x)*); + #[cfg(feature = "defmt")] + ::defmt::debug!($s $(, $x)*); + #[cfg(not(any(feature = "log", feature="defmt")))] + let _ = ($( & $x ),*); + } + }; +} + +macro_rules! info { + ($s:literal $(, $x:expr)* $(,)?) => { + { + #[cfg(feature = "log")] + ::log::info!($s $(, $x)*); + #[cfg(feature = "defmt")] + ::defmt::info!($s $(, $x)*); + #[cfg(not(any(feature = "log", feature="defmt")))] + let _ = ($( & $x ),*); + } + }; +} + +macro_rules! warn { + ($s:literal $(, $x:expr)* $(,)?) => { + { + #[cfg(feature = "log")] + ::log::warn!($s $(, $x)*); + #[cfg(feature = "defmt")] + ::defmt::warn!($s $(, $x)*); + #[cfg(not(any(feature = "log", feature="defmt")))] + let _ = ($( & $x ),*); + } + }; +} + +macro_rules! error { + ($s:literal $(, $x:expr)* $(,)?) => { + { + #[cfg(feature = "log")] + ::log::error!($s $(, $x)*); + #[cfg(feature = "defmt")] + ::defmt::error!($s $(, $x)*); + #[cfg(not(any(feature = "log", feature="defmt")))] + let _ = ($( & $x ),*); + } + }; +} + +#[cfg(feature = "defmt")] +macro_rules! unwrap { + ($($x:tt)*) => { + ::defmt::unwrap!($($x)*) + }; +} + +#[cfg(not(feature = "defmt"))] +macro_rules! unwrap { + ($arg:expr) => { + match $crate::fmt::Try::into_result($arg) { + ::core::result::Result::Ok(t) => t, + ::core::result::Result::Err(e) => { + ::core::panic!("unwrap of `{}` failed: {:?}", ::core::stringify!($arg), e); + } + } + }; + ($arg:expr, $($msg:expr),+ $(,)? ) => { + match $crate::fmt::Try::into_result($arg) { + ::core::result::Result::Ok(t) => t, + ::core::result::Result::Err(e) => { + ::core::panic!("unwrap of `{}` failed: {}: {:?}", ::core::stringify!($arg), ::core::format_args!($($msg,)*), e); + } + } + } +} + +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct NoneError; + +pub trait Try { + type Ok; + type Error; + fn into_result(self) -> Result<Self::Ok, Self::Error>; +} + +impl<T> Try for Option<T> { + type Ok = T; + type Error = NoneError; + + #[inline] + fn into_result(self) -> Result<T, NoneError> { + self.ok_or(NoneError) + } +} + +impl<T, E> Try for Result<T, E> { + type Ok = T; + type Error = E; + + #[inline] + fn into_result(self) -> Self { + self + } +} diff --git a/embassy-boot/stm32/src/lib.rs b/embassy-boot/stm32/src/lib.rs new file mode 100644 index 00000000..d1754a31 --- /dev/null +++ b/embassy-boot/stm32/src/lib.rs @@ -0,0 +1,75 @@ +#![no_std] +#![feature(generic_associated_types)] +#![feature(type_alias_impl_trait)] + +mod fmt; + +pub use embassy_boot::{FirmwareUpdater, FlashProvider, Partition, SingleFlashProvider, State}; + +pub struct BootLoader<const PAGE_SIZE: usize> { + boot: embassy_boot::BootLoader<PAGE_SIZE>, +} + +impl<const PAGE_SIZE: usize> BootLoader<PAGE_SIZE> { + /// Create a new bootloader instance using parameters from linker script + pub fn default() -> Self { + extern "C" { + static __bootloader_state_start: u32; + static __bootloader_state_end: u32; + static __bootloader_active_start: u32; + static __bootloader_active_end: u32; + static __bootloader_dfu_start: u32; + static __bootloader_dfu_end: u32; + } + + let active = unsafe { + Partition::new( + &__bootloader_active_start as *const u32 as usize, + &__bootloader_active_end as *const u32 as usize, + ) + }; + let dfu = unsafe { + Partition::new( + &__bootloader_dfu_start as *const u32 as usize, + &__bootloader_dfu_end as *const u32 as usize, + ) + }; + let state = unsafe { + Partition::new( + &__bootloader_state_start as *const u32 as usize, + &__bootloader_state_end as *const u32 as usize, + ) + }; + + trace!("ACTIVE: 0x{:x} - 0x{:x}", active.from, active.to); + trace!("DFU: 0x{:x} - 0x{:x}", dfu.from, dfu.to); + trace!("STATE: 0x{:x} - 0x{:x}", state.from, state.to); + + Self::new(active, dfu, state) + } + + /// Create a new bootloader instance using the supplied partitions for active, dfu and state. + pub fn new(active: Partition, dfu: Partition, state: Partition) -> Self { + Self { + boot: embassy_boot::BootLoader::new(active, dfu, state), + } + } + + /// Boots the application + pub fn prepare<F: FlashProvider>(&mut self, flash: &mut F) -> usize { + match self.boot.prepare_boot(flash) { + Ok(_) => self.boot.boot_address(), + Err(_) => panic!("boot prepare error!"), + } + } + + pub unsafe fn load(&mut self, start: usize) -> ! { + trace!("Loading app at 0x{:x}", start); + let mut p = cortex_m::Peripherals::steal(); + #[cfg(not(feature = "thumbv6"))] + p.SCB.invalidate_icache(); + p.SCB.vtor.write(start as u32); + + cortex_m::asm::bootload(start as *const u32) + } +} diff --git a/embassy-boot/stm32/src/main.rs b/embassy-boot/stm32/src/main.rs new file mode 100644 index 00000000..6fe0fb66 --- /dev/null +++ b/embassy-boot/stm32/src/main.rs @@ -0,0 +1,62 @@ +#![no_std] +#![no_main] + +use cortex_m_rt::{entry, exception}; + +#[cfg(feature = "defmt")] +use defmt_rtt as _; + +use embassy_boot_stm32::*; +use embassy_stm32::flash::Flash; + +#[cfg(not(any(feature = "flash-2k", feature = "flash-256", feature = "flash-128")))] +compile_error!("No flash size specified. Must specify exactly one of the following features: flash-2k, flash-256, flash-128"); + +#[entry] +fn main() -> ! { + let p = embassy_stm32::init(Default::default()); + + // Uncomment this if you are debugging the bootloader with debugger/RTT attached, + // as it prevents a hard fault when accessing flash 'too early' after boot. + /* + for i in 0..10000000 { + cortex_m::asm::nop(); + } + */ + + #[cfg(feature = "flash-2k")] + let mut bl: BootLoader<2048> = BootLoader::default(); + + #[cfg(feature = "flash-256")] + let mut bl: BootLoader<256> = BootLoader::default(); + + #[cfg(feature = "flash-128")] + let mut bl: BootLoader<128> = BootLoader::default(); + + let mut flash = Flash::unlock(p.FLASH); + let start = bl.prepare(&mut SingleFlashProvider::new(&mut flash)); + core::mem::drop(flash); + unsafe { bl.load(start) } +} + +#[no_mangle] +#[cfg_attr(target_os = "none", link_section = ".HardFault.user")] +unsafe extern "C" fn HardFault() { + cortex_m::peripheral::SCB::sys_reset(); +} + +#[exception] +unsafe fn DefaultHandler(_: i16) -> ! { + const SCB_ICSR: *const u32 = 0xE000_ED04 as *const u32; + let irqn = core::ptr::read_volatile(SCB_ICSR) as u8 as i16 - 16; + + panic!("DefaultHandler #{:?}", irqn); +} + +#[panic_handler] +fn panic(_info: &core::panic::PanicInfo) -> ! { + unsafe { + cortex_m::asm::udf(); + core::hint::unreachable_unchecked(); + } +} |