max/embassy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Align stm32

Browse Source
This commit is contained in:
Rasmus Melchior Jacobsen 2023-05-30 13:57:19 +02:00
parent 24dee870a8
commit 887ecef369
1 changed files with 17 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
embassy-boot/stm32/src/lib.rs
View File

@ -3,30 +3,34 @@
#![doc = include_str!("../README.md")] #![doc = include_str!("../README.md")]
mod fmt; mod fmt;
pub use embassy_boot::{AlignedBuffer, BootFlash, FirmwareUpdater, FlashConfig, Partition, SingleFlashConfig, State}; #[cfg(feature = "nightly")]
pub use embassy_boot::FirmwareUpdater;
pub use embassy_boot::{AlignedBuffer, BlockingFirmwareUpdater, BootLoaderConfig, FirmwareUpdaterConfig, State};
use embedded_storage::nor_flash::NorFlash;
/// A bootloader for STM32 devices. /// A bootloader for STM32 devices.
pub struct BootLoader<const BUFFER_SIZE: usize> { pub struct BootLoader<ACTIVE: NorFlash, DFU: NorFlash, STATE: NorFlash, const BUFFER_SIZE: usize> {
boot: embassy_boot::BootLoader, boot: embassy_boot::BootLoader<ACTIVE, DFU, STATE>,
aligned_buf: AlignedBuffer<BUFFER_SIZE>, aligned_buf: AlignedBuffer<BUFFER_SIZE>,
} }
impl<const BUFFER_SIZE: usize> BootLoader<BUFFER_SIZE> { impl<ACTIVE: NorFlash, DFU: NorFlash, STATE: NorFlash, const BUFFER_SIZE: usize>
BootLoader<ACTIVE, DFU, STATE, BUFFER_SIZE>
{
/// Create a new bootloader instance using the supplied partitions for active, dfu and 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 { pub fn new(config: BootLoaderConfig<ACTIVE, DFU, STATE>) -> Self {
Self { Self {
boot: embassy_boot::BootLoader::new(active, dfu, state), boot: embassy_boot::BootLoader::new(config),
aligned_buf: AlignedBuffer([0; BUFFER_SIZE]), aligned_buf: AlignedBuffer([0; BUFFER_SIZE]),
} }
} }
/// Inspect the bootloader state and perform actions required before booting, such as swapping /// Inspect the bootloader state and perform actions required before booting, such as swapping
/// firmware. /// firmware.
pub fn prepare<F: FlashConfig>(&mut self, flash: &mut F) -> usize { pub fn prepare(&mut self) {
match self.boot.prepare_boot(flash, self.aligned_buf.as_mut()) { self.boot
Ok(_) => embassy_stm32::flash::FLASH_BASE + self.boot.boot_address(), .prepare_boot(self.aligned_buf.as_mut())
Err(_) => panic!("boot prepare error!"), .expect("Boot prepare error");
}
} }
/// Boots the application. /// Boots the application.
@ -34,54 +38,14 @@ impl<const BUFFER_SIZE: usize> BootLoader<BUFFER_SIZE> {
/// # Safety /// # Safety
/// ///
/// This modifies the stack pointer and reset vector and will run code placed in the active partition. /// This modifies the stack pointer and reset vector and will run code placed in the active partition.
pub unsafe fn load(&mut self, start: usize) -> ! { pub unsafe fn load(&mut self, start: u32) -> ! {
trace!("Loading app at 0x{:x}", start); trace!("Loading app at 0x{:x}", start);
#[allow(unused_mut)] #[allow(unused_mut)]
let mut p = cortex_m::Peripherals::steal(); let mut p = cortex_m::Peripherals::steal();
#[cfg(not(armv6m))] #[cfg(not(armv6m))]
p.SCB.invalidate_icache(); p.SCB.invalidate_icache();
p.SCB.vtor.write(start as u32); p.SCB.vtor.write(start);
cortex_m::asm::bootload(start as *const u32) cortex_m::asm::bootload(start as *const u32)
} }
} }
#[cfg(target_os = "none")]
impl<const BUFFER_SIZE: usize> Default for BootLoader<BUFFER_SIZE> {
/// Create a new bootloader instance using parameters from linker script
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 u32,
&__bootloader_active_end as *const u32 as u32,
)
};
let dfu = unsafe {
Partition::new(
&__bootloader_dfu_start as *const u32 as u32,
&__bootloader_dfu_end as *const u32 as u32,
)
};
let state = unsafe {
Partition::new(
&__bootloader_state_start as *const u32 as u32,
&__bootloader_state_end as *const u32 as u32,
)
};
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)
}
}