update interrupt module

Author: romancardenas

Cargo.toml

@@ -58,14 +58,10 @@ html-escape = "0.2"
 url = { version = "2.5", features = ["serde"] }
 
 [dependencies.svd-parser]
-git = "https://github.com/romancardenas/svd.git" # TODO use crates.io
-rev = "ddc3d99"
 features = ["expand"]
 version = "0.14.7"
 
 [dependencies.svd-rs]
-git = "https://github.com/romancardenas/svd.git" # TODO use crates.io
-rev = "ddc3d99"
 features = ["serde"]
 version = "0.14.9"
 

src/generate/riscv.rs

@@ -15,19 +15,10 @@ pub fn render(
 ) -> Result<TokenStream> {
     let mut mod_items = TokenStream::new();
 
-    let external_interrupts = peripherals
-        .iter()
-        .flat_map(|p| p.interrupt.iter())
-        .map(|i| (i.value, i))
-        .collect::<HashMap<_, _>>();
-    let mut external_interrupts = external_interrupts.into_values().collect::<Vec<_>>();
-    external_interrupts.sort_by_key(|i| i.value);
-    if !external_interrupts.is_empty() {
-        writeln!(device_x, "/* External interrupt sources */")?;
-        mod_items.extend(quote! { pub use riscv_pac::ExternalInterruptNumber; });
-
+    if !r.core_interrupts.is_empty() {
+        writeln!(device_x, "/* Core interrupt sources and trap handlers */")?;
         let mut interrupts = vec![];
-        for i in external_interrupts.iter() {
+        for i in r.core_interrupts.iter() {
             let name = TokenStream::from_str(&i.name).unwrap();
             let value = TokenStream::from_str(&format!("{}", i.value)).unwrap();
             let description = format!(
@@ -42,29 +33,43 @@ pub fn render(
             );
 
             writeln!(device_x, "PROVIDE({name} = DefaultHandler);")?;
+            writeln!(
+                device_x,
+                "PROVIDE(_start_{name}_trap = _start_DefaultHandler_trap);"
+            )?;
 
             interrupts.push(quote! {
                 #[doc = #description]
                 #name = #value,
-            })
+            });
         }
         mod_items.extend(quote! {
-            /// External interrupts. These interrupts are handled by the external peripherals.
-            #[repr(usize)]
-            #[riscv_pac::pac_enum(unsafe ExternalInterruptNumber)]
+            /// Core interrupts. These interrupts are handled by the core itself.
+            #[riscv::pac_enum(unsafe CoreInterruptNumber)]
             #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-            pub enum ExternalInterrupt {
+            pub enum CoreInterrupt {
                 #(#interrupts)*
             }
         });
+    } else {
+        // when no interrupts are defined, we re-export the standard riscv interrupts
+        mod_items.extend(quote! {pub use riscv::interrupt::Interrupt as CoreInterrupt;});
     }
 
-    if !r.core_interrupts.is_empty() {
-        writeln!(device_x, "/* Core interrupt sources and trap handlers */")?;
-        mod_items.extend(quote! { pub use riscv_pac::CoreInterruptNumber; });
+    // TODO something similar to core interrupts but for exceptions
+    mod_items.extend(quote! { pub use riscv::interrupt::Exception; });
 
+    let external_interrupts = peripherals
+        .iter()
+        .flat_map(|p| p.interrupt.iter())
+        .map(|i| (i.value, i))
+        .collect::<HashMap<_, _>>();
+    let mut external_interrupts = external_interrupts.into_values().collect::<Vec<_>>();
+    external_interrupts.sort_by_key(|i| i.value);
+    if !external_interrupts.is_empty() {
+        writeln!(device_x, "/* External interrupt sources */")?;
         let mut interrupts = vec![];
-        for i in r.core_interrupts.iter() {
+        for i in external_interrupts.iter() {
             let name = TokenStream::from_str(&i.name).unwrap();
             let value = TokenStream::from_str(&format!("{}", i.value)).unwrap();
             let description = format!(
@@ -79,29 +84,23 @@ pub fn render(
             );
 
             writeln!(device_x, "PROVIDE({name} = DefaultHandler);")?;
-            writeln!(
-                device_x,
-                "PROVIDE(_start_{name}_trap = _start_DefaultHandler_trap);"
-            )?;
 
             interrupts.push(quote! {
                 #[doc = #description]
                 #name = #value,
-            });
+            })
         }
         mod_items.extend(quote! {
-            /// Core interrupts. These interrupts are handled by the core itself.
-            #[repr(usize)]
-            #[riscv_pac::pac_enum(unsafe CoreInterruptNumber)]
+            /// External interrupts. These interrupts are handled by the external peripherals.
+            #[riscv::pac_enum(unsafe ExternalInterruptNumber)]
             #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-            pub enum CoreInterrupt {
+            pub enum ExternalInterrupt {
                 #(#interrupts)*
             }
         });
     }
 
     if !r.priorities.is_empty() {
-        mod_items.extend(quote! { pub use riscv_pac::PriorityNumber; });
         let priorities = r.priorities.iter().map(|p| {
             let name = TokenStream::from_str(&p.name).unwrap();
             let value = TokenStream::from_str(&format!("{}", p.value)).unwrap();
@@ -123,8 +122,7 @@ pub fn render(
         });
         mod_items.extend(quote! {
             /// Priority levels in the device
-            #[repr(u8)]
-            #[riscv_pac::pac_enum(unsafe PriorityNumber)]
+            #[riscv::pac_enum(unsafe PriorityNumber)]
             #[derive(Debug, Clone, Copy, PartialEq, Eq)]
             pub enum Priority {
                 #(#priorities)*
@@ -133,7 +131,6 @@ pub fn render(
     }
 
     if !r.harts.is_empty() {
-        mod_items.extend(quote! { pub use riscv_pac::HartIdNumber; });
         let harts = r.harts.iter().map(|h| {
             let name = TokenStream::from_str(&h.name).unwrap();
             let value = TokenStream::from_str(&format!("{}", h.value)).unwrap();
@@ -155,15 +152,39 @@ pub fn render(
         });
         mod_items.extend(quote! {
             /// HARTs in the device
-            #[repr(u16)]
-            #[riscv_pac::pac_enum(unsafe HartIdNumber)]
+            #[riscv::pac_enum(unsafe HartIdNumber)]
             #[derive(Debug, Clone, Copy, PartialEq, Eq)]
             pub enum Hart {
                 #(#harts)*
             }
         });
     }
 
+    mod_items.extend(quote! {
+        pub use riscv::{
+            CoreInterruptNumber, ExceptionNumber, PriorityNumber, HartIdNumber,
+            interrupt::{enable, disable, free, nested}
+        };
+
+        pub type Trap = riscv::interrupt::Trap<CoreInterrupt, Exception>;
+
+        /// Retrieves the cause of a trap in the current hart.
+        ///
+        /// If the raw cause is not a valid interrupt or exception for the target, it returns an error.
+        #[inline]
+        pub fn try_cause() -> riscv::result::Result<Trap> {
+            riscv::interrupt::try_cause()
+        }
+
+        /// Retrieves the cause of a trap in the current hart (machine mode).
+        ///
+        /// If the raw cause is not a valid interrupt or exception for the target, it panics.
+        #[inline]
+        pub fn cause() -> Trap {
+            try_cause().unwrap()
+        }
+    });
+
     Ok(quote! {
         /// Interrupt numbers, priority levels, and HART IDs.
         pub mod interrupt {

src/lib.rs

@@ -150,7 +150,6 @@
 //!
 //! - [`critical-section`](https://crates.io/crates/critical-section) v1.x
 //! - [`riscv`](https://crates.io/crates/riscv) v0.9.x (if target is RISC-V) TODO update version
-//! - [`riscv-pac`](https://crates.io/crates/riscv-pac) v0.9.x (if target is RISC-V) TODO update version
 //! - [`riscv-peripheral`](https://crates.io/crates/riscv-peripheral) v0.9.x (if target is RISC-V and has standard peripherals) TODO update version
 //! - [`riscv-rt`](https://crates.io/crates/riscv-rt) v0.9.x (if target is RISC-V) TODO update version
 //! - [`vcell`](https://crates.io/crates/vcell) v0.1.x
@@ -163,7 +162,6 @@
 //! [dependencies]
 //! critical-section = { version = "1.0", optional = true }
 //! riscv = "0.9.0" // TODO update version
-//! riscv-pac = "0.9.0" // TODO update version
 //! riscv-peripheral = "0.9.0" // TODO update version
 //! riscv-rt = { version = "0.9.0", optional = true } // TODO update version
 //! vcell = "0.1.0"