[otlib] Deprecate CLI flag for setting reset delay

Reset delays are now configured once in configuration files and cannot
be changed per-test on the command line.

This commit switches all uses of the `reset_target` function to use
either `reset` or `reset_with_delay` where appropriate. All delays
should be exactly the same after this commit.

Signed-off-by: James Wainwright <[email protected]>

Author: jwnrt

sw/host/opentitanlib/src/app/mod.rs

@@ -987,6 +987,7 @@ impl TransportWrapper {
         Ok(())
     }
 
+    #[deprecated = "use [`reset`] or [`reset_with_delay`]"]
     pub fn reset_target(&self, reset_delay: Duration, clear_uart_rx: bool) -> Result<()> {
         let uart_rx = match clear_uart_rx {
             true => UartRx::Clear,

sw/host/opentitanlib/src/bootstrap/legacy_rescue.rs

@@ -8,7 +8,7 @@ use std::time::{Duration, Instant};
 use thiserror::Error;
 use zerocopy::{Immutable, IntoBytes};
 
-use crate::app::TransportWrapper;
+use crate::app::{TransportWrapper, UartRx};
 use crate::bootstrap::{Bootstrap, BootstrapOptions, UpdateProtocol};
 use crate::impl_serializable_error;
 use crate::io::uart::Uart;
@@ -253,17 +253,12 @@ impl LegacyRescue {
 
     /// Reset the chip and send the magic 'r' character at the opportune moment during boot in
     /// order to enter rescue more, repeat if necessary.
-    fn enter_rescue_mode(
-        &self,
-        transport: &TransportWrapper,
-        container: &Bootstrap,
-        uart: &dyn Uart,
-    ) -> Result<()> {
+    fn enter_rescue_mode(&self, transport: &TransportWrapper, uart: &dyn Uart) -> Result<()> {
         // Attempt getting the attention of the bootloader.
         let timeout = Duration::from_millis(2000);
         for _ in 0..Self::MAX_CONSECUTIVE_ERRORS {
             eprint!("Resetting...");
-            transport.reset_target(container.reset_delay, true)?;
+            transport.reset(UartRx::Clear)?;
 
             let stopwatch = Instant::now();
             while stopwatch.elapsed() < timeout {
@@ -321,7 +316,7 @@ impl UpdateProtocol for LegacyRescue {
         let frames = Frame::from_payload(payload)?;
         let uart = container.uart_params.create(transport)?;
 
-        self.enter_rescue_mode(transport, container, &*uart)?;
+        self.enter_rescue_mode(transport, &*uart)?;
 
         // Send frames one at a time.
         progress.new_stage("", frames.len() * Frame::DATA_LEN);
@@ -367,7 +362,7 @@ impl UpdateProtocol for LegacyRescue {
         if container.leave_in_reset {
             container.reset_pin.write(false)?; // Low active
         } else {
-            transport.reset_target(container.reset_delay, false)?;
+            transport.reset(UartRx::Keep)?;
         }
 
         progress.progress(frames.len() * Frame::DATA_LEN);

sw/host/opentitanlib/src/bootstrap/mod.rs

@@ -11,7 +11,7 @@ use humantime::parse_duration;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
-use crate::app::{NoProgressBar, TransportWrapper};
+use crate::app::{NoProgressBar, TransportWrapper, UartRx};
 use crate::impl_serializable_error;
 use crate::io::gpio::GpioPin;
 use crate::io::spi::SpiParams;
@@ -86,9 +86,6 @@ pub struct BootstrapOptions {
     /// Whether to reset target and clear UART RX buffer after bootstrap. For Chip Whisperer board only.
     #[arg(long)]
     pub clear_uart: Option<bool>,
-    /// Duration of the reset pulse.
-    #[arg(long, value_parser = parse_duration, default_value = "100ms")]
-    pub reset_delay: Duration,
     /// If set, keep the bootstrap strapping applied and do not perform the post-bootstrap reset
     /// sequence.
     #[arg(long)]
@@ -111,7 +108,6 @@ pub struct Bootstrap<'a> {
     pub uart_params: &'a UartParams,
     pub spi_params: &'a SpiParams,
     reset_pin: Rc<dyn GpioPin>,
-    reset_delay: Duration,
     leave_in_reset: bool,
     leave_in_bootstrap: bool,
 }
@@ -164,7 +160,6 @@ impl<'a> Bootstrap<'a> {
             uart_params: &options.uart_params,
             spi_params: &options.spi_params,
             reset_pin: transport.gpio_pin("RESET")?,
-            reset_delay: options.reset_delay,
             leave_in_reset: options.leave_in_reset,
             leave_in_bootstrap: options.leave_in_bootstrap,
         }
@@ -185,7 +180,11 @@ impl<'a> Bootstrap<'a> {
         if perform_bootstrap_reset {
             log::info!("Asserting bootstrap pins...");
             rom_boot_strapping.apply()?;
-            transport.reset_target(self.reset_delay, self.clear_uart_rx)?;
+            let uart_rx = match self.clear_uart_rx {
+                true => UartRx::Clear,
+                false => UartRx::Keep,
+            };
+            transport.reset(uart_rx)?;
             log::info!("Performing bootstrap...");
         }
         let result = updater.update(self, transport, payload, progress);
@@ -204,7 +203,7 @@ impl<'a> Bootstrap<'a> {
                 rom_boot_strapping.remove()?;
                 // Don't clear the UART RX buffer after bootstrap to preserve the bootstrap
                 // output.
-                transport.reset_target(self.reset_delay, false)?;
+                transport.reset(UartRx::Keep)?;
             }
         }
         result

sw/host/opentitanlib/src/rescue/serial.rs

@@ -7,7 +7,7 @@ use std::cell::Cell;
 use std::rc::Rc;
 use std::time::Duration;
 
-use crate::app::TransportWrapper;
+use crate::app::{TransportWrapper, UartRx};
 use crate::io::uart::Uart;
 use crate::rescue::xmodem::Xmodem;
 use crate::rescue::{EntryMode, Rescue, RescueError, RescueMode};
@@ -53,7 +53,7 @@ impl Rescue for RescueSerial {
         match mode {
             EntryMode::Reset => {
                 self.uart.set_break(true)?;
-                transport.reset_target(self.reset_delay, /*clear_uart=*/ true)?;
+                transport.reset_with_delay(UartRx::Clear, self.reset_delay)?;
             }
             EntryMode::Reboot => {
                 self.reboot()?;

sw/host/opentitanlib/src/rescue/spidfu.rs

@@ -8,7 +8,7 @@ use std::rc::Rc;
 use std::time::{Duration, Instant};
 use zerocopy::{Immutable, IntoBytes};
 
-use crate::app::TransportWrapper;
+use crate::app::{TransportWrapper, UartRx};
 use crate::chip::rom_error::RomError;
 use crate::io::spi::Target;
 use crate::rescue::dfu::*;
@@ -75,9 +75,7 @@ impl Rescue for SpiDfu {
         );
         self.params.set_trigger(transport, true)?;
         match mode {
-            EntryMode::Reset => {
-                transport.reset_target(self.reset_delay, /*clear_uart=*/ false)?
-            }
+            EntryMode::Reset => transport.reset_with_delay(UartRx::Keep, self.reset_delay)?,
             EntryMode::Reboot => {
                 self.reboot()?;
                 // Give the chip a chance to reset before attempting to re-read

sw/host/opentitanlib/src/rescue/usbdfu.rs

@@ -6,7 +6,7 @@ use anyhow::{Result, bail};
 use std::cell::{Cell, Ref, RefCell};
 use std::time::Duration;
 
-use crate::app::TransportWrapper;
+use crate::app::{TransportWrapper, UartRx};
 use crate::rescue::dfu::*;
 use crate::rescue::{EntryMode, Rescue, RescueError, RescueMode, RescueParams};
 use crate::util::usb::UsbBackend;
@@ -49,9 +49,7 @@ impl Rescue for UsbDfu {
         self.params.set_trigger(transport, true)?;
 
         match mode {
-            EntryMode::Reset => {
-                transport.reset_target(self.reset_delay, /*clear_uart=*/ false)?
-            }
+            EntryMode::Reset => transport.reset_with_delay(UartRx::Keep, self.reset_delay)?,
             EntryMode::Reboot => self.reboot()?,
             EntryMode::None => {}
         }

sw/host/opentitanlib/src/test_utils/lc.rs

@@ -7,22 +7,21 @@ use std::time::Duration;
 use anyhow::Result;
 use arrayvec::ArrayVec;
 
-use crate::app::TransportWrapper;
+use crate::app::{TransportWrapper, UartRx};
 use crate::dif::lc_ctrl::{DifLcCtrlState, LcCtrlReg, LcCtrlStatus};
 use crate::io::jtag::{JtagParams, JtagTap};
 use crate::test_utils::lc_transition::wait_for_status;
 
 pub fn read_lc_state(
     transport: &TransportWrapper,
     jtag_params: &JtagParams,
-    reset_delay: Duration,
 ) -> Result<DifLcCtrlState> {
     transport.pin_strapping("PINMUX_TAP_LC")?.apply()?;
 
     // Apply bootstrap pin to be able to connect to JTAG when ROM execution is
     // enabled.
     transport.pin_strapping("ROM_BOOTSTRAP")?.apply()?;
-    transport.reset_target(reset_delay, true)?;
+    transport.reset(UartRx::Clear)?;
     let mut jtag = jtag_params.create(transport)?.connect(JtagTap::LcTap)?;
     // We must wait for the lc_ctrl to initialize before the LC state is exposed.
     wait_for_status(
@@ -40,14 +39,13 @@ pub fn read_lc_state(
 pub fn read_device_id(
     transport: &TransportWrapper,
     jtag_params: &JtagParams,
-    reset_delay: Duration,
 ) -> Result<ArrayVec<u32, 8>> {
     transport.pin_strapping("PINMUX_TAP_LC")?.apply()?;
 
     // Apply bootstrap pin to be able to connect to JTAG when ROM execution is
     // enabled.
     transport.pin_strapping("ROM_BOOTSTRAP")?.apply()?;
-    transport.reset_target(reset_delay, true)?;
+    transport.reset(UartRx::Clear)?;
     let mut jtag = jtag_params.create(transport)?.connect(JtagTap::LcTap)?;
     // We must wait for the lc_ctrl to initialize before the LC state is exposed.
     wait_for_status(

sw/host/opentitanlib/src/test_utils/lc_transition.rs

@@ -9,7 +9,7 @@ use anyhow::{Context, Result, bail};
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
-use crate::app::TransportWrapper;
+use crate::app::{TransportWrapper, UartRx};
 use crate::chip::boolean::MultiBitBool8;
 use crate::dif::lc_ctrl::{
     DifLcCtrlState, LcCtrlReg, LcCtrlStatus, LcCtrlTransitionCmd, LcCtrlTransitionCtrl,
@@ -142,7 +142,7 @@ fn setup_lc_transition(
 /// tap_lc_strapping.apply().expect("failed to apply strapping");
 ///
 /// // Reset into the new strapping.
-/// transport.reset_target(init.bootstrap.options.reset_delay, true).unwrap();
+/// transport.reset(UartRx::Clear).unwrap();
 ///
 /// // Connect to the LC controller TAP.
 /// let mut jtag = transport
@@ -159,7 +159,6 @@ fn setup_lc_transition(
 ///     DifLcCtrlState::Prod,
 ///     Some(test_exit_token.into_register_values()),
 ///     true,
-///     init.bootstrap.options.reset_delay,
 ///     Some(JtagTap::LcTap),
 /// ).expect("failed to trigger transition to prod");
 ///
@@ -180,7 +179,6 @@ pub fn trigger_lc_transition(
     target_lc_state: DifLcCtrlState,
     token: Option<[u32; 4]>,
     use_external_clk: bool,
-    reset_delay: Duration,
     reset_tap_straps: Option<JtagTap>,
 ) -> Result<()> {
     // Wait for the lc_ctrl to become initialized, claim the mutex, and program the target state
@@ -222,7 +220,7 @@ pub fn trigger_lc_transition(
             JtagTap::RiscvTap => transport.pin_strapping("PINMUX_TAP_RISCV")?.apply()?,
         }
     }
-    transport.reset_target(reset_delay, true)?;
+    transport.reset(UartRx::Clear)?;
 
     Ok(())
 }