Keep the page read/write loops in the library

The page loops (init_read + read_page x N, init_write + write_page x N)
are mechanical protocol with no timing, so they belong in the library as
ISPDevice::read/write rather than being duplicated in every consumer.

They take a dep-free '&dyn Fn(done, total)' progress callback, so the loop
stays in the lib without dragging back any runtime/UI dependency. The CLI
flasher (and the web app) now just create their progress bar, pass a
callback, and keep owning the surrounding cycle: sequencing, the
post-erase/reboot settle delays, and verification.

Author: carlossless

crates/sinowealth-isp/src/isp_device.rs

@@ -191,6 +191,54 @@ impl ISPDevice {
         Ok(())
     }
 
+    /// Reads `length` bytes starting at `start_addr` by looping over pages.
+    ///
+    /// `progress` is invoked after each page with `(pages_done, pages_total)`;
+    /// pass `&|_, _| {}` if you do not need it. This is mechanical protocol with
+    /// no delays, so it stays in the library; sequencing it into a full read
+    /// cycle (and the surrounding settle delays) is the caller's job.
+    pub async fn read(
+        &self,
+        start_addr: usize,
+        length: usize,
+        progress: &dyn Fn(usize, usize),
+    ) -> Result<Vec<u8>, ISPError> {
+        let page_size = self.device_spec.platform.page_size;
+        let num_page = length / page_size;
+
+        self.init_read(start_addr).await?;
+
+        let mut result: Vec<u8> = vec![];
+        for i in 0..num_page {
+            self.read_page(&mut result).await?;
+            progress(i + 1, num_page);
+        }
+        Ok(result)
+    }
+
+    /// Writes `num_pages` pages from `buffer`, starting at `start_addr`.
+    ///
+    /// `progress` is invoked after each page with `(pages_done, pages_total)`;
+    /// pass `&|_, _| {}` if you do not need it.
+    pub async fn write(
+        &self,
+        start_addr: usize,
+        buffer: &[u8],
+        progress: &dyn Fn(usize, usize),
+    ) -> Result<(), ISPError> {
+        let page_size = self.device_spec.platform.page_size;
+        let num_page = self.device_spec.num_pages();
+
+        self.init_write(start_addr).await?;
+
+        for i in 0..num_page {
+            self.write_page(&buffer[(i * page_size)..((i + 1) * page_size)])
+                .await?;
+            progress(i + 1, num_page);
+        }
+        Ok(())
+    }
+
     /// Erases everything in flash, except the ISP bootloader section itself and initializes the
     /// reset vector to jump to ISP.
     ///

crates/sinowealth-kb-tool/src/flasher.rs

@@ -67,42 +67,42 @@ pub fn write_cycle(device: &ISPDevice, firmware: &mut [u8]) -> Result<(), ISPErr
 fn read(device: &ISPDevice, start_addr: usize, length: usize) -> Result<Vec<u8>, ISPError> {
     let page_size = device.device_spec().platform.page_size;
     let num_page = length / page_size;
-    let mut result: Vec<u8> = vec![];
 
     eprintln!("Reading...");
     let bar = ProgressBar::new(num_page as u64);
 
-    device.init_read(start_addr).wait()?;
+    let result = device
+        .read(start_addr, length, &|done, _total| {
+            debug!(
+                "Reading page {} @ offset {:#06x}",
+                done - 1,
+                start_addr + (done - 1) * page_size
+            );
+            bar.set_position(done as u64);
+        })
+        .wait()?;
 
-    for i in 0..num_page {
-        bar.inc(1);
-        debug!(
-            "Reading page {} @ offset {:#06x}",
-            i,
-            start_addr + i * page_size
-        );
-        device.read_page(&mut result).wait()?;
-    }
     bar.finish();
     Ok(result)
 }
 
 fn write(device: &ISPDevice, start_addr: usize, buffer: &[u8]) -> Result<(), ISPError> {
-    let spec = *device.device_spec();
-    let page_size = spec.platform.page_size;
+    let page_size = device.device_spec().platform.page_size;
 
     eprintln!("Writing...");
-    let bar = ProgressBar::new(spec.num_pages() as u64);
+    let bar = ProgressBar::new(device.device_spec().num_pages() as u64);
+
+    device
+        .write(start_addr, buffer, &|done, _total| {
+            debug!(
+                "Writing page {} @ offset {:#06x}",
+                done - 1,
+                (done - 1) * page_size
+            );
+            bar.set_position(done as u64);
+        })
+        .wait()?;
 
-    device.init_write(start_addr).wait()?;
-
-    for i in 0..spec.num_pages() {
-        bar.inc(1);
-        debug!("Writing page {} @ offset {:#06x}", i, i * page_size);
-        device
-            .write_page(&buffer[(i * page_size)..((i + 1) * page_size)])
-            .wait()?;
-    }
     bar.finish();
     Ok(())
 }