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

embassy-stm32/src/flash/f4.rs

@@ -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);
+    }
+}