diff --git a/examples/comp_w_dac.rs b/examples/comp_w_dac.rs
index e1313108..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();
diff --git a/examples/opamp.rs b/examples/opamp.rs
index e4576a7a..eb10a773 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);
-
-    // Set up opamp1 and opamp2 in follower mode
-    let opamp1 = opamp1.follower(gpioa.pa1, gpioa.pa2);
-    let opamp2 = opamp2.follower(gpioa.pa7, InternalOutput);
-
-    // Set up opamp1 and opamp2 in open loop mode
-    let opamp3 = opamp3.open_loop(gpiob.pb0, gpiob.pb2, gpiob.pb1);
+    let pa1 = gpioa.pa1.into_analog();
+    let pa2 = gpioa.pa2.into_analog();
+    let pa7 = gpioa.pa7.into_analog();
 
-    // disable opamps
-    let (opamp1, pa1, pa2) = opamp1.disable();
-    let (opamp2, pa7) = opamp2.disable();
+    let pb0 = gpiob.pb0.into_analog();
+    let pb1 = gpiob.pb1.into_analog();
+    let pb2 = gpiob.pb2.into_analog();
 
-    let (_opamp3, _pb0, _pb2, _pb1) = opamp3.disable();
+    // setup opamps
+    let (opamp1, opamp2, opamp3, ..) = dp.OPAMP.split(&mut rcc);
 
     // 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,
-    );
+    let _opamp1 = opamp1.pga(&pa1, pa2, Gain::Gain2);
+    
+    // Set up opamp2 in follower mode with output routed to internal ADC
+    let opamp2 = opamp2.follower(&pa7, InternalOutput);
+
+    // 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 da174734..0a52f450 100644
--- a/src/comparator.rs
+++ b/src/comparator.rs
@@ -5,16 +5,18 @@
 //! 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;
 use crate::exti::{Event as ExtiEvent, ExtiExt};
+use crate::gpio::{FrozenPin, IsFrozen};
 use crate::gpio::{
     gpioa::{PA0, PA1, PA11, PA12, PA2, PA3, PA4, PA5, PA6, PA7},
     gpiob::{PB0, PB1, PB14, PB15, PB2, PB6, PB7, PB8, PB9},
     gpioc::PC2,
     gpiof::PF4,
-    Analog, Alternate, AlternateOD, SignalEdge, AF2, AF3, AF8,
+    Alternate, AlternateOD, Analog, SignalEdge, AF2, AF3, AF8,
 };
 
 #[cfg(any(
@@ -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 FrozenPin<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
             }
 
-            fn setup(&self, comp: &$COMP) {
+            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
+            }
+
+            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: FrozenPin<P> + PositiveInput<COMP>,
+        NP: FrozenPin<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: FrozenPin<P> + PositiveInput<$COMP>,
+                NP: FrozenPin<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: FrozenPin<P> + PositiveInput<$COMP>,
+                NP: FrozenPin<N> + NegativeInput<$COMP>
+            {
                 comp.comparator(positive_input, negative_input, config, clocks)
             }
 
diff --git a/src/dac.rs b/src/dac.rs
index 109374c0..82b9ebc9 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, FrozenPin, IsFrozen, IsNotFrozen};
 use crate::rcc::{self, *};
 use crate::stm32::{DAC1, DAC2, DAC3, DAC4, RCC};
 use hal::blocking::delay::DelayUs;
@@ -64,9 +64,20 @@ 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> FrozenPin<$DACxCHy<M, Enabled, IsFrozen>> for $DACxCHy<M, Enabled>{}
+        impl<const M: u8> FrozenPin<$DACxCHy<M, Enabled, IsFrozen>> for $DACxCHy<M, WaveGenerator>{}
+        impl<const M: u8> FrozenPin<$DACxCHy<M, Enabled, IsFrozen>> for &$DACxCHy<M, Enabled, IsFrozen>{}
+        impl<const M: u8> FrozenPin<$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 +209,7 @@ macro_rules! dac_helper {
 
                     $CX {
                         _enabled: PhantomData,
+                        _frozen_state: PhantomData,
                     }
                 }
 
@@ -214,11 +226,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 +264,7 @@ macro_rules! dac_helper {
 
                     $CX {
                         _enabled: PhantomData,
+                        _frozen_state: PhantomData,
                     }
                 }
 
@@ -263,13 +277,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 +301,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 b8f6de18..b69d2177 100644
--- a/src/gpio.rs
+++ b/src/gpio.rs
@@ -18,7 +18,7 @@ pub trait GpioExt {
 }
 
 /// 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;
@@ -26,6 +26,20 @@ 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 FrozenPin<T>: crate::Sealed {}
+impl<A1, A2, B1, B2> FrozenPin<(B1, B2)> for (A1, A2) where A1: FrozenPin<B1>, A2: FrozenPin<B2> {}
+impl<A1, A2, A3, B1, B2, B3> FrozenPin<(B1, B2, B3)> for (A1, A2, A3) where A1: FrozenPin<B1>, A2: FrozenPin<B2>, A3: FrozenPin<B3> {}
+impl<A1, A2, A3, A4, B1, B2, B3, B4> FrozenPin<(B1, B2, B3, B4)> for (A1, A2, A3, A4) where A1: FrozenPin<B1>, A2: FrozenPin<B2>, A3: FrozenPin<B3>, A4: FrozenPin<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>,
@@ -352,6 +366,11 @@ macro_rules! gpio {
                     _frozen_state: PhantomData<F>,
                 }
 
+                impl<MODE> FrozenPin<$PXi<MODE, IsFrozen>> for $PXi<MODE> {}
+                impl<MODE> FrozenPin<$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>> {
@@ -552,7 +571,7 @@ macro_rules! gpio {
                         }
                         $PXi { _mode: PhantomData, _frozen_state: PhantomData }
                     }
-                    
+
                     pub fn freeze(self) -> $PXi<MODE, IsFrozen> {
                         $PXi { _mode: PhantomData, _frozen_state: PhantomData }
                     }
diff --git a/src/opamp.rs b/src/opamp.rs
index 0b549229..e372610a 100644
--- a/src/opamp.rs
+++ b/src/opamp.rs
@@ -59,7 +59,12 @@
 
 // TODO: Add support for calibration
 
-use core::{borrow::Borrow, marker::PhantomData};
+use crate::gpio::gpioa::{PA1, PA2, PA3, PA5, PA6, PA7, PA8};
+use crate::gpio::gpiob::{PB0, PB1, PB10, PB11, PB12, PB13, PB14, PB15, PB2};
+use crate::gpio::gpioc::{PC3, PC5};
+use crate::gpio::gpiod::{PD11, PD12, PD14, PD8, PD9};
+use crate::gpio::{Analog, FrozenPin, IsFrozen};
+use core::marker::PhantomData;
 
 /// PGA Gain
 pub enum Gain {
@@ -84,21 +89,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 +146,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: FrozenPin<NonInverting>,
+        OP: FrozenPin<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: FrozenPin<NonInverting>,
+        P2: FrozenPin<<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 +172,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: FrozenPin<NonInverting>,
+        B2: FrozenPin<<Opamp as ConfigurePgaReg<Opamp, NonInverting>>::Vinm0>,
     >(
         self,
         non_inverting: B1,
@@ -177,9 +185,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: FrozenPin<NonInverting>,
+        B2: FrozenPin<<Opamp as ConfigurePgaReg<Opamp, NonInverting>>::Vinm0>,
+        B3: FrozenPin<<Opamp as ConfigurePgaReg<Opamp, NonInverting>>::Vinm1>,
     >(
         self,
         non_inverting: B1,
@@ -209,7 +217,6 @@ where
     /// Configure the
     ///
     fn configure_pga<Output>(
-        output: Output,
         gain: Gain,
         mode: PgaMode,
         output_enable: bool,
@@ -218,7 +225,7 @@ where
         Pga {
             opamp: PhantomData,
             non_inverting: PhantomData,
-            output,
+            output: PhantomData,
         }
     }
 }
@@ -251,27 +258,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 +367,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 +390,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 +414,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 +422,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 +431,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 +484,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: FrozenPin<$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: FrozenPin<$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 +524,7 @@ macro_rules! opamps {
                                     .enabled()
                             );
                     }
-                    Follower {opamp: PhantomData, input, output: InternalOutput}
+                    Follower {opamp: PhantomData, input: PhantomData, output: PhantomData}
                 }
             }
 
@@ -633,37 +561,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: FrozenPin<$non_inverting>,
+                    Inverting: FrozenPin<$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: FrozenPin<$non_inverting>,
+                    Inverting: FrozenPin<$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 +605,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 +675,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: FrozenPin<$non_inverting>,
+                    OP: FrozenPin<$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: FrozenPin<$non_inverting>,
+                    P2: FrozenPin<<$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: FrozenPin<$non_inverting>,
+                    P2: FrozenPin<<$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: FrozenPin<$non_inverting>,
+                    P2: FrozenPin<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm0>,
+                    P3: FrozenPin<<$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: FrozenPin<$non_inverting>,
+                    OP: FrozenPin<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: FrozenPin<$non_inverting>,
+                    P2: FrozenPin<<$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: FrozenPin<$non_inverting>,
+                    P2: FrozenPin<<$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: FrozenPin<$non_inverting>,
+                    P2: FrozenPin<<$opamp as ConfigurePgaReg<$opamp, $non_inverting>>::Vinm0>,
+                    P3: FrozenPin<<$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 +799,47 @@ 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>,
+        vinm0: PA3<Analog, IsFrozen>,
+        vinm1: PC5<Analog, IsFrozen>,
         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>,
+        vinm0: PA5<Analog, IsFrozen>,
+        vinm1: PC5<Analog, IsFrozen>,
         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>,
+        vinm0: PB2<Analog, IsFrozen>,
+        vinm1: PB10<Analog, IsFrozen>,
         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 +851,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..774221f1 100644
--- a/src/pwm.rs
+++ b/src/pwm.rs
@@ -172,6 +172,8 @@
 use core::marker::PhantomData;
 use core::mem::MaybeUninit;
 
+use crate::gpio::FrozenPin;
+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: FrozenPin<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: FrozenPin<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: FrozenPin<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: FrozenPin<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: FrozenPin<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: FrozenPin<PINS>,
                 PINS: Pins<$TIMX, T, U>,
             {
                 unsafe {