NaxdyOrg/embassy
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Add region start to flash sectors

Browse source
This commit is contained in:
Rasmus Melchior Jacobsen 2023-03-25 16:03:06 +01:00
parent 73ccc04231
commit 245147634b
2 changed files with 75 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

90
embassy-hal-common/src/stm32/flash/f4.rs
View file

@ -7,6 +7,7 @@ pub const SECOND_BANK_SECTOR_OFFSET: u8 = 12;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub struct FlashSector { pub struct FlashSector {
pub index: u8, pub index: u8,
pub start: u32,
pub size: u32, pub size: u32,
} }
@ -22,7 +23,8 @@ pub fn get_sector(address: u32, dual_bank: bool, flash_size: u32) -> FlashSector
let sector = get_single_bank_sector(offset - bank_size); let sector = get_single_bank_sector(offset - bank_size);
FlashSector { FlashSector {
index: SECOND_BANK_SECTOR_OFFSET + sector.index, index: SECOND_BANK_SECTOR_OFFSET + sector.index,
..sector start: sector.start + bank_size,
size: sector.size,
} }
} }
} }
@ -30,25 +32,31 @@ pub fn get_sector(address: u32, dual_bank: bool, flash_size: u32) -> FlashSector
fn get_single_bank_sector(offset: u32) -> FlashSector { fn get_single_bank_sector(offset: u32) -> FlashSector {
// First 4 sectors are 16KB, then one 64KB, and rest are 128KB // First 4 sectors are 16KB, then one 64KB, and rest are 128KB
match offset / LARGE_SECTOR_SIZE { match offset / LARGE_SECTOR_SIZE {
0 => { 0 => {
if offset < 4 * SMALL_SECTOR_SIZE { if offset < 4 * SMALL_SECTOR_SIZE {
let small_sector_index = offset / SMALL_SECTOR_SIZE;
FlashSector { FlashSector {
index: (offset / SMALL_SECTOR_SIZE) as u8, index: small_sector_index as u8,
start: FLASH_BASE + small_sector_index * SMALL_SECTOR_SIZE,
size: SMALL_SECTOR_SIZE, size: SMALL_SECTOR_SIZE,
} }
} else { } else {
FlashSector { FlashSector {
index: 4, index: 4,
start: FLASH_BASE + 4 * SMALL_SECTOR_SIZE,
size: MEDIUM_SECTOR_SIZE, size: MEDIUM_SECTOR_SIZE,
} }
} }
} }
i => FlashSector { i => {
index: 4 + i as u8, let large_sector_index = i - 1;
size: LARGE_SECTOR_SIZE, FlashSector {
}, index: (5 + large_sector_index) as u8,
start: FLASH_BASE + 4 * SMALL_SECTOR_SIZE + MEDIUM_SECTOR_SIZE + large_sector_index * LARGE_SECTOR_SIZE,
size: LARGE_SECTOR_SIZE,
}
}
} }
} }
@ -58,54 +66,54 @@ mod tests {
#[test] #[test]
fn can_get_sector_single_bank() { fn can_get_sector_single_bank() {
let assert_sector = |index: u8, size: u32, addr: u32| { let assert_sector = |index: u8, start: u32, size: u32, addr: u32| {
assert_eq!(FlashSector { index, size }, get_sector(addr, false, 1024 * 1024)) assert_eq!(FlashSector { index, start, size }, get_sector(addr, false, 1024 * 1024))
}; };
assert_sector(0, SMALL_SECTOR_SIZE, 0x0800_0000); assert_sector(0, 0x0800_0000, SMALL_SECTOR_SIZE, 0x0800_0000);
assert_sector(0, SMALL_SECTOR_SIZE, 0x0800_3FFF); assert_sector(0, 0x0800_0000, SMALL_SECTOR_SIZE, 0x0800_3FFF);
assert_sector(3, SMALL_SECTOR_SIZE, 0x0800_C000); assert_sector(3, 0x0800_C000, SMALL_SECTOR_SIZE, 0x0800_C000);
assert_sector(3, SMALL_SECTOR_SIZE, 0x0800_FFFF); assert_sector(3, 0x0800_C000, SMALL_SECTOR_SIZE, 0x0800_FFFF);
assert_sector(4, MEDIUM_SECTOR_SIZE, 0x0801_0000); assert_sector(4, 0x0801_0000, MEDIUM_SECTOR_SIZE, 0x0801_0000);
assert_sector(4, MEDIUM_SECTOR_SIZE, 0x0801_FFFF); assert_sector(4, 0x0801_0000, MEDIUM_SECTOR_SIZE, 0x0801_FFFF);
assert_sector(5, LARGE_SECTOR_SIZE, 0x0802_0000); assert_sector(5, 0x0802_0000, LARGE_SECTOR_SIZE, 0x0802_0000);
assert_sector(5, LARGE_SECTOR_SIZE, 0x0803_FFFF); assert_sector(5, 0x0802_0000, LARGE_SECTOR_SIZE, 0x0803_FFFF);
assert_sector(11, LARGE_SECTOR_SIZE, 0x080E_0000); assert_sector(11, 0x080E_0000, LARGE_SECTOR_SIZE, 0x080E_0000);
assert_sector(11, LARGE_SECTOR_SIZE, 0x080F_FFFF); assert_sector(11, 0x080E_0000, LARGE_SECTOR_SIZE, 0x080F_FFFF);
} }
#[test] #[test]
fn can_get_sector_dual_bank() { fn can_get_sector_dual_bank() {
let assert_sector = |index: u8, size: u32, addr: u32| { let assert_sector = |index: u8, start: u32, size: u32, addr: u32| {
assert_eq!(FlashSector { index, size }, get_sector(addr, true, 1024 * 1024)) assert_eq!(FlashSector { index, start, size }, get_sector(addr, true, 1024 * 1024))
}; };
assert_sector(0, SMALL_SECTOR_SIZE, 0x0800_0000); assert_sector(0, 0x0800_0000, SMALL_SECTOR_SIZE, 0x0800_0000);
assert_sector(0, SMALL_SECTOR_SIZE, 0x0800_3FFF); assert_sector(0, 0x0800_0000, SMALL_SECTOR_SIZE, 0x0800_3FFF);
assert_sector(3, SMALL_SECTOR_SIZE, 0x0800_C000); assert_sector(3, 0x0800_C000, SMALL_SECTOR_SIZE, 0x0800_C000);
assert_sector(3, SMALL_SECTOR_SIZE, 0x0800_FFFF); assert_sector(3, 0x0800_C000, SMALL_SECTOR_SIZE, 0x0800_FFFF);
assert_sector(4, MEDIUM_SECTOR_SIZE, 0x0801_0000); assert_sector(4, 0x0801_0000, MEDIUM_SECTOR_SIZE, 0x0801_0000);
assert_sector(4, MEDIUM_SECTOR_SIZE, 0x0801_FFFF); assert_sector(4, 0x0801_0000, MEDIUM_SECTOR_SIZE, 0x0801_FFFF);
assert_sector(5, LARGE_SECTOR_SIZE, 0x0802_0000); assert_sector(5, 0x0802_0000, LARGE_SECTOR_SIZE, 0x0802_0000);
assert_sector(5, LARGE_SECTOR_SIZE, 0x0803_FFFF); assert_sector(5, 0x0802_0000, LARGE_SECTOR_SIZE, 0x0803_FFFF);
assert_sector(7, LARGE_SECTOR_SIZE, 0x0806_0000); assert_sector(7, 0x0806_0000, LARGE_SECTOR_SIZE, 0x0806_0000);
assert_sector(7, LARGE_SECTOR_SIZE, 0x0807_FFFF); assert_sector(7, 0x0806_0000, LARGE_SECTOR_SIZE, 0x0807_FFFF);
assert_sector(12, SMALL_SECTOR_SIZE, 0x0808_0000); assert_sector(12, 0x0808_0000, SMALL_SECTOR_SIZE, 0x0808_0000);
assert_sector(12, SMALL_SECTOR_SIZE, 0x0808_3FFF); assert_sector(12, 0x0808_0000, SMALL_SECTOR_SIZE, 0x0808_3FFF);
assert_sector(15, SMALL_SECTOR_SIZE, 0x0808_C000); assert_sector(15, 0x0808_C000, SMALL_SECTOR_SIZE, 0x0808_C000);
assert_sector(15, SMALL_SECTOR_SIZE, 0x0808_FFFF); assert_sector(15, 0x0808_C000, SMALL_SECTOR_SIZE, 0x0808_FFFF);
assert_sector(16, MEDIUM_SECTOR_SIZE, 0x0809_0000); assert_sector(16, 0x0809_0000, MEDIUM_SECTOR_SIZE, 0x0809_0000);
assert_sector(16, MEDIUM_SECTOR_SIZE, 0x0809_FFFF); assert_sector(16, 0x0809_0000, MEDIUM_SECTOR_SIZE, 0x0809_FFFF);
assert_sector(17, LARGE_SECTOR_SIZE, 0x080A_0000); assert_sector(17, 0x080A_0000, LARGE_SECTOR_SIZE, 0x080A_0000);
assert_sector(17, LARGE_SECTOR_SIZE, 0x080B_FFFF); assert_sector(17, 0x080A_0000, LARGE_SECTOR_SIZE, 0x080B_FFFF);
assert_sector(19, LARGE_SECTOR_SIZE, 0x080E_0000); assert_sector(19, 0x080E_0000, LARGE_SECTOR_SIZE, 0x080E_0000);
assert_sector(19, LARGE_SECTOR_SIZE, 0x080F_FFFF); assert_sector(19, 0x080E_0000, LARGE_SECTOR_SIZE, 0x080F_FFFF);
} }
} }

42
embassy-hal-common/src/stm32/flash/f7.rs
View file

@ -6,6 +6,7 @@ pub(crate) const LARGE_SECTOR_SIZE: u32 = 256 * 1024;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub struct FlashSector { pub struct FlashSector {
pub index: u8, pub index: u8,
pub start: u32,
pub size: u32, pub size: u32,
} }
@ -15,21 +16,28 @@ pub fn get_sector(address: u32) -> FlashSector {
match offset / LARGE_SECTOR_SIZE { match offset / LARGE_SECTOR_SIZE {
0 => { 0 => {
if offset < 4 * SMALL_SECTOR_SIZE { if offset < 4 * SMALL_SECTOR_SIZE {
let small_sector_index = offset / SMALL_SECTOR_SIZE;
FlashSector { FlashSector {
index: (offset / SMALL_SECTOR_SIZE) as u8, index: small_sector_index as u8,
start: FLASH_BASE + small_sector_index * SMALL_SECTOR_SIZE,
size: SMALL_SECTOR_SIZE, size: SMALL_SECTOR_SIZE,
} }
} else { } else {
FlashSector { FlashSector {
index: 4, index: 4,
start: FLASH_BASE + 4 * SMALL_SECTOR_SIZE,
size: MEDIUM_SECTOR_SIZE, size: MEDIUM_SECTOR_SIZE,
} }
} }
} }
i => FlashSector { i => {
index: 4 + i as u8, let large_sector_index = i - 1;
size: LARGE_SECTOR_SIZE, FlashSector {
}, index: (5 + large_sector_index) as u8,
start: FLASH_BASE + 4 * SMALL_SECTOR_SIZE + MEDIUM_SECTOR_SIZE + large_sector_index * LARGE_SECTOR_SIZE,
size: LARGE_SECTOR_SIZE,
}
}
} }
} }
@ -39,19 +47,21 @@ mod tests {
#[test] #[test]
fn can_get_sector() { fn can_get_sector() {
let assert_sector = |index: u8, size: u32, addr: u32| assert_eq!(FlashSector { index, size }, get_sector(addr)); let assert_sector = |index: u8, start: u32, size: u32, addr: u32| {
assert_eq!(FlashSector { index, start, size }, get_sector(addr))
};
assert_sector(0, SMALL_SECTOR_SIZE, 0x0800_0000); assert_sector(0, 0x0800_0000, SMALL_SECTOR_SIZE, 0x0800_0000);
assert_sector(0, SMALL_SECTOR_SIZE, 0x0800_7FFF); assert_sector(0, 0x0800_0000, SMALL_SECTOR_SIZE, 0x0800_7FFF);
assert_sector(3, SMALL_SECTOR_SIZE, 0x0801_8000); assert_sector(3, 0x0801_8000, SMALL_SECTOR_SIZE, 0x0801_8000);
assert_sector(3, SMALL_SECTOR_SIZE, 0x0801_FFFF); assert_sector(3, 0x0801_8000, SMALL_SECTOR_SIZE, 0x0801_FFFF);
assert_sector(4, MEDIUM_SECTOR_SIZE, 0x0802_0000); assert_sector(4, 0x0802_0000, MEDIUM_SECTOR_SIZE, 0x0802_0000);
assert_sector(4, MEDIUM_SECTOR_SIZE, 0x0803_FFFF); assert_sector(4, 0x0802_0000, MEDIUM_SECTOR_SIZE, 0x0803_FFFF);
assert_sector(5, LARGE_SECTOR_SIZE, 0x0804_0000); assert_sector(5, 0x0804_0000, LARGE_SECTOR_SIZE, 0x0804_0000);
assert_sector(5, LARGE_SECTOR_SIZE, 0x0807_FFFF); assert_sector(5, 0x0804_0000, LARGE_SECTOR_SIZE, 0x0807_FFFF);
assert_sector(7, LARGE_SECTOR_SIZE, 0x080C_0000); assert_sector(7, 0x080C_0000, LARGE_SECTOR_SIZE, 0x080C_0000);
assert_sector(7, LARGE_SECTOR_SIZE, 0x080F_FFFF); assert_sector(7, 0x080C_0000, LARGE_SECTOR_SIZE, 0x080F_FFFF);
} }
} }