Merge pull request #2 from qwandor/features

Add methods for match register and interrupts, and optional chrono support

.github/workflows/ci.yml

@@ -23,7 +23,9 @@ jobs:
       run: cargo fmt --all -- --check
     - name: Clippy
       run: cargo clippy --target ${{ matrix.targets }} --all-features -- -A clippy::new_without_default
-    - name: Build
+    - name: Build with no features
+      run: cargo build --target ${{ matrix.targets }} --no-default-features
+    - name: Build with all features
       run: cargo build --target ${{ matrix.targets }} --all-features
     - name: Unit test
       if: ${{ matrix.targets == 'x86_64-unknown-linux-gnu' }}

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## Unreleased
+
+### New features
+
+- Added methods for match register and interrupts.
+- Added optional dependency on `chrono`.
+
 ## 0.2.0
 
 ### Breaking changes

Cargo.toml

@@ -12,3 +12,8 @@ keywords = ["arceos", "aarch64", "rtc", "pl031"]
 categories = ["os", "hardware-support", "no-std"]
 
 [dependencies]
+chrono = { version = "0.4.38", default-features = false, optional = true }
+
+[features]
+chrono = ["dep:chrono"]
+default = ["chrono"]

src/chrono.rs

@@ -0,0 +1,26 @@
+use crate::Rtc;
+use chrono::{DateTime, TimeZone as _, Utc};
+use core::num::TryFromIntError;
+
+impl Rtc {
+    /// Returns the current time.
+    pub fn get_time(&self) -> DateTime<Utc> {
+        Utc.timestamp_opt(self.get_unix_timestamp().into(), 0)
+            .unwrap()
+    }
+
+    /// Sets the current time.
+    ///
+    /// Returns an error if the given time is beyond the bounds supported by the RTC.
+    pub fn set_time(&mut self, time: DateTime<Utc>) -> Result<(), TryFromIntError> {
+        self.set_unix_timestamp(time.timestamp().try_into()?);
+        Ok(())
+    }
+
+    /// Sets the match register to the given time. When the RTC value matches this then an interrupt
+    /// will be generated (if it is enabled).
+    pub fn set_match(&mut self, match_time: DateTime<Utc>) -> Result<(), TryFromIntError> {
+        self.set_match_timestamp(match_time.timestamp().try_into()?);
+        Ok(())
+    }
+}

src/lib.rs

@@ -1,9 +1,18 @@
 //! System Real Time Clock (RTC) Drivers for aarch64 based on PL031.
 
 #![cfg_attr(not(test), no_std)]
+#![deny(
+    clippy::missing_safety_doc,
+    clippy::undocumented_unsafe_blocks,
+    unsafe_op_in_unsafe_fn
+)]
+
+#[cfg(feature = "chrono")]
+mod chrono;
 
 use core::ptr::{addr_of, addr_of_mut};
 
+#[derive(Default)]
 #[repr(C, align(4))]
 struct Registers {
     /// Data register
@@ -63,6 +72,52 @@ impl Rtc {
         // of a PL031 device which is appropriately mapped.
         unsafe { addr_of_mut!((*self.registers).lr).write_volatile(unix_time) }
     }
+
+    /// Writes a match value. When the RTC value matches this then an interrupt
+    /// will be generated (if it is enabled).
+    pub fn set_match_timestamp(&mut self, match_timestamp: u32) {
+        // SAFETY: We know that self.registers points to the control registers
+        // of a PL031 device which is appropriately mapped.
+        unsafe { addr_of_mut!((*self.registers).mr).write_volatile(match_timestamp) }
+    }
+
+    /// Returns whether the match register matches the RTC value, whether or not
+    /// the interrupt is enabled.
+    pub fn matched(&self) -> bool {
+        // SAFETY: We know that self.registers points to the control registers
+        // of a PL031 device which is appropriately mapped.
+        let ris = unsafe { addr_of!((*self.registers).ris).read_volatile() };
+        (ris & 0x01) != 0
+    }
+
+    /// Returns whether there is currently an interrupt pending.
+    ///
+    /// This should be true if and only if `matched` returns true and the
+    /// interrupt is masked.
+    pub fn interrupt_pending(&self) -> bool {
+        // SAFETY: We know that self.registers points to the control registers
+        // of a PL031 device which is appropriately mapped.
+        let ris = unsafe { addr_of!((*self.registers).mis).read_volatile() };
+        (ris & 0x01) != 0
+    }
+
+    /// Sets or clears the interrupt mask.
+    ///
+    /// When the mask is true the interrupt is enabled; when it is false the
+    /// interrupt is disabled.
+    pub fn enable_interrupt(&mut self, mask: bool) {
+        let imsc = if mask { 0x01 } else { 0x00 };
+        // SAFETY: We know that self.registers points to the control registers
+        // of a PL031 device which is appropriately mapped.
+        unsafe { addr_of_mut!((*self.registers).imsc).write_volatile(imsc) }
+    }
+
+    /// Clears a pending interrupt, if any.
+    pub fn clear_interrupt(&mut self) {
+        // SAFETY: We know that self.registers points to the control registers
+        // of a PL031 device which is appropriately mapped.
+        unsafe { addr_of_mut!((*self.registers).icr).write_volatile(0x01) }
+    }
 }
 
 // SAFETY: `Rtc` just contains a pointer to device memory, which can be accessed from any context.
@@ -71,3 +126,33 @@ unsafe impl Send for Rtc {}
 // SAFETY: An `&Rtc` only allows reading device registers, which can safety be done from multiple
 // places at once.
 unsafe impl Sync for Rtc {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_timestamp() {
+        let mut registers = Registers {
+            dr: 12345678,
+            ..Registers::default()
+        };
+
+        // SAFETY: The pointer is constructed from a reference so it must be valid
+        let rtc = unsafe { Rtc::new(&mut registers as *mut Registers as _) };
+
+        assert_eq!(rtc.get_unix_timestamp(), 12345678);
+    }
+
+    #[test]
+    fn test_set_timestamp() {
+        let mut registers = Registers::default();
+
+        // SAFETY: The pointer is constructed from a reference so it must be valid
+        let mut rtc = unsafe { Rtc::new(&mut registers as *mut Registers as _) };
+
+        rtc.set_unix_timestamp(424242);
+        drop(rtc);
+        assert_eq!(registers.lr, 424242);
+    }
+}