Skip programming erased pages

Flash memory is set to all `1` when erased. We have to erase pages
before writing so writing pages full of `1` is not a good use of
CPU time.

Before
real    2m0.817s
user    0m4.380s
sys     0m3.305s

After
real	1m44.543s
user	0m3.586s
sys	0m2.710s

Author: labbott

drv/cosmo-hf/src/hf.rs

@@ -9,7 +9,7 @@ use drv_hf_api::{
     HF_PERSISTENT_DATA_STRIDE,
 };
 use idol_runtime::{
-    LeaseBufReader, LeaseBufWriter, Leased, LenLimit, NotificationHandler,
+    ClientError, LeaseBufWriter, Leased, LenLimit, NotificationHandler,
     RequestError, R, W,
 };
 use ringbuf::ringbuf_entry_root as ringbuf_entry;
@@ -421,11 +421,13 @@ impl idl::InOrderHostFlashImpl for ServerImpl {
         self.drv.check_flash_mux_state()?;
         let addr = self.flash_addr(addr, data.len() as u32)?;
         self.invalidate_write();
+        let mut block: [u8; PAGE_SIZE_BYTES] = [0; PAGE_SIZE_BYTES];
+        // Read the entire data block into our address space.
+        data.read_range(0..data.len(), &mut block[..data.len()])
+            .map_err(|_| RequestError::Fail(ClientError::WentAway))?;
+
         self.drv
-            .flash_write(
-                addr,
-                &mut LeaseBufReader::<_, 32>::from(data.into_inner()),
-            )
+            .flash_write(addr, &block[..data.len()])
             .map_err(|()| RequestError::went_away())
     }
 

drv/cosmo-hf/src/main.rs

@@ -345,44 +345,38 @@ impl FlashDriver {
         Ok(())
     }
 
-    /// Writes data from a `BufReader` into the flash
+    /// Writes data from a slice into the flash
     ///
-    /// This function will only return an error if it fails to write to a
-    /// provided lease; when given a slice, it is infallible.
-    fn flash_write(
-        &mut self,
-        addr: FlashAddr,
-        data: &mut dyn idol_runtime::BufReader<'_>,
-    ) -> Result<(), ()> {
-        loop {
-            let len = data.remaining_size().min(PAGE_SIZE_BYTES);
-            if len == 0 {
-                break;
-            }
-            self.flash_write_enable();
-            self.drv.data_bytes.set_count(len as u16);
-            self.drv.addr.set_addr(addr.0);
-            self.drv.dummy_cycles.set_count(0);
-            for i in 0..len.div_ceil(4) {
-                let mut v = [0u8; 4];
-                for (j, byte) in v.iter_mut().enumerate() {
-                    let k = i * 4 + j;
-                    if k < len {
-                        let Some(d) = data.read() else {
-                            return Err(());
-                        };
-                        *byte = d;
-                    }
-                }
-                let v = u32::from_le_bytes(v);
-                self.drv.tx_fifo_wdata.set_fifo_data(v);
-            }
-            self.drv.instr.set_opcode(instr::QUAD_INPUT_PAGE_PROGRAM_4B);
-            self.wait_fpga_busy();
+    /// This function will only return an error if the slice len is not a full
+    /// page size
+    fn flash_write(&mut self, addr: FlashAddr, data: &[u8]) -> Result<(), ()> {
+        // This function will not work if we try and write less than a full page
+        if data.len() != PAGE_SIZE_BYTES {
+            return Err(());
+        }
 
-            // Wait for the busy flag to be unset
-            self.wait_flash_busy(Trace::WriteBusy);
+        let len = data.len();
+
+        // Don't bother writing erased pages
+        if data.iter().all(|x| *x == 0xff) {
+            return Ok(());
         }
+
+        self.flash_write_enable();
+        self.drv.data_bytes.set_count(len as u16);
+        self.drv.addr.set_addr(addr.0);
+        self.drv.dummy_cycles.set_count(0);
+
+        for chunk in data.chunks(4) {
+            let v = u32::from_le_bytes(chunk.try_into().unwrap());
+            self.drv.tx_fifo_wdata.set_fifo_data(v);
+        }
+
+        self.drv.instr.set_opcode(instr::QUAD_INPUT_PAGE_PROGRAM_4B);
+        self.wait_fpga_busy();
+
+        // Wait for the busy flag to be unset
+        self.wait_flash_busy(Trace::WriteBusy);
         Ok(())
     }