rp/gpio: remove generics.

1 files changed, 62 insertions, 63 deletions

diff --git a/embassy-rp/src/gpio.rs b/embassy-rp/src/gpio.rs
index 7eb57bbe6..93b29bbf9 100644
--- a/embassy-rp/src/gpio.rs
+++ b/embassy-rp/src/gpio.rs
@@ -8,6 +8,7 @@ use core::task::{Context, Poll};
 use embassy_hal_internal::{impl_peripheral, into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 
+use self::sealed::Pin as _;
 use crate::interrupt::InterruptExt;
 use crate::pac::common::{Reg, RW};
 use crate::pac::SIO;
@@ -105,14 +106,14 @@ pub struct DormantWakeConfig {
 }
 
 /// GPIO input driver.
-pub struct Input<'d, T: Pin> {
-    pin: Flex<'d, T>,
+pub struct Input<'d> {
+    pin: Flex<'d>,
 }
 
-impl<'d, T: Pin> Input<'d, T> {
+impl<'d> Input<'d> {
     /// Create GPIO input driver for a [Pin] with the provided [Pull] configuration.
     #[inline]
-    pub fn new(pin: impl Peripheral<P = T> + 'd, pull: Pull) -> Self {
+    pub fn new(pin: impl Peripheral<P = impl Pin> + 'd, pull: Pull) -> Self {
         let mut pin = Flex::new(pin);
         pin.set_as_input();
         pin.set_pull(pull);
@@ -175,7 +176,7 @@ impl<'d, T: Pin> Input<'d, T> {
 
     /// Configure dormant wake.
     #[inline]
-    pub fn dormant_wake(&mut self, cfg: DormantWakeConfig) -> DormantWake<T> {
+    pub fn dormant_wake(&mut self, cfg: DormantWakeConfig) -> DormantWake<'_> {
         self.pin.dormant_wake(cfg)
     }
 }
@@ -255,14 +256,12 @@ fn IO_IRQ_QSPI() {
 }
 
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-struct InputFuture<'a, T: Pin> {
-    pin: PeripheralRef<'a, T>,
+struct InputFuture<'d> {
+    pin: PeripheralRef<'d, AnyPin>,
 }
 
-impl<'d, T: Pin> InputFuture<'d, T> {
-    /// Create a new future wiating for input trigger.
-    pub fn new(pin: impl Peripheral<P = T> + 'd, level: InterruptTrigger) -> Self {
-        into_ref!(pin);
+impl<'d> InputFuture<'d> {
+    fn new(pin: PeripheralRef<'d, AnyPin>, level: InterruptTrigger) -> Self {
         let pin_group = (pin.pin() % 8) as usize;
         // first, clear the INTR register bits. without this INTR will still
         // contain reports of previous edges, causing the IRQ to fire early
@@ -305,7 +304,7 @@ impl<'d, T: Pin> InputFuture<'d, T> {
     }
 }
 
-impl<'d, T: Pin> Future for InputFuture<'d, T> {
+impl<'d> Future for InputFuture<'d> {
     type Output = ();
 
     fn poll(self: FuturePin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
@@ -344,14 +343,14 @@ impl<'d, T: Pin> Future for InputFuture<'d, T> {
 }
 
 /// GPIO output driver.
-pub struct Output<'d, T: Pin> {
-    pin: Flex<'d, T>,
+pub struct Output<'d> {
+    pin: Flex<'d>,
 }
 
-impl<'d, T: Pin> Output<'d, T> {
+impl<'d> Output<'d> {
     /// Create GPIO output driver for a [Pin] with the provided [Level].
     #[inline]
-    pub fn new(pin: impl Peripheral<P = T> + 'd, initial_output: Level) -> Self {
+    pub fn new(pin: impl Peripheral<P = impl Pin> + 'd, initial_output: Level) -> Self {
         let mut pin = Flex::new(pin);
         match initial_output {
             Level::High => pin.set_high(),
@@ -418,14 +417,14 @@ impl<'d, T: Pin> Output<'d, T> {
 }
 
 /// GPIO output open-drain.
-pub struct OutputOpenDrain<'d, T: Pin> {
-    pin: Flex<'d, T>,
+pub struct OutputOpenDrain<'d> {
+    pin: Flex<'d>,
 }
 
-impl<'d, T: Pin> OutputOpenDrain<'d, T> {
+impl<'d> OutputOpenDrain<'d> {
     /// Create GPIO output driver for a [Pin] in open drain mode with the provided [Level].
     #[inline]
-    pub fn new(pin: impl Peripheral<P = T> + 'd, initial_output: Level) -> Self {
+    pub fn new(pin: impl Peripheral<P = impl Pin> + 'd, initial_output: Level) -> Self {
         let mut pin = Flex::new(pin);
         pin.set_low();
         match initial_output {
@@ -548,17 +547,17 @@ impl<'d, T: Pin> OutputOpenDrain<'d, T> {
 /// This pin can be either an input or output pin. The output level register bit will remain
 /// set while not in output mode, so the pin's level will be 'remembered' when it is not in output
 /// mode.
-pub struct Flex<'d, T: Pin> {
-    pin: PeripheralRef<'d, T>,
+pub struct Flex<'d> {
+    pin: PeripheralRef<'d, AnyPin>,
 }
 
-impl<'d, T: Pin> Flex<'d, T> {
+impl<'d> Flex<'d> {
     /// Wrap the pin in a `Flex`.
     ///
     /// The pin remains disconnected. The initial output level is unspecified, but can be changed
     /// before the pin is put into output mode.
     #[inline]
-    pub fn new(pin: impl Peripheral<P = T> + 'd) -> Self {
+    pub fn new(pin: impl Peripheral<P = impl Pin> + 'd) -> Self {
         into_ref!(pin);
 
         pin.pad_ctrl().write(|w| {
@@ -569,7 +568,7 @@ impl<'d, T: Pin> Flex<'d, T> {
             w.set_funcsel(pac::io::vals::Gpio0ctrlFuncsel::SIO_0 as _);
         });
 
-        Self { pin }
+        Self { pin: pin.map_into() }
     }
 
     #[inline]
@@ -716,36 +715,36 @@ impl<'d, T: Pin> Flex<'d, T> {
     /// Wait until the pin is high. If it is already high, return immediately.
     #[inline]
     pub async fn wait_for_high(&mut self) {
-        InputFuture::new(&mut self.pin, InterruptTrigger::LevelHigh).await;
+        InputFuture::new(self.pin.reborrow(), InterruptTrigger::LevelHigh).await;
     }
 
     /// Wait until the pin is low. If it is already low, return immediately.
     #[inline]
     pub async fn wait_for_low(&mut self) {
-        InputFuture::new(&mut self.pin, InterruptTrigger::LevelLow).await;
+        InputFuture::new(self.pin.reborrow(), InterruptTrigger::LevelLow).await;
     }
 
     /// Wait for the pin to undergo a transition from low to high.
     #[inline]
     pub async fn wait_for_rising_edge(&mut self) {
-        InputFuture::new(&mut self.pin, InterruptTrigger::EdgeHigh).await;
+        InputFuture::new(self.pin.reborrow(), InterruptTrigger::EdgeHigh).await;
     }
 
     /// Wait for the pin to undergo a transition from high to low.
     #[inline]
     pub async fn wait_for_falling_edge(&mut self) {
-        InputFuture::new(&mut self.pin, InterruptTrigger::EdgeLow).await;
+        InputFuture::new(self.pin.reborrow(), InterruptTrigger::EdgeLow).await;
     }
 
     /// Wait for the pin to undergo any transition, i.e low to high OR high to low.
     #[inline]
     pub async fn wait_for_any_edge(&mut self) {
-        InputFuture::new(&mut self.pin, InterruptTrigger::AnyEdge).await;
+        InputFuture::new(self.pin.reborrow(), InterruptTrigger::AnyEdge).await;
     }
 
     /// Configure dormant wake.
     #[inline]
-    pub fn dormant_wake(&mut self, cfg: DormantWakeConfig) -> DormantWake<T> {
+    pub fn dormant_wake(&mut self, cfg: DormantWakeConfig) -> DormantWake<'_> {
         let idx = self.pin._pin() as usize;
         self.pin.io().intr(idx / 8).write(|w| {
             w.set_edge_high(idx % 8, cfg.edge_high);
@@ -764,7 +763,7 @@ impl<'d, T: Pin> Flex<'d, T> {
     }
 }
 
-impl<'d, T: Pin> Drop for Flex<'d, T> {
+impl<'d> Drop for Flex<'d> {
     #[inline]
     fn drop(&mut self) {
         let idx = self.pin._pin() as usize;
@@ -782,12 +781,12 @@ impl<'d, T: Pin> Drop for Flex<'d, T> {
 }
 
 /// Dormant wake driver.
-pub struct DormantWake<'w, T: Pin> {
-    pin: PeripheralRef<'w, T>,
+pub struct DormantWake<'w> {
+    pin: PeripheralRef<'w, AnyPin>,
     cfg: DormantWakeConfig,
 }
 
-impl<'w, T: Pin> Drop for DormantWake<'w, T> {
+impl<'w> Drop for DormantWake<'w> {
     fn drop(&mut self) {
         let idx = self.pin._pin() as usize;
         self.pin.io().intr(idx / 8).write(|w| {
@@ -970,7 +969,7 @@ mod eh02 {
 
     use super::*;
 
-    impl<'d, T: Pin> embedded_hal_02::digital::v2::InputPin for Input<'d, T> {
+    impl<'d> embedded_hal_02::digital::v2::InputPin for Input<'d> {
         type Error = Infallible;
 
         fn is_high(&self) -> Result<bool, Self::Error> {
@@ -982,7 +981,7 @@ mod eh02 {
         }
     }
 
-    impl<'d, T: Pin> embedded_hal_02::digital::v2::OutputPin for Output<'d, T> {
+    impl<'d> embedded_hal_02::digital::v2::OutputPin for Output<'d> {
         type Error = Infallible;
 
         fn set_high(&mut self) -> Result<(), Self::Error> {
@@ -994,7 +993,7 @@ mod eh02 {
         }
     }
 
-    impl<'d, T: Pin> embedded_hal_02::digital::v2::StatefulOutputPin for Output<'d, T> {
+    impl<'d> embedded_hal_02::digital::v2::StatefulOutputPin for Output<'d> {
         fn is_set_high(&self) -> Result<bool, Self::Error> {
             Ok(self.is_set_high())
         }
@@ -1004,7 +1003,7 @@ mod eh02 {
         }
     }
 
-    impl<'d, T: Pin> embedded_hal_02::digital::v2::ToggleableOutputPin for Output<'d, T> {
+    impl<'d> embedded_hal_02::digital::v2::ToggleableOutputPin for Output<'d> {
         type Error = Infallible;
         #[inline]
         fn toggle(&mut self) -> Result<(), Self::Error> {
@@ -1012,7 +1011,7 @@ mod eh02 {
         }
     }
 
-    impl<'d, T: Pin> embedded_hal_02::digital::v2::InputPin for OutputOpenDrain<'d, T> {
+    impl<'d> embedded_hal_02::digital::v2::InputPin for OutputOpenDrain<'d> {
         type Error = Infallible;
 
         fn is_high(&self) -> Result<bool, Self::Error> {
@@ -1024,7 +1023,7 @@ mod eh02 {
         }
     }
 
-    impl<'d, T: Pin> embedded_hal_02::digital::v2::OutputPin for OutputOpenDrain<'d, T> {
+    impl<'d> embedded_hal_02::digital::v2::OutputPin for OutputOpenDrain<'d> {
         type Error = Infallible;
 
         #[inline]
@@ -1038,7 +1037,7 @@ mod eh02 {
         }
     }
 
-    impl<'d, T: Pin> embedded_hal_02::digital::v2::StatefulOutputPin for OutputOpenDrain<'d, T> {
+    impl<'d> embedded_hal_02::digital::v2::StatefulOutputPin for OutputOpenDrain<'d> {
         fn is_set_high(&self) -> Result<bool, Self::Error> {
             Ok(self.is_set_high())
         }
@@ -1048,7 +1047,7 @@ mod eh02 {
         }
     }
 
-    impl<'d, T: Pin> embedded_hal_02::digital::v2::ToggleableOutputPin for OutputOpenDrain<'d, T> {
+    impl<'d> embedded_hal_02::digital::v2::ToggleableOutputPin for OutputOpenDrain<'d> {
         type Error = Infallible;
         #[inline]
         fn toggle(&mut self) -> Result<(), Self::Error> {
@@ -1056,7 +1055,7 @@ mod eh02 {
         }
     }
 
-    impl<'d, T: Pin> embedded_hal_02::digital::v2::InputPin for Flex<'d, T> {
+    impl<'d> embedded_hal_02::digital::v2::InputPin for Flex<'d> {
         type Error = Infallible;
 
         fn is_high(&self) -> Result<bool, Self::Error> {
@@ -1068,7 +1067,7 @@ mod eh02 {
         }
     }
 
-    impl<'d, T: Pin> embedded_hal_02::digital::v2::OutputPin for Flex<'d, T> {
+    impl<'d> embedded_hal_02::digital::v2::OutputPin for Flex<'d> {
         type Error = Infallible;
 
         fn set_high(&mut self) -> Result<(), Self::Error> {
@@ -1080,7 +1079,7 @@ mod eh02 {
         }
     }
 
-    impl<'d, T: Pin> embedded_hal_02::digital::v2::StatefulOutputPin for Flex<'d, T> {
+    impl<'d> embedded_hal_02::digital::v2::StatefulOutputPin for Flex<'d> {
         fn is_set_high(&self) -> Result<bool, Self::Error> {
             Ok(self.is_set_high())
         }
@@ -1090,7 +1089,7 @@ mod eh02 {
         }
     }
 
-    impl<'d, T: Pin> embedded_hal_02::digital::v2::ToggleableOutputPin for Flex<'d, T> {
+    impl<'d> embedded_hal_02::digital::v2::ToggleableOutputPin for Flex<'d> {
         type Error = Infallible;
         #[inline]
         fn toggle(&mut self) -> Result<(), Self::Error> {
@@ -1099,11 +1098,11 @@ mod eh02 {
     }
 }
 
-impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Input<'d, T> {
+impl<'d> embedded_hal_1::digital::ErrorType for Input<'d> {
     type Error = Infallible;
 }
 
-impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Input<'d, T> {
+impl<'d> embedded_hal_1::digital::InputPin for Input<'d> {
     fn is_high(&mut self) -> Result<bool, Self::Error> {
         Ok((*self).is_high())
     }
@@ -1113,11 +1112,11 @@ impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Input<'d, T> {
     }
 }
 
-impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Output<'d, T> {
+impl<'d> embedded_hal_1::digital::ErrorType for Output<'d> {
     type Error = Infallible;
 }
 
-impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Output<'d, T> {
+impl<'d> embedded_hal_1::digital::OutputPin for Output<'d> {
     fn set_high(&mut self) -> Result<(), Self::Error> {
         Ok(self.set_high())
     }
@@ -1127,7 +1126,7 @@ impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Output<'d, T> {
     }
 }
 
-impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Output<'d, T> {
+impl<'d> embedded_hal_1::digital::StatefulOutputPin for Output<'d> {
     fn is_set_high(&mut self) -> Result<bool, Self::Error> {
         Ok((*self).is_set_high())
     }
@@ -1137,11 +1136,11 @@ impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Output<'d, T> {
     }
 }
 
-impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for OutputOpenDrain<'d, T> {
+impl<'d> embedded_hal_1::digital::ErrorType for OutputOpenDrain<'d> {
     type Error = Infallible;
 }
 
-impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for OutputOpenDrain<'d, T> {
+impl<'d> embedded_hal_1::digital::OutputPin for OutputOpenDrain<'d> {
     fn set_high(&mut self) -> Result<(), Self::Error> {
         Ok(self.set_high())
     }
@@ -1151,7 +1150,7 @@ impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for OutputOpenDrain<'d, T> {
     }
 }
 
-impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for OutputOpenDrain<'d, T> {
+impl<'d> embedded_hal_1::digital::StatefulOutputPin for OutputOpenDrain<'d> {
     fn is_set_high(&mut self) -> Result<bool, Self::Error> {
         Ok((*self).is_set_high())
     }
@@ -1161,7 +1160,7 @@ impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for OutputOpenDrain<
     }
 }
 
-impl<'d, T: Pin> embedded_hal_1::digital::InputPin for OutputOpenDrain<'d, T> {
+impl<'d> embedded_hal_1::digital::InputPin for OutputOpenDrain<'d> {
     fn is_high(&mut self) -> Result<bool, Self::Error> {
         Ok((*self).is_high())
     }
@@ -1171,11 +1170,11 @@ impl<'d, T: Pin> embedded_hal_1::digital::InputPin for OutputOpenDrain<'d, T> {
     }
 }
 
-impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Flex<'d, T> {
+impl<'d> embedded_hal_1::digital::ErrorType for Flex<'d> {
     type Error = Infallible;
 }
 
-impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Flex<'d, T> {
+impl<'d> embedded_hal_1::digital::InputPin for Flex<'d> {
     fn is_high(&mut self) -> Result<bool, Self::Error> {
         Ok((*self).is_high())
     }
@@ -1185,7 +1184,7 @@ impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Flex<'d, T> {
     }
 }
 
-impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Flex<'d, T> {
+impl<'d> embedded_hal_1::digital::OutputPin for Flex<'d> {
     fn set_high(&mut self) -> Result<(), Self::Error> {
         Ok(self.set_high())
     }
@@ -1195,7 +1194,7 @@ impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Flex<'d, T> {
     }
 }
 
-impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Flex<'d, T> {
+impl<'d> embedded_hal_1::digital::StatefulOutputPin for Flex<'d> {
     fn is_set_high(&mut self) -> Result<bool, Self::Error> {
         Ok((*self).is_set_high())
     }
@@ -1205,7 +1204,7 @@ impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Flex<'d, T> {
     }
 }
 
-impl<'d, T: Pin> embedded_hal_async::digital::Wait for Flex<'d, T> {
+impl<'d> embedded_hal_async::digital::Wait for Flex<'d> {
     async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
         self.wait_for_high().await;
         Ok(())
@@ -1232,7 +1231,7 @@ impl<'d, T: Pin> embedded_hal_async::digital::Wait for Flex<'d, T> {
     }
 }
 
-impl<'d, T: Pin> embedded_hal_async::digital::Wait for Input<'d, T> {
+impl<'d> embedded_hal_async::digital::Wait for Input<'d> {
     async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
         self.wait_for_high().await;
         Ok(())
@@ -1259,7 +1258,7 @@ impl<'d, T: Pin> embedded_hal_async::digital::Wait for Input<'d, T> {
     }
 }
 
-impl<'d, T: Pin> embedded_hal_async::digital::Wait for OutputOpenDrain<'d, T> {
+impl<'d> embedded_hal_async::digital::Wait for OutputOpenDrain<'d> {
     async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
         self.wait_for_high().await;
         Ok(())