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

Support running tests in embassy-stm32 and move impl from common back to stm32

Browse Source
This commit is contained in:
Rasmus Melchior Jacobsen
2023-03-29 11:31:45 +02:00
parent e9a5b31fa8
commit d6ce1c4325
9 changed files with 186 additions and 197 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
embassy-stm32/src/flash/f4.rs
View File

@ -2,12 +2,15 @@ use core::convert::TryInto;
use core::ptr::write_volatile;
use core::sync::atomic::{fence, Ordering};
use embassy_hal_common::stm32::flash::f4::{get_sector, SECOND_BANK_SECTOR_OFFSET};
use super::{FLASH_SIZE, WRITE_SIZE};
use super::{FlashSector, FLASH_BASE, FLASH_SIZE, WRITE_SIZE};
use crate::flash::Error;
use crate::pac;
const SMALL_SECTOR_SIZE: u32 = 16 * 1024;
const MEDIUM_SECTOR_SIZE: u32 = 64 * 1024;
const LARGE_SECTOR_SIZE: u32 = 128 * 1024;
const SECOND_BANK_SECTOR_OFFSET: u8 = 12;
fn is_dual_bank() -> bool {
match FLASH_SIZE / 1024 {
// 1 MB devices depend on configuration
@ -141,3 +144,110 @@ unsafe fn blocking_wait_ready() -> Result<(), Error> {
}
}
}
fn get_sector(address: u32, dual_bank: bool, flash_size: u32) -> FlashSector {
let offset = address - FLASH_BASE as u32;
if !dual_bank {
get_single_bank_sector(offset)
} else {
let bank_size = flash_size / 2;
if offset < bank_size {
get_single_bank_sector(offset)
} else {
let sector = get_single_bank_sector(offset - bank_size);
FlashSector {
index: SECOND_BANK_SECTOR_OFFSET + sector.index,
start: sector.start + bank_size,
size: sector.size,
}
}
}
}
fn get_single_bank_sector(offset: u32) -> FlashSector {
// First 4 sectors are 16KB, then one 64KB, and rest are 128KB
match offset / LARGE_SECTOR_SIZE {
0 => {
if offset < 4 * SMALL_SECTOR_SIZE {
let small_sector_index = offset / SMALL_SECTOR_SIZE;
FlashSector {
index: small_sector_index as u8,
start: FLASH_BASE as u32 + small_sector_index * SMALL_SECTOR_SIZE,
size: SMALL_SECTOR_SIZE,
}
} else {
FlashSector {
index: 4,
start: FLASH_BASE as u32 + 4 * SMALL_SECTOR_SIZE,
size: MEDIUM_SECTOR_SIZE,
}
}
}
i => {
let large_sector_index = i - 1;
FlashSector {
index: (5 + large_sector_index) as u8,
start: FLASH_BASE as u32 + 4 * SMALL_SECTOR_SIZE + MEDIUM_SECTOR_SIZE + large_sector_index * LARGE_SECTOR_SIZE,
size: LARGE_SECTOR_SIZE,
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn can_get_sector_single_bank() {
let assert_sector = |index: u8, start: u32, size: u32, addr: u32| {
assert_eq!(FlashSector { index, start, size }, get_sector(addr, false, 1024 * 1024))
};
assert_sector(0, 0x0800_0000, SMALL_SECTOR_SIZE, 0x0800_0000);
assert_sector(0, 0x0800_0000, SMALL_SECTOR_SIZE, 0x0800_3FFF);
assert_sector(3, 0x0800_C000, SMALL_SECTOR_SIZE, 0x0800_C000);
assert_sector(3, 0x0800_C000, SMALL_SECTOR_SIZE, 0x0800_FFFF);
assert_sector(4, 0x0801_0000, MEDIUM_SECTOR_SIZE, 0x0801_0000);
assert_sector(4, 0x0801_0000, MEDIUM_SECTOR_SIZE, 0x0801_FFFF);
assert_sector(5, 0x0802_0000, LARGE_SECTOR_SIZE, 0x0802_0000);
assert_sector(5, 0x0802_0000, LARGE_SECTOR_SIZE, 0x0803_FFFF);
assert_sector(11, 0x080E_0000, LARGE_SECTOR_SIZE, 0x080E_0000);
assert_sector(11, 0x080E_0000, LARGE_SECTOR_SIZE, 0x080F_FFFF);
}
#[test]
fn can_get_sector_dual_bank() {
let assert_sector = |index: u8, start: u32, size: u32, addr: u32| {
assert_eq!(FlashSector { index, start, size }, get_sector(addr, true, 1024 * 1024))
};
assert_sector(0, 0x0800_0000, SMALL_SECTOR_SIZE, 0x0800_0000);
assert_sector(0, 0x0800_0000, SMALL_SECTOR_SIZE, 0x0800_3FFF);
assert_sector(3, 0x0800_C000, SMALL_SECTOR_SIZE, 0x0800_C000);
assert_sector(3, 0x0800_C000, SMALL_SECTOR_SIZE, 0x0800_FFFF);
assert_sector(4, 0x0801_0000, MEDIUM_SECTOR_SIZE, 0x0801_0000);
assert_sector(4, 0x0801_0000, MEDIUM_SECTOR_SIZE, 0x0801_FFFF);
assert_sector(5, 0x0802_0000, LARGE_SECTOR_SIZE, 0x0802_0000);
assert_sector(5, 0x0802_0000, LARGE_SECTOR_SIZE, 0x0803_FFFF);
assert_sector(7, 0x0806_0000, LARGE_SECTOR_SIZE, 0x0806_0000);
assert_sector(7, 0x0806_0000, LARGE_SECTOR_SIZE, 0x0807_FFFF);
assert_sector(12, 0x0808_0000, SMALL_SECTOR_SIZE, 0x0808_0000);
assert_sector(12, 0x0808_0000, SMALL_SECTOR_SIZE, 0x0808_3FFF);
assert_sector(15, 0x0808_C000, SMALL_SECTOR_SIZE, 0x0808_C000);
assert_sector(15, 0x0808_C000, SMALL_SECTOR_SIZE, 0x0808_FFFF);
assert_sector(16, 0x0809_0000, MEDIUM_SECTOR_SIZE, 0x0809_0000);
assert_sector(16, 0x0809_0000, MEDIUM_SECTOR_SIZE, 0x0809_FFFF);
assert_sector(17, 0x080A_0000, LARGE_SECTOR_SIZE, 0x080A_0000);
assert_sector(17, 0x080A_0000, LARGE_SECTOR_SIZE, 0x080B_FFFF);
assert_sector(19, 0x080E_0000, LARGE_SECTOR_SIZE, 0x080E_0000);
assert_sector(19, 0x080E_0000, LARGE_SECTOR_SIZE, 0x080F_FFFF);
}
}

64
embassy-stm32/src/flash/f7.rs
View File

@ -2,12 +2,14 @@ use core::convert::TryInto;
use core::ptr::write_volatile;
use core::sync::atomic::{fence, Ordering};
use embassy_hal_common::stm32::flash::f7::get_sector;
use super::WRITE_SIZE;
use super::{FlashSector, FLASH_BASE, WRITE_SIZE};
use crate::flash::Error;
use crate::pac;
const SMALL_SECTOR_SIZE: u32 = 32 * 1024;
const MEDIUM_SECTOR_SIZE: u32 = 128 * 1024;
const LARGE_SECTOR_SIZE: u32 = 256 * 1024;
pub(crate) unsafe fn lock() {
pac::FLASH.cr().modify(|w| w.set_lock(true));
}
@ -129,3 +131,59 @@ unsafe fn blocking_wait_ready() -> Result<(), Error> {
}
}
}
fn get_sector(address: u32) -> FlashSector {
// First 4 sectors are 32KB, then one 128KB, and rest are 256KB
let offset = address - FLASH_BASE as u32;
match offset / LARGE_SECTOR_SIZE {
0 => {
if offset < 4 * SMALL_SECTOR_SIZE {
let small_sector_index = offset / SMALL_SECTOR_SIZE;
FlashSector {
index: small_sector_index as u8,
start: FLASH_BASE as u32 + small_sector_index * SMALL_SECTOR_SIZE,
size: SMALL_SECTOR_SIZE,
}
} else {
FlashSector {
index: 4,
start: FLASH_BASE as u32 + 4 * SMALL_SECTOR_SIZE,
size: MEDIUM_SECTOR_SIZE,
}
}
}
i => {
let large_sector_index = i - 1;
FlashSector {
index: (5 + large_sector_index) as u8,
start: FLASH_BASE as u32 + 4 * SMALL_SECTOR_SIZE + MEDIUM_SECTOR_SIZE + large_sector_index * LARGE_SECTOR_SIZE,
size: LARGE_SECTOR_SIZE,
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn can_get_sector() {
let assert_sector = |index: u8, start: u32, size: u32, addr: u32| {
assert_eq!(FlashSector { index, start, size }, get_sector(addr))
};
assert_sector(0, 0x0800_0000, SMALL_SECTOR_SIZE, 0x0800_0000);
assert_sector(0, 0x0800_0000, SMALL_SECTOR_SIZE, 0x0800_7FFF);
assert_sector(3, 0x0801_8000, SMALL_SECTOR_SIZE, 0x0801_8000);
assert_sector(3, 0x0801_8000, SMALL_SECTOR_SIZE, 0x0801_FFFF);
assert_sector(4, 0x0802_0000, MEDIUM_SECTOR_SIZE, 0x0802_0000);
assert_sector(4, 0x0802_0000, MEDIUM_SECTOR_SIZE, 0x0803_FFFF);
assert_sector(5, 0x0804_0000, LARGE_SECTOR_SIZE, 0x0804_0000);
assert_sector(5, 0x0804_0000, LARGE_SECTOR_SIZE, 0x0807_FFFF);
assert_sector(7, 0x080C_0000, LARGE_SECTOR_SIZE, 0x080C_0000);
assert_sector(7, 0x080C_0000, LARGE_SECTOR_SIZE, 0x080F_FFFF);
}
}

7
embassy-stm32/src/flash/mod.rs
View File

@ -19,6 +19,13 @@ pub struct Flash<'d> {
_inner: PeripheralRef<'d, FLASH>,
}
#[derive(Debug, PartialEq)]
pub struct FlashSector {
pub index: u8,
pub start: u32,
pub size: u32,
}
static REGION_LOCK: Mutex<CriticalSectionRawMutex, ()> = Mutex::new(());
impl<'d> Flash<'d> {