Add tests to ensure that we don't reset current_time drivers

esp-hal/src/system.rs

@@ -106,6 +106,8 @@ pub enum Peripheral {
     Trace0,
     #[cfg(lcd_cam)]
     LcdCam,
+    #[cfg(systimer)]
+    Systimer,
 }
 
 /// The `DPORT`/`PCR`/`SYSTEM` peripheral split into its different logical
@@ -493,6 +495,11 @@ impl PeripheralClockControl {
                 perip_clk_en1.modify(|_, w| w.lcd_cam_clk_en().set_bit());
                 perip_rst_en1.modify(|_, w| w.lcd_cam_rst().clear_bit());
             }
+            #[cfg(systimer)]
+            Peripheral::Systimer => {
+                perip_clk_en0.modify(|_, w| w.systimer_clk_en().set_bit());
+                perip_rst_en0.modify(|_, w| w.systimer_rst().clear_bit());
+            }
         });
     }
 
@@ -697,6 +704,11 @@ impl PeripheralClockControl {
                 perip_rst_en1.modify(|_, w| w.lcd_cam_rst().set_bit());
                 perip_rst_en1.modify(|_, w| w.lcd_cam_rst().clear_bit());
             }
+            #[cfg(systimer)]
+            Peripheral::Systimer => {
+                perip_rst_en0.modify(|_, w| w.systimer_rst().set_bit());
+                perip_rst_en0.modify(|_, w| w.systimer_rst().clear_bit());
+            }
         });
     }
 }
@@ -915,6 +927,15 @@ impl PeripheralClockControl {
                     .trace_conf()
                     .modify(|_, w| w.trace_rst_en().clear_bit());
             }
+            #[cfg(systimer)]
+            Peripheral::Systimer => {
+                system
+                    .systimer_conf()
+                    .modify(|_, w| w.systimer_clk_en().set_bit());
+                system
+                    .systimer_conf()
+                    .modify(|_, w| w.systimer_rst_en().clear_bit());
+            }
         }
     }
 
@@ -1107,6 +1128,15 @@ impl PeripheralClockControl {
                     .trace_conf()
                     .modify(|_, w| w.trace_rst_en().clear_bit());
             }
+            #[cfg(systimer)]
+            Peripheral::Systimer => {
+                system
+                    .systimer_conf()
+                    .modify(|_, w| w.systimer_rst_en().set_bit());
+                system
+                    .systimer_conf()
+                    .modify(|_, w| w.systimer_rst_en().clear_bit());
+            }
         }
     }
 }

esp-hal/src/timer/systimer.rs

@@ -81,6 +81,7 @@ use crate::{
     interrupt::{self, InterruptHandler},
     peripheral::Peripheral,
     peripherals::{Interrupt, SYSTIMER},
+    system::{Peripheral as PeripheralEnable, PeripheralClockControl},
     Async,
     Blocking,
     Cpu,
@@ -131,6 +132,9 @@ impl<'d> SystemTimer<'d> {
         #[cfg(soc_etm)]
         etm::enable_etm();
 
+        // Don't reset Systimer as it will break `current_time`, only enable it
+        PeripheralClockControl::enable(PeripheralEnable::Systimer);
+
         Self {
             unit0: SpecificUnit::new(),
             #[cfg(not(esp32s2))]

hil-test/Cargo.toml

@@ -170,6 +170,10 @@ p256                = { version = "0.13.2", default-features = false, features =
 sha1                = { version = "0.10.6", default-features = false }
 sha2                = { version = "0.10.8", default-features = false }
 
+[build-dependencies]
+esp-build    = { version = "0.1.0", path = "../esp-build" }
+esp-metadata = { version = "0.2.0", path = "../esp-metadata" }
+
 [features]
 default = ["async", "embassy"]
 
@@ -227,3 +231,6 @@ incremental      = false
 opt-level        = 3
 lto              = "fat"
 overflow-checks  = false
+
+[lints.rust]
+unexpected_cfgs = "allow"

hil-test/build.rs

@@ -0,0 +1,41 @@
+use std::{error::Error, str::FromStr};
+
+use esp_build::assert_unique_used_features;
+use esp_metadata::{Chip, Config};
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // NOTE: update when adding new device support!
+    // Ensure that exactly one chip has been specified:
+    assert_unique_used_features!(
+        "esp32", "esp32c2", "esp32c3", "esp32c6", "esp32h2", "esp32s2", "esp32s3"
+    );
+
+    // NOTE: update when adding new device support!
+    // Determine the name of the configured device:
+    let device_name = if cfg!(feature = "esp32") {
+        "esp32"
+    } else if cfg!(feature = "esp32c2") {
+        "esp32c2"
+    } else if cfg!(feature = "esp32c3") {
+        "esp32c3"
+    } else if cfg!(feature = "esp32c6") {
+        "esp32c6"
+    } else if cfg!(feature = "esp32h2") {
+        "esp32h2"
+    } else if cfg!(feature = "esp32s2") {
+        "esp32s2"
+    } else if cfg!(feature = "esp32s3") {
+        "esp32s3"
+    } else {
+        unreachable!() // We've confirmed exactly one known device was selected
+    };
+
+    // Load the configuration file for the configured device:
+    let chip = Chip::from_str(device_name)?;
+    let config = Config::for_chip(&chip);
+
+    // Define all necessary configuration symbols for the configured device:
+    config.define_symbols();
+
+    Ok(())
+}

hil-test/tests/get_time.rs

@@ -6,11 +6,15 @@
 #![no_std]
 #![no_main]
 
+#[cfg(esp32)]
+use esp_hal::clock::Clocks;
 use esp_hal::{clock::ClockControl, delay::Delay, peripherals::Peripherals, system::SystemControl};
 use hil_test as _;
 
 struct Context {
     delay: Delay,
+    #[cfg(esp32)]
+    clocks: Clocks<'static>,
 }
 
 impl Context {
@@ -21,7 +25,11 @@ impl Context {
 
         let delay = Delay::new(&clocks);
 
-        Context { delay }
+        Context {
+            delay,
+            #[cfg(esp32)]
+            clocks,
+        }
     }
 }
 
@@ -45,4 +53,37 @@ mod tests {
         assert!(t2 > t1);
         assert!((t2 - t1).to_millis() >= 500u64);
     }
+
+    #[cfg(systimer)]
+    #[test]
+    #[timeout(3)]
+    fn test_current_time_construct_systimer(ctx: Context) {
+        let t1 = esp_hal::time::current_time();
+        // construct the timer in between calls to current_time
+        let _ = esp_hal::timer::systimer::SystemTimer::new(unsafe {
+            esp_hal::peripherals::SYSTIMER::steal()
+        });
+        ctx.delay.delay_millis(500);
+        let t2 = esp_hal::time::current_time();
+
+        assert!(t2 > t1);
+        assert!((t2 - t1).to_millis() >= 500u64);
+    }
+
+    #[cfg(esp32)]
+    #[test]
+    #[timeout(3)]
+    fn test_current_time_construct_timg0(ctx: Context) {
+        let t1 = esp_hal::time::current_time();
+        // construct the timer in between calls to current_time
+        let _ = esp_hal::timer::timg::TimerGroup::new(
+            unsafe { esp_hal::peripherals::TIMG0::steal() },
+            &ctx.clocks,
+        );
+        ctx.delay.delay_millis(500);
+        let t2 = esp_hal::time::current_time();
+
+        assert!(t2 > t1);
+        assert!((t2 - t1).to_millis() >= 500u64);
+    }
 }