feat(test_runner): pause the RP2040 test driver's output until the serial port is open

Author: yvt

src/r3_port_arm_m_test_driver/src/board_rp2040.rs

@@ -1,4 +1,7 @@
-use core::panic::PanicInfo;
+use core::{
+    panic::PanicInfo,
+    sync::atomic::{AtomicBool, Ordering},
+};
 use r3::kernel::{cfg::CfgBuilder, Kernel, StartupHook};
 use r3_support_rp2040::usbstdio;
 
@@ -81,11 +84,14 @@ pub const fn configure<System: Kernel>(b: &mut CfgBuilder<System>) {
     usbstdio::configure::<_, Options>(b);
 }
 
+static SHOULD_PAUSE_OUTPUT: AtomicBool = AtomicBool::new(true);
+
 struct Options;
 
 impl usbstdio::Options for Options {
     /// Handle USB serial input data.
     fn handle_input(s: &[u8]) {
+        let mut should_unpause_output = false;
         for &b in s.iter() {
             match b {
                 b'r' => {
@@ -96,17 +102,27 @@ impl usbstdio::Options for Options {
                         .reset_to_usb_boot(gpio_activity_pin_mask, disable_interface_mask);
                 }
                 b'g' => {
-                    // TODO: unblock the output? check if this is really necessary.
-                    //       maybe we can get away with DTR
+                    should_unpause_output = true;
                 }
                 _ => {}
             }
         }
+
+        if should_unpause_output && SHOULD_PAUSE_OUTPUT.load(Ordering::Relaxed) {
+            SHOULD_PAUSE_OUTPUT.store(false, Ordering::Relaxed);
+
+            // Flush the transmission buffer.
+            usbstdio::poll::<Options>();
+        }
     }
 
     fn product_name() -> &'static str {
         "R3 Test Driver Port"
     }
+
+    fn should_pause_output() -> bool {
+        SHOULD_PAUSE_OUTPUT.load(Ordering::Relaxed)
+    }
 }
 
 #[repr(C)]

src/r3_support_rp2040/src/usbstdio.rs

@@ -49,7 +49,7 @@ fn with_usb_stdio_global<T>(f: impl FnOnce(&mut UsbStdioGlobal, &mut WriteBufDeq
 }
 
 /// The options for the USB serial device configured by [`configure`].
-pub trait Options {
+pub trait Options: 'static + Send + Sync {
     /// Handle incoming data.
     ///
     /// This method may be called with interrupts disabled. It's safe to write
@@ -60,6 +60,15 @@ pub trait Options {
     fn product_name() -> &'static str {
         "R3 Example Application Port"
     }
+
+    /// Return a flag indicating whether the output data should be withheld
+    /// from transmission.
+    ///
+    /// If this flag is changed to `false`, [`poll`] must be called to flush
+    /// the data in the transmission buffer.
+    fn should_pause_output() -> bool {
+        false
+    }
 }
 
 /// Add a USB serial device to the system and register it as the destination of
@@ -98,7 +107,7 @@ pub const fn configure<System: Kernel, TOptions: Options>(b: &mut CfgBuilder<Sys
             });
 
             // Register the standard output
-            crate::stdout::set_stdout(NbWriter);
+            crate::stdout::set_stdout(NbWriter::<TOptions>(core::marker::PhantomData));
         })
         .finish(b);
 
@@ -114,29 +123,33 @@ pub const fn configure<System: Kernel, TOptions: Options>(b: &mut CfgBuilder<Sys
     InterruptHandler::build()
         .line(int_num)
         .start(|_| {
-            let mut buf = [0; 64];
-            let mut read_len = 0;
+            poll::<TOptions>();
+        })
+        .finish(b);
+}
 
-            // Get the global `UsbStdioGlobal` instance, which should
-            // have been created by the startup hook above
-            with_usb_stdio_global(|g, write_buf| {
-                g.usb_device.poll(&mut [&mut g.serial]);
+pub fn poll<TOptions: Options>() {
+    let mut buf = [0; 64];
+    let mut read_len = 0;
 
-                if let Ok(len) = g.serial.read(&mut buf) {
-                    read_len = len;
-                }
+    // Get the global `UsbStdioGlobal` instance, which should
+    // have been created by the startup hook above
+    with_usb_stdio_global(|g, write_buf| {
+        g.usb_device.poll(&mut [&mut g.serial]);
 
-                g.try_flush(write_buf);
-            });
+        if let Ok(len) = g.serial.read(&mut buf) {
+            read_len = len;
+        }
 
-            if read_len > 0 {
-                TOptions::handle_input(&buf[..read_len]);
-            }
-        })
-        .finish(b);
+        g.try_flush::<TOptions>(write_buf);
+    });
+
+    if read_len > 0 {
+        TOptions::handle_input(&buf[..read_len]);
+    }
 }
 
-struct NbWriter;
+struct NbWriter<TOptions>(core::marker::PhantomData<fn() -> TOptions>);
 
 fn map_usb_error_to_nb_error(e: usb_device::UsbError) -> nb::Error<core::convert::Infallible> {
     match e {
@@ -158,22 +171,22 @@ fn map_usb_error_to_nb_error(e: usb_device::UsbError) -> nb::Error<core::convert
     }
 }
 
-impl embedded_hal::serial::Write<u8> for NbWriter {
+impl<TOptions: Options> embedded_hal::serial::Write<u8> for NbWriter<TOptions> {
     type Error = core::convert::Infallible;
 
     fn write(&mut self, word: u8) -> nb::Result<(), Self::Error> {
         with_usb_stdio_global(|g, write_buf| {
             // Push the given byte to the write buffer. Return `WouldBlock` if
             // the buffer is full.
             write_buf.push(word).map_err(|_| nb::Error::WouldBlock)?;
-            g.try_flush(write_buf);
+            g.try_flush::<TOptions>(write_buf);
             Ok(())
         })
     }
 
     fn flush(&mut self) -> nb::Result<(), Self::Error> {
         with_usb_stdio_global(|g, write_buf| {
-            g.try_flush(write_buf);
+            g.try_flush::<TOptions>(write_buf);
             g.serial.flush().map_err(map_usb_error_to_nb_error)?;
             if !write_buf.is_empty() {
                 return Err(nb::Error::WouldBlock);
@@ -184,9 +197,9 @@ impl embedded_hal::serial::Write<u8> for NbWriter {
 }
 
 impl UsbStdioGlobal {
-    fn try_flush(&mut self, write_buf: &mut WriteBufDeque) {
-        // Withhold the data until DTR is asserted and RTS is cleared
-        if !self.serial.dtr() {
+    fn try_flush<TOptions: Options>(&mut self, write_buf: &mut WriteBufDeque) {
+        // Withhold the data until DTR is asserted
+        if !self.serial.dtr() || TOptions::should_pause_output() {
             return;
         }
 

src/r3_test_runner/src/targets/rp_pico.rs

@@ -160,8 +160,20 @@ impl DebugProbe for RaspberryPiPicoUsbDebugProbe {
 
             self.serial = Some(BufStream::new(serial));
 
+            // Tell the test driver that we are now listening for the output
+            log::debug!("Unblocking the test driver's output");
+            let serial = self.serial.as_mut().unwrap();
+            serial
+                .write_all(b"g")
+                .await
+                .with_context(|| "Failed to write to the test driver serial interface.")?;
+            serial
+                .flush()
+                .await
+                .with_context(|| "Failed to write to the test driver serial interface.")?;
+
             // Now, pass the channel to the caller
-            Ok(Box::pin(Demux::new(self.serial.as_mut().unwrap())) as _)
+            Ok(Box::pin(Demux::new(serial)) as _)
         })
     }
 }