From df14c887d66bcd4218530ebd05b7961544a2ecd5 Mon Sep 17 00:00:00 2001
From: Andrey Zgarbul <zgarbul.andrey@gmail.com>
Date: Sun, 6 Oct 2024 13:29:33 +0300
Subject: [PATCH] Serial/SPI/I2C/CAN remap

---
 CHANGELOG.md              |   5 +-
 examples/serial_config.rs |  18 +---
 examples/spi-slave.rs     |   4 +-
 src/can.rs                |  91 +++++++++++--------
 src/gpio.rs               |   8 ++
 src/i2c.rs                |  79 ++++++++++++-----
 src/i2c/blocking.rs       |   2 +-
 src/serial.rs             | 141 ++++++++++++++++++++---------
 src/spi.rs                | 180 +++++++++++++++++++++++---------------
 9 files changed, 339 insertions(+), 189 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 54e771c9..411cdfb2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,7 +11,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 - Relax pin type generics for `Serial`, `I2c`, `Spi`, `Can`. [#462]
   Use enums of pin tuples and `Enum::from<(tuple)>` for pin remap before passing to peripheral.
-  Remove `RemapStruct`s. [#462] [#506]
+  Remove `RemapStruct`s. [#462] [#506] [#509]
 - Use independent `Spi` and `SpiSlave` structures instead of `OP` generic [#462]
 - Take `&Clocks` instead of `Clocks` [#498]
 - Temporary replace `stm32f1` with `stm32f1-staging` [#503]
@@ -26,6 +26,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Check "device selected" in `build.rs` [#502]
 - Use gpio field enums internally [#506]
 - Unmacro `dma.rs` [#505]
+- Rework USART remap, 
 
 ### Added
 
@@ -37,6 +38,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Add DAC [#483]
 - Add an option to allow overclocking [#494]
 - `new` on gpio mode [#506]
+- Add `Serial` `rx`/`tx` constructors [#509]
 
 [#416]: https://github.com/stm32-rs/stm32f1xx-hal/pull/416
 [#453]: https://github.com/stm32-rs/stm32f1xx-hal/pull/453
@@ -54,6 +56,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 [#503]: https://github.com/stm32-rs/stm32f1xx-hal/pull/503
 [#505]: https://github.com/stm32-rs/stm32f1xx-hal/pull/505
 [#506]: https://github.com/stm32-rs/stm32f1xx-hal/pull/506
+[#509]: https://github.com/stm32-rs/stm32f1xx-hal/pull/509
 
 ## [v0.10.0] - 2022-12-12
 
diff --git a/examples/serial_config.rs b/examples/serial_config.rs
index 59f01e4b..6f585c8f 100644
--- a/examples/serial_config.rs
+++ b/examples/serial_config.rs
@@ -1,6 +1,4 @@
-//! Serial interface loopback test
-//!
-//! You have to short the TX and RX pins to make this program work
+//! Serial Config test
 
 #![deny(unsafe_code)]
 #![allow(clippy::empty_loop)]
@@ -40,27 +38,22 @@ fn main() -> ! {
 
     // USART1
     // let tx = gpioa.pa9.into_alternate_push_pull(&mut gpioa.crh);
-    // let rx = gpioa.pa10;
 
     // USART1
     // let tx = gpiob.pb6.into_alternate_push_pull(&mut gpiob.crl);
-    // let rx = gpiob.pb7;
 
     // USART2
     // let tx = gpioa.pa2.into_alternate_push_pull(&mut gpioa.crl);
-    // let rx = gpioa.pa3;
 
     // USART3
     // Configure pb10 as a push_pull output, this will be the tx pin
     let tx = gpiob.pb10.into_alternate_push_pull(&mut gpiob.crh);
-    // Take ownership over pb11
-    let rx = gpiob.pb11;
 
-    // Set up the usart device. Take ownership over the USART register and tx/rx pins. The rest of
+    // Set up the usart device. Take ownership over the USART register and tx pin. The rest of
     // the registers are used to enable and configure the device.
-    let serial = Serial::new(
+    let mut tx = Serial::tx(
         p.USART3,
-        (tx, rx, &mut afio.mapr),
+        (tx, &mut afio.mapr),
         serial::Config::default()
             .baudrate(9600.bps())
             .stopbits(serial::StopBits::STOP2)
@@ -69,9 +62,6 @@ fn main() -> ! {
         &clocks,
     );
 
-    // Split the serial struct into a receiving and a transmitting part
-    let (mut tx, _rx) = serial.split();
-
     let sent = b'U';
     block!(tx.write_u8(sent)).unwrap();
     block!(tx.write_u8(sent)).unwrap();
diff --git a/examples/spi-slave.rs b/examples/spi-slave.rs
index 0f7ae712..313ddd9a 100644
--- a/examples/spi-slave.rs
+++ b/examples/spi-slave.rs
@@ -38,7 +38,7 @@ fn main() -> ! {
 
     let mut afio = dp.AFIO.constrain();
     let gpioa = dp.GPIOA.split();
-    let mut gpiob = dp.GPIOB.split();
+    let gpiob = dp.GPIOB.split();
 
     // SPI1
     // Convert pins during SPI initialization
@@ -53,7 +53,7 @@ fn main() -> ! {
     // SPI2
     // Convert pins before SPI initialization
     let sck = gpiob.pb13;
-    let miso = gpiob.pb14.into_alternate_push_pull(&mut gpiob.crh);
+    let miso = gpiob.pb14;
     let mosi = gpiob.pb15;
 
     let spi2 = dp.SPI2.spi_slave((sck, miso, mosi), MODE);
diff --git a/src/can.rs b/src/can.rs
index 5ad0c3bc..cf619424 100644
--- a/src/can.rs
+++ b/src/can.rs
@@ -20,27 +20,39 @@
 //! | RX       | PB5     | PB12  |
 
 use crate::afio::MAPR;
-use crate::gpio::{self, Alternate, Cr, Floating, Input, PinMode, PullUp};
+use crate::gpio::{self, Alternate, Cr, Floating, Input, NoPin, PinMode, PullUp, 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,
+}
+
+impl<TX, RX> From<(TX, RX)> for Pins<TX, RX> {
+    fn from(value: (TX, RX)) -> Self {
+        Self {
+            tx: value.0,
+            rx: value.1,
+        }
+    }
+}
+
 pub mod can1 {
     use super::*;
 
     remap! {
-        Pins: [
-            #[cfg(not(feature = "connectivity"))]
-            All, Tx, Rx, PA12, PA11  => { |_, w| unsafe { w.can_remap().bits(0) } };
-            #[cfg(feature = "connectivity")]
-            All, Tx, Rx, PA12, PA11  => { |_, w| unsafe { w.can1_remap().bits(0) } };
-            #[cfg(not(feature = "connectivity"))]
-            Remap, RemapTx, RemapRx, PB9, PB8  => { |_, w| unsafe { w.can_remap().bits(10) } };
-            #[cfg(feature = "connectivity")]
-            Remap, RemapTx, RemapRx, PB9, PB8  => { |_, w| unsafe { w.can1_remap().bits(10) } };
-        ]
+        #[cfg(not(feature = "connectivity"))]
+        PA12, PA11  => { |_, w| unsafe { w.can_remap().bits(0) } };
+        #[cfg(feature = "connectivity")]
+        PA12, PA11  => { |_, w| unsafe { w.can1_remap().bits(0) } };
+        #[cfg(not(feature = "connectivity"))]
+        PB9, PB8  => { |_, w| unsafe { w.can_remap().bits(10) } };
+        #[cfg(feature = "connectivity")]
+        PB9, PB8  => { |_, w| unsafe { w.can1_remap().bits(10) } };
     }
 }
 
@@ -49,39 +61,39 @@ pub mod can2 {
     use super::*;
 
     remap! {
-        Pins: [
-            All, Tx, Rx, PB6, PB5  => { |_, w| w.can2_remap().bit(false) };
-            Remap, RemapTx, RemapRx, PB13, PB12  => { |_, w| w.can2_remap().bit(true) };
-        ]
+        PB6, PB5  => { |_, w| w.can2_remap().bit(false) };
+        PB13, PB12  => { |_, w| w.can2_remap().bit(true) };
     }
 }
 
 macro_rules! remap {
-    ($name:ident: [
-        $($(#[$attr:meta])* $rname:ident, $txonly:ident, $rxonly:ident, $TX:ident, $RX:ident => { $remapex:expr };)+
-    ]) => {
-        pub enum $name<PULL> {
+    ($($(#[$attr:meta])* $TX:ident, $RX:ident => { $remapex:expr };)+) => {
+        pub enum Tx {
             $(
                 $(#[$attr])*
-                $rname { tx: gpio::$TX<Alternate>, rx: gpio::$RX<Input<PULL>> },
-                $(#[$attr])*
-                $txonly { tx: gpio::$TX<Alternate> },
+                $TX(gpio::$TX<Alternate>),
+            )+
+            None(NoPin<PushPull>),
+        }
+        pub enum Rx<PULL> {
+            $(
                 $(#[$attr])*
-                $rxonly { rx: gpio::$RX<Input<PULL>> },
+                $RX(gpio::$RX<Input<PULL>>),
             )+
+            None(NoPin<PULL>),
         }
 
         $(
             $(#[$attr])*
-            impl<PULL: InMode> From<(gpio::$TX<Alternate>, gpio::$RX<Input<PULL>>, &mut MAPR)> for $name<PULL> {
+            impl<PULL: InMode> From<(gpio::$TX<Alternate>, gpio::$RX<Input<PULL>>, &mut MAPR)> for Pins<Tx, Rx<PULL>> {
                 fn from(p: (gpio::$TX<Alternate>, gpio::$RX<Input<PULL>>, &mut MAPR)) -> Self {
                     p.2.modify_mapr($remapex);
-                    Self::$rname { tx: p.0, rx: p.1 }
+                    Self { tx: Tx::$TX(p.0), rx: Rx::$RX(p.1) }
                 }
             }
 
             $(#[$attr])*
-            impl<PULL> From<(gpio::$TX, gpio::$RX, &mut MAPR)> for $name<PULL>
+            impl<PULL> From<(gpio::$TX, gpio::$RX, &mut MAPR)> for Pins<Tx, Rx<PULL>>
             where
                 Input<PULL>: PinMode,
                 PULL: InMode,
@@ -91,21 +103,21 @@ macro_rules! remap {
                     let tx = p.0.into_mode(&mut cr);
                     let rx = p.1.into_mode(&mut cr);
                     p.2.modify_mapr($remapex);
-                    Self::$rname { tx, rx }
+                    Self { tx: Tx::$TX(tx), rx: Rx::$RX(rx) }
                 }
             }
 
             $(#[$attr])*
-            impl From<(gpio::$TX, &mut MAPR)> for $name<Floating> {
+            impl From<(gpio::$TX, &mut MAPR)> for Pins<Tx, Rx<Floating>> {
                 fn from(p: (gpio::$TX, &mut MAPR)) -> Self {
                     let tx = p.0.into_mode(&mut Cr);
                     p.1.modify_mapr($remapex);
-                    Self::$txonly { tx }
+                    Self { tx: Tx::$TX(tx), rx: Rx::None(NoPin::new()) }
                 }
             }
 
             $(#[$attr])*
-            impl<PULL> From<(gpio::$RX, &mut MAPR)> for $name<PULL>
+            impl<PULL> From<(gpio::$RX, &mut MAPR)> for Pins<Tx, Rx<PULL>>
             where
                 Input<PULL>: PinMode,
                 PULL: InMode,
@@ -113,7 +125,7 @@ macro_rules! remap {
                 fn from(p: (gpio::$RX, &mut MAPR)) -> Self {
                     let rx = p.0.into_mode(&mut Cr);
                     p.1.modify_mapr($remapex);
-                    Self::$rxonly { rx }
+                    Self { tx: Tx::None(NoPin::new()), rx: Rx::$RX(rx) }
                 }
             }
         )+
@@ -125,7 +137,7 @@ pub trait CanExt: Sized + Instance {
     fn can(
         self,
         #[cfg(not(feature = "connectivity"))] usb: pac::USB,
-        pins: impl Into<Self::Pins<Floating>>,
+        pins: impl Into<Pins<Self::Tx, Self::Rx<Floating>>>,
     ) -> Can<Self, Floating>;
     fn can_loopback(
         self,
@@ -137,7 +149,7 @@ impl<CAN: Instance> CanExt for CAN {
     fn can(
         self,
         #[cfg(not(feature = "connectivity"))] usb: pac::USB,
-        pins: impl Into<Self::Pins<Floating>>,
+        pins: impl Into<Pins<Self::Tx, Self::Rx<Floating>>>,
     ) -> Can<Self, Floating> {
         Can::new(
             self,
@@ -159,21 +171,24 @@ impl<CAN: Instance> CanExt for CAN {
 }
 
 pub trait Instance: crate::rcc::Enable {
-    type Pins<PULL>;
+    type Tx;
+    type Rx<PULL>;
 }
 impl Instance for pac::CAN1 {
-    type Pins<PULL> = can1::Pins<PULL>;
+    type Tx = can1::Tx;
+    type Rx<PULL> = can1::Rx<PULL>;
 }
 #[cfg(feature = "connectivity")]
 impl Instance for pac::CAN2 {
-    type Pins<PULL> = can2::Pins<PULL>;
+    type Tx = can2::Tx;
+    type Rx<PULL> = can2::Rx<PULL>;
 }
 
 /// Interface to the CAN peripheral.
 #[allow(unused)]
 pub struct Can<CAN: Instance, PULL = Floating> {
     can: CAN,
-    pins: Option<CAN::Pins<PULL>>,
+    pins: Option<Pins<CAN::Tx, CAN::Rx<PULL>>>,
 }
 
 impl<CAN: Instance, PULL> Can<CAN, PULL> {
@@ -184,7 +199,7 @@ impl<CAN: Instance, PULL> Can<CAN, PULL> {
     pub fn new(
         can: CAN,
         #[cfg(not(feature = "connectivity"))] _usb: pac::USB,
-        pins: impl Into<CAN::Pins<PULL>>,
+        pins: impl Into<Pins<CAN::Tx, CAN::Rx<PULL>>>,
     ) -> Can<CAN, PULL> {
         let rcc = unsafe { &(*RCC::ptr()) };
         CAN::enable(rcc);
diff --git a/src/gpio.rs b/src/gpio.rs
index 05be3321..bd1b62af 100644
--- a/src/gpio.rs
+++ b/src/gpio.rs
@@ -143,6 +143,14 @@ pub trait GpioExt {
     unsafe fn split_without_reset(self) -> Self::Parts;
 }
 
+#[derive(Debug, Default)]
+pub struct NoPin<MODE>(PhantomData<MODE>);
+impl<MODE> NoPin<MODE> {
+    pub fn new() -> Self {
+        Self(PhantomData)
+    }
+}
+
 /// Marker trait for active states.
 pub trait Active {}
 
diff --git a/src/i2c.rs b/src/i2c.rs
index b3cb8b22..4480241a 100644
--- a/src/i2c.rs
+++ b/src/i2c.rs
@@ -85,15 +85,29 @@ impl From<Hertz> for Mode {
     }
 }
 
+pub struct Pins<SCL, SDA> {
+    pub scl: SCL,
+    pub sda: SDA,
+}
+
+impl<SCL, SDA> From<(SCL, SDA)> for Pins<SCL, SDA> {
+    fn from(value: (SCL, SDA)) -> Self {
+        Self {
+            scl: value.0,
+            sda: value.1,
+        }
+    }
+}
+
 pub mod i2c1 {
     use crate::afio::MAPR;
 
     use super::*;
 
     remap! {
-        Pins: [
-            No, PB6, PB7 => MAPR { |_, w| w.i2c1_remap().bit(false) };
-            Remap, PB8, PB9 => MAPR { |_, w| w.i2c1_remap().bit(true) };
+        [
+            PB6, PB7 => MAPR { |_, w| w.i2c1_remap().bit(false) };
+            PB8, PB9 => MAPR { |_, w| w.i2c1_remap().bit(true) };
         ]
     }
 }
@@ -101,37 +115,42 @@ pub mod i2c2 {
     use super::*;
 
     remap! {
-        Pins: [
-            No, PB10, PB11;
+        [
+            PB10, PB11;
         ]
     }
 }
 
 macro_rules! remap {
-    ($name:ident: [
-        $($rname:ident, $SCL:ident, $SDA:ident $( => $MAPR:ident { $remapex:expr })?;)+
+    ([
+        $($SCL:ident, $SDA:ident $( => $MAPR:ident { $remapex:expr })?;)+
     ]) => {
-        pub enum $name {
+        pub enum Scl {
             $(
-                $rname { scl: gpio::$SCL<Alternate<OpenDrain>>, sda: gpio::$SDA<Alternate<OpenDrain>> },
+                $SCL(gpio::$SCL<Alternate<OpenDrain>>),
+            )+
+        }
+        pub enum Sda {
+            $(
+                $SDA(gpio::$SDA<Alternate<OpenDrain>>),
             )+
         }
 
         $(
-            impl From<(gpio::$SCL<Alternate<OpenDrain>>, gpio::$SDA<Alternate<OpenDrain>> $(, &mut $MAPR)?)> for $name {
+            impl From<(gpio::$SCL<Alternate<OpenDrain>>, gpio::$SDA<Alternate<OpenDrain>> $(, &mut $MAPR)?)> for Pins<Scl, Sda> {
                 fn from(p: (gpio::$SCL<Alternate<OpenDrain>>, gpio::$SDA<Alternate<OpenDrain>> $(, &mut $MAPR)?)) -> Self {
                     $(p.2.modify_mapr($remapex);)?
-                    Self::$rname { scl: p.0, sda: p.1 }
+                    Self { scl: Scl::$SCL(p.0), sda: Sda::$SDA(p.1) }
                 }
             }
 
-            impl From<(gpio::$SCL, gpio::$SDA $(, &mut $MAPR)?)> for $name {
+            impl From<(gpio::$SCL, gpio::$SDA $(, &mut $MAPR)?)> for Pins<Scl, Sda> {
                 fn from(p: (gpio::$SCL, gpio::$SDA $(, &mut $MAPR)?)) -> Self {
                     let mut cr = Cr;
                     let scl = p.0.into_mode(&mut cr);
                     let sda = p.1.into_mode(&mut cr);
                     $(p.2.modify_mapr($remapex);)?
-                    Self::$rname { scl, sda }
+                    Self { scl: Scl::$SCL(scl), sda: Sda::$SDA(sda) }
                 }
             }
         )+
@@ -140,12 +159,17 @@ macro_rules! remap {
 use remap;
 
 pub trait I2cExt: Sized + Instance {
-    fn i2c(self, pins: impl Into<Self::Pins>, mode: impl Into<Mode>, clocks: &Clocks) -> I2c<Self>;
+    fn i2c(
+        self,
+        pins: impl Into<Pins<Self::Scl, Self::Sda>>,
+        mode: impl Into<Mode>,
+        clocks: &Clocks,
+    ) -> I2c<Self>;
 
     #[allow(clippy::too_many_arguments)]
     fn blocking_i2c(
         self,
-        pins: impl Into<Self::Pins>,
+        pins: impl Into<Pins<Self::Scl, Self::Sda>>,
         mode: impl Into<Mode>,
         clocks: &Clocks,
         start_timeout_us: u32,
@@ -164,7 +188,12 @@ pub trait I2cExt: Sized + Instance {
 }
 
 impl<I2C: Instance> I2cExt for I2C {
-    fn i2c(self, pins: impl Into<Self::Pins>, mode: impl Into<Mode>, clocks: &Clocks) -> I2c<Self> {
+    fn i2c(
+        self,
+        pins: impl Into<Pins<Self::Scl, Self::Sda>>,
+        mode: impl Into<Mode>,
+        clocks: &Clocks,
+    ) -> I2c<Self> {
         I2c::new(self, pins, mode, clocks)
     }
 }
@@ -172,7 +201,7 @@ impl<I2C: Instance> I2cExt for I2C {
 /// I2C peripheral operating in master mode
 pub struct I2c<I2C: Instance> {
     i2c: I2C,
-    pins: I2C::Pins,
+    pins: (I2C::Scl, I2C::Sda),
     mode: Mode,
     pclk1: Hertz,
 }
@@ -180,21 +209,24 @@ pub struct I2c<I2C: Instance> {
 pub trait Instance:
     crate::Sealed + Deref<Target = crate::pac::i2c1::RegisterBlock> + Enable + Reset + BusClock
 {
-    type Pins;
+    type Scl;
+    type Sda;
 }
 
 impl Instance for I2C1 {
-    type Pins = i2c1::Pins;
+    type Scl = i2c1::Scl;
+    type Sda = i2c1::Sda;
 }
 impl Instance for I2C2 {
-    type Pins = i2c2::Pins;
+    type Scl = i2c2::Scl;
+    type Sda = i2c2::Sda;
 }
 
 impl<I2C: Instance> I2c<I2C> {
     /// Creates a generic I2C object
     pub fn new(
         i2c: I2C,
-        pins: impl Into<I2C::Pins>,
+        pins: impl Into<Pins<I2C::Scl, I2C::Sda>>,
         mode: impl Into<Mode>,
         clocks: &Clocks,
     ) -> Self {
@@ -206,10 +238,11 @@ impl<I2C: Instance> I2c<I2C> {
         let pclk1 = I2C::clock(clocks);
 
         assert!(mode.get_frequency() <= kHz(400));
+        let pins = pins.into();
 
         let mut i2c = I2c {
             i2c,
-            pins: pins.into(),
+            pins: (pins.scl, pins.sda),
             mode,
             pclk1,
         };
@@ -284,7 +317,7 @@ impl<I2C: Instance> I2c<I2C> {
     }
 
     /// Releases the I2C peripheral and associated pins
-    pub fn release(self) -> (I2C, I2C::Pins) {
+    pub fn release(self) -> (I2C, (I2C::Scl, I2C::Sda)) {
         (self.i2c, self.pins)
     }
 }
diff --git a/src/i2c/blocking.rs b/src/i2c/blocking.rs
index 315adec1..58cda400 100644
--- a/src/i2c/blocking.rs
+++ b/src/i2c/blocking.rs
@@ -22,7 +22,7 @@ impl<I2C: Instance> BlockingI2c<I2C> {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         i2c: I2C,
-        pins: impl Into<I2C::Pins>,
+        pins: impl Into<Pins<I2C::Scl, I2C::Sda>>,
         mode: impl Into<Mode>,
         clocks: &Clocks,
         start_timeout_us: u32,
diff --git a/src/serial.rs b/src/serial.rs
index 0c840c46..7cc5eaef 100644
--- a/src/serial.rs
+++ b/src/serial.rs
@@ -68,7 +68,7 @@ use embedded_dma::{ReadBuffer, WriteBuffer};
 
 use crate::afio::MAPR;
 use crate::dma::{dma1, CircBuffer, RxDma, Transfer, TxDma, R, W};
-use crate::gpio::{self, Alternate, Cr, Floating, Input, PinMode, PullUp, PushPull};
+use crate::gpio::{self, Alternate, Cr, Floating, Input, NoPin, PinMode, PullUp, PushPull};
 use crate::pac::{RCC, USART1, USART2, USART3};
 use crate::rcc::{BusClock, Clocks, Enable, Reset};
 use crate::time::{Bps, U32Ext};
@@ -80,16 +80,28 @@ pub trait InMode {}
 impl InMode for Floating {}
 impl InMode for PullUp {}
 
+pub struct Pins<TX, RX> {
+    pub tx: TX,
+    pub rx: RX,
+}
+
+impl<TX, RX> From<(TX, RX)> for Pins<TX, RX> {
+    fn from(value: (TX, RX)) -> Self {
+        Self {
+            tx: value.0,
+            rx: value.1,
+        }
+    }
+}
+
 // USART REMAPPING, see: https://www.st.com/content/ccc/resource/technical/document/reference_manual/59/b9/ba/7f/11/af/43/d5/CD00171190.pdf/files/CD00171190.pdf/jcr:content/translations/en.CD00171190.pdf
 // Section 9.3.8
 pub mod usart1 {
     use super::*;
 
     remap! {
-        Pins: [
-            All, Tx, Rx, PA9, PA10 => { |_, w| w.usart1_remap().bit(false) };
-            Remap, RemapTx, RemapRx, PB6, PB7  => { |_, w| w.usart1_remap().bit(true) };
-        ]
+        PA9, PA10 => { |_, w| w.usart1_remap().bit(false) };
+        PB6, PB7  => { |_, w| w.usart1_remap().bit(true) };
     }
 }
 
@@ -97,10 +109,8 @@ pub mod usart2 {
     use super::*;
 
     remap! {
-        Pins: [
-            All, Tx, Rx, PA2, PA3 => { |_, w| w.usart2_remap().bit(false) };
-            Remap, RemapTx, RemapRx, PD5, PD6 => { |_, w| w.usart2_remap().bit(true) };
-        ]
+        PA2, PA3 => { |_, w| w.usart2_remap().bit(false) };
+        PD5, PD6 => { |_, w| w.usart2_remap().bit(true) };
     }
 }
 
@@ -108,35 +118,36 @@ pub mod usart3 {
     use super::*;
 
     remap! {
-        Pins: [
-            RxTx, Tx, Rx, PB10, PB11 => { |_, w| unsafe { w.usart3_remap().bits(0b00)} };
-            Remap1, Remap1Tx, Remap1Rx, PC10, PC11 => { |_, w| unsafe { w.usart3_remap().bits(0b01)} };
-            Remap2, Remap2Tx, Remap2Rx, PD8, PD9 => { |_, w| unsafe { w.usart3_remap().bits(0b11)} };
-        ]
+        PB10, PB11 => { |_, w| unsafe { w.usart3_remap().bits(0b00)} };
+        PC10, PC11 => { |_, w| unsafe { w.usart3_remap().bits(0b01)} };
+        PD8, PD9 => { |_, w| unsafe { w.usart3_remap().bits(0b11)} };
     }
 }
 
 macro_rules! remap {
-    ($name:ident: [
-        $($rname:ident, $txonly:ident, $rxonly:ident, $TX:ident, $RX:ident => { $remapex:expr };)+
-    ]) => {
-        pub enum $name<Otype, PULL> {
+    ($($TX:ident, $RX:ident => { $remapex:expr };)+) => {
+        pub enum Tx<Otype> {
+            $(
+                $TX(gpio::$TX<Alternate<Otype>>),
+            )+
+            None(NoPin<Otype>),
+        }
+        pub enum Rx<PULL> {
             $(
-                $rname { tx: gpio::$TX<Alternate<Otype>>, rx: gpio::$RX<Input<PULL>> },
-                $txonly { tx: gpio::$TX<Alternate<Otype>> },
-                $rxonly { rx: gpio::$RX<Input<PULL>> },
+                $RX(gpio::$RX<Input<PULL>>),
             )+
+            None(NoPin<PULL>),
         }
 
         $(
-            impl<Otype, PULL: InMode> From<(gpio::$TX<Alternate<Otype>>, gpio::$RX<Input<PULL>>, &mut MAPR)> for $name<Otype, PULL> {
+            impl<Otype, PULL: InMode> From<(gpio::$TX<Alternate<Otype>>, gpio::$RX<Input<PULL>>, &mut MAPR)> for Pins<Tx<Otype>, Rx<PULL>> {
                 fn from(p: (gpio::$TX<Alternate<Otype>>, gpio::$RX<Input<PULL>>, &mut MAPR)) -> Self {
                     p.2.modify_mapr($remapex);
-                    Self::$rname { tx: p.0, rx: p.1 }
+                    Self { tx: Tx::$TX(p.0), rx: Rx::$RX(p.1) }
                 }
             }
 
-            impl<Otype, PULL> From<(gpio::$TX, gpio::$RX, &mut MAPR)> for $name<Otype, PULL>
+            impl<Otype, PULL> From<(gpio::$TX, gpio::$RX, &mut MAPR)> for Pins<Tx<Otype>, Rx<PULL>>
             where
                 Alternate<Otype>: PinMode,
                 Input<PULL>: PinMode,
@@ -147,30 +158,35 @@ macro_rules! remap {
                     let tx = p.0.into_mode(&mut cr);
                     let rx = p.1.into_mode(&mut cr);
                     p.2.modify_mapr($remapex);
-                    Self::$rname { tx, rx }
+                    Self { tx: Tx::$TX(tx), rx: Rx::$RX(rx) }
                 }
             }
 
-            impl<Otype> From<(gpio::$TX, &mut MAPR)> for $name<Otype, Floating>
+            impl<Otype> From<(gpio::$TX<Alternate<Otype>>, &mut MAPR)> for Pins<Tx<Otype>, Rx<Floating>> {
+                fn from(p: (gpio::$TX<Alternate<Otype>>, &mut MAPR)) -> Self {
+                    p.1.modify_mapr($remapex);
+                    Self { tx: Tx::$TX(p.0), rx: Rx::None(NoPin::new()) }
+                }
+            }
+
+            impl<Otype> From<(gpio::$TX, &mut MAPR)> for Pins<Tx<Otype>, Rx<Floating>>
             where
                 Alternate<Otype>: PinMode,
             {
                 fn from(p: (gpio::$TX, &mut MAPR)) -> Self {
                     let tx = p.0.into_mode(&mut Cr);
                     p.1.modify_mapr($remapex);
-                    Self::$txonly { tx }
+                    Self { tx: Tx::$TX(tx), rx: Rx::None(NoPin::new()) }
                 }
             }
 
-            impl<PULL> From<(gpio::$RX, &mut MAPR)> for $name<PushPull, PULL>
+            impl<PULL> From<(gpio::$RX<Input<PULL>>, &mut MAPR)> for Pins<Tx<PushPull>, Rx<PULL>>
             where
-                Input<PULL>: PinMode,
                 PULL: InMode,
             {
-                fn from(p: (gpio::$RX, &mut MAPR)) -> Self {
-                    let rx = p.0.into_mode(&mut Cr);
+                fn from(p: (gpio::$RX<Input<PULL>>, &mut MAPR)) -> Self {
                     p.1.modify_mapr($remapex);
-                    Self::$rxonly { rx }
+                    Self { tx: Tx::None(NoPin::new()), rx: Rx::$RX(p.0) }
                 }
             }
         )+
@@ -181,16 +197,32 @@ use remap;
 pub trait SerialExt: Sized + Instance {
     fn serial(
         self,
-        pins: impl Into<Self::Pins<PushPull, Floating>>,
+        pins: impl Into<Pins<Self::Tx<PushPull>, Self::Rx<Floating>>>,
         config: impl Into<Config>,
         clocks: &Clocks,
     ) -> Serial<Self, PushPull, Floating>;
+    fn tx(
+        self,
+        pins: impl Into<Pins<Self::Tx<PushPull>, Self::Rx<Floating>>>,
+        config: impl Into<Config>,
+        clocks: &Clocks,
+    ) -> Tx<Self> {
+        self.serial(pins.into(), config, clocks).split().0
+    }
+    fn rx(
+        self,
+        pins: impl Into<Pins<Self::Tx<PushPull>, Self::Rx<Floating>>>,
+        config: impl Into<Config>,
+        clocks: &Clocks,
+    ) -> Rx<Self> {
+        self.serial(pins.into(), config, clocks).split().1
+    }
 }
 
 impl<USART: Instance> SerialExt for USART {
     fn serial(
         self,
-        pins: impl Into<Self::Pins<PushPull, Floating>>,
+        pins: impl Into<Pins<Self::Tx<PushPull>, Self::Rx<Floating>>>,
         config: impl Into<Config>,
         clocks: &Clocks,
     ) -> Serial<Self> {
@@ -203,7 +235,8 @@ use crate::pac::usart1 as uart_base;
 pub trait Instance:
     crate::Sealed + Deref<Target = uart_base::RegisterBlock> + Enable + Reset + BusClock
 {
-    type Pins<Otype, PULL>;
+    type Tx<Otype>;
+    type Rx<PULL>;
 
     #[doc(hidden)]
     fn ptr() -> *const uart_base::RegisterBlock;
@@ -213,7 +246,8 @@ macro_rules! inst {
     ($($USARTX:ident, $usart:ident;)+) => {
         $(
             impl Instance for $USARTX {
-                type Pins<Otype, PULL> = $usart::Pins<Otype, PULL>;
+                type Tx<Otype> = $usart::Tx<Otype>;
+                type Rx<PULL> = $usart::Rx<PULL>;
 
                 fn ptr() -> *const uart_base::RegisterBlock {
                     <$USARTX>::ptr()
@@ -347,7 +381,8 @@ impl From<Bps> for Config {
 pub struct Serial<USART: Instance, Otype = PushPull, PULL = Floating> {
     pub tx: Tx<USART>,
     pub rx: Rx<USART>,
-    pub token: ReleaseToken<USART, USART::Pins<Otype, PULL>>,
+    #[allow(clippy::type_complexity)]
+    pub token: ReleaseToken<USART, (USART::Tx<Otype>, USART::Rx<PULL>)>,
 }
 
 /// Serial transmitter
@@ -366,6 +401,28 @@ pub struct ReleaseToken<USART, PINS> {
     pins: PINS,
 }
 
+impl<USART: Instance, Otype> Serial<USART, Otype, Floating> {
+    pub fn tx(
+        usart: USART,
+        pins: impl Into<Pins<USART::Tx<Otype>, USART::Rx<Floating>>>,
+        config: impl Into<Config>,
+        clocks: &Clocks,
+    ) -> Tx<USART> {
+        Self::new(usart, pins.into(), config, clocks).split().0
+    }
+}
+
+impl<USART: Instance, PULL> Serial<USART, PushPull, PULL> {
+    pub fn rx(
+        usart: USART,
+        pins: impl Into<Pins<USART::Tx<PushPull>, USART::Rx<PULL>>>,
+        config: impl Into<Config>,
+        clocks: &Clocks,
+    ) -> Rx<USART> {
+        Self::new(usart, pins.into(), config, clocks).split().1
+    }
+}
+
 impl<USART: Instance, Otype, PULL> Serial<USART, Otype, PULL> {
     /// Configures the serial interface and creates the interface
     /// struct.
@@ -384,7 +441,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<USART::Pins<Otype, PULL>>,
+        pins: impl Into<Pins<USART::Tx<Otype>, USART::Rx<PULL>>>,
         config: impl Into<Config>,
         clocks: &Clocks,
     ) -> Self {
@@ -414,7 +471,10 @@ impl<USART: Instance, Otype, PULL> Serial<USART, Otype, PULL> {
             rx: Rx {
                 _usart: PhantomData,
             },
-            token: ReleaseToken { usart, pins },
+            token: ReleaseToken {
+                usart,
+                pins: (pins.tx, pins.rx),
+            },
         }
     }
 
@@ -448,7 +508,8 @@ impl<USART: Instance, Otype, PULL> Serial<USART, Otype, PULL> {
     /// // Release `Serial`
     /// let (usart, (tx_pin, rx_pin)) = serial.release();
     /// ```
-    pub fn release(self) -> (USART, USART::Pins<Otype, PULL>) {
+    #[allow(clippy::type_complexity)]
+    pub fn release(self) -> (USART, (USART::Tx<Otype>, USART::Rx<PULL>)) {
         (self.token.usart, self.token.pins)
     }
 
diff --git a/src/spi.rs b/src/spi.rs
index 93c50419..c585f5f0 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, PinMode, PullUp, PushPull};
+use crate::gpio::{self, Alternate, Cr, Floating, Input, NoPin, PinMode, PullUp, PushPull};
 use crate::rcc::{BusClock, Clocks, Enable, Reset};
 use crate::time::Hertz;
 
@@ -108,14 +108,23 @@ pub trait InMode {}
 impl InMode for Floating {}
 impl InMode for PullUp {}
 
+pub struct MasterPins<SCK, MISO, MOSI> {
+    pub sck: SCK,
+    pub mi: MISO,
+    pub mo: MOSI,
+}
+pub struct SlavePins<SCK, MISO, MOSI> {
+    pub sck: SCK,
+    pub so: MISO,
+    pub si: MOSI,
+}
+
 pub mod spi1 {
     use super::*;
 
     remap! {
-        MasterPins, SlavePins: [
-            All, Nomosi, Nomiso, PA5, PA6, PA7 => MAPR { |_, w| w.spi1_remap().bit(false) };
-            Remap, RemapNomosi, RemapNomiso, PB3, PB4, PB5  => MAPR { |_, w| w.spi1_remap().bit(true) };
-        ]
+        PA5, PA6, PA7 => MAPR { |_, w| w.spi1_remap().bit(false) };
+        PB3, PB4, PB5  => MAPR { |_, w| w.spi1_remap().bit(true) };
     }
 }
 
@@ -123,9 +132,7 @@ pub mod spi2 {
     use super::*;
 
     remap! {
-        MasterPins, SlavePins: [
-            All, Nomosi, Nomiso, PB13, PB14, PB15;
-        ]
+        PB13, PB14, PB15;
     }
 }
 #[cfg(any(feature = "high", feature = "connectivity"))]
@@ -133,56 +140,71 @@ pub mod spi3 {
     use super::*;
 
     remap! {
-        MasterPins, SlavePins: [
-            #[cfg(not(feature = "connectivity"))]
-            All, Nomosi, Nomiso, PB3, PB4, PB5;
-            #[cfg(feature = "connectivity")]
-            All, Nomosi, Nomiso, PB3, PB4, PB5 => MAPR { |_, w| w.spi3_remap().bit(false) };
-            #[cfg(feature = "connectivity")]
-            Remap, RemapNomosi, RemapNomiso, PC10, PC11, PC12  => MAPR { |_, w| w.spi3_remap().bit(true) };
-        ]
+        #[cfg(not(feature = "connectivity"))]
+        PB3, PB4, PB5;
+        #[cfg(feature = "connectivity")]
+        PB3, PB4, PB5 => MAPR { |_, w| w.spi3_remap().bit(false) };
+        #[cfg(feature = "connectivity")]
+        PC10, PC11, PC12  => MAPR { |_, w| w.spi3_remap().bit(true) };
     }
 }
 
 macro_rules! remap {
-    ($master:ident, $slave:ident: [
-        $($(#[$attr:meta])* $rname:ident, $nomosi:ident, $nomiso:ident, $SCK:ident, $MISO:ident, $MOSI:ident $( => $MAPR:ident { $remapex:expr })?;)+
-    ]) => {
-        pub enum $master<PULL> {
+    (
+        $($(#[$attr:meta])* $SCK:ident, $MISO:ident, $MOSI:ident $( => $MAPR:ident { $remapex:expr })?;)+
+    ) => {
+        pub enum Sck {
             $(
                 $(#[$attr])*
-                $rname { sck: gpio::$SCK<Alternate>, miso: gpio::$MISO<Input<PULL>>, mosi: gpio::$MOSI<Alternate> },
-                $(#[$attr])*
-                $nomosi { sck: gpio::$SCK<Alternate>, miso: gpio::$MISO<Input<PULL>> },
+                $SCK(gpio::$SCK<Alternate>),
+            )+
+            None(NoPin<PushPull>),
+        }
+
+        pub enum Mi<PULL> {
+            $(
                 $(#[$attr])*
-                $nomiso { sck: gpio::$SCK<Alternate>, mosi: gpio::$MOSI<Alternate> },
+                $MISO(gpio::$MISO<Input<PULL>>),
             )+
+            None(NoPin<Floating>),
         }
 
-        pub enum $slave<Otype, PULL> {
+        pub enum So<Otype> {
             $(
                 $(#[$attr])*
-                $rname { sck: gpio::$SCK, miso: gpio::$MISO<Alternate<Otype>>, mosi: gpio::$MOSI<Input<PULL>> },
+                $MISO(gpio::$MISO<Alternate<Otype>>),
+            )+
+            None(NoPin<PushPull>),
+        }
+
+        pub enum Mo {
+            $(
                 $(#[$attr])*
-                $nomosi { sck: gpio::$SCK, miso: gpio::$MISO<Alternate<Otype>> },
+                $MOSI(gpio::$MOSI<Alternate>),
+            )+
+            None(NoPin<PushPull>),
+        }
+
+        pub enum Si<PULL> {
+            $(
                 $(#[$attr])*
-                $nomiso { sck: gpio::$SCK, mosi: gpio::$MOSI<Input<PULL>> },
+                $MOSI(gpio::$MOSI<Input<PULL>>),
             )+
+            None(NoPin<Floating>),
         }
 
         $(
             // For master mode
-
             $(#[$attr])*
-            impl<PULL: InMode> From<(gpio::$SCK<Alternate>, gpio::$MISO<Input<PULL>>, gpio::$MOSI<Alternate> $(, &mut $MAPR)?)> for $master<PULL> {
+            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 {
                     $(p.3.modify_mapr($remapex);)?
-                    Self::$rname { sck: p.0, miso: p.1, mosi: p.2 }
+                    Self { sck: Sck::$SCK(p.0), mi: Mi::$MISO(p.1), mo: Mo::$MOSI(p.2) }
                 }
             }
 
             $(#[$attr])*
-            impl<PULL> From<(gpio::$SCK, gpio::$MISO, gpio::$MOSI $(, &mut $MAPR)?)> for $master<PULL>
+            impl<PULL> From<(gpio::$SCK, gpio::$MISO, gpio::$MOSI $(, &mut $MAPR)?)> for MasterPins<Sck, Mi<PULL>, Mo>
             where
                 Input<PULL>: PinMode,
                 PULL: InMode,
@@ -193,20 +215,20 @@ macro_rules! remap {
                     let miso = p.1.into_mode(&mut cr);
                     let mosi = p.2.into_mode(&mut cr);
                     $(p.3.modify_mapr($remapex);)?
-                    Self::$rname { sck, miso, mosi }
+                    Self { sck: Sck::$SCK(sck), mi: Mi::$MISO(miso), mo: Mo::$MOSI(mosi) }
                 }
             }
 
             $(#[$attr])*
-            impl<PULL: InMode> From<(gpio::$SCK<Alternate>, gpio::$MISO<Input<PULL>> $(, &mut $MAPR)?)> for $master<PULL> {
+            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 {
                     $(p.2.modify_mapr($remapex);)?
-                    Self::$nomosi { sck: p.0, miso: p.1 }
+                    Self { sck: Sck::$SCK(p.0), mi: Mi::$MISO(p.1), mo: Mo::None(NoPin::new()) }
                 }
             }
 
             $(#[$attr])*
-            impl<PULL> From<(gpio::$SCK, gpio::$MISO $(, &mut $MAPR)?)> for $master<PULL>
+            impl<PULL> From<(gpio::$SCK, gpio::$MISO $(, &mut $MAPR)?)> for super::MasterPins<Sck, Mi<PULL>, Mo>
             where
                 Input<PULL>: PinMode,
                 PULL: InMode,
@@ -216,33 +238,33 @@ macro_rules! remap {
                     let sck = p.0.into_mode(&mut cr);
                     let miso = p.1.into_mode(&mut cr);
                     $(p.2.modify_mapr($remapex);)?
-                    Self::$nomosi { sck, miso }
+                    Self { sck: Sck::$SCK(sck), mi: Mi::$MISO(miso), mo: Mo::None(NoPin::new()) }
                 }
             }
 
             $(#[$attr])*
-            impl From<(gpio::$SCK, gpio::$MOSI $(, &mut $MAPR)?)> for $master<Floating> {
+            impl From<(gpio::$SCK, gpio::$MOSI $(, &mut $MAPR)?)> for super::MasterPins<Sck, Mi<Floating>, Mo> {
                 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);
                     $(p.2.modify_mapr($remapex);)?
-                    Self::$nomiso { sck, mosi }
+                    Self { sck: Sck::$SCK(sck), mi: Mi::None(NoPin::new()), mo: Mo::$MOSI(mosi) }
                 }
             }
 
             // For slave mode
 
             $(#[$attr])*
-            impl<Otype, PULL: InMode> From<(gpio::$SCK, gpio::$MISO<Alternate<Otype>>, gpio::$MOSI<Input<PULL>> $(, &mut $MAPR)?)> for $slave<Otype, PULL> {
-                fn from(p: (gpio::$SCK, gpio::$MISO<Alternate<Otype>>, gpio::$MOSI<Input<PULL>> $(, &mut $MAPR)?)) -> Self {
+            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 {
                     $(p.3.modify_mapr($remapex);)?
-                    Self::$rname { sck: p.0, miso: p.1, mosi: p.2 }
+                    Self { sck: Sck::$SCK(p.0), so: So::$MISO(p.1), si: Si::$MOSI(p.2) }
                 }
             }
 
             $(#[$attr])*
-            impl<Otype, PULL> From<(gpio::$SCK, gpio::$MISO, gpio::$MOSI $(, &mut $MAPR)?)> for $slave<Otype, PULL>
+            impl<Otype, PULL> From<(gpio::$SCK, gpio::$MISO, gpio::$MOSI $(, &mut $MAPR)?)> for SlavePins<Sck, So<Otype>, Si<PULL>>
             where
                 Alternate<Otype>: PinMode,
                 Input<PULL>: PinMode,
@@ -254,12 +276,12 @@ macro_rules! remap {
                     let miso = p.1.into_mode(&mut cr);
                     let mosi = p.2.into_mode(&mut cr);
                     $(p.3.modify_mapr($remapex);)?
-                    Self::$rname { sck, miso, mosi }
+                    Self { sck: Sck::$SCK(sck), so: So::$MISO(miso), si: Si::$MOSI(mosi) }
                 }
             }
 
             $(#[$attr])*
-            impl<Otype> From<(gpio::$SCK, gpio::$MISO $(, &mut $MAPR)?)> for $slave<Otype, Floating>
+            impl<Otype> From<(gpio::$SCK, gpio::$MISO $(, &mut $MAPR)?)> for SlavePins<Sck, So<Otype>, Si<Floating>>
             where
                 Alternate<Otype>: PinMode,
             {
@@ -268,12 +290,12 @@ macro_rules! remap {
                     let sck = p.0.into_mode(&mut cr);
                     let miso = p.1.into_mode(&mut cr);
                     $(p.2.modify_mapr($remapex);)?
-                    Self::$nomosi { sck, miso }
+                    Self { sck: Sck::$SCK(sck), so: So::$MISO(miso), si: Si::None(NoPin::new()) }
                 }
             }
 
             $(#[$attr])*
-            impl<PULL> From<(gpio::$SCK, gpio::$MOSI $(, &mut $MAPR)?)> for $slave<PushPull, PULL>
+            impl<PULL> From<(gpio::$SCK, gpio::$MOSI $(, &mut $MAPR)?)> for SlavePins<Sck, So<PushPull>, Si<PULL>>
             where
                 Input<PULL>: PinMode,
                 PULL: InMode,
@@ -283,7 +305,7 @@ macro_rules! remap {
                     let sck = p.0.into_mode(&mut cr);
                     let mosi = p.1.into_mode(&mut cr);
                     $(p.2.modify_mapr($remapex);)?
-                    Self::$nomiso { sck, mosi }
+                    Self { sck: Sck::$SCK(sck), so: So::None(NoPin::new()), si: Si::$MOSI(mosi) }
                 }
             }
         )+
@@ -294,14 +316,14 @@ use remap;
 pub trait SpiExt: Sized + Instance {
     fn spi(
         self,
-        pins: impl Into<Self::MasterPins<Floating>>,
+        pins: impl Into<MasterPins<Self::Sck, Self::Mi<Floating>, Self::Mo>>,
         mode: Mode,
         freq: Hertz,
         clocks: &Clocks,
     ) -> Spi<Self, u8, Floating>;
     fn spi_u16(
         self,
-        pins: impl Into<Self::MasterPins<Floating>>,
+        pins: impl Into<MasterPins<Self::Sck, Self::Mi<Floating>, Self::Mo>>,
         mode: Mode,
         freq: Hertz,
         clocks: &Clocks,
@@ -310,12 +332,12 @@ pub trait SpiExt: Sized + Instance {
     }
     fn spi_slave(
         self,
-        pins: impl Into<Self::SlavePins<PushPull, Floating>>,
+        pins: impl Into<SlavePins<Self::Sck, Self::So<PushPull>, Self::Si<Floating>>>,
         mode: Mode,
     ) -> SpiSlave<Self, u8, PushPull, Floating>;
     fn spi_slave_u16(
         self,
-        pins: impl Into<Self::SlavePins<PushPull, Floating>>,
+        pins: impl Into<SlavePins<Self::Sck, Self::So<PushPull>, Self::Si<Floating>>>,
         mode: Mode,
     ) -> SpiSlave<Self, u16, PushPull, Floating> {
         Self::spi_slave(self, pins, mode).frame_size_16bit()
@@ -325,7 +347,7 @@ pub trait SpiExt: Sized + Instance {
 impl<SPI: Instance> SpiExt for SPI {
     fn spi(
         self,
-        pins: impl Into<Self::MasterPins<Floating>>,
+        pins: impl Into<MasterPins<Self::Sck, Self::Mi<Floating>, Self::Mo>>,
         mode: Mode,
         freq: Hertz,
         clocks: &Clocks,
@@ -334,7 +356,7 @@ impl<SPI: Instance> SpiExt for SPI {
     }
     fn spi_slave(
         self,
-        pins: impl Into<Self::SlavePins<PushPull, Floating>>,
+        pins: impl Into<SlavePins<Self::Sck, Self::So<PushPull>, Self::Si<Floating>>>,
         mode: Mode,
     ) -> SpiSlave<Self, u8, PushPull, Floating> {
         SpiSlave::new(self, pins, mode)
@@ -358,13 +380,13 @@ impl<SPI, W> SpiInner<SPI, W> {
 /// Spi in Master mode
 pub struct Spi<SPI: Instance, W, PULL = Floating> {
     inner: SpiInner<SPI, W>,
-    pins: SPI::MasterPins<PULL>,
+    pins: (SPI::Sck, SPI::Mi<PULL>, SPI::Mo),
 }
 
 /// Spi in Slave mode
 pub struct SpiSlave<SPI: Instance, W, Otype = PushPull, PULL = Floating> {
     inner: SpiInner<SPI, W>,
-    pins: SPI::SlavePins<Otype, PULL>,
+    pins: (SPI::Sck, SPI::So<Otype>, SPI::Si<PULL>),
 }
 
 impl<SPI: Instance, W, PULL> Deref for Spi<SPI, W, PULL> {
@@ -405,22 +427,34 @@ pub enum SpiBitFormat {
 pub trait Instance:
     crate::Sealed + Deref<Target = crate::pac::spi1::RegisterBlock> + Enable + Reset + BusClock
 {
-    type MasterPins<PULL>;
-    type SlavePins<Otype, PULL>;
+    type Sck;
+    type Mi<PULL>;
+    type So<Otype>;
+    type Mo;
+    type Si<PULL>;
 }
 
 impl Instance for pac::SPI1 {
-    type MasterPins<PULL> = spi1::MasterPins<PULL>;
-    type SlavePins<Otype, PULL> = spi1::SlavePins<Otype, PULL>;
+    type Sck = spi1::Sck;
+    type Mi<PULL> = spi1::Mi<PULL>;
+    type So<Otype> = spi1::So<Otype>;
+    type Mo = spi1::Mo;
+    type Si<PULL> = spi1::Si<PULL>;
 }
 impl Instance for pac::SPI2 {
-    type MasterPins<PULL> = spi2::MasterPins<PULL>;
-    type SlavePins<Otype, PULL> = spi2::SlavePins<Otype, PULL>;
+    type Sck = spi2::Sck;
+    type Mi<PULL> = spi2::Mi<PULL>;
+    type So<Otype> = spi2::So<Otype>;
+    type Mo = spi2::Mo;
+    type Si<PULL> = spi2::Si<PULL>;
 }
 #[cfg(any(feature = "high", feature = "connectivity"))]
 impl Instance for pac::SPI3 {
-    type MasterPins<PULL> = spi3::MasterPins<PULL>;
-    type SlavePins<Otype, PULL> = spi3::SlavePins<Otype, PULL>;
+    type Sck = spi3::Sck;
+    type Mi<PULL> = spi3::Mi<PULL>;
+    type So<Otype> = spi3::So<Otype>;
+    type Mo = spi3::Mo;
+    type Si<PULL> = spi3::Si<PULL>;
 }
 
 impl<SPI: Instance, PULL> Spi<SPI, u8, PULL> {
@@ -433,7 +467,7 @@ impl<SPI: Instance, PULL> Spi<SPI, u8, PULL> {
     */
     pub fn new(
         spi: SPI,
-        pins: impl Into<SPI::MasterPins<PULL>>,
+        pins: impl Into<MasterPins<SPI::Sck, SPI::Mi<PULL>, SPI::Mo>>,
         mode: Mode,
         freq: Hertz,
         clocks: &Clocks,
@@ -487,11 +521,12 @@ impl<SPI: Instance, PULL> Spi<SPI, u8, PULL> {
 
         Spi {
             inner: SpiInner::new(spi),
-            pins,
+            pins: (pins.sck, pins.mi, pins.mo),
         }
     }
 
-    pub fn release(self) -> (SPI, SPI::MasterPins<PULL>) {
+    #[allow(clippy::type_complexity)]
+    pub fn release(self) -> (SPI, (SPI::Sck, SPI::Mi<PULL>, SPI::Mo)) {
         (self.inner.spi, self.pins)
     }
 }
@@ -504,7 +539,11 @@ impl<SPI: Instance, Otype, PULL> SpiSlave<SPI, u8, Otype, PULL> {
 
       You can also use `NoMiso` or `NoMosi` if you don't want to use the pins
     */
-    pub fn new(spi: SPI, pins: impl Into<SPI::SlavePins<Otype, PULL>>, mode: Mode) -> Self {
+    pub fn new(
+        spi: SPI,
+        pins: impl Into<SlavePins<SPI::Sck, SPI::So<Otype>, SPI::Si<PULL>>>,
+        mode: Mode,
+    ) -> Self {
         // enable or reset SPI
         let rcc = unsafe { &(*RCC::ptr()) };
         SPI::enable(rcc);
@@ -540,11 +579,12 @@ impl<SPI: Instance, Otype, PULL> SpiSlave<SPI, u8, Otype, PULL> {
 
         SpiSlave {
             inner: SpiInner::new(spi),
-            pins,
+            pins: (pins.sck, pins.so, pins.si),
         }
     }
 
-    pub fn release(self) -> (SPI, SPI::SlavePins<Otype, PULL>) {
+    #[allow(clippy::type_complexity)]
+    pub fn release(self) -> (SPI, (SPI::Sck, SPI::So<Otype>, SPI::Si<PULL>)) {
         (self.inner.spi, self.pins)
     }
 }