diff --git a/CHANGELOG.md b/CHANGELOG.md
index e09bbcd1..39c718c9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Use independent `Spi` and `SpiSlave` structures instead of `OP` generic [#462]
 - Take `&Clocks` instead of `Clocks` [#498]
 - Temporary replace `stm32f1` with `stm32f1-staging` [#503]
+- Remove `PULL` generic from `Input` mode [#512]
+  Fix `as_(mode)` in #421 [#512]
 
 ### Changed
 
@@ -62,6 +64,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 [#509]: https://github.com/stm32-rs/stm32f1xx-hal/pull/509
 [#510]: https://github.com/stm32-rs/stm32f1xx-hal/pull/510
 [#511]: https://github.com/stm32-rs/stm32f1xx-hal/pull/511
+[#512]: https://github.com/stm32-rs/stm32f1xx-hal/pull/512
 
 ## [v0.10.0] - 2022-12-12
 
diff --git a/examples/can-loopback.rs b/examples/can-loopback.rs
index 09ca81c2..eb0cda1b 100644
--- a/examples/can-loopback.rs
+++ b/examples/can-loopback.rs
@@ -12,7 +12,7 @@ use panic_halt as _;
 
 use cortex_m_rt::entry;
 use nb::block;
-use stm32f1xx_hal::{can::Can, gpio::Floating, pac, prelude::*};
+use stm32f1xx_hal::{can::Can, pac, prelude::*};
 
 #[entry]
 fn main() -> ! {
@@ -25,7 +25,7 @@ fn main() -> ! {
     // resonator must be used.
     rcc.cfgr.use_hse(8.MHz()).freeze(&mut flash.acr);
 
-    let can = Can::<_, Floating>::new_loopback(
+    let can = Can::new_loopback(
         dp.CAN1,
         #[cfg(not(feature = "connectivity"))]
         dp.USB,
diff --git a/examples/can-rtic.rs b/examples/can-rtic.rs
index 415a5c43..dbd963c5 100644
--- a/examples/can-rtic.rs
+++ b/examples/can-rtic.rs
@@ -55,7 +55,7 @@ mod app {
     use super::{enqueue_frame, PriorityFrame};
     use bxcan::{filter::Mask32, ExtendedId, Fifo, Frame, Interrupts, Rx0, StandardId, Tx};
     use heapless::binary_heap::{BinaryHeap, Max};
-    use stm32f1xx_hal::{can::Can, gpio::Floating, pac::CAN1, prelude::*};
+    use stm32f1xx_hal::{can::Can, pac::CAN1, prelude::*};
 
     #[local]
     struct Local {
@@ -89,14 +89,14 @@ mod app {
         let mut afio = cx.device.AFIO.constrain();
 
         #[cfg(not(feature = "connectivity"))]
-        let can = Can::<_, Floating>::new(
+        let can = Can::new(
             cx.device.CAN1,
             cx.device.USB,
             (can_tx_pin, can_rx_pin, &mut afio.mapr),
         );
 
         #[cfg(feature = "connectivity")]
-        let can = Can::<_, Floating>::new(cx.device.CAN1, (can_tx_pin, can_rx_pin, &mut afio.mapr));
+        let can = Can::new(cx.device.CAN1, (can_tx_pin, can_rx_pin, &mut afio.mapr));
 
         // APB1 (PCLK1): 16MHz, Bit rate: 1000kBit/s, Sample Point 87.5%
         // Value was calculated with http://www.bittiming.can-wiki.info/
diff --git a/examples/exti.rs b/examples/exti.rs
index 57eb8c57..a2216fbc 100644
--- a/examples/exti.rs
+++ b/examples/exti.rs
@@ -19,10 +19,8 @@ use stm32f1xx_hal::{pac, prelude::*};
 // where the interrupt is not yet enabled (i.e. no concurrent accesses can occur).
 // After enabling the interrupt, main() may not have any references to these objects any more.
 // For the sake of minimalism, we do not use RTIC here, which would be the better way.
-static mut LED: MaybeUninit<stm32f1xx_hal::gpio::gpioc::PC13<Output<PushPull>>> =
-    MaybeUninit::uninit();
-static mut INT_PIN: MaybeUninit<stm32f1xx_hal::gpio::gpioa::PA7<Input<Floating>>> =
-    MaybeUninit::uninit();
+static mut LED: MaybeUninit<stm32f1xx_hal::gpio::gpioc::PC13<Output>> = MaybeUninit::uninit();
+static mut INT_PIN: MaybeUninit<stm32f1xx_hal::gpio::gpioa::PA7<Input>> = MaybeUninit::uninit();
 
 #[interrupt]
 fn EXTI9_5() {
diff --git a/examples/exti_rtic.rs b/examples/exti_rtic.rs
index 07e449d9..aaf1a7b0 100644
--- a/examples/exti_rtic.rs
+++ b/examples/exti_rtic.rs
@@ -8,7 +8,7 @@ use panic_halt as _;
 #[rtic::app(device = stm32f1xx_hal::pac)]
 mod app {
     use stm32f1xx_hal::{
-        gpio::{gpioa::PA0, gpioc::PC13, Edge, ExtiPin, Input, Output, PullDown, PushPull},
+        gpio::{gpioa::PA0, gpioc::PC13, Edge, ExtiPin, Input, Output},
         prelude::*,
     };
 
@@ -17,8 +17,8 @@ mod app {
 
     #[local]
     struct Local {
-        button: PA0<Input<PullDown>>,
-        led: PC13<Output<PushPull>>,
+        button: PA0<Input>,
+        led: PC13<Output>,
     }
 
     #[init]
diff --git a/examples/mfrc522.rs b/examples/mfrc522.rs
index cbb57e76..cddc2555 100644
--- a/examples/mfrc522.rs
+++ b/examples/mfrc522.rs
@@ -32,9 +32,9 @@ fn main() -> ! {
 
     let clocks = rcc.cfgr.freeze(&mut flash.acr);
 
-    let sck = gpioa.pa5.into_alternate_push_pull(&mut gpioa.crl);
+    let sck = gpioa.pa5;
     let miso = gpioa.pa6;
-    let mosi = gpioa.pa7.into_alternate_push_pull(&mut gpioa.crl);
+    let mosi = gpioa.pa7;
     let spi = Spi::new(
         dp.SPI1,
         (sck, miso, mosi, &mut afio.mapr),
diff --git a/examples/multi_mode_gpio.rs b/examples/multi_mode_gpio.rs.disabled
similarity index 100%
rename from examples/multi_mode_gpio.rs
rename to examples/multi_mode_gpio.rs.disabled
diff --git a/src/afio.rs b/src/afio.rs
index d4e0b845..3f4f0ba6 100644
--- a/src/afio.rs
+++ b/src/afio.rs
@@ -4,7 +4,7 @@ use crate::pac::{self, afio, AFIO, RCC};
 use crate::rcc::{Enable, Reset};
 
 use crate::gpio::{
-    Debugger, Floating, Input, PA15, {PB3, PB4},
+    Debugger, Input, PA15, {PB3, PB4},
 };
 use crate::sealed::Sealed;
 
@@ -94,11 +94,7 @@ impl MAPR {
         pa15: PA15<Debugger>,
         pb3: PB3<Debugger>,
         pb4: PB4<Debugger>,
-    ) -> (
-        PA15<Input<Floating>>,
-        PB3<Input<Floating>>,
-        PB4<Input<Floating>>,
-    ) {
+    ) -> (PA15<Input>, PB3<Input>, PB4<Input>) {
         self.jtag_enabled = false;
         // Avoid duplicating swj_cfg write code
         self.modify_mapr(|_, w| w);
diff --git a/src/can.rs b/src/can.rs
index 1ddd5d9e..2a6b77a7 100644
--- a/src/can.rs
+++ b/src/can.rs
@@ -20,13 +20,9 @@
 //! | RX       | PB5     | PB12  |
 
 use crate::afio::Remap;
-use crate::gpio::{self, Alternate, Cr, Floating, Input, NoPin, PinMode, PullUp, PushPull};
+use crate::gpio::{self, Alternate, Cr, Input, NoPin, PushPull};
 use crate::pac::{self, RCC};
 
-pub trait InMode {}
-impl InMode for Floating {}
-impl InMode for PullUp {}
-
 pub struct Pins<TX, RX> {
     pub tx: TX,
     pub rx: RX,
@@ -72,36 +68,32 @@ macro_rules! remap {
             )+
             None(NoPin<PushPull>),
         }
-        pub enum Rx<PULL> {
+        pub enum Rx {
             $(
-                $RX(gpio::$RX<Input<PULL>>),
+                $RX(gpio::$RX<Input>),
             )+
-            None(NoPin<PULL>),
+            None(NoPin<PushPull>),
         }
 
         $(
-            impl<PULL: InMode> From<(gpio::$TX<Alternate>, gpio::$RX<Input<PULL>>, &mut <$PER as Remap>::Mapr)> for Pins<Tx, Rx<PULL>> {
-                fn from(p: (gpio::$TX<Alternate>, gpio::$RX<Input<PULL>>, &mut <$PER as Remap>::Mapr)) -> Self {
+            impl From<(gpio::$TX<Alternate>, gpio::$RX, &mut <$PER as Remap>::Mapr)> for Pins<Tx, Rx> {
+                fn from(p: (gpio::$TX<Alternate>, gpio::$RX, &mut <$PER as Remap>::Mapr)) -> Self {
                     <$PER>::remap(p.2, $remap);
                     Self { tx: Tx::$TX(p.0), rx: Rx::$RX(p.1) }
                 }
             }
 
-            impl<PULL> From<(gpio::$TX, gpio::$RX, &mut <$PER as Remap>::Mapr)> for Pins<Tx, Rx<PULL>>
-            where
-                Input<PULL>: PinMode,
-                PULL: InMode,
-            {
+            impl From<(gpio::$TX, gpio::$RX, &mut <$PER as Remap>::Mapr)> for Pins<Tx, Rx> {
                 fn from(p: (gpio::$TX, gpio::$RX, &mut <$PER as Remap>::Mapr)) -> Self {
                     let mut cr = Cr;
                     let tx = p.0.into_mode(&mut cr);
-                    let rx = p.1.into_mode(&mut cr);
+                    let rx = p.1;
                     <$PER>::remap(p.2, $remap);
                     Self { tx: Tx::$TX(tx), rx: Rx::$RX(rx) }
                 }
             }
 
-            impl From<(gpio::$TX, &mut <$PER as Remap>::Mapr)> for Pins<Tx, Rx<Floating>> {
+            impl From<(gpio::$TX, &mut <$PER as Remap>::Mapr)> for Pins<Tx, Rx> {
                 fn from(p: (gpio::$TX, &mut <$PER as Remap>::Mapr)) -> Self {
                     let tx = p.0.into_mode(&mut Cr);
                     <$PER>::remap(p.1, $remap);
@@ -109,13 +101,9 @@ macro_rules! remap {
                 }
             }
 
-            impl<PULL> From<(gpio::$RX, &mut <$PER as Remap>::Mapr)> for Pins<Tx, Rx<PULL>>
-            where
-                Input<PULL>: PinMode,
-                PULL: InMode,
-            {
+            impl From<(gpio::$RX, &mut <$PER as Remap>::Mapr)> for Pins<Tx, Rx> {
                 fn from(p: (gpio::$RX, &mut <$PER as Remap>::Mapr)) -> Self {
-                    let rx = p.0.into_mode(&mut Cr);
+                    let rx = p.0;
                     <$PER>::remap(p.1, $remap);
                     Self { tx: Tx::None(NoPin::new()), rx: Rx::$RX(rx) }
                 }
@@ -129,20 +117,17 @@ pub trait CanExt: Sized + Instance {
     fn can(
         self,
         #[cfg(not(feature = "connectivity"))] usb: pac::USB,
-        pins: impl Into<Pins<Self::Tx, Self::Rx<Floating>>>,
-    ) -> Can<Self, Floating>;
-    fn can_loopback(
-        self,
-        #[cfg(not(feature = "connectivity"))] usb: pac::USB,
-    ) -> Can<Self, Floating>;
+        pins: impl Into<Pins<Self::Tx, Self::Rx>>,
+    ) -> Can<Self>;
+    fn can_loopback(self, #[cfg(not(feature = "connectivity"))] usb: pac::USB) -> Can<Self>;
 }
 
 impl<CAN: Instance> CanExt for CAN {
     fn can(
         self,
         #[cfg(not(feature = "connectivity"))] usb: pac::USB,
-        pins: impl Into<Pins<Self::Tx, Self::Rx<Floating>>>,
-    ) -> Can<Self, Floating> {
+        pins: impl Into<Pins<Self::Tx, Self::Rx>>,
+    ) -> Can<Self> {
         Can::new(
             self,
             #[cfg(not(feature = "connectivity"))]
@@ -150,10 +135,7 @@ impl<CAN: Instance> CanExt for CAN {
             pins,
         )
     }
-    fn can_loopback(
-        self,
-        #[cfg(not(feature = "connectivity"))] usb: pac::USB,
-    ) -> Can<Self, Floating> {
+    fn can_loopback(self, #[cfg(not(feature = "connectivity"))] usb: pac::USB) -> Can<Self> {
         Can::new_loopback(
             self,
             #[cfg(not(feature = "connectivity"))]
@@ -164,26 +146,26 @@ impl<CAN: Instance> CanExt for CAN {
 
 pub trait Instance: crate::rcc::Enable {
     type Tx;
-    type Rx<PULL>;
+    type Rx;
 }
 impl Instance for pac::CAN1 {
     type Tx = can1::Tx;
-    type Rx<PULL> = can1::Rx<PULL>;
+    type Rx = can1::Rx;
 }
 #[cfg(feature = "connectivity")]
 impl Instance for pac::CAN2 {
     type Tx = can2::Tx;
-    type Rx<PULL> = can2::Rx<PULL>;
+    type Rx = can2::Rx;
 }
 
 /// Interface to the CAN peripheral.
 #[allow(unused)]
-pub struct Can<CAN: Instance, PULL = Floating> {
+pub struct Can<CAN: Instance> {
     can: CAN,
-    pins: Option<Pins<CAN::Tx, CAN::Rx<PULL>>>,
+    pins: Option<Pins<CAN::Tx, CAN::Rx>>,
 }
 
-impl<CAN: Instance, PULL> Can<CAN, PULL> {
+impl<CAN: Instance> Can<CAN> {
     /// Creates a CAN interface.
     ///
     /// CAN shares SRAM with the USB peripheral. Take ownership of USB to
@@ -191,8 +173,8 @@ impl<CAN: Instance, PULL> Can<CAN, PULL> {
     pub fn new(
         can: CAN,
         #[cfg(not(feature = "connectivity"))] _usb: pac::USB,
-        pins: impl Into<Pins<CAN::Tx, CAN::Rx<PULL>>>,
-    ) -> Can<CAN, PULL> {
+        pins: impl Into<Pins<CAN::Tx, CAN::Rx>>,
+    ) -> Can<CAN> {
         let rcc = unsafe { &(*RCC::ptr()) };
         CAN::enable(rcc);
 
@@ -204,7 +186,7 @@ impl<CAN: Instance, PULL> Can<CAN, PULL> {
     pub fn new_loopback(
         can: CAN,
         #[cfg(not(feature = "connectivity"))] _usb: pac::USB,
-    ) -> Can<CAN, PULL> {
+    ) -> Can<CAN> {
         let rcc = unsafe { &(*RCC::ptr()) };
         CAN::enable(rcc);
 
@@ -212,18 +194,18 @@ impl<CAN: Instance, PULL> Can<CAN, PULL> {
     }
 }
 
-unsafe impl<PULL> bxcan::Instance for Can<pac::CAN1, PULL> {
+unsafe impl bxcan::Instance for Can<pac::CAN1> {
     const REGISTERS: *mut bxcan::RegisterBlock = pac::CAN1::ptr() as *mut _;
 }
 
 #[cfg(feature = "connectivity")]
-unsafe impl<PULL> bxcan::Instance for Can<pac::CAN2, PULL> {
+unsafe impl bxcan::Instance for Can<pac::CAN2> {
     const REGISTERS: *mut bxcan::RegisterBlock = pac::CAN2::ptr() as *mut _;
 }
 
-unsafe impl<PULL> bxcan::FilterOwner for Can<pac::CAN1, PULL> {
+unsafe impl bxcan::FilterOwner for Can<pac::CAN1> {
     const NUM_FILTER_BANKS: u8 = 28;
 }
 
 #[cfg(feature = "connectivity")]
-unsafe impl<PULL> bxcan::MasterInstance for Can<pac::CAN1, PULL> {}
+unsafe impl bxcan::MasterInstance for Can<pac::CAN1> {}
diff --git a/src/gpio.rs b/src/gpio.rs
index bd1b62af..6718f45d 100644
--- a/src/gpio.rs
+++ b/src/gpio.rs
@@ -156,25 +156,28 @@ pub trait Active {}
 
 /// Input mode (type state)
 #[derive(Default)]
-pub struct Input<PULL = Floating>(PhantomData<PULL>);
-
-impl<PULL> Active for Input<PULL> {}
-
-/// Used by the debugger (type state)
-#[derive(Default)]
-pub struct Debugger;
+pub struct Input;
+
+/// Pull setting for an input.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Pull {
+    /// Floating
+    None = 0,
+    /// Pulled up
+    Up = 1,
+    /// Pulled down
+    Down = 2,
+}
 
-/// Floating input (type state)
 #[derive(Default)]
-pub struct Floating;
+struct PulledInput;
 
-/// Pulled down input (type state)
-#[derive(Default)]
-pub struct PullDown;
+impl Active for Input {}
 
-/// Pulled up input (type state)
+/// Used by the debugger (type state)
 #[derive(Default)]
-pub struct PullUp;
+pub struct Debugger;
 
 /// Output mode (type state)
 #[derive(Default)]
@@ -222,7 +225,6 @@ mod sealed {
     pub trait PinMode: Default {
         const CNF: super::Cnf;
         const MODE: super::Mode;
-        const PULL: Option<bool> = None;
     }
 }
 
@@ -231,7 +233,7 @@ use crate::pac::gpioa::crl::{CNF0 as Cnf, MODE0 as Mode};
 use sealed::Interruptable;
 pub(crate) use sealed::PinMode;
 
-impl<MODE> Interruptable for Input<MODE> {}
+impl Interruptable for Input {}
 impl Interruptable for Dynamic {}
 
 /// External Interrupt Pin
@@ -375,7 +377,7 @@ macro_rules! gpio {
         pub mod $gpiox {
             use crate::pac::{$GPIOX, RCC};
             use crate::rcc::{Enable, Reset};
-            use super::{Active, Floating, GpioExt, Input, PartiallyErasedPin, ErasedPin, Pin, Cr};
+            use super::{Active, GpioExt, Input, PartiallyErasedPin, ErasedPin, Pin, Cr};
             #[allow(unused)]
             use super::Debugger;
 
@@ -392,7 +394,7 @@ macro_rules! gpio {
             }
 
             $(
-                pub type $PXi<MODE = Input<Floating>> = Pin<$port_id, $pin_number, MODE>;
+                pub type $PXi<MODE = Input> = Pin<$port_id, $pin_number, MODE>;
             )+
 
             impl GpioExt for $GPIOX {
@@ -455,7 +457,7 @@ macro_rules! gpio {
 /// - `P` is port name: `A` for GPIOA, `B` for GPIOB, etc.
 /// - `N` is pin number: from `0` to `15`.
 /// - `MODE` is one of the pin modes (see [Modes](crate::gpio#modes) section).
-pub struct Pin<const P: char, const N: u8, MODE = Input<Floating>> {
+pub struct Pin<const P: char, const N: u8, MODE = Input> {
     mode: MODE,
 }
 
@@ -505,7 +507,7 @@ impl<const P: char, const N: u8> Pin<P, N, Debugger> {
     /// must enforce that the pin is really in this
     /// state in the hardware.
     #[allow(dead_code)]
-    pub(crate) unsafe fn activate(self) -> Pin<P, N, Input<Floating>> {
+    pub(crate) unsafe fn activate(self) -> Pin<P, N, Input> {
         Pin::new()
     }
 }
@@ -616,7 +618,7 @@ impl<const P: char, const N: u8, MODE> Pin<P, N, Output<MODE>> {
     }
 }
 
-impl<const P: char, const N: u8, MODE> Pin<P, N, Input<MODE>> {
+impl<const P: char, const N: u8> Pin<P, N, Input> {
     #[inline]
     pub fn is_high(&self) -> bool {
         !self._is_low()
@@ -628,6 +630,59 @@ impl<const P: char, const N: u8, MODE> Pin<P, N, Input<MODE>> {
     }
 }
 
+impl<const P: char, const N: u8, MODE> Pin<P, N, MODE> {
+    fn _set_pull_up(&mut self) {
+        let gpio = unsafe { &(*gpiox::<P>()) };
+        gpio.bsrr().write(|w| w.bs(N).set_bit());
+    }
+    fn _pull_up(mut self) -> Self {
+        self._set_pull_up();
+        self
+    }
+    fn _set_pull_down(&mut self) {
+        let gpio = unsafe { &(*gpiox::<P>()) };
+        gpio.bsrr().write(|w| w.br(N).set_bit());
+    }
+    fn _pull_down(mut self) -> Self {
+        self._set_pull_down();
+        self
+    }
+}
+impl<const P: char, const N: u8> Pin<P, N, Input> {
+    /// Set the internal pull-up and pull-down resistor
+    pub fn set_internal_resistor(&mut self, pull: Pull) {
+        match pull {
+            Pull::None => {
+                let gpio = unsafe { &(*gpiox::<P>()) };
+                match N {
+                    0..=7 => {
+                        gpio.crl().modify(|_, w| w.cnf(N).variant(Cnf::OpenDrain));
+                    }
+                    8..=15 => {
+                        gpio.crh()
+                            .modify(|_, w| unsafe { w.cnf(N - 16).bits(Cnf::OpenDrain as u8) });
+                    }
+                    _ => unreachable!(),
+                }
+            }
+            Pull::Up => {
+                self.mode::<PulledInput>();
+                self._set_pull_up()
+            }
+            Pull::Down => {
+                self.mode::<PulledInput>();
+                self._set_pull_down()
+            }
+        }
+    }
+
+    /// Set the internal pull-up and pull-down resistor
+    pub fn internal_resistor(mut self, pull: Pull) -> Self {
+        self.set_internal_resistor(pull);
+        self
+    }
+}
+
 impl<const P: char, const N: u8> Pin<P, N, Output<OpenDrain>> {
     #[inline]
     pub fn is_high(&self) -> bool {
@@ -671,20 +726,22 @@ where
 
     /// Configures the pin to operate as a floating input pin
     #[inline]
-    pub fn into_floating_input(self, cr: &mut <Self as HL>::Cr) -> Pin<P, N, Input<Floating>> {
+    pub fn into_floating_input(self, cr: &mut <Self as HL>::Cr) -> Pin<P, N, Input> {
         self.into_mode(cr)
     }
 
     /// Configures the pin to operate as a pulled down input pin
     #[inline]
-    pub fn into_pull_down_input(self, cr: &mut <Self as HL>::Cr) -> Pin<P, N, Input<PullDown>> {
-        self.into_mode(cr)
+    pub fn into_pull_down_input(mut self, _cr: &mut <Self as HL>::Cr) -> Pin<P, N, Input> {
+        self.mode::<PulledInput>();
+        Pin::new()._pull_down()
     }
 
     /// Configures the pin to operate as a pulled up input pin
     #[inline]
-    pub fn into_pull_up_input(self, cr: &mut <Self as HL>::Cr) -> Pin<P, N, Input<PullUp>> {
-        self.into_mode(cr)
+    pub fn into_pull_up_input(mut self, _cr: &mut <Self as HL>::Cr) -> Pin<P, N, Input> {
+        self.mode::<PulledInput>();
+        Pin::new()._pull_up()
     }
 
     /// Configures the pin to operate as an open-drain output pin.
@@ -745,8 +802,8 @@ where
     /// and output without changing the type. It starts out
     /// as a floating input
     #[inline]
-    pub fn into_dynamic(mut self, cr: &mut <Self as HL>::Cr) -> Pin<P, N, Dynamic> {
-        self.mode::<Input<Floating>>(cr);
+    pub fn into_dynamic(mut self, _cr: &mut <Self as HL>::Cr) -> Pin<P, N, Dynamic> {
+        self.mode::<Input>();
         Pin::new()
     }
 }
@@ -762,14 +819,13 @@ macro_rules! impl_temp_output {
         #[inline]
         pub fn $fn_name(
             &mut self,
-            cr: &mut <Self as HL>::Cr,
+            _cr: &mut <Self as HL>::Cr,
             mut f: impl FnMut(&mut Pin<P, N, $mode>),
         ) {
-            self.mode::<$mode>(cr);
+            self.mode::<$mode>();
             let mut temp = Pin::<P, N, $mode>::new();
             f(&mut temp);
-            self.mode::<$mode>(cr);
-            Self::new();
+            temp.mode::<MODE>();
         }
 
         /// Temporarily change the mode of the pin.
@@ -780,33 +836,31 @@ macro_rules! impl_temp_output {
         #[inline]
         pub fn $stateful_fn_name(
             &mut self,
-            cr: &mut <Self as HL>::Cr,
+            _cr: &mut <Self as HL>::Cr,
             state: PinState,
             mut f: impl FnMut(&mut Pin<P, N, $mode>),
         ) {
             self._set_state(state);
-            self.mode::<$mode>(cr);
+            self.mode::<$mode>();
             let mut temp = Pin::<P, N, $mode>::new();
             f(&mut temp);
-            self.mode::<$mode>(cr);
-            Self::new();
+            temp.mode::<MODE>();
         }
     };
 }
 macro_rules! impl_temp_input {
-    ($fn_name:ident, $mode:ty) => {
+    ($fn_name:ident, $mode:ty $(, $pull:ident)?) => {
         /// Temporarily change the mode of the pin.
         #[inline]
         pub fn $fn_name(
             &mut self,
-            cr: &mut <Self as HL>::Cr,
-            mut f: impl FnMut(&mut Pin<P, N, $mode>),
+            _cr: &mut <Self as HL>::Cr,
+            mut f: impl FnMut(&mut Pin<P, N, Input>),
         ) {
-            self.mode::<$mode>(cr);
-            let mut temp = Pin::<P, N, $mode>::new();
+            self.mode::<$mode>();
+            let mut temp = Pin::<P, N, Input>::new() $(.$pull())?;
             f(&mut temp);
-            self.mode::<$mode>(cr);
-            Self::new();
+            temp.mode::<MODE>();
         }
     };
 }
@@ -826,9 +880,9 @@ where
         as_open_drain_output_with_state,
         Output<OpenDrain>
     );
-    impl_temp_input!(as_floating_input, Input<Floating>);
-    impl_temp_input!(as_pull_up_input, Input<PullUp>);
-    impl_temp_input!(as_pull_down_input, Input<PullDown>);
+    impl_temp_input!(as_floating_input, Input);
+    impl_temp_input!(as_pull_up_input, PulledInput, _pull_up);
+    impl_temp_input!(as_pull_down_input, PulledInput, _pull_down);
 }
 
 impl<const P: char, const N: u8, MODE> Pin<P, N, MODE>
@@ -877,37 +931,39 @@ where
     Self: HL,
 {
     #[inline]
-    pub fn make_pull_up_input(&mut self, cr: &mut <Self as HL>::Cr) {
+    pub fn make_pull_up_input(&mut self, _cr: &mut <Self as HL>::Cr) {
         // NOTE(unsafe), we have a mutable reference to the current pin
-        self.mode::<Input<PullUp>>(cr);
+        self.mode::<PulledInput>();
+        self._set_pull_up();
         self.mode = Dynamic::InputPullUp;
     }
 
     #[inline]
-    pub fn make_pull_down_input(&mut self, cr: &mut <Self as HL>::Cr) {
+    pub fn make_pull_down_input(&mut self, _cr: &mut <Self as HL>::Cr) {
         // NOTE(unsafe), we have a mutable reference to the current pin
-        self.mode::<Input<PullDown>>(cr);
+        self.mode::<PulledInput>();
+        self._set_pull_down();
         self.mode = Dynamic::InputPullDown;
     }
 
     #[inline]
-    pub fn make_floating_input(&mut self, cr: &mut <Self as HL>::Cr) {
+    pub fn make_floating_input(&mut self, _cr: &mut <Self as HL>::Cr) {
         // NOTE(unsafe), we have a mutable reference to the current pin
-        self.mode::<Input<Floating>>(cr);
+        self.mode::<Input>();
         self.mode = Dynamic::InputFloating;
     }
 
     #[inline]
-    pub fn make_push_pull_output(&mut self, cr: &mut <Self as HL>::Cr) {
+    pub fn make_push_pull_output(&mut self, _cr: &mut <Self as HL>::Cr) {
         // NOTE(unsafe), we have a mutable reference to the current pin
-        self.mode::<Output<PushPull>>(cr);
+        self.mode::<Output<PushPull>>();
         self.mode = Dynamic::OutputPushPull;
     }
 
     #[inline]
-    pub fn make_open_drain_output(&mut self, cr: &mut <Self as HL>::Cr) {
+    pub fn make_open_drain_output(&mut self, _cr: &mut <Self as HL>::Cr) {
         // NOTE(unsafe), we have a mutable reference to the current pin
-        self.mode::<Output<OpenDrain>>(cr);
+        self.mode::<Output<OpenDrain>>();
         self.mode = Dynamic::OutputOpenDrain;
     }
 }
@@ -917,21 +973,14 @@ impl PinMode for Analog {
     const CNF: Cnf = Cnf::PushPull;
 }
 
-impl PinMode for Input<Floating> {
+impl PinMode for Input {
     const MODE: Mode = Mode::Input;
     const CNF: Cnf = Cnf::OpenDrain;
 }
 
-impl PinMode for Input<PullDown> {
-    const MODE: Mode = Mode::Input;
-    const CNF: Cnf = Cnf::AltPushPull;
-    const PULL: Option<bool> = Some(false);
-}
-
-impl PinMode for Input<PullUp> {
+impl PinMode for PulledInput {
     const MODE: Mode = Mode::Input;
     const CNF: Cnf = Cnf::AltPushPull;
-    const PULL: Option<bool> = Some(true);
 }
 
 impl PinMode for Output<PushPull> {
@@ -954,24 +1003,10 @@ impl PinMode for Alternate<OpenDrain> {
     const CNF: Cnf = Cnf::AltOpenDrain;
 }
 
-impl<const P: char, const N: u8, M> Pin<P, N, M>
-where
-    Self: HL,
-{
-    fn mode<MODE: PinMode>(&mut self, _cr: &mut <Self as HL>::Cr) {
+impl<const P: char, const N: u8, M> Pin<P, N, M> {
+    fn mode<MODE: PinMode>(&mut self) {
         let gpio = unsafe { &(*gpiox::<P>()) };
 
-        // Input<PullUp> or Input<PullDown> mode
-        if let Some(pull) = MODE::PULL {
-            gpio.bsrr().write(|w| {
-                if pull {
-                    w.bs(N).set_bit()
-                } else {
-                    w.br(N).set_bit()
-                }
-            })
-        }
-
         match N {
             0..=7 => {
                 gpio.crl()
@@ -986,10 +1021,18 @@ where
             _ => unreachable!(),
         }
     }
+}
 
+impl<const P: char, const N: u8, M> Pin<P, N, M>
+where
+    Self: HL,
+{
     #[inline]
-    pub(crate) fn into_mode<MODE: PinMode>(mut self, cr: &mut <Self as HL>::Cr) -> Pin<P, N, MODE> {
-        self.mode::<MODE>(cr);
+    pub(crate) fn into_mode<MODE: PinMode>(
+        mut self,
+        _cr: &mut <Self as HL>::Cr,
+    ) -> Pin<P, N, MODE> {
+        self.mode::<MODE>();
         Pin::new()
     }
 }
@@ -1007,17 +1050,27 @@ impl Analog {
     }
 }
 
-impl<PULL> Input<PULL> {
+impl Input {
     pub fn new<const P: char, const N: u8, MODE>(
-        pin: Pin<P, N, MODE>,
+        mut pin: Pin<P, N, MODE>,
         cr: &mut <Pin<P, N, MODE> as HL>::Cr,
-        _pull: PULL,
+        pull: Pull,
     ) -> Pin<P, N, Self>
     where
         Pin<P, N, MODE>: HL,
         Self: PinMode,
     {
-        pin.into_mode(cr)
+        match pull {
+            Pull::None => pin.into_mode(cr),
+            Pull::Up => {
+                pin.mode::<PulledInput>();
+                Pin::new()._pull_up()
+            }
+            Pull::Down => {
+                pin.mode::<PulledInput>();
+                Pin::new()._pull_down()
+            }
+        }
     }
 }
 
diff --git a/src/gpio/erased.rs b/src/gpio/erased.rs
index f09bff71..2b6a90d3 100644
--- a/src/gpio/erased.rs
+++ b/src/gpio/erased.rs
@@ -57,7 +57,7 @@ macro_rules! impl_pxx {
             }
         }
 
-        impl<MODE> ErasedPin<Input<MODE>> {
+        impl ErasedPin<Input> {
             pub fn is_high(&self) -> bool {
                 match self {
                     $(Self::$pin(pin) => pin.is_high()),*
diff --git a/src/gpio/hal_02.rs b/src/gpio/hal_02.rs
index 54baa8ab..127b87f9 100644
--- a/src/gpio/hal_02.rs
+++ b/src/gpio/hal_02.rs
@@ -72,7 +72,7 @@ impl<const P: char, const N: u8, MODE> ToggleableOutputPin for Pin<P, N, Output<
     }
 }
 
-impl<const P: char, const N: u8, MODE> InputPin for Pin<P, N, Input<MODE>> {
+impl<const P: char, const N: u8> InputPin for Pin<P, N, Input> {
     type Error = Infallible;
     #[inline]
     fn is_high(&self) -> Result<bool, Self::Error> {
@@ -152,7 +152,7 @@ impl<const P: char> InputPin for PartiallyErasedPin<P, Output<OpenDrain>> {
     }
 }
 
-impl<const P: char, MODE> InputPin for PartiallyErasedPin<P, Input<MODE>> {
+impl<const P: char> InputPin for PartiallyErasedPin<P, Input> {
     type Error = Infallible;
 
     #[inline(always)]
@@ -191,7 +191,7 @@ impl<MODE> StatefulOutputPin for ErasedPin<Output<MODE>> {
     }
 }
 
-impl<MODE> InputPin for ErasedPin<Input<MODE>> {
+impl InputPin for ErasedPin<Input> {
     type Error = Infallible;
     fn is_high(&self) -> Result<bool, Infallible> {
         Ok(self.is_high())
diff --git a/src/gpio/hal_1.rs b/src/gpio/hal_1.rs
index a3d4bc40..f63417d5 100644
--- a/src/gpio/hal_1.rs
+++ b/src/gpio/hal_1.rs
@@ -16,7 +16,7 @@ fn into_state(state: PinState) -> super::PinState {
 impl<const P: char, const N: u8, MODE> ErrorType for Pin<P, N, Output<MODE>> {
     type Error = Infallible;
 }
-impl<const P: char, const N: u8, MODE> ErrorType for Pin<P, N, Input<MODE>> {
+impl<const P: char, const N: u8> ErrorType for Pin<P, N, Input> {
     type Error = Infallible;
 }
 
@@ -88,7 +88,7 @@ impl<const P: char, const N: u8, MODE> StatefulOutputPin for Pin<P, N, Output<MO
     }
 }
 
-impl<const P: char, const N: u8, MODE> InputPin for Pin<P, N, Input<MODE>> {
+impl<const P: char, const N: u8> InputPin for Pin<P, N, Input> {
     #[inline]
     fn is_high(&mut self) -> Result<bool, Self::Error> {
         Ok((*self).is_high())
@@ -156,7 +156,7 @@ impl<const P: char> InputPin for PartiallyErasedPin<P, Output<OpenDrain>> {
     }
 }
 
-impl<const P: char, MODE> InputPin for PartiallyErasedPin<P, Input<MODE>> {
+impl<const P: char> InputPin for PartiallyErasedPin<P, Input> {
     #[inline(always)]
     fn is_high(&mut self) -> Result<bool, Self::Error> {
         Ok((*self).is_high())
@@ -196,7 +196,7 @@ impl<MODE> StatefulOutputPin for ErasedPin<Output<MODE>> {
     }
 }
 
-impl<MODE> InputPin for ErasedPin<Input<MODE>> {
+impl InputPin for ErasedPin<Input> {
     fn is_high(&mut self) -> Result<bool, Infallible> {
         Ok((*self).is_high())
     }
diff --git a/src/gpio/partially_erased.rs b/src/gpio/partially_erased.rs
index 4aef818b..f0380acc 100644
--- a/src/gpio/partially_erased.rs
+++ b/src/gpio/partially_erased.rs
@@ -102,7 +102,7 @@ impl<const P: char> PartiallyErasedPin<P, Output<OpenDrain>> {
     }
 }
 
-impl<const P: char, MODE> PartiallyErasedPin<P, Input<MODE>> {
+impl<const P: char> PartiallyErasedPin<P, Input> {
     #[inline(always)]
     pub fn is_high(&self) -> bool {
         !self.is_low()
diff --git a/src/serial.rs b/src/serial.rs
index f1547787..a568340d 100644
--- a/src/serial.rs
+++ b/src/serial.rs
@@ -68,7 +68,7 @@ use embedded_dma::{ReadBuffer, WriteBuffer};
 
 use crate::afio::Remap;
 use crate::dma::{dma1, CircBuffer, RxDma, Transfer, TxDma, R, W};
-use crate::gpio::{self, Alternate, Cr, Floating, Input, NoPin, PinMode, PullUp, PushPull};
+use crate::gpio::{self, Alternate, Cr, Input, NoPin, PinMode, PushPull};
 use crate::pac::{self, RCC};
 use crate::rcc::{BusClock, Clocks, Enable, Reset};
 use crate::time::{Bps, U32Ext};
@@ -76,10 +76,6 @@ use crate::time::{Bps, U32Ext};
 mod hal_02;
 mod hal_1;
 
-pub trait InMode {}
-impl InMode for Floating {}
-impl InMode for PullUp {}
-
 pub struct Pins<TX, RX> {
     pub tx: TX,
     pub rx: RX,
@@ -138,44 +134,42 @@ macro_rules! remap {
             )+
             None(NoPin<Otype>),
         }
-        pub enum Rx<PULL> {
+        pub enum Rx {
             $(
-                $RX(gpio::$RX<Input<PULL>>),
+                $RX(gpio::$RX<Input>),
             )+
-            None(NoPin<PULL>),
+            None(NoPin<PushPull>),
         }
 
         $(
-            impl<Otype, PULL: InMode> From<(gpio::$TX<Alternate<Otype>>, gpio::$RX<Input<PULL>>, &mut <$PER as Remap>::Mapr)> for Pins<Tx<Otype>, Rx<PULL>> {
-                fn from(p: (gpio::$TX<Alternate<Otype>>, gpio::$RX<Input<PULL>>, &mut <$PER as Remap>::Mapr)) -> Self {
+            impl<Otype> From<(gpio::$TX<Alternate<Otype>>, gpio::$RX, &mut <$PER as Remap>::Mapr)> for Pins<Tx<Otype>, Rx> {
+                fn from(p: (gpio::$TX<Alternate<Otype>>, gpio::$RX, &mut <$PER as Remap>::Mapr)) -> Self {
                     <$PER>::remap(p.2, $remap);
                     Self { tx: Tx::$TX(p.0), rx: Rx::$RX(p.1) }
                 }
             }
 
-            impl<Otype, PULL> From<(gpio::$TX, gpio::$RX, &mut <$PER as Remap>::Mapr)> for Pins<Tx<Otype>, Rx<PULL>>
+            impl<Otype> From<(gpio::$TX, gpio::$RX, &mut <$PER as Remap>::Mapr)> for Pins<Tx<Otype>, Rx>
             where
                 Alternate<Otype>: PinMode,
-                Input<PULL>: PinMode,
-                PULL: InMode,
             {
                 fn from(p: (gpio::$TX, gpio::$RX, &mut <$PER as Remap>::Mapr)) -> Self {
                     let mut cr = Cr;
                     let tx = p.0.into_mode(&mut cr);
-                    let rx = p.1.into_mode(&mut cr);
+                    let rx = p.1;
                     <$PER>::remap(p.2, $remap);
                     Self { tx: Tx::$TX(tx), rx: Rx::$RX(rx) }
                 }
             }
 
-            impl<Otype> From<(gpio::$TX<Alternate<Otype>>, &mut <$PER as Remap>::Mapr)> for Pins<Tx<Otype>, Rx<Floating>> {
+            impl<Otype> From<(gpio::$TX<Alternate<Otype>>, &mut <$PER as Remap>::Mapr)> for Pins<Tx<Otype>, Rx> {
                 fn from(p: (gpio::$TX<Alternate<Otype>>, &mut <$PER as Remap>::Mapr)) -> Self {
                     <$PER>::remap(p.1, $remap);
                     Self { tx: Tx::$TX(p.0), rx: Rx::None(NoPin::new()) }
                 }
             }
 
-            impl<Otype> From<(gpio::$TX, &mut <$PER as Remap>::Mapr)> for Pins<Tx<Otype>, Rx<Floating>>
+            impl<Otype> From<(gpio::$TX, &mut <$PER as Remap>::Mapr)> for Pins<Tx<Otype>, Rx>
             where
                 Alternate<Otype>: PinMode,
             {
@@ -186,11 +180,8 @@ macro_rules! remap {
                 }
             }
 
-            impl<PULL> From<(gpio::$RX<Input<PULL>>, &mut <$PER as Remap>::Mapr)> for Pins<Tx<PushPull>, Rx<PULL>>
-            where
-                PULL: InMode,
-            {
-                fn from(p: (gpio::$RX<Input<PULL>>, &mut <$PER as Remap>::Mapr)) -> Self {
+            impl From<(gpio::$RX, &mut <$PER as Remap>::Mapr)> for Pins<Tx<PushPull>, Rx> {
+                fn from(p: (gpio::$RX<Input>, &mut <$PER as Remap>::Mapr)) -> Self {
                     <$PER>::remap(p.1, $remap);
                     Self { tx: Tx::None(NoPin::new()), rx: Rx::$RX(p.0) }
                 }
@@ -203,13 +194,13 @@ use remap;
 pub trait SerialExt: Sized + Instance {
     fn serial(
         self,
-        pins: impl Into<Pins<Self::Tx<PushPull>, Self::Rx<Floating>>>,
+        pins: impl Into<Pins<Self::Tx<PushPull>, Self::Rx>>,
         config: impl Into<Config>,
         clocks: &Clocks,
-    ) -> Serial<Self, PushPull, Floating>;
+    ) -> Serial<Self, PushPull>;
     fn tx(
         self,
-        pins: impl Into<Pins<Self::Tx<PushPull>, Self::Rx<Floating>>>,
+        pins: impl Into<Pins<Self::Tx<PushPull>, Self::Rx>>,
         config: impl Into<Config>,
         clocks: &Clocks,
     ) -> Tx<Self> {
@@ -217,7 +208,7 @@ pub trait SerialExt: Sized + Instance {
     }
     fn rx(
         self,
-        pins: impl Into<Pins<Self::Tx<PushPull>, Self::Rx<Floating>>>,
+        pins: impl Into<Pins<Self::Tx<PushPull>, Self::Rx>>,
         config: impl Into<Config>,
         clocks: &Clocks,
     ) -> Rx<Self> {
@@ -228,7 +219,7 @@ pub trait SerialExt: Sized + Instance {
 impl<USART: Instance> SerialExt for USART {
     fn serial(
         self,
-        pins: impl Into<Pins<Self::Tx<PushPull>, Self::Rx<Floating>>>,
+        pins: impl Into<Pins<Self::Tx<PushPull>, Self::Rx>>,
         config: impl Into<Config>,
         clocks: &Clocks,
     ) -> Serial<Self> {
@@ -242,7 +233,7 @@ pub trait Instance:
     crate::Sealed + Deref<Target = uart_base::RegisterBlock> + Enable + Reset + BusClock
 {
     type Tx<Otype>;
-    type Rx<PULL>;
+    type Rx;
 
     #[doc(hidden)]
     fn ptr() -> *const uart_base::RegisterBlock;
@@ -253,7 +244,7 @@ macro_rules! inst {
         $(
             impl Instance for $USARTX {
                 type Tx<Otype> = $usart::Tx<Otype>;
-                type Rx<PULL> = $usart::Rx<PULL>;
+                type Rx = $usart::Rx;
 
                 fn ptr() -> *const uart_base::RegisterBlock {
                     <$USARTX>::ptr()
@@ -384,11 +375,11 @@ impl From<Bps> for Config {
 }
 
 /// Serial abstraction
-pub struct Serial<USART: Instance, Otype = PushPull, PULL = Floating> {
+pub struct Serial<USART: Instance, Otype = PushPull> {
     pub tx: Tx<USART>,
     pub rx: Rx<USART>,
     #[allow(clippy::type_complexity)]
-    pub token: ReleaseToken<USART, (USART::Tx<Otype>, USART::Rx<PULL>)>,
+    pub token: ReleaseToken<USART, (USART::Tx<Otype>, USART::Rx)>,
 }
 
 /// Serial transmitter
@@ -407,10 +398,10 @@ pub struct ReleaseToken<USART, PINS> {
     pins: PINS,
 }
 
-impl<USART: Instance, Otype> Serial<USART, Otype, Floating> {
+impl<USART: Instance, Otype> Serial<USART, Otype> {
     pub fn tx(
         usart: USART,
-        pins: impl Into<Pins<USART::Tx<Otype>, USART::Rx<Floating>>>,
+        pins: impl Into<Pins<USART::Tx<Otype>, USART::Rx>>,
         config: impl Into<Config>,
         clocks: &Clocks,
     ) -> Tx<USART> {
@@ -418,10 +409,10 @@ impl<USART: Instance, Otype> Serial<USART, Otype, Floating> {
     }
 }
 
-impl<USART: Instance, PULL> Serial<USART, PushPull, PULL> {
+impl<USART: Instance> Serial<USART, PushPull> {
     pub fn rx(
         usart: USART,
-        pins: impl Into<Pins<USART::Tx<PushPull>, USART::Rx<PULL>>>,
+        pins: impl Into<Pins<USART::Tx<PushPull>, USART::Rx>>,
         config: impl Into<Config>,
         clocks: &Clocks,
     ) -> Rx<USART> {
@@ -429,7 +420,7 @@ impl<USART: Instance, PULL> Serial<USART, PushPull, PULL> {
     }
 }
 
-impl<USART: Instance, Otype, PULL> Serial<USART, Otype, PULL> {
+impl<USART: Instance, Otype> Serial<USART, Otype> {
     /// Configures the serial interface and creates the interface
     /// struct.
     ///
@@ -447,7 +438,7 @@ impl<USART: Instance, Otype, PULL> Serial<USART, Otype, PULL> {
     /// corresponding pins. `APBX` is used to reset the USART.)
     pub fn new(
         usart: USART,
-        pins: impl Into<Pins<USART::Tx<Otype>, USART::Rx<PULL>>>,
+        pins: impl Into<Pins<USART::Tx<Otype>, USART::Rx>>,
         config: impl Into<Config>,
         clocks: &Clocks,
     ) -> Self {
@@ -515,7 +506,7 @@ impl<USART: Instance, Otype, PULL> Serial<USART, Otype, PULL> {
     /// let (usart, (tx_pin, rx_pin)) = serial.release();
     /// ```
     #[allow(clippy::type_complexity)]
-    pub fn release(self) -> (USART, (USART::Tx<Otype>, USART::Rx<PULL>)) {
+    pub fn release(self) -> (USART, (USART::Tx<Otype>, USART::Rx)) {
         (self.token.usart, self.token.pins)
     }
 
@@ -755,7 +746,7 @@ pub enum Event {
     Idle,
 }
 
-impl<USART: Instance, Otype, PULL> Serial<USART, Otype, PULL> {
+impl<USART: Instance, Otype> Serial<USART, Otype> {
     /// Starts listening to the USART by enabling the _Received data
     /// ready to be read (RXNE)_ interrupt and _Transmit data
     /// register empty (TXE)_ interrupt
diff --git a/src/spi.rs b/src/spi.rs
index 67beaddc..a77219e3 100644
--- a/src/spi.rs
+++ b/src/spi.rs
@@ -46,7 +46,7 @@ use crate::dma::dma1;
 #[cfg(feature = "connectivity")]
 use crate::dma::dma2;
 use crate::dma::{Receive, RxDma, RxTxDma, Transfer, TransferPayload, Transmit, TxDma, R, W};
-use crate::gpio::{self, Alternate, Cr, Floating, Input, NoPin, PinMode, PullUp, PushPull};
+use crate::gpio::{self, Alternate, Cr, Input, NoPin, PinMode, PushPull};
 use crate::rcc::{BusClock, Clocks, Enable, Reset};
 use crate::time::Hertz;
 
@@ -104,10 +104,6 @@ pub enum Error {
 
 use core::marker::PhantomData;
 
-pub trait InMode {}
-impl InMode for Floating {}
-impl InMode for PullUp {}
-
 pub struct MasterPins<SCK, MISO, MOSI> {
     pub sck: SCK,
     pub mi: MISO,
@@ -169,11 +165,11 @@ macro_rules! remap {
             None(NoPin<PushPull>),
         }
 
-        pub enum Mi<PULL> {
+        pub enum Mi {
             $(
-                $MISO(gpio::$MISO<Input<PULL>>),
+                $MISO(gpio::$MISO<Input>),
             )+
-            None(NoPin<Floating>),
+            None(NoPin<PushPull>),
         }
 
         pub enum So<Otype> {
@@ -190,59 +186,51 @@ macro_rules! remap {
             None(NoPin<PushPull>),
         }
 
-        pub enum Si<PULL> {
+        pub enum Si {
             $(
-                $MOSI(gpio::$MOSI<Input<PULL>>),
+                $MOSI(gpio::$MOSI<Input>),
             )+
-            None(NoPin<Floating>),
+            None(NoPin<PushPull>),
         }
 
         $(
             // For master mode
-            impl<PULL: InMode> From<(gpio::$SCK<Alternate>, gpio::$MISO<Input<PULL>>, gpio::$MOSI<Alternate> $(, &mut $MAPR)?)> for MasterPins<Sck, Mi<PULL>, Mo> {
-                fn from(p: (gpio::$SCK<Alternate>, gpio::$MISO<Input<PULL>>, gpio::$MOSI<Alternate> $(, &mut $MAPR)?)) -> Self {
+            impl From<(gpio::$SCK<Alternate>, gpio::$MISO, gpio::$MOSI<Alternate> $(, &mut $MAPR)?)> for MasterPins<Sck, Mi, Mo> {
+                fn from(p: (gpio::$SCK<Alternate>, gpio::$MISO, gpio::$MOSI<Alternate> $(, &mut $MAPR)?)) -> Self {
                     $(<$PER>::remap(p.3, $remap);)?
                     Self { sck: Sck::$SCK(p.0), mi: Mi::$MISO(p.1), mo: Mo::$MOSI(p.2) }
                 }
             }
 
-            impl<PULL> From<(gpio::$SCK, gpio::$MISO, gpio::$MOSI $(, &mut $MAPR)?)> for MasterPins<Sck, Mi<PULL>, Mo>
-            where
-                Input<PULL>: PinMode,
-                PULL: InMode,
-            {
+            impl From<(gpio::$SCK, gpio::$MISO, gpio::$MOSI $(, &mut $MAPR)?)> for MasterPins<Sck, Mi, Mo> {
                 fn from(p: (gpio::$SCK, gpio::$MISO, gpio::$MOSI $(, &mut $MAPR)?)) -> Self {
                     let mut cr = Cr;
                     let sck = p.0.into_mode(&mut cr);
-                    let miso = p.1.into_mode(&mut cr);
+                    let miso = p.1;
                     let mosi = p.2.into_mode(&mut cr);
                     $(<$PER>::remap(p.3, $remap);)?
                     Self { sck: Sck::$SCK(sck), mi: Mi::$MISO(miso), mo: Mo::$MOSI(mosi) }
                 }
             }
 
-            impl<PULL: InMode> From<(gpio::$SCK<Alternate>, gpio::$MISO<Input<PULL>> $(, &mut $MAPR)?)> for MasterPins<Sck, Mi<PULL>, Mo> {
-                fn from(p: (gpio::$SCK<Alternate>, gpio::$MISO<Input<PULL>> $(, &mut $MAPR)?)) -> Self {
+            impl From<(gpio::$SCK<Alternate>, gpio::$MISO $(, &mut $MAPR)?)> for MasterPins<Sck, Mi, Mo> {
+                fn from(p: (gpio::$SCK<Alternate>, gpio::$MISO $(, &mut $MAPR)?)) -> Self {
                     $(<$PER>::remap(p.2, $remap);)?
                     Self { sck: Sck::$SCK(p.0), mi: Mi::$MISO(p.1), mo: Mo::None(NoPin::new()) }
                 }
             }
 
-            impl<PULL> From<(gpio::$SCK, gpio::$MISO $(, &mut $MAPR)?)> for super::MasterPins<Sck, Mi<PULL>, Mo>
-            where
-                Input<PULL>: PinMode,
-                PULL: InMode,
-            {
+            impl From<(gpio::$SCK, gpio::$MISO $(, &mut $MAPR)?)> for super::MasterPins<Sck, Mi, Mo> {
                 fn from(p: (gpio::$SCK, gpio::$MISO $(, &mut $MAPR)?)) -> Self {
                     let mut cr = Cr;
                     let sck = p.0.into_mode(&mut cr);
-                    let miso = p.1.into_mode(&mut cr);
+                    let miso = p.1;
                     $(<$PER>::remap(p.2, $remap);)?
                     Self { sck: Sck::$SCK(sck), mi: Mi::$MISO(miso), mo: Mo::None(NoPin::new()) }
                 }
             }
 
-            impl From<(gpio::$SCK, gpio::$MOSI $(, &mut $MAPR)?)> for super::MasterPins<Sck, Mi<Floating>, Mo> {
+            impl From<(gpio::$SCK, gpio::$MOSI $(, &mut $MAPR)?)> for super::MasterPins<Sck, Mi, Mo> {
                 fn from(p: (gpio::$SCK, gpio::$MOSI $(, &mut $MAPR)?)) -> Self {
                     let mut cr = Cr;
                     let sck = p.0.into_mode(&mut cr);
@@ -254,30 +242,28 @@ macro_rules! remap {
 
             // For slave mode
 
-            impl<Otype, PULL: InMode> From<(gpio::$SCK<Alternate>, gpio::$MISO<Alternate<Otype>>, gpio::$MOSI<Input<PULL>> $(, &mut $MAPR)?)> for SlavePins<Sck, So<Otype>, Si<PULL>> {
-                fn from(p: (gpio::$SCK<Alternate>, gpio::$MISO<Alternate<Otype>>, gpio::$MOSI<Input<PULL>> $(, &mut $MAPR)?)) -> Self {
+            impl<Otype> From<(gpio::$SCK<Alternate>, gpio::$MISO<Alternate<Otype>>, gpio::$MOSI $(, &mut $MAPR)?)> for SlavePins<Sck, So<Otype>, Si> {
+                fn from(p: (gpio::$SCK<Alternate>, gpio::$MISO<Alternate<Otype>>, gpio::$MOSI $(, &mut $MAPR)?)) -> Self {
                     $(<$PER>::remap(p.3, $remap);)?
                     Self { sck: Sck::$SCK(p.0), so: So::$MISO(p.1), si: Si::$MOSI(p.2) }
                 }
             }
 
-            impl<Otype, PULL> From<(gpio::$SCK, gpio::$MISO, gpio::$MOSI $(, &mut $MAPR)?)> for SlavePins<Sck, So<Otype>, Si<PULL>>
+            impl<Otype> From<(gpio::$SCK, gpio::$MISO, gpio::$MOSI $(, &mut $MAPR)?)> for SlavePins<Sck, So<Otype>, Si>
             where
                 Alternate<Otype>: PinMode,
-                Input<PULL>: PinMode,
-                PULL: InMode,
             {
                 fn from(p: (gpio::$SCK, gpio::$MISO, gpio::$MOSI $(, &mut $MAPR)?)) -> Self {
                     let mut cr = Cr;
                     let sck = p.0.into_mode(&mut cr);
                     let miso = p.1.into_mode(&mut cr);
-                    let mosi = p.2.into_mode(&mut cr);
+                    let mosi = p.2;
                     $(<$PER>::remap(p.3, $remap);)?
                     Self { sck: Sck::$SCK(sck), so: So::$MISO(miso), si: Si::$MOSI(mosi) }
                 }
             }
 
-            impl<Otype> From<(gpio::$SCK, gpio::$MISO $(, &mut $MAPR)?)> for SlavePins<Sck, So<Otype>, Si<Floating>>
+            impl<Otype> From<(gpio::$SCK, gpio::$MISO $(, &mut $MAPR)?)> for SlavePins<Sck, So<Otype>, Si>
             where
                 Alternate<Otype>: PinMode,
             {
@@ -290,15 +276,11 @@ macro_rules! remap {
                 }
             }
 
-            impl<PULL> From<(gpio::$SCK, gpio::$MOSI $(, &mut $MAPR)?)> for SlavePins<Sck, So<PushPull>, Si<PULL>>
-            where
-                Input<PULL>: PinMode,
-                PULL: InMode,
-            {
+            impl From<(gpio::$SCK, gpio::$MOSI $(, &mut $MAPR)?)> for SlavePins<Sck, So<PushPull>, Si> {
                 fn from(p: (gpio::$SCK, gpio::$MOSI $(, &mut $MAPR)?)) -> Self {
                     let mut cr = Cr;
                     let sck = p.0.into_mode(&mut cr);
-                    let mosi = p.1.into_mode(&mut cr);
+                    let mosi = p.1;
                     $(<$PER>::remap(p.2, $remap);)?
                     Self { sck: Sck::$SCK(sck), so: So::None(NoPin::new()), si: Si::$MOSI(mosi) }
                 }
@@ -311,14 +293,14 @@ use remap;
 pub trait SpiExt: Sized + Instance {
     fn spi(
         self,
-        pins: impl Into<MasterPins<Self::Sck, Self::Mi<Floating>, Self::Mo>>,
+        pins: impl Into<MasterPins<Self::Sck, Self::Mi, Self::Mo>>,
         mode: Mode,
         freq: Hertz,
         clocks: &Clocks,
-    ) -> Spi<Self, u8, Floating>;
+    ) -> Spi<Self, u8>;
     fn spi_u16(
         self,
-        pins: impl Into<MasterPins<Self::Sck, Self::Mi<Floating>, Self::Mo>>,
+        pins: impl Into<MasterPins<Self::Sck, Self::Mi, Self::Mo>>,
         mode: Mode,
         freq: Hertz,
         clocks: &Clocks,
@@ -327,14 +309,14 @@ pub trait SpiExt: Sized + Instance {
     }
     fn spi_slave(
         self,
-        pins: impl Into<SlavePins<Self::Sck, Self::So<PushPull>, Self::Si<Floating>>>,
+        pins: impl Into<SlavePins<Self::Sck, Self::So<PushPull>, Self::Si>>,
         mode: Mode,
-    ) -> SpiSlave<Self, u8, PushPull, Floating>;
+    ) -> SpiSlave<Self, u8, PushPull>;
     fn spi_slave_u16(
         self,
-        pins: impl Into<SlavePins<Self::Sck, Self::So<PushPull>, Self::Si<Floating>>>,
+        pins: impl Into<SlavePins<Self::Sck, Self::So<PushPull>, Self::Si>>,
         mode: Mode,
-    ) -> SpiSlave<Self, u16, PushPull, Floating> {
+    ) -> SpiSlave<Self, u16, PushPull> {
         Self::spi_slave(self, pins, mode).frame_size_16bit()
     }
 }
@@ -342,18 +324,18 @@ pub trait SpiExt: Sized + Instance {
 impl<SPI: Instance> SpiExt for SPI {
     fn spi(
         self,
-        pins: impl Into<MasterPins<Self::Sck, Self::Mi<Floating>, Self::Mo>>,
+        pins: impl Into<MasterPins<Self::Sck, Self::Mi, Self::Mo>>,
         mode: Mode,
         freq: Hertz,
         clocks: &Clocks,
-    ) -> Spi<Self, u8, Floating> {
+    ) -> Spi<Self, u8> {
         Spi::new(self, pins, mode, freq, clocks)
     }
     fn spi_slave(
         self,
-        pins: impl Into<SlavePins<Self::Sck, Self::So<PushPull>, Self::Si<Floating>>>,
+        pins: impl Into<SlavePins<Self::Sck, Self::So<PushPull>, Self::Si>>,
         mode: Mode,
-    ) -> SpiSlave<Self, u8, PushPull, Floating> {
+    ) -> SpiSlave<Self, u8, PushPull> {
         SpiSlave::new(self, pins, mode)
     }
 }
@@ -373,38 +355,38 @@ impl<SPI, W> SpiInner<SPI, W> {
 }
 
 /// Spi in Master mode
-pub struct Spi<SPI: Instance, W, PULL = Floating> {
+pub struct Spi<SPI: Instance, W> {
     inner: SpiInner<SPI, W>,
-    pins: (SPI::Sck, SPI::Mi<PULL>, SPI::Mo),
+    pins: (SPI::Sck, SPI::Mi, SPI::Mo),
 }
 
 /// Spi in Slave mode
-pub struct SpiSlave<SPI: Instance, W, Otype = PushPull, PULL = Floating> {
+pub struct SpiSlave<SPI: Instance, W, Otype = PushPull> {
     inner: SpiInner<SPI, W>,
-    pins: (SPI::Sck, SPI::So<Otype>, SPI::Si<PULL>),
+    pins: (SPI::Sck, SPI::So<Otype>, SPI::Si),
 }
 
-impl<SPI: Instance, W, PULL> Deref for Spi<SPI, W, PULL> {
+impl<SPI: Instance, W> Deref for Spi<SPI, W> {
     type Target = SpiInner<SPI, W>;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
 
-impl<SPI: Instance, W, PULL> DerefMut for Spi<SPI, W, PULL> {
+impl<SPI: Instance, W> DerefMut for Spi<SPI, W> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
 
-impl<SPI: Instance, W, Otype, PULL> Deref for SpiSlave<SPI, W, Otype, PULL> {
+impl<SPI: Instance, W, Otype> Deref for SpiSlave<SPI, W, Otype> {
     type Target = SpiInner<SPI, W>;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
 
-impl<SPI: Instance, W, Otype, PULL> DerefMut for SpiSlave<SPI, W, Otype, PULL> {
+impl<SPI: Instance, W, Otype> DerefMut for SpiSlave<SPI, W, Otype> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
@@ -423,36 +405,36 @@ pub trait Instance:
     crate::Sealed + Deref<Target = crate::pac::spi1::RegisterBlock> + Enable + Reset + BusClock
 {
     type Sck;
-    type Mi<PULL>;
+    type Mi;
     type So<Otype>;
     type Mo;
-    type Si<PULL>;
+    type Si;
 }
 
 impl Instance for pac::SPI1 {
     type Sck = spi1::Sck;
-    type Mi<PULL> = spi1::Mi<PULL>;
+    type Mi = spi1::Mi;
     type So<Otype> = spi1::So<Otype>;
     type Mo = spi1::Mo;
-    type Si<PULL> = spi1::Si<PULL>;
+    type Si = spi1::Si;
 }
 impl Instance for pac::SPI2 {
     type Sck = spi2::Sck;
-    type Mi<PULL> = spi2::Mi<PULL>;
+    type Mi = spi2::Mi;
     type So<Otype> = spi2::So<Otype>;
     type Mo = spi2::Mo;
-    type Si<PULL> = spi2::Si<PULL>;
+    type Si = spi2::Si;
 }
 #[cfg(any(feature = "high", feature = "connectivity"))]
 impl Instance for pac::SPI3 {
     type Sck = spi3::Sck;
-    type Mi<PULL> = spi3::Mi<PULL>;
+    type Mi = spi3::Mi;
     type So<Otype> = spi3::So<Otype>;
     type Mo = spi3::Mo;
-    type Si<PULL> = spi3::Si<PULL>;
+    type Si = spi3::Si;
 }
 
-impl<SPI: Instance, PULL> Spi<SPI, u8, PULL> {
+impl<SPI: Instance> Spi<SPI, u8> {
     /**
       Constructs an SPI instance using SPI1 in 8bit dataframe mode.
 
@@ -462,7 +444,7 @@ impl<SPI: Instance, PULL> Spi<SPI, u8, PULL> {
     */
     pub fn new(
         spi: SPI,
-        pins: impl Into<MasterPins<SPI::Sck, SPI::Mi<PULL>, SPI::Mo>>,
+        pins: impl Into<MasterPins<SPI::Sck, SPI::Mi, SPI::Mo>>,
         mode: Mode,
         freq: Hertz,
         clocks: &Clocks,
@@ -521,12 +503,12 @@ impl<SPI: Instance, PULL> Spi<SPI, u8, PULL> {
     }
 
     #[allow(clippy::type_complexity)]
-    pub fn release(self) -> (SPI, (SPI::Sck, SPI::Mi<PULL>, SPI::Mo)) {
+    pub fn release(self) -> (SPI, (SPI::Sck, SPI::Mi, SPI::Mo)) {
         (self.inner.spi, self.pins)
     }
 }
 
-impl<SPI: Instance, Otype, PULL> SpiSlave<SPI, u8, Otype, PULL> {
+impl<SPI: Instance, Otype> SpiSlave<SPI, u8, Otype> {
     /**
       Constructs an SPI instance using SPI1 in 8bit dataframe mode.
 
@@ -536,7 +518,7 @@ impl<SPI: Instance, Otype, PULL> SpiSlave<SPI, u8, Otype, PULL> {
     */
     pub fn new(
         spi: SPI,
-        pins: impl Into<SlavePins<SPI::Sck, SPI::So<Otype>, SPI::Si<PULL>>>,
+        pins: impl Into<SlavePins<SPI::Sck, SPI::So<Otype>, SPI::Si>>,
         mode: Mode,
     ) -> Self {
         // enable or reset SPI
@@ -579,7 +561,7 @@ impl<SPI: Instance, Otype, PULL> SpiSlave<SPI, u8, Otype, PULL> {
     }
 
     #[allow(clippy::type_complexity)]
-    pub fn release(self) -> (SPI, (SPI::Sck, SPI::So<Otype>, SPI::Si<PULL>)) {
+    pub fn release(self) -> (SPI, (SPI::Sck, SPI::So<Otype>, SPI::Si)) {
         (self.inner.spi, self.pins)
     }
 }
@@ -686,9 +668,9 @@ impl<SPI: Instance, W: Copy> SpiInner<SPI, W> {
     }
 }
 
-impl<SPI: Instance, PULL> Spi<SPI, u8, PULL> {
+impl<SPI: Instance> Spi<SPI, u8> {
     /// Converts from 8bit dataframe to 16bit.
-    pub fn frame_size_16bit(self) -> Spi<SPI, u16, PULL> {
+    pub fn frame_size_16bit(self) -> Spi<SPI, u16> {
         self.spi.cr1().modify(|_, w| w.spe().clear_bit());
         self.spi.cr1().modify(|_, w| w.dff().set_bit());
         self.spi.cr1().modify(|_, w| w.spe().set_bit());
@@ -699,9 +681,9 @@ impl<SPI: Instance, PULL> Spi<SPI, u8, PULL> {
     }
 }
 
-impl<SPI: Instance, Otype, PULL> SpiSlave<SPI, u8, Otype, PULL> {
+impl<SPI: Instance, Otype> SpiSlave<SPI, u8, Otype> {
     /// Converts from 8bit dataframe to 16bit.
-    pub fn frame_size_16bit(self) -> SpiSlave<SPI, u16, Otype, PULL> {
+    pub fn frame_size_16bit(self) -> SpiSlave<SPI, u16, Otype> {
         self.spi.cr1().modify(|_, w| w.spe().clear_bit());
         self.spi.cr1().modify(|_, w| w.dff().set_bit());
         self.spi.cr1().modify(|_, w| w.spe().set_bit());
@@ -712,9 +694,9 @@ impl<SPI: Instance, Otype, PULL> SpiSlave<SPI, u8, Otype, PULL> {
     }
 }
 
-impl<SPI: Instance, PULL> Spi<SPI, u16, PULL> {
+impl<SPI: Instance> Spi<SPI, u16> {
     /// Converts from 16bit dataframe to 8bit.
-    pub fn frame_size_8bit(self) -> Spi<SPI, u16, PULL> {
+    pub fn frame_size_8bit(self) -> Spi<SPI, u16> {
         self.spi.cr1().modify(|_, w| w.spe().clear_bit());
         self.spi.cr1().modify(|_, w| w.dff().clear_bit());
         self.spi.cr1().modify(|_, w| w.spe().set_bit());
@@ -725,9 +707,9 @@ impl<SPI: Instance, PULL> Spi<SPI, u16, PULL> {
     }
 }
 
-impl<SPI: Instance, Otype, PULL> SpiSlave<SPI, u16, Otype, PULL> {
+impl<SPI: Instance, Otype> SpiSlave<SPI, u16, Otype> {
     /// Converts from 16bit dataframe to 8bit.
-    pub fn frame_size_8bit(self) -> SpiSlave<SPI, u8, Otype, PULL> {
+    pub fn frame_size_8bit(self) -> SpiSlave<SPI, u8, Otype> {
         self.spi.cr1().modify(|_, w| w.spe().clear_bit());
         self.spi.cr1().modify(|_, w| w.dff().clear_bit());
         self.spi.cr1().modify(|_, w| w.spe().set_bit());
@@ -783,17 +765,14 @@ where
 
 // DMA
 
-pub type SpiTxDma<SPI, CHANNEL, PULL = Floating> = TxDma<Spi<SPI, u8, PULL>, CHANNEL>;
-pub type SpiRxDma<SPI, CHANNEL, PULL = Floating> = RxDma<Spi<SPI, u8, PULL>, CHANNEL>;
-pub type SpiRxTxDma<SPI, RXCHANNEL, TXCHANNEL, PULL = Floating> =
-    RxTxDma<Spi<SPI, u8, PULL>, RXCHANNEL, TXCHANNEL>;
+pub type SpiTxDma<SPI, CHANNEL> = TxDma<Spi<SPI, u8>, CHANNEL>;
+pub type SpiRxDma<SPI, CHANNEL> = RxDma<Spi<SPI, u8>, CHANNEL>;
+pub type SpiRxTxDma<SPI, RXCHANNEL, TXCHANNEL> = RxTxDma<Spi<SPI, u8>, RXCHANNEL, TXCHANNEL>;
 
-pub type SpiSlaveTxDma<SPI, CHANNEL, Otype, PULL = Floating> =
-    TxDma<SpiSlave<SPI, u8, Otype, PULL>, CHANNEL>;
-pub type SpiSlaveRxDma<SPI, CHANNEL, Otype, PULL = Floating> =
-    RxDma<SpiSlave<SPI, u8, Otype, PULL>, CHANNEL>;
-pub type SpiSlaveRxTxDma<SPI, RXCHANNEL, TXCHANNEL, Otype, PULL = Floating> =
-    RxTxDma<SpiSlave<SPI, u8, Otype, PULL>, RXCHANNEL, TXCHANNEL>;
+pub type SpiSlaveTxDma<SPI, CHANNEL, Otype> = TxDma<SpiSlave<SPI, u8, Otype>, CHANNEL>;
+pub type SpiSlaveRxDma<SPI, CHANNEL, Otype> = RxDma<SpiSlave<SPI, u8, Otype>, CHANNEL>;
+pub type SpiSlaveRxTxDma<SPI, RXCHANNEL, TXCHANNEL, Otype> =
+    RxTxDma<SpiSlave<SPI, u8, Otype>, RXCHANNEL, TXCHANNEL>;
 
 macro_rules! spi_dma {
     (
@@ -807,39 +786,39 @@ macro_rules! spi_dma {
         $slavetxdma:ident,
         $slaverxtxdma:ident
     ) => {
-        pub type $rxdma<PULL = Floating> = SpiRxDma<$SPIi, $RCi, PULL>;
-        pub type $txdma<PULL = Floating> = SpiTxDma<$SPIi, $TCi, PULL>;
-        pub type $rxtxdma<PULL = Floating> = SpiRxTxDma<$SPIi, $RCi, $TCi, PULL>;
+        pub type $rxdma = SpiRxDma<$SPIi, $RCi>;
+        pub type $txdma = SpiTxDma<$SPIi, $TCi>;
+        pub type $rxtxdma = SpiRxTxDma<$SPIi, $RCi, $TCi>;
 
-        impl<PULL> Transmit for SpiTxDma<$SPIi, $TCi, PULL> {
+        impl Transmit for SpiTxDma<$SPIi, $TCi> {
             type TxChannel = $TCi;
             type ReceivedWord = u8;
         }
 
-        impl<PULL> Receive for SpiRxDma<$SPIi, $RCi, PULL> {
+        impl Receive for SpiRxDma<$SPIi, $RCi> {
             type RxChannel = $RCi;
             type TransmittedWord = u8;
         }
 
-        impl<PULL> Transmit for SpiRxTxDma<$SPIi, $RCi, $TCi, PULL> {
+        impl Transmit for SpiRxTxDma<$SPIi, $RCi, $TCi> {
             type TxChannel = $TCi;
             type ReceivedWord = u8;
         }
 
-        impl<PULL> Receive for SpiRxTxDma<$SPIi, $RCi, $TCi, PULL> {
+        impl Receive for SpiRxTxDma<$SPIi, $RCi, $TCi> {
             type RxChannel = $RCi;
             type TransmittedWord = u8;
         }
 
-        impl<PULL> Spi<$SPIi, u8, PULL> {
-            pub fn with_tx_dma(self, channel: $TCi) -> SpiTxDma<$SPIi, $TCi, PULL> {
+        impl Spi<$SPIi, u8> {
+            pub fn with_tx_dma(self, channel: $TCi) -> SpiTxDma<$SPIi, $TCi> {
                 self.spi.cr2().modify(|_, w| w.txdmaen().set_bit());
                 SpiTxDma {
                     payload: self,
                     channel,
                 }
             }
-            pub fn with_rx_dma(self, channel: $RCi) -> SpiRxDma<$SPIi, $RCi, PULL> {
+            pub fn with_rx_dma(self, channel: $RCi) -> SpiRxDma<$SPIi, $RCi> {
                 self.spi.cr2().modify(|_, w| w.rxdmaen().set_bit());
                 SpiRxDma {
                     payload: self,
@@ -850,7 +829,7 @@ macro_rules! spi_dma {
                 self,
                 rxchannel: $RCi,
                 txchannel: $TCi,
-            ) -> SpiRxTxDma<$SPIi, $RCi, $TCi, PULL> {
+            ) -> SpiRxTxDma<$SPIi, $RCi, $TCi> {
                 self.spi
                     .cr2()
                     .modify(|_, w| w.rxdmaen().set_bit().txdmaen().set_bit());
@@ -862,24 +841,24 @@ macro_rules! spi_dma {
             }
         }
 
-        impl<PULL> SpiTxDma<$SPIi, $TCi, PULL> {
-            pub fn release(self) -> (Spi<$SPIi, u8, PULL>, $TCi) {
+        impl SpiTxDma<$SPIi, $TCi> {
+            pub fn release(self) -> (Spi<$SPIi, u8>, $TCi) {
                 let SpiTxDma { payload, channel } = self;
                 payload.spi.cr2().modify(|_, w| w.txdmaen().clear_bit());
                 (payload, channel)
             }
         }
 
-        impl<PULL> SpiRxDma<$SPIi, $RCi, PULL> {
-            pub fn release(self) -> (Spi<$SPIi, u8, PULL>, $RCi) {
+        impl SpiRxDma<$SPIi, $RCi> {
+            pub fn release(self) -> (Spi<$SPIi, u8>, $RCi) {
                 let SpiRxDma { payload, channel } = self;
                 payload.spi.cr2().modify(|_, w| w.rxdmaen().clear_bit());
                 (payload, channel)
             }
         }
 
-        impl<PULL> SpiRxTxDma<$SPIi, $RCi, $TCi, PULL> {
-            pub fn release(self) -> (Spi<$SPIi, u8, PULL>, $RCi, $TCi) {
+        impl SpiRxTxDma<$SPIi, $RCi, $TCi> {
+            pub fn release(self) -> (Spi<$SPIi, u8>, $RCi, $TCi) {
                 let SpiRxTxDma {
                     payload,
                     rxchannel,
@@ -893,7 +872,7 @@ macro_rules! spi_dma {
             }
         }
 
-        impl<PULL> TransferPayload for SpiTxDma<$SPIi, $TCi, PULL> {
+        impl TransferPayload for SpiTxDma<$SPIi, $TCi> {
             fn start(&mut self) {
                 self.channel.start();
             }
@@ -902,7 +881,7 @@ macro_rules! spi_dma {
             }
         }
 
-        impl<PULL> TransferPayload for SpiRxDma<$SPIi, $RCi, PULL> {
+        impl TransferPayload for SpiRxDma<$SPIi, $RCi> {
             fn start(&mut self) {
                 self.channel.start();
             }
@@ -911,7 +890,7 @@ macro_rules! spi_dma {
             }
         }
 
-        impl<PULL> TransferPayload for SpiRxTxDma<$SPIi, $RCi, $TCi, PULL> {
+        impl TransferPayload for SpiRxTxDma<$SPIi, $RCi, $TCi> {
             fn start(&mut self) {
                 self.rxchannel.start();
                 self.txchannel.start();
@@ -922,7 +901,7 @@ macro_rules! spi_dma {
             }
         }
 
-        impl<B, PULL> crate::dma::ReadDma<B, u8> for SpiRxDma<$SPIi, $RCi, PULL>
+        impl<B> crate::dma::ReadDma<B, u8> for SpiRxDma<$SPIi, $RCi>
         where
             B: WriteBuffer<Word = u8>,
         {
@@ -958,7 +937,7 @@ macro_rules! spi_dma {
             }
         }
 
-        impl<B, PULL> crate::dma::WriteDma<B, u8> for SpiTxDma<$SPIi, $TCi, PULL>
+        impl<B> crate::dma::WriteDma<B, u8> for SpiTxDma<$SPIi, $TCi>
         where
             B: ReadBuffer<Word = u8>,
         {
@@ -994,8 +973,7 @@ macro_rules! spi_dma {
             }
         }
 
-        impl<RXB, TXB, PULL> crate::dma::ReadWriteDma<RXB, TXB, u8>
-            for SpiRxTxDma<$SPIi, $RCi, $TCi, PULL>
+        impl<RXB, TXB> crate::dma::ReadWriteDma<RXB, TXB, u8> for SpiRxTxDma<$SPIi, $RCi, $TCi>
         where
             RXB: WriteBuffer<Word = u8>,
             TXB: ReadBuffer<Word = u8>,
@@ -1063,42 +1041,39 @@ macro_rules! spi_dma {
             }
         }
 
-        pub type $slaverxdma<Otype = PushPull, PULL = Floating> =
-            SpiSlaveRxDma<$SPIi, $RCi, Otype, PULL>;
-        pub type $slavetxdma<Otype = PushPull, PULL = Floating> =
-            SpiSlaveTxDma<$SPIi, $TCi, Otype, PULL>;
-        pub type $slaverxtxdma<Otype = PushPull, PULL = Floating> =
-            SpiSlaveRxTxDma<$SPIi, $RCi, $TCi, Otype, PULL>;
+        pub type $slaverxdma<Otype = PushPull> = SpiSlaveRxDma<$SPIi, $RCi, Otype>;
+        pub type $slavetxdma<Otype = PushPull> = SpiSlaveTxDma<$SPIi, $TCi, Otype>;
+        pub type $slaverxtxdma<Otype = PushPull> = SpiSlaveRxTxDma<$SPIi, $RCi, $TCi, Otype>;
 
-        impl<Otype, PULL> Transmit for SpiSlaveTxDma<$SPIi, $TCi, Otype, PULL> {
+        impl<Otype> Transmit for SpiSlaveTxDma<$SPIi, $TCi, Otype> {
             type TxChannel = $TCi;
             type ReceivedWord = u8;
         }
 
-        impl<Otype, PULL> Receive for SpiSlaveRxDma<$SPIi, $RCi, Otype, PULL> {
+        impl<Otype> Receive for SpiSlaveRxDma<$SPIi, $RCi, Otype> {
             type RxChannel = $RCi;
             type TransmittedWord = u8;
         }
 
-        impl<Otype, PULL> Transmit for SpiSlaveRxTxDma<$SPIi, $RCi, $TCi, Otype, PULL> {
+        impl<Otype> Transmit for SpiSlaveRxTxDma<$SPIi, $RCi, $TCi, Otype> {
             type TxChannel = $TCi;
             type ReceivedWord = u8;
         }
 
-        impl<Otype, PULL> Receive for SpiSlaveRxTxDma<$SPIi, $RCi, $TCi, Otype, PULL> {
+        impl<Otype> Receive for SpiSlaveRxTxDma<$SPIi, $RCi, $TCi, Otype> {
             type RxChannel = $RCi;
             type TransmittedWord = u8;
         }
 
-        impl<Otype, PULL> SpiSlave<$SPIi, u8, Otype, PULL> {
-            pub fn with_tx_dma(self, channel: $TCi) -> SpiSlaveTxDma<$SPIi, $TCi, Otype, PULL> {
+        impl<Otype> SpiSlave<$SPIi, u8, Otype> {
+            pub fn with_tx_dma(self, channel: $TCi) -> SpiSlaveTxDma<$SPIi, $TCi, Otype> {
                 self.spi.cr2().modify(|_, w| w.txdmaen().set_bit());
                 SpiSlaveTxDma {
                     payload: self,
                     channel,
                 }
             }
-            pub fn with_rx_dma(self, channel: $RCi) -> SpiSlaveRxDma<$SPIi, $RCi, Otype, PULL> {
+            pub fn with_rx_dma(self, channel: $RCi) -> SpiSlaveRxDma<$SPIi, $RCi, Otype> {
                 self.spi.cr2().modify(|_, w| w.rxdmaen().set_bit());
                 SpiSlaveRxDma {
                     payload: self,
@@ -1109,7 +1084,7 @@ macro_rules! spi_dma {
                 self,
                 rxchannel: $RCi,
                 txchannel: $TCi,
-            ) -> SpiSlaveRxTxDma<$SPIi, $RCi, $TCi, Otype, PULL> {
+            ) -> SpiSlaveRxTxDma<$SPIi, $RCi, $TCi, Otype> {
                 self.spi
                     .cr2()
                     .modify(|_, w| w.rxdmaen().set_bit().txdmaen().set_bit());
@@ -1121,24 +1096,24 @@ macro_rules! spi_dma {
             }
         }
 
-        impl<Otype, PULL> SpiSlaveTxDma<$SPIi, $TCi, Otype, PULL> {
-            pub fn release(self) -> (SpiSlave<$SPIi, u8, Otype, PULL>, $TCi) {
+        impl<Otype> SpiSlaveTxDma<$SPIi, $TCi, Otype> {
+            pub fn release(self) -> (SpiSlave<$SPIi, u8, Otype>, $TCi) {
                 let SpiSlaveTxDma { payload, channel } = self;
                 payload.spi.cr2().modify(|_, w| w.txdmaen().clear_bit());
                 (payload, channel)
             }
         }
 
-        impl<Otype, PULL> SpiSlaveRxDma<$SPIi, $RCi, Otype, PULL> {
-            pub fn release(self) -> (SpiSlave<$SPIi, u8, Otype, PULL>, $RCi) {
+        impl<Otype> SpiSlaveRxDma<$SPIi, $RCi, Otype> {
+            pub fn release(self) -> (SpiSlave<$SPIi, u8, Otype>, $RCi) {
                 let SpiSlaveRxDma { payload, channel } = self;
                 payload.spi.cr2().modify(|_, w| w.rxdmaen().clear_bit());
                 (payload, channel)
             }
         }
 
-        impl<Otype, PULL> SpiSlaveRxTxDma<$SPIi, $RCi, $TCi, Otype, PULL> {
-            pub fn release(self) -> (SpiSlave<$SPIi, u8, Otype, PULL>, $RCi, $TCi) {
+        impl<Otype> SpiSlaveRxTxDma<$SPIi, $RCi, $TCi, Otype> {
+            pub fn release(self) -> (SpiSlave<$SPIi, u8, Otype>, $RCi, $TCi) {
                 let SpiSlaveRxTxDma {
                     payload,
                     rxchannel,
@@ -1152,7 +1127,7 @@ macro_rules! spi_dma {
             }
         }
 
-        impl<Otype, PULL> TransferPayload for SpiSlaveTxDma<$SPIi, $TCi, Otype, PULL> {
+        impl<Otype> TransferPayload for SpiSlaveTxDma<$SPIi, $TCi, Otype> {
             fn start(&mut self) {
                 self.channel.start();
             }
@@ -1161,7 +1136,7 @@ macro_rules! spi_dma {
             }
         }
 
-        impl<Otype, PULL> TransferPayload for SpiSlaveRxDma<$SPIi, $RCi, Otype, PULL> {
+        impl<Otype> TransferPayload for SpiSlaveRxDma<$SPIi, $RCi, Otype> {
             fn start(&mut self) {
                 self.channel.start();
             }
@@ -1170,7 +1145,7 @@ macro_rules! spi_dma {
             }
         }
 
-        impl<Otype, PULL> TransferPayload for SpiSlaveRxTxDma<$SPIi, $RCi, $TCi, Otype, PULL> {
+        impl<Otype> TransferPayload for SpiSlaveRxTxDma<$SPIi, $RCi, $TCi, Otype> {
             fn start(&mut self) {
                 self.rxchannel.start();
                 self.txchannel.start();
@@ -1181,7 +1156,7 @@ macro_rules! spi_dma {
             }
         }
 
-        impl<B, Otype, PULL> crate::dma::ReadDma<B, u8> for SpiSlaveRxDma<$SPIi, $RCi, Otype, PULL>
+        impl<B, Otype> crate::dma::ReadDma<B, u8> for SpiSlaveRxDma<$SPIi, $RCi, Otype>
         where
             B: WriteBuffer<Word = u8>,
         {
@@ -1217,7 +1192,7 @@ macro_rules! spi_dma {
             }
         }
 
-        impl<B, Otype, PULL> crate::dma::WriteDma<B, u8> for SpiSlaveTxDma<$SPIi, $TCi, Otype, PULL>
+        impl<B, Otype> crate::dma::WriteDma<B, u8> for SpiSlaveTxDma<$SPIi, $TCi, Otype>
         where
             B: ReadBuffer<Word = u8>,
         {
@@ -1253,8 +1228,8 @@ macro_rules! spi_dma {
             }
         }
 
-        impl<RXB, TXB, Otype, PULL> crate::dma::ReadWriteDma<RXB, TXB, u8>
-            for SpiSlaveRxTxDma<$SPIi, $RCi, $TCi, Otype, PULL>
+        impl<RXB, TXB, Otype> crate::dma::ReadWriteDma<RXB, TXB, u8>
+            for SpiSlaveRxTxDma<$SPIi, $RCi, $TCi, Otype>
         where
             RXB: WriteBuffer<Word = u8>,
             TXB: ReadBuffer<Word = u8>,
diff --git a/src/spi/hal_02.rs b/src/spi/hal_02.rs
index 2e410153..bb346efc 100644
--- a/src/spi/hal_02.rs
+++ b/src/spi/hal_02.rs
@@ -30,7 +30,7 @@ impl From<Mode> for super::Mode {
     }
 }
 
-impl<SPI, W, PULL> spi::FullDuplex<W> for Spi<SPI, W, PULL>
+impl<SPI, W> spi::FullDuplex<W> for Spi<SPI, W>
 where
     SPI: Instance,
     W: Copy,
@@ -46,14 +46,14 @@ where
     }
 }
 
-impl<SPI, W, PULL> blocking::transfer::Default<W> for Spi<SPI, W, PULL>
+impl<SPI, W> blocking::transfer::Default<W> for Spi<SPI, W>
 where
     SPI: Instance,
     W: Copy,
 {
 }
 
-impl<SPI: Instance, PULL> blocking::Write<u8> for Spi<SPI, u8, PULL> {
+impl<SPI: Instance> blocking::Write<u8> for Spi<SPI, u8> {
     type Error = Error;
 
     fn write(&mut self, words: &[u8]) -> Result<(), Error> {
@@ -61,7 +61,7 @@ impl<SPI: Instance, PULL> blocking::Write<u8> for Spi<SPI, u8, PULL> {
     }
 }
 
-impl<SPI: Instance, PULL> blocking::Write<u16> for Spi<SPI, u16, PULL> {
+impl<SPI: Instance> blocking::Write<u16> for Spi<SPI, u16> {
     type Error = Error;
 
     fn write(&mut self, words: &[u16]) -> Result<(), Error> {
diff --git a/src/spi/hal_1.rs b/src/spi/hal_1.rs
index f038ac72..633fde11 100644
--- a/src/spi/hal_1.rs
+++ b/src/spi/hal_1.rs
@@ -38,7 +38,7 @@ impl embedded_hal::spi::Error for Error {
     }
 }
 
-impl<SPI: Instance, W, PULL> ErrorType for Spi<SPI, W, PULL> {
+impl<SPI: Instance, W> ErrorType for Spi<SPI, W> {
     type Error = Error;
 }
 
@@ -46,7 +46,7 @@ mod nb {
     use super::{Error, Instance, Spi};
     use embedded_hal_nb::spi::FullDuplex;
 
-    impl<SPI, W, PULL> FullDuplex<W> for Spi<SPI, W, PULL>
+    impl<SPI, W> FullDuplex<W> for Spi<SPI, W>
     where
         SPI: Instance,
         W: Copy,
@@ -66,7 +66,7 @@ mod blocking {
     use core::ops::DerefMut;
     use embedded_hal::spi::SpiBus;
 
-    impl<SPI: Instance, W, PULL> SpiBus<W> for Spi<SPI, W, PULL>
+    impl<SPI: Instance, W> SpiBus<W> for Spi<SPI, W>
     where
         SPI: Instance,
         W: Copy + 'static,
diff --git a/src/timer/pwm_input.rs b/src/timer/pwm_input.rs
index 78bb7c42..fef296b8 100644
--- a/src/timer/pwm_input.rs
+++ b/src/timer/pwm_input.rs
@@ -16,11 +16,11 @@ pub trait Pins<REMAP> {}
 
 use super::pins::{sealed::Remap, CPin};
 
-impl<TIM, REMAP, P1, P2, MODE1, MODE2> Pins<REMAP> for (P1, P2)
+impl<TIM, REMAP, P1, P2> Pins<REMAP> for (P1, P2)
 where
     REMAP: Remap<Periph = TIM>,
-    P1: CPin<REMAP, 0> + gpio::PinExt<Mode = Input<MODE1>>,
-    P2: CPin<REMAP, 1> + gpio::PinExt<Mode = Input<MODE2>>,
+    P1: CPin<REMAP, 0> + gpio::PinExt<Mode = Input>,
+    P2: CPin<REMAP, 1> + gpio::PinExt<Mode = Input>,
 {
 }
 
diff --git a/src/usb.rs b/src/usb.rs
index f86d408a..d0a6d6c4 100644
--- a/src/usb.rs
+++ b/src/usb.rs
@@ -9,13 +9,13 @@ use crate::rcc::{Enable, Reset};
 use stm32_usbd::UsbPeripheral;
 
 use crate::gpio::gpioa::{PA11, PA12};
-use crate::gpio::{Floating, Input};
+use crate::gpio::Input;
 pub use stm32_usbd::UsbBus;
 
 pub struct Peripheral {
     pub usb: USB,
-    pub pin_dm: PA11<Input<Floating>>,
-    pub pin_dp: PA12<Input<Floating>>,
+    pub pin_dm: PA11<Input>,
+    pub pin_dp: PA12<Input>,
 }
 
 unsafe impl Sync for Peripheral {}