implement undocumented system erase and write

Author: aq1018

algos/v3/src/bin/sys.rs

@@ -18,7 +18,7 @@ algorithm!(Algo, {
     program_time_out: PROGRAM_TIMEOUT_MS,
     erase_time_out: ERASE_TIMEOUT_MS,
     sectors: [{
-        size: SYS_PAGE_SIZE,
+        size: SYS_ERASE_SIZE,
         address: SYS_BASE,
     }]
 });
@@ -34,12 +34,12 @@ impl FlashAlgorithm for Algo {
     }
 
     fn erase_sector(&mut self, addr: u32) -> Result<(), ErrorCode> {
-        fast_page_erase(addr, SYS_PAGE_SIZE);
+        boot_page_erase(addr);
         Ok(())
     }
 
     fn program_page(&mut self, addr: u32, data: &[u8]) -> Result<(), ErrorCode> {
-        fast_page_program(addr, data, SYS_PAGE_SIZE, SYS_LOAD);
+        boot_page_program(addr, data, SYS_LOAD);
         Ok(())
     }
 }

algos/v3/src/lib.rs

@@ -11,6 +11,8 @@ pub const SYS_BASE: u32 = region("SYS_1").address;
 const SYS_FAST: (u32, u32) = fast(region("SYS_1"));
 pub const SYS_PAGE_SIZE: u32 = SYS_FAST.0;
 pub const SYS_LOAD: u32 = SYS_FAST.1;
+const SYS_STD: (u32, u32) = standard(region("SYS_1"));
+pub const SYS_ERASE_SIZE: u32 = SYS_STD.0;
 
 pub const OPT_BASE: u32 = region("OPT").address;
 const OPT_STD: (u32, u32) = standard(region("OPT"));
@@ -78,6 +80,50 @@ pub fn fast_page_program(addr: u32, data: &[u8], _page_size: u32, load_size: u32
     FLASH.ctlr().modify(|w| w.set_page_pg(false));
 }
 
+/// SYS uses standard PER (4 KB) + BTER; FTER silently no-ops on this region.
+pub fn boot_page_erase(addr: u32) {
+    wait_busy();
+    FLASH.ctlr().modify(|w| {
+        w.set_per(true);
+        w.set_bter(true);
+    });
+    FLASH.addr().write(|w| w.set_far(addr));
+    FLASH.ctlr().modify(|w| w.set_strt(true));
+    wait_busy();
+    FLASH.ctlr().modify(|w| {
+        w.set_per(false);
+        w.set_bter(false);
+    });
+}
+
+/// `fast_page_program` with BTPG OR-ed in; without it the word write to
+/// 0x1FFF8000 faults and WR_BSY never clears.
+pub fn boot_page_program(addr: u32, data: &[u8], load_size: u32) {
+    wait_busy();
+    FLASH.ctlr().modify(|w| {
+        w.set_page_pg(true);
+        w.set_btpg(true);
+    });
+
+    let mut cur = addr;
+    let mut src = data.as_ptr() as *const u32;
+    let words = data.len() as u32 / load_size;
+    for _ in 0..words {
+        let v = unsafe { src.read() };
+        unsafe { core::ptr::write_volatile(cur as *mut u32, v) };
+        wait_wr_busy();
+        cur += load_size;
+        src = unsafe { src.add(1) };
+    }
+
+    FLASH.ctlr().modify(|w| w.set_pgstart(true));
+    wait_busy();
+    FLASH.ctlr().modify(|w| {
+        w.set_page_pg(false);
+        w.set_btpg(false);
+    });
+}
+
 pub fn mass_erase() {
     wait_busy();
     FLASH.ctlr().modify(|w| w.set_mer(true));

xtask/src/algo.rs

@@ -1,5 +1,5 @@
 use anyhow::{Context, Result, anyhow, bail};
-use probe_rs_target::{FlashProperties, RawFlashAlgorithm};
+use probe_rs_target::{FlashProperties, RawFlashAlgorithm, SectorDescription};
 use std::collections::HashMap;
 use std::path::Path;
 use std::process::Command;
@@ -243,7 +243,14 @@ fn extract_algo(buf: &[u8]) -> Result<RawFlashAlgorithm> {
         erased_byte_value: dev.erased,
         program_page_timeout: dev.program_to,
         erase_sector_timeout: dev.erase_to,
-        sectors: Vec::new(),
+        sectors: dev
+            .sectors
+            .iter()
+            .map(|(size, address)| SectorDescription {
+                size: *size as u64,
+                address: *address as u64,
+            })
+            .collect(),
     };
     // probe-rs schema default (Rust default for u64 is 0).
     algo.rtt_poll_interval = 20;
@@ -257,28 +264,44 @@ struct FlashDevice {
     erased: u8,
     program_to: u32,
     erase_to: u32,
+    sectors: Vec<(u32, u32)>,
 }
 
 fn read_flash_device(elf: &goblin::elf::Elf<'_>, buf: &[u8]) -> Result<FlashDevice> {
     use scroll::Pread;
     let mut addr = None;
+    let mut sym_size = 0u32;
     for s in elf.syms.iter() {
         if &elf.strtab[s.st_name] == "FlashDevice" {
             addr = Some(s.st_value as u32);
+            sym_size = s.st_size as u32;
             break;
         }
     }
     let addr = addr.ok_or_else(|| anyhow!("ELF missing FlashDevice symbol"))?;
 
-    let bytes = read_at(elf, buf, addr, 160)
-        .ok_or_else(|| anyhow!("FlashDevice not in any LOAD segment"))?;
+    let want = sym_size.max(160);
+    let bytes =
+        read_at(elf, buf, addr, want).ok_or_else(|| anyhow!("FlashDevice not in any LOAD segment"))?;
+    let mut sectors = Vec::new();
+    let mut off = 160;
+    while off + 8 <= bytes.len() {
+        let size: u32 = bytes.pread(off).unwrap();
+        let address: u32 = bytes.pread(off + 4).unwrap();
+        if size == u32::MAX && address == u32::MAX {
+            break;
+        }
+        sectors.push((size, address));
+        off += 8;
+    }
     Ok(FlashDevice {
         start: bytes.pread::<u32>(132).unwrap() as u64,
         size: bytes.pread::<u32>(136).unwrap() as u64,
         page_size: bytes.pread(140).unwrap(),
         erased: bytes.pread(148).unwrap(),
         program_to: bytes.pread(152).unwrap(),
         erase_to: bytes.pread(156).unwrap(),
+        sectors,
     })
 }
 

xtask/src/render.rs

@@ -255,10 +255,19 @@ fn build_family(
         algo.default = true;
         algo.flash_properties.address_range = start..end;
         algo.flash_properties.page_size = page_size;
-        algo.flash_properties.sectors = vec![SectorDescription {
-            size: page_size as u64,
-            address: 0,
-        }];
+        // Keep the erase size declared by the `algorithm!` macro (SYS on
+        // flash_v3 uses 4 KB; USR/OB match page_size). Rebase to 0 — addresses
+        // in sectors[] are relative to address_range.start.
+        if algo.flash_properties.sectors.is_empty() {
+            algo.flash_properties.sectors = vec![SectorDescription {
+                size: page_size as u64,
+                address: 0,
+            }];
+        } else {
+            for s in algo.flash_properties.sectors.iter_mut() {
+                s.address = 0;
+            }
+        }
         // Drop EraseChip for SYS — defends against accidental bulk-erase
         // routing. USR's MER and OB's page-erase+defaults are fine.
         if kind == "sys" {