diff --git a/Cargo.toml b/Cargo.toml
index feae6d1..879b44d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@ edition = "2018"
 targets = ["riscv64gc-unknown-none-elf"]
 
 [dependencies]
-embedded-hal = "1.0.0-alpha.1"
-nb = "0.1.1"
+embedded-hal = { version = "0.2.4", features = ["unproven"] }
+nb = "1.0.0"
 k210-pac = "0.2.0"
 bitflags = "1.2.1"
diff --git a/src/gpio.rs b/src/gpio.rs
index efe0fb9..f025ee0 100644
--- a/src/gpio.rs
+++ b/src/gpio.rs
@@ -5,7 +5,7 @@ use crate::pac;
 use crate::sysctl::{self, APB0};
 use crate::fpioa::{IoPin, Pull, Mode};
 use crate::bit_utils::{u32_set_bit, u32_toggle_bit, u32_bit_is_set, u32_bit_is_clear};
-use embedded_hal::digital::{OutputPin, StatefulOutputPin, InputPin, ToggleableOutputPin};
+use embedded_hal::digital::v2::{OutputPin, StatefulOutputPin, InputPin, ToggleableOutputPin};
 
 /// Extension trait to split a GPIO peripheral into independent pins
 pub trait GpioExt {
@@ -15,7 +15,7 @@ pub trait GpioExt {
 
 macro_rules! def_gpio_pins {
     ($($GPIOX: ident: ($num: expr, $gpiox: ident, $func: ident);)+) => {
-        
+
 impl GpioExt for pac::GPIO {
     fn split(self, apb0: &mut APB0) -> Parts {
         // enable APB0 bus
@@ -23,7 +23,7 @@ impl GpioExt for pac::GPIO {
         // enable sysctl peripheral
         sysctl::clk_en_peri().modify(|_r, w| w.gpio_clk_en().set_bit());
         // return ownership
-        Parts { 
+        Parts {
             $( $gpiox: $GPIOX { _ownership: () }, )+
         }
     }
@@ -151,7 +151,7 @@ impl<GPIO: GpioIndex, PIN: IoPin, MODE: Active> Gpio<GPIO, PIN, MODE> {
 
     #[inline]
     fn direction_in(&mut self) {
-        unsafe { 
+        unsafe {
             let p = &(*pac::GPIO::ptr()).direction as *const _ as *mut _;
             u32_set_bit(p, false, GPIO::INDEX as usize);
         }
@@ -159,7 +159,7 @@ impl<GPIO: GpioIndex, PIN: IoPin, MODE: Active> Gpio<GPIO, PIN, MODE> {
 
     #[inline]
     fn direction_out(&mut self) {
-        unsafe { 
+        unsafe {
             let p = &(*pac::GPIO::ptr()).direction as *const _ as *mut _;
             u32_set_bit(p, true, GPIO::INDEX as usize);
         }
@@ -169,15 +169,15 @@ impl<GPIO: GpioIndex, PIN: IoPin, MODE: Active> Gpio<GPIO, PIN, MODE> {
 impl<GPIO: GpioIndex, PIN, MODE> InputPin for Gpio<GPIO, PIN, Input<MODE>> {
     type Error = core::convert::Infallible;
 
-    fn try_is_high(&self) -> Result<bool, Self::Error> { 
-        Ok(unsafe { 
+    fn is_high(&self) -> Result<bool, Self::Error> {
+        Ok(unsafe {
             let p = &(*pac::GPIO::ptr()).data_input as *const _ as *const _;
             u32_bit_is_set(p, GPIO::INDEX as usize)
         })
     }
 
-    fn try_is_low(&self) -> Result<bool, Self::Error> { 
-        Ok(unsafe { 
+    fn is_low(&self) -> Result<bool, Self::Error> {
+        Ok(unsafe {
             let p = &(*pac::GPIO::ptr()).data_input as *const _ as *const _;
             u32_bit_is_clear(p, GPIO::INDEX as usize)
         })
@@ -187,16 +187,16 @@ impl<GPIO: GpioIndex, PIN, MODE> InputPin for Gpio<GPIO, PIN, Input<MODE>> {
 impl<GPIO: GpioIndex, PIN> OutputPin for Gpio<GPIO, PIN, Output> {
     type Error = core::convert::Infallible;
 
-    fn try_set_high(&mut self) -> Result<(), Self::Error> {
-        unsafe { 
+    fn set_high(&mut self) -> Result<(), Self::Error> {
+        unsafe {
             let p = &(*pac::GPIO::ptr()).data_output as *const _ as *mut _;
             u32_set_bit(p, true, GPIO::INDEX as usize);
         }
         Ok(())
     }
 
-    fn try_set_low(&mut self) -> Result<(), Self::Error> {
-        unsafe { 
+    fn set_low(&mut self) -> Result<(), Self::Error> {
+        unsafe {
             let p = &(*pac::GPIO::ptr()).data_output as *const _ as *mut _;
             u32_set_bit(p, false, GPIO::INDEX as usize);
         }
@@ -205,15 +205,15 @@ impl<GPIO: GpioIndex, PIN> OutputPin for Gpio<GPIO, PIN, Output> {
 }
 
 impl<GPIO: GpioIndex, PIN> StatefulOutputPin for Gpio<GPIO, PIN, Output> {
-    fn try_is_set_high(&self) -> Result<bool, Self::Error> {
-        Ok(unsafe { 
+    fn is_set_high(&self) -> Result<bool, Self::Error> {
+        Ok(unsafe {
             let p = &(*pac::GPIO::ptr()).data_output as *const _ as *const _;
             u32_bit_is_set(p, GPIO::INDEX as usize)
         })
     }
 
-    fn try_is_set_low(&self) -> Result<bool, Self::Error> { 
-        Ok(unsafe { 
+    fn is_set_low(&self) -> Result<bool, Self::Error> {
+        Ok(unsafe {
             let p = &(*pac::GPIO::ptr()).data_output as *const _ as *const _;
             u32_bit_is_clear(p, GPIO::INDEX as usize)
         })
@@ -223,8 +223,8 @@ impl<GPIO: GpioIndex, PIN> StatefulOutputPin for Gpio<GPIO, PIN, Output> {
 impl<GPIO: GpioIndex, PIN> ToggleableOutputPin for Gpio<GPIO, PIN, Output> {
     type Error = core::convert::Infallible;
 
-    fn try_toggle(&mut self) -> Result<(), Self::Error> { 
-        unsafe { 
+    fn toggle(&mut self) -> Result<(), Self::Error> {
+        unsafe {
             let p = &(*pac::GPIO::ptr()).data_output as *const _ as *mut _;
             u32_toggle_bit(p, GPIO::INDEX as usize);
         }
diff --git a/src/gpiohs.rs b/src/gpiohs.rs
index 9be4195..14993f9 100644
--- a/src/gpiohs.rs
+++ b/src/gpiohs.rs
@@ -1,346 +1,283 @@
 //! High-speed GPIO peripheral (GPIOHS)
 
-use crate::pac::GPIOHS;
+// use crate::bit_utils::{u32_bit_is_clear, u32_bit_is_set, u32_set_bit, u32_toggle_bit};
+use crate::fpioa::{IoPin, Mode, Pull};
+use crate::pac;
 use core::marker::PhantomData;
-use crate::bit_utils::{u32_set_bit, u32_toggle_bit, u32_bit_is_set, u32_bit_is_clear};
-use embedded_hal::digital::{InputPin, OutputPin};
+use embedded_hal::digital::v2::{InputPin, OutputPin, StatefulOutputPin, ToggleableOutputPin};
 
-// todo: verify
+// reused type state
+pub use crate::gpio::{Active, Floating, Input, Output, PullDown, PullUp, Unknown};
 
-/// Floating mode (type state)
-pub struct Floating;
-
-/// PullUp mode (type state)
-pub struct PullUp;
-
-/// Input mode (type state)
-pub struct Input<MODE>(MODE);
-
-/// Output mode (type state)
-pub struct Output<MODE>(MODE);
+/// GPIOHS Index
+pub trait GpiohsIndex {
+    type FUNC;
+    const INDEX: u8;
+}
 
 pub trait GpiohsExt {
     fn split(self) -> Parts;
 }
 
-impl GpiohsExt for GPIOHS {
-    fn split(self) -> Parts {
-        Parts { 
-            gpiohs0: Gpiohs0 { _mode: PhantomData },
-        }
-    }
-}
+pub use gpiohs_pins::*;
 
-pub struct Parts {
-    pub gpiohs0: Gpiohs0<Input<Floating>>,
-}
-
-pub struct Gpiohs0<MODE> {
-    _mode: PhantomData<MODE>,
-}
-
-impl<MODE> Gpiohs0<MODE> {
-    pub fn into_pull_up_input(self) -> Gpiohs0<Input<PullUp>> {
-        GPIOHS::set_output_en(0, false);
-        GPIOHS::set_input_en(0, true);
-        GPIOHS::set_pullup_en(0, true);
-        Gpiohs0 { _mode: PhantomData }
-    }
+macro_rules! def_gpiohs_pins {
+    ($($GPIOHSX: ident: ($num: expr, $gpiohsx: ident, $func: ident);)+) => {
 
-    // todo: all modes
-}
-
-bitflags::bitflags! {
-    pub struct Edge: u8 {
-        const RISING =  0b00000001;
-        const FALLING = 0b00000010;
-        const HIGH =    0b00000100;
-        const LOW =     0b00001000;
-    }
-}
+        pub struct Parts {
+            $( pub $gpiohsx: $GPIOHSX, )+
+        }
 
-impl<MODE> Gpiohs0<MODE> {
-    pub fn trigger_on_edge(&mut self, edge: Edge) {
-        // clear all pending bits
-        GPIOHS::clear_rise_ip(0);
-        GPIOHS::clear_fall_ip(0);
-        GPIOHS::clear_high_ip(0);
-        GPIOHS::clear_low_ip(0);
-        // enable interrupts according to flags
-        GPIOHS::set_rise_ie(0, edge.contains(Edge::RISING));
-        GPIOHS::set_fall_ie(0, edge.contains(Edge::FALLING));
-        GPIOHS::set_high_ie(0, edge.contains(Edge::HIGH));
-        GPIOHS::set_low_ie(0, edge.contains(Edge::LOW));
-    }
 
-    pub fn check_edges(&self) -> Edge {
-        let mut ans = Edge::empty();
-        if GPIOHS::has_rise_ip(0) {
-            ans |= Edge::RISING;
+        impl GpiohsExt for pac::GPIOHS {
+            fn split(self) -> Parts {
+                Parts {
+                    $( $gpiohsx: $GPIOHSX { _ownership: () }, )+
+                }
+            }
         }
-        if GPIOHS::has_fall_ip(0) {
-            ans |= Edge::FALLING;
-        }
-        if GPIOHS::has_high_ip(0) {
-            ans |= Edge::HIGH;
-        }
-        if GPIOHS::has_low_ip(0) {
-            ans |= Edge::LOW;
-        }
-        ans
-    }
 
-    pub fn clear_interrupt_pending_bits(&mut self) {
-        if GPIOHS::has_rise_ie(0) {
-            GPIOHS::set_rise_ie(0, false);
-            GPIOHS::clear_rise_ip(0);
-            GPIOHS::set_rise_ie(0, true);
-        }
-        if GPIOHS::has_fall_ie(0) {
-            GPIOHS::set_fall_ie(0, false);
-            GPIOHS::clear_fall_ip(0);
-            GPIOHS::set_fall_ie(0, true);
-        }
-        if GPIOHS::has_high_ie(0) {
-            GPIOHS::set_high_ie(0, false);
-            GPIOHS::clear_high_ip(0);
-            GPIOHS::set_high_ie(0, true);
-        }
-        if GPIOHS::has_low_ie(0) {
-            GPIOHS::set_low_ie(0, false);
-            GPIOHS::clear_low_ip(0);
-            GPIOHS::set_low_ie(0, true);
+        /// All GPIOHS pins
+        pub mod gpiohs_pins {
+            use super::GpiohsIndex;
+            $(
+            /// GPIOHS pin
+            pub struct $GPIOHSX {
+                pub(crate) _ownership: ()
+            }
+
+            impl GpiohsIndex for $GPIOHSX {
+                type FUNC = crate::fpioa::functions::$func;
+                const INDEX: u8 = $num;
+            }
+            )+
         }
     }
 }
 
-impl<MODE> InputPin for Gpiohs0<Input<MODE>> {
-    type Error = core::convert::Infallible;
-
-    fn try_is_high(&self) -> Result<bool, Self::Error> { 
-        Ok(unsafe { 
-            let p = &(*GPIOHS::ptr()).input_val as *const _ as *const _;
-            u32_bit_is_set(p, 0)
-        })
-    }
-
-    fn try_is_low(&self) -> Result<bool, Self::Error> { 
-        Ok(unsafe { 
-            let p = &(*GPIOHS::ptr()).input_val as *const _ as *const _;
-            u32_bit_is_clear(p, 0)
-        })
-    }
+def_gpiohs_pins! {
+    GPIOHS0: (0, gpiohs0, GPIOHS0);
+    GPIOHS1: (1, gpiohs1, GPIOHS1);
+    GPIOHS2: (2, gpiohs2, GPIOHS2);
+    GPIOHS3: (3, gpiohs3, GPIOHS3);
+    GPIOHS4: (4, gpiohs4, GPIOHS4);
+    GPIOHS5: (5, gpiohs5, GPIOHS5);
+    GPIOHS6: (6, gpiohs6, GPIOHS6);
+    GPIOHS7: (7, gpiohs7, GPIOHS7);
+    GPIOHS8: (8, gpiohs8, GPIOHS8);
+    GPIOHS9: (9, gpiohs9, GPIOHS9);
+    GPIOHS10: (10, gpiohs10, GPIOHS10);
+    GPIOHS11: (11, gpiohs11, GPIOHS11);
+    GPIOHS12: (12, gpiohs12, GPIOHS12);
+    GPIOHS13: (13, gpiohs13, GPIOHS13);
+    GPIOHS14: (14, gpiohs14, GPIOHS14);
+    GPIOHS15: (15, gpiohs15, GPIOHS15);
+    GPIOHS16: (16, gpiohs16, GPIOHS16);
+    GPIOHS17: (17, gpiohs17, GPIOHS17);
+    GPIOHS18: (18, gpiohs18, GPIOHS18);
+    GPIOHS19: (19, gpiohs19, GPIOHS19);
+    GPIOHS20: (20, gpiohs20, GPIOHS20);
+    GPIOHS21: (21, gpiohs21, GPIOHS21);
+    GPIOHS22: (22, gpiohs22, GPIOHS22);
+    GPIOHS23: (23, gpiohs23, GPIOHS23);
+    GPIOHS24: (24, gpiohs24, GPIOHS24);
+    GPIOHS25: (25, gpiohs25, GPIOHS25);
+    GPIOHS26: (26, gpiohs26, GPIOHS26);
+    GPIOHS27: (27, gpiohs27, GPIOHS27);
+    GPIOHS28: (28, gpiohs28, GPIOHS28);
+    GPIOHS29: (29, gpiohs29, GPIOHS29);
+    GPIOHS30: (30, gpiohs30, GPIOHS30);
+    GPIOHS31: (31, gpiohs31, GPIOHS31);
 }
 
-impl<MODE> OutputPin for Gpiohs0<Output<MODE>> {
-    type Error = core::convert::Infallible;
-
-    fn try_set_high(&mut self) -> Result<(), Self::Error> {
-        unsafe { 
-            let p = &(*GPIOHS::ptr()).output_val as *const _ as *mut _;
-            u32_set_bit(p, true, 0);
-        }
-        Ok(())
-    }
+/// GPIOHS wrapper struct
+pub struct Gpiohs<GPIOHS, PIN, MODE> {
+    gpiohs: GPIOHS,
+    pin: PIN,
+    _mode: PhantomData<MODE>,
+}
 
-    fn try_set_low(&mut self) -> Result<(), Self::Error> {
-        unsafe { 
-            let p = &(*GPIOHS::ptr()).output_val as *const _ as *mut _;
-            u32_set_bit(p, false, 0);
+impl<GPIOHS: GpiohsIndex, PIN: Mode<GPIOHS::FUNC>> Gpiohs<GPIOHS, PIN, Unknown> {
+    pub fn new(gpiohs: GPIOHS, pin: PIN) -> Gpiohs<GPIOHS, PIN, Unknown> {
+        Gpiohs {
+            gpiohs,
+            pin,
+            _mode: PhantomData,
         }
-        Ok(())
     }
 }
 
-trait GpiohsAccess {
-    fn peripheral() -> &'static mut crate::pac::gpiohs::RegisterBlock;
-
-    fn set_drive(index: usize, bit: bool) {
-        unsafe { 
-            let p = &mut Self::peripheral().drive as *mut _ as *mut _; 
-            u32_set_bit(p, bit, index);
-        }
+impl<GPIOHS, PIN, MODE> Gpiohs<GPIOHS, PIN, MODE> {
+    pub fn free(self) -> (GPIOHS, PIN) {
+        (self.gpiohs, self.pin)
     }
+}
 
-    fn input_value(index: usize) -> bool {
-        unsafe { 
-            let p = &mut Self::peripheral().input_val as *mut _ as *mut _; 
-            u32_bit_is_set(p, index)
+impl<GPIOHS: GpiohsIndex, PIN: IoPin, MODE: Active> Gpiohs<GPIOHS, PIN, MODE> {
+    pub fn into_floating_input(mut self) -> Gpiohs<GPIOHS, PIN, Input<Floating>> {
+        self.pin.set_io_pull(Pull::None);
+        self.direction_in();
+        Gpiohs {
+            gpiohs: self.gpiohs,
+            pin: self.pin,
+            _mode: PhantomData,
         }
     }
 
-    fn set_input_en(index: usize, bit: bool) {
-        unsafe { 
-            let p = &mut Self::peripheral().input_en as *mut _ as *mut _; 
-            u32_set_bit(p, bit, index);
+    pub fn into_pull_up_input(mut self) -> Gpiohs<GPIOHS, PIN, Input<PullUp>> {
+        self.pin.set_io_pull(Pull::Up);
+        self.direction_in();
+        self.enable_pullup();
+        Gpiohs {
+            gpiohs: self.gpiohs,
+            pin: self.pin,
+            _mode: PhantomData,
         }
     }
 
-    fn set_iof_en(index: usize, bit: bool) {
-        unsafe { 
-            let p = &mut Self::peripheral().iof_en as *mut _ as *mut _; 
-            u32_set_bit(p, bit, index);
+    pub fn into_pull_down_input(mut self) -> Gpiohs<GPIOHS, PIN, Input<PullDown>> {
+        self.pin.set_io_pull(Pull::Down);
+        self.direction_in();
+        self.disable_pullup();
+        Gpiohs {
+            gpiohs: self.gpiohs,
+            pin: self.pin,
+            _mode: PhantomData,
         }
     }
 
-    fn set_iof_sel(index: usize, bit: bool) {
-        unsafe { 
-            let p = &mut Self::peripheral().iof_sel as *mut _ as *mut _; 
-            u32_set_bit(p, bit, index);
+    pub fn into_push_pull_output(mut self) -> Gpiohs<GPIOHS, PIN, Output> {
+        self.pin.set_io_pull(Pull::Down);
+        self.direction_out();
+        Gpiohs {
+            gpiohs: self.gpiohs,
+            pin: self.pin,
+            _mode: PhantomData,
         }
     }
 
-    fn set_output_en(index: usize, bit: bool) {
-        unsafe { 
-            let p = &mut Self::peripheral().output_en as *mut _ as *mut _; 
-            u32_set_bit(p, bit, index);
+    #[inline]
+    fn direction_in(&mut self) {
+        unsafe {
+            (*pac::GPIOHS::ptr())
+                .output_en
+                .modify(|r, w| w.bits(r.bits() & (!(1 << GPIOHS::INDEX))));
+            (*pac::GPIOHS::ptr())
+                .input_en
+                .modify(|r, w| w.bits(r.bits() | (1 << GPIOHS::INDEX)));
         }
     }
 
-    fn set_output_value(index: usize, bit: bool) {
-        unsafe { 
-            let p = &mut Self::peripheral().output_val as *mut _ as *mut _; 
-            u32_set_bit(p, bit, index);
+    #[inline]
+    fn direction_out(&mut self) {
+        unsafe {
+            (*pac::GPIOHS::ptr())
+                .output_en
+                .modify(|r, w| w.bits(r.bits() | (1 << GPIOHS::INDEX)));
+            (*pac::GPIOHS::ptr())
+                .input_en
+                .modify(|r, w| w.bits(r.bits() & (!(1 << GPIOHS::INDEX))));
         }
     }
 
-    fn set_output_xor(index: usize, bit: bool) {
-        unsafe { 
-            let p = &mut Self::peripheral().output_xor as *mut _ as *mut _; 
-            u32_set_bit(p, bit, index);
+    #[inline]
+    fn enable_pullup(&mut self) {
+        unsafe {
+            (*pac::GPIOHS::ptr())
+                .pullup_en
+                .modify(|r, w| w.bits(r.bits() | (1 << GPIOHS::INDEX)));
         }
     }
 
-    fn toggle_pin(index: usize) {
-        unsafe { 
-            let p = &mut Self::peripheral().output_val as *mut _ as *mut _; 
-            u32_toggle_bit(p, index);
+    #[inline]
+    fn disable_pullup(&mut self) {
+        unsafe {
+            (*pac::GPIOHS::ptr())
+                .pullup_en
+                .modify(|r, w| w.bits(r.bits() & (!(1 << GPIOHS::INDEX))));
         }
     }
+}
 
-    fn set_pullup_en(index: usize, bit: bool) {
-        unsafe { 
-            let p = &mut Self::peripheral().pullup_en as *mut _ as *mut _; 
-            u32_set_bit(p, bit, index);
-        }
-    }
+impl<GPIOHS: GpiohsIndex, PIN, MODE> InputPin for Gpiohs<GPIOHS, PIN, Input<MODE>> {
+    type Error = core::convert::Infallible;
 
-    fn set_rise_ie(index: usize, bit: bool) {
-        unsafe {
-            let p = &mut Self::peripheral().rise_ie as *mut _ as *mut _; 
-            u32_set_bit(p, bit, index);
-        }
-    }
-    
-    fn clear_rise_ip(index: usize) {
-        unsafe {
-            let p = &mut Self::peripheral().rise_ip as *mut _ as *mut _; 
-            u32_set_bit(p, true, index);
-        }
-    }
-    
-    fn set_fall_ie(index: usize, bit: bool) {
-        unsafe {
-            let p = &mut Self::peripheral().fall_ie as *mut _ as *mut _; 
-            u32_set_bit(p, bit, index);
-        }
-    }
-    
-    fn clear_fall_ip(index: usize) {
-        unsafe {
-            let p = &mut Self::peripheral().fall_ip as *mut _ as *mut _; 
-            u32_set_bit(p, true, index);
-        }
-    }
-    
-    fn set_high_ie(index: usize, bit: bool) {
-        unsafe {
-            let p = &mut Self::peripheral().high_ie as *mut _ as *mut _; 
-            u32_set_bit(p, bit, index);
-        }
-    }
-    
-    fn clear_high_ip(index: usize,) {
-        unsafe {
-            let p = &mut Self::peripheral().high_ip as *mut _ as *mut _; 
-            u32_set_bit(p, true, index);
-        }
-    }
-    
-    fn set_low_ie(index: usize, bit: bool) {
-        unsafe {
-            let p = &mut Self::peripheral().low_ie as *mut _ as *mut _; 
-            u32_set_bit(p, bit, index);
-        }
-    }
-    
-    fn clear_low_ip(index: usize) {
-        unsafe {
-            let p = &mut Self::peripheral().low_ip as *mut _ as *mut _; 
-            u32_set_bit(p, true, index);
-        }
+    fn is_high(&self) -> Result<bool, Self::Error> {
+        Ok(
+            unsafe {
+                ((*pac::GPIOHS::ptr()).input_val.read().bits() >> GPIOHS::INDEX) & 0b1 == 0b1
+            },
+        )
     }
 
-    fn has_rise_ie(index: usize) -> bool {
-        unsafe {
-            let p = &mut Self::peripheral().rise_ie as *mut _ as *mut _; 
-            u32_bit_is_set(p, index)
-        }
+    fn is_low(&self) -> Result<bool, Self::Error> {
+        Ok(
+            unsafe {
+                ((*pac::GPIOHS::ptr()).input_val.read().bits() >> GPIOHS::INDEX) & 0b1 == 0b0
+            },
+        )
     }
+}
 
-    fn has_fall_ie(index: usize) -> bool {
-        unsafe {
-            let p = &mut Self::peripheral().fall_ie as *mut _ as *mut _; 
-            u32_bit_is_set(p, index)
-        }
-    }
+impl<GPIOHS: GpiohsIndex, PIN> OutputPin for Gpiohs<GPIOHS, PIN, Output> {
+    type Error = core::convert::Infallible;
 
-    fn has_high_ie(index: usize) -> bool {
+    fn set_high(&mut self) -> Result<(), Self::Error> {
         unsafe {
-            let p = &mut Self::peripheral().high_ie as *mut _ as *mut _; 
-            u32_bit_is_set(p, index)
+            (*pac::GPIOHS::ptr())
+                .output_val
+                .modify(|r, w| w.bits(r.bits() | (1 << GPIOHS::INDEX)));
         }
+        Ok(())
     }
 
-    fn has_low_ie(index: usize) -> bool {
+    fn set_low(&mut self) -> Result<(), Self::Error> {
         unsafe {
-            let p = &mut Self::peripheral().low_ie as *mut _ as *mut _; 
-            u32_bit_is_set(p, index)
+            (*pac::GPIOHS::ptr())
+                .output_val
+                .modify(|r, w| w.bits(r.bits() & (!(1 << GPIOHS::INDEX as u8))));
         }
+        Ok(())
     }
+}
 
-    fn has_rise_ip(index: usize) -> bool {
-        unsafe {
-            let p = &mut Self::peripheral().rise_ip as *mut _ as *mut _; 
-            u32_bit_is_set(p, index)
-        }
+impl<GPIOHS: GpiohsIndex, PIN> StatefulOutputPin for Gpiohs<GPIOHS, PIN, Output> {
+    fn is_set_high(&self) -> Result<bool, Self::Error> {
+        Ok(unsafe {
+            ((*pac::GPIOHS::ptr()).output_val.read().bits() >> GPIOHS::INDEX) & 0b1 == 0b1
+        })
     }
 
-    fn has_fall_ip(index: usize) -> bool {
-        unsafe {
-            let p = &mut Self::peripheral().fall_ip as *mut _ as *mut _; 
-            u32_bit_is_set(p, index)
-        }
+    fn is_set_low(&self) -> Result<bool, Self::Error> {
+        Ok(unsafe {
+            ((*pac::GPIOHS::ptr()).output_val.read().bits() >> GPIOHS::INDEX) & 0b1 == 0b0
+        })
     }
+}
 
-    fn has_high_ip(index: usize) -> bool {
-        unsafe {
-            let p = &mut Self::peripheral().high_ip as *mut _ as *mut _; 
-            u32_bit_is_set(p, index)
-        }
-    }
+impl<GPIOHS: GpiohsIndex, PIN> ToggleableOutputPin for Gpiohs<GPIOHS, PIN, Output> {
+    type Error = core::convert::Infallible;
 
-    fn has_low_ip(index: usize) -> bool {
+    fn toggle(&mut self) -> Result<(), Self::Error> {
         unsafe {
-            let p = &mut Self::peripheral().low_ip as *mut _ as *mut _; 
-            u32_bit_is_set(p, index)
+            (*pac::GPIOHS::ptr())
+                .output_val
+                .modify(|r, w| w.bits(r.bits() ^ (1 << GPIOHS::INDEX)))
         }
+        Ok(())
     }
-    
 }
 
-impl GpiohsAccess for GPIOHS {
-    fn peripheral() -> &'static mut crate::pac::gpiohs::RegisterBlock {
-        unsafe { &mut *(GPIOHS::ptr() as *mut _) }
-    }
+/// Gpiohs pin trigger edge type
+#[derive(Clone, Copy, Debug)]
+pub enum Edge {
+    None,
+    Falling,
+    Rising,
+    Both,
+    Low,
+    High = 8,
 }
+
+// TODO: interrupt
+// TODO: Drive Strength
\ No newline at end of file
diff --git a/src/serial.rs b/src/serial.rs
index 302fbb5..356b4d2 100644
--- a/src/serial.rs
+++ b/src/serial.rs
@@ -100,7 +100,7 @@ impl Serial<UARTHS> {
 impl serial::Read<u8> for Rx<UARTHS> {
     type Error = Infallible;
 
-    fn try_read(&mut self) -> nb::Result<u8, Infallible> {
+    fn read(&mut self) -> nb::Result<u8, Infallible> {
         let rxdata = self.uart.rxdata.read();
 
         if rxdata.empty().bit_is_set() {
@@ -114,7 +114,7 @@ impl serial::Read<u8> for Rx<UARTHS> {
 impl serial::Write<u8> for Tx<UARTHS> {
     type Error = Infallible;
 
-    fn try_write(&mut self, byte: u8) -> nb::Result<(), Infallible> {
+    fn write(&mut self, byte: u8) -> nb::Result<(), Infallible> {
         let txdata = self.uart.txdata.read();
 
         if txdata.full().bit_is_set() {
@@ -127,7 +127,7 @@ impl serial::Write<u8> for Tx<UARTHS> {
         }
     }
 
-    fn try_flush(&mut self) -> nb::Result<(), Infallible> {
+    fn flush(&mut self) -> nb::Result<(), Infallible> {
         let txdata = self.uart.txdata.read();
 
         if txdata.full().bit_is_set() {
@@ -200,7 +200,7 @@ impl<UART: UartX> Serial<UART> {
 impl<UART: UartX> serial::Read<u8> for Rx<UART> {
     type Error = Infallible;
 
-    fn try_read(&mut self) -> nb::Result<u8, Infallible> {
+    fn read(&mut self) -> nb::Result<u8, Infallible> {
         let lsr = self.uart.lsr.read();
 
         if (lsr.bits() & (1<<0)) == 0 { // Data Ready bit
@@ -215,7 +215,7 @@ impl<UART: UartX> serial::Read<u8> for Rx<UART> {
 impl<UART: UartX> serial::Write<u8> for Tx<UART> {
     type Error = Infallible;
 
-    fn try_write(&mut self, byte: u8) -> nb::Result<(), Infallible> {
+    fn write(&mut self, byte: u8) -> nb::Result<(), Infallible> {
         let lsr = self.uart.lsr.read();
 
         if (lsr.bits() & (1<<5)) != 0 { // Transmit Holding Register Empty bit
@@ -228,7 +228,7 @@ impl<UART: UartX> serial::Write<u8> for Tx<UART> {
         }
     }
 
-    fn try_flush(&mut self) -> nb::Result<(), Infallible> {
+    fn flush(&mut self) -> nb::Result<(), Infallible> {
         // TODO
         Ok(())
     }
diff --git a/src/spi.rs b/src/spi.rs
index 89a7f91..38bfbe8 100644
--- a/src/spi.rs
+++ b/src/spi.rs
@@ -6,18 +6,18 @@ use crate::sysctl::{self, APB0};
 pub use embedded_hal::spi::{Mode, Polarity, Phase};
 use core::convert::Infallible;
 
-/// 
+///
 pub struct Spi<SPI> {
     spi: SPI
 }
 
 impl Spi<SPI0> {
     pub fn spi0(
-        spi: SPI0, 
-        mode: Mode, 
-        frame_format: FrameFormat, 
-        endian: Endian, 
-        clock: &Clocks, 
+        spi: SPI0,
+        mode: Mode,
+        frame_format: FrameFormat,
+        endian: Endian,
+        clock: &Clocks,
         apb0: &mut APB0
     ) -> Self {
         let work_mode = hal_mode_to_pac(mode);
@@ -53,14 +53,14 @@ impl Spi<SPI0> {
         // enable APB0 bus
         apb0.enable();
         // enable peripheral via sysctl
-        sysctl::clk_en_peri().modify(|_r, w| 
+        sysctl::clk_en_peri().modify(|_r, w|
             w.spi0_clk_en().set_bit());
         Spi { spi }
     }
 
     pub fn release(self) -> SPI0 {
         // power off
-        sysctl::clk_en_peri().modify(|_r, w| 
+        sysctl::clk_en_peri().modify(|_r, w|
             w.spi0_clk_en().clear_bit());
         self.spi
     }
@@ -74,12 +74,12 @@ impl embedded_hal::spi::FullDuplex<u8> for Spi<SPI0> {
     ///
     /// **NOTE** A word must be sent to the slave before attempting to call this
     /// method.
-    fn try_read(&mut self) -> nb::Result<u8, Self::Error> {
+    fn read(&mut self) -> nb::Result<u8, Self::Error> {
         todo!()
     }
 
     /// Sends a word to the slave
-    fn try_send(&mut self, word: u8) -> nb::Result<(), Self::Error> {
+    fn send(&mut self, word: u8) -> nb::Result<(), Self::Error> {
         todo!("{}", word)
     }
 }
diff --git a/src/stdout.rs b/src/stdout.rs
index 8483cc4..98eb10b 100644
--- a/src/stdout.rs
+++ b/src/stdout.rs
@@ -13,14 +13,14 @@ impl<'p, T> Write for Stdout<'p, T>
     fn write_str(&mut self, s: &str) -> core::fmt::Result {
         for byte in s.as_bytes() {
             if *byte == b'\n' {
-                let res = block!(self.0.try_write(b'\r'));
+                let res = block!(self.0.write(b'\r'));
 
                 if res.is_err() {
                     return Err(core::fmt::Error);
                 }
             }
 
-            let res = block!(self.0.try_write(*byte));
+            let res = block!(self.0.write(*byte));
 
             if res.is_err() {
                 return Err(core::fmt::Error);