12 files changed, 560 insertions, 712 deletions

diff --git a/embassy-stm32/src/exti.rs b/embassy-stm32/src/exti.rs
index 07c63a2ef..dbd24804f 100644
--- a/embassy-stm32/src/exti.rs
+++ b/embassy-stm32/src/exti.rs
@@ -1,3 +1,4 @@
+use core::convert::Infallible;
 use core::future::Future;
 use core::marker::PhantomData;
 use core::pin::Pin;
@@ -137,74 +138,56 @@ impl<'d, T: GpioPin> ExtiInput<'d, T> {
     }
 }
 
-mod eh02 {
-    use core::convert::Infallible;
+impl<'d, T: GpioPin> embedded_hal_02::digital::v2::InputPin for ExtiInput<'d, T> {
+    type Error = Infallible;
 
-    use super::*;
-
-    impl<'d, T: GpioPin> embedded_hal_02::digital::v2::InputPin for ExtiInput<'d, T> {
-        type Error = Infallible;
-
-        fn is_high(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_high())
-        }
+    fn is_high(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_high())
+    }
 
-        fn is_low(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_low())
-        }
+    fn is_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_low())
     }
 }
 
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
-    use core::convert::Infallible;
-
-    use super::*;
+impl<'d, T: GpioPin> embedded_hal_1::digital::ErrorType for ExtiInput<'d, T> {
+    type Error = Infallible;
+}
 
-    impl<'d, T: GpioPin> embedded_hal_1::digital::ErrorType for ExtiInput<'d, T> {
-        type Error = Infallible;
+impl<'d, T: GpioPin> embedded_hal_1::digital::InputPin for ExtiInput<'d, T> {
+    fn is_high(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_high())
     }
 
-    impl<'d, T: GpioPin> embedded_hal_1::digital::InputPin for ExtiInput<'d, T> {
-        fn is_high(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_high())
-        }
-
-        fn is_low(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_low())
-        }
+    fn is_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_low())
     }
 }
-#[cfg(all(feature = "unstable-traits", feature = "nightly"))]
-mod eha {
 
-    use super::*;
-
-    impl<'d, T: GpioPin> embedded_hal_async::digital::Wait for ExtiInput<'d, T> {
-        async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
-            self.wait_for_high().await;
-            Ok(())
-        }
+impl<'d, T: GpioPin> embedded_hal_async::digital::Wait for ExtiInput<'d, T> {
+    async fn wait_for_high(&mut self) -> Result<(), Self::Error> {
+        self.wait_for_high().await;
+        Ok(())
+    }
 
-        async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
-            self.wait_for_low().await;
-            Ok(())
-        }
+    async fn wait_for_low(&mut self) -> Result<(), Self::Error> {
+        self.wait_for_low().await;
+        Ok(())
+    }
 
-        async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
-            self.wait_for_rising_edge().await;
-            Ok(())
-        }
+    async fn wait_for_rising_edge(&mut self) -> Result<(), Self::Error> {
+        self.wait_for_rising_edge().await;
+        Ok(())
+    }
 
-        async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
-            self.wait_for_falling_edge().await;
-            Ok(())
-        }
+    async fn wait_for_falling_edge(&mut self) -> Result<(), Self::Error> {
+        self.wait_for_falling_edge().await;
+        Ok(())
+    }
 
-        async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
-            self.wait_for_any_edge().await;
-            Ok(())
-        }
+    async fn wait_for_any_edge(&mut self) -> Result<(), Self::Error> {
+        self.wait_for_any_edge().await;
+        Ok(())
     }
 }
 
diff --git a/embassy-stm32/src/flash/asynch.rs b/embassy-stm32/src/flash/asynch.rs
index e966e2a77..eae40c7ec 100644
--- a/embassy-stm32/src/flash/asynch.rs
+++ b/embassy-stm32/src/flash/asynch.rs
@@ -55,7 +55,6 @@ impl interrupt::typelevel::Handler<crate::interrupt::typelevel::FLASH> for Inter
     }
 }
 
-#[cfg(feature = "nightly")]
 impl embedded_storage_async::nor_flash::ReadNorFlash for Flash<'_, Async> {
     const READ_SIZE: usize = super::READ_SIZE;
 
@@ -68,7 +67,6 @@ impl embedded_storage_async::nor_flash::ReadNorFlash for Flash<'_, Async> {
     }
 }
 
-#[cfg(feature = "nightly")]
 impl embedded_storage_async::nor_flash::NorFlash for Flash<'_, Async> {
     const WRITE_SIZE: usize = WRITE_SIZE;
     const ERASE_SIZE: usize = super::MAX_ERASE_SIZE;
@@ -158,8 +156,7 @@ foreach_flash_region! {
             }
         }
 
-        #[cfg(feature = "nightly")]
-        impl embedded_storage_async::nor_flash::ReadNorFlash for crate::_generated::flash_regions::$type_name<'_, Async> {
+                impl embedded_storage_async::nor_flash::ReadNorFlash for crate::_generated::flash_regions::$type_name<'_, Async> {
             const READ_SIZE: usize = super::READ_SIZE;
 
             async fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error> {
@@ -171,8 +168,7 @@ foreach_flash_region! {
             }
         }
 
-        #[cfg(feature = "nightly")]
-        impl embedded_storage_async::nor_flash::NorFlash for crate::_generated::flash_regions::$type_name<'_, Async> {
+                impl embedded_storage_async::nor_flash::NorFlash for crate::_generated::flash_regions::$type_name<'_, Async> {
             const WRITE_SIZE: usize = $write_size;
             const ERASE_SIZE: usize = $erase_size;
 
diff --git a/embassy-stm32/src/flash/f4.rs b/embassy-stm32/src/flash/f4.rs
index 3e5959ddb..5d07020ce 100644
--- a/embassy-stm32/src/flash/f4.rs
+++ b/embassy-stm32/src/flash/f4.rs
@@ -142,7 +142,6 @@ mod alt_regions {
                 }
             }
 
-            #[cfg(feature = "nightly")]
             impl embedded_storage_async::nor_flash::ReadNorFlash for $type_name<'_, Async> {
                 const READ_SIZE: usize = crate::flash::READ_SIZE;
 
@@ -155,7 +154,6 @@ mod alt_regions {
                 }
             }
 
-            #[cfg(feature = "nightly")]
             impl embedded_storage_async::nor_flash::NorFlash for $type_name<'_, Async> {
                 const WRITE_SIZE: usize = $region.write_size as usize;
                 const ERASE_SIZE: usize = $region.erase_size as usize;
diff --git a/embassy-stm32/src/gpio.rs b/embassy-stm32/src/gpio.rs
index 011f4c07a..b863c4ffe 100644
--- a/embassy-stm32/src/gpio.rs
+++ b/embassy-stm32/src/gpio.rs
@@ -772,306 +772,293 @@ pub(crate) unsafe fn init(_cs: CriticalSection) {
     });
 }
 
-mod eh02 {
-    use embedded_hal_02::digital::v2::{InputPin, OutputPin, StatefulOutputPin, ToggleableOutputPin};
+impl<'d, T: Pin> embedded_hal_02::digital::v2::InputPin for Input<'d, T> {
+    type Error = Infallible;
 
-    use super::*;
-
-    impl<'d, T: Pin> InputPin for Input<'d, T> {
-        type Error = Infallible;
-
-        #[inline]
-        fn is_high(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_high())
-        }
-
-        #[inline]
-        fn is_low(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_low())
-        }
+    #[inline]
+    fn is_high(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_high())
     }
 
-    impl<'d, T: Pin> OutputPin for Output<'d, T> {
-        type Error = Infallible;
-
-        #[inline]
-        fn set_high(&mut self) -> Result<(), Self::Error> {
-            self.set_high();
-            Ok(())
-        }
-
-        #[inline]
-        fn set_low(&mut self) -> Result<(), Self::Error> {
-            self.set_low();
-            Ok(())
-        }
+    #[inline]
+    fn is_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_low())
     }
+}
 
-    impl<'d, T: Pin> StatefulOutputPin for Output<'d, T> {
-        #[inline]
-        fn is_set_high(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_set_high())
-        }
+impl<'d, T: Pin> embedded_hal_02::digital::v2::OutputPin for Output<'d, T> {
+    type Error = Infallible;
 
-        /// Is the output pin set as low?
-        #[inline]
-        fn is_set_low(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_set_low())
-        }
+    #[inline]
+    fn set_high(&mut self) -> Result<(), Self::Error> {
+        self.set_high();
+        Ok(())
     }
 
-    impl<'d, T: Pin> ToggleableOutputPin for Output<'d, T> {
-        type Error = Infallible;
-        #[inline]
-        fn toggle(&mut self) -> Result<(), Self::Error> {
-            self.toggle();
-            Ok(())
-        }
+    #[inline]
+    fn set_low(&mut self) -> Result<(), Self::Error> {
+        self.set_low();
+        Ok(())
     }
+}
 
-    impl<'d, T: Pin> OutputPin for OutputOpenDrain<'d, T> {
-        type Error = Infallible;
+impl<'d, T: Pin> embedded_hal_02::digital::v2::StatefulOutputPin for Output<'d, T> {
+    #[inline]
+    fn is_set_high(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_set_high())
+    }
 
-        #[inline]
-        fn set_high(&mut self) -> Result<(), Self::Error> {
-            self.set_high();
-            Ok(())
-        }
+    /// Is the output pin set as low?
+    #[inline]
+    fn is_set_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_set_low())
+    }
+}
 
-        #[inline]
-        fn set_low(&mut self) -> Result<(), Self::Error> {
-            self.set_low();
-            Ok(())
-        }
+impl<'d, T: Pin> embedded_hal_02::digital::v2::ToggleableOutputPin for Output<'d, T> {
+    type Error = Infallible;
+    #[inline]
+    fn toggle(&mut self) -> Result<(), Self::Error> {
+        self.toggle();
+        Ok(())
     }
+}
 
-    impl<'d, T: Pin> StatefulOutputPin for OutputOpenDrain<'d, T> {
-        #[inline]
-        fn is_set_high(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_set_high())
-        }
+impl<'d, T: Pin> embedded_hal_02::digital::v2::OutputPin for OutputOpenDrain<'d, T> {
+    type Error = Infallible;
 
-        /// Is the output pin set as low?
-        #[inline]
-        fn is_set_low(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_set_low())
-        }
+    #[inline]
+    fn set_high(&mut self) -> Result<(), Self::Error> {
+        self.set_high();
+        Ok(())
     }
 
-    impl<'d, T: Pin> ToggleableOutputPin for OutputOpenDrain<'d, T> {
-        type Error = Infallible;
-        #[inline]
-        fn toggle(&mut self) -> Result<(), Self::Error> {
-            self.toggle();
-            Ok(())
-        }
+    #[inline]
+    fn set_low(&mut self) -> Result<(), Self::Error> {
+        self.set_low();
+        Ok(())
     }
+}
 
-    impl<'d, T: Pin> InputPin for Flex<'d, T> {
-        type Error = Infallible;
+impl<'d, T: Pin> embedded_hal_02::digital::v2::StatefulOutputPin for OutputOpenDrain<'d, T> {
+    #[inline]
+    fn is_set_high(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_set_high())
+    }
 
-        #[inline]
-        fn is_high(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_high())
-        }
+    /// Is the output pin set as low?
+    #[inline]
+    fn is_set_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_set_low())
+    }
+}
 
-        #[inline]
-        fn is_low(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_low())
-        }
+impl<'d, T: Pin> embedded_hal_02::digital::v2::ToggleableOutputPin for OutputOpenDrain<'d, T> {
+    type Error = Infallible;
+    #[inline]
+    fn toggle(&mut self) -> Result<(), Self::Error> {
+        self.toggle();
+        Ok(())
     }
+}
 
-    impl<'d, T: Pin> OutputPin for Flex<'d, T> {
-        type Error = Infallible;
+impl<'d, T: Pin> embedded_hal_02::digital::v2::InputPin for Flex<'d, T> {
+    type Error = Infallible;
 
-        #[inline]
-        fn set_high(&mut self) -> Result<(), Self::Error> {
-            self.set_high();
-            Ok(())
-        }
+    #[inline]
+    fn is_high(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_high())
+    }
 
-        #[inline]
-        fn set_low(&mut self) -> Result<(), Self::Error> {
-            self.set_low();
-            Ok(())
-        }
+    #[inline]
+    fn is_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_low())
     }
+}
 
-    impl<'d, T: Pin> StatefulOutputPin for Flex<'d, T> {
-        #[inline]
-        fn is_set_high(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_set_high())
-        }
+impl<'d, T: Pin> embedded_hal_02::digital::v2::OutputPin for Flex<'d, T> {
+    type Error = Infallible;
 
-        /// Is the output pin set as low?
-        #[inline]
-        fn is_set_low(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_set_low())
-        }
+    #[inline]
+    fn set_high(&mut self) -> Result<(), Self::Error> {
+        self.set_high();
+        Ok(())
     }
 
-    impl<'d, T: Pin> ToggleableOutputPin for Flex<'d, T> {
-        type Error = Infallible;
-        #[inline]
-        fn toggle(&mut self) -> Result<(), Self::Error> {
-            self.toggle();
-            Ok(())
-        }
+    #[inline]
+    fn set_low(&mut self) -> Result<(), Self::Error> {
+        self.set_low();
+        Ok(())
     }
 }
 
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
-    use embedded_hal_1::digital::{ErrorType, InputPin, OutputPin, StatefulOutputPin, ToggleableOutputPin};
+impl<'d, T: Pin> embedded_hal_02::digital::v2::StatefulOutputPin for Flex<'d, T> {
+    #[inline]
+    fn is_set_high(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_set_high())
+    }
 
-    use super::*;
+    /// Is the output pin set as low?
+    #[inline]
+    fn is_set_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_set_low())
+    }
+}
 
-    impl<'d, T: Pin> ErrorType for Input<'d, T> {
-        type Error = Infallible;
+impl<'d, T: Pin> embedded_hal_02::digital::v2::ToggleableOutputPin for Flex<'d, T> {
+    type Error = Infallible;
+    #[inline]
+    fn toggle(&mut self) -> Result<(), Self::Error> {
+        self.toggle();
+        Ok(())
     }
+}
 
-    impl<'d, T: Pin> InputPin for Input<'d, T> {
-        #[inline]
-        fn is_high(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_high())
-        }
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Input<'d, T> {
+    type Error = Infallible;
+}
 
-        #[inline]
-        fn is_low(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_low())
-        }
+impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Input<'d, T> {
+    #[inline]
+    fn is_high(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_high())
     }
 
-    impl<'d, T: Pin> ErrorType for Output<'d, T> {
-        type Error = Infallible;
+    #[inline]
+    fn is_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_low())
     }
+}
 
-    impl<'d, T: Pin> OutputPin for Output<'d, T> {
-        #[inline]
-        fn set_high(&mut self) -> Result<(), Self::Error> {
-            Ok(self.set_high())
-        }
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Output<'d, T> {
+    type Error = Infallible;
+}
 
-        #[inline]
-        fn set_low(&mut self) -> Result<(), Self::Error> {
-            Ok(self.set_low())
-        }
+impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Output<'d, T> {
+    #[inline]
+    fn set_high(&mut self) -> Result<(), Self::Error> {
+        Ok(self.set_high())
     }
 
-    impl<'d, T: Pin> StatefulOutputPin for Output<'d, T> {
-        #[inline]
-        fn is_set_high(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_set_high())
-        }
+    #[inline]
+    fn set_low(&mut self) -> Result<(), Self::Error> {
+        Ok(self.set_low())
+    }
+}
 
-        /// Is the output pin set as low?
-        #[inline]
-        fn is_set_low(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_set_low())
-        }
+impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Output<'d, T> {
+    #[inline]
+    fn is_set_high(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_set_high())
     }
 
-    impl<'d, T: Pin> ToggleableOutputPin for Output<'d, T> {
-        #[inline]
-        fn toggle(&mut self) -> Result<(), Self::Error> {
-            Ok(self.toggle())
-        }
+    /// Is the output pin set as low?
+    #[inline]
+    fn is_set_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_set_low())
     }
+}
 
-    impl<'d, T: Pin> ErrorType for OutputOpenDrain<'d, T> {
-        type Error = Infallible;
+impl<'d, T: Pin> embedded_hal_1::digital::ToggleableOutputPin for Output<'d, T> {
+    #[inline]
+    fn toggle(&mut self) -> Result<(), Self::Error> {
+        Ok(self.toggle())
     }
+}
 
-    impl<'d, T: Pin> InputPin for OutputOpenDrain<'d, T> {
-        #[inline]
-        fn is_high(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_high())
-        }
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for OutputOpenDrain<'d, T> {
+    type Error = Infallible;
+}
 
-        #[inline]
-        fn is_low(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_low())
-        }
+impl<'d, T: Pin> embedded_hal_1::digital::InputPin for OutputOpenDrain<'d, T> {
+    #[inline]
+    fn is_high(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_high())
     }
 
-    impl<'d, T: Pin> OutputPin for OutputOpenDrain<'d, T> {
-        #[inline]
-        fn set_high(&mut self) -> Result<(), Self::Error> {
-            Ok(self.set_high())
-        }
+    #[inline]
+    fn is_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_low())
+    }
+}
 
-        #[inline]
-        fn set_low(&mut self) -> Result<(), Self::Error> {
-            Ok(self.set_low())
-        }
+impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for OutputOpenDrain<'d, T> {
+    #[inline]
+    fn set_high(&mut self) -> Result<(), Self::Error> {
+        Ok(self.set_high())
     }
 
-    impl<'d, T: Pin> StatefulOutputPin for OutputOpenDrain<'d, T> {
-        #[inline]
-        fn is_set_high(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_set_high())
-        }
+    #[inline]
+    fn set_low(&mut self) -> Result<(), Self::Error> {
+        Ok(self.set_low())
+    }
+}
 
-        /// Is the output pin set as low?
-        #[inline]
-        fn is_set_low(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_set_low())
-        }
+impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for OutputOpenDrain<'d, T> {
+    #[inline]
+    fn is_set_high(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_set_high())
     }
 
-    impl<'d, T: Pin> ToggleableOutputPin for OutputOpenDrain<'d, T> {
-        #[inline]
-        fn toggle(&mut self) -> Result<(), Self::Error> {
-            Ok(self.toggle())
-        }
+    /// Is the output pin set as low?
+    #[inline]
+    fn is_set_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_set_low())
     }
+}
 
-    impl<'d, T: Pin> InputPin for Flex<'d, T> {
-        #[inline]
-        fn is_high(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_high())
-        }
+impl<'d, T: Pin> embedded_hal_1::digital::ToggleableOutputPin for OutputOpenDrain<'d, T> {
+    #[inline]
+    fn toggle(&mut self) -> Result<(), Self::Error> {
+        Ok(self.toggle())
+    }
+}
 
-        #[inline]
-        fn is_low(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_low())
-        }
+impl<'d, T: Pin> embedded_hal_1::digital::InputPin for Flex<'d, T> {
+    #[inline]
+    fn is_high(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_high())
     }
 
-    impl<'d, T: Pin> OutputPin for Flex<'d, T> {
-        #[inline]
-        fn set_high(&mut self) -> Result<(), Self::Error> {
-            Ok(self.set_high())
-        }
+    #[inline]
+    fn is_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_low())
+    }
+}
 
-        #[inline]
-        fn set_low(&mut self) -> Result<(), Self::Error> {
-            Ok(self.set_low())
-        }
+impl<'d, T: Pin> embedded_hal_1::digital::OutputPin for Flex<'d, T> {
+    #[inline]
+    fn set_high(&mut self) -> Result<(), Self::Error> {
+        Ok(self.set_high())
     }
 
-    impl<'d, T: Pin> ToggleableOutputPin for Flex<'d, T> {
-        #[inline]
-        fn toggle(&mut self) -> Result<(), Self::Error> {
-            Ok(self.toggle())
-        }
+    #[inline]
+    fn set_low(&mut self) -> Result<(), Self::Error> {
+        Ok(self.set_low())
     }
+}
 
-    impl<'d, T: Pin> ErrorType for Flex<'d, T> {
-        type Error = Infallible;
+impl<'d, T: Pin> embedded_hal_1::digital::ToggleableOutputPin for Flex<'d, T> {
+    #[inline]
+    fn toggle(&mut self) -> Result<(), Self::Error> {
+        Ok(self.toggle())
     }
+}
 
-    impl<'d, T: Pin> StatefulOutputPin for Flex<'d, T> {
-        #[inline]
-        fn is_set_high(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_set_high())
-        }
+impl<'d, T: Pin> embedded_hal_1::digital::ErrorType for Flex<'d, T> {
+    type Error = Infallible;
+}
 
-        /// Is the output pin set as low?
-        #[inline]
-        fn is_set_low(&self) -> Result<bool, Self::Error> {
-            Ok(self.is_set_low())
-        }
+impl<'d, T: Pin> embedded_hal_1::digital::StatefulOutputPin for Flex<'d, T> {
+    #[inline]
+    fn is_set_high(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_set_high())
+    }
+
+    /// Is the output pin set as low?
+    #[inline]
+    fn is_set_low(&self) -> Result<bool, Self::Error> {
+        Ok(self.is_set_low())
     }
 }
 
diff --git a/embassy-stm32/src/i2c/mod.rs b/embassy-stm32/src/i2c/mod.rs
index 19346d707..d2a50cf7e 100644
--- a/embassy-stm32/src/i2c/mod.rs
+++ b/embassy-stm32/src/i2c/mod.rs
@@ -2,6 +2,7 @@
 
 use core::marker::PhantomData;
 
+use crate::dma::NoDma;
 use crate::interrupt;
 
 #[cfg_attr(i2c_v1, path = "v1.rs")]
@@ -97,107 +98,92 @@ foreach_peripheral!(
     };
 );
 
-mod eh02 {
-    use super::*;
-
-    impl<'d, T: Instance> embedded_hal_02::blocking::i2c::Read for I2c<'d, T> {
-        type Error = Error;
+impl<'d, T: Instance> embedded_hal_02::blocking::i2c::Read for I2c<'d, T> {
+    type Error = Error;
 
-        fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
-            self.blocking_read(address, buffer)
-        }
+    fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
+        self.blocking_read(address, buffer)
     }
+}
 
-    impl<'d, T: Instance> embedded_hal_02::blocking::i2c::Write for I2c<'d, T> {
-        type Error = Error;
+impl<'d, T: Instance> embedded_hal_02::blocking::i2c::Write for I2c<'d, T> {
+    type Error = Error;
 
-        fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
-            self.blocking_write(address, write)
-        }
+    fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
+        self.blocking_write(address, write)
     }
+}
 
-    impl<'d, T: Instance> embedded_hal_02::blocking::i2c::WriteRead for I2c<'d, T> {
-        type Error = Error;
+impl<'d, T: Instance> embedded_hal_02::blocking::i2c::WriteRead for I2c<'d, T> {
+    type Error = Error;
 
-        fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
-            self.blocking_write_read(address, write, read)
-        }
+    fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
+        self.blocking_write_read(address, write, read)
     }
 }
 
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
-    use super::*;
-    use crate::dma::NoDma;
-
-    impl embedded_hal_1::i2c::Error for Error {
-        fn kind(&self) -> embedded_hal_1::i2c::ErrorKind {
-            match *self {
-                Self::Bus => embedded_hal_1::i2c::ErrorKind::Bus,
-                Self::Arbitration => embedded_hal_1::i2c::ErrorKind::ArbitrationLoss,
-                Self::Nack => {
-                    embedded_hal_1::i2c::ErrorKind::NoAcknowledge(embedded_hal_1::i2c::NoAcknowledgeSource::Unknown)
-                }
-                Self::Timeout => embedded_hal_1::i2c::ErrorKind::Other,
-                Self::Crc => embedded_hal_1::i2c::ErrorKind::Other,
-                Self::Overrun => embedded_hal_1::i2c::ErrorKind::Overrun,
-                Self::ZeroLengthTransfer => embedded_hal_1::i2c::ErrorKind::Other,
+impl embedded_hal_1::i2c::Error for Error {
+    fn kind(&self) -> embedded_hal_1::i2c::ErrorKind {
+        match *self {
+            Self::Bus => embedded_hal_1::i2c::ErrorKind::Bus,
+            Self::Arbitration => embedded_hal_1::i2c::ErrorKind::ArbitrationLoss,
+            Self::Nack => {
+                embedded_hal_1::i2c::ErrorKind::NoAcknowledge(embedded_hal_1::i2c::NoAcknowledgeSource::Unknown)
             }
+            Self::Timeout => embedded_hal_1::i2c::ErrorKind::Other,
+            Self::Crc => embedded_hal_1::i2c::ErrorKind::Other,
+            Self::Overrun => embedded_hal_1::i2c::ErrorKind::Overrun,
+            Self::ZeroLengthTransfer => embedded_hal_1::i2c::ErrorKind::Other,
         }
     }
+}
 
-    impl<'d, T: Instance, TXDMA, RXDMA> embedded_hal_1::i2c::ErrorType for I2c<'d, T, TXDMA, RXDMA> {
-        type Error = Error;
-    }
+impl<'d, T: Instance, TXDMA, RXDMA> embedded_hal_1::i2c::ErrorType for I2c<'d, T, TXDMA, RXDMA> {
+    type Error = Error;
+}
 
-    impl<'d, T: Instance> embedded_hal_1::i2c::I2c for I2c<'d, T, NoDma, NoDma> {
-        fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
-            self.blocking_read(address, read)
-        }
+impl<'d, T: Instance> embedded_hal_1::i2c::I2c for I2c<'d, T, NoDma, NoDma> {
+    fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
+        self.blocking_read(address, read)
+    }
 
-        fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
-            self.blocking_write(address, write)
-        }
+    fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
+        self.blocking_write(address, write)
+    }
 
-        fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
-            self.blocking_write_read(address, write, read)
-        }
+    fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
+        self.blocking_write_read(address, write, read)
+    }
 
-        fn transaction(
-            &mut self,
-            _address: u8,
-            _operations: &mut [embedded_hal_1::i2c::Operation<'_>],
-        ) -> Result<(), Self::Error> {
-            todo!();
-        }
+    fn transaction(
+        &mut self,
+        _address: u8,
+        _operations: &mut [embedded_hal_1::i2c::Operation<'_>],
+    ) -> Result<(), Self::Error> {
+        todo!();
     }
 }
 
-#[cfg(all(feature = "unstable-traits", feature = "nightly"))]
-mod eha {
-    use super::*;
-
-    impl<'d, T: Instance, TXDMA: TxDma<T>, RXDMA: RxDma<T>> embedded_hal_async::i2c::I2c for I2c<'d, T, TXDMA, RXDMA> {
-        async fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
-            self.read(address, read).await
-        }
+impl<'d, T: Instance, TXDMA: TxDma<T>, RXDMA: RxDma<T>> embedded_hal_async::i2c::I2c for I2c<'d, T, TXDMA, RXDMA> {
+    async fn read(&mut self, address: u8, read: &mut [u8]) -> Result<(), Self::Error> {
+        self.read(address, read).await
+    }
 
-        async fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
-            self.write(address, write).await
-        }
+    async fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Self::Error> {
+        self.write(address, write).await
+    }
 
-        async fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
-            self.write_read(address, write, read).await
-        }
+    async fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Self::Error> {
+        self.write_read(address, write, read).await
+    }
 
-        async fn transaction(
-            &mut self,
-            address: u8,
-            operations: &mut [embedded_hal_1::i2c::Operation<'_>],
-        ) -> Result<(), Self::Error> {
-            let _ = address;
-            let _ = operations;
-            todo!()
-        }
+    async fn transaction(
+        &mut self,
+        address: u8,
+        operations: &mut [embedded_hal_1::i2c::Operation<'_>],
+    ) -> Result<(), Self::Error> {
+        let _ = address;
+        let _ = operations;
+        todo!()
     }
 }
diff --git a/embassy-stm32/src/lib.rs b/embassy-stm32/src/lib.rs
index 511da9179..7ce801a0a 100644
--- a/embassy-stm32/src/lib.rs
+++ b/embassy-stm32/src/lib.rs
@@ -1,6 +1,5 @@
 #![cfg_attr(not(test), no_std)]
-#![cfg_attr(feature = "nightly", feature(async_fn_in_trait, impl_trait_projections))]
-#![cfg_attr(feature = "nightly", allow(stable_features, unknown_lints, async_fn_in_trait))]
+#![allow(async_fn_in_trait)]
 
 //! ## Feature flags
 #![doc = document_features::document_features!(feature_label = r#"<span class="stab portability"><code>{feature}</code></span>"#)]
diff --git a/embassy-stm32/src/spi/mod.rs b/embassy-stm32/src/spi/mod.rs
index c391e0a5a..92599c75e 100644
--- a/embassy-stm32/src/spi/mod.rs
+++ b/embassy-stm32/src/spi/mod.rs
@@ -848,102 +848,88 @@ fn transfer_word<W: Word>(regs: Regs, tx_word: W) -> Result<W, Error> {
     Ok(rx_word)
 }
 
-mod eh02 {
-    use super::*;
-
-    // Note: It is not possible to impl these traits generically in embedded-hal 0.2 due to a conflict with
-    // some marker traits. For details, see https://github.com/rust-embedded/embedded-hal/pull/289
-    macro_rules! impl_blocking {
-        ($w:ident) => {
-            impl<'d, T: Instance, Tx, Rx> embedded_hal_02::blocking::spi::Write<$w> for Spi<'d, T, Tx, Rx> {
-                type Error = Error;
-
-                fn write(&mut self, words: &[$w]) -> Result<(), Self::Error> {
-                    self.blocking_write(words)
-                }
+// Note: It is not possible to impl these traits generically in embedded-hal 0.2 due to a conflict with
+// some marker traits. For details, see https://github.com/rust-embedded/embedded-hal/pull/289
+macro_rules! impl_blocking {
+    ($w:ident) => {
+        impl<'d, T: Instance, Tx, Rx> embedded_hal_02::blocking::spi::Write<$w> for Spi<'d, T, Tx, Rx> {
+            type Error = Error;
+
+            fn write(&mut self, words: &[$w]) -> Result<(), Self::Error> {
+                self.blocking_write(words)
             }
+        }
 
-            impl<'d, T: Instance, Tx, Rx> embedded_hal_02::blocking::spi::Transfer<$w> for Spi<'d, T, Tx, Rx> {
-                type Error = Error;
+        impl<'d, T: Instance, Tx, Rx> embedded_hal_02::blocking::spi::Transfer<$w> for Spi<'d, T, Tx, Rx> {
+            type Error = Error;
 
-                fn transfer<'w>(&mut self, words: &'w mut [$w]) -> Result<&'w [$w], Self::Error> {
-                    self.blocking_transfer_in_place(words)?;
-                    Ok(words)
-                }
+            fn transfer<'w>(&mut self, words: &'w mut [$w]) -> Result<&'w [$w], Self::Error> {
+                self.blocking_transfer_in_place(words)?;
+                Ok(words)
             }
-        };
-    }
-
-    impl_blocking!(u8);
-    impl_blocking!(u16);
+        }
+    };
 }
 
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
-    use super::*;
+impl_blocking!(u8);
+impl_blocking!(u16);
 
-    impl<'d, T: Instance, Tx, Rx> embedded_hal_1::spi::ErrorType for Spi<'d, T, Tx, Rx> {
-        type Error = Error;
-    }
+impl<'d, T: Instance, Tx, Rx> embedded_hal_1::spi::ErrorType for Spi<'d, T, Tx, Rx> {
+    type Error = Error;
+}
 
-    impl<'d, T: Instance, W: Word, Tx, Rx> embedded_hal_1::spi::SpiBus<W> for Spi<'d, T, Tx, Rx> {
-        fn flush(&mut self) -> Result<(), Self::Error> {
-            Ok(())
-        }
+impl<'d, T: Instance, W: Word, Tx, Rx> embedded_hal_1::spi::SpiBus<W> for Spi<'d, T, Tx, Rx> {
+    fn flush(&mut self) -> Result<(), Self::Error> {
+        Ok(())
+    }
 
-        fn read(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
-            self.blocking_read(words)
-        }
+    fn read(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
+        self.blocking_read(words)
+    }
 
-        fn write(&mut self, words: &[W]) -> Result<(), Self::Error> {
-            self.blocking_write(words)
-        }
+    fn write(&mut self, words: &[W]) -> Result<(), Self::Error> {
+        self.blocking_write(words)
+    }
 
-        fn transfer(&mut self, read: &mut [W], write: &[W]) -> Result<(), Self::Error> {
-            self.blocking_transfer(read, write)
-        }
+    fn transfer(&mut self, read: &mut [W], write: &[W]) -> Result<(), Self::Error> {
+        self.blocking_transfer(read, write)
+    }
 
-        fn transfer_in_place(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
-            self.blocking_transfer_in_place(words)
-        }
+    fn transfer_in_place(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
+        self.blocking_transfer_in_place(words)
     }
+}
 
-    impl embedded_hal_1::spi::Error for Error {
-        fn kind(&self) -> embedded_hal_1::spi::ErrorKind {
-            match *self {
-                Self::Framing => embedded_hal_1::spi::ErrorKind::FrameFormat,
-                Self::Crc => embedded_hal_1::spi::ErrorKind::Other,
-                Self::ModeFault => embedded_hal_1::spi::ErrorKind::ModeFault,
-                Self::Overrun => embedded_hal_1::spi::ErrorKind::Overrun,
-            }
+impl embedded_hal_1::spi::Error for Error {
+    fn kind(&self) -> embedded_hal_1::spi::ErrorKind {
+        match *self {
+            Self::Framing => embedded_hal_1::spi::ErrorKind::FrameFormat,
+            Self::Crc => embedded_hal_1::spi::ErrorKind::Other,
+            Self::ModeFault => embedded_hal_1::spi::ErrorKind::ModeFault,
+            Self::Overrun => embedded_hal_1::spi::ErrorKind::Overrun,
         }
     }
 }
 
-#[cfg(all(feature = "unstable-traits", feature = "nightly"))]
-mod eha {
-    use super::*;
-
-    impl<'d, T: Instance, Tx: TxDma<T>, Rx: RxDma<T>, W: Word> embedded_hal_async::spi::SpiBus<W> for Spi<'d, T, Tx, Rx> {
-        async fn flush(&mut self) -> Result<(), Self::Error> {
-            Ok(())
-        }
+impl<'d, T: Instance, Tx: TxDma<T>, Rx: RxDma<T>, W: Word> embedded_hal_async::spi::SpiBus<W> for Spi<'d, T, Tx, Rx> {
+    async fn flush(&mut self) -> Result<(), Self::Error> {
+        Ok(())
+    }
 
-        async fn write(&mut self, words: &[W]) -> Result<(), Self::Error> {
-            self.write(words).await
-        }
+    async fn write(&mut self, words: &[W]) -> Result<(), Self::Error> {
+        self.write(words).await
+    }
 
-        async fn read(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
-            self.read(words).await
-        }
+    async fn read(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
+        self.read(words).await
+    }
 
-        async fn transfer(&mut self, read: &mut [W], write: &[W]) -> Result<(), Self::Error> {
-            self.transfer(read, write).await
-        }
+    async fn transfer(&mut self, read: &mut [W], write: &[W]) -> Result<(), Self::Error> {
+        self.transfer(read, write).await
+    }
 
-        async fn transfer_in_place(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
-            self.transfer_in_place(words).await
-        }
+    async fn transfer_in_place(&mut self, words: &mut [W]) -> Result<(), Self::Error> {
+        self.transfer_in_place(words).await
     }
 }
 
diff --git a/embassy-stm32/src/usart/buffered.rs b/embassy-stm32/src/usart/buffered.rs
index 4daddfe91..a2e4ceaae 100644
--- a/embassy-stm32/src/usart/buffered.rs
+++ b/embassy-stm32/src/usart/buffered.rs
@@ -560,172 +560,120 @@ impl<'d, T: BasicInstance> embedded_io::Write for BufferedUartTx<'d, T> {
     }
 }
 
-mod eh02 {
-    use super::*;
-
-    impl<'d, T: BasicInstance> embedded_hal_02::serial::Read<u8> for BufferedUartRx<'d, T> {
-        type Error = Error;
-
-        fn read(&mut self) -> Result<u8, nb::Error<Self::Error>> {
-            let r = T::regs();
-            unsafe {
-                let sr = sr(r).read();
-                if sr.pe() {
-                    rdr(r).read_volatile();
-                    Err(nb::Error::Other(Error::Parity))
-                } else if sr.fe() {
-                    rdr(r).read_volatile();
-                    Err(nb::Error::Other(Error::Framing))
-                } else if sr.ne() {
-                    rdr(r).read_volatile();
-                    Err(nb::Error::Other(Error::Noise))
-                } else if sr.ore() {
-                    rdr(r).read_volatile();
-                    Err(nb::Error::Other(Error::Overrun))
-                } else if sr.rxne() {
-                    Ok(rdr(r).read_volatile())
-                } else {
-                    Err(nb::Error::WouldBlock)
-                }
+impl<'d, T: BasicInstance> embedded_hal_02::serial::Read<u8> for BufferedUartRx<'d, T> {
+    type Error = Error;
+
+    fn read(&mut self) -> Result<u8, nb::Error<Self::Error>> {
+        let r = T::regs();
+        unsafe {
+            let sr = sr(r).read();
+            if sr.pe() {
+                rdr(r).read_volatile();
+                Err(nb::Error::Other(Error::Parity))
+            } else if sr.fe() {
+                rdr(r).read_volatile();
+                Err(nb::Error::Other(Error::Framing))
+            } else if sr.ne() {
+                rdr(r).read_volatile();
+                Err(nb::Error::Other(Error::Noise))
+            } else if sr.ore() {
+                rdr(r).read_volatile();
+                Err(nb::Error::Other(Error::Overrun))
+            } else if sr.rxne() {
+                Ok(rdr(r).read_volatile())
+            } else {
+                Err(nb::Error::WouldBlock)
             }
         }
     }
+}
 
-    impl<'d, T: BasicInstance> embedded_hal_02::blocking::serial::Write<u8> for BufferedUartTx<'d, T> {
-        type Error = Error;
+impl<'d, T: BasicInstance> embedded_hal_02::blocking::serial::Write<u8> for BufferedUartTx<'d, T> {
+    type Error = Error;
 
-        fn bwrite_all(&mut self, mut buffer: &[u8]) -> Result<(), Self::Error> {
-            while !buffer.is_empty() {
-                match self.blocking_write(buffer) {
-                    Ok(0) => panic!("zero-length write."),
-                    Ok(n) => buffer = &buffer[n..],
-                    Err(e) => return Err(e),
-                }
+    fn bwrite_all(&mut self, mut buffer: &[u8]) -> Result<(), Self::Error> {
+        while !buffer.is_empty() {
+            match self.blocking_write(buffer) {
+                Ok(0) => panic!("zero-length write."),
+                Ok(n) => buffer = &buffer[n..],
+                Err(e) => return Err(e),
             }
-            Ok(())
-        }
-
-        fn bflush(&mut self) -> Result<(), Self::Error> {
-            self.blocking_flush()
         }
+        Ok(())
     }
 
-    impl<'d, T: BasicInstance> embedded_hal_02::serial::Read<u8> for BufferedUart<'d, T> {
-        type Error = Error;
-
-        fn read(&mut self) -> Result<u8, nb::Error<Self::Error>> {
-            embedded_hal_02::serial::Read::read(&mut self.rx)
-        }
+    fn bflush(&mut self) -> Result<(), Self::Error> {
+        self.blocking_flush()
     }
+}
 
-    impl<'d, T: BasicInstance> embedded_hal_02::blocking::serial::Write<u8> for BufferedUart<'d, T> {
-        type Error = Error;
-
-        fn bwrite_all(&mut self, mut buffer: &[u8]) -> Result<(), Self::Error> {
-            while !buffer.is_empty() {
-                match self.tx.blocking_write(buffer) {
-                    Ok(0) => panic!("zero-length write."),
-                    Ok(n) => buffer = &buffer[n..],
-                    Err(e) => return Err(e),
-                }
-            }
-            Ok(())
-        }
+impl<'d, T: BasicInstance> embedded_hal_02::serial::Read<u8> for BufferedUart<'d, T> {
+    type Error = Error;
 
-        fn bflush(&mut self) -> Result<(), Self::Error> {
-            self.tx.blocking_flush()
-        }
+    fn read(&mut self) -> Result<u8, nb::Error<Self::Error>> {
+        embedded_hal_02::serial::Read::read(&mut self.rx)
     }
 }
 
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
-    use super::*;
+impl<'d, T: BasicInstance> embedded_hal_02::blocking::serial::Write<u8> for BufferedUart<'d, T> {
+    type Error = Error;
 
-    impl<'d, T: BasicInstance> embedded_hal_nb::serial::ErrorType for BufferedUart<'d, T> {
-        type Error = Error;
+    fn bwrite_all(&mut self, mut buffer: &[u8]) -> Result<(), Self::Error> {
+        while !buffer.is_empty() {
+            match self.tx.blocking_write(buffer) {
+                Ok(0) => panic!("zero-length write."),
+                Ok(n) => buffer = &buffer[n..],
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(())
     }
 
-    impl<'d, T: BasicInstance> embedded_hal_nb::serial::ErrorType for BufferedUartTx<'d, T> {
-        type Error = Error;
+    fn bflush(&mut self) -> Result<(), Self::Error> {
+        self.tx.blocking_flush()
     }
+}
 
-    impl<'d, T: BasicInstance> embedded_hal_nb::serial::ErrorType for BufferedUartRx<'d, T> {
-        type Error = Error;
-    }
+impl<'d, T: BasicInstance> embedded_hal_nb::serial::ErrorType for BufferedUart<'d, T> {
+    type Error = Error;
+}
 
-    impl<'d, T: BasicInstance> embedded_hal_nb::serial::Read for BufferedUartRx<'d, T> {
-        fn read(&mut self) -> nb::Result<u8, Self::Error> {
-            embedded_hal_02::serial::Read::read(self)
-        }
-    }
+impl<'d, T: BasicInstance> embedded_hal_nb::serial::ErrorType for BufferedUartTx<'d, T> {
+    type Error = Error;
+}
 
-    impl<'d, T: BasicInstance> embedded_hal_nb::serial::Write for BufferedUartTx<'d, T> {
-        fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
-            self.blocking_write(&[char]).map(drop).map_err(nb::Error::Other)
-        }
+impl<'d, T: BasicInstance> embedded_hal_nb::serial::ErrorType for BufferedUartRx<'d, T> {
+    type Error = Error;
+}
 
-        fn flush(&mut self) -> nb::Result<(), Self::Error> {
-            self.blocking_flush().map_err(nb::Error::Other)
-        }
+impl<'d, T: BasicInstance> embedded_hal_nb::serial::Read for BufferedUartRx<'d, T> {
+    fn read(&mut self) -> nb::Result<u8, Self::Error> {
+        embedded_hal_02::serial::Read::read(self)
     }
+}
 
-    impl<'d, T: BasicInstance> embedded_hal_nb::serial::Read for BufferedUart<'d, T> {
-        fn read(&mut self) -> Result<u8, nb::Error<Self::Error>> {
-            embedded_hal_02::serial::Read::read(&mut self.rx)
-        }
+impl<'d, T: BasicInstance> embedded_hal_nb::serial::Write for BufferedUartTx<'d, T> {
+    fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
+        self.blocking_write(&[char]).map(drop).map_err(nb::Error::Other)
     }
 
-    impl<'d, T: BasicInstance> embedded_hal_nb::serial::Write for BufferedUart<'d, T> {
-        fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
-            self.tx.blocking_write(&[char]).map(drop).map_err(nb::Error::Other)
-        }
-
-        fn flush(&mut self) -> nb::Result<(), Self::Error> {
-            self.tx.blocking_flush().map_err(nb::Error::Other)
-        }
+    fn flush(&mut self) -> nb::Result<(), Self::Error> {
+        self.blocking_flush().map_err(nb::Error::Other)
     }
 }
 
-#[cfg(all(
-    feature = "unstable-traits",
-    feature = "nightly",
-    feature = "_todo_embedded_hal_serial"
-))]
-mod eha {
-    use core::future::Future;
-
-    use super::*;
-
-    impl<'d, T: BasicInstance> embedded_hal_async::serial::Write for BufferedUartTx<'d, T> {
-        async fn write(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
-            Self::write(buf)
-        }
-
-        async fn flush(&mut self) -> Result<(), Self::Error> {
-            Self::flush()
-        }
-    }
-
-    impl<'d, T: BasicInstance> embedded_hal_async::serial::Read for BufferedUartRx<'d, T> {
-        async fn read(&mut self, buf: &mut [u8]) -> Result<(), Self::Error> {
-            Self::read(buf)
-        }
+impl<'d, T: BasicInstance> embedded_hal_nb::serial::Read for BufferedUart<'d, T> {
+    fn read(&mut self) -> Result<u8, nb::Error<Self::Error>> {
+        embedded_hal_02::serial::Read::read(&mut self.rx)
     }
+}
 
-    impl<'d, T: BasicInstance> embedded_hal_async::serial::Write for BufferedUart<'d, T> {
-        async fn write(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
-            self.tx.write(buf)
-        }
-
-        async fn flush(&mut self) -> Result<(), Self::Error> {
-            self.tx.flush()
-        }
+impl<'d, T: BasicInstance> embedded_hal_nb::serial::Write for BufferedUart<'d, T> {
+    fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
+        self.tx.blocking_write(&[char]).map(drop).map_err(nb::Error::Other)
     }
 
-    impl<'d, T: BasicInstance> embedded_hal_async::serial::Read for BufferedUart<'d, T> {
-        async fn read(&mut self, buf: &mut [u8]) -> Result<(), Self::Error> {
-            self.rx.read(buf)
-        }
+    fn flush(&mut self) -> nb::Result<(), Self::Error> {
+        self.tx.blocking_flush().map_err(nb::Error::Other)
     }
 }
diff --git a/embassy-stm32/src/usart/mod.rs b/embassy-stm32/src/usart/mod.rs
index ea127e7f7..d5828a492 100644
--- a/embassy-stm32/src/usart/mod.rs
+++ b/embassy-stm32/src/usart/mod.rs
@@ -1010,102 +1010,93 @@ fn configure(
     Ok(())
 }
 
-mod eh02 {
-    use super::*;
+impl<'d, T: BasicInstance, RxDma> embedded_hal_02::serial::Read<u8> for UartRx<'d, T, RxDma> {
+    type Error = Error;
+    fn read(&mut self) -> Result<u8, nb::Error<Self::Error>> {
+        self.nb_read()
+    }
+}
 
-    impl<'d, T: BasicInstance, RxDma> embedded_hal_02::serial::Read<u8> for UartRx<'d, T, RxDma> {
-        type Error = Error;
-        fn read(&mut self) -> Result<u8, nb::Error<Self::Error>> {
-            self.nb_read()
-        }
+impl<'d, T: BasicInstance, TxDma> embedded_hal_02::blocking::serial::Write<u8> for UartTx<'d, T, TxDma> {
+    type Error = Error;
+    fn bwrite_all(&mut self, buffer: &[u8]) -> Result<(), Self::Error> {
+        self.blocking_write(buffer)
+    }
+    fn bflush(&mut self) -> Result<(), Self::Error> {
+        self.blocking_flush()
     }
+}
 
-    impl<'d, T: BasicInstance, TxDma> embedded_hal_02::blocking::serial::Write<u8> for UartTx<'d, T, TxDma> {
-        type Error = Error;
-        fn bwrite_all(&mut self, buffer: &[u8]) -> Result<(), Self::Error> {
-            self.blocking_write(buffer)
-        }
-        fn bflush(&mut self) -> Result<(), Self::Error> {
-            self.blocking_flush()
-        }
+impl<'d, T: BasicInstance, TxDma, RxDma> embedded_hal_02::serial::Read<u8> for Uart<'d, T, TxDma, RxDma> {
+    type Error = Error;
+    fn read(&mut self) -> Result<u8, nb::Error<Self::Error>> {
+        self.nb_read()
     }
+}
 
-    impl<'d, T: BasicInstance, TxDma, RxDma> embedded_hal_02::serial::Read<u8> for Uart<'d, T, TxDma, RxDma> {
-        type Error = Error;
-        fn read(&mut self) -> Result<u8, nb::Error<Self::Error>> {
-            self.nb_read()
-        }
+impl<'d, T: BasicInstance, TxDma, RxDma> embedded_hal_02::blocking::serial::Write<u8> for Uart<'d, T, TxDma, RxDma> {
+    type Error = Error;
+    fn bwrite_all(&mut self, buffer: &[u8]) -> Result<(), Self::Error> {
+        self.blocking_write(buffer)
+    }
+    fn bflush(&mut self) -> Result<(), Self::Error> {
+        self.blocking_flush()
     }
+}
 
-    impl<'d, T: BasicInstance, TxDma, RxDma> embedded_hal_02::blocking::serial::Write<u8> for Uart<'d, T, TxDma, RxDma> {
-        type Error = Error;
-        fn bwrite_all(&mut self, buffer: &[u8]) -> Result<(), Self::Error> {
-            self.blocking_write(buffer)
-        }
-        fn bflush(&mut self) -> Result<(), Self::Error> {
-            self.blocking_flush()
+impl embedded_hal_nb::serial::Error for Error {
+    fn kind(&self) -> embedded_hal_nb::serial::ErrorKind {
+        match *self {
+            Self::Framing => embedded_hal_nb::serial::ErrorKind::FrameFormat,
+            Self::Noise => embedded_hal_nb::serial::ErrorKind::Noise,
+            Self::Overrun => embedded_hal_nb::serial::ErrorKind::Overrun,
+            Self::Parity => embedded_hal_nb::serial::ErrorKind::Parity,
+            Self::BufferTooLong => embedded_hal_nb::serial::ErrorKind::Other,
         }
     }
 }
 
-#[cfg(feature = "unstable-traits")]
-mod eh1 {
-    use super::*;
+impl<'d, T: BasicInstance, TxDma, RxDma> embedded_hal_nb::serial::ErrorType for Uart<'d, T, TxDma, RxDma> {
+    type Error = Error;
+}
 
-    impl embedded_hal_nb::serial::Error for Error {
-        fn kind(&self) -> embedded_hal_nb::serial::ErrorKind {
-            match *self {
-                Self::Framing => embedded_hal_nb::serial::ErrorKind::FrameFormat,
-                Self::Noise => embedded_hal_nb::serial::ErrorKind::Noise,
-                Self::Overrun => embedded_hal_nb::serial::ErrorKind::Overrun,
-                Self::Parity => embedded_hal_nb::serial::ErrorKind::Parity,
-                Self::BufferTooLong => embedded_hal_nb::serial::ErrorKind::Other,
-            }
-        }
-    }
+impl<'d, T: BasicInstance, TxDma> embedded_hal_nb::serial::ErrorType for UartTx<'d, T, TxDma> {
+    type Error = Error;
+}
 
-    impl<'d, T: BasicInstance, TxDma, RxDma> embedded_hal_nb::serial::ErrorType for Uart<'d, T, TxDma, RxDma> {
-        type Error = Error;
-    }
+impl<'d, T: BasicInstance, RxDma> embedded_hal_nb::serial::ErrorType for UartRx<'d, T, RxDma> {
+    type Error = Error;
+}
 
-    impl<'d, T: BasicInstance, TxDma> embedded_hal_nb::serial::ErrorType for UartTx<'d, T, TxDma> {
-        type Error = Error;
+impl<'d, T: BasicInstance, RxDma> embedded_hal_nb::serial::Read for UartRx<'d, T, RxDma> {
+    fn read(&mut self) -> nb::Result<u8, Self::Error> {
+        self.nb_read()
     }
+}
 
-    impl<'d, T: BasicInstance, RxDma> embedded_hal_nb::serial::ErrorType for UartRx<'d, T, RxDma> {
-        type Error = Error;
+impl<'d, T: BasicInstance, TxDma> embedded_hal_nb::serial::Write for UartTx<'d, T, TxDma> {
+    fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
+        self.blocking_write(&[char]).map_err(nb::Error::Other)
     }
 
-    impl<'d, T: BasicInstance, RxDma> embedded_hal_nb::serial::Read for UartRx<'d, T, RxDma> {
-        fn read(&mut self) -> nb::Result<u8, Self::Error> {
-            self.nb_read()
-        }
+    fn flush(&mut self) -> nb::Result<(), Self::Error> {
+        self.blocking_flush().map_err(nb::Error::Other)
     }
+}
 
-    impl<'d, T: BasicInstance, TxDma> embedded_hal_nb::serial::Write for UartTx<'d, T, TxDma> {
-        fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
-            self.blocking_write(&[char]).map_err(nb::Error::Other)
-        }
-
-        fn flush(&mut self) -> nb::Result<(), Self::Error> {
-            self.blocking_flush().map_err(nb::Error::Other)
-        }
+impl<'d, T: BasicInstance, TxDma, RxDma> embedded_hal_nb::serial::Read for Uart<'d, T, TxDma, RxDma> {
+    fn read(&mut self) -> Result<u8, nb::Error<Self::Error>> {
+        self.nb_read()
     }
+}
 
-    impl<'d, T: BasicInstance, TxDma, RxDma> embedded_hal_nb::serial::Read for Uart<'d, T, TxDma, RxDma> {
-        fn read(&mut self) -> Result<u8, nb::Error<Self::Error>> {
-            self.nb_read()
-        }
+impl<'d, T: BasicInstance, TxDma, RxDma> embedded_hal_nb::serial::Write for Uart<'d, T, TxDma, RxDma> {
+    fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
+        self.blocking_write(&[char]).map_err(nb::Error::Other)
     }
 
-    impl<'d, T: BasicInstance, TxDma, RxDma> embedded_hal_nb::serial::Write for Uart<'d, T, TxDma, RxDma> {
-        fn write(&mut self, char: u8) -> nb::Result<(), Self::Error> {
-            self.blocking_write(&[char]).map_err(nb::Error::Other)
-        }
-
-        fn flush(&mut self) -> nb::Result<(), Self::Error> {
-            self.blocking_flush().map_err(nb::Error::Other)
-        }
+    fn flush(&mut self) -> nb::Result<(), Self::Error> {
+        self.blocking_flush().map_err(nb::Error::Other)
     }
 }
 
@@ -1159,47 +1150,39 @@ where
     }
 }
 
-#[cfg(all(feature = "unstable-traits", feature = "nightly"))]
-mod eio {
-    use super::*;
-
-    impl<T, TxDma, RxDma> embedded_io_async::Write for Uart<'_, T, TxDma, RxDma>
-    where
-        T: BasicInstance,
-        TxDma: super::TxDma<T>,
-    {
-        async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
-            self.write(buf).await?;
-            Ok(buf.len())
-        }
+impl<T, TxDma, RxDma> embedded_io_async::Write for Uart<'_, T, TxDma, RxDma>
+where
+    T: BasicInstance,
+    TxDma: self::TxDma<T>,
+{
+    async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+        self.write(buf).await?;
+        Ok(buf.len())
+    }
 
-        async fn flush(&mut self) -> Result<(), Self::Error> {
-            self.blocking_flush()
-        }
+    async fn flush(&mut self) -> Result<(), Self::Error> {
+        self.blocking_flush()
     }
+}
 
-    impl<T, TxDma> embedded_io_async::Write for UartTx<'_, T, TxDma>
-    where
-        T: BasicInstance,
-        TxDma: super::TxDma<T>,
-    {
-        async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
-            self.write(buf).await?;
-            Ok(buf.len())
-        }
+impl<T, TxDma> embedded_io_async::Write for UartTx<'_, T, TxDma>
+where
+    T: BasicInstance,
+    TxDma: self::TxDma<T>,
+{
+    async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+        self.write(buf).await?;
+        Ok(buf.len())
+    }
 
-        async fn flush(&mut self) -> Result<(), Self::Error> {
-            self.blocking_flush()
-        }
+    async fn flush(&mut self) -> Result<(), Self::Error> {
+        self.blocking_flush()
     }
 }
 
-#[cfg(feature = "nightly")]
 pub use buffered::*;
 
-#[cfg(feature = "nightly")]
 pub use crate::usart::buffered::InterruptHandler as BufferedInterruptHandler;
-#[cfg(feature = "nightly")]
 mod buffered;
 
 #[cfg(not(gpdma))]
@@ -1284,7 +1267,6 @@ pub(crate) mod sealed {
         fn regs() -> Regs;
         fn state() -> &'static State;
 
-        #[cfg(feature = "nightly")]
         fn buffered_state() -> &'static buffered::State;
     }
 
@@ -1322,7 +1304,6 @@ macro_rules! impl_usart {
                 &STATE
             }
 
-            #[cfg(feature = "nightly")]
             fn buffered_state() -> &'static buffered::State {
                 static STATE: buffered::State = buffered::State::new();
                 &STATE
diff --git a/embassy-stm32/src/usart/ringbuffered.rs b/embassy-stm32/src/usart/ringbuffered.rs
index eceabbe9a..b8d17e4e4 100644
--- a/embassy-stm32/src/usart/ringbuffered.rs
+++ b/embassy-stm32/src/usart/ringbuffered.rs
@@ -7,7 +7,7 @@ use embassy_embedded_hal::SetConfig;
 use embassy_hal_internal::PeripheralRef;
 use futures::future::{select, Either};
 
-use super::{clear_interrupt_flags, rdr, reconfigure, sr, BasicInstance, Config, ConfigError, Error, UartRx};
+use super::{clear_interrupt_flags, rdr, reconfigure, sr, BasicInstance, Config, ConfigError, Error, RxDma, UartRx};
 use crate::dma::ReadableRingBuffer;
 use crate::usart::{Regs, Sr};
 
@@ -240,28 +240,20 @@ fn clear_idle_flag(r: Regs) -> Sr {
     sr
 }
 
-#[cfg(all(feature = "unstable-traits", feature = "nightly"))]
-mod eio {
-    use embedded_io_async::{ErrorType, Read};
-
-    use super::RingBufferedUartRx;
-    use crate::usart::{BasicInstance, Error, RxDma};
-
-    impl<T, Rx> ErrorType for RingBufferedUartRx<'_, T, Rx>
-    where
-        T: BasicInstance,
-        Rx: RxDma<T>,
-    {
-        type Error = Error;
-    }
+impl<T, Rx> embedded_io_async::ErrorType for RingBufferedUartRx<'_, T, Rx>
+where
+    T: BasicInstance,
+    Rx: RxDma<T>,
+{
+    type Error = Error;
+}
 
-    impl<T, Rx> Read for RingBufferedUartRx<'_, T, Rx>
-    where
-        T: BasicInstance,
-        Rx: RxDma<T>,
-    {
-        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
-            self.read(buf).await
-        }
+impl<T, Rx> embedded_io_async::Read for RingBufferedUartRx<'_, T, Rx>
+where
+    T: BasicInstance,
+    Rx: RxDma<T>,
+{
+    async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+        self.read(buf).await
     }
 }
diff --git a/embassy-stm32/src/usb/mod.rs b/embassy-stm32/src/usb/mod.rs
index bee287fe6..d0b289462 100644
--- a/embassy-stm32/src/usb/mod.rs
+++ b/embassy-stm32/src/usb/mod.rs
@@ -1,9 +1,7 @@
 use crate::interrupt;
 use crate::rcc::RccPeripheral;
 
-#[cfg(feature = "nightly")]
 mod usb;
-#[cfg(feature = "nightly")]
 pub use usb::*;
 
 pub(crate) mod sealed {
diff --git a/embassy-stm32/src/usb_otg/mod.rs b/embassy-stm32/src/usb_otg/mod.rs
index 12e5f0e60..be54a3d10 100644
--- a/embassy-stm32/src/usb_otg/mod.rs
+++ b/embassy-stm32/src/usb_otg/mod.rs
@@ -1,13 +1,10 @@
 use crate::rcc::RccPeripheral;
 use crate::{interrupt, peripherals};
 
-#[cfg(feature = "nightly")]
 mod usb;
-#[cfg(feature = "nightly")]
 pub use usb::*;
 
 // Using Instance::ENDPOINT_COUNT requires feature(const_generic_expr) so just define maximum eps
-#[cfg(feature = "nightly")]
 const MAX_EP_COUNT: usize = 9;
 
 pub(crate) mod sealed {
@@ -17,7 +14,6 @@ pub(crate) mod sealed {
         const ENDPOINT_COUNT: usize;
 
         fn regs() -> crate::pac::otg::Otg;
-        #[cfg(feature = "nightly")]
         fn state() -> &'static super::State<{ super::MAX_EP_COUNT }>;
     }
 }
@@ -99,8 +95,7 @@ foreach_interrupt!(
                 crate::pac::USB_OTG_FS
             }
 
-            #[cfg(feature = "nightly")]
-            fn state() -> &'static State<MAX_EP_COUNT> {
+                        fn state() -> &'static State<MAX_EP_COUNT> {
                 static STATE: State<MAX_EP_COUNT> = State::new();
                 &STATE
             }
@@ -151,8 +146,7 @@ foreach_interrupt!(
                 unsafe { crate::pac::otg::Otg::from_ptr(crate::pac::USB_OTG_HS.as_ptr()) }
             }
 
-            #[cfg(feature = "nightly")]
-            fn state() -> &'static State<MAX_EP_COUNT> {
+                        fn state() -> &'static State<MAX_EP_COUNT> {
                 static STATE: State<MAX_EP_COUNT> = State::new();
                 &STATE
             }