Add region start to flash sectors

2 files changed, 75 insertions, 57 deletions

diff --git a/embassy-hal-common/src/stm32/flash/f4.rs b/embassy-hal-common/src/stm32/flash/f4.rs
index 44d6c08c4..a8069dddf 100644
--- a/embassy-hal-common/src/stm32/flash/f4.rs
+++ b/embassy-hal-common/src/stm32/flash/f4.rs
@@ -7,6 +7,7 @@ pub const SECOND_BANK_SECTOR_OFFSET: u8 = 12;
 #[derive(Debug, PartialEq)]
 pub struct FlashSector {
     pub index: u8,
+    pub start: 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);
             FlashSector {
                 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 {
     // 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: (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,
                 }
             } else {
                 FlashSector {
                     index: 4,
+                    start: FLASH_BASE + 4 * SMALL_SECTOR_SIZE,
                     size: MEDIUM_SECTOR_SIZE,
                 }
             }
         }
-        i => FlashSector {
-            index: 4 + i as u8,
-            size: LARGE_SECTOR_SIZE,
-        },
+        i => {
+            let large_sector_index = i - 1;
+            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]
     fn can_get_sector_single_bank() {
-        let assert_sector = |index: u8, size: u32, addr: u32| {
-            assert_eq!(FlashSector { index, size }, get_sector(addr, false, 1024 * 1024))
+        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, SMALL_SECTOR_SIZE, 0x0800_0000);
-        assert_sector(0, SMALL_SECTOR_SIZE, 0x0800_3FFF);
-        assert_sector(3, SMALL_SECTOR_SIZE, 0x0800_C000);
-        assert_sector(3, SMALL_SECTOR_SIZE, 0x0800_FFFF);
+        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, MEDIUM_SECTOR_SIZE, 0x0801_0000);
-        assert_sector(4, MEDIUM_SECTOR_SIZE, 0x0801_FFFF);
+        assert_sector(4, 0x0801_0000, MEDIUM_SECTOR_SIZE, 0x0801_0000);
+        assert_sector(4, 0x0801_0000, MEDIUM_SECTOR_SIZE, 0x0801_FFFF);
 
-        assert_sector(5, LARGE_SECTOR_SIZE, 0x0802_0000);
-        assert_sector(5, LARGE_SECTOR_SIZE, 0x0803_FFFF);
-        assert_sector(11, LARGE_SECTOR_SIZE, 0x080E_0000);
-        assert_sector(11, LARGE_SECTOR_SIZE, 0x080F_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, size: u32, addr: u32| {
-            assert_eq!(FlashSector { index, size }, get_sector(addr, true, 1024 * 1024))
+        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, SMALL_SECTOR_SIZE, 0x0800_0000);
-        assert_sector(0, SMALL_SECTOR_SIZE, 0x0800_3FFF);
-        assert_sector(3, SMALL_SECTOR_SIZE, 0x0800_C000);
-        assert_sector(3, SMALL_SECTOR_SIZE, 0x0800_FFFF);
+        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, MEDIUM_SECTOR_SIZE, 0x0801_0000);
-        assert_sector(4, MEDIUM_SECTOR_SIZE, 0x0801_FFFF);
+        assert_sector(4, 0x0801_0000, MEDIUM_SECTOR_SIZE, 0x0801_0000);
+        assert_sector(4, 0x0801_0000, MEDIUM_SECTOR_SIZE, 0x0801_FFFF);
 
-        assert_sector(5, LARGE_SECTOR_SIZE, 0x0802_0000);
-        assert_sector(5, LARGE_SECTOR_SIZE, 0x0803_FFFF);
-        assert_sector(7, LARGE_SECTOR_SIZE, 0x0806_0000);
-        assert_sector(7, LARGE_SECTOR_SIZE, 0x0807_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, SMALL_SECTOR_SIZE, 0x0808_0000);
-        assert_sector(12, SMALL_SECTOR_SIZE, 0x0808_3FFF);
-        assert_sector(15, SMALL_SECTOR_SIZE, 0x0808_C000);
-        assert_sector(15, SMALL_SECTOR_SIZE, 0x0808_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, MEDIUM_SECTOR_SIZE, 0x0809_0000);
-        assert_sector(16, MEDIUM_SECTOR_SIZE, 0x0809_FFFF);
+        assert_sector(16, 0x0809_0000, MEDIUM_SECTOR_SIZE, 0x0809_0000);
+        assert_sector(16, 0x0809_0000, MEDIUM_SECTOR_SIZE, 0x0809_FFFF);
 
-        assert_sector(17, LARGE_SECTOR_SIZE, 0x080A_0000);
-        assert_sector(17, LARGE_SECTOR_SIZE, 0x080B_FFFF);
-        assert_sector(19, LARGE_SECTOR_SIZE, 0x080E_0000);
-        assert_sector(19, LARGE_SECTOR_SIZE, 0x080F_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);
     }
 }
diff --git a/embassy-hal-common/src/stm32/flash/f7.rs b/embassy-hal-common/src/stm32/flash/f7.rs
index 90938e6ab..2f586adee 100644
--- a/embassy-hal-common/src/stm32/flash/f7.rs
+++ b/embassy-hal-common/src/stm32/flash/f7.rs
@@ -6,6 +6,7 @@ pub(crate) const LARGE_SECTOR_SIZE: u32 = 256 * 1024;
 #[derive(Debug, PartialEq)]
 pub struct FlashSector {
     pub index: u8,
+    pub start: u32,
     pub size: u32,
 }
 
@@ -15,21 +16,28 @@ pub fn get_sector(address: u32) -> FlashSector {
     match offset / LARGE_SECTOR_SIZE {
         0 => {
             if offset < 4 * SMALL_SECTOR_SIZE {
+                let small_sector_index = offset / SMALL_SECTOR_SIZE;
                 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,
                 }
             } else {
                 FlashSector {
                     index: 4,
+                    start: FLASH_BASE + 4 * SMALL_SECTOR_SIZE,
                     size: MEDIUM_SECTOR_SIZE,
                 }
             }
         }
-        i => FlashSector {
-            index: 4 + i as u8,
-            size: LARGE_SECTOR_SIZE,
-        },
+        i => {
+            let large_sector_index = i - 1;
+            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]
     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, SMALL_SECTOR_SIZE, 0x0800_7FFF);
-        assert_sector(3, SMALL_SECTOR_SIZE, 0x0801_8000);
-        assert_sector(3, SMALL_SECTOR_SIZE, 0x0801_FFFF);
+        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, MEDIUM_SECTOR_SIZE, 0x0802_0000);
-        assert_sector(4, MEDIUM_SECTOR_SIZE, 0x0803_FFFF);
+        assert_sector(4, 0x0802_0000, MEDIUM_SECTOR_SIZE, 0x0802_0000);
+        assert_sector(4, 0x0802_0000, MEDIUM_SECTOR_SIZE, 0x0803_FFFF);
 
-        assert_sector(5, LARGE_SECTOR_SIZE, 0x0804_0000);
-        assert_sector(5, LARGE_SECTOR_SIZE, 0x0807_FFFF);
-        assert_sector(7, LARGE_SECTOR_SIZE, 0x080C_0000);
-        assert_sector(7, LARGE_SECTOR_SIZE, 0x080F_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);
     }
 }