diff --git a/examples/comp.rs b/examples/comp.rs
index 5893e6d0..ec5d078c 100644
--- a/examples/comp.rs
+++ b/examples/comp.rs
@@ -46,7 +46,7 @@ fn main() -> ! {
             .output_inverted(),
         &rcc.clocks,
     );
-    let led2 = gpioa.pa12.into_push_pull_output();
+    let led2 = gpioa.pa12.into_alternate();
     // Configure PA12 to the comparator's alternate function so it gets
     // changed directly by the comparator.
     comp2.output_pin(led2);
diff --git a/examples/comp_w_dac.rs b/examples/comp_w_dac.rs
index 20600068..19213b45 100644
--- a/examples/comp_w_dac.rs
+++ b/examples/comp_w_dac.rs
@@ -30,7 +30,7 @@ fn main() -> ! {
     // Set up DAC to output to pa4 and to internal signal Dac1IntSig1
     // which just so happens is compatible with comp1
     let dac1ch1 = dp.DAC1.constrain((gpioa.pa4, Dac1IntSig1), &mut rcc);
-    let mut dac = dac1ch1.calibrate_buffer(&mut delay).enable();
+    let mut dac = dac1ch1.calibrate_buffer(&mut delay).enable().freeze();
 
     let (comp1, _comp2, ..) = dp.COMP.split(&mut rcc);
     let pa1 = gpioa.pa1.into_analog();
@@ -43,7 +43,7 @@ fn main() -> ! {
         &rcc.clocks,
     );
 
-    let led2 = gpioa.pa0.into_push_pull_output();
+    let led2 = gpioa.pa0.into_alternate();
     // Configure PA12 to the comparator's alternate function so it gets
     // changed directly by the comparator.
     comp.output_pin(led2);
diff --git a/examples/opamp.rs b/examples/opamp.rs
index e4576a7a..6e418e1d 100644
--- a/examples/opamp.rs
+++ b/examples/opamp.rs
@@ -31,35 +31,25 @@ fn main() -> ! {
     let gpioa = dp.GPIOA.split(&mut rcc);
     let gpiob = dp.GPIOB.split(&mut rcc);
 
-    // setup opamps
-    let (opamp1, opamp2, opamp3, ..) = dp.OPAMP.split(&mut rcc);
+    let pa1 = gpioa.pa1.into_analog();
+    let pa2 = gpioa.pa2.into_analog();
+    let pa7 = gpioa.pa7.into_analog();
 
-    // Set up opamp1 and opamp2 in follower mode
-    let opamp1 = opamp1.follower(gpioa.pa1, gpioa.pa2);
-    let opamp2 = opamp2.follower(gpioa.pa7, InternalOutput);
+    let pb0 = gpiob.pb0.into_analog();
+    let pb1 = gpiob.pb1.into_analog();
+    let pb2 = gpiob.pb2.into_analog();
 
-    // Set up opamp1 and opamp2 in open loop mode
-    let opamp3 = opamp3.open_loop(gpiob.pb0, gpiob.pb2, gpiob.pb1);
+    // setup opamps
+    let (opamp1, opamp2, opamp3, ..) = dp.OPAMP.split(&mut rcc);
 
-    // disable opamps
-    let (opamp1, pa1, pa2) = opamp1.disable();
-    let (opamp2, pa7) = opamp2.disable();
+    // Configure opamp1 with pa1 as non-inverting input and set gain to x2
+    let _opamp1 = opamp1.pga(&pa1, pa2, Gain::Gain2);
 
-    let (_opamp3, _pb0, _pb2, _pb1) = opamp3.disable();
+    // Set up opamp2 in follower mode with output routed to internal ADC
+    let opamp2 = opamp2.follower(&pa7, InternalOutput);
 
-    // Configure opamp1 with pa1 as non-inverting input and set gain to x2
-    let _opamp1 = opamp1.pga(
-        pa1,
-        pa2, // Route output to pin pa2
-        Gain::Gain2,
-    );
-
-    // Configure op with pa7 as non-inverting input and set gain to x4
-    let opamp2 = opamp2.pga(
-        pa7,
-        InternalOutput, // Do not route output to any external pin, use internal AD instead
-        Gain::Gain4,
-    );
+    // Set up opamp3 in open loop mode
+    let _opamp3 = opamp3.open_loop(&pb0, pb2, pb1);
 
     // Lock opamp2. After the opamp is locked its registers cannot be written
     // until the device is reset (even if using unsafe register accesses).
@@ -78,15 +68,13 @@ fn main() -> ! {
         );
 
         let millivolts = adc.sample_to_millivolts(sample);
-        info!("opamp2 thus 4x pa7: {}mV", millivolts);
+        info!("opamp2 thus pa7: {}mV", millivolts);
 
         delay.delay_ms(100);
     }
 
     #[allow(unreachable_code)]
     {
-        let (_opamp1, _pin) = _opamp1.disable();
-
         loop {
             delay.delay_ms(100);
         }
diff --git a/src/comparator.rs b/src/comparator.rs
index d0597ea7..1c7473ee 100644
--- a/src/comparator.rs
+++ b/src/comparator.rs
@@ -5,6 +5,7 @@
 //! This code has been taken from the stm32g0xx-hal project and modified slightly to support
 //! STM32G4xx MCUs.
 
+use core::borrow::Borrow;
 use core::marker::PhantomData;
 
 use crate::dac;
@@ -14,8 +15,9 @@ use crate::gpio::{
     gpiob::{PB0, PB1, PB14, PB15, PB2, PB6, PB7, PB8, PB9},
     gpioc::PC2,
     gpiof::PF4,
-    Analog, OpenDrain, Output, PushPull, SignalEdge, AF2, AF3, AF8,
+    Alternate, AlternateOD, Analog, SignalEdge, AF2, AF3, AF8,
 };
+use crate::gpio::{Frozen, IsFrozen};
 
 #[cfg(any(
     feature = "stm32g473",
@@ -139,12 +141,17 @@ pub enum Hysteresis {
 }
 
 /// Comparator positive input
-pub trait PositiveInput<C> {
-    fn setup(&self, comp: &C);
+pub trait PositiveInput<C>: crate::Sealed {
+    /// Setup comaprator to use this as its positive input
+    ///
+    /// # Safety
+    ///
+    /// Internal use only
+    unsafe fn setup(&self, comp: &mut C);
 }
 
 /// Comparator negative input
-pub trait NegativeInput<C> {
+pub trait NegativeInput<C>: crate::Sealed {
     /// Does this input use the internal reference Vrefint
     ///
     /// This only true for RefintInput
@@ -155,19 +162,36 @@ pub trait NegativeInput<C> {
     /// This is only relevant for `RefintInput` other than `RefintInput::VRefint`
     fn use_resistor_divider(&self) -> bool;
 
-    fn setup(&self, comp: &C);
+    /// Setup comaprator to use this as its negative input
+    ///
+    /// # Safety
+    ///
+    /// Internal use only
+    unsafe fn setup(&self, comp: &mut C);
 }
 
 macro_rules! positive_input_pin {
     ($COMP:ident, $pin_0:ident, $pin_1:ident) => {
-        impl PositiveInput<$COMP> for &$pin_0<Analog> {
-            fn setup(&self, comp: &$COMP) {
+        impl PositiveInput<$COMP> for &$pin_0<Analog, IsFrozen> {
+            unsafe fn setup(&self, comp: &mut $COMP) {
+                comp.csr().modify(|_, w| w.inpsel().bit(false))
+            }
+        }
+
+        impl PositiveInput<$COMP> for $pin_0<Analog> {
+            unsafe fn setup(&self, comp: &mut $COMP) {
                 comp.csr().modify(|_, w| w.inpsel().bit(false))
             }
         }
 
-        impl PositiveInput<$COMP> for &$pin_1<Analog> {
-            fn setup(&self, comp: &$COMP) {
+        impl PositiveInput<$COMP> for &$pin_1<Analog, IsFrozen> {
+            unsafe fn setup(&self, comp: &mut $COMP) {
+                comp.csr().modify(|_, w| w.inpsel().bit(true))
+            }
+        }
+
+        impl PositiveInput<$COMP> for $pin_1<Analog> {
+            unsafe fn setup(&self, comp: &mut $COMP) {
                 comp.csr().modify(|_, w| w.inpsel().bit(true))
             }
         }
@@ -212,7 +236,7 @@ macro_rules! negative_input_pin_helper {
                 false
             }
 
-            fn setup(&self, comp: &$COMP) {
+            unsafe fn setup(&self, comp: &mut $COMP) {
                 comp.csr().modify(|_, w| unsafe { w.inmsel().bits($bits) })
             }
         }
@@ -257,6 +281,9 @@ pub enum RefintInput {
     VRefint = 0b011,
 }
 
+impl Frozen<RefintInput> for RefintInput {}
+impl crate::Sealed for RefintInput {}
+
 macro_rules! refint_input {
     ($($COMP:ident, )+) => {$(
         impl NegativeInput<$COMP> for RefintInput {
@@ -266,7 +293,7 @@ macro_rules! refint_input {
                 *self != RefintInput::VRefint
             }
 
-            fn setup(&self, comp: &$COMP) {
+            unsafe fn setup(&self, comp: &mut $COMP) {
                 comp.csr()
                     .modify(|_, w| unsafe { w.inmsel().bits(*self as u8) })
             }
@@ -285,15 +312,27 @@ refint_input!(COMP1, COMP2, COMP3, COMP4,);
 refint_input!(COMP5, COMP6, COMP7,);
 
 macro_rules! dac_input_helper {
-    ($COMP:ident: $channel:ident, $MODE:ident, $bits:expr) => {
-        impl<ED> NegativeInput<$COMP> for &dac::$channel<{ dac::$MODE }, ED> {
+    ($COMP:ident: $channel:ident, $MODE:ident, $ED:ty, $bits:expr) => {
+        impl NegativeInput<$COMP> for &dac::$channel<{ dac::$MODE }, $ED, IsFrozen> {
+            const USE_VREFINT: bool = false;
+
+            fn use_resistor_divider(&self) -> bool {
+                false
+            }
+
+            unsafe fn setup(&self, comp: &mut $COMP) {
+                comp.csr().modify(|_, w| unsafe { w.inmsel().bits($bits) })
+            }
+        }
+
+        impl NegativeInput<$COMP> for dac::$channel<{ dac::$MODE }, $ED> {
             const USE_VREFINT: bool = false;
 
             fn use_resistor_divider(&self) -> bool {
                 false
             }
 
-            fn setup(&self, comp: &$COMP) {
+            unsafe fn setup(&self, comp: &mut $COMP) {
                 comp.csr().modify(|_, w| unsafe { w.inmsel().bits($bits) })
             }
         }
@@ -302,8 +341,10 @@ macro_rules! dac_input_helper {
 
 macro_rules! dac_input {
     ($COMP:ident: $channel:ident, $bits:expr) => {
-        dac_input_helper!($COMP: $channel, M_MIX_SIG, $bits);
-        dac_input_helper!($COMP: $channel, M_INT_SIG, $bits);
+        dac_input_helper!($COMP: $channel, M_MIX_SIG, dac::Enabled, $bits);
+        dac_input_helper!($COMP: $channel, M_MIX_SIG, dac::WaveGenerator, $bits);
+        dac_input_helper!($COMP: $channel, M_INT_SIG, dac::Enabled, $bits);
+        dac_input_helper!($COMP: $channel, M_INT_SIG, dac::WaveGenerator, $bits);
     };
 }
 
@@ -371,27 +412,36 @@ pub struct Comparator<C, ED> {
 
 pub trait ComparatorExt<COMP> {
     /// Initializes a comparator
-    fn comparator<P: PositiveInput<COMP>, N: NegativeInput<COMP>>(
+    fn comparator<PP, NP, P, N>(
         self,
-        positive_input: P,
-        negative_input: N,
+        positive_input: PP,
+        negative_input: NP,
         config: Config,
         clocks: &Clocks,
-    ) -> Comparator<COMP, Disabled>;
+    ) -> Comparator<COMP, Disabled>
+    where
+        PP: Frozen<P> + PositiveInput<COMP>,
+        NP: Frozen<N> + NegativeInput<COMP>;
 }
 
 macro_rules! impl_comparator {
     ($COMP:ty, $comp:ident, $Event:expr) => {
         impl ComparatorExt<$COMP> for $COMP {
-            fn comparator<P: PositiveInput<$COMP>, N: NegativeInput<$COMP>>(
-                self,
-                positive_input: P,
-                negative_input: N,
+            fn comparator<PP, NP, P, N>(
+                mut self,
+                positive_input: PP,
+                negative_input: NP,
                 config: Config,
                 clocks: &Clocks,
-            ) -> Comparator<$COMP, Disabled> {
-                positive_input.setup(&self);
-                negative_input.setup(&self);
+            ) -> Comparator<$COMP, Disabled>
+            where
+                PP: Frozen<P> + PositiveInput<$COMP>,
+                NP: Frozen<N> + NegativeInput<$COMP>,
+            {
+                unsafe {
+                    positive_input.borrow().setup(&mut self);
+                    negative_input.borrow().setup(&mut self);
+                }
                 // Delay for scaler voltage bridge initialization for certain negative inputs
                 let voltage_scaler_delay = clocks.sys_clk.raw() / (1_000_000 / 200); // 200us
                 cortex_m::asm::delay(voltage_scaler_delay);
@@ -399,9 +449,9 @@ macro_rules! impl_comparator {
                     w.hyst()
                         .bits(config.hysteresis as u8)
                         .scalen()
-                        .bit(N::USE_VREFINT)
+                        .bit(NP::USE_VREFINT)
                         .brgen()
-                        .bit(negative_input.use_resistor_divider())
+                        .bit(negative_input.borrow().use_resistor_divider())
                         .pol()
                         .bit(config.inverted)
                 });
@@ -415,13 +465,17 @@ macro_rules! impl_comparator {
 
         impl Comparator<$COMP, Disabled> {
             /// Initializes a comparator
-            pub fn $comp<P: PositiveInput<$COMP>, N: NegativeInput<$COMP>>(
+            pub fn $comp<PP, NP, P, N>(
                 comp: $COMP,
-                positive_input: P,
-                negative_input: N,
+                positive_input: PP,
+                negative_input: NP,
                 config: Config,
                 clocks: &Clocks,
-            ) -> Self {
+            ) -> Self
+            where
+                PP: Frozen<P> + PositiveInput<$COMP>,
+                NP: Frozen<N> + NegativeInput<$COMP>,
+            {
                 comp.comparator(positive_input, negative_input, config, clocks)
             }
 
@@ -486,9 +540,7 @@ macro_rules! impl_comparator {
             /// Configures a GPIO pin to output the signal of the comparator
             ///
             /// Multiple GPIO pins may be configured as the output simultaneously.
-            pub fn output_pin<P: OutputPin<$COMP>>(&self, pin: P) {
-                pin.setup();
-            }
+            pub fn output_pin<P: OutputPin<$COMP>>(&self, _pin: P) {}
         }
     };
 }
@@ -587,22 +639,16 @@ impl ComparatorSplit for COMP {
     }
 }
 
-pub trait OutputPin<COMP> {
-    fn setup(self);
-}
+pub trait OutputPin<COMP> {}
 
 #[allow(unused_macros)] // TODO: add support for more devices
 macro_rules! output_pin {
-    ($COMP:ident, $pin:ident, $AF:ident, $mode_t:ident, $into:ident) => {
-        impl OutputPin<$COMP> for $pin<Output<$mode_t>> {
-            fn setup(self) {
-                self.$into::<$AF>();
-            }
-        }
+    ($COMP:ident, $pin:ident, $AF:ident, $mode_t:ident) => {
+        impl OutputPin<$COMP> for $pin<$mode_t<$AF>> {}
     };
     ($($COMP:ident: $pin:ident, $AF:ident,)+) => {$(
-        output_pin!($COMP, $pin, $AF, PushPull, into_alternate);
-        output_pin!($COMP, $pin, $AF, OpenDrain, into_alternate_open_drain);
+        output_pin!($COMP, $pin, $AF, Alternate);
+        output_pin!($COMP, $pin, $AF, AlternateOD);
     )+};
 }
 
diff --git a/src/dac.rs b/src/dac.rs
index 109374c0..84b5d447 100644
--- a/src/dac.rs
+++ b/src/dac.rs
@@ -9,7 +9,7 @@ use core::marker::PhantomData;
 use core::mem::MaybeUninit;
 
 use crate::gpio::gpioa::{PA4, PA5, PA6};
-use crate::gpio::DefaultMode;
+use crate::gpio::{DefaultMode, Frozen, IsFrozen, IsNotFrozen};
 use crate::rcc::{self, *};
 use crate::stm32::{DAC1, DAC2, DAC3, DAC4, RCC};
 use hal::blocking::delay::DelayUs;
@@ -64,9 +64,26 @@ impl ED for Disabled {}
 
 macro_rules! impl_dac {
     ($DACxCHy:ident) => {
-        pub struct $DACxCHy<const MODE_BITS: u8, ED> {
+        pub struct $DACxCHy<const MODE_BITS: u8, ED, F = IsNotFrozen> {
             _enabled: PhantomData<ED>,
+            _frozen_state: PhantomData<F>,
         }
+
+        impl<const M: u8> Frozen<$DACxCHy<M, Enabled, IsFrozen>> for $DACxCHy<M, Enabled> {}
+        impl<const M: u8> Frozen<$DACxCHy<M, Enabled, IsFrozen>> for $DACxCHy<M, WaveGenerator> {}
+        impl<const M: u8> Frozen<$DACxCHy<M, Enabled, IsFrozen>>
+            for &$DACxCHy<M, Enabled, IsFrozen>
+        {
+        }
+        impl<const M: u8> Frozen<$DACxCHy<M, Enabled, IsFrozen>>
+            for &$DACxCHy<M, WaveGenerator, IsFrozen>
+        {
+        }
+
+        impl<const M: u8> crate::Sealed for $DACxCHy<M, Enabled> {}
+        impl<const M: u8> crate::Sealed for $DACxCHy<M, WaveGenerator> {}
+        impl<const M: u8> crate::Sealed for &$DACxCHy<M, Enabled, IsFrozen> {}
+        impl<const M: u8> crate::Sealed for &$DACxCHy<M, WaveGenerator, IsFrozen> {}
     };
 }
 
@@ -198,6 +215,7 @@ macro_rules! dac_helper {
 
                     $CX {
                         _enabled: PhantomData,
+                        _frozen_state: PhantomData,
                     }
                 }
 
@@ -214,11 +232,12 @@ macro_rules! dac_helper {
 
                     $CX {
                         _enabled: PhantomData,
+                        _frozen_state: PhantomData,
                     }
                 }
             }
 
-            impl<const MODE_BITS: u8, ED> $CX<MODE_BITS, ED> {
+            impl<const MODE_BITS: u8, ED> $CX<MODE_BITS, ED, IsNotFrozen> {
                 /// Calibrate the DAC output buffer by performing a "User
                 /// trimming" operation. It is useful when the VDDA/VREF+
                 /// voltage or temperature differ from the factory trimming
@@ -251,6 +270,7 @@ macro_rules! dac_helper {
 
                     $CX {
                         _enabled: PhantomData,
+                        _frozen_state: PhantomData,
                     }
                 }
 
@@ -263,13 +283,18 @@ macro_rules! dac_helper {
 
                     $CX {
                         _enabled: PhantomData,
+                        _frozen_state: PhantomData,
                     }
                 }
+
+                pub fn freeze(self) -> $CX<MODE_BITS, ED, IsFrozen> {
+                    $CX { _enabled: PhantomData, _frozen_state: PhantomData }
+                }
             }
 
             /// DacOut implementation available in any Enabled/Disabled
             /// state
-            impl<const MODE_BITS: u8, ED> DacOut<u16> for $CX<MODE_BITS, ED> {
+            impl<const MODE_BITS: u8, ED, F> DacOut<u16> for $CX<MODE_BITS, ED, F> {
                 fn set_value(&mut self, val: u16) {
                     let dac = unsafe { &(*<$DAC>::ptr()) };
                     dac.$dhrx.write(|w| unsafe { w.bits(val as u32) });
@@ -282,7 +307,7 @@ macro_rules! dac_helper {
             }
 
             /// Wave generator state implementation
-            impl<const MODE_BITS: u8> $CX<MODE_BITS, WaveGenerator> {
+            impl<const MODE_BITS: u8, F> $CX<MODE_BITS, WaveGenerator, F> {
                 pub fn trigger(&mut self) {
                     let dac = unsafe { &(*<$DAC>::ptr()) };
                     dac.dac_swtrgr.write(|w| { w.$swtrig().set_bit() });
diff --git a/src/gpio.rs b/src/gpio.rs
index 967d7c7d..13f14f88 100644
--- a/src/gpio.rs
+++ b/src/gpio.rs
@@ -17,6 +17,65 @@ pub trait GpioExt {
     fn split(self, rcc: &mut Rcc) -> Self::Parts;
 }
 
+/// Type state for a gpio pin frozen to its current mode
+///
+/// The into_alternate/analog/{x}_input/output can not be called on a pin with this state.
+/// The pin is thus guaranteed to stay as this type as long as the program is running.
+pub struct IsFrozen;
+
+/// See [IsFrozen]
+pub struct IsNotFrozen;
+
+/// A pin type that is guaranteed to stay in the current mode after being passed to a peripheral
+///
+/// This is implemented for all owned pins since no one else can change their mode once ownership is passed on to the peripheral.
+///
+/// It is also implemented for reference to a frozen pin `&$PXi<MODE, IsFrozen>`, since they can not change mode due to being frozen.
+pub trait Frozen<T>: crate::Sealed {}
+impl<A1, A2, B1, B2> Frozen<(B1, B2)> for (A1, A2)
+where
+    A1: Frozen<B1>,
+    A2: Frozen<B2>,
+{
+}
+impl<A1, A2, A3, B1, B2, B3> Frozen<(B1, B2, B3)> for (A1, A2, A3)
+where
+    A1: Frozen<B1>,
+    A2: Frozen<B2>,
+    A3: Frozen<B3>,
+{
+}
+impl<A1, A2, A3, A4, B1, B2, B3, B4> Frozen<(B1, B2, B3, B4)> for (A1, A2, A3, A4)
+where
+    A1: Frozen<B1>,
+    A2: Frozen<B2>,
+    A3: Frozen<B3>,
+    A4: Frozen<B4>,
+{
+}
+
+impl<A1, A2> crate::Sealed for (A1, A2)
+where
+    A1: crate::Sealed,
+    A2: crate::Sealed,
+{
+}
+impl<A1, A2, A3> crate::Sealed for (A1, A2, A3)
+where
+    A1: crate::Sealed,
+    A2: crate::Sealed,
+    A3: crate::Sealed,
+{
+}
+impl<A1, A2, A3, A4> crate::Sealed for (A1, A2, A3, A4)
+where
+    A1: crate::Sealed,
+    A2: crate::Sealed,
+    A3: crate::Sealed,
+    A4: crate::Sealed,
+{
+}
+
 /// Input mode (type state)
 pub struct Input<MODE> {
     _mode: PhantomData<MODE>,
@@ -260,7 +319,7 @@ macro_rules! gpio {
                     rcc.rb.ahb2enr.modify(|_, w| w.$iopxenr().set_bit());
                     Parts {
                         $(
-                            $pxi: $PXi { _mode: PhantomData },
+                            $pxi: $PXi { _mode: PhantomData, _frozen_state: PhantomData },
                         )+
                     }
                 }
@@ -338,10 +397,16 @@ macro_rules! gpio {
             exti_erased!($PXx<Input<MODE>>, $Pxn);
 
             $(
-                pub struct $PXi<MODE> {
+                pub struct $PXi<MODE, F = IsNotFrozen> {
                     _mode: PhantomData<MODE>,
+                    _frozen_state: PhantomData<F>,
                 }
 
+                impl<MODE> Frozen<$PXi<MODE, IsFrozen>> for $PXi<MODE> {}
+                impl<MODE> Frozen<$PXi<MODE, IsFrozen>> for &$PXi<MODE, IsFrozen> {}
+                impl<MODE, F> crate::Sealed for $PXi<MODE, F> {}
+                impl<MODE> crate::Sealed for &$PXi<MODE, IsFrozen> {}
+
                 #[allow(clippy::from_over_into)]
                 impl Into<$PXi<Input<PullDown>>> for $PXi<DefaultMode> {
                     fn into(self) -> $PXi<Input<PullDown>> {
@@ -358,7 +423,7 @@ macro_rules! gpio {
 
                 #[allow(clippy::from_over_into)]
                 impl Into<$PXi<Analog>> for $PXi<DefaultMode> {
-                    fn into(self) -> $PXi<Analog> {
+                    fn into(self) -> $PXi<Analog, IsNotFrozen> {
                         self.into_analog()
                     }
                 }
@@ -377,7 +442,7 @@ macro_rules! gpio {
                     }
                 }
 
-                impl<MODE> $PXi<MODE> {
+                impl<MODE> $PXi<MODE, IsNotFrozen> {
                     /// Configures the pin to operate as a floating input pin
                     pub fn into_floating_input(self) -> $PXi<Input<Floating>> {
                         let offset = 2 * $i;
@@ -390,7 +455,7 @@ macro_rules! gpio {
                                 w.bits(r.bits() & !(0b11 << offset))
                             })
                         };
-                        $PXi { _mode: PhantomData }
+                        $PXi { _mode: PhantomData, _frozen_state: PhantomData }
                     }
 
                     /// Configures the pin to operate as a pulled down input pin
@@ -405,7 +470,7 @@ macro_rules! gpio {
                                 w.bits(r.bits() & !(0b11 << offset))
                             })
                         };
-                        $PXi { _mode: PhantomData }
+                        $PXi { _mode: PhantomData, _frozen_state: PhantomData }
                     }
 
                     /// Configures the pin to operate as a pulled up input pin
@@ -420,11 +485,11 @@ macro_rules! gpio {
                                 w.bits(r.bits() & !(0b11 << offset))
                             })
                         };
-                        $PXi { _mode: PhantomData }
+                        $PXi { _mode: PhantomData, _frozen_state: PhantomData }
                     }
 
                     /// Configures the pin to operate as an analog pin
-                    pub fn into_analog(self) -> $PXi<Analog> {
+                    pub fn into_analog<F>(self) -> $PXi<Analog, F> {
                         let offset = 2 * $i;
                         unsafe {
                             let gpio = &(*$GPIOX::ptr());
@@ -435,7 +500,7 @@ macro_rules! gpio {
                                 w.bits((r.bits() & !(0b11 << offset)) | (0b11 << offset))
                             });
                         }
-                        $PXi { _mode: PhantomData }
+                        $PXi { _mode: PhantomData, _frozen_state: PhantomData }
                     }
 
                     /// Configures the pin to operate as an open drain output pin
@@ -453,7 +518,7 @@ macro_rules! gpio {
                                 w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset))
                             })
                         };
-                        $PXi { _mode: PhantomData }
+                        $PXi { _mode: PhantomData, _frozen_state: PhantomData }
                     }
 
                     /// Configures the pin to operate as an push pull output pin
@@ -471,13 +536,13 @@ macro_rules! gpio {
                                 w.bits((r.bits() & !(0b11 << offset)) | (0b01 << offset))
                             })
                         };
-                        $PXi { _mode: PhantomData }
+                        $PXi { _mode: PhantomData, _frozen_state: PhantomData }
                     }
 
                     /// Configures the pin as external trigger
                     pub fn listen(self, edge: SignalEdge, exti: &mut EXTI) -> $PXi<MODE> {
                         exti.listen(Event::from_code($i), edge);
-                        $PXi { _mode: PhantomData }
+                        $PXi { _mode: PhantomData, _frozen_state: PhantomData }
                     }
 
                     /// Set pin speed
@@ -491,7 +556,7 @@ macro_rules! gpio {
                         self
                     }
 
-                    pub fn into_alternate<const A: u8>(self) -> $PXi<Alternate<A>> {
+                    pub fn into_alternate<const A: u8, F>(self) -> $PXi<Alternate<A>, F> {
                         let mode = A as u32;
                         let offset = 2 * $i;
                         let offset2 = 4 * $i;
@@ -514,10 +579,10 @@ macro_rules! gpio {
                                 w.bits(r.bits() & !(0b1 << $i))
                             });
                         }
-                        $PXi { _mode: PhantomData }
+                        $PXi { _mode: PhantomData, _frozen_state: PhantomData }
                     }
 
-                    pub fn into_alternate_open_drain<const A: u8>(self) -> $PXi<AlternateOD<A>> {
+                    pub fn into_alternate_open_drain<const A: u8, F>(self) -> $PXi<AlternateOD<A>, F> {
                         let mode = A as u32;
                         let offset = 2 * $i;
                         let offset2 = 4 * $i;
@@ -540,11 +605,15 @@ macro_rules! gpio {
                                 w.bits((r.bits() & !(0b11 << offset)) | (0b10 << offset))
                             });
                         }
-                        $PXi { _mode: PhantomData }
+                        $PXi { _mode: PhantomData, _frozen_state: PhantomData }
+                    }
+
+                    pub fn freeze(self) -> $PXi<MODE, IsFrozen> {
+                        $PXi { _mode: PhantomData, _frozen_state: PhantomData }
                     }
                 }
 
-                impl<MODE> $PXi<Output<MODE>> {
+                impl<MODE> $PXi<Output<MODE>, IsNotFrozen> {
                     /// Erases the pin number from the type
                     ///
                     /// This is useful when you want to collect the pins into an array where you
@@ -554,7 +623,7 @@ macro_rules! gpio {
                     }
                 }
 
-                impl<MODE> OutputPin for $PXi<Output<MODE>> {
+                impl<MODE, F> OutputPin for $PXi<Output<MODE>, F> {
                     type Error = ();
 
                     fn set_high(&mut self) -> Result<(), ()> {
@@ -570,7 +639,7 @@ macro_rules! gpio {
                     }
                 }
 
-                impl<MODE> StatefulOutputPin for $PXi<Output<MODE>> {
+                impl<MODE, F> StatefulOutputPin for $PXi<Output<MODE>, F> {
                     fn is_set_high(&self) -> Result<bool, ()> {
                         let is_set_high = !self.is_set_low()?;
                         Ok(is_set_high)
@@ -583,10 +652,10 @@ macro_rules! gpio {
                     }
                 }
 
-                impl<MODE> toggleable::Default for $PXi<Output<MODE>> {
+                impl<MODE, F> toggleable::Default for $PXi<Output<MODE>, F> {
                 }
 
-                impl<MODE> InputPin for $PXi<Output<MODE>> {
+                impl<MODE, F> InputPin for $PXi<Output<MODE>, F> {
                     type Error = ();
 
                     fn is_high(&self) -> Result<bool, ()> {
@@ -601,7 +670,7 @@ macro_rules! gpio {
                     }
                 }
 
-                impl<MODE> $PXi<Input<MODE>> {
+                impl<MODE> $PXi<Input<MODE>, IsNotFrozen> {
                     /// Erases the pin number from the type
                     ///
                     /// This is useful when you want to collect the pins into an array where you
@@ -611,7 +680,7 @@ macro_rules! gpio {
                     }
                 }
 
-                impl<MODE> InputPin for $PXi<Input<MODE>> {
+                impl<MODE, F> InputPin for $PXi<Input<MODE>, F> {
                     type Error = ();
 
                     fn is_high(&self) -> Result<bool, ()> {
diff --git a/src/opamp.rs b/src/opamp.rs
index 0b549229..2babe962 100644
--- a/src/opamp.rs
+++ b/src/opamp.rs
@@ -59,7 +59,28 @@
 
 // TODO: Add support for calibration
 
-use core::{borrow::Borrow, marker::PhantomData};
+use crate::gpio::{
+    gpioa::{PA1, PA2, PA3, PA5, PA6, PA7},
+    gpiob::{PB0, PB1, PB10, PB13, PB14, PB2},
+    gpioc::PC5,
+    gpiod::PD14,
+};
+
+#[cfg(any(
+    feature = "stm32g473",
+    feature = "stm32g474",
+    feature = "stm32g483",
+    feature = "stm32g484",
+))]
+use crate::gpio::{
+    gpioa::PA8,
+    gpiob::{PB11, PB12, PB15},
+    gpioc::PC3,
+    gpiod::{PD11, PD12, PD8, PD9},
+};
+
+use crate::gpio::{Analog, Frozen, IsFrozen};
+use core::marker::PhantomData;
 
 /// PGA Gain
 pub enum Gain {
@@ -84,21 +105,21 @@ pub struct Disabled<Opamp> {
 /// State type for opamp running in voltage follower mode.
 pub struct Follower<Opamp, Input, Output> {
     opamp: PhantomData<Opamp>,
-    input: Input,
-    output: Output,
+    input: PhantomData<Input>,
+    output: PhantomData<Output>,
 }
 /// State type for opamp running in open-loop mode.
 pub struct OpenLoop<Opamp, NonInverting, Inverting, Output> {
     opamp: PhantomData<Opamp>,
-    non_inverting: NonInverting,
-    inverting: Inverting,
-    output: Output,
+    non_inverting: PhantomData<NonInverting>,
+    inverting: PhantomData<Inverting>,
+    output: PhantomData<Output>,
 }
 /// State type for opamp running in programmable-gain mode.
 pub struct Pga<Opamp, NonInverting, Output> {
     opamp: PhantomData<Opamp>,
     non_inverting: PhantomData<NonInverting>,
-    output: Output,
+    output: PhantomData<Output>,
 }
 /// State type for an opamp that has been locked.
 pub struct Locked<Opamp, Output> {
@@ -141,22 +162,25 @@ where
     Opamp: ConfigurePgaReg<Opamp, NonInverting> + LookupPgaGain,
 {
     /// Configures the opamp for programmable gain operation.
-    fn pga<B: Borrow<NonInverting>>(
+    fn pga<IP, OP>(
         self,
-        non_inverting: B,
-        output: Output,
+        non_inverting: IP,
+        output: OP,
         gain: Gain,
-    ) -> Pga<Opamp, NonInverting, Output>;
+    ) -> Pga<Opamp, NonInverting, Output>
+    where
+        IP: Frozen<NonInverting>,
+        OP: Frozen<Output>;
 
     /// Trait for opamps that can be run in programmable gain mode,
     /// with external filtering.
     fn pga_external_filter<
-        B1: Borrow<NonInverting>,
-        B2: Borrow<<Opamp as ConfigurePgaReg<Opamp, NonInverting>>::Vinm0>,
+        P1: Frozen<NonInverting>,
+        P2: Frozen<<Opamp as ConfigurePgaReg<Opamp, NonInverting>>::Vinm0>,
     >(
         self,
-        non_inverting: B1,
-        filter: B2,
+        non_inverting: P1,
+        filter: P2,
         output: Output,
         gain: Gain,
     ) -> Pga<Opamp, NonInverting, Output>;
@@ -164,8 +188,8 @@ where
     /// Configures the opamp for programmable gain operation, with
     /// external filtering.
     fn pga_external_bias<
-        B1: Borrow<NonInverting>,
-        B2: Borrow<<Opamp as ConfigurePgaReg<Opamp, NonInverting>>::Vinm0>,
+        B1: Frozen<NonInverting>,
+        B2: Frozen<<Opamp as ConfigurePgaReg<Opamp, NonInverting>>::Vinm0>,
     >(
         self,
         non_inverting: B1,
@@ -177,9 +201,9 @@ where
     /// Configures the opamp for programmable gain operation, with
     /// external filtering.
     fn pga_external_bias_and_filter<
-        B1: Borrow<NonInverting>,
-        B2: Borrow<<Opamp as ConfigurePgaReg<Opamp, NonInverting>>::Vinm0>,
-        B3: Borrow<<Opamp as ConfigurePgaReg<Opamp, NonInverting>>::Vinm1>,
+        B1: Frozen<NonInverting>,
+        B2: Frozen<<Opamp as ConfigurePgaReg<Opamp, NonInverting>>::Vinm0>,
+        B3: Frozen<<Opamp as ConfigurePgaReg<Opamp, NonInverting>>::Vinm1>,
     >(
         self,
         non_inverting: B1,
@@ -209,7 +233,6 @@ where
     /// Configure the
     ///
     fn configure_pga<Output>(
-        output: Output,
         gain: Gain,
         mode: PgaMode,
         output_enable: bool,
@@ -218,7 +241,7 @@ where
         Pga {
             opamp: PhantomData,
             non_inverting: PhantomData,
-            output,
+            output: PhantomData,
         }
     }
 }
@@ -251,27 +274,21 @@ macro_rules! opamps {
             $opamp:ident => $opampreg:ident
             :
             {
-                vinm0: $vinm0:ty,
-                vinm1: $vinm1:ty,
-
                 inverting
                 :
                 {
-                    $(
-                        $inverting:ty
-                        :
-                        $inverting_mask:tt
-                    ),*
-                    $(,)?
+                    vinm0: $vinm0:ty,
+                    vinm1: $vinm1:ty,
                 }
                 ,
                 non_inverting
                 :
                 {
                     $(
-                        $non_inverting:ty
-                        :
                         $non_inverting_mask:tt
+                        :
+                        $non_inverting:ty
+
                     ),*
                     $(,)?
                 }
@@ -366,41 +383,15 @@ macro_rules! opamps {
                     }
                 }
 
-                impl<Input> Follower<$opamp, Input, $output> {
-                    /// Disables the opamp and returns the resources it held.
-                    pub fn disable(self) -> (Disabled<$opamp>, Input, $output) {
-                        unsafe { $opamp::_reset() };
-                        (Disabled { opamp: PhantomData }, self.input, self.output)
-                    }
-
-                    /// Disables the external output.
-                    /// This will connect the opamp output to the internal ADC.
-                    /// If the output was enabled, the output pin is returned.
-                    pub fn disable_output(self) -> (Follower<$opamp, Input, InternalOutput>, $output) {
-                        unsafe { $opamp::_disable_output(); }
-                        (Follower::<$opamp, Input, InternalOutput> {
-                            opamp: PhantomData,
-                            input: self.input,
-                            output: InternalOutput,
-                        }, self.output)
-                    }
-                }
-
                 impl<Input> Follower<$opamp, Input, InternalOutput> {
-                    /// Disables the opamp and returns the resources it held.
-                    pub fn disable(self) -> (Disabled<$opamp>, Input) {
-                        unsafe { $opamp::_reset() };
-                        (Disabled { opamp: PhantomData }, self.input)
-                    }
-
                     /// Enables the external output pin.
-                    pub fn enable_output(self, output:$output) -> Follower<$opamp, Input, $output> {
+                    pub fn enable_output(self, _output: $output) -> Follower<$opamp, Input, $output> {
                         unsafe { $opamp::_enable_output(); }
 
                         Follower::<$opamp, Input, $output> {
                             opamp: PhantomData,
                             input: self.input,
-                            output,
+                            output: PhantomData,
                         }
                     }
                 }
@@ -415,43 +406,16 @@ macro_rules! opamps {
                     }
                 }
 
-                impl<NonInverting, Inverting> OpenLoop<$opamp, NonInverting, Inverting, $output> {
-                    /// Disables the opamp and returns the resources it held.
-                    pub fn disable(self) -> (Disabled<$opamp>, NonInverting, Inverting, $output) {
-                        unsafe { $opamp::_reset() };
-                        (Disabled { opamp: PhantomData }, self.non_inverting, self.inverting, self.output)
-                    }
-
-                    /// Disables the external output.
-                    /// This will connect the opamp output to the internal ADC.
-                    /// If the output was enabled, the output pin is returned.
-                    pub fn disable_output(self) -> (OpenLoop<$opamp, NonInverting, Inverting, InternalOutput>, $output) {
-                        unsafe { $opamp::_disable_output(); }
-                        (OpenLoop::<$opamp, NonInverting, Inverting, InternalOutput> {
-                            opamp: PhantomData,
-                            inverting: self.inverting,
-                            non_inverting: self.non_inverting,
-                            output: InternalOutput,
-                        }, self.output)
-                    }
-                }
-
                 impl<NonInverting, Inverting> OpenLoop<$opamp, NonInverting, Inverting, InternalOutput> {
-                    /// Disables the opamp and returns the resources it held.
-                    pub fn disable(self) -> (Disabled<$opamp>, NonInverting, Inverting) {
-                        unsafe { $opamp::_reset() };
-                        (Disabled { opamp: PhantomData }, self.non_inverting, self.inverting)
-                    }
-
                     /// Enables the external output pin.
-                    pub fn enable_output(self, output:$output) -> OpenLoop<$opamp, NonInverting, Inverting, $output> {
+                    pub fn enable_output(self, _output:$output) -> OpenLoop<$opamp, NonInverting, Inverting, $output> {
                         unsafe { $opamp::_enable_output(); }
 
                         OpenLoop::<$opamp, NonInverting, Inverting, $output> {
                             opamp: PhantomData,
-                            inverting: self.inverting,
-                            non_inverting: self.non_inverting,
-                            output,
+                            inverting: PhantomData,
+                            non_inverting: PhantomData,
+                            output: PhantomData,
                         }
                     }
                 }
@@ -466,25 +430,6 @@ macro_rules! opamps {
                     }
                 }
 
-                impl<NonInverting> Pga<$opamp, NonInverting, $output> {
-                    /// Disables the opamp and returns the resources it held.
-                    pub fn disable(self) -> (Disabled<$opamp>, $output) {
-                        unsafe { $opamp::_reset() };
-                        (Disabled { opamp: PhantomData }, self.output)
-                    }
-
-                    /// Disables the external output.
-                    /// This will connect the opamp output to the internal ADC.
-                    pub fn disable_output(self) -> (Pga<$opamp, NonInverting, InternalOutput>, $output) {
-                        unsafe { $opamp::_disable_output(); }
-                        (Pga::<$opamp, NonInverting, InternalOutput> {
-                            opamp: PhantomData,
-                            non_inverting: self.non_inverting,
-                            output: InternalOutput,
-                        }, self.output)
-                    }
-                }
-
                 impl<NonInverting> Pga<$opamp, NonInverting, InternalOutput> {
                     /// Disables the opamp and returns the resources it held.
                     pub fn disable(self) -> Disabled<$opamp> {
@@ -493,7 +438,7 @@ macro_rules! opamps {
                     }
 
                     /// Enables the external output pin.
-                    pub fn enable_output<IntoOutput>(self, output: IntoOutput) -> Pga<$opamp, NonInverting, $output>
+                    pub fn enable_output<IntoOutput>(self, _output: IntoOutput) -> Pga<$opamp, NonInverting, $output>
                     where
                         IntoOutput: Into<$output>,
                     {
@@ -502,13 +447,13 @@ macro_rules! opamps {
                         Pga::<$opamp, NonInverting, $output> {
                             opamp: PhantomData,
                             non_inverting: self.non_inverting,
-                            output: output.into(),
+                            output: PhantomData,
                         }
                     }
                 }
 
                 opamps!{ @follower $opamp => $opampreg, $output, $($non_inverting_mask, $non_inverting),* }
-                opamps!{ @open_loop_tt $opamp => $opampreg, $output, $($non_inverting_mask, $non_inverting),* : ($($inverting_mask, $inverting),*) }
+                opamps!{ @open_loop_tt $opamp => $opampreg, $output, $($non_inverting_mask, $non_inverting),* : (vinm0, $vinm0, vinm1, $vinm1) }
                 opamps!{ @pga_tt $opamp => $opampreg, $output, $($non_inverting_mask, $non_inverting),* : $vinm0, $vinm1 }
 
             )*
@@ -555,31 +500,30 @@ macro_rules! opamps {
     } => {
         paste::paste!{
             $(
-            impl <IntoInput, IntoOutput> IntoFollower <$opamp, IntoInput, IntoOutput, $input, $output> for Disabled<$opamp>
+            impl <Input, IntoOutput> IntoFollower <$opamp, Input, IntoOutput, $input, $output> for Disabled<$opamp>
                 where
-                    IntoInput: Into<$input>,
+                    Input: Frozen<$input>,
                     IntoOutput: Into<$output>,
             {
                 #[inline]
                 fn follower(
                     self,
-                    input: IntoInput,
+                    input: Input,
                     output: IntoOutput,
                 ) -> Follower<$opamp, $input, $output> {
                     self.follower(input, InternalOutput).enable_output(output.into())
                 }
             }
 
-            impl <IntoInput> IntoFollower <$opamp, IntoInput, InternalOutput, $input, InternalOutput> for Disabled<$opamp>
+            impl <Input> IntoFollower <$opamp, Input, InternalOutput, $input, InternalOutput> for Disabled<$opamp>
                 where
-                    IntoInput: Into<$input>,
+                    Input: Frozen<$input>,
             {
                 fn follower(
                     self,
-                    input: IntoInput,
+                    _input: Input,
                     _output: InternalOutput,
                 ) -> Follower<$opamp, $input, InternalOutput> {
-                    let input = input.into();
                     unsafe {
                         use crate::stm32::opamp::[<$opampreg _csr>]::OPAINTOEN_A;
                         (*crate::stm32::OPAMP::ptr())
@@ -596,7 +540,7 @@ macro_rules! opamps {
                                     .enabled()
                             );
                     }
-                    Follower {opamp: PhantomData, input, output: InternalOutput}
+                    Follower {opamp: PhantomData, input: PhantomData, output: PhantomData}
                 }
             }
 
@@ -633,37 +577,35 @@ macro_rules! opamps {
     } => {
         paste::paste!{
         $(
-            impl <IntoNonInverting, IntoInverting, IntoOutput> IntoOpenLoop
-                <$opamp, IntoNonInverting, IntoInverting, IntoOutput, $non_inverting, $inverting, $output> for Disabled<$opamp>
+            impl <NonInverting, Inverting, IntoOutput> IntoOpenLoop
+                <$opamp, NonInverting, Inverting, IntoOutput, $non_inverting, $inverting, $output> for Disabled<$opamp>
                 where
-                    IntoNonInverting: Into<$non_inverting>,
-                    IntoInverting: Into<$inverting>,
+                    NonInverting: Frozen<$non_inverting>,
+                    Inverting: Frozen<$inverting>,
                     IntoOutput: Into<$output>,
             {
                 #[inline]
                 fn open_loop(
                     self,
-                    non_inverting: IntoNonInverting,
-                    inverting: IntoInverting,
+                    non_inverting: NonInverting,
+                    inverting: Inverting,
                     output: IntoOutput,
                 ) -> OpenLoop<$opamp, $non_inverting, $inverting, $output> {
                     self.open_loop(non_inverting, inverting, InternalOutput).enable_output(output.into())
                 }
             }
-            impl <IntoNonInverting, IntoInverting> IntoOpenLoop
-                <$opamp, IntoNonInverting, IntoInverting, InternalOutput, $non_inverting, $inverting, InternalOutput> for Disabled<$opamp>
+            impl <NonInverting, Inverting> IntoOpenLoop
+                <$opamp, NonInverting, Inverting, InternalOutput, $non_inverting, $inverting, InternalOutput> for Disabled<$opamp>
                 where
-                    IntoNonInverting: Into<$non_inverting>,
-                    IntoInverting: Into<$inverting>,
+                    NonInverting: Frozen<$non_inverting>,
+                    Inverting: Frozen<$inverting>,
             {
                 fn open_loop(
                     self,
-                    non_inverting: IntoNonInverting,
-                    inverting: IntoInverting,
+                    _non_inverting: NonInverting,
+                    _inverting: Inverting,
                     _output: InternalOutput,
                 ) -> OpenLoop<$opamp, $non_inverting, $inverting, InternalOutput> {
-                    let non_inverting = non_inverting.into();
-                    let inverting = inverting.into();
                     unsafe {
                         use crate::stm32::opamp::[<$opampreg _csr>]::OPAINTOEN_A;
                         (*crate::stm32::OPAMP::ptr())
@@ -679,7 +621,7 @@ macro_rules! opamps {
                                     .enabled()
                             );
                     }
-                    OpenLoop {opamp: PhantomData, non_inverting, inverting, output: InternalOutput}
+                    OpenLoop {opamp: PhantomData, non_inverting: PhantomData, inverting: PhantomData, output: PhantomData }
                 }
             }
         )*
@@ -749,115 +691,121 @@ macro_rules! opamps {
 
             impl IntoPga<$opamp, $non_inverting, $output> for Disabled<$opamp>
             {
-                fn pga<B: Borrow<$non_inverting>>(
+                fn pga<IP, OP>(
                     self,
-                    _non_inverting: B,
-                    output: $output,
+                    _non_inverting: IP,
+                    _output: OP,
                     gain: Gain,
                 ) -> Pga<$opamp, $non_inverting, $output>
+                where
+                    IP: Frozen<$non_inverting>,
+                    OP: Frozen<$output>,
                 {
-                    $opamp::configure_pga(output.into(), gain, PgaMode::Pga, true)
+                    $opamp::configure_pga(gain, PgaMode::Pga, true)
                 }
 
                 #[allow(private_bounds)]
                 fn pga_external_filter<
-                    B1: Borrow<$non_inverting>,
-                    B2: Borrow<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm0>,
+                    P1: Frozen<$non_inverting>,
+                    P2: Frozen<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm0>,
                 >(
                     self,
-                    _non_inverting: B1,
-                    _filter: B2,
-                    output: $output,
+                    _non_inverting: P1,
+                    _filter: P2,
+                    _output: $output,
                     gain: Gain,
                 ) -> Pga<$opamp, $non_inverting, $output> {
-                    $opamp::configure_pga(output.into(), gain, PgaMode::PgaExternalFilter, true)
+                    $opamp::configure_pga(gain, PgaMode::PgaExternalFilter, true)
                 }
 
                 #[allow(private_bounds)]
                 fn pga_external_bias<
-                    B1: Borrow<$non_inverting>,
-                    B2: Borrow<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm0>,
+                    P1: Frozen<$non_inverting>,
+                    P2: Frozen<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm0>,
                 >(
                     self,
-                    _non_inverting: B1,
-                    _inverting: B2,
-                    output: $output,
+                    _non_inverting: P1,
+                    _inverting: P2,
+                    _output: $output,
                     gain: Gain,
                 ) -> Pga<$opamp, $non_inverting, $output> {
-                    $opamp::configure_pga(output.into(), gain, PgaMode::PgaExternalBias, true)
+                    $opamp::configure_pga(gain, PgaMode::PgaExternalBias, true)
                 }
 
                 #[allow(private_bounds)]
                 fn pga_external_bias_and_filter<
-                    B1: Borrow<$non_inverting>,
-                    B2: Borrow<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm0>,
-                    B3: Borrow<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm1>,
+                    P1: Frozen<$non_inverting>,
+                    P2: Frozen<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm0>,
+                    P3: Frozen<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm1>,
                 >(
                     self,
-                    _non_inverting: B1,
-                    _inverting: B2,
-                    _filter: B3,
-                    output: $output,
+                    _non_inverting: P1,
+                    _inverting: P2,
+                    _filter: P3,
+                    _output: $output,
                     gain: Gain,
                 ) -> Pga<$opamp, $non_inverting, $output> {
-                    $opamp::configure_pga(output.into(), gain, PgaMode::PgaExternalBiasAndFilter, true)
+                    $opamp::configure_pga(gain, PgaMode::PgaExternalBiasAndFilter, true)
                 }
             }
 
             impl IntoPga<$opamp, $non_inverting, InternalOutput> for Disabled<$opamp>
             {
-                fn pga<B: Borrow<$non_inverting>>(
+                fn pga<IP, OP>(
                     self,
-                    _non_inverting: B,
-                    _output: InternalOutput,
+                    _non_inverting: IP,
+                    _output: OP,
                     gain: Gain,
                 ) -> Pga<$opamp, $non_inverting, InternalOutput>
+                where
+                    IP: Frozen<$non_inverting>,
+                    OP: Frozen<InternalOutput>
                 {
-                    $opamp::configure_pga(InternalOutput, gain, PgaMode::Pga, true)
+                    $opamp::configure_pga(gain, PgaMode::Pga, true)
                 }
 
                 #[allow(private_bounds)]
                 fn pga_external_filter<
-                    B1: Borrow<$non_inverting>,
-                    B2: Borrow<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm0>,
+                    P1: Frozen<$non_inverting>,
+                    P2: Frozen<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm0>,
                 >(
                     self,
-                    _non_inverting: B1,
-                    _filter: B2,
+                    _non_inverting: P1,
+                    _filter: P2,
                     _output: InternalOutput,
                     gain: Gain,
                 ) -> Pga<$opamp, $non_inverting, InternalOutput> {
-                    $opamp::configure_pga(InternalOutput, gain, PgaMode::PgaExternalFilter, true)
+                    $opamp::configure_pga(gain, PgaMode::PgaExternalFilter, true)
                 }
 
                 #[allow(private_bounds)]
                 fn pga_external_bias<
-                    B1: Borrow<$non_inverting>,
-                    B2: Borrow<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm0>,
+                    P1: Frozen<$non_inverting>,
+                    P2: Frozen<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm0>,
                 >(
                     self,
-                    _non_inverting: B1,
-                    _inverting: B2,
+                    _non_inverting: P1,
+                    _inverting: P2,
                     _output: InternalOutput,
                     gain: Gain,
                 ) -> Pga<$opamp, $non_inverting, InternalOutput> {
-                    $opamp::configure_pga(InternalOutput, gain, PgaMode::PgaExternalBias, true)
+                    $opamp::configure_pga(gain, PgaMode::PgaExternalBias, true)
                 }
 
                 #[allow(private_bounds)]
                 fn pga_external_bias_and_filter<
-                    B1: Borrow<$non_inverting>,
-                    B2: Borrow<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm0>,
-                    B3: Borrow<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm1>,
+                    P1: Frozen<$non_inverting>,
+                    P2: Frozen<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm0>,
+                    P3: Frozen<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm1>,
                 >(
                     self,
-                    _non_inverting: B1,
-                    _inverting: B2,
-                    _filter: B3,
+                    _non_inverting: P1,
+                    _inverting: P2,
+                    _filter: P3,
                     _output: InternalOutput,
                     gain: Gain,
                 ) -> Pga<$opamp, $non_inverting, InternalOutput> {
-                    $opamp::configure_pga(InternalOutput, gain, PgaMode::PgaExternalBiasAndFilter, true)
+                    $opamp::configure_pga(gain, PgaMode::PgaExternalBiasAndFilter, true)
                 }
             }
         }
@@ -867,47 +815,41 @@ macro_rules! opamps {
 #[cfg(any(feature = "stm32g431", feature = "stm32g441", feature = "stm32g471",))]
 opamps! {
     Opamp1 => opamp1: {
-        vinm0: crate::gpio::gpioa::PA3<crate::gpio::Analog>,
-        vinm1: crate::gpio::gpioc::PC5<crate::gpio::Analog>,
         inverting: {
-            crate::gpio::gpioa::PA3<crate::gpio::Analog>: vinm0,
-            crate::gpio::gpioc::PC5<crate::gpio::Analog>: vinm1,
+            vinm0: PA3<Analog, IsFrozen>,
+            vinm1: PC5<Analog, IsFrozen>,
         },
         non_inverting: {
-            crate::gpio::gpioa::PA1<crate::gpio::Analog>: vinp0,
-            crate::gpio::gpioa::PA3<crate::gpio::Analog>: vinp1,
-            crate::gpio::gpioa::PA7<crate::gpio::Analog>: vinp2,
+            vinp0: PA1<Analog, IsFrozen>,
+            vinp1: PA3<Analog, IsFrozen>,
+            vinp2: PA7<Analog, IsFrozen>,
         },
-        output: crate::gpio::gpioa::PA2<crate::gpio::Analog>,
+        output: PA2<Analog, IsFrozen>,
     },
     Opamp2 => opamp2: {
-        vinm0: crate::gpio::gpioa::PA5<crate::gpio::Analog>,
-        vinm1: crate::gpio::gpioc::PC5<crate::gpio::Analog>,
         inverting: {
-            crate::gpio::gpioa::PA5<crate::gpio::Analog>: vinm0,
-            crate::gpio::gpioc::PC5<crate::gpio::Analog>: vinm1,
+            vinm0: PA5<Analog, IsFrozen>,
+            vinm1: PC5<Analog, IsFrozen>,
         },
         non_inverting: {
-            crate::gpio::gpioa::PA7<crate::gpio::Analog>: vinp0,
-            crate::gpio::gpiob::PB14<crate::gpio::Analog>: vinp1,
-            crate::gpio::gpiob::PB0<crate::gpio::Analog>: vinp2,
-            crate::gpio::gpiod::PD14<crate::gpio::Analog>: vinp3,
+            vinp0: PA7<Analog, IsFrozen>,
+            vinp1: PB14<Analog, IsFrozen>,
+            vinp2: PB0<Analog, IsFrozen>,
+            vinp3: PD14<Analog, IsFrozen>,
         },
-        output: crate::gpio::gpioa::PA6<crate::gpio::Analog>,
+        output: PA6<Analog, IsFrozen>,
     },
     Opamp3 => opamp3: {
-        vinm0: crate::gpio::gpiob::PB2<crate::gpio::Analog>,
-        vinm1: crate::gpio::gpiob::PB10<crate::gpio::Analog>,
         inverting: {
-            crate::gpio::gpiob::PB2<crate::gpio::Analog>: vinm0,
-            crate::gpio::gpiob::PB10<crate::gpio::Analog>: vinm1,
+            vinm0: PB2<Analog, IsFrozen>,
+            vinm1: PB10<Analog, IsFrozen>,
         },
         non_inverting: {
-            crate::gpio::gpiob::PB0<crate::gpio::Analog>: vinp0,
-            crate::gpio::gpiob::PB13<crate::gpio::Analog>: vinp1,
-            crate::gpio::gpioa::PA1<crate::gpio::Analog>: vinp2,
+            vinp0: PB0<Analog, IsFrozen>,
+            vinp1: PB13<Analog, IsFrozen>,
+            vinp2: PA1<Analog, IsFrozen>,
         },
-        output: crate::gpio::gpiob::PB1<crate::gpio::Analog>,
+        output: PB1<Analog, IsFrozen>,
     },
 }
 
@@ -919,88 +861,76 @@ opamps! {
 ))]
 opamps! {
     Opamp1 => opamp1: {
-        vinm0: crate::gpio::gpioa::PA3<crate::gpio::Analog>,
-        vinm1: crate::gpio::gpioc::PC5<crate::gpio::Analog>,
         inverting: {
-            crate::gpio::gpioa::PA3<crate::gpio::Analog>: vinm0,
-            crate::gpio::gpioc::PC5<crate::gpio::Analog>: vinm1,
+            vinm0: PA3<Analog, IsFrozen>,
+            vinm1: PC5<Analog, IsFrozen>,
         },
         non_inverting: {
-            crate::gpio::gpioa::PA1<crate::gpio::Analog>: vinp0,
-            crate::gpio::gpioa::PA3<crate::gpio::Analog>: vinp1,
-            crate::gpio::gpioa::PA7<crate::gpio::Analog>: vinp2,
+            vinp0: PA1<Analog, IsFrozen>,
+            vinp1: PA3<Analog, IsFrozen>,
+            vinp2: PA7<Analog, IsFrozen>
         },
-        output: crate::gpio::gpioa::PA2<crate::gpio::Analog>,
+        output: PA2<Analog, IsFrozen>,
     },
     Opamp2 => opamp2: {
-        vinm0: crate::gpio::gpioa::PA5<crate::gpio::Analog>,
-        vinm1: crate::gpio::gpioc::PC5<crate::gpio::Analog>,
         inverting: {
-            crate::gpio::gpioa::PA5<crate::gpio::Analog>: vinm0,
-            crate::gpio::gpioc::PC5<crate::gpio::Analog>: vinm1,
+            vinm0: PA5<Analog, IsFrozen>,
+            vinm1: PC5<Analog, IsFrozen>,
         },
         non_inverting: {
-            crate::gpio::gpioa::PA7<crate::gpio::Analog>: vinp0,
-            crate::gpio::gpiob::PB14<crate::gpio::Analog>: vinp1,
-            crate::gpio::gpiob::PB0<crate::gpio::Analog>: vinp2,
-            crate::gpio::gpiod::PD14<crate::gpio::Analog>: vinp3,
+            vinp0: PA7<Analog, IsFrozen>,
+            vinp1: PB14<Analog, IsFrozen>,
+            vinp2: PB0<Analog, IsFrozen>,
+            vinp3: PD14<Analog, IsFrozen>,
         },
-        output: crate::gpio::gpioa::PA6<crate::gpio::Analog>,
+        output: PA6<Analog, IsFrozen>,
     },
     Opamp3 => opamp3: {
-        vinm0: crate::gpio::gpiob::PB2<crate::gpio::Analog>,
-        vinm1: crate::gpio::gpiob::PB10<crate::gpio::Analog>,
         inverting: {
-            crate::gpio::gpiob::PB2<crate::gpio::Analog>: vinm0,
-            crate::gpio::gpiob::PB10<crate::gpio::Analog>: vinm1,
+            vinm0: PB2<Analog, IsFrozen>,
+            vinm1: PB10<Analog, IsFrozen>,
         },
         non_inverting: {
-            crate::gpio::gpiob::PB0<crate::gpio::Analog>: vinp0,
-            crate::gpio::gpiob::PB13<crate::gpio::Analog>: vinp1,
-            crate::gpio::gpioa::PA1<crate::gpio::Analog>: vinp2,
+            vinp0: PB0<Analog, IsFrozen>,
+            vinp1: PB13<Analog, IsFrozen>,
+            vinp2: PA1<Analog, IsFrozen>,
         },
-        output: crate::gpio::gpiob::PB1<crate::gpio::Analog>,
+        output: PB1<Analog, IsFrozen>,
     },
     Opamp4 => opamp4: {
-        vinm0: crate::gpio::gpiob::PB10<crate::gpio::Analog>,
-        vinm1: crate::gpio::gpiod::PD8<crate::gpio::Analog>,
         inverting: {
-            crate::gpio::gpiob::PB10<crate::gpio::Analog>: vinm0,
-            crate::gpio::gpiod::PD8<crate::gpio::Analog>: vinm1,
+            vinm0: PB10<Analog, IsFrozen>,
+            vinm1: PD8<Analog, IsFrozen>,
         },
         non_inverting: {
-            crate::gpio::gpiob::PB13<crate::gpio::Analog>: vinp0,
-            crate::gpio::gpiod::PD11<crate::gpio::Analog>: vinp1,
-            crate::gpio::gpiob::PB11<crate::gpio::Analog>: vinp2,
+            vinp0: PB13<Analog, IsFrozen>,
+            vinp1: PD11<Analog, IsFrozen>,
+            vinp2: PB11<Analog, IsFrozen>,
         },
-        output: crate::gpio::gpiob::PB12<crate::gpio::Analog>,
+        output: PB12<Analog, IsFrozen>,
     },
     Opamp5 => opamp5: {
-        vinm0: crate::gpio::gpiob::PB15<crate::gpio::Analog>,
-        vinm1: crate::gpio::gpioa::PA3<crate::gpio::Analog>,
         inverting: {
-            crate::gpio::gpiob::PB15<crate::gpio::Analog>: vinm0,
-            crate::gpio::gpioa::PA3<crate::gpio::Analog>: vinm1,
+            vinm0: PB15<Analog, IsFrozen>,
+            vinm1: PA3<Analog, IsFrozen>,
         },
         non_inverting: {
-            crate::gpio::gpiob::PB14<crate::gpio::Analog>: vinp0,
-            crate::gpio::gpiod::PD12<crate::gpio::Analog>: vinp1,
-            crate::gpio::gpioc::PC3<crate::gpio::Analog>: vinp2,
+            vinp0: PB14<Analog, IsFrozen>,
+            vinp1: PD12<Analog, IsFrozen>,
+            vinp2: PC3<Analog, IsFrozen>,
         },
-        output: crate::gpio::gpioa::PA8<crate::gpio::Analog>,
+        output: PA8<Analog, IsFrozen>,
     },
     Opamp6 => opamp6: {
-        vinm0: crate::gpio::gpioa::PA1<crate::gpio::Analog>,
-        vinm1: crate::gpio::gpiob::PB1<crate::gpio::Analog>,
         inverting: {
-            crate::gpio::gpioa::PA1<crate::gpio::Analog>: vinm0,
-            crate::gpio::gpiob::PB1<crate::gpio::Analog>: vinm1,
+            vinm0: PA1<Analog, IsFrozen>,
+            vinm1: PB1<Analog, IsFrozen>,
         },
         non_inverting: {
-            crate::gpio::gpiob::PB12<crate::gpio::Analog>: vinp0,
-            crate::gpio::gpiod::PD9<crate::gpio::Analog>: vinp1,
-            crate::gpio::gpiob::PB13<crate::gpio::Analog>: vinp2,
+            vinp0: PB12<Analog, IsFrozen>,
+            vinp1: PD9<Analog, IsFrozen>,
+            vinp2: PB13<Analog, IsFrozen>,
         },
-        output: crate::gpio::gpiob::PB11<crate::gpio::Analog>,
+        output: PB11<Analog, IsFrozen>,
     },
 }
diff --git a/src/pwm.rs b/src/pwm.rs
index 5f27211d..ed9e9c12 100644
--- a/src/pwm.rs
+++ b/src/pwm.rs
@@ -172,6 +172,8 @@
 use core::marker::PhantomData;
 use core::mem::MaybeUninit;
 
+use crate::gpio::Frozen;
+use crate::gpio::IsFrozen;
 use crate::hal;
 use crate::stm32::LPTIMER1;
 use crate::stm32::RCC;
@@ -219,7 +221,7 @@ use crate::gpio::{Alternate, AF1, AF10, AF11, AF12, AF2, AF3, AF4, AF5, AF6, AF9
 // This trait marks that a GPIO pin can be used with a specific timer channel
 // TIM is the timer being used
 // CHANNEL is a marker struct for the channel (or multi channels for tuples)
-// Example: impl Pins<TIM1, C1> for PA8<Alternate<AF1>> { type Channel = Pwm<TIM1, C1>; }
+// Example: impl Pins<TIM1, C1> for PA8<Alternate<AF1>, IsFrozen> { type Channel = Pwm<TIM1, C1>; }
 /// Pins is a trait that marks which GPIO pins may be used as PWM channels; it should not be directly used.
 /// See the device datasheet 'Pin descriptions' chapter for which pins can be used with which timer PWM channels (or look at Implementors)
 pub trait Pins<TIM, CHANNEL, COMP> {
@@ -550,27 +552,27 @@ macro_rules! pins {
 pins! {
     LPTIMER1:
         OUT: [
-            PA14<Alternate<AF1>>,
-            PB2<Alternate<AF1>>,
-            PC1<Alternate<AF1>>
+            PA14<Alternate<AF1>, IsFrozen>,
+            PB2<Alternate<AF1>, IsFrozen>,
+            PC1<Alternate<AF1>, IsFrozen>
         ]
 }
 // Dual channel timers
 pins! {
     TIM15:
         CH1(ComplementaryDisabled): [
-            PA2<Alternate<AF9>>,
-            PB14<Alternate<AF1>>,
-            PF9<Alternate<AF3>>
+            PA2<Alternate<AF9>, IsFrozen>,
+            PB14<Alternate<AF1>, IsFrozen>,
+            PF9<Alternate<AF3>, IsFrozen>
         ]
         CH2(ComplementaryImpossible): [
-            PA3<Alternate<AF9>>,
-            PB15<Alternate<AF1>>,
-            PF10<Alternate<AF3>>
+            PA3<Alternate<AF9>, IsFrozen>,
+            PB15<Alternate<AF1>, IsFrozen>,
+            PF10<Alternate<AF3>, IsFrozen>
         ]
         CH1N: [
-            PA1<Alternate<AF9>>,
-            PB15<Alternate<AF2>>,
+            PA1<Alternate<AF9>, IsFrozen>,
+            PB15<Alternate<AF2>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g471",
                 feature = "stm32g473",
@@ -578,47 +580,47 @@ pins! {
                 feature = "stm32g483",
                 feature = "stm32g484"
             ))]
-            PG9<Alternate<AF14>>
+            PG9<Alternate<AF14>, IsFrozen>
         ]
         CH2N: []
         BRK: [
-            PA9<Alternate<AF9>>,
-            PC5<Alternate<AF2>>
+            PA9<Alternate<AF9>, IsFrozen>,
+            PC5<Alternate<AF2>, IsFrozen>
         ]
         BRK2: []
     TIM16:
         CH1(ComplementaryDisabled): [
-            PA6<Alternate<AF1>>,
-            PA12<Alternate<AF1>>,
-            PB4<Alternate<AF1>>,
-            PB8<Alternate<AF1>>,
-            PE0<Alternate<AF4>>
+            PA6<Alternate<AF1>, IsFrozen>,
+            PA12<Alternate<AF1>, IsFrozen>,
+            PB4<Alternate<AF1>, IsFrozen>,
+            PB8<Alternate<AF1>, IsFrozen>,
+            PE0<Alternate<AF4>, IsFrozen>
         ]
         CH2(ComplementaryImpossible): []
         CH1N: [
-            PA13<Alternate<AF1>>,
-            PB6<Alternate<AF1>>
+            PA13<Alternate<AF1>, IsFrozen>,
+            PB6<Alternate<AF1>, IsFrozen>
         ]
         CH2N: []
         BRK: [
-            PB5<Alternate<AF1>>
+            PB5<Alternate<AF1>, IsFrozen>
         ]
         BRK2: []
     TIM17:
         CH1(ComplementaryDisabled): [
-            PA7<Alternate<AF1>>,
-            PB5<Alternate<AF10>>,
-            PB9<Alternate<AF1>>,
-            PE1<Alternate<AF4>>
+            PA7<Alternate<AF1>, IsFrozen>,
+            PB5<Alternate<AF10>, IsFrozen>,
+            PB9<Alternate<AF1>, IsFrozen>,
+            PE1<Alternate<AF4>, IsFrozen>
         ]
         CH2(ComplementaryImpossible): []
         CH1N: [
-            PB7<Alternate<AF1>>
+            PB7<Alternate<AF1>, IsFrozen>
         ]
         CH2N: []
         BRK: [
-            PA10<Alternate<AF1>>,
-            PB4<Alternate<AF10>>
+            PA10<Alternate<AF1>, IsFrozen>,
+            PB4<Alternate<AF10>, IsFrozen>
         ]
         BRK2: []
 }
@@ -626,87 +628,87 @@ pins! {
 pins! {
     TIM1:
         CH1(ComplementaryDisabled): [
-            PA8<Alternate<AF6>>,
-            PC0<Alternate<AF2>>,
-            PE9<Alternate<AF2>>
+            PA8<Alternate<AF6>, IsFrozen>,
+            PC0<Alternate<AF2>, IsFrozen>,
+            PE9<Alternate<AF2>, IsFrozen>
         ]
         CH2(ComplementaryDisabled): [
-            PA9<Alternate<AF6>>,
-            PC1<Alternate<AF2>>,
-            PE11<Alternate<AF2>>
+            PA9<Alternate<AF6>, IsFrozen>,
+            PC1<Alternate<AF2>, IsFrozen>,
+            PE11<Alternate<AF2>, IsFrozen>
         ]
         CH3(ComplementaryDisabled): [
-            PA10<Alternate<AF6>>,
-            PC2<Alternate<AF2>>,
-            PE13<Alternate<AF2>>
+            PA10<Alternate<AF6>, IsFrozen>,
+            PC2<Alternate<AF2>, IsFrozen>,
+            PE13<Alternate<AF2>, IsFrozen>
         ]
         CH4(ComplementaryDisabled): [
-            PA11<Alternate<AF11>>,
-            PC3<Alternate<AF2>>,
-            PE14<Alternate<AF2>>
+            PA11<Alternate<AF11>, IsFrozen>,
+            PC3<Alternate<AF2>, IsFrozen>,
+            PE14<Alternate<AF2>, IsFrozen>
         ]
         CH1N: [
-            PA7<Alternate<AF6>>,
-            PA11<Alternate<AF6>>,
-            PB13<Alternate<AF6>>,
-            PC13<Alternate<AF4>>,
-            PE8<Alternate<AF2>>
+            PA7<Alternate<AF6>, IsFrozen>,
+            PA11<Alternate<AF6>, IsFrozen>,
+            PB13<Alternate<AF6>, IsFrozen>,
+            PC13<Alternate<AF4>, IsFrozen>,
+            PE8<Alternate<AF2>, IsFrozen>
         ]
         CH2N: [
-            PA12<Alternate<AF6>>,
-            PB0<Alternate<AF6>>,
-            PB14<Alternate<AF6>>,
-            PE10<Alternate<AF2>>
+            PA12<Alternate<AF6>, IsFrozen>,
+            PB0<Alternate<AF6>, IsFrozen>,
+            PB14<Alternate<AF6>, IsFrozen>,
+            PE10<Alternate<AF2>, IsFrozen>
         ]
         CH3N: [
-            PB1<Alternate<AF6>>,
-            PB9<Alternate<AF12>>,
-            PB15<Alternate<AF4>>,
-            PE12<Alternate<AF2>>,
-            PF0<Alternate<AF6>>
+            PB1<Alternate<AF6>, IsFrozen>,
+            PB9<Alternate<AF12>, IsFrozen>,
+            PB15<Alternate<AF4>, IsFrozen>,
+            PE12<Alternate<AF2>, IsFrozen>,
+            PF0<Alternate<AF6>, IsFrozen>
         ]
         CH4N: [
-            PC5<Alternate<AF6>>,
-            PE15<Alternate<AF6>>
+            PC5<Alternate<AF6>, IsFrozen>,
+            PE15<Alternate<AF6>, IsFrozen>
         ]
         BRK: [
-            PA6<Alternate<AF6>>,
-            PA14<Alternate<AF6>>,
-            PA15<Alternate<AF9>>,
-            PB8<Alternate<AF12>>,
-            PB10<Alternate<AF12>>,
-            PB12<Alternate<AF6>>,
-            PC13<Alternate<AF2>>,
-            PE15<Alternate<AF2>>
+            PA6<Alternate<AF6>, IsFrozen>,
+            PA14<Alternate<AF6>, IsFrozen>,
+            PA15<Alternate<AF9>, IsFrozen>,
+            PB8<Alternate<AF12>, IsFrozen>,
+            PB10<Alternate<AF12>, IsFrozen>,
+            PB12<Alternate<AF6>, IsFrozen>,
+            PC13<Alternate<AF2>, IsFrozen>,
+            PE15<Alternate<AF2>, IsFrozen>
         ]
         BRK2: [
-            PA11<Alternate<AF12>>,
-            PC3<Alternate<AF6>>,
-            PE14<Alternate<AF6>>
+            PA11<Alternate<AF12>, IsFrozen>,
+            PC3<Alternate<AF6>, IsFrozen>,
+            PE14<Alternate<AF6>, IsFrozen>
         ]
     TIM2:
         CH1(ComplementaryImpossible): [
-            PA0<Alternate<AF1>>,
-            PA5<Alternate<AF1>>,
-            PA15<Alternate<AF1>>,
-            PD3<Alternate<AF2>>
+            PA0<Alternate<AF1>, IsFrozen>,
+            PA5<Alternate<AF1>, IsFrozen>,
+            PA15<Alternate<AF1>, IsFrozen>,
+            PD3<Alternate<AF2>, IsFrozen>
         ]
         CH2(ComplementaryImpossible): [
-            PA1<Alternate<AF1>>,
-            PB3<Alternate<AF1>>,
-            PD4<Alternate<AF2>>
+            PA1<Alternate<AF1>, IsFrozen>,
+            PB3<Alternate<AF1>, IsFrozen>,
+            PD4<Alternate<AF2>, IsFrozen>
         ]
         CH3(ComplementaryImpossible): [
-            PA2<Alternate<AF1>>,
-            PA9<Alternate<AF10>>,
-            PB10<Alternate<AF1>>,
-            PD7<Alternate<AF2>>
+            PA2<Alternate<AF1>, IsFrozen>,
+            PA9<Alternate<AF10>, IsFrozen>,
+            PB10<Alternate<AF1>, IsFrozen>,
+            PD7<Alternate<AF2>, IsFrozen>
         ]
         CH4(ComplementaryImpossible): [
-            PA3<Alternate<AF1>>,
-            PA10<Alternate<AF10>>,
-            PB11<Alternate<AF1>>,
-            PD6<Alternate<AF2>>
+            PA3<Alternate<AF1>, IsFrozen>,
+            PA10<Alternate<AF10>, IsFrozen>,
+            PB11<Alternate<AF1>, IsFrozen>,
+            PD6<Alternate<AF2>, IsFrozen>
         ]
         CH1N: []
         CH2N: []
@@ -716,28 +718,28 @@ pins! {
         BRK2: []
     TIM3:
         CH1(ComplementaryImpossible): [
-            PA6<Alternate<AF2>>,
-            PB4<Alternate<AF2>>,
-            PC6<Alternate<AF2>>,
-            PE2<Alternate<AF2>>
+            PA6<Alternate<AF2>, IsFrozen>,
+            PB4<Alternate<AF2>, IsFrozen>,
+            PC6<Alternate<AF2>, IsFrozen>,
+            PE2<Alternate<AF2>, IsFrozen>
         ]
         CH2(ComplementaryImpossible): [
-            PA4<Alternate<AF2>>,
-            PA7<Alternate<AF2>>,
-            PB5<Alternate<AF2>>,
-            PC7<Alternate<AF2>>,
-            PE3<Alternate<AF2>>
+            PA4<Alternate<AF2>, IsFrozen>,
+            PA7<Alternate<AF2>, IsFrozen>,
+            PB5<Alternate<AF2>, IsFrozen>,
+            PC7<Alternate<AF2>, IsFrozen>,
+            PE3<Alternate<AF2>, IsFrozen>
         ]
         CH3(ComplementaryImpossible): [
-            PB0<Alternate<AF2>>,
-            PC8<Alternate<AF2>>,
-            PE4<Alternate<AF2>>
+            PB0<Alternate<AF2>, IsFrozen>,
+            PC8<Alternate<AF2>, IsFrozen>,
+            PE4<Alternate<AF2>, IsFrozen>
         ]
         CH4(ComplementaryImpossible): [
-            PB1<Alternate<AF2>>,
-            PB7<Alternate<AF10>>,
-            PC9<Alternate<AF2>>,
-            PE5<Alternate<AF2>>
+            PB1<Alternate<AF2>, IsFrozen>,
+            PB7<Alternate<AF10>, IsFrozen>,
+            PC9<Alternate<AF2>, IsFrozen>,
+            PE5<Alternate<AF2>, IsFrozen>
         ]
         CH1N: []
         CH2N: []
@@ -747,23 +749,23 @@ pins! {
         BRK2: []
     TIM4:
         CH1(ComplementaryImpossible): [
-            PA11<Alternate<AF10>>,
-            PB6<Alternate<AF2>>,
-            PD12<Alternate<AF2>>
+            PA11<Alternate<AF10>, IsFrozen>,
+            PB6<Alternate<AF2>, IsFrozen>,
+            PD12<Alternate<AF2>, IsFrozen>
         ]
         CH2(ComplementaryImpossible): [
-            PA12<Alternate<AF10>>,
-            PB7<Alternate<AF2>>,
-            PD13<Alternate<AF2>>
+            PA12<Alternate<AF10>, IsFrozen>,
+            PB7<Alternate<AF2>, IsFrozen>,
+            PD13<Alternate<AF2>, IsFrozen>
         ]
         CH3(ComplementaryImpossible): [
-            PA13<Alternate<AF10>>,
-            PB8<Alternate<AF2>>,
-            PD14<Alternate<AF2>>
+            PA13<Alternate<AF10>, IsFrozen>,
+            PB8<Alternate<AF2>, IsFrozen>,
+            PD14<Alternate<AF2>, IsFrozen>
         ]
         CH4(ComplementaryImpossible): [
-            PB9<Alternate<AF2>>,
-            PD15<Alternate<AF2>>,
+            PB9<Alternate<AF2>, IsFrozen>,
+            PD15<Alternate<AF2>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g471",
                 feature = "stm32g473",
@@ -771,7 +773,7 @@ pins! {
                 feature = "stm32g483",
                 feature = "stm32g484"
             ))]
-            PF6<Alternate<AF2>>
+            PF6<Alternate<AF2>, IsFrozen>
         ]
         CH1N: []
         CH2N: []
@@ -790,24 +792,24 @@ pins! {
 pins! {
     TIM5:
         CH1(ComplementaryImpossible): [
-            PA0<Alternate<AF2>>,
-            PB2<Alternate<AF2>>,
-            PF6<Alternate<AF6>>
+            PA0<Alternate<AF2>, IsFrozen>,
+            PB2<Alternate<AF2>, IsFrozen>,
+            PF6<Alternate<AF6>, IsFrozen>
         ]
         CH2(ComplementaryImpossible): [
-            PA1<Alternate<AF2>>,
-            PC12<Alternate<AF1>>,
-            PF7<Alternate<AF6>>
+            PA1<Alternate<AF2>, IsFrozen>,
+            PC12<Alternate<AF1>, IsFrozen>,
+            PF7<Alternate<AF6>, IsFrozen>
         ]
         CH3(ComplementaryImpossible): [
-            PA2<Alternate<AF2>>,
-            PE8<Alternate<AF1>>,
-            PF8<Alternate<AF6>>
+            PA2<Alternate<AF2>, IsFrozen>,
+            PE8<Alternate<AF1>, IsFrozen>,
+            PF8<Alternate<AF6>, IsFrozen>
         ]
         CH4(ComplementaryImpossible): [
-            PA3<Alternate<AF2>>,
-            PE9<Alternate<AF1>>,
-            PF9<Alternate<AF6>>
+            PA3<Alternate<AF2>, IsFrozen>,
+            PE9<Alternate<AF1>, IsFrozen>,
+            PF9<Alternate<AF6>, IsFrozen>
         ]
         CH1N: []
         CH2N: []
@@ -819,53 +821,53 @@ pins! {
 pins! {
     TIM8:
         CH1(ComplementaryDisabled): [
-            PA15<Alternate<AF2>>,
-            PB6<Alternate<AF5>>,
-            PC6<Alternate<AF4>>
+            PA15<Alternate<AF2>, IsFrozen>,
+            PB6<Alternate<AF5>, IsFrozen>,
+            PC6<Alternate<AF4>, IsFrozen>
         ]
         CH2(ComplementaryDisabled): [
-            PA14<Alternate<AF5>>,
-            PB8<Alternate<AF10>>,
-            PC7<Alternate<AF4>>
+            PA14<Alternate<AF5>, IsFrozen>,
+            PB8<Alternate<AF10>, IsFrozen>,
+            PC7<Alternate<AF4>, IsFrozen>
         ]
         CH3(ComplementaryDisabled): [
-            PB9<Alternate<AF10>>,
-            PC8<Alternate<AF4>>
+            PB9<Alternate<AF10>, IsFrozen>,
+            PC8<Alternate<AF4>, IsFrozen>
         ]
         CH4(ComplementaryDisabled): [
-            PC9<Alternate<AF4>>,
-            PD1<Alternate<AF4>>
+            PC9<Alternate<AF4>, IsFrozen>,
+            PD1<Alternate<AF4>, IsFrozen>
         ]
         CH1N: [
-            PA7<Alternate<AF4>>,
-            PB3<Alternate<AF4>>,
-            PC10<Alternate<AF4>>
+            PA7<Alternate<AF4>, IsFrozen>,
+            PB3<Alternate<AF4>, IsFrozen>,
+            PC10<Alternate<AF4>, IsFrozen>
         ]
         CH2N: [
-            PB0<Alternate<AF4>>,
-            PB4<Alternate<AF4>>,
-            PC11<Alternate<AF4>>
+            PB0<Alternate<AF4>, IsFrozen>,
+            PB4<Alternate<AF4>, IsFrozen>,
+            PC11<Alternate<AF4>, IsFrozen>
         ]
         CH3N: [
-            PB1<Alternate<AF4>>,
-            PB5<Alternate<AF3>>,
-            PC12<Alternate<AF4>>
+            PB1<Alternate<AF4>, IsFrozen>,
+            PB5<Alternate<AF3>, IsFrozen>,
+            PC12<Alternate<AF4>, IsFrozen>
         ]
         CH4N: [
-            PC13<Alternate<AF6>>,
-            PD0<Alternate<AF6>>
+            PC13<Alternate<AF6>, IsFrozen>,
+            PD0<Alternate<AF6>, IsFrozen>
         ]
         BRK: [
-            PA0<Alternate<AF9>>,
-            PA6<Alternate<AF4>>,
-            PA10<Alternate<AF11>>,
-            PB7<Alternate<AF5>>,
-            PD2<Alternate<AF4>>
+            PA0<Alternate<AF9>, IsFrozen>,
+            PA6<Alternate<AF4>, IsFrozen>,
+            PA10<Alternate<AF11>, IsFrozen>,
+            PB7<Alternate<AF5>, IsFrozen>,
+            PD2<Alternate<AF4>, IsFrozen>
         ]
         BRK2: [
-            PB6<Alternate<AF10>>,
-            PC9<Alternate<AF6>>,
-            PD1<Alternate<AF6>>
+            PB6<Alternate<AF10>, IsFrozen>,
+            PC9<Alternate<AF6>, IsFrozen>,
+            PD1<Alternate<AF6>, IsFrozen>
         ]
 }
 #[cfg(any(
@@ -879,108 +881,108 @@ pins! {
 pins! {
     TIM20:
         CH1(ComplementaryDisabled): [
-            PB2<Alternate<AF3>>,
-            PE2<Alternate<AF6>>,
+            PB2<Alternate<AF3>, IsFrozen>,
+            PE2<Alternate<AF6>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g473",
                 feature = "stm32g474",
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PF12<Alternate<AF2>>
+            PF12<Alternate<AF2>, IsFrozen>
         ]
         CH2(ComplementaryDisabled): [
-            PC2<Alternate<AF6>>,
-            PE3<Alternate<AF6>>,
+            PC2<Alternate<AF6>, IsFrozen>,
+            PE3<Alternate<AF6>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g473",
                 feature = "stm32g474",
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PF13<Alternate<AF2>>
+            PF13<Alternate<AF2>, IsFrozen>
         ]
         CH3(ComplementaryDisabled): [
-            PC8<Alternate<AF6>>,
-            PF2<Alternate<AF2>>,
+            PC8<Alternate<AF6>, IsFrozen>,
+            PF2<Alternate<AF2>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g473",
                 feature = "stm32g474",
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PF14<Alternate<AF2>>
+            PF14<Alternate<AF2>, IsFrozen>
         ]
         CH4(ComplementaryDisabled): [
-            PE1<Alternate<AF4>>,
+            PE1<Alternate<AF4>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g473",
                 feature = "stm32g474",
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PF3<Alternate<AF2>>,
+            PF3<Alternate<AF2>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g473",
                 feature = "stm32g474",
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PF15<Alternate<AF2>>
+            PF15<Alternate<AF2>, IsFrozen>
         ]
         CH1N: [
-            PE4<Alternate<AF6>>,
+            PE4<Alternate<AF6>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g473",
                 feature = "stm32g474",
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PF4<Alternate<AF3>>,
+            PF4<Alternate<AF3>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g473",
                 feature = "stm32g474",
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PG0<Alternate<AF2>>
+            PG0<Alternate<AF2>, IsFrozen>
         ]
         CH2N: [
-            PE5<Alternate<AF6>>,
+            PE5<Alternate<AF6>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g473",
                 feature = "stm32g474",
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PF5<Alternate<AF2>>,
+            PF5<Alternate<AF2>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g473",
                 feature = "stm32g474",
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PG1<Alternate<AF2>>
+            PG1<Alternate<AF2>, IsFrozen>
         ]
         CH3N: [
-            PE6<Alternate<AF6>>,
+            PE6<Alternate<AF6>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g473",
                 feature = "stm32g474",
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PG2<Alternate<AF2>>
+            PG2<Alternate<AF2>, IsFrozen>
         ]
         CH4N: [
-            PE0<Alternate<AF3>>,
+            PE0<Alternate<AF3>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g473",
                 feature = "stm32g474",
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PG3<Alternate<AF6>>
+            PG3<Alternate<AF6>, IsFrozen>
         ]
         BRK: [
             #[cfg(any(
@@ -989,22 +991,22 @@ pins! {
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PF7<Alternate<AF2>>,
-            PF9<Alternate<AF2>>,
+            PF7<Alternate<AF2>, IsFrozen>,
+            PF9<Alternate<AF2>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g473",
                 feature = "stm32g474",
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PG3<Alternate<AF2>>,
+            PG3<Alternate<AF2>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g473",
                 feature = "stm32g474",
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PG6<Alternate<AF2>>
+            PG6<Alternate<AF2>, IsFrozen>
         ]
         BRK2: [
             #[cfg(any(
@@ -1013,15 +1015,15 @@ pins! {
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PF8<Alternate<AF2>>,
-            PF10<Alternate<AF2>>,
+            PF8<Alternate<AF2>, IsFrozen>,
+            PF10<Alternate<AF2>, IsFrozen>,
             #[cfg(any(
                 feature = "stm32g473",
                 feature = "stm32g474",
                 feature = "stm32g483",
                 feature = "stm32g484",
             ))]
-            PG4<Alternate<AF2>>
+            PG4<Alternate<AF2>, IsFrozen>
         ]
 }
 
@@ -1112,19 +1114,21 @@ fn calculate_deadtime(base_freq: Hertz, deadtime: NanoSecond) -> (u8, u8) {
 /// Allows the pwm() method to be added to the peripheral register structs from the device crate
 pub trait PwmExt: Sized {
     /// The requested frequency will be rounded to the nearest achievable frequency; the actual frequency may be higher or lower than requested.
-    fn pwm<PINS, T, U, V>(self, _pins: PINS, frequency: T, rcc: &mut Rcc) -> PINS::Channel
+    fn pwm<P, PINS, T, U, V>(self, _pins: P, frequency: T, rcc: &mut Rcc) -> PINS::Channel
     where
+        P: Frozen<PINS>,
         PINS: Pins<Self, U, V>,
         T: Into<Hertz>;
 }
 
 pub trait PwmAdvExt<WIDTH>: Sized {
-    fn pwm_advanced<PINS, CHANNEL, COMP>(
+    fn pwm_advanced<P, PINS, CHANNEL, COMP>(
         self,
-        _pins: PINS,
+        _pins: P,
         rcc: &mut Rcc,
     ) -> PwmBuilder<Self, PINS, CHANNEL, FaultDisabled, COMP, WIDTH>
     where
+        P: Frozen<PINS>,
         PINS: Pins<Self, CHANNEL, COMP>;
 }
 
@@ -1132,8 +1136,9 @@ pub trait PwmAdvExt<WIDTH>: Sized {
 macro_rules! pwm_ext_hal {
     ($TIMX:ident: $timX:ident) => {
         impl PwmExt for $TIMX {
-            fn pwm<PINS, T, U, V>(self, pins: PINS, frequency: T, rcc: &mut Rcc) -> PINS::Channel
+            fn pwm<P, PINS, T, U, V>(self, pins: P, frequency: T, rcc: &mut Rcc) -> PINS::Channel
             where
+                P: Frozen<PINS>,
                 PINS: Pins<Self, U, V>,
                 T: Into<Hertz>,
             {
@@ -1151,13 +1156,14 @@ macro_rules! tim_hal {
             pwm_ext_hal!($TIMX: $timX);
 
             /// Configures PWM
-            fn $timX<PINS, T, U>(
+            fn $timX<P, PINS, T, U>(
                 tim: $TIMX,
-                _pins: PINS,
+                _pins: P,
                 freq: Hertz,
                 rcc: &mut Rcc,
             ) -> PINS::Channel
             where
+                P: Frozen<PINS>,
                 PINS: Pins<$TIMX, T, U>,
             {
                 unsafe {
@@ -1194,12 +1200,13 @@ macro_rules! tim_hal {
             }
 
             impl PwmAdvExt<$typ> for $TIMX {
-                fn pwm_advanced<PINS, CHANNEL, COMP>(
+                fn pwm_advanced<P, PINS, CHANNEL, COMP>(
                     self,
-                    _pins: PINS,
+                    _pins: P,
                     rcc: &mut Rcc,
                 ) -> PwmBuilder<Self, PINS, CHANNEL, FaultDisabled, COMP, $typ>
                 where
+                    P: Frozen<PINS>,
                     PINS: Pins<Self, CHANNEL, COMP>
                 {
                     unsafe {
@@ -1769,13 +1776,14 @@ macro_rules! lptim_hal {
             pwm_ext_hal!($TIMX: $timX);
 
             /// Configures PWM signal on the LPTIM OUT pin.
-            fn $timX<PINS, T, U>(
+            fn $timX<P, PINS, T, U>(
                 tim: $TIMX,
-                _pins: PINS,
+                _pins: P,
                 freq: Hertz,
                 rcc: &mut Rcc,
             ) -> PINS::Channel
             where
+                P: Frozen<PINS>,
                 PINS: Pins<$TIMX, T, U>,
             {
                 unsafe {