Use riscv macros to simplify examples and tests

Author: romancardenas

riscv-peripheral/examples/e310x.rs

@@ -1,36 +1,16 @@
 //! Peripheral definitions for the E310x chip.
+//!
 //! This is a simple example of how to use the `riscv-peripheral` crate to generate
 //! peripheral definitions for a target.
 
-use riscv_pac::{
-    result::{Error, Result},
-    ExternalInterruptNumber, HartIdNumber, InterruptNumber, PriorityNumber,
-};
-
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[riscv::pac_enum(unsafe HartIdNumber)]
 pub enum HartId {
     H0 = 0,
 }
 
-unsafe impl HartIdNumber for HartId {
-    const MAX_HART_ID_NUMBER: usize = Self::H0 as usize;
-
-    #[inline]
-    fn number(self) -> usize {
-        self as _
-    }
-
-    #[inline]
-    fn from_number(number: usize) -> Result<Self> {
-        match number {
-            0 => Ok(Self::H0),
-            _ => Err(Error::InvalidVariant(number)),
-        }
-    }
-}
-
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-#[repr(usize)]
+#[riscv::pac_enum(unsafe ExternalInterruptNumber)]
 pub enum Interrupt {
     WATCHDOG = 1,
     RTC = 2,
@@ -86,29 +66,8 @@ pub enum Interrupt {
     I2C0 = 52,
 }
 
-unsafe impl InterruptNumber for Interrupt {
-    const MAX_INTERRUPT_NUMBER: usize = Self::I2C0 as usize;
-
-    #[inline]
-    fn number(self) -> usize {
-        self as _
-    }
-
-    #[inline]
-    fn from_number(number: usize) -> Result<Self> {
-        if number == 0 || number > Self::MAX_INTERRUPT_NUMBER {
-            Err(Error::InvalidVariant(number))
-        } else {
-            // SAFETY: valid interrupt number
-            Ok(unsafe { core::mem::transmute::<usize, Interrupt>(number) })
-        }
-    }
-}
-
-unsafe impl ExternalInterruptNumber for Interrupt {}
-
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-#[repr(usize)]
+#[riscv::pac_enum(unsafe PriorityNumber)]
 pub enum Priority {
     P0 = 0,
     P1 = 1,
@@ -120,25 +79,6 @@ pub enum Priority {
     P7 = 7,
 }
 
-unsafe impl PriorityNumber for Priority {
-    const MAX_PRIORITY_NUMBER: usize = Self::P7 as usize;
-
-    #[inline]
-    fn number(self) -> usize {
-        self as _
-    }
-
-    #[inline]
-    fn from_number(number: usize) -> Result<Self> {
-        if number > Self::MAX_PRIORITY_NUMBER {
-            Err(Error::InvalidVariant(number))
-        } else {
-            // SAFETY: valid priority number
-            Ok(unsafe { core::mem::transmute::<usize, Priority>(number) })
-        }
-    }
-}
-
 riscv_peripheral::clint_codegen!(
     base 0x0200_0000,
     mtime_freq 32_768,

riscv-peripheral/src/aclint.rs

@@ -92,36 +92,16 @@ impl<C: Clint> CLINT<C> {
 
 #[cfg(test)]
 pub(crate) mod test {
-    use super::HartIdNumber;
-    use riscv_pac::result::{Error, Result};
+    use riscv_pac::{result::Error, HartIdNumber};
 
     #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-    #[repr(usize)]
-    pub(crate) enum HartId {
+    #[riscv::pac_enum(unsafe HartIdNumber)]
+    pub(super) enum HartId {
         H0 = 0,
         H1 = 1,
         H2 = 2,
     }
 
-    unsafe impl HartIdNumber for HartId {
-        const MAX_HART_ID_NUMBER: usize = Self::H2 as usize;
-
-        #[inline]
-        fn number(self) -> usize {
-            self as _
-        }
-
-        #[inline]
-        fn from_number(number: usize) -> Result<Self> {
-            if number > Self::MAX_HART_ID_NUMBER {
-                Err(Error::InvalidVariant(number))
-            } else {
-                // SAFETY: valid context number
-                Ok(unsafe { core::mem::transmute::<usize, HartId>(number) })
-            }
-        }
-    }
-
     #[test]
     fn check_hart_id_enum() {
         assert_eq!(HartId::H0.number(), 0);

riscv-peripheral/src/macros.rs

@@ -32,22 +32,9 @@ pub use paste::paste;
 ///
 /// /// HART IDs for the target CLINT peripheral
 /// #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+/// #[riscv::pac_enum(unsafe HartIdNumber)]
 /// pub enum HartId { H0 = 0, H1 = 1, H2 = 2 }
 ///
-/// // Implement `HartIdNumber` for `HartId`
-/// unsafe impl riscv_peripheral::aclint::HartIdNumber for HartId {
-///   const MAX_HART_ID_NUMBER: usize = Self::H2 as usize;
-///   fn number(self) -> usize { self as _ }
-///   fn from_number(number: usize) -> Result<Self> {
-///     match number {
-///      0 => Ok(HartId::H0),
-///      1 => Ok(HartId::H1),
-///      2 => Ok(HartId::H2),
-///      _ => Err(Error::InvalidVariant(number)),
-///     }
-///   }
-/// }
-///
 /// riscv_peripheral::clint_codegen!(
 ///     base 0x0200_0000,
 ///     mtime_freq 32_768,
@@ -158,30 +145,16 @@ macro_rules! clint_codegen {
 /// let pendings = plic.pendings();     // Pendings registers
 /// ```
 ///
-///
 /// ## Base address and per-HART context proxies
 ///
 /// ```
 /// use riscv_pac::result::{Error, Result};
 ///
 /// /// HART IDs for the target CLINT peripheral
 /// #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+/// #[riscv::pac_enum(unsafe HartIdNumber)]
 /// pub enum HartId { H0 = 0, H1 = 1, H2 = 2 }
 ///
-/// // Implement `HartIdNumber` for `HartId`
-/// unsafe impl riscv_peripheral::aclint::HartIdNumber for HartId {
-///   const MAX_HART_ID_NUMBER: usize = Self::H2 as usize;
-///   fn number(self) -> usize { self as _ }
-///   fn from_number(number: usize) -> Result<Self> {
-///     match number {
-///      0 => Ok(HartId::H0),
-///      1 => Ok(HartId::H1),
-///      2 => Ok(HartId::H2),
-///      _ => Err(Error::InvalidVariant(number)),
-///     }
-///   }
-/// }
-///
 /// riscv_peripheral::plic_codegen!(
 ///     base 0x0C00_0000,
 ///     harts [HartId::H0 => 0, HartId::H1 => 1, HartId::H2 => 2], // do not forget the ending comma!
@@ -242,7 +215,7 @@ macro_rules! plic_codegen {
         $crate::macros::paste! {
             impl PLIC {
                 $(
-                    #[doc = "Returns a PLIC context proxy for context of HART "]
+                    #[doc = "Returns a PLIC context proxy for context of HART [`"]
                     #[doc = stringify!($hart)]
                     #[doc = "`]."]
                     #[inline]

riscv-peripheral/src/plic.rs

@@ -186,10 +186,10 @@ impl<P: Plic> CTX<P> {
 
 #[cfg(test)]
 pub(crate) mod test {
-    use riscv_pac::result::{Error, Result};
-    use riscv_pac::{ExternalInterruptNumber, HartIdNumber, InterruptNumber, PriorityNumber};
+    use riscv_pac::{result::Error, HartIdNumber, InterruptNumber, PriorityNumber};
 
     #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+    #[riscv::pac_enum(unsafe ExternalInterruptNumber)]
     pub(crate) enum Interrupt {
         I1 = 1,
         I2 = 2,
@@ -198,6 +198,7 @@ pub(crate) mod test {
     }
 
     #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+    #[riscv::pac_enum(unsafe PriorityNumber)]
     pub(crate) enum Priority {
         P0 = 0,
         P1 = 1,
@@ -206,73 +207,13 @@ pub(crate) mod test {
     }
 
     #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+    #[riscv::pac_enum(unsafe HartIdNumber)]
     pub(crate) enum Context {
         C0 = 0,
         C1 = 1,
         C2 = 2,
     }
 
-    unsafe impl InterruptNumber for Interrupt {
-        const MAX_INTERRUPT_NUMBER: usize = Self::I4 as usize;
-
-        #[inline]
-        fn number(self) -> usize {
-            self as _
-        }
-
-        #[inline]
-        fn from_number(number: usize) -> Result<Self> {
-            match number {
-                1 => Ok(Interrupt::I1),
-                2 => Ok(Interrupt::I2),
-                3 => Ok(Interrupt::I3),
-                4 => Ok(Interrupt::I4),
-                _ => Err(Error::InvalidVariant(number)),
-            }
-        }
-    }
-
-    unsafe impl ExternalInterruptNumber for Interrupt {}
-
-    unsafe impl PriorityNumber for Priority {
-        const MAX_PRIORITY_NUMBER: usize = Self::P3 as usize;
-
-        #[inline]
-        fn number(self) -> usize {
-            self as _
-        }
-
-        #[inline]
-        fn from_number(number: usize) -> Result<Self> {
-            match number {
-                0 => Ok(Priority::P0),
-                1 => Ok(Priority::P1),
-                2 => Ok(Priority::P2),
-                3 => Ok(Priority::P3),
-                _ => Err(Error::InvalidVariant(number)),
-            }
-        }
-    }
-
-    unsafe impl HartIdNumber for Context {
-        const MAX_HART_ID_NUMBER: usize = Self::C2 as usize;
-
-        #[inline]
-        fn number(self) -> usize {
-            self as _
-        }
-
-        #[inline]
-        fn from_number(number: usize) -> Result<Self> {
-            match number {
-                0 => Ok(Context::C0),
-                1 => Ok(Context::C1),
-                2 => Ok(Context::C2),
-                _ => Err(Error::InvalidVariant(number)),
-            }
-        }
-    }
-
     #[test]
     fn check_interrupt_enum() {
         assert_eq!(Interrupt::I1.number(), 1);