diff --git a/Cargo.toml b/Cargo.toml
index 158fc8f..0b5dc88 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,7 +10,8 @@ license = "ISC"
 edition = "2018"
 
 [dependencies]
-gd32vf103-pac = "0.4.0"
+# critical-section only required for doctests
+gd32vf103-pac = { version = "0.5.0", features = ["critical-section"] }
 riscv = "0.6.0"
 nb = "0.1.2"
 void = { version = "1.0.2", default-features = false }
diff --git a/src/eclic.rs b/src/eclic.rs
index 071892c..20b3060 100644
--- a/src/eclic.rs
+++ b/src/eclic.rs
@@ -1,5 +1,4 @@
-use crate::pac::ECLIC;
-use riscv::interrupt::Nr;
+use crate::pac::{ECLIC, Interrupt};
 
 const EFFECTIVE_LEVEL_PRIORITY_BITS: u8 = 4;
 
@@ -84,43 +83,43 @@ pub trait EclicExt {
     fn get_priority_bits() -> u8;
 
     /// Setup `interrupt`
-    fn setup<I: Nr + Copy>(interrupt: I, tt: TriggerType, level: Level, priority: Priority);
+    fn setup(interrupt: Interrupt, tt: TriggerType, level: Level, priority: Priority);
 
     /// Enables `interrupt`
-    unsafe fn unmask<I: Nr>(interrupt: I);
+    unsafe fn unmask(interrupt: Interrupt);
 
     /// Disables `interrupt`
-    fn mask<I: Nr>(interrupt: I);
+    fn mask(interrupt: Interrupt);
 
     /// Checks if `interrupt` is enabled
-    fn is_enabled<I: Nr>(interrupt: I) -> bool;
+    fn is_enabled(interrupt: Interrupt) -> bool;
 
     /// Forces `interrupt` into pending state
-    fn pend<I: Nr>(interrupt: I);
+    fn pend(interrupt: Interrupt);
 
     /// Clears `interrupt`'s pending state
-    fn unpend<I: Nr>(interrupt: I);
+    fn unpend(interrupt: Interrupt);
 
     /// Checks if `interrupt` is pending
-    fn is_pending<I: Nr>(interrupt: I) -> bool;
+    fn is_pending(interrupt: Interrupt) -> bool;
 
     /// Set `interrupt` trigger type
-    fn set_trigger_type<I: Nr>(interrupt: I, tt: TriggerType);
+    fn set_trigger_type(interrupt: Interrupt, tt: TriggerType);
 
     /// Get `interrupt` trigger type
-    fn get_trigger_type<I: Nr>(interrupt: I) -> Option<TriggerType>;
+    fn get_trigger_type(interrupt: Interrupt) -> Option<TriggerType>;
 
     // Set `interrupt` level
-    fn set_level<I: Nr>(interrupt: I, level: Level);
+    fn set_level(interrupt: Interrupt, level: Level);
 
     // Get `interrupt` level
-    fn get_level<I: Nr>(interrupt: I) -> Level;
+    fn get_level(interrupt: Interrupt) -> Level;
 
     // Set `interrupt` priority
-    fn set_priority<I: Nr>(interrupt: I, priority: Priority);
+    fn set_priority(interrupt: Interrupt, priority: Priority);
 
     // Get `interrupt` interrupt
-    fn get_priority<I: Nr>(interrupt: I) -> Priority;
+    fn get_priority(interrupt: Interrupt) -> Priority;
 }
 
 impl EclicExt for ECLIC {
@@ -181,7 +180,7 @@ impl EclicExt for ECLIC {
         EFFECTIVE_LEVEL_PRIORITY_BITS - Self::get_level_bits()
     }
 
-    fn setup<I: Nr + Copy>(interrupt: I, tt: TriggerType, level: Level, priority: Priority) {
+    fn setup(interrupt: Interrupt, tt: TriggerType, level: Level, priority: Priority) {
         Self::mask(interrupt);
         Self::set_trigger_type(interrupt, tt);
         Self::set_level(interrupt, level);
@@ -190,31 +189,25 @@ impl EclicExt for ECLIC {
     }
 
     #[inline]
-    unsafe fn unmask<I: Nr>(interrupt: I) {
-        let nr = usize::from(interrupt.nr());
-
-        (*Self::ptr()).clicints[nr]
+    unsafe fn unmask(interrupt: Interrupt) {
+        (*Self::ptr()).clicints[interrupt as usize]
             .clicintie
             .write(|w| w.ie().set_bit())
     }
 
     #[inline]
-    fn mask<I: Nr>(interrupt: I) {
-        let nr = usize::from(interrupt.nr());
-
+    fn mask(interrupt: Interrupt) {
         unsafe {
-            (*Self::ptr()).clicints[nr]
+            (*Self::ptr()).clicints[interrupt as usize]
                 .clicintie
                 .write(|w| w.ie().clear_bit())
         }
     }
 
     #[inline]
-    fn is_enabled<I: Nr>(interrupt: I) -> bool {
-        let nr = usize::from(interrupt.nr());
-
+    fn is_enabled(interrupt: Interrupt) -> bool {
         unsafe {
-            (*Self::ptr()).clicints[nr]
+            (*Self::ptr()).clicints[interrupt as usize]
                 .clicintie
                 .read()
                 .ie()
@@ -223,33 +216,27 @@ impl EclicExt for ECLIC {
     }
 
     #[inline]
-    fn pend<I: Nr>(interrupt: I) {
-        let nr = usize::from(interrupt.nr());
-
+    fn pend(interrupt: Interrupt) {
         unsafe {
-            (*Self::ptr()).clicints[nr]
+            (*Self::ptr()).clicints[interrupt as usize]
                 .clicintip
                 .write(|w| w.ip().set_bit())
         }
     }
 
     #[inline]
-    fn unpend<I: Nr>(interrupt: I) {
-        let nr = usize::from(interrupt.nr());
-
+    fn unpend(interrupt: Interrupt) {
         unsafe {
-            (*Self::ptr()).clicints[nr]
+            (*Self::ptr()).clicints[interrupt as usize]
                 .clicintip
                 .write(|w| w.ip().clear_bit())
         }
     }
 
     #[inline]
-    fn is_pending<I: Nr>(interrupt: I) -> bool {
-        let nr = usize::from(interrupt.nr());
-
+    fn is_pending(interrupt: Interrupt) -> bool {
         unsafe {
-            (*Self::ptr()).clicints[nr]
+            (*Self::ptr()).clicints[interrupt as usize]
                 .clicintip
                 .read()
                 .ip()
@@ -258,21 +245,17 @@ impl EclicExt for ECLIC {
     }
 
     #[inline]
-    fn set_trigger_type<I: Nr>(interrupt: I, tt: TriggerType) {
-        let nr = usize::from(interrupt.nr());
-
+    fn set_trigger_type(interrupt: Interrupt, tt: TriggerType) {
         unsafe {
-            (*Self::ptr()).clicints[nr]
+            (*Self::ptr()).clicints[interrupt as usize]
                 .clicintattr
                 .write(|w| w.trig().bits(tt as u8).shv().clear_bit())
         }
     }
 
     #[inline]
-    fn get_trigger_type<I: Nr>(interrupt: I) -> Option<TriggerType> {
-        let nr = usize::from(interrupt.nr());
-
-        match unsafe { (*Self::ptr()).clicints[nr].clicintattr.read().trig().bits() } {
+    fn get_trigger_type(interrupt: Interrupt) -> Option<TriggerType> {
+        match unsafe { (*Self::ptr()).clicints[interrupt as usize].clicintattr.read().trig().bits() } {
             0 => Some(TriggerType::Level),
             1 => Some(TriggerType::RisingEdge),
             3 => Some(TriggerType::FallingEdge),
@@ -281,11 +264,9 @@ impl EclicExt for ECLIC {
     }
 
     #[inline]
-    fn set_level<I: Nr>(interrupt: I, level: Level) {
-        let nr = usize::from(interrupt.nr());
-
+    fn set_level(interrupt: Interrupt, level: Level) {
         let mut intctl = unsafe {
-            (*Self::ptr()).clicints[nr]
+            (*Self::ptr()).clicints[interrupt as usize]
                 .clicintctl
                 .read()
                 .level_priority()
@@ -300,18 +281,16 @@ impl EclicExt for ECLIC {
         let level = level << (8 - level_bits);
 
         unsafe {
-            (*Self::ptr()).clicints[nr]
+            (*Self::ptr()).clicints[interrupt as usize]
                 .clicintctl
                 .write(|w| w.level_priority().bits(intctl | level))
         }
     }
 
     #[inline]
-    fn get_level<I: Nr>(interrupt: I) -> Level {
-        let nr = usize::from(interrupt.nr());
-
+    fn get_level(interrupt: Interrupt) -> Level {
         let intctl = unsafe {
-            (*Self::ptr()).clicints[nr]
+            (*Self::ptr()).clicints[interrupt as usize]
                 .clicintctl
                 .read()
                 .level_priority()
@@ -325,11 +304,9 @@ impl EclicExt for ECLIC {
     }
 
     #[inline]
-    fn set_priority<I: Nr>(interrupt: I, priority: Priority) {
-        let nr = usize::from(interrupt.nr());
-
+    fn set_priority(interrupt: Interrupt, priority: Priority) {
         let mut intctl = unsafe {
-            (*Self::ptr()).clicints[nr]
+            (*Self::ptr()).clicints[interrupt as usize]
                 .clicintctl
                 .read()
                 .level_priority()
@@ -347,18 +324,16 @@ impl EclicExt for ECLIC {
         let priority = priority << (8 - EFFECTIVE_LEVEL_PRIORITY_BITS);
 
         unsafe {
-            (*Self::ptr()).clicints[nr]
+            (*Self::ptr()).clicints[interrupt as usize]
                 .clicintctl
                 .write(|w| w.level_priority().bits(intctl | priority))
         }
     }
 
     #[inline]
-    fn get_priority<I: Nr>(interrupt: I) -> Priority {
-        let nr = usize::from(interrupt.nr());
-
+    fn get_priority(interrupt: Interrupt) -> Priority {
         let intctl = unsafe {
-            (*Self::ptr()).clicints[nr]
+            (*Self::ptr()).clicints[interrupt as usize]
                 .clicintctl
                 .read()
                 .level_priority()