cosmo-hf: add limited busy-polls in all wait paths

Presently, the `cosmo-hf` driver has three functions that wait for some
status to change before continuing: `wait_fpga_busy`, `wait_fpga_rx`,
and `wait_flash_busy`. All of these functions check the desired
condition in a loop and sleep for 1ms when it is not satisfied.
Currently, `wait_fpga_busy` will first perform a limited number of
busy-polls before starting to sleep between polls, but the other
functions do not. While investigating HF write performance on
Grapefruit,
@cbiffle and I found that commenting out the sleeps in these polling
functions improved HF write performance significantly: writing 2MiB of
random data using `humility qspi -D` went from taking about a minute to
about 36 seconds --- that's a 40% performance improvement.

This branch is like a slightly more principled version of commenting out
the `sleep_for` calls. I've generalized the pervious `wait_fpga_busy` of
doing 32 busy-polls before starting to sleep to something that can be
used by all three wait-for-condition type functions. I did change the
code for implementing this a bit from the previous thing, which
implemented the counter using a `for i in 0..` loop that checked `i >
32` This was a bit more concise and kind  of a cute trick, but had a
somewhat surprising behavior: the loop wasn't actually infinite, and
would terminate after `u32::MAX` polls. Of course, polling for
4,294,967,295ms means we would have waited about 50 days for a write to
complete before terminating the loop unexpectedly, and if that happened,
something would have to be REALLY broken. But, it's still a pretty wrong
behavior, so the implementation I've done --- using a `while` loop with an explicitly incremented counter --- will never terminate unless the condition has actually changed, which seems a little less anxiety-inducing.

Author: hawkw

drv/cosmo-hf/src/main.rs

@@ -145,27 +145,12 @@ impl FlashDriver {
 
     /// Wait until the FPGA is idle
     fn wait_fpga_busy(&self) {
-        loop {
-            if !self.drv.spisr.busy() {
-                break;
-            }
-            ringbuf_entry!(Trace::FpgaBusy);
-            sleep_for(1);
-        }
+        self.poll_wait(|this| !this.drv.spisr.busy(), Trace::FpgaBusy)
     }
 
     /// Wait until a word is available in the FPGA's RX buffer
     fn wait_fpga_rx(&self) {
-        for i in 0.. {
-            if !self.drv.spisr.rx_empty() {
-                break;
-            }
-            ringbuf_entry!(Trace::FpgaBusy);
-            // Initial busy-loop for faster response
-            if i >= 32 {
-                sleep_for(1);
-            }
-        }
+        self.poll_wait(|this| !this.drv.spisr.rx_empty(), Trace::FpgaBusy)
     }
 
     /// Clears the FPGA's internal FIFOs
@@ -177,13 +162,47 @@ impl FlashDriver {
         });
     }
 
+    /// Wait for a condition represented by the provided `poll` function.
+    ///
+    /// The driver will wait until the `poll` function returns `true`. Each time
+    /// `poll` returns `false`, the provided `trace` will be recorded in the
+    /// ring buffer.
+    fn poll_wait(&self, poll: fn(&Self) -> bool, trace: Trace) {
+        // When polling the FPGA or flash chips, this number of polls are
+        // attempted *without* sleeping between polls. If the FPGA/flash's
+        // status has not changed after this number of polls, the driver will
+        // begin to sleep for a short period between subsequent polls.
+        //
+        // This is intended to improve copy performance for operations where the
+        // desired status transition occurs in less than 1ms, avoiding a 1-2ms
+        // sleep and round-trip through the scheduler. status transitions
+        // quickly.
+        const MAX_BUSY_POLLS: u32 = 32;
+
+        let mut busy_polls = 0;
+        while !poll(self) {
+            ringbuf_entry!(trace);
+
+            if busy_polls > MAX_BUSY_POLLS {
+                // If we've exhausted all of our busy polls, sleep for a bit
+                // before polling again.
+                sleep_for(1);
+            } else {
+                // Only increment the counter while we are busy-polling.
+                // Otherwise, if we incremented it unconditionally, we might
+                // overflow and start busy-polling again. Of course, we won't do
+                // that unless we are stuck waiting for 4,294,967,295ms, which
+                // is a little under 50 days, so things would probably have gone
+                // very wrong if that happened. But, still...
+                busy_polls += 1;
+            }
+        }
+    }
+
     /// Wait until the SPI flash is idle
     fn wait_flash_busy(&self, t: Trace) {
         // Wait for the busy flag to be unset
-        while (self.read_flash_status() & 1) != 0 {
-            ringbuf_entry!(t);
-            sleep_for(1);
-        }
+        self.poll_wait(|this| this.read_flash_status() & 1 == 0, t);
     }
 
     /// Reads the STATUS1 register from flash