From 4d6b3c57b1a0b99409cae743a102408f23ca828b Mon Sep 17 00:00:00 2001
From: pennae <github@quasiparticle.net>
Date: Thu, 20 Jul 2023 16:08:59 +0200
Subject: rp: fix multicore stack guard setup

the region field of the register is four bits wide followed by the valid
bit that causes the rnr update we rely on for the rasr write. 0x08 is
just a bit short to reach the valid bit, and since rp2040 has only 8
regions it (at best) doesn't do anything at all.
---
 embassy-rp/src/multicore.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/embassy-rp/src/multicore.rs b/embassy-rp/src/multicore.rs
index 468e8470a..89a2680ad 100644
--- a/embassy-rp/src/multicore.rs
+++ b/embassy-rp/src/multicore.rs
@@ -74,7 +74,7 @@ fn install_stack_guard(stack_bottom: *mut usize) {
     let subregion_select = 0xff ^ (1 << ((addr >> 5) & 7));
     unsafe {
         core.MPU.ctrl.write(5); // enable mpu with background default map
-        core.MPU.rbar.write((addr & !0xff) | 0x8);
+        core.MPU.rbar.write((addr & !0xff) | (1 << 4)); // set address and update RNR
         core.MPU.rasr.write(
             1 // enable region
                | (0x7 << 1) // size 2^(7 + 1) = 256
-- 
cgit 


From e9445ec72d8713aa7705e0a727c13c259d529e71 Mon Sep 17 00:00:00 2001
From: pennae <github@quasiparticle.net>
Date: Thu, 20 Jul 2023 16:57:54 +0200
Subject: rp: allow for MPU-based stack guards on core 0 as well

using these will require some linker script intervention. setting the
core0 stack needs linker intervention anyway (to provide _stack_start),
having it also provide _stack_end for the guard to use is not that much
of a stretch.
---
 embassy-rp/src/lib.rs       | 68 +++++++++++++++++++++++++++++++++++++++++++++
 embassy-rp/src/multicore.rs | 33 ++++------------------
 2 files changed, 74 insertions(+), 27 deletions(-)

diff --git a/embassy-rp/src/lib.rs b/embassy-rp/src/lib.rs
index 4f205a16e..50f028d4c 100644
--- a/embassy-rp/src/lib.rs
+++ b/embassy-rp/src/lib.rs
@@ -219,6 +219,74 @@ select_bootloader! {
     default => BOOT_LOADER_W25Q080
 }
 
+/// Installs a stack guard for the CORE0 stack in MPU region 0.
+/// Will fail if the MPU is already confgigured. This function requires
+/// a `_stack_end` symbol to be defined by the linker script, and expexcts
+/// `_stack_end` to be located at the lowest address (largest depth) of
+/// the stack.
+///
+/// This method can *only* set up stack guards on the currently
+/// executing core. Stack guards for CORE1 are set up automatically,
+/// only CORE0 should ever use this.
+///
+/// # Usage
+///
+/// ```no_run
+/// #![feature(type_alias_impl_trait)]
+/// use embassy_rp::install_core0_stack_guard;
+/// use embassy_executor::{Executor, Spawner};
+///
+/// #[embassy_executor::main]
+/// async fn main(_spawner: Spawner) {
+///     // set up by the linker as follows:
+///     //
+///     //     MEMORY {
+///     //       STACK0: ORIGIN = 0x20040000, LENGTH = 4K
+///     //     }
+///     //
+///     //     _stack_end = ORIGIN(STACK0);
+///     //     _stack_start = _stack_end + LENGTH(STACK0);
+///     //
+///     install_core0_stack_guard().expect("MPU already configured");
+///     let p = embassy_rp::init(Default::default());
+///
+///     // ...
+/// }
+/// ```
+pub fn install_core0_stack_guard() -> Result<(), ()> {
+    extern "C" {
+        static mut _stack_end: usize;
+    }
+    unsafe { install_stack_guard(&mut _stack_end as *mut usize) }
+}
+
+#[inline(always)]
+fn install_stack_guard(stack_bottom: *mut usize) -> Result<(), ()> {
+    let core = unsafe { cortex_m::Peripherals::steal() };
+
+    // Fail if MPU is already configured
+    if core.MPU.ctrl.read() != 0 {
+        return Err(());
+    }
+
+    // The minimum we can protect is 32 bytes on a 32 byte boundary, so round up which will
+    // just shorten the valid stack range a tad.
+    let addr = (stack_bottom as u32 + 31) & !31;
+    // Mask is 1 bit per 32 bytes of the 256 byte range... clear the bit for the segment we want
+    let subregion_select = 0xff ^ (1 << ((addr >> 5) & 7));
+    unsafe {
+        core.MPU.ctrl.write(5); // enable mpu with background default map
+        core.MPU.rbar.write((addr & !0xff) | (1 << 4)); // set address and update RNR
+        core.MPU.rasr.write(
+            1 // enable region
+               | (0x7 << 1) // size 2^(7 + 1) = 256
+               | (subregion_select << 8)
+               | 0x10000000, // XN = disable instruction fetch; no other bits means no permissions
+        );
+    }
+    Ok(())
+}
+
 pub mod config {
     use crate::clocks::ClockConfig;
 
diff --git a/embassy-rp/src/multicore.rs b/embassy-rp/src/multicore.rs
index 89a2680ad..915761801 100644
--- a/embassy-rp/src/multicore.rs
+++ b/embassy-rp/src/multicore.rs
@@ -52,41 +52,20 @@ use core::sync::atomic::{compiler_fence, AtomicBool, Ordering};
 
 use crate::interrupt::InterruptExt;
 use crate::peripherals::CORE1;
-use crate::{gpio, interrupt, pac};
+use crate::{gpio, install_stack_guard, interrupt, pac};
 
 const PAUSE_TOKEN: u32 = 0xDEADBEEF;
 const RESUME_TOKEN: u32 = !0xDEADBEEF;
 static IS_CORE1_INIT: AtomicBool = AtomicBool::new(false);
 
 #[inline(always)]
-fn install_stack_guard(stack_bottom: *mut usize) {
-    let core = unsafe { cortex_m::Peripherals::steal() };
-
-    // Trap if MPU is already configured
-    if core.MPU.ctrl.read() != 0 {
+fn core1_setup(stack_bottom: *mut usize) {
+    if let Err(_) = install_stack_guard(stack_bottom) {
+        // currently only happens if the MPU was already set up, which
+        // would indicate that the core is already in use from outside
+        // embassy, somehow. trap if so since we can't deal with that.
         cortex_m::asm::udf();
     }
-
-    // The minimum we can protect is 32 bytes on a 32 byte boundary, so round up which will
-    // just shorten the valid stack range a tad.
-    let addr = (stack_bottom as u32 + 31) & !31;
-    // Mask is 1 bit per 32 bytes of the 256 byte range... clear the bit for the segment we want
-    let subregion_select = 0xff ^ (1 << ((addr >> 5) & 7));
-    unsafe {
-        core.MPU.ctrl.write(5); // enable mpu with background default map
-        core.MPU.rbar.write((addr & !0xff) | (1 << 4)); // set address and update RNR
-        core.MPU.rasr.write(
-            1 // enable region
-               | (0x7 << 1) // size 2^(7 + 1) = 256
-               | (subregion_select << 8)
-               | 0x10000000, // XN = disable instruction fetch; no other bits means no permissions
-        );
-    }
-}
-
-#[inline(always)]
-fn core1_setup(stack_bottom: *mut usize) {
-    install_stack_guard(stack_bottom);
     unsafe {
         gpio::init();
     }
-- 
cgit 


From c83552eadcf7546acf8bf4de47d7d9243ffe56d0 Mon Sep 17 00:00:00 2001
From: Adam Greig <adam@adamgreig.com>
Date: Sat, 22 Jul 2023 12:45:18 +0100
Subject: stm32: fix DAC examples

The DAC driver defaults to enabling the channel trigger, but leaves it
at the default value of TIM6 TRGO, then performs a software trigger
after writing the new output value. We could change the trigger
selection to software trigger, but for this example it's simpler to just
disable the trigger.
---
 examples/stm32f4/src/bin/dac.rs | 2 +-
 examples/stm32h7/src/bin/dac.rs | 2 +-
 examples/stm32l4/src/bin/dac.rs | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/examples/stm32f4/src/bin/dac.rs b/examples/stm32f4/src/bin/dac.rs
index 3a6216712..aaedcfecc 100644
--- a/examples/stm32f4/src/bin/dac.rs
+++ b/examples/stm32f4/src/bin/dac.rs
@@ -14,11 +14,11 @@ async fn main(_spawner: Spawner) -> ! {
     info!("Hello World, dude!");
 
     let mut dac = DacCh1::new(p.DAC, NoDma, p.PA4);
+    unwrap!(dac.set_trigger_enable(false));
 
     loop {
         for v in 0..=255 {
             unwrap!(dac.set(Value::Bit8(to_sine_wave(v))));
-            dac.trigger();
         }
     }
 }
diff --git a/examples/stm32h7/src/bin/dac.rs b/examples/stm32h7/src/bin/dac.rs
index 586b4154b..ee078286b 100644
--- a/examples/stm32h7/src/bin/dac.rs
+++ b/examples/stm32h7/src/bin/dac.rs
@@ -21,11 +21,11 @@ fn main() -> ! {
     let p = embassy_stm32::init(config);
 
     let mut dac = DacCh1::new(p.DAC1, NoDma, p.PA4);
+    unwrap!(dac.set_trigger_enable(false));
 
     loop {
         for v in 0..=255 {
             unwrap!(dac.set(Value::Bit8(to_sine_wave(v))));
-            dac.trigger();
         }
     }
 }
diff --git a/examples/stm32l4/src/bin/dac.rs b/examples/stm32l4/src/bin/dac.rs
index ade43eb35..0193a248e 100644
--- a/examples/stm32l4/src/bin/dac.rs
+++ b/examples/stm32l4/src/bin/dac.rs
@@ -13,11 +13,11 @@ fn main() -> ! {
     info!("Hello World!");
 
     let mut dac = DacCh1::new(p.DAC1, NoDma, p.PA4);
+    unwrap!(dac.set_trigger_enable(false));
 
     loop {
         for v in 0..=255 {
             unwrap!(dac.set(Value::Bit8(to_sine_wave(v))));
-            dac.trigger();
         }
     }
 }
-- 
cgit 


From e5b4641f9ee1b181a16028b84131083e0247d4d5 Mon Sep 17 00:00:00 2001
From: Adam Greig <adam@adamgreig.com>
Date: Sat, 22 Jul 2023 12:47:17 +0100
Subject: stm32/dac: set pin mode to analog (ref #334)

---
 embassy-stm32/src/dac/mod.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/embassy-stm32/src/dac/mod.rs b/embassy-stm32/src/dac/mod.rs
index 31a2d8863..3dee242ef 100644
--- a/embassy-stm32/src/dac/mod.rs
+++ b/embassy-stm32/src/dac/mod.rs
@@ -213,8 +213,9 @@ impl<'d, T: Instance, Tx> DacCh1<'d, T, Tx> {
     pub fn new(
         peri: impl Peripheral<P = T> + 'd,
         dma: impl Peripheral<P = Tx> + 'd,
-        _pin: impl Peripheral<P = impl DacPin<T, 1>> + 'd,
+        pin: impl Peripheral<P = impl DacPin<T, 1>> + crate::gpio::sealed::Pin + 'd,
     ) -> Self {
+        pin.set_as_analog();
         into_ref!(peri, dma);
         T::enable();
         T::reset();
@@ -324,8 +325,9 @@ impl<'d, T: Instance, Tx> DacCh2<'d, T, Tx> {
     pub fn new(
         _peri: impl Peripheral<P = T> + 'd,
         dma: impl Peripheral<P = Tx> + 'd,
-        _pin: impl Peripheral<P = impl DacPin<T, 2>> + 'd,
+        pin: impl Peripheral<P = impl DacPin<T, 2>> + crate::gpio::sealed::Pin + 'd,
     ) -> Self {
+        pin.set_as_analog();
         into_ref!(_peri, dma);
         T::enable();
         T::reset();
@@ -439,9 +441,11 @@ impl<'d, T: Instance, TxCh1, TxCh2> Dac<'d, T, TxCh1, TxCh2> {
         peri: impl Peripheral<P = T> + 'd,
         dma_ch1: impl Peripheral<P = TxCh1> + 'd,
         dma_ch2: impl Peripheral<P = TxCh2> + 'd,
-        _pin_ch1: impl Peripheral<P = impl DacPin<T, 1>> + 'd,
-        _pin_ch2: impl Peripheral<P = impl DacPin<T, 2>> + 'd,
+        pin_ch1: impl Peripheral<P = impl DacPin<T, 1>> + crate::gpio::sealed::Pin + 'd,
+        pin_ch2: impl Peripheral<P = impl DacPin<T, 2>> + crate::gpio::sealed::Pin + 'd,
     ) -> Self {
+        pin_ch1.set_as_analog();
+        pin_ch2.set_as_analog();
         into_ref!(peri, dma_ch1, dma_ch2);
         T::enable();
         T::reset();
-- 
cgit 


From 224fbc8125de73e08c0fe03df6d3980001f77c7f Mon Sep 17 00:00:00 2001
From: Adam Greig <adam@adamgreig.com>
Date: Sat, 22 Jul 2023 13:17:40 +0100
Subject: stm32: remove duplicate features from stm32f4 examples Cargo.toml

---
 examples/stm32f4/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/stm32f4/Cargo.toml b/examples/stm32f4/Cargo.toml
index c1c821364..a7e60b7bb 100644
--- a/examples/stm32f4/Cargo.toml
+++ b/examples/stm32f4/Cargo.toml
@@ -6,7 +6,7 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
-embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "executor-interrupt", "defmt", "integrated-timers", "arch-cortex-m", "executor-thread", "executor-interrupt"] }
+embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "executor-interrupt", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "unstable-traits", "tick-hz-32_768"] }
 embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "unstable-traits", "defmt", "stm32f429zi", "unstable-pac", "memory-x", "time-driver-any", "exti", "embedded-sdmmc", "chrono"]  }
 embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"] }
-- 
cgit 


From 80ce6d1fb7eeb4617c2d10468e136a5013d71ac3 Mon Sep 17 00:00:00 2001
From: JuliDi <20155974+JuliDi@users.noreply.github.com>
Date: Sat, 22 Jul 2023 19:25:02 +0200
Subject: update DAC triggers to incorporate v3

---
 embassy-stm32/Cargo.toml     |  4 ++--
 embassy-stm32/src/dac/mod.rs | 49 ++++++++++++++++++++++++++++++++++++++------
 embassy-stm32/src/dma/dma.rs | 19 +++++++++++++++--
 3 files changed, 62 insertions(+), 10 deletions(-)

diff --git a/embassy-stm32/Cargo.toml b/embassy-stm32/Cargo.toml
index ec934e8be..0fb6fdb56 100644
--- a/embassy-stm32/Cargo.toml
+++ b/embassy-stm32/Cargo.toml
@@ -57,7 +57,7 @@ sdio-host = "0.5.0"
 embedded-sdmmc = { git = "https://github.com/embassy-rs/embedded-sdmmc-rs", rev = "a4f293d3a6f72158385f79c98634cb8a14d0d2fc", optional = true }
 critical-section = "1.1"
 atomic-polyfill = "1.0.1"
-stm32-metapac = "12"
+stm32-metapac = "13"
 vcell = "0.1.3"
 bxcan = "0.7.0"
 nb = "1.0.0"
@@ -74,7 +74,7 @@ critical-section = { version = "1.1", features = ["std"] }
 [build-dependencies]
 proc-macro2 = "1.0.36"
 quote = "1.0.15"
-stm32-metapac = { version = "12", default-features = false, features = ["metadata"]}
+stm32-metapac = { version = "13", default-features = false, features = ["metadata"]}
 
 [features]
 default = ["rt"]
diff --git a/embassy-stm32/src/dac/mod.rs b/embassy-stm32/src/dac/mod.rs
index 3dee242ef..6712585cf 100644
--- a/embassy-stm32/src/dac/mod.rs
+++ b/embassy-stm32/src/dac/mod.rs
@@ -38,11 +38,30 @@ impl Channel {
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 /// Trigger sources for CH1
 pub enum Ch1Trigger {
-    Tim6,
+    #[cfg(dac_v3)]
+    Tim1,
+    Tim2,
+    #[cfg(not(dac_v2))]
     Tim3,
+    #[cfg(dac_v3)]
+    Tim4,
+    #[cfg(dac_v3)]
+    Tim5,
+    Tim6,
     Tim7,
+    #[cfg(dac_v3)]
+    Tim8,
     Tim15,
-    Tim2,
+    #[cfg(dac_v3)]
+    Hrtim1Dactrg1,
+    #[cfg(dac_v3)]
+    Hrtim1Dactrg2,
+    #[cfg(dac_v3)]
+    Lptim1,
+    #[cfg(dac_v3)]
+    Lptim2,
+    #[cfg(dac_v3)]
+    Lptim3,
     Exti9,
     Software,
 }
@@ -50,11 +69,30 @@ pub enum Ch1Trigger {
 impl Ch1Trigger {
     fn tsel(&self) -> dac::vals::Tsel1 {
         match self {
-            Ch1Trigger::Tim6 => dac::vals::Tsel1::TIM6_TRGO,
+            #[cfg(dac_v3)]
+            Ch1Trigger::Tim1 => dac::vals::Tsel1::TIM1_TRGO,
+            Ch1Trigger::Tim2 => dac::vals::Tsel1::TIM2_TRGO,
+            #[cfg(dac_v2)]
             Ch1Trigger::Tim3 => dac::vals::Tsel1::TIM3_TRGO,
+            #[cfg(dac_v3)]
+            Ch1Trigger::Tim4 => dac::vals::Tsel1::TIM4_TRGO,
+            #[cfg(dac_v3)]
+            Ch1Trigger::Tim5 => dac::vals::Tsel1::TIM5_TRGO,
+            Ch1Trigger::Tim6 => dac::vals::Tsel1::TIM6_TRGO,
             Ch1Trigger::Tim7 => dac::vals::Tsel1::TIM7_TRGO,
+            #[cfg(dac_v3)]
+            Ch1Trigger::Tim8 => dac::vals::Tsel1::TIM8_TRGO,
             Ch1Trigger::Tim15 => dac::vals::Tsel1::TIM15_TRGO,
-            Ch1Trigger::Tim2 => dac::vals::Tsel1::TIM2_TRGO,
+            #[cfg(dac_v3)]
+            Ch1Trigger::Hrtim1Dactrg1 => dac::vals::Tsel1::HRTIM1_DACTRG1,
+            #[cfg(dac_v3)]
+            Ch1Trigger::Hrtim1Dactrg2 => dac::vals::Tsel1::HRTIM1_DACTRG2,
+            #[cfg(dac_v3)]
+            Ch1Trigger::Lptim1 => dac::vals::Tsel1::LPTIM1_OUT,
+            #[cfg(dac_v3)]
+            Ch1Trigger::Lptim2 => dac::vals::Tsel1::LPTIM2_OUT,
+            #[cfg(dac_v3)]
+            Ch1Trigger::Lptim3 => dac::vals::Tsel1::LPTIM3_OUT,
             Ch1Trigger::Exti9 => dac::vals::Tsel1::EXTI9,
             Ch1Trigger::Software => dac::vals::Tsel1::SOFTWARE,
         }
@@ -363,7 +401,6 @@ impl<'d, T: Instance, Tx> DacCh2<'d, T, Tx> {
     /// Note that for performance reasons in circular mode the transfer complete interrupt is disabled.
     ///
     /// **Important:** Channel 2 has to be configured for the DAC instance!
-    #[cfg(all(bdma, not(dma)))] // It currently only works with BDMA-only chips (DMA should theoretically work though)
     pub async fn write(&mut self, data: ValueArray<'_>, circular: bool) -> Result<(), Error>
     where
         Tx: DmaCh2<T>,
@@ -467,7 +504,7 @@ impl<'d, T: Instance, TxCh1, TxCh2> Dac<'d, T, TxCh1, TxCh2> {
         dac_ch1.enable_channel().unwrap();
         dac_ch1.set_trigger_enable(true).unwrap();
 
-        #[cfg(dac_v2)]
+        #[cfg(any(dac_v2, dac_v3))]
         dac_ch2.set_channel_mode(0).unwrap();
         dac_ch2.enable_channel().unwrap();
         dac_ch2.set_trigger_enable(true).unwrap();
diff --git a/embassy-stm32/src/dma/dma.rs b/embassy-stm32/src/dma/dma.rs
index 58d438af8..f14084599 100644
--- a/embassy-stm32/src/dma/dma.rs
+++ b/embassy-stm32/src/dma/dma.rs
@@ -28,6 +28,12 @@ pub struct TransferOptions {
     pub flow_ctrl: FlowControl,
     /// FIFO threshold for DMA FIFO mode. If none, direct mode is used.
     pub fifo_threshold: Option<FifoThreshold>,
+    /// Enable circular DMA
+    pub circular: bool,
+    /// Enable half transfer interrupt
+    pub half_transfer_ir: bool,
+    /// Enable transfer complete interrupt
+    pub complete_transfer_ir: bool,
 }
 
 impl Default for TransferOptions {
@@ -37,6 +43,9 @@ impl Default for TransferOptions {
             mburst: Burst::Single,
             flow_ctrl: FlowControl::Dma,
             fifo_threshold: None,
+            circular: false,
+            half_transfer_ir: false,
+            complete_transfer_ir: true,
         }
     }
 }
@@ -365,7 +374,13 @@ impl<'a, C: Channel> Transfer<'a, C> {
             });
             w.set_pinc(vals::Inc::FIXED);
             w.set_teie(true);
-            w.set_tcie(true);
+            w.set_tcie(options.complete_transfer_ir);
+            if options.circular {
+                w.set_circ(vals::Circ::ENABLED);
+                debug!("Setting circular mode");
+            } else {
+                w.set_circ(vals::Circ::DISABLED);
+            }
             #[cfg(dma_v1)]
             w.set_trbuff(true);
 
@@ -646,7 +661,7 @@ impl<'a, C: Channel, W: Word> RingBuffer<'a, C, W> {
         w.set_minc(vals::Inc::INCREMENTED);
         w.set_pinc(vals::Inc::FIXED);
         w.set_teie(true);
-        w.set_htie(true);
+        w.set_htie(options.half_transfer_ir);
         w.set_tcie(true);
         w.set_circ(vals::Circ::ENABLED);
         #[cfg(dma_v1)]
-- 
cgit 


From a56b3e9a44dbad2480e9937fa9e26e320951fc12 Mon Sep 17 00:00:00 2001
From: JuliDi <20155974+JuliDi@users.noreply.github.com>
Date: Sat, 22 Jul 2023 19:47:36 +0200
Subject: update feature gates for v3

---
 embassy-stm32/src/dac/mod.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/embassy-stm32/src/dac/mod.rs b/embassy-stm32/src/dac/mod.rs
index bf15eaac5..979748bb4 100644
--- a/embassy-stm32/src/dac/mod.rs
+++ b/embassy-stm32/src/dac/mod.rs
@@ -164,7 +164,7 @@ pub trait DacChannel<T: Instance, Tx> {
     }
 
     /// Set mode register of the given channel
-    #[cfg(dac_v2)]
+    #[cfg(any(dac_v2, dac_v3))]
     fn set_channel_mode(&mut self, val: u8) -> Result<(), Error> {
         T::regs().mcr().modify(|reg| {
             reg.set_mode(Self::CHANNEL.index(), val);
@@ -262,7 +262,7 @@ impl<'d, T: Instance, Tx> DacCh1<'d, T, Tx> {
 
         // Configure each activated channel. All results can be `unwrap`ed since they
         // will only error if the channel is not configured (i.e. ch1, ch2 are false)
-        #[cfg(dac_v2)]
+        #[cfg(any(dac_v2, dac_v3))]
         dac.set_channel_mode(0).unwrap();
         dac.enable_channel().unwrap();
         dac.set_trigger_enable(true).unwrap();
@@ -288,7 +288,6 @@ impl<'d, T: Instance, Tx> DacCh1<'d, T, Tx> {
     /// Note that for performance reasons in circular mode the transfer complete interrupt is disabled.
     ///
     /// **Important:** Channel 1 has to be configured for the DAC instance!
-    #[cfg(all(bdma, not(dma)))] // It currently only works with BDMA-only chips (DMA should theoretically work though)
     pub async fn write(&mut self, data: ValueArray<'_>, circular: bool) -> Result<(), Error>
     where
         Tx: DmaCh1<T>,
@@ -377,7 +376,7 @@ impl<'d, T: Instance, Tx> DacCh2<'d, T, Tx> {
 
         // Configure each activated channel. All results can be `unwrap`ed since they
         // will only error if the channel is not configured (i.e. ch1, ch2 are false)
-        #[cfg(dac_v2)]
+        #[cfg(any(dac_v2, dac_v3))]
         dac.set_channel_mode(0).unwrap();
         dac.enable_channel().unwrap();
         dac.set_trigger_enable(true).unwrap();
@@ -499,7 +498,7 @@ impl<'d, T: Instance, TxCh1, TxCh2> Dac<'d, T, TxCh1, TxCh2> {
 
         // Configure each activated channel. All results can be `unwrap`ed since they
         // will only error if the channel is not configured (i.e. ch1, ch2 are false)
-        #[cfg(dac_v2)]
+        #[cfg(any(dac_v2, dac_v3))]
         dac_ch1.set_channel_mode(0).unwrap();
         dac_ch1.enable_channel().unwrap();
         dac_ch1.set_trigger_enable(true).unwrap();
-- 
cgit 


From 8e230bf6ece95470fa3be6476a4e01dbddb716ca Mon Sep 17 00:00:00 2001
From: JuliDi <20155974+JuliDi@users.noreply.github.com>
Date: Sat, 22 Jul 2023 21:36:03 +0200
Subject: add missing TransferOptions fields for DMA

---
 embassy-stm32/src/sdmmc/mod.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/embassy-stm32/src/sdmmc/mod.rs b/embassy-stm32/src/sdmmc/mod.rs
index 698292bff..434c56a48 100644
--- a/embassy-stm32/src/sdmmc/mod.rs
+++ b/embassy-stm32/src/sdmmc/mod.rs
@@ -225,6 +225,9 @@ const DMA_TRANSFER_OPTIONS: crate::dma::TransferOptions = crate::dma::TransferOp
     mburst: crate::dma::Burst::Incr4,
     flow_ctrl: crate::dma::FlowControl::Peripheral,
     fifo_threshold: Some(crate::dma::FifoThreshold::Full),
+    circular: false,
+    half_transfer_ir: false,
+    complete_transfer_ir: true,
 };
 #[cfg(all(sdmmc_v1, not(dma)))]
 const DMA_TRANSFER_OPTIONS: crate::dma::TransferOptions = crate::dma::TransferOptions {
-- 
cgit 


From fbe30b2453a4bdbacd091aa1804b416bcb4e0706 Mon Sep 17 00:00:00 2001
From: Adam Greig <adam@adamgreig.com>
Date: Sat, 22 Jul 2023 21:58:29 +0100
Subject: Add notes about setting chip name correctly for examples.

---
 README.md                   | 6 ++++++
 examples/stm32c0/Cargo.toml | 3 ++-
 examples/stm32f0/Cargo.toml | 3 ++-
 examples/stm32f1/Cargo.toml | 3 ++-
 examples/stm32f2/Cargo.toml | 3 ++-
 examples/stm32f3/Cargo.toml | 3 ++-
 examples/stm32f4/Cargo.toml | 3 ++-
 examples/stm32f7/Cargo.toml | 3 ++-
 examples/stm32g0/Cargo.toml | 3 ++-
 examples/stm32g4/Cargo.toml | 3 ++-
 examples/stm32h5/Cargo.toml | 3 ++-
 examples/stm32h7/Cargo.toml | 3 ++-
 examples/stm32l0/Cargo.toml | 3 ++-
 examples/stm32l4/Cargo.toml | 3 ++-
 examples/stm32l5/Cargo.toml | 3 ++-
 examples/stm32u5/Cargo.toml | 3 ++-
 examples/stm32wb/Cargo.toml | 7 ++++---
 examples/stm32wl/Cargo.toml | 3 ++-
 18 files changed, 42 insertions(+), 19 deletions(-)

diff --git a/README.md b/README.md
index b05e55aa5..28407b8bc 100644
--- a/README.md
+++ b/README.md
@@ -111,6 +111,12 @@ cargo install probe-rs --features cli
 cd examples/nrf52840
 ```
 
+- Ensure `Cargo.toml` sets the right feature for the name of the chip you are programming.
+  If this name is incorrect, the example may fail to run or immediately crash
+  after being programmed.
+
+- Ensure `.cargo/config.toml` contains the name of the chip you are programming.
+
 - Run the example
 
 For example:
diff --git a/examples/stm32c0/Cargo.toml b/examples/stm32c0/Cargo.toml
index 26837abef..e74c5357b 100644
--- a/examples/stm32c0/Cargo.toml
+++ b/examples/stm32c0/Cargo.toml
@@ -5,10 +5,11 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32c031c6 to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "time-driver-any", "stm32c031c6", "memory-x", "unstable-pac", "exti"]  }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "time-driver-any", "stm32c031c6", "memory-x", "unstable-pac", "exti"]  }
 
 defmt = "0.3"
 defmt-rtt = "0.4"
diff --git a/examples/stm32f0/Cargo.toml b/examples/stm32f0/Cargo.toml
index b7b5eaa99..620a139ae 100644
--- a/examples/stm32f0/Cargo.toml
+++ b/examples/stm32f0/Cargo.toml
@@ -7,6 +7,8 @@ license = "MIT OR Apache-2.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+# Change stm32f091rc to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "memory-x", "stm32f091rc", "time-driver-any", "exti", "unstable-pac"] }
 cortex-m = { version = "0.7.6", features = ["inline-asm", "critical-section-single-core"] }
 cortex-m-rt = "0.7.0"
 defmt = "0.3"
@@ -15,5 +17,4 @@ panic-probe = "0.3"
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "executor-interrupt", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "memory-x", "stm32f091rc", "time-driver-any", "exti", "unstable-pac"] }
 static_cell = { version = "1.1", features = ["nightly"]}
diff --git a/examples/stm32f1/Cargo.toml b/examples/stm32f1/Cargo.toml
index 29cad5b67..8450c541f 100644
--- a/examples/stm32f1/Cargo.toml
+++ b/examples/stm32f1/Cargo.toml
@@ -5,10 +5,11 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32f103c8 to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32f103c8", "unstable-pac", "memory-x", "time-driver-any", "unstable-traits" ]  }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32f103c8", "unstable-pac", "memory-x", "time-driver-any", "unstable-traits" ]  }
 embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"] }
 embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
 
diff --git a/examples/stm32f2/Cargo.toml b/examples/stm32f2/Cargo.toml
index 652210c7f..147e2ecbf 100644
--- a/examples/stm32f2/Cargo.toml
+++ b/examples/stm32f2/Cargo.toml
@@ -5,10 +5,11 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32f207zg to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32f207zg", "unstable-pac", "memory-x", "time-driver-any", "exti"]  }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32f207zg", "unstable-pac", "memory-x", "time-driver-any", "exti"]  }
 
 defmt = "0.3"
 defmt-rtt = "0.4"
diff --git a/examples/stm32f3/Cargo.toml b/examples/stm32f3/Cargo.toml
index 489d0ff4c..6ac5d57e9 100644
--- a/examples/stm32f3/Cargo.toml
+++ b/examples/stm32f3/Cargo.toml
@@ -5,10 +5,11 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32f303ze to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32f303ze", "unstable-pac", "memory-x", "time-driver-any", "exti"]  }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "executor-interrupt", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32f303ze", "unstable-pac", "memory-x", "time-driver-any", "exti"]  }
 embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"] }
 embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
 
diff --git a/examples/stm32f4/Cargo.toml b/examples/stm32f4/Cargo.toml
index c1c821364..e1ef40f92 100644
--- a/examples/stm32f4/Cargo.toml
+++ b/examples/stm32f4/Cargo.toml
@@ -5,10 +5,11 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32f429zi to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "unstable-traits", "defmt", "stm32f429zi", "unstable-pac", "memory-x", "time-driver-any", "exti", "embedded-sdmmc", "chrono"]  }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "executor-interrupt", "defmt", "integrated-timers", "arch-cortex-m", "executor-thread", "executor-interrupt"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "unstable-traits", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "unstable-traits", "defmt", "stm32f429zi", "unstable-pac", "memory-x", "time-driver-any", "exti", "embedded-sdmmc", "chrono"]  }
 embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"] }
 embassy-net = { version = "0.1.0", path = "../../embassy-net", features = ["defmt", "tcp", "dhcpv4", "medium-ethernet", "nightly"] }
 
diff --git a/examples/stm32f7/Cargo.toml b/examples/stm32f7/Cargo.toml
index 84d7b79c5..bbc99fee0 100644
--- a/examples/stm32f7/Cargo.toml
+++ b/examples/stm32f7/Cargo.toml
@@ -5,10 +5,11 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32f767zi to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32f767zi", "unstable-pac", "time-driver-any", "exti"]  }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32f767zi", "unstable-pac", "time-driver-any", "exti"]  }
 embassy-net = { path = "../../embassy-net", features = ["defmt", "nightly", "tcp", "dhcpv4", "medium-ethernet"] }
 embedded-io = { version = "0.4.0", features = ["async"] }
 embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"] }
diff --git a/examples/stm32g0/Cargo.toml b/examples/stm32g0/Cargo.toml
index c88282d91..4a14568ac 100644
--- a/examples/stm32g0/Cargo.toml
+++ b/examples/stm32g0/Cargo.toml
@@ -5,10 +5,11 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32g071rb to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "time-driver-any", "stm32g071rb", "memory-x", "unstable-pac", "exti"]  }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "time-driver-any", "stm32g071rb", "memory-x", "unstable-pac", "exti"]  }
 
 defmt = "0.3"
 defmt-rtt = "0.4"
diff --git a/examples/stm32g4/Cargo.toml b/examples/stm32g4/Cargo.toml
index 18bd03c39..935997a74 100644
--- a/examples/stm32g4/Cargo.toml
+++ b/examples/stm32g4/Cargo.toml
@@ -5,10 +5,11 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32g491re to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "time-driver-any", "stm32g491re", "memory-x", "unstable-pac", "exti"]  }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "time-driver-any", "stm32g491re", "memory-x", "unstable-pac", "exti"]  }
 embassy-hal-common = {version = "0.1.0", path = "../../embassy-hal-common" }
 embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"] }
 
diff --git a/examples/stm32h5/Cargo.toml b/examples/stm32h5/Cargo.toml
index 227bc28b4..aebc795c1 100644
--- a/examples/stm32h5/Cargo.toml
+++ b/examples/stm32h5/Cargo.toml
@@ -5,10 +5,11 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32h563zi to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32h563zi", "time-driver-any", "exti", "unstable-pac", "unstable-traits"] }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "unstable-traits", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32h563zi", "time-driver-any", "exti", "unstable-pac", "unstable-traits"] }
 embassy-net = { path = "../../embassy-net", features = ["defmt", "nightly", "tcp", "dhcpv4", "medium-ethernet", "unstable-traits", "proto-ipv6"] }
 embedded-io = { version = "0.4.0", features = ["async"] }
 embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"] }
diff --git a/examples/stm32h7/Cargo.toml b/examples/stm32h7/Cargo.toml
index 768702fa9..2d82c0d0d 100644
--- a/examples/stm32h7/Cargo.toml
+++ b/examples/stm32h7/Cargo.toml
@@ -5,10 +5,11 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32h743bi to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32h743bi", "time-driver-any", "exti", "unstable-pac", "unstable-traits"] }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "unstable-traits", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32h743bi", "time-driver-any", "exti", "unstable-pac", "unstable-traits"] }
 embassy-net = { path = "../../embassy-net", features = ["defmt", "nightly", "tcp", "dhcpv4", "medium-ethernet", "unstable-traits", "proto-ipv6"] }
 embedded-io = { version = "0.4.0", features = ["async"] }
 embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"] }
diff --git a/examples/stm32l0/Cargo.toml b/examples/stm32l0/Cargo.toml
index 747cec7bf..e6a5a4c14 100644
--- a/examples/stm32l0/Cargo.toml
+++ b/examples/stm32l0/Cargo.toml
@@ -10,10 +10,11 @@ nightly = ["embassy-stm32/nightly", "embassy-time/nightly", "embassy-time/unstab
            "embassy-lora", "lora-phy", "lorawan-device", "lorawan", "embedded-io/async"]
 
 [dependencies]
+# Change stm32l072cz to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["defmt", "stm32l072cz", "time-driver-any", "exti", "unstable-traits", "memory-x"]  }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["defmt", "stm32l072cz", "time-driver-any", "exti", "unstable-traits", "memory-x"]  }
 embassy-lora = { version = "0.1.0", path = "../../embassy-lora", features = ["time", "defmt"], optional = true }
 lora-phy = { version = "1", optional = true }
 lorawan-device = { version = "0.10.0", default-features = false, features = ["async", "external-lora-phy"], optional = true }
diff --git a/examples/stm32l4/Cargo.toml b/examples/stm32l4/Cargo.toml
index c55558518..41c9869bf 100644
--- a/examples/stm32l4/Cargo.toml
+++ b/examples/stm32l4/Cargo.toml
@@ -5,11 +5,12 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32l4s5vi to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "unstable-pac", "stm32l4s5vi", "time-driver-any", "exti", "unstable-traits", "chrono"]  }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
 embassy-embedded-hal = { version = "0.1.0", path = "../../embassy-embedded-hal" }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "unstable-pac", "stm32l4s5vi", "time-driver-any", "exti", "unstable-traits", "chrono"]  }
 embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"] }
 
 defmt = "0.3"
diff --git a/examples/stm32l5/Cargo.toml b/examples/stm32l5/Cargo.toml
index 54911482e..5d66c59c3 100644
--- a/examples/stm32l5/Cargo.toml
+++ b/examples/stm32l5/Cargo.toml
@@ -5,10 +5,11 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32l552ze to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "unstable-pac", "stm32l552ze", "time-driver-any", "exti", "unstable-traits", "memory-x"]  }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "unstable-pac", "stm32l552ze", "time-driver-any", "exti", "unstable-traits", "memory-x"]  }
 embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"] }
 embassy-net = { version = "0.1.0", path = "../../embassy-net", features = ["defmt", "nightly", "tcp", "dhcpv4", "medium-ethernet"] }
 embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
diff --git a/examples/stm32u5/Cargo.toml b/examples/stm32u5/Cargo.toml
index 835e32940..a43a55909 100644
--- a/examples/stm32u5/Cargo.toml
+++ b/examples/stm32u5/Cargo.toml
@@ -5,10 +5,11 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32u585ai to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "unstable-pac", "stm32u585ai", "time-driver-any", "memory-x" ]  }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "unstable-pac", "stm32u585ai", "time-driver-any", "memory-x" ]  }
 embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"] }
 
 defmt = "0.3"
diff --git a/examples/stm32wb/Cargo.toml b/examples/stm32wb/Cargo.toml
index 7c0b83e65..48e340264 100644
--- a/examples/stm32wb/Cargo.toml
+++ b/examples/stm32wb/Cargo.toml
@@ -5,11 +5,12 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32wb55rg to your chip name in both dependencies, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32wb55rg", "time-driver-any", "memory-x", "exti"]  }
+embassy-stm32-wpan = { version = "0.1.0", path = "../../embassy-stm32-wpan", features = ["defmt", "stm32wb55rg"] }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32wb55rg", "time-driver-any", "memory-x", "exti"]  }
-embassy-stm32-wpan = { version = "0.1.0", path = "../../embassy-stm32-wpan", features = ["defmt", "stm32wb55rg"] }
 embassy-net = { version = "0.1.0", path = "../../embassy-net", features = ["defmt", "udp", "medium-ieee802154", "nightly"], optional=true }
 
 defmt = "0.3"
@@ -50,4 +51,4 @@ required-features = ["ble"]
 
 [[bin]] 
 name = "gatt_server"
-required-features = ["ble"]
\ No newline at end of file
+required-features = ["ble"]
diff --git a/examples/stm32wl/Cargo.toml b/examples/stm32wl/Cargo.toml
index e2c66f456..6e6f269aa 100644
--- a/examples/stm32wl/Cargo.toml
+++ b/examples/stm32wl/Cargo.toml
@@ -5,10 +5,11 @@ version = "0.1.0"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
+# Change stm32wl55jc-cm4 to your chip name, if necessary.
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "unstable-traits", "defmt", "stm32wl55jc-cm4", "time-driver-any", "memory-x", "unstable-pac", "exti", "chrono"] }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["nightly", "unstable-traits", "defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "unstable-traits", "defmt", "stm32wl55jc-cm4", "time-driver-any", "memory-x", "unstable-pac", "exti", "chrono"] }
 embassy-embedded-hal = { version = "0.1.0", path = "../../embassy-embedded-hal" }
 embassy-lora = { version = "0.1.0", path = "../../embassy-lora", features = ["stm32wl", "time", "defmt"] }
 lora-phy = { version = "1" }
-- 
cgit 


From fbcc587eca63b038e0e878a58b0b21ba54bc21d8 Mon Sep 17 00:00:00 2001
From: xoviat <49173759+xoviat@users.noreply.github.com>
Date: Sat, 22 Jul 2023 17:06:04 -0500
Subject: update readme

---
 README.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/README.md b/README.md
index 28407b8bc..c4c01dfbc 100644
--- a/README.md
+++ b/README.md
@@ -33,6 +33,7 @@ The <a href="https://docs.embassy.dev/embassy-net/">embassy-net</a> network stac
 
 - **Bluetooth** - 
 The <a href="https://github.com/embassy-rs/nrf-softdevice">nrf-softdevice</a> crate provides Bluetooth Low Energy 4.x and 5.x support for nRF52 microcontrollers.
+The <a href="https://github.com/embassy-rs/embassy/tree/main/embassy-stm32-wpan">embassy-stm32-wpan</a> crate provides Bluetooth Low Energy 5.x support for stm32wb microcontrollers.
 
 - **LoRa** - 
 <a href="https://docs.embassy.dev/embassy-lora/">embassy-lora</a> supports LoRa networking.
@@ -125,6 +126,8 @@ For example:
 cargo run --release --bin blinky
 ```
 
+For more help getting started, see [Getting Started][1] and [Running the Examples][2].
+
 ## Developing Embassy with Rust Analyzer based editors
 
 The [Rust Analyzer](https://rust-analyzer.github.io/) is used by [Visual Studio Code](https://code.visualstudio.com/)
@@ -157,3 +160,5 @@ This work is licensed under either of
 
 at your option.
 
+[1]: https://github.com/embassy-rs/embassy/wiki/Getting-Started
+[2]: https://github.com/embassy-rs/embassy/wiki/Running-the-Examples
-- 
cgit 


From 4883fdd1549e8d43290b39d72c3b311d300010ea Mon Sep 17 00:00:00 2001
From: Alex Ferro <alextm@ferrouscanine.com>
Date: Sat, 22 Jul 2023 17:17:01 -0600
Subject: Add a STM32/DMARingBuffer::read_exact helper

This provides a helper function with an async implementation, that
will only return (or error) when it was able to read that many bytes,
sleeping until ready.

Additionally, corrected the documentation for Ringbuffer functions to use
"elements" instead of "bytes" as the types were already generic over the
word/element size.
---
 embassy-stm32/src/dma/bdma.rs       | 44 ++++++++++++++++++++++++++++++++++---
 embassy-stm32/src/dma/dma.rs        | 44 ++++++++++++++++++++++++++++++++++---
 embassy-stm32/src/dma/ringbuffer.rs | 18 +++++++--------
 3 files changed, 91 insertions(+), 15 deletions(-)

diff --git a/embassy-stm32/src/dma/bdma.rs b/embassy-stm32/src/dma/bdma.rs
index 5a87888b7..68c78123d 100644
--- a/embassy-stm32/src/dma/bdma.rs
+++ b/embassy-stm32/src/dma/bdma.rs
@@ -466,15 +466,53 @@ impl<'a, C: Channel, W: Word> RingBuffer<'a, C, W> {
         self.ringbuf.clear(DmaCtrlImpl(self.channel.reborrow()));
     }
 
-    /// Read bytes from the ring buffer
+    /// Read elements from the ring buffer
     /// Return a tuple of the length read and the length remaining in the buffer
-    /// If not all of the bytes were read, then there will be some bytes in the buffer remaining
-    /// The length remaining is the capacity, ring_buf.len(), less the bytes remaining after the read
+    /// If not all of the elements were read, then there will be some elements in the buffer remaining
+    /// The length remaining is the capacity, ring_buf.len(), less the elements remaining after the read
     /// OverrunError is returned if the portion to be read was overwritten by the DMA controller.
     pub fn read(&mut self, buf: &mut [W]) -> Result<(usize, usize), OverrunError> {
         self.ringbuf.read(DmaCtrlImpl(self.channel.reborrow()), buf)
     }
 
+    /// Read an exact number of elements from the ringbuffer.
+    ///
+    /// Returns the remaining number of elements available for immediate reading.
+    /// OverrunError is returned if the portion to be read was overwritten by the DMA controller.
+    ///
+    /// Async/Wake Behavior:
+    /// The underlying DMA peripheral only can wake us when its buffer pointer has reached the halfway point,
+    /// and when it wraps around. This means that when called with a buffer of length 'M', when this
+    /// ring buffer was created with a buffer of size 'N':
+    /// - If M equals N/2 or N/2 divides evenly into M, this function will return every N/2 elements read on the DMA source.
+    /// - Otherwise, this function may need up to N/2 extra elements to arrive before returning.
+    pub async fn read_exact(&mut self, buffer: &mut [W]) -> Result<usize, OverrunError> {
+        use core::future::poll_fn;
+        use core::sync::atomic::compiler_fence;
+
+        let mut read_data = 0;
+        let buffer_len = buffer.len();
+
+        poll_fn(|cx| {
+            self.set_waker(cx.waker());
+
+            compiler_fence(Ordering::SeqCst);
+
+            match self.read(&mut buffer[read_data..buffer_len]) {
+                Ok((len, remaining)) => {
+                    read_data += len;
+                    if read_data == buffer_len {
+                        Poll::Ready(Ok(remaining))
+                    } else {
+                        Poll::Pending
+                    }
+                }
+                Err(e) => Poll::Ready(Err(e)),
+            }
+        })
+        .await
+    }
+
     /// The capacity of the ringbuffer
     pub fn cap(&self) -> usize {
         self.ringbuf.cap()
diff --git a/embassy-stm32/src/dma/dma.rs b/embassy-stm32/src/dma/dma.rs
index 58d438af8..9459fb763 100644
--- a/embassy-stm32/src/dma/dma.rs
+++ b/embassy-stm32/src/dma/dma.rs
@@ -696,15 +696,53 @@ impl<'a, C: Channel, W: Word> RingBuffer<'a, C, W> {
         self.ringbuf.clear(DmaCtrlImpl(self.channel.reborrow()));
     }
 
-    /// Read bytes from the ring buffer
+    /// Read elements from the ring buffer
     /// Return a tuple of the length read and the length remaining in the buffer
-    /// If not all of the bytes were read, then there will be some bytes in the buffer remaining
-    /// The length remaining is the capacity, ring_buf.len(), less the bytes remaining after the read
+    /// If not all of the elements were read, then there will be some elements in the buffer remaining
+    /// The length remaining is the capacity, ring_buf.len(), less the elements remaining after the read
     /// OverrunError is returned if the portion to be read was overwritten by the DMA controller.
     pub fn read(&mut self, buf: &mut [W]) -> Result<(usize, usize), OverrunError> {
         self.ringbuf.read(DmaCtrlImpl(self.channel.reborrow()), buf)
     }
 
+    /// Read an exact number of elements from the ringbuffer.
+    ///
+    /// Returns the remaining number of elements available for immediate reading.
+    /// OverrunError is returned if the portion to be read was overwritten by the DMA controller.
+    ///
+    /// Async/Wake Behavior:
+    /// The underlying DMA peripheral only can wake us when its buffer pointer has reached the halfway point,
+    /// and when it wraps around. This means that when called with a buffer of length 'M', when this
+    /// ring buffer was created with a buffer of size 'N':
+    /// - If M equals N/2 or N/2 divides evenly into M, this function will return every N/2 elements read on the DMA source.
+    /// - Otherwise, this function may need up to N/2 extra elements to arrive before returning.
+    pub async fn read_exact(&mut self, buffer: &mut [W]) -> Result<usize, OverrunError> {
+        use core::future::poll_fn;
+        use core::sync::atomic::compiler_fence;
+
+        let mut read_data = 0;
+        let buffer_len = buffer.len();
+
+        poll_fn(|cx| {
+            self.set_waker(cx.waker());
+
+            compiler_fence(Ordering::SeqCst);
+
+            match self.read(&mut buffer[read_data..buffer_len]) {
+                Ok((len, remaining)) => {
+                    read_data += len;
+                    if read_data == buffer_len {
+                        Poll::Ready(Ok(remaining))
+                    } else {
+                        Poll::Pending
+                    }
+                }
+                Err(e) => Poll::Ready(Err(e)),
+            }
+        })
+        .await
+    }
+
     // The capacity of the ringbuffer
     pub fn cap(&self) -> usize {
         self.ringbuf.cap()
diff --git a/embassy-stm32/src/dma/ringbuffer.rs b/embassy-stm32/src/dma/ringbuffer.rs
index a2bde986f..190793974 100644
--- a/embassy-stm32/src/dma/ringbuffer.rs
+++ b/embassy-stm32/src/dma/ringbuffer.rs
@@ -72,10 +72,10 @@ impl<'a, W: Word> DmaRingBuffer<'a, W> {
         self.cap() - remaining_transfers
     }
 
-    /// Read bytes from the ring buffer
+    /// Read elements from the ring buffer
     /// Return a tuple of the length read and the length remaining in the buffer
-    /// If not all of the bytes were read, then there will be some bytes in the buffer remaining
-    /// The length remaining is the capacity, ring_buf.len(), less the bytes remaining after the read
+    /// If not all of the elements were read, then there will be some elements in the buffer remaining
+    /// The length remaining is the capacity, ring_buf.len(), less the elements remaining after the read
     /// OverrunError is returned if the portion to be read was overwritten by the DMA controller.
     pub fn read(&mut self, mut dma: impl DmaCtrl, buf: &mut [W]) -> Result<(usize, usize), OverrunError> {
         /*
@@ -95,11 +95,11 @@ impl<'a, W: Word> DmaRingBuffer<'a, W> {
         */
         let end = self.pos(dma.get_remaining_transfers());
         if self.start == end && dma.get_complete_count() == 0 {
-            // No bytes are available in the buffer
+            // No elements are available in the buffer
             Ok((0, self.cap()))
         } else if self.start < end {
             // The available, unread portion in the ring buffer DOES NOT wrap
-            // Copy out the bytes from the dma buffer
+            // Copy out the elements from the dma buffer
             let len = self.copy_to(buf, self.start..end);
 
             compiler_fence(Ordering::SeqCst);
@@ -128,7 +128,7 @@ impl<'a, W: Word> DmaRingBuffer<'a, W> {
             // The DMA writer has wrapped since we last read and is currently
             // writing (or the next byte added will be) in the beginning of the ring buffer.
 
-            // The provided read buffer is not large enough to include all bytes from the tail of the dma buffer.
+            // The provided read buffer is not large enough to include all elements from the tail of the dma buffer.
 
             // Copy out from the dma buffer
             let len = self.copy_to(buf, self.start..self.cap());
@@ -154,8 +154,8 @@ impl<'a, W: Word> DmaRingBuffer<'a, W> {
             // The DMA writer has wrapped since we last read and is currently
             // writing (or the next byte added will be) in the beginning of the ring buffer.
 
-            // The provided read buffer is large enough to include all bytes from the tail of the dma buffer,
-            // so the next read will not have any unread tail bytes in the ring buffer.
+            // The provided read buffer is large enough to include all elements from the tail of the dma buffer,
+            // so the next read will not have any unread tail elements in the ring buffer.
 
             // Copy out from the dma buffer
             let tail = self.copy_to(buf, self.start..self.cap());
@@ -180,7 +180,7 @@ impl<'a, W: Word> DmaRingBuffer<'a, W> {
     }
     /// Copy from the dma buffer at `data_range` into `buf`
     fn copy_to(&mut self, buf: &mut [W], data_range: Range<usize>) -> usize {
-        // Limit the number of bytes that can be copied
+        // Limit the number of elements that can be copied
         let length = usize::min(data_range.len(), buf.len());
 
         // Copy from dma buffer into read buffer
-- 
cgit 


From bd60f003e0ef367e1678d549973ba9b4ae753652 Mon Sep 17 00:00:00 2001
From: xoviat <xoviat@users.noreply.github.com>
Date: Sun, 23 Jul 2023 17:01:34 -0500
Subject: stm32/rcc: move rcc logic from ipcc

---
 embassy-stm32/src/ipcc.rs    |  56 +-------
 embassy-stm32/src/rcc/mod.rs |   8 ++
 embassy-stm32/src/rcc/wb.rs  | 326 ++++++++++++++++++++++++++++++++++++-------
 3 files changed, 287 insertions(+), 103 deletions(-)

diff --git a/embassy-stm32/src/ipcc.rs b/embassy-stm32/src/ipcc.rs
index a24cba9f0..e100ca5cc 100644
--- a/embassy-stm32/src/ipcc.rs
+++ b/embassy-stm32/src/ipcc.rs
@@ -265,63 +265,9 @@ pub(crate) mod sealed {
 }
 
 fn _configure_pwr() {
-    // TODO: move this to RCC
-
-    let pwr = crate::pac::PWR;
+    // TODO: move the rest of this to rcc
     let rcc = crate::pac::RCC;
 
-    rcc.cfgr().modify(|w| w.set_stopwuck(true));
-
-    pwr.cr1().modify(|w| w.set_dbp(true));
-    pwr.cr1().modify(|w| w.set_dbp(true));
-
-    // configure LSE
-    rcc.bdcr().modify(|w| w.set_lseon(true));
-
-    // select system clock source = PLL
-    // set PLL coefficients
-    // m: 2,
-    // n: 12,
-    // r: 3,
-    // q: 4,
-    // p: 3,
-    let src_bits = 0b11;
-    let pllp = (3 - 1) & 0b11111;
-    let pllq = (4 - 1) & 0b111;
-    let pllr = (3 - 1) & 0b111;
-    let plln = 12 & 0b1111111;
-    let pllm = (2 - 1) & 0b111;
-    rcc.pllcfgr().modify(|w| {
-        w.set_pllsrc(src_bits);
-        w.set_pllm(pllm);
-        w.set_plln(plln);
-        w.set_pllr(pllr);
-        w.set_pllp(pllp);
-        w.set_pllpen(true);
-        w.set_pllq(pllq);
-        w.set_pllqen(true);
-    });
-    // enable PLL
-    rcc.cr().modify(|w| w.set_pllon(true));
-    rcc.cr().write(|w| w.set_hsion(false));
-    // while !rcc.cr().read().pllrdy() {}
-
-    // configure SYSCLK mux to use PLL clocl
-    rcc.cfgr().modify(|w| w.set_sw(0b11));
-
-    // configure CPU1 & CPU2 dividers
-    rcc.cfgr().modify(|w| w.set_hpre(0)); // not divided
-    rcc.extcfgr().modify(|w| {
-        w.set_c2hpre(0b1000); // div2
-        w.set_shdhpre(0); // not divided
-    });
-
-    // apply APB1 / APB2 values
-    rcc.cfgr().modify(|w| {
-        w.set_ppre1(0b000); // not divided
-        w.set_ppre2(0b000); // not divided
-    });
-
     // TODO: required
     // set RF wake-up clock = LSE
     rcc.csr().modify(|w| w.set_rfwkpsel(0b01));
diff --git a/embassy-stm32/src/rcc/mod.rs b/embassy-stm32/src/rcc/mod.rs
index 886fc0b93..4ae65d3e6 100644
--- a/embassy-stm32/src/rcc/mod.rs
+++ b/embassy-stm32/src/rcc/mod.rs
@@ -78,6 +78,14 @@ pub struct Clocks {
 /// The existence of this value indicates that the clock configuration can no longer be changed
 static mut CLOCK_FREQS: MaybeUninit<Clocks> = MaybeUninit::uninit();
 
+#[cfg(stm32wb)]
+/// RCC initialization function
+pub(crate) unsafe fn init(config: Config) {
+    set_freqs(compute_clocks(&config));
+
+    configure_clocks(&config);
+}
+
 /// Sets the clock frequencies
 ///
 /// Safety: Sets a mutable global.
diff --git a/embassy-stm32/src/rcc/wb.rs b/embassy-stm32/src/rcc/wb.rs
index e6123821a..41f602c02 100644
--- a/embassy-stm32/src/rcc/wb.rs
+++ b/embassy-stm32/src/rcc/wb.rs
@@ -1,6 +1,5 @@
-use crate::pac::RCC;
-use crate::rcc::{set_freqs, Clocks};
-use crate::time::Hertz;
+use crate::rcc::Clocks;
+use crate::time::{khz, mhz, Hertz};
 
 /// Most of clock setup is copied from stm32l0xx-hal, and adopted to the generated PAC,
 /// and with the addition of the init function to configure a system clock.
@@ -13,11 +12,94 @@ pub const HSI_FREQ: Hertz = Hertz(16_000_000);
 /// LSI speed
 pub const LSI_FREQ: Hertz = Hertz(32_000);
 
-/// System clock mux source
 #[derive(Clone, Copy)]
-pub enum ClockSrc {
-    HSE(Hertz),
-    HSI16,
+pub enum HsePrescaler {
+    NotDivided,
+    Div2,
+}
+
+impl From<HsePrescaler> for bool {
+    fn from(value: HsePrescaler) -> Self {
+        match value {
+            HsePrescaler::NotDivided => false,
+            HsePrescaler::Div2 => true,
+        }
+    }
+}
+
+pub struct Hse {
+    pub prediv: HsePrescaler,
+
+    pub frequency: Hertz,
+}
+
+/// System clock mux source
+#[derive(Clone, Copy, PartialEq)]
+pub enum Sysclk {
+    /// MSI selected as sysclk
+    MSI,
+    /// HSI selected as sysclk
+    HSI,
+    /// HSE selected as sysclk
+    HSE,
+    /// PLL selected as sysclk
+    Pll,
+}
+
+impl From<Sysclk> for u8 {
+    fn from(value: Sysclk) -> Self {
+        match value {
+            Sysclk::MSI => 0b00,
+            Sysclk::HSI => 0b01,
+            Sysclk::HSE => 0b10,
+            Sysclk::Pll => 0b11,
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum PllSource {
+    Hsi,
+    Msi,
+    Hse,
+}
+
+impl From<PllSource> for u8 {
+    fn from(value: PllSource) -> Self {
+        match value {
+            PllSource::Msi => 0b01,
+            PllSource::Hsi => 0b10,
+            PllSource::Hse => 0b11,
+        }
+    }
+}
+
+pub enum Pll48Source {
+    PllSai,
+    Pll,
+    Msi,
+    Hsi48,
+}
+
+pub struct PllMux {
+    /// Source clock selection.
+    pub source: PllSource,
+
+    /// PLL pre-divider (DIVM). Must be between 1 and 63.
+    pub prediv: u8,
+}
+
+pub struct Pll {
+    /// PLL multiplication factor. Must be between 4 and 512.
+    pub mul: u16,
+
+    /// PLL P division factor. If None, PLL P output is disabled. Must be between 1 and 128.
+    /// On PLL1, it must be even (in particular, it cannot be 1.)
+    pub divp: Option<u16>,
+    /// PLL Q division factor. If None, PLL Q output is disabled. Must be between 1 and 128.
+    pub divq: Option<u16>,
+    /// PLL R division factor. If None, PLL R output is disabled. Must be between 1 and 128.
+    pub divr: Option<u16>,
 }
 
 /// AHB prescaler
@@ -84,8 +166,18 @@ impl Into<u8> for AHBPrescaler {
 
 /// Clocks configutation
 pub struct Config {
-    pub mux: ClockSrc,
-    pub ahb_pre: AHBPrescaler,
+    pub hse: Option<Hse>,
+    pub lse: Option<Hertz>,
+    pub sys: Sysclk,
+    pub mux: Option<PllMux>,
+    pub pll48: Option<Pll48Source>,
+
+    pub pll: Option<Pll>,
+    pub pllsai: Option<Pll>,
+
+    pub ahb1_pre: AHBPrescaler,
+    pub ahb2_pre: AHBPrescaler,
+    pub ahb3_pre: AHBPrescaler,
     pub apb1_pre: APBPrescaler,
     pub apb2_pre: APBPrescaler,
 }
@@ -94,76 +186,214 @@ impl Default for Config {
     #[inline]
     fn default() -> Config {
         Config {
-            mux: ClockSrc::HSI16,
-            ahb_pre: AHBPrescaler::NotDivided,
+            hse: Some(Hse {
+                frequency: mhz(32),
+                prediv: HsePrescaler::NotDivided,
+            }),
+            lse: Some(khz(32)),
+            sys: Sysclk::HSI,
+            mux: Some(PllMux {
+                source: PllSource::Hse,
+                prediv: 2,
+            }),
+            pll48: None,
+
+            pll: Some(Pll {
+                mul: 12,
+                divp: Some(3),
+                divq: Some(4),
+                divr: Some(3),
+            }),
+            pllsai: None,
+
+            ahb1_pre: AHBPrescaler::NotDivided,
+            ahb2_pre: AHBPrescaler::Div2,
+            ahb3_pre: AHBPrescaler::NotDivided,
             apb1_pre: APBPrescaler::NotDivided,
             apb2_pre: APBPrescaler::NotDivided,
         }
     }
 }
 
-pub(crate) unsafe fn init(config: Config) {
-    let (sys_clk, sw) = match config.mux {
-        ClockSrc::HSI16 => {
-            // Enable HSI16
-            RCC.cr().write(|w| w.set_hsion(true));
-            while !RCC.cr().read().hsirdy() {}
+pub(crate) fn compute_clocks(config: &Config) -> Clocks {
+    let hse_clk = config.hse.as_ref().map(|hse| match hse.prediv {
+        HsePrescaler::NotDivided => hse.frequency,
+        HsePrescaler::Div2 => hse.frequency / 2u32,
+    });
+
+    let mux_clk = config.mux.as_ref().map(|pll_mux| {
+        (match pll_mux.source {
+            PllSource::Hse => hse_clk.unwrap(),
+            PllSource::Hsi => HSI_FREQ,
+            _ => unreachable!(),
+        } / pll_mux.prediv)
+    });
 
-            (HSI_FREQ.0, 0x01)
+    let (pll_r, _pll_q, _pll_p) = match &config.pll {
+        Some(pll) => {
+            let pll_vco = mux_clk.unwrap() * pll.mul as u32;
+
+            (
+                pll.divr.map(|divr| pll_vco / divr),
+                pll.divq.map(|divq| pll_vco / divq),
+                pll.divp.map(|divp| pll_vco / divp),
+            )
         }
-        ClockSrc::HSE(freq) => {
-            // Enable HSE
-            RCC.cr().write(|w| w.set_hseon(true));
-            while !RCC.cr().read().hserdy() {}
+        None => (None, None, None),
+    };
 
-            (freq.0, 0x02)
+    let sys_clk = match config.sys {
+        Sysclk::HSE => hse_clk.unwrap(),
+        Sysclk::HSI => HSI_FREQ,
+        Sysclk::Pll => pll_r.unwrap(),
+        _ => unreachable!(),
+    };
+
+    let ahb1_clk = match config.ahb1_pre {
+        AHBPrescaler::NotDivided => sys_clk,
+        pre => {
+            let pre: u8 = pre.into();
+            let pre = 1u32 << (pre as u32 - 7);
+            sys_clk / pre
         }
     };
 
-    RCC.cfgr().modify(|w| {
-        w.set_sw(sw.into());
-        w.set_hpre(config.ahb_pre.into());
-        w.set_ppre1(config.apb1_pre.into());
-        w.set_ppre2(config.apb2_pre.into());
-    });
+    let ahb2_clk = match config.ahb2_pre {
+        AHBPrescaler::NotDivided => sys_clk,
+        pre => {
+            let pre: u8 = pre.into();
+            let pre = 1u32 << (pre as u32 - 7);
+            sys_clk / pre
+        }
+    };
 
-    let ahb_freq: u32 = match config.ahb_pre {
+    let ahb3_clk = match config.ahb3_pre {
         AHBPrescaler::NotDivided => sys_clk,
         pre => {
             let pre: u8 = pre.into();
-            let pre = 1 << (pre as u32 - 7);
+            let pre = 1u32 << (pre as u32 - 7);
             sys_clk / pre
         }
     };
 
-    let (apb1_freq, apb1_tim_freq) = match config.apb1_pre {
-        APBPrescaler::NotDivided => (ahb_freq, ahb_freq),
+    let (apb1_clk, apb1_tim_clk) = match config.apb1_pre {
+        APBPrescaler::NotDivided => (ahb1_clk, ahb1_clk),
         pre => {
             let pre: u8 = pre.into();
             let pre: u8 = 1 << (pre - 3);
-            let freq = ahb_freq / pre as u32;
-            (freq, freq * 2)
+            let freq = ahb1_clk / pre as u32;
+            (freq, freq * 2u32)
         }
     };
 
-    let (apb2_freq, apb2_tim_freq) = match config.apb2_pre {
-        APBPrescaler::NotDivided => (ahb_freq, ahb_freq),
+    let (apb2_clk, apb2_tim_clk) = match config.apb2_pre {
+        APBPrescaler::NotDivided => (ahb1_clk, ahb1_clk),
         pre => {
             let pre: u8 = pre.into();
             let pre: u8 = 1 << (pre - 3);
-            let freq = ahb_freq / pre as u32;
-            (freq, freq * 2)
+            let freq = ahb1_clk / pre as u32;
+            (freq, freq * 2u32)
         }
     };
 
-    set_freqs(Clocks {
-        sys: Hertz(sys_clk),
-        ahb1: Hertz(ahb_freq),
-        ahb2: Hertz(ahb_freq),
-        ahb3: Hertz(ahb_freq),
-        apb1: Hertz(apb1_freq),
-        apb2: Hertz(apb2_freq),
-        apb1_tim: Hertz(apb1_tim_freq),
-        apb2_tim: Hertz(apb2_tim_freq),
+    Clocks {
+        sys: sys_clk,
+        ahb1: ahb1_clk,
+        ahb2: ahb2_clk,
+        ahb3: ahb3_clk,
+        apb1: apb1_clk,
+        apb2: apb2_clk,
+        apb1_tim: apb1_tim_clk,
+        apb2_tim: apb2_tim_clk,
+    }
+}
+
+pub(crate) fn configure_clocks(config: &Config) {
+    let pwr = crate::pac::PWR;
+    let rcc = crate::pac::RCC;
+
+    let needs_hsi = if let Some(pll_mux) = &config.mux {
+        pll_mux.source == PllSource::Hsi
+    } else {
+        false
+    };
+
+    if needs_hsi || config.sys == Sysclk::HSI {
+        rcc.cr().modify(|w| {
+            w.set_hsion(true);
+        });
+
+        while !rcc.cr().read().hsirdy() {}
+    }
+
+    match &config.lse {
+        Some(_) => {
+            rcc.cfgr().modify(|w| w.set_stopwuck(true));
+
+            pwr.cr1().modify(|w| w.set_dbp(true));
+            pwr.cr1().modify(|w| w.set_dbp(true));
+
+            rcc.bdcr().modify(|w| w.set_lseon(true));
+        }
+        _ => {}
+    }
+
+    match &config.hse {
+        Some(hse) => {
+            rcc.cr().modify(|w| {
+                w.set_hsepre(hse.prediv.into());
+                w.set_hseon(true);
+            });
+
+            while !rcc.cr().read().hserdy() {}
+        }
+        _ => {}
+    }
+
+    match &config.mux {
+        Some(pll_mux) => {
+            rcc.pllcfgr().modify(|w| {
+                w.set_pllm(pll_mux.prediv);
+                w.set_pllsrc(pll_mux.source.into());
+            });
+        }
+        _ => {}
+    };
+
+    match &config.pll {
+        Some(pll) => {
+            rcc.pllcfgr().modify(|w| {
+                w.set_plln((pll.mul - 1) as u8);
+                pll.divp.map(|divp| {
+                    w.set_pllpen(true);
+                    w.set_pllp((divp - 1) as u8)
+                });
+                pll.divq.map(|divq| {
+                    w.set_pllqen(true);
+                    w.set_pllq((divq - 1) as u8)
+                });
+                pll.divr.map(|divr| w.set_pllr((divr - 1) as u8));
+            });
+
+            rcc.cr().modify(|w| w.set_pllon(true));
+
+            while !rcc.cr().read().pllrdy() {}
+        }
+        _ => {}
+    }
+
+    rcc.cfgr().modify(|w| {
+        w.set_sw(config.sys.into());
+        w.set_hpre(config.ahb1_pre.into());
+        w.set_ppre1(config.apb1_pre.into());
+        w.set_ppre2(config.apb2_pre.into());
+
+        w.set_ppre1(config.apb1_pre.into());
+        w.set_ppre2(config.apb2_pre.into());
+    });
+
+    rcc.extcfgr().modify(|w| {
+        w.set_c2hpre(config.ahb2_pre.into());
+        w.set_shdhpre(config.ahb3_pre.into());
     });
 }
-- 
cgit 


From 2a0fe7304595497b3458b350574ed788a5a07876 Mon Sep 17 00:00:00 2001
From: chemicstry <chemicstry@gmail.com>
Date: Mon, 24 Jul 2023 17:46:03 +0300
Subject: stm32/can: bxcan async enable

---
 embassy-stm32/src/can/bxcan.rs  | 12 ++++++++++++
 examples/stm32f4/src/bin/can.rs |  7 +++++--
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/embassy-stm32/src/can/bxcan.rs b/embassy-stm32/src/can/bxcan.rs
index 5a0153464..8b8244d4f 100644
--- a/embassy-stm32/src/can/bxcan.rs
+++ b/embassy-stm32/src/can/bxcan.rs
@@ -161,6 +161,18 @@ impl<'d, T: Instance> Can<'d, T> {
             .leave_disabled();
     }
 
+    /// Enables the peripheral and synchronizes with the bus.
+    ///
+    /// This will wait for 11 consecutive recessive bits (bus idle state).
+    /// Contrary to enable method from bxcan library, this will not freeze the executor while waiting.
+    pub async fn enable(&mut self) {
+        while self.borrow_mut().enable_non_blocking().is_err() {
+            // SCE interrupt is only generated for entering sleep mode, but not leaving.
+            // Yield to allow other tasks to execute while can bus is initializing.
+            embassy_futures::yield_now().await;
+        }
+    }
+
     /// Queues the message to be sent but exerts backpressure
     pub async fn write(&mut self, frame: &Frame) -> bxcan::TransmitStatus {
         poll_fn(|cx| {
diff --git a/examples/stm32f4/src/bin/can.rs b/examples/stm32f4/src/bin/can.rs
index 08bed88db..f84f74d30 100644
--- a/examples/stm32f4/src/bin/can.rs
+++ b/examples/stm32f4/src/bin/can.rs
@@ -40,10 +40,13 @@ async fn main(_spawner: Spawner) {
 
     can.as_mut()
         .modify_config()
-        .set_bit_timing(0x001c0003) // http://www.bittiming.can-wiki.info/
         .set_loopback(true) // Receive own frames
         .set_silent(true)
-        .enable();
+        .leave_disabled();
+
+    can.set_bitrate(1_000_000);
+
+    can.enable().await;
 
     let mut i: u8 = 0;
     loop {
-- 
cgit 


From a60d92cfbbacc909ba781802cad04fe00e849026 Mon Sep 17 00:00:00 2001
From: Michael van Niekerk <mike@agri-io.co.za>
Date: Mon, 24 Jul 2023 22:20:00 +0200
Subject: Tx and Rx setup

---
 examples/rp/.idea/.gitignore    |   8 ++
 examples/rp/.idea/modules.xml   |   8 ++
 examples/rp/.idea/rp.iml        |  12 ++
 examples/rp/.idea/vcs.xml       |   6 +
 examples/rp/src/bin/pio_uart.rs | 262 ++++++++++++++++++++++++++++++++++++++++
 5 files changed, 296 insertions(+)
 create mode 100644 examples/rp/.idea/.gitignore
 create mode 100644 examples/rp/.idea/modules.xml
 create mode 100644 examples/rp/.idea/rp.iml
 create mode 100644 examples/rp/.idea/vcs.xml
 create mode 100644 examples/rp/src/bin/pio_uart.rs

diff --git a/examples/rp/.idea/.gitignore b/examples/rp/.idea/.gitignore
new file mode 100644
index 000000000..13566b81b
--- /dev/null
+++ b/examples/rp/.idea/.gitignore
@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
diff --git a/examples/rp/.idea/modules.xml b/examples/rp/.idea/modules.xml
new file mode 100644
index 000000000..06ff4b23d
--- /dev/null
+++ b/examples/rp/.idea/modules.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/rp.iml" filepath="$PROJECT_DIR$/.idea/rp.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file
diff --git a/examples/rp/.idea/rp.iml b/examples/rp/.idea/rp.iml
new file mode 100644
index 000000000..9b4cf845b
--- /dev/null
+++ b/examples/rp/.idea/rp.iml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file
diff --git a/examples/rp/.idea/vcs.xml b/examples/rp/.idea/vcs.xml
new file mode 100644
index 000000000..b2bdec2d7
--- /dev/null
+++ b/examples/rp/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/examples/rp/src/bin/pio_uart.rs b/examples/rp/src/bin/pio_uart.rs
new file mode 100644
index 000000000..14d05f4db
--- /dev/null
+++ b/examples/rp/src/bin/pio_uart.rs
@@ -0,0 +1,262 @@
+//! This example shows how to use USB (Universal Serial Bus) in the RP2040 chip.
+//!
+//! This creates a USB serial port that echos.
+
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::{info, panic};
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::{PIO0, USB};
+use embassy_rp::usb::{Driver, Instance, InterruptHandler};
+use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
+use embassy_usb::driver::EndpointError;
+use embassy_usb::{Builder, Config};
+use embassy_rp::pio::{InterruptHandler as PioInterruptHandler};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct UsbIrqs {
+    USBCTRL_IRQ => InterruptHandler<USB>;
+});
+
+bind_interrupts!(struct PioIrqs {
+    PIO0_IRQ_0 => PioInterruptHandler<PIO0>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    info!("Hello there!");
+
+    let p = embassy_rp::init(Default::default());
+
+    // Create the driver, from the HAL.
+    let driver = Driver::new(p.USB, UsbIrqs);
+
+    // Create embassy-usb Config
+    let mut config = Config::new(0xc0de, 0xcafe);
+    config.manufacturer = Some("Embassy");
+    config.product = Some("PIO UART example");
+    config.serial_number = Some("12345678");
+    config.max_power = 100;
+    config.max_packet_size_0 = 64;
+
+    // Required for windows compatibility.
+    // https://developer.nordicsemi.com/nRF_Connect_SDK/doc/1.9.1/kconfig/CONFIG_CDC_ACM_IAD.html#help
+    config.device_class = 0xEF;
+    config.device_sub_class = 0x02;
+    config.device_protocol = 0x01;
+    config.composite_with_iads = true;
+
+    // Create embassy-usb DeviceBuilder using the driver and config.
+    // It needs some buffers for building the descriptors.
+    let mut device_descriptor = [0; 256];
+    let mut config_descriptor = [0; 256];
+    let mut bos_descriptor = [0; 256];
+    let mut control_buf = [0; 64];
+
+    let mut state = State::new();
+
+    let mut builder = Builder::new(
+        driver,
+        config,
+        &mut device_descriptor,
+        &mut config_descriptor,
+        &mut bos_descriptor,
+        &mut control_buf,
+    );
+
+    // Create classes on the builder.
+    let mut class = CdcAcmClass::new(&mut builder, &mut state, 64);
+
+    // Build the builder.
+    let mut usb = builder.build();
+
+    // Run the USB device.
+    let usb_fut = usb.run();
+
+    // Do stuff with the class!
+    let echo_fut = async {
+        loop {
+            class.wait_connection().await;
+            info!("Connected");
+            let _ = echo(&mut class).await;
+            info!("Disconnected");
+        }
+    };
+
+    // Run everything concurrently.
+    // If we had made everything `'static` above instead, we could do this using separate tasks instead.
+    join(usb_fut, echo_fut).await;
+}
+
+struct Disconnected {}
+
+impl From<EndpointError> for Disconnected {
+    fn from(val: EndpointError) -> Self {
+        match val {
+            EndpointError::BufferOverflow => panic!("Buffer overflow"),
+            EndpointError::Disabled => Disconnected {},
+        }
+    }
+}
+
+async fn echo<'d, T: Instance + 'd>(class: &mut CdcAcmClass<'d, Driver<'d, T>>) -> Result<(), Disconnected> {
+    let mut buf = [0; 64];
+    loop {
+        let n = class.read_packet(&mut buf).await?;
+        let data = &buf[..n];
+        info!("data: {:x}", data);
+        class.write_packet(data).await?;
+    }
+}
+
+mod uart {
+    use embassy_rp::peripherals::PIO0;
+    use embassy_rp::pio::{Common, Pio, PioPin, StateMachine};
+    use embassy_rp::Peripheral;
+
+    use crate::PioIrqs;
+
+    pub struct PioUart<'a> {
+        baud: u64,
+        pio: Common<'a, PIO0>,
+        sm0: StateMachine<'a, PIO0, 0>,
+        sm1: StateMachine<'a, PIO0, 1>,
+    }
+
+    impl<'a> PioUart<'a> {
+        pub async fn new(
+            baud: u64,
+            pio: impl Peripheral<P = PIO0> + 'a,
+            tx_pin: impl PioPin,
+            rx_pin: impl PioPin,
+        ) -> PioUart<'a> {
+            let Pio {
+                mut common,
+                mut sm0,
+                mut sm1,
+                ..
+            } = Pio::new(pio, PioIrqs);
+
+            crate::uart_tx::setup_uart_tx_on_sm0(&mut common, &mut sm0, tx_pin, baud);
+            crate::uart_rx::setup_uart_rx_on_sm1(&mut common, &mut sm1, rx_pin, baud);
+
+            PioUart {
+                baud,
+                pio: common,
+                sm0,
+                sm1,
+            }
+        }
+    }
+}
+
+mod uart_tx {
+    use embassy_rp::gpio::Level;
+    use embassy_rp::peripherals::PIO0;
+    use embassy_rp::pio::{Common, Config, Direction, FifoJoin, PioPin, ShiftDirection, StateMachine};
+    use embassy_rp::relocate::RelocatedProgram;
+    use fixed::traits::ToFixed;
+    use fixed_macro::types::U56F8;
+
+    pub fn setup_uart_tx_on_sm0<'a>(
+        common: &mut Common<'a, PIO0>,
+        sm_tx: &mut StateMachine<'a, PIO0, 0>,
+        tx_pin: impl PioPin,
+        baud: u64,
+    ) {
+        let prg = pio_proc::pio_asm!(
+            r#"
+                ;.program uart_tx
+                .side_set 1 opt
+
+                ; An 8n1 UART transmit program.
+                ; OUT pin 0 and side-set pin 0 are both mapped to UART TX pin.
+
+                    pull       side 1 [7]  ; Assert stop bit, or stall with line in idle state
+                    set x, 7   side 0 [7]  ; Preload bit counter, assert start bit for 8 clocks
+                bitloop:                   ; This loop will run 8 times (8n1 UART)
+                    out pins, 1            ; Shift 1 bit from OSR to the first OUT pin
+                    jmp x-- bitloop   [6]  ; Each loop iteration is 8 cycles.
+            "#
+        );
+        let tx_pin = common.make_pio_pin(tx_pin);
+        sm_tx.set_pins(Level::High, &[&tx_pin]);
+        sm_tx.set_pin_dirs(Direction::Out, &[&tx_pin]);
+
+        let relocated = RelocatedProgram::new(&prg.program);
+        let mut cfg = Config::default();
+
+        cfg.use_program(&common.load_program(&relocated), &[&tx_pin]);
+        cfg.clock_divider = (U56F8!(125_000_000) / (8 * baud)).to_fixed();
+        cfg.shift_out.auto_fill = false;
+        cfg.shift_out.direction = ShiftDirection::Right;
+        cfg.fifo_join = FifoJoin::TxOnly;
+        cfg.set_out_pins(&[&tx_pin]);
+        cfg.set_set_pins(&[&tx_pin]);
+        sm_tx.set_config(&cfg);
+        sm_tx.set_enable(true)
+    }
+}
+
+mod uart_rx {
+    use embassy_rp::gpio::Level;
+    use embassy_rp::peripherals::PIO0;
+    use embassy_rp::pio::{Common, Config, Direction, FifoJoin, PioPin, ShiftDirection, StateMachine};
+    use embassy_rp::relocate::RelocatedProgram;
+    use fixed::traits::ToFixed;
+    use fixed_macro::types::U56F8;
+
+    pub fn setup_uart_rx_on_sm1<'a>(
+        common: &mut Common<'a, PIO0>,
+        sm_rx: &mut StateMachine<'a, PIO0, 1>,
+        rx_pin: impl PioPin,
+        baud: u64,
+    ) {
+        let prg = pio_proc::pio_asm!(
+            r#"
+                ;.program uart_rx
+
+                ; Slightly more fleshed-out 8n1 UART receiver which handles framing errors and
+                ; break conditions more gracefully.
+                ; IN pin 0 and JMP pin are both mapped to the GPIO used as UART RX.
+
+                start:
+                    wait 0 pin 0        ; Stall until start bit is asserted
+                    set x, 7    [10]    ; Preload bit counter, then delay until halfway through
+                bitloop:                ; the first data bit (12 cycles incl wait, set).
+                    in pins, 1          ; Shift data bit into ISR
+                    jmp x-- bitloop [6] ; Loop 8 times, each loop iteration is 8 cycles
+                    jmp pin good_stop   ; Check stop bit (should be high)
+
+                    irq 4 rel           ; Either a framing error or a break. Set a sticky flag,
+                    wait 1 pin 0        ; and wait for line to return to idle state.
+                    jmp start           ; Don't push data if we didn't see good framing.
+
+                good_stop:              ; No delay before returning to start; a little slack is
+                    push                ; important in case the TX clock is slightly too fast.
+            "#
+        );
+
+        let rx_pin = common.make_pio_pin(rx_pin);
+        sm_rx.set_pins(Level::High, &[&rx_pin]);
+        sm_rx.set_pin_dirs(Direction::In, &[&rx_pin]);
+
+        let relocated = RelocatedProgram::new(&prg.program);
+        let mut cfg = Config::default();
+
+        cfg.use_program(&common.load_program(&relocated), &[&rx_pin]);
+        cfg.clock_divider = (U56F8!(125_000_000) / (8 * baud)).to_fixed();
+        cfg.shift_out.auto_fill = false;
+        cfg.shift_out.direction = ShiftDirection::Right;
+        cfg.fifo_join = FifoJoin::RxOnly;
+        cfg.set_in_pins(&[&rx_pin]);
+        cfg.set_jmp_pin(&rx_pin);
+        // cfg.set_set_pins(&[&rx_pin]);
+        sm_rx.set_config(&cfg);
+        sm_rx.set_enable(true)
+    }
+}
-- 
cgit 


From 1425dda0a76da5da44de4c2fb7d04fc5a02cfc8a Mon Sep 17 00:00:00 2001
From: xoviat <xoviat@users.noreply.github.com>
Date: Mon, 24 Jul 2023 17:19:45 -0500
Subject: stm32/rcc: fix minor issues

---
 embassy-stm32/src/rcc/wb.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/embassy-stm32/src/rcc/wb.rs b/embassy-stm32/src/rcc/wb.rs
index 41f602c02..91a11a95d 100644
--- a/embassy-stm32/src/rcc/wb.rs
+++ b/embassy-stm32/src/rcc/wb.rs
@@ -191,7 +191,7 @@ impl Default for Config {
                 prediv: HsePrescaler::NotDivided,
             }),
             lse: Some(khz(32)),
-            sys: Sysclk::HSI,
+            sys: Sysclk::Pll,
             mux: Some(PllMux {
                 source: PllSource::Hse,
                 prediv: 2,
@@ -363,7 +363,7 @@ pub(crate) fn configure_clocks(config: &Config) {
     match &config.pll {
         Some(pll) => {
             rcc.pllcfgr().modify(|w| {
-                w.set_plln((pll.mul - 1) as u8);
+                w.set_plln(pll.mul as u8);
                 pll.divp.map(|divp| {
                     w.set_pllpen(true);
                     w.set_pllp((divp - 1) as u8)
@@ -372,7 +372,10 @@ pub(crate) fn configure_clocks(config: &Config) {
                     w.set_pllqen(true);
                     w.set_pllq((divq - 1) as u8)
                 });
-                pll.divr.map(|divr| w.set_pllr((divr - 1) as u8));
+                pll.divr.map(|divr| {
+                    // w.set_pllren(true);
+                    w.set_pllr((divr - 1) as u8);
+                });
             });
 
             rcc.cr().modify(|w| w.set_pllon(true));
@@ -387,9 +390,6 @@ pub(crate) fn configure_clocks(config: &Config) {
         w.set_hpre(config.ahb1_pre.into());
         w.set_ppre1(config.apb1_pre.into());
         w.set_ppre2(config.apb2_pre.into());
-
-        w.set_ppre1(config.apb1_pre.into());
-        w.set_ppre2(config.apb2_pre.into());
     });
 
     rcc.extcfgr().modify(|w| {
-- 
cgit 


From 3c41784de87a8903ac72cea19da784c0152896fe Mon Sep 17 00:00:00 2001
From: xoviat <xoviat@users.noreply.github.com>
Date: Mon, 24 Jul 2023 18:08:23 -0500
Subject: stm32/usart: fix error msg for lptim

---
 embassy-stm32/src/usart/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/embassy-stm32/src/usart/mod.rs b/embassy-stm32/src/usart/mod.rs
index ea8e525ea..3b9226fdf 100644
--- a/embassy-stm32/src/usart/mod.rs
+++ b/embassy-stm32/src/usart/mod.rs
@@ -857,7 +857,7 @@ fn configure(r: Regs, config: &Config, pclk_freq: Hertz, kind: Kind, enable_rx:
         "Using {} oversampling, desired baudrate: {}, actual baudrate: {}",
         oversampling,
         config.baudrate,
-        pclk_freq.0 / div
+        (pclk_freq.0 * mul as u32) / div
     );
 
     r.cr2().write(|w| {
-- 
cgit 


From 270d1d59a0b6ab2f180376bb193c2495f14632b8 Mon Sep 17 00:00:00 2001
From: xoviat <xoviat@users.noreply.github.com>
Date: Mon, 24 Jul 2023 18:25:15 -0500
Subject: stm32/rcc: use wpan default only for wpan

---
 embassy-stm32/src/rcc/wb.rs     | 52 +++++++++++++++++++++++++++--------------
 tests/stm32/src/bin/wpan_ble.rs |  6 ++++-
 tests/stm32/src/bin/wpan_mac.rs |  6 ++++-
 3 files changed, 44 insertions(+), 20 deletions(-)

diff --git a/embassy-stm32/src/rcc/wb.rs b/embassy-stm32/src/rcc/wb.rs
index 91a11a95d..4322b950a 100644
--- a/embassy-stm32/src/rcc/wb.rs
+++ b/embassy-stm32/src/rcc/wb.rs
@@ -182,32 +182,48 @@ pub struct Config {
     pub apb2_pre: APBPrescaler,
 }
 
+pub const WPAN_DEFAULT: Config = Config {
+    hse: Some(Hse {
+        frequency: mhz(32),
+        prediv: HsePrescaler::NotDivided,
+    }),
+    lse: Some(khz(32)),
+    sys: Sysclk::Pll,
+    mux: Some(PllMux {
+        source: PllSource::Hse,
+        prediv: 2,
+    }),
+    pll48: None,
+
+    pll: Some(Pll {
+        mul: 12,
+        divp: Some(3),
+        divq: Some(4),
+        divr: Some(3),
+    }),
+    pllsai: None,
+
+    ahb1_pre: AHBPrescaler::NotDivided,
+    ahb2_pre: AHBPrescaler::Div2,
+    ahb3_pre: AHBPrescaler::NotDivided,
+    apb1_pre: APBPrescaler::NotDivided,
+    apb2_pre: APBPrescaler::NotDivided,
+};
+
 impl Default for Config {
     #[inline]
     fn default() -> Config {
         Config {
-            hse: Some(Hse {
-                frequency: mhz(32),
-                prediv: HsePrescaler::NotDivided,
-            }),
-            lse: Some(khz(32)),
-            sys: Sysclk::Pll,
-            mux: Some(PllMux {
-                source: PllSource::Hse,
-                prediv: 2,
-            }),
+            hse: None,
+            lse: None,
+            sys: Sysclk::HSI,
+            mux: None,
             pll48: None,
-
-            pll: Some(Pll {
-                mul: 12,
-                divp: Some(3),
-                divq: Some(4),
-                divr: Some(3),
-            }),
+            pll: None,
             pllsai: None,
 
             ahb1_pre: AHBPrescaler::NotDivided,
-            ahb2_pre: AHBPrescaler::Div2,
+            ahb2_pre: AHBPrescaler::NotDivided,
             ahb3_pre: AHBPrescaler::NotDivided,
             apb1_pre: APBPrescaler::NotDivided,
             apb2_pre: APBPrescaler::NotDivided,
diff --git a/tests/stm32/src/bin/wpan_ble.rs b/tests/stm32/src/bin/wpan_ble.rs
index 3ad8aca4e..452da77a4 100644
--- a/tests/stm32/src/bin/wpan_ble.rs
+++ b/tests/stm32/src/bin/wpan_ble.rs
@@ -12,6 +12,7 @@ use common::*;
 use embassy_executor::Spawner;
 use embassy_stm32::bind_interrupts;
 use embassy_stm32::ipcc::{Config, ReceiveInterruptHandler, TransmitInterruptHandler};
+use embassy_stm32::rcc::WPAN_DEFAULT;
 use embassy_stm32_wpan::hci::host::uart::UartHci;
 use embassy_stm32_wpan::hci::host::{AdvertisingFilterPolicy, EncryptionKey, HostHci, OwnAddressType};
 use embassy_stm32_wpan::hci::types::AdvertisingType;
@@ -40,7 +41,10 @@ async fn run_mm_queue(memory_manager: mm::MemoryManager) {
 
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
-    let p = embassy_stm32::init(config());
+    let mut config = config();
+    config.rcc = WPAN_DEFAULT;
+
+    let p = embassy_stm32::init(config);
     info!("Hello World!");
 
     let config = Config::default();
diff --git a/tests/stm32/src/bin/wpan_mac.rs b/tests/stm32/src/bin/wpan_mac.rs
index b04a19ee9..7eab2fd38 100644
--- a/tests/stm32/src/bin/wpan_mac.rs
+++ b/tests/stm32/src/bin/wpan_mac.rs
@@ -10,6 +10,7 @@ use common::*;
 use embassy_executor::Spawner;
 use embassy_stm32::bind_interrupts;
 use embassy_stm32::ipcc::{Config, ReceiveInterruptHandler, TransmitInterruptHandler};
+use embassy_stm32::rcc::WPAN_DEFAULT;
 use embassy_stm32_wpan::mac::commands::{AssociateRequest, GetRequest, ResetRequest, SetRequest};
 use embassy_stm32_wpan::mac::event::MacEvent;
 use embassy_stm32_wpan::mac::typedefs::{
@@ -31,7 +32,10 @@ async fn run_mm_queue(memory_manager: mm::MemoryManager) {
 
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
-    let p = embassy_stm32::init(config());
+    let mut config = config();
+    config.rcc = WPAN_DEFAULT;
+
+    let p = embassy_stm32::init(config);
     info!("Hello World!");
 
     let config = Config::default();
-- 
cgit 


From 858ddf6777d6df0e8c02921d29cd6a8095a7cdad Mon Sep 17 00:00:00 2001
From: Piotr Esden-Tempski <piotr@esden.net>
Date: Wed, 26 Jul 2023 18:32:40 -0700
Subject: Added debug=2 in release profile to all examples.

This makes rtt output work right when using `cargo run` in release mode.

Debug was already enabled for release builds in some of the examples but
not all.
---
 examples/nrf-rtos-trace/Cargo.toml | 3 +++
 examples/nrf52840-rtic/Cargo.toml  | 3 +++
 examples/nrf52840/Cargo.toml       | 3 +++
 examples/nrf5340/Cargo.toml        | 3 +++
 examples/rp/Cargo.toml             | 3 ++-
 examples/std/Cargo.toml            | 3 +++
 examples/stm32c0/Cargo.toml        | 3 +++
 examples/stm32f0/Cargo.toml        | 3 +++
 examples/stm32f1/Cargo.toml        | 3 +++
 examples/stm32f2/Cargo.toml        | 3 +++
 examples/stm32f3/Cargo.toml        | 3 +++
 examples/stm32f7/Cargo.toml        | 3 +++
 examples/stm32g0/Cargo.toml        | 3 +++
 examples/stm32g4/Cargo.toml        | 3 +++
 examples/stm32l0/Cargo.toml        | 3 +++
 examples/stm32l1/Cargo.toml        | 3 +++
 examples/stm32l4/Cargo.toml        | 3 +++
 examples/stm32l5/Cargo.toml        | 3 +++
 examples/stm32u5/Cargo.toml        | 3 +++
 examples/stm32wb/Cargo.toml        | 3 +++
 examples/stm32wl/Cargo.toml        | 3 +++
 examples/wasm/Cargo.toml           | 3 +++
 22 files changed, 65 insertions(+), 1 deletion(-)

diff --git a/examples/nrf-rtos-trace/Cargo.toml b/examples/nrf-rtos-trace/Cargo.toml
index 30b67b7b2..068474e7a 100644
--- a/examples/nrf-rtos-trace/Cargo.toml
+++ b/examples/nrf-rtos-trace/Cargo.toml
@@ -34,3 +34,6 @@ log = { version = "0.4.17", optional = true }
 [[bin]]
 name = "rtos_trace"
 required-features = ["nightly"]
+
+[profile.release]
+debug = 2
diff --git a/examples/nrf52840-rtic/Cargo.toml b/examples/nrf52840-rtic/Cargo.toml
index ded3b7db8..715f1ecfe 100644
--- a/examples/nrf52840-rtic/Cargo.toml
+++ b/examples/nrf52840-rtic/Cargo.toml
@@ -19,3 +19,6 @@ cortex-m = { version = "0.7.6", features = ["inline-asm", "critical-section-sing
 cortex-m-rt = "0.7.0"
 panic-probe = { version = "0.3", features = ["print-defmt"] }
 futures = { version = "0.3.17", default-features = false, features = ["async-await"] }
+
+[profile.release]
+debug = 2
diff --git a/examples/nrf52840/Cargo.toml b/examples/nrf52840/Cargo.toml
index 9b41ec5ab..5d6bf54e8 100644
--- a/examples/nrf52840/Cargo.toml
+++ b/examples/nrf52840/Cargo.toml
@@ -59,3 +59,6 @@ microfft = "0.5.0"
 
 [patch.crates-io]
 lora-phy = { git = "https://github.com/embassy-rs/lora-phy", rev = "ad289428fd44b02788e2fa2116445cc8f640a265" }
+
+[profile.release]
+debug = 2
diff --git a/examples/nrf5340/Cargo.toml b/examples/nrf5340/Cargo.toml
index f1d45f336..b0e51dcf4 100644
--- a/examples/nrf5340/Cargo.toml
+++ b/examples/nrf5340/Cargo.toml
@@ -53,3 +53,6 @@ rand = { version = "0.8.4", default-features = false }
 embedded-storage = "0.3.0"
 usbd-hid = "0.6.0"
 serde = { version = "1.0.136", default-features = false }
+
+[profile.release]
+debug = 2
diff --git a/examples/rp/Cargo.toml b/examples/rp/Cargo.toml
index c812cb3ee..f2fe5da4e 100644
--- a/examples/rp/Cargo.toml
+++ b/examples/rp/Cargo.toml
@@ -53,7 +53,8 @@ pio = "0.2.1"
 rand = { version = "0.8.5", default-features = false }
 
 [profile.release]
-debug = true
+debug = 2
 
 [patch.crates-io]
 lora-phy = { git = "https://github.com/embassy-rs/lora-phy", rev = "ad289428fd44b02788e2fa2116445cc8f640a265" }
+
diff --git a/examples/std/Cargo.toml b/examples/std/Cargo.toml
index 92933ab50..42adede10 100644
--- a/examples/std/Cargo.toml
+++ b/examples/std/Cargo.toml
@@ -23,3 +23,6 @@ clap = { version = "3.0.0-beta.5", features = ["derive"] }
 rand_core = { version = "0.6.3", features = ["std"] }
 heapless = { version = "0.7.5", default-features = false }
 static_cell = { version = "1.1", features = ["nightly"]}
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32c0/Cargo.toml b/examples/stm32c0/Cargo.toml
index e74c5357b..8534921ab 100644
--- a/examples/stm32c0/Cargo.toml
+++ b/examples/stm32c0/Cargo.toml
@@ -20,3 +20,6 @@ embedded-hal = "0.2.6"
 panic-probe = { version = "0.3", features = ["print-defmt"] }
 futures = { version = "0.3.17", default-features = false, features = ["async-await"] }
 heapless = { version = "0.7.5", default-features = false }
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32f0/Cargo.toml b/examples/stm32f0/Cargo.toml
index 620a139ae..46b6db45c 100644
--- a/examples/stm32f0/Cargo.toml
+++ b/examples/stm32f0/Cargo.toml
@@ -18,3 +18,6 @@ embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["de
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "executor-interrupt", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
 static_cell = { version = "1.1", features = ["nightly"]}
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32f1/Cargo.toml b/examples/stm32f1/Cargo.toml
index 8450c541f..5d32992cd 100644
--- a/examples/stm32f1/Cargo.toml
+++ b/examples/stm32f1/Cargo.toml
@@ -26,3 +26,6 @@ nb = "1.0.0"
 
 [profile.dev]
 opt-level = "s"
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32f2/Cargo.toml b/examples/stm32f2/Cargo.toml
index 147e2ecbf..9857fb631 100644
--- a/examples/stm32f2/Cargo.toml
+++ b/examples/stm32f2/Cargo.toml
@@ -21,3 +21,6 @@ panic-probe = { version = "0.3", features = ["print-defmt"] }
 futures = { version = "0.3.17", default-features = false, features = ["async-await"] }
 heapless = { version = "0.7.5", default-features = false }
 nb = "1.0.0"
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32f3/Cargo.toml b/examples/stm32f3/Cargo.toml
index 6ac5d57e9..bd594d16a 100644
--- a/examples/stm32f3/Cargo.toml
+++ b/examples/stm32f3/Cargo.toml
@@ -25,3 +25,6 @@ heapless = { version = "0.7.5", default-features = false }
 nb = "1.0.0"
 embedded-storage = "0.3.0"
 static_cell = { version = "1.1", features = ["nightly"]}
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32f7/Cargo.toml b/examples/stm32f7/Cargo.toml
index bbc99fee0..a6964c7bc 100644
--- a/examples/stm32f7/Cargo.toml
+++ b/examples/stm32f7/Cargo.toml
@@ -28,3 +28,6 @@ rand_core = "0.6.3"
 critical-section = "1.1"
 embedded-storage = "0.3.0"
 static_cell = { version = "1.1", features = ["nightly"]}
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32g0/Cargo.toml b/examples/stm32g0/Cargo.toml
index 4a14568ac..b4dfe3c6b 100644
--- a/examples/stm32g0/Cargo.toml
+++ b/examples/stm32g0/Cargo.toml
@@ -20,3 +20,6 @@ embedded-hal = "0.2.6"
 panic-probe = { version = "0.3", features = ["print-defmt"] }
 futures = { version = "0.3.17", default-features = false, features = ["async-await"] }
 heapless = { version = "0.7.5", default-features = false }
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32g4/Cargo.toml b/examples/stm32g4/Cargo.toml
index 935997a74..ce8838605 100644
--- a/examples/stm32g4/Cargo.toml
+++ b/examples/stm32g4/Cargo.toml
@@ -22,3 +22,6 @@ embedded-hal = "0.2.6"
 panic-probe = { version = "0.3", features = ["print-defmt"] }
 futures = { version = "0.3.17", default-features = false, features = ["async-await"] }
 heapless = { version = "0.7.5", default-features = false }
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32l0/Cargo.toml b/examples/stm32l0/Cargo.toml
index e6a5a4c14..f2ebae775 100644
--- a/examples/stm32l0/Cargo.toml
+++ b/examples/stm32l0/Cargo.toml
@@ -36,3 +36,6 @@ static_cell = "1.1"
 
 [patch.crates-io]
 lora-phy = { git = "https://github.com/embassy-rs/lora-phy", rev = "ad289428fd44b02788e2fa2116445cc8f640a265" }
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32l1/Cargo.toml b/examples/stm32l1/Cargo.toml
index dcca1cc3d..329d44cac 100644
--- a/examples/stm32l1/Cargo.toml
+++ b/examples/stm32l1/Cargo.toml
@@ -20,3 +20,6 @@ panic-probe = { version = "0.3", features = ["print-defmt"] }
 futures = { version = "0.3.17", default-features = false, features = ["async-await"] }
 heapless = { version = "0.7.5", default-features = false }
 embedded-storage = "0.3.0"
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32l4/Cargo.toml b/examples/stm32l4/Cargo.toml
index 41c9869bf..0f770e2f0 100644
--- a/examples/stm32l4/Cargo.toml
+++ b/examples/stm32l4/Cargo.toml
@@ -27,3 +27,6 @@ heapless = { version = "0.7.5", default-features = false }
 chrono = { version = "^0.4", default-features = false }
 
 micromath = "2.0.0"
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32l5/Cargo.toml b/examples/stm32l5/Cargo.toml
index 5d66c59c3..1afd00398 100644
--- a/examples/stm32l5/Cargo.toml
+++ b/examples/stm32l5/Cargo.toml
@@ -27,3 +27,6 @@ heapless = { version = "0.7.5", default-features = false }
 rand_core = { version = "0.6.3", default-features = false }
 embedded-io = { version = "0.4.0", features = ["async"] }
 static_cell = { version = "1.1", features = ["nightly"]}
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32u5/Cargo.toml b/examples/stm32u5/Cargo.toml
index a43a55909..db251eafe 100644
--- a/examples/stm32u5/Cargo.toml
+++ b/examples/stm32u5/Cargo.toml
@@ -23,3 +23,6 @@ futures = { version = "0.3.17", default-features = false, features = ["async-awa
 heapless = { version = "0.7.5", default-features = false }
 
 micromath = "2.0.0"
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32wb/Cargo.toml b/examples/stm32wb/Cargo.toml
index 48e340264..1a5aff352 100644
--- a/examples/stm32wb/Cargo.toml
+++ b/examples/stm32wb/Cargo.toml
@@ -52,3 +52,6 @@ required-features = ["ble"]
 [[bin]] 
 name = "gatt_server"
 required-features = ["ble"]
+
+[profile.release]
+debug = 2
diff --git a/examples/stm32wl/Cargo.toml b/examples/stm32wl/Cargo.toml
index 6e6f269aa..3e99b1018 100644
--- a/examples/stm32wl/Cargo.toml
+++ b/examples/stm32wl/Cargo.toml
@@ -30,3 +30,6 @@ chrono = { version = "^0.4", default-features = false }
 
 [patch.crates-io]
 lora-phy = { git = "https://github.com/embassy-rs/lora-phy", rev = "ad289428fd44b02788e2fa2116445cc8f640a265" }
+
+[profile.release]
+debug = 2
diff --git a/examples/wasm/Cargo.toml b/examples/wasm/Cargo.toml
index 3679e3857..2791cc341 100644
--- a/examples/wasm/Cargo.toml
+++ b/examples/wasm/Cargo.toml
@@ -17,3 +17,6 @@ wasm-bindgen = "0.2"
 web-sys = { version = "0.3", features = ["Document", "Element", "HtmlElement", "Node", "Window" ] }
 log = "0.4.11"
 critical-section = { version = "1.1", features = ["std"] }
+
+[profile.release]
+debug = 2
-- 
cgit 


From c54ae73d4999fdf6243adeedcde1467493c8935a Mon Sep 17 00:00:00 2001
From: ceekdee <taigatensor@gmail.com>
Date: Wed, 26 Jul 2023 21:51:09 -0500
Subject: Use lora-phy v1.2.1; modify embassy-lora dependencies.

---
 embassy-lora/Cargo.toml      | 13 +++----------
 examples/nrf52840/Cargo.toml |  3 ---
 examples/rp/Cargo.toml       |  3 ---
 examples/stm32l0/Cargo.toml  |  3 ---
 examples/stm32wl/Cargo.toml  |  3 ---
 5 files changed, 3 insertions(+), 22 deletions(-)

diff --git a/embassy-lora/Cargo.toml b/embassy-lora/Cargo.toml
index e4524af5b..c4857ace0 100644
--- a/embassy-lora/Cargo.toml
+++ b/embassy-lora/Cargo.toml
@@ -12,7 +12,7 @@ target = "thumbv7em-none-eabi"
 
 [features]
 stm32wl = ["dep:embassy-stm32"]
-time = []
+time = ["dep:embassy-time", "dep:lorawan-device"]
 defmt = ["dep:defmt", "lorawan-device/defmt"]
 
 [dependencies]
@@ -20,18 +20,11 @@ defmt = ["dep:defmt", "lorawan-device/defmt"]
 defmt = { version = "0.3", optional = true }
 log = { version = "0.4.14", optional = true }
 
-embassy-time = { version = "0.1.2", path = "../embassy-time" }
+embassy-time = { version = "0.1.2", path = "../embassy-time", optional = true }
 embassy-sync = { version = "0.2.0", path = "../embassy-sync" }
 embassy-stm32 = { version = "0.1.0", path = "../embassy-stm32", default-features = false, optional = true }
-embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-alpha.11" }
 embedded-hal-async = { version = "=0.2.0-alpha.2" }
-embassy-hal-common = { version = "0.1.0", path = "../embassy-hal-common", default-features = false }
-futures = { version = "0.3.17", default-features = false, features = [ "async-await" ] }
 embedded-hal = { version = "0.2", features = ["unproven"] }
-bit_field = { version = "0.10" }
 
 lora-phy = { version = "1" }
-lorawan-device = { version = "0.10.0", default-features = false, features = ["async"] }
-
-[patch.crates-io]
-lora-phy = { git = "https://github.com/embassy-rs/lora-phy", rev = "ad289428fd44b02788e2fa2116445cc8f640a265" }
+lorawan-device = { version = "0.10.0", default-features = false, features = ["async"], optional = true }
diff --git a/examples/nrf52840/Cargo.toml b/examples/nrf52840/Cargo.toml
index 9b41ec5ab..f39f9323f 100644
--- a/examples/nrf52840/Cargo.toml
+++ b/examples/nrf52840/Cargo.toml
@@ -56,6 +56,3 @@ serde = { version = "1.0.136", default-features = false }
 embedded-hal-async = { version = "0.2.0-alpha.2", optional = true }
 num-integer = { version = "0.1.45", default-features = false }
 microfft = "0.5.0"
-
-[patch.crates-io]
-lora-phy = { git = "https://github.com/embassy-rs/lora-phy", rev = "ad289428fd44b02788e2fa2116445cc8f640a265" }
diff --git a/examples/rp/Cargo.toml b/examples/rp/Cargo.toml
index c812cb3ee..8a675443a 100644
--- a/examples/rp/Cargo.toml
+++ b/examples/rp/Cargo.toml
@@ -54,6 +54,3 @@ rand = { version = "0.8.5", default-features = false }
 
 [profile.release]
 debug = true
-
-[patch.crates-io]
-lora-phy = { git = "https://github.com/embassy-rs/lora-phy", rev = "ad289428fd44b02788e2fa2116445cc8f640a265" }
diff --git a/examples/stm32l0/Cargo.toml b/examples/stm32l0/Cargo.toml
index e6a5a4c14..e794cf1eb 100644
--- a/examples/stm32l0/Cargo.toml
+++ b/examples/stm32l0/Cargo.toml
@@ -33,6 +33,3 @@ futures = { version = "0.3.17", default-features = false, features = ["async-awa
 heapless = { version = "0.7.5", default-features = false }
 embedded-hal = "0.2.6"
 static_cell = "1.1"
-
-[patch.crates-io]
-lora-phy = { git = "https://github.com/embassy-rs/lora-phy", rev = "ad289428fd44b02788e2fa2116445cc8f640a265" }
diff --git a/examples/stm32wl/Cargo.toml b/examples/stm32wl/Cargo.toml
index 6e6f269aa..b3f57af53 100644
--- a/examples/stm32wl/Cargo.toml
+++ b/examples/stm32wl/Cargo.toml
@@ -27,6 +27,3 @@ panic-probe = { version = "0.3", features = ["print-defmt"] }
 futures = { version = "0.3.17", default-features = false, features = ["async-await"] }
 heapless = { version = "0.7.5", default-features = false }
 chrono = { version = "^0.4", default-features = false }
-
-[patch.crates-io]
-lora-phy = { git = "https://github.com/embassy-rs/lora-phy", rev = "ad289428fd44b02788e2fa2116445cc8f640a265" }
-- 
cgit 


From 13acca624f4995e06cbe1606bee10015ecd31d06 Mon Sep 17 00:00:00 2001
From: ceekdee <taigatensor@gmail.com>
Date: Wed, 26 Jul 2023 22:23:02 -0500
Subject: Correct embassy-lora time feature

---
 embassy-lora/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/embassy-lora/Cargo.toml b/embassy-lora/Cargo.toml
index c4857ace0..a77ed003e 100644
--- a/embassy-lora/Cargo.toml
+++ b/embassy-lora/Cargo.toml
@@ -12,7 +12,7 @@ target = "thumbv7em-none-eabi"
 
 [features]
 stm32wl = ["dep:embassy-stm32"]
-time = ["dep:embassy-time", "dep:lorawan-device"]
+time = ["embassy-time", "lorawan-device"]
 defmt = ["dep:defmt", "lorawan-device/defmt"]
 
 [dependencies]
-- 
cgit 


From a6543cef16e74f8e935c92f0b4f3ef12b8f72f75 Mon Sep 17 00:00:00 2001
From: goueslati <ghaith.oueslati@habemus.com>
Date: Thu, 27 Jul 2023 15:00:01 +0100
Subject: wpan: update stm32wb-hci

---
 embassy-stm32-wpan/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/embassy-stm32-wpan/Cargo.toml b/embassy-stm32-wpan/Cargo.toml
index 6cd122200..2c6089c56 100644
--- a/embassy-stm32-wpan/Cargo.toml
+++ b/embassy-stm32-wpan/Cargo.toml
@@ -26,7 +26,7 @@ aligned = "0.4.1"
 
 bit_field = "0.10.2"
 stm32-device-signature = { version = "0.3.3", features = ["stm32wb5x"] }
-stm32wb-hci = { version = "0.1.3", optional = true }
+stm32wb-hci = { version = "0.1.4", optional = true }
 futures = { version = "0.3.17", default-features = false, features = ["async-await"] }
 bitflags = { version = "2.3.3", optional = true }
 
-- 
cgit 


From 93864610ce5d9127eb415f8020ec43c26fb20804 Mon Sep 17 00:00:00 2001
From: JuliDi <20155974+JuliDi@users.noreply.github.com>
Date: Thu, 27 Jul 2023 19:04:43 +0200
Subject: Add DAC HIL test with ADC

---
 tests/stm32/Cargo.toml     | 13 ++++++--
 tests/stm32/src/bin/dac.rs | 81 ++++++++++++++++++++++++++++++++++++++++++++++
 tests/stm32/src/common.rs  |  1 +
 3 files changed, 92 insertions(+), 3 deletions(-)
 create mode 100644 tests/stm32/src/bin/dac.rs

diff --git a/tests/stm32/Cargo.toml b/tests/stm32/Cargo.toml
index 3007cd1e6..17320649e 100644
--- a/tests/stm32/Cargo.toml
+++ b/tests/stm32/Cargo.toml
@@ -7,11 +7,11 @@ autobins = false
 
 [features]
 stm32f103c8 = ["embassy-stm32/stm32f103c8", "not-gpdma"]     # Blue Pill
-stm32f429zi = ["embassy-stm32/stm32f429zi", "chrono", "can", "not-gpdma"]     # Nucleo "sdmmc"
-stm32g071rb = ["embassy-stm32/stm32g071rb", "not-gpdma"]     # Nucleo
+stm32f429zi = ["embassy-stm32/stm32f429zi", "chrono", "can", "not-gpdma", "dac-adc-pin"]     # Nucleo "sdmmc"
+stm32g071rb = ["embassy-stm32/stm32g071rb", "not-gpdma", "dac-adc-pin"]     # Nucleo
 stm32c031c6 = ["embassy-stm32/stm32c031c6", "not-gpdma"]     # Nucleo
 stm32g491re = ["embassy-stm32/stm32g491re", "not-gpdma"]     # Nucleo
-stm32h755zi = ["embassy-stm32/stm32h755zi-cm7", "not-gpdma"] # Nucleo
+stm32h755zi = ["embassy-stm32/stm32h755zi-cm7", "not-gpdma", "dac-adc-pin"] # Nucleo
 stm32wb55rg = ["embassy-stm32/stm32wb55rg", "not-gpdma", "ble", "mac" ]     # Nucleo
 stm32h563zi = ["embassy-stm32/stm32h563zi"]     # Nucleo
 stm32u585ai = ["embassy-stm32/stm32u585ai"]     # IoT board
@@ -23,6 +23,7 @@ ble = ["dep:embassy-stm32-wpan", "embassy-stm32-wpan/ble"]
 mac = ["dep:embassy-stm32-wpan", "embassy-stm32-wpan/mac"]
 embassy-stm32-wpan = []
 not-gpdma = []
+dac-adc-pin = []
 
 [dependencies]
 teleprobe-meta = "1"
@@ -42,6 +43,7 @@ cortex-m-rt = "0.7.0"
 embedded-hal = "0.2.6"
 embedded-hal-1 = { package = "embedded-hal", version = "=1.0.0-alpha.11" }
 embedded-hal-async = { version = "=0.2.0-alpha.2" }
+micromath = "2.0.0"
 panic-probe = { version = "0.3.0", features = ["print-defmt"] }
 rand_core = { version = "0.6", default-features = false }
 rand_chacha = { version = "0.3", default-features = false }
@@ -55,6 +57,11 @@ name = "can"
 path = "src/bin/can.rs"
 required-features = [ "can",]
 
+[[bin]]
+name = "dac"
+path = "src/bin/dac.rs"
+required-features = [ "dac-adc-pin",]
+
 [[bin]]
 name = "gpio"
 path = "src/bin/gpio.rs"
diff --git a/tests/stm32/src/bin/dac.rs b/tests/stm32/src/bin/dac.rs
new file mode 100644
index 000000000..67a7d5b59
--- /dev/null
+++ b/tests/stm32/src/bin/dac.rs
@@ -0,0 +1,81 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+// required-features: dac-adc-pin
+
+#[path = "../common.rs"]
+mod common;
+use common::*;
+use defmt::assert;
+use embassy_executor::Spawner;
+use embassy_stm32::adc::Adc;
+use embassy_stm32::dac::{DacCh1, DacChannel, Value};
+use embassy_stm32::dma::NoDma;
+use embassy_time::{Delay, Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    // Initialize the board and obtain a Peripherals instance
+    let p: embassy_stm32::Peripherals = embassy_stm32::init(config());
+
+    #[cfg(feature = "stm32f429zi")]
+    let dac_peripheral = p.DAC;
+
+    #[cfg(any(feature = "stm32h755zi", feature = "stm32g071rb"))]
+    let dac_peripheral = p.DAC1;
+
+    let mut dac: DacCh1<'_, _, NoDma> = DacCh1::new(dac_peripheral, NoDma, p.PA4);
+    unwrap!(dac.set_trigger_enable(false));
+
+    let mut adc = Adc::new(p.ADC1, &mut Delay);
+
+    #[cfg(feature = "stm32h755zi")]
+    let normalization_factor = 256;
+    #[cfg(any(feature = "stm32f429zi", feature = "stm32g071rb"))]
+    let normalization_factor: i32 = 16;
+
+    unwrap!(dac.set(Value::Bit8(0)));
+    // Now wait a little to obtain a stable value
+    Timer::after(Duration::from_millis(30)).await;
+    let offset = adc.read(&mut unsafe { embassy_stm32::Peripherals::steal() }.PA4);
+
+    for v in 0..=255 {
+        // First set the DAC output value
+        let dac_output_val = to_sine_wave(v);
+        unwrap!(dac.set(Value::Bit8(dac_output_val)));
+
+        // Now wait a little to obtain a stable value
+        Timer::after(Duration::from_millis(30)).await;
+
+        // Need to steal the peripherals here because PA4 is obviously in use already
+        let measured = adc.read(&mut unsafe { embassy_stm32::Peripherals::steal() }.PA4);
+        // Calibrate and normalize the measurement to get close to the dac_output_val
+        let measured_normalized = ((measured as i32 - offset as i32) / normalization_factor) as i16;
+
+        info!("value / measured: {} / {}", dac_output_val, measured_normalized);
+
+        // The deviations are quite enormous but that does not matter since this is only a quick test
+        assert!((dac_output_val as i16 - measured_normalized).abs() < 15);
+    }
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
+
+use core::f32::consts::PI;
+
+use micromath::F32Ext;
+
+fn to_sine_wave(v: u8) -> u8 {
+    if v >= 128 {
+        // top half
+        let r = PI * ((v - 128) as f32 / 128.0);
+        (r.sin() * 128.0 + 127.0) as u8
+    } else {
+        // bottom half
+        let r = PI + PI * (v as f32 / 128.0);
+        (r.sin() * 128.0 + 127.0) as u8
+    }
+}
diff --git a/tests/stm32/src/common.rs b/tests/stm32/src/common.rs
index 3d2a9b8ef..ca5cb43ac 100644
--- a/tests/stm32/src/common.rs
+++ b/tests/stm32/src/common.rs
@@ -33,6 +33,7 @@ pub fn config() -> Config {
     {
         config.rcc.sys_ck = Some(Hertz(400_000_000));
         config.rcc.pll1.q_ck = Some(Hertz(100_000_000));
+        config.rcc.adc_clock_source = embassy_stm32::rcc::AdcClockSource::PerCk;
     }
 
     #[cfg(feature = "stm32u585ai")]
-- 
cgit 


From e947aa01533b7fd41133678ed8444a16c9c341e0 Mon Sep 17 00:00:00 2001
From: Michael van Niekerk <mike@agri-io.co.za>
Date: Fri, 28 Jul 2023 11:37:38 +0200
Subject: Comments

---
 examples/rp/Cargo.toml          |   1 +
 examples/rp/src/bin/pio_uart.rs | 351 +++++++++++++++++++++++++++++-----------
 2 files changed, 261 insertions(+), 91 deletions(-)

diff --git a/examples/rp/Cargo.toml b/examples/rp/Cargo.toml
index c812cb3ee..2a018ad04 100644
--- a/examples/rp/Cargo.toml
+++ b/examples/rp/Cargo.toml
@@ -7,6 +7,7 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 embassy-embedded-hal = { version = "0.1.0", path = "../../embassy-embedded-hal", features = ["defmt"] }
+embassy-hal-common = { version = "0.1.0", path = "../../embassy-hal-common", features = ["defmt"] }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "executor-interrupt", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["nightly", "unstable-traits", "defmt", "defmt-timestamp-uptime"] }
diff --git a/examples/rp/src/bin/pio_uart.rs b/examples/rp/src/bin/pio_uart.rs
index 14d05f4db..eeb213e1b 100644
--- a/examples/rp/src/bin/pio_uart.rs
+++ b/examples/rp/src/bin/pio_uart.rs
@@ -1,23 +1,35 @@
-//! This example shows how to use USB (Universal Serial Bus) in the RP2040 chip.
+//! This example shows how to use the PIO module in the RP2040 chip to implement a duplex UART.
+//! The PIO module is a very powerful peripheral that can be used to implement many different
+//! protocols. It is a very flexible state machine that can be programmed to do almost anything.
 //!
-//! This creates a USB serial port that echos.
+//! This example opens up a USB device that implements a CDC ACM serial port. It then uses the
+//! PIO module to implement a UART that is connected to the USB serial port. This allows you to
+//! communicate with a device connected to the RP2040 over USB serial.
 
 #![no_std]
 #![no_main]
 #![feature(type_alias_impl_trait)]
+#![feature(async_fn_in_trait)]
 
-use defmt::{info, panic};
+use defmt::{info, panic, trace};
 use embassy_executor::Spawner;
-use embassy_futures::join::join;
+use embassy_futures::join::{join, join3};
 use embassy_rp::bind_interrupts;
 use embassy_rp::peripherals::{PIO0, USB};
+use embassy_rp::pio::InterruptHandler as PioInterruptHandler;
 use embassy_rp::usb::{Driver, Instance, InterruptHandler};
-use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
+use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_sync::channel::Channel;
+use embassy_usb::class::cdc_acm::{CdcAcmClass, Receiver, Sender, State};
 use embassy_usb::driver::EndpointError;
 use embassy_usb::{Builder, Config};
-use embassy_rp::pio::{InterruptHandler as PioInterruptHandler};
+use embedded_io::asynch::{Read, Write};
 use {defmt_rtt as _, panic_probe as _};
 
+use crate::uart::PioUart;
+use crate::uart_rx::PioUartRx;
+use crate::uart_tx::PioUartTx;
+
 bind_interrupts!(struct UsbIrqs {
     USBCTRL_IRQ => InterruptHandler<USB>;
 });
@@ -69,7 +81,7 @@ async fn main(_spawner: Spawner) {
     );
 
     // Create classes on the builder.
-    let mut class = CdcAcmClass::new(&mut builder, &mut state, 64);
+    let class = CdcAcmClass::new(&mut builder, &mut state, 64);
 
     // Build the builder.
     let mut usb = builder.build();
@@ -77,19 +89,50 @@ async fn main(_spawner: Spawner) {
     // Run the USB device.
     let usb_fut = usb.run();
 
-    // Do stuff with the class!
-    let echo_fut = async {
+    // PIO UART setup
+    let uart = PioUart::new(9600, p.PIO0, p.PIN_4, p.PIN_5).await;
+    let (mut uart_tx, mut uart_rx) = uart.split();
+
+    // Channels setup
+    static USB_CHANNEL_TX: Channel<ThreadModeRawMutex, u8, 20> = Channel::<ThreadModeRawMutex, u8, 20>::new();
+    let mut usb_channel_tx_send = USB_CHANNEL_TX.sender();
+    let mut usb_channel_tx_recv = USB_CHANNEL_TX.receiver();
+
+    static UART_CHANNEL_TX: Channel<ThreadModeRawMutex, u8, 20> = Channel::<ThreadModeRawMutex, u8, 20>::new();
+    let mut uart_channel_tx_send = UART_CHANNEL_TX.sender();
+    let mut uart_channel_tx_recv = UART_CHANNEL_TX.receiver();
+
+    let (mut usb_tx, mut usb_rx) = class.split();
+
+    // Read + write from USB
+    let usb_future = async {
         loop {
-            class.wait_connection().await;
+            info!("Wait for USB connection");
+            usb_rx.wait_connection().await;
             info!("Connected");
-            let _ = echo(&mut class).await;
+            let _ = join(
+                usb_read(&mut usb_rx, &mut uart_channel_tx_send),
+                usb_write(&mut usb_tx, &mut usb_channel_tx_recv),
+            )
+            .await;
             info!("Disconnected");
         }
     };
 
+    // Read + write from UART
+    let uart_future = async {
+        loop {
+            let _ = join(
+                uart_read(&mut uart_rx, &mut usb_channel_tx_send),
+                uart_write(&mut uart_tx, &mut uart_channel_tx_recv),
+            )
+            .await;
+        }
+    };
+
     // Run everything concurrently.
     // If we had made everything `'static` above instead, we could do this using separate tasks instead.
-    join(usb_fut, echo_fut).await;
+    join3(usb_fut, usb_future, uart_future).await;
 }
 
 struct Disconnected {}
@@ -103,28 +146,79 @@ impl From<EndpointError> for Disconnected {
     }
 }
 
-async fn echo<'d, T: Instance + 'd>(class: &mut CdcAcmClass<'d, Driver<'d, T>>) -> Result<(), Disconnected> {
+/// Read from the USB and write it to the UART TX send channel
+async fn usb_read<'d, T: Instance + 'd>(
+    usb_rx: &mut Receiver<'d, Driver<'d, T>>,
+    uart_tx_send: &mut embassy_sync::channel::Sender<'d, ThreadModeRawMutex, u8, 20>,
+) -> Result<(), Disconnected> {
     let mut buf = [0; 64];
     loop {
-        let n = class.read_packet(&mut buf).await?;
+        let n = usb_rx.read_packet(&mut buf).await?;
         let data = &buf[..n];
-        info!("data: {:x}", data);
-        class.write_packet(data).await?;
+        trace!("USB IN: {:x}", data);
+        for byte in data {
+            uart_tx_send.send(*byte).await;
+        }
+    }
+}
+
+/// Read from the USB TX receive channel and write it to the USB
+async fn usb_write<'d, T: Instance + 'd>(
+    usb_tx: &mut Sender<'d, Driver<'d, T>>,
+    usb_tx_recv: &mut embassy_sync::channel::Receiver<'d, ThreadModeRawMutex, u8, 20>,
+) -> Result<(), Disconnected> {
+    loop {
+        let n = usb_tx_recv.recv().await;
+        let data = [n];
+        trace!("USB OUT: {:x}", data);
+        usb_tx.write_packet(&data).await?;
+    }
+}
+
+/// Read from the UART and write it to the USB TX send channel
+async fn uart_read<'a>(
+    uart_rx: &mut PioUartRx<'a>,
+    usb_tx_send: &mut embassy_sync::channel::Sender<'a, ThreadModeRawMutex, u8, 20>,
+) -> Result<(), Disconnected> {
+    let mut buf = [0; 1];
+    loop {
+        let n = uart_rx.read(&mut buf).await.expect("UART read error");
+        if n == 0 {
+            continue;
+        }
+        trace!("UART IN: {:x}", buf);
+        usb_tx_send.send(buf[0]).await;
+    }
+}
+
+/// Read from the UART TX receive channel and write it to the UART
+async fn uart_write<'a>(
+    uart_tx: &mut PioUartTx<'a>,
+    uart_rx_recv: &mut embassy_sync::channel::Receiver<'a, ThreadModeRawMutex, u8, 20>,
+) -> Result<(), Disconnected> {
+    loop {
+        let n = uart_rx_recv.recv().await;
+        let data = [n];
+        trace!("UART OUT: {:x}", data);
+        let _ = uart_tx.write(&data).await;
     }
 }
 
 mod uart {
+    use core::fmt::Debug;
+
     use embassy_rp::peripherals::PIO0;
-    use embassy_rp::pio::{Common, Pio, PioPin, StateMachine};
+    use embassy_rp::pio::{Pio, PioPin};
     use embassy_rp::Peripheral;
+    use embedded_io::ErrorKind;
 
+    use crate::uart_rx::PioUartRx;
+    use crate::uart_tx::PioUartTx;
     use crate::PioIrqs;
 
     pub struct PioUart<'a> {
-        baud: u64,
-        pio: Common<'a, PIO0>,
-        sm0: StateMachine<'a, PIO0, 0>,
-        sm1: StateMachine<'a, PIO0, 1>,
+        tx: PioUartTx<'a>,
+        rx: PioUartRx<'a>,
     }
 
     impl<'a> PioUart<'a> {
@@ -135,21 +229,25 @@ mod uart {
             rx_pin: impl PioPin,
         ) -> PioUart<'a> {
             let Pio {
-                mut common,
-                mut sm0,
-                mut sm1,
-                ..
+                mut common, sm0, sm1, ..
             } = Pio::new(pio, PioIrqs);
 
-            crate::uart_tx::setup_uart_tx_on_sm0(&mut common, &mut sm0, tx_pin, baud);
-            crate::uart_rx::setup_uart_rx_on_sm1(&mut common, &mut sm1, rx_pin, baud);
+            let (tx, origin) = PioUartTx::new(&mut common, sm0, tx_pin, baud, None);
+            let (rx, _) = PioUartRx::new(&mut common, sm1, rx_pin, baud, Some(origin));
 
-            PioUart {
-                baud,
-                pio: common,
-                sm0,
-                sm1,
-            }
+            PioUart { tx, rx }
+        }
+
+        pub fn split(self) -> (PioUartTx<'a>, PioUartRx<'a>) {
+            (self.tx, self.rx)
+        }
+    }
+    #[derive(defmt::Format, Debug)]
+    pub struct PioUartError {}
+
+    impl embedded_io::Error for PioUartError {
+        fn kind(&self) -> ErrorKind {
+            ErrorKind::Other
         }
     }
 }
@@ -159,18 +257,27 @@ mod uart_tx {
     use embassy_rp::peripherals::PIO0;
     use embassy_rp::pio::{Common, Config, Direction, FifoJoin, PioPin, ShiftDirection, StateMachine};
     use embassy_rp::relocate::RelocatedProgram;
+    use embedded_io::asynch::Write;
+    use embedded_io::Io;
     use fixed::traits::ToFixed;
     use fixed_macro::types::U56F8;
 
-    pub fn setup_uart_tx_on_sm0<'a>(
-        common: &mut Common<'a, PIO0>,
-        sm_tx: &mut StateMachine<'a, PIO0, 0>,
-        tx_pin: impl PioPin,
-        baud: u64,
-    ) {
-        let prg = pio_proc::pio_asm!(
-            r#"
-                ;.program uart_tx
+    use crate::uart::PioUartError;
+
+    pub struct PioUartTx<'a> {
+        sm_tx: StateMachine<'a, PIO0, 0>,
+    }
+
+    impl<'a> PioUartTx<'a> {
+        pub fn new(
+            common: &mut Common<'a, PIO0>,
+            mut sm_tx: StateMachine<'a, PIO0, 0>,
+            tx_pin: impl PioPin,
+            baud: u64,
+            origin: Option<u8>,
+        ) -> (Self, u8) {
+            let mut prg = pio_proc::pio_asm!(
+                r#"
                 .side_set 1 opt
 
                 ; An 8n1 UART transmit program.
@@ -182,23 +289,55 @@ mod uart_tx {
                     out pins, 1            ; Shift 1 bit from OSR to the first OUT pin
                     jmp x-- bitloop   [6]  ; Each loop iteration is 8 cycles.
             "#
-        );
-        let tx_pin = common.make_pio_pin(tx_pin);
-        sm_tx.set_pins(Level::High, &[&tx_pin]);
-        sm_tx.set_pin_dirs(Direction::Out, &[&tx_pin]);
-
-        let relocated = RelocatedProgram::new(&prg.program);
-        let mut cfg = Config::default();
-
-        cfg.use_program(&common.load_program(&relocated), &[&tx_pin]);
-        cfg.clock_divider = (U56F8!(125_000_000) / (8 * baud)).to_fixed();
-        cfg.shift_out.auto_fill = false;
-        cfg.shift_out.direction = ShiftDirection::Right;
-        cfg.fifo_join = FifoJoin::TxOnly;
-        cfg.set_out_pins(&[&tx_pin]);
-        cfg.set_set_pins(&[&tx_pin]);
-        sm_tx.set_config(&cfg);
-        sm_tx.set_enable(true)
+            );
+            prg.program.origin = origin;
+            let tx_pin = common.make_pio_pin(tx_pin);
+            sm_tx.set_pins(Level::High, &[&tx_pin]);
+            sm_tx.set_pin_dirs(Direction::Out, &[&tx_pin]);
+
+            let relocated = RelocatedProgram::new(&prg.program);
+
+            let mut cfg = Config::default();
+
+            cfg.set_out_pins(&[&tx_pin]);
+            cfg.use_program(&common.load_program(&relocated), &[&tx_pin]);
+            cfg.shift_out.auto_fill = false;
+            cfg.shift_out.direction = ShiftDirection::Right;
+            cfg.fifo_join = FifoJoin::TxOnly;
+            cfg.clock_divider = (U56F8!(125_000_000) / (8 * baud)).to_fixed();
+            sm_tx.set_config(&cfg);
+            sm_tx.set_enable(true);
+
+            // The 4 state machines of the PIO each have their own program counter that starts taking
+            // instructions at an offset (origin) of the 32 instruction "space" the PIO device has.
+            // It is up to the programmer to sort out where to place these instructions.
+            // From the pio_asm! macro you get a ProgramWithDefines which has a field .program.origin
+            // which takes an Option<u8>.
+            //
+            // When you load more than one RelocatedProgram into the PIO,
+            // you load your first program at origin = 0.
+            // The RelocatedProgram has .code().count() which returns a usize,
+            // for which you can then use as your next program's origin.
+            let offset = relocated.code().count() as u8 + origin.unwrap_or_default();
+            (Self { sm_tx }, offset)
+        }
+
+        pub async fn write_u8(&mut self, data: u8) {
+            self.sm_tx.tx().wait_push(data as u32).await;
+        }
+    }
+
+    impl Io for PioUartTx<'_> {
+        type Error = PioUartError;
+    }
+
+    impl Write for PioUartTx<'_> {
+        async fn write(&mut self, buf: &[u8]) -> Result<usize, PioUartError> {
+            for byte in buf {
+                self.write_u8(*byte).await;
+            }
+            Ok(buf.len())
+        }
     }
 }
 
@@ -207,19 +346,27 @@ mod uart_rx {
     use embassy_rp::peripherals::PIO0;
     use embassy_rp::pio::{Common, Config, Direction, FifoJoin, PioPin, ShiftDirection, StateMachine};
     use embassy_rp::relocate::RelocatedProgram;
+    use embedded_io::asynch::Read;
+    use embedded_io::Io;
     use fixed::traits::ToFixed;
     use fixed_macro::types::U56F8;
 
-    pub fn setup_uart_rx_on_sm1<'a>(
-        common: &mut Common<'a, PIO0>,
-        sm_rx: &mut StateMachine<'a, PIO0, 1>,
-        rx_pin: impl PioPin,
-        baud: u64,
-    ) {
-        let prg = pio_proc::pio_asm!(
-            r#"
-                ;.program uart_rx
+    use crate::uart::PioUartError;
+
+    pub struct PioUartRx<'a> {
+        sm_rx: StateMachine<'a, PIO0, 1>,
+    }
 
+    impl<'a> PioUartRx<'a> {
+        pub fn new(
+            common: &mut Common<'a, PIO0>,
+            mut sm_rx: StateMachine<'a, PIO0, 1>,
+            rx_pin: impl PioPin,
+            baud: u64,
+            origin: Option<u8>,
+        ) -> (Self, u8) {
+            let mut prg = pio_proc::pio_asm!(
+                r#"
                 ; Slightly more fleshed-out 8n1 UART receiver which handles framing errors and
                 ; break conditions more gracefully.
                 ; IN pin 0 and JMP pin are both mapped to the GPIO used as UART RX.
@@ -227,36 +374,58 @@ mod uart_rx {
                 start:
                     wait 0 pin 0        ; Stall until start bit is asserted
                     set x, 7    [10]    ; Preload bit counter, then delay until halfway through
-                bitloop:                ; the first data bit (12 cycles incl wait, set).
+                rx_bitloop:                ; the first data bit (12 cycles incl wait, set).
                     in pins, 1          ; Shift data bit into ISR
-                    jmp x-- bitloop [6] ; Loop 8 times, each loop iteration is 8 cycles
-                    jmp pin good_stop   ; Check stop bit (should be high)
+                    jmp x-- rx_bitloop [6] ; Loop 8 times, each loop iteration is 8 cycles
+                    jmp pin good_rx_stop   ; Check stop bit (should be high)
 
                     irq 4 rel           ; Either a framing error or a break. Set a sticky flag,
                     wait 1 pin 0        ; and wait for line to return to idle state.
                     jmp start           ; Don't push data if we didn't see good framing.
 
-                good_stop:              ; No delay before returning to start; a little slack is
+                good_rx_stop:              ; No delay before returning to start; a little slack is
                     push                ; important in case the TX clock is slightly too fast.
             "#
-        );
-
-        let rx_pin = common.make_pio_pin(rx_pin);
-        sm_rx.set_pins(Level::High, &[&rx_pin]);
-        sm_rx.set_pin_dirs(Direction::In, &[&rx_pin]);
-
-        let relocated = RelocatedProgram::new(&prg.program);
-        let mut cfg = Config::default();
-
-        cfg.use_program(&common.load_program(&relocated), &[&rx_pin]);
-        cfg.clock_divider = (U56F8!(125_000_000) / (8 * baud)).to_fixed();
-        cfg.shift_out.auto_fill = false;
-        cfg.shift_out.direction = ShiftDirection::Right;
-        cfg.fifo_join = FifoJoin::RxOnly;
-        cfg.set_in_pins(&[&rx_pin]);
-        cfg.set_jmp_pin(&rx_pin);
-        // cfg.set_set_pins(&[&rx_pin]);
-        sm_rx.set_config(&cfg);
-        sm_rx.set_enable(true)
+            );
+            prg.program.origin = origin;
+            let relocated = RelocatedProgram::new(&prg.program);
+            let mut cfg = Config::default();
+            cfg.use_program(&common.load_program(&relocated), &[]);
+
+            let rx_pin = common.make_pio_pin(rx_pin);
+            sm_rx.set_pins(Level::High, &[&rx_pin]);
+            cfg.set_in_pins(&[&rx_pin]);
+            cfg.set_jmp_pin(&rx_pin);
+            sm_rx.set_pin_dirs(Direction::In, &[&rx_pin]);
+
+            cfg.clock_divider = (U56F8!(125_000_000) / (8 * baud)).to_fixed();
+            cfg.shift_out.auto_fill = false;
+            cfg.shift_out.direction = ShiftDirection::Right;
+            cfg.fifo_join = FifoJoin::RxOnly;
+            sm_rx.set_config(&cfg);
+            sm_rx.set_enable(true);
+
+            let offset = relocated.code().count() as u8 + origin.unwrap_or_default();
+            (Self { sm_rx }, offset)
+        }
+
+        pub async fn read_u8(&mut self) -> u8 {
+            self.sm_rx.rx().wait_pull().await as u8
+        }
+    }
+
+    impl Io for PioUartRx<'_> {
+        type Error = PioUartError;
+    }
+
+    impl Read for PioUartRx<'_> {
+        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, PioUartError> {
+            let mut i = 0;
+            while i < buf.len() {
+                buf[i] = self.read_u8().await;
+                i += 1;
+            }
+            Ok(i)
+        }
     }
 }
-- 
cgit 


From 0f1ff77fcc3c085f9969bac4963d784c022e6044 Mon Sep 17 00:00:00 2001
From: Michael van Niekerk <mike@agri-io.co.za>
Date: Fri, 28 Jul 2023 11:38:08 +0200
Subject: Comments

---
 examples/rp/.idea/.gitignore  |  8 --------
 examples/rp/.idea/modules.xml |  8 --------
 examples/rp/.idea/rp.iml      | 12 ------------
 examples/rp/.idea/vcs.xml     |  6 ------
 4 files changed, 34 deletions(-)
 delete mode 100644 examples/rp/.idea/.gitignore
 delete mode 100644 examples/rp/.idea/modules.xml
 delete mode 100644 examples/rp/.idea/rp.iml
 delete mode 100644 examples/rp/.idea/vcs.xml

diff --git a/examples/rp/.idea/.gitignore b/examples/rp/.idea/.gitignore
deleted file mode 100644
index 13566b81b..000000000
--- a/examples/rp/.idea/.gitignore
+++ /dev/null
@@ -1,8 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml
diff --git a/examples/rp/.idea/modules.xml b/examples/rp/.idea/modules.xml
deleted file mode 100644
index 06ff4b23d..000000000
--- a/examples/rp/.idea/modules.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/rp.iml" filepath="$PROJECT_DIR$/.idea/rp.iml" />
-    </modules>
-  </component>
-</project>
\ No newline at end of file
diff --git a/examples/rp/.idea/rp.iml b/examples/rp/.idea/rp.iml
deleted file mode 100644
index 9b4cf845b..000000000
--- a/examples/rp/.idea/rp.iml
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-      <excludeFolder url="file://$MODULE_DIR$/target" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>
\ No newline at end of file
diff --git a/examples/rp/.idea/vcs.xml b/examples/rp/.idea/vcs.xml
deleted file mode 100644
index b2bdec2d7..000000000
--- a/examples/rp/.idea/vcs.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
-  </component>
-</project>
\ No newline at end of file
-- 
cgit 


From 91338adc159dd026ba56dcb4e991ed9f60053bb0 Mon Sep 17 00:00:00 2001
From: Michael van Niekerk <mike@agri-io.co.za>
Date: Fri, 28 Jul 2023 11:56:59 +0200
Subject: Don't include embedded-hal-common

---
 examples/rp/Cargo.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/examples/rp/Cargo.toml b/examples/rp/Cargo.toml
index 2a018ad04..c812cb3ee 100644
--- a/examples/rp/Cargo.toml
+++ b/examples/rp/Cargo.toml
@@ -7,7 +7,6 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 embassy-embedded-hal = { version = "0.1.0", path = "../../embassy-embedded-hal", features = ["defmt"] }
-embassy-hal-common = { version = "0.1.0", path = "../../embassy-hal-common", features = ["defmt"] }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "executor-interrupt", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["nightly", "unstable-traits", "defmt", "defmt-timestamp-uptime"] }
-- 
cgit 


From 146c744223056561c6be61dda791993d939d0ae0 Mon Sep 17 00:00:00 2001
From: Michael van Niekerk <mike@agri-io.co.za>
Date: Fri, 28 Jul 2023 12:56:31 +0200
Subject: Fixes as per PR

---
 examples/rp/src/bin/pio_uart.rs | 114 +++++++++++++++++-----------------------
 1 file changed, 48 insertions(+), 66 deletions(-)

diff --git a/examples/rp/src/bin/pio_uart.rs b/examples/rp/src/bin/pio_uart.rs
index eeb213e1b..c978f8f06 100644
--- a/examples/rp/src/bin/pio_uart.rs
+++ b/examples/rp/src/bin/pio_uart.rs
@@ -19,7 +19,7 @@ use embassy_rp::peripherals::{PIO0, USB};
 use embassy_rp::pio::InterruptHandler as PioInterruptHandler;
 use embassy_rp::usb::{Driver, Instance, InterruptHandler};
 use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
-use embassy_sync::channel::Channel;
+use embassy_sync::pipe::Pipe;
 use embassy_usb::class::cdc_acm::{CdcAcmClass, Receiver, Sender, State};
 use embassy_usb::driver::EndpointError;
 use embassy_usb::{Builder, Config};
@@ -30,11 +30,8 @@ use crate::uart::PioUart;
 use crate::uart_rx::PioUartRx;
 use crate::uart_tx::PioUartTx;
 
-bind_interrupts!(struct UsbIrqs {
+bind_interrupts!(struct Irqs {
     USBCTRL_IRQ => InterruptHandler<USB>;
-});
-
-bind_interrupts!(struct PioIrqs {
     PIO0_IRQ_0 => PioInterruptHandler<PIO0>;
 });
 
@@ -45,7 +42,7 @@ async fn main(_spawner: Spawner) {
     let p = embassy_rp::init(Default::default());
 
     // Create the driver, from the HAL.
-    let driver = Driver::new(p.USB, UsbIrqs);
+    let driver = Driver::new(p.USB, Irqs);
 
     // Create embassy-usb Config
     let mut config = Config::new(0xc0de, 0xcafe);
@@ -90,17 +87,17 @@ async fn main(_spawner: Spawner) {
     let usb_fut = usb.run();
 
     // PIO UART setup
-    let uart = PioUart::new(9600, p.PIO0, p.PIN_4, p.PIN_5).await;
+    let uart = PioUart::new(9600, p.PIO0, p.PIN_4, p.PIN_5);
     let (mut uart_tx, mut uart_rx) = uart.split();
 
-    // Channels setup
-    static USB_CHANNEL_TX: Channel<ThreadModeRawMutex, u8, 20> = Channel::<ThreadModeRawMutex, u8, 20>::new();
-    let mut usb_channel_tx_send = USB_CHANNEL_TX.sender();
-    let mut usb_channel_tx_recv = USB_CHANNEL_TX.receiver();
+    // Pipe setup
+    static USB_PIPE: Pipe<ThreadModeRawMutex, 20> = Pipe::new();
+    let mut usb_pipe_writer = USB_PIPE.writer();
+    let mut usb_pipe_reader = USB_PIPE.reader();
 
-    static UART_CHANNEL_TX: Channel<ThreadModeRawMutex, u8, 20> = Channel::<ThreadModeRawMutex, u8, 20>::new();
-    let mut uart_channel_tx_send = UART_CHANNEL_TX.sender();
-    let mut uart_channel_tx_recv = UART_CHANNEL_TX.receiver();
+    static UART_PIPE: Pipe<ThreadModeRawMutex, 20> = Pipe::new();
+    let mut uart_pipe_writer = UART_PIPE.writer();
+    let mut uart_pipe_reader = UART_PIPE.reader();
 
     let (mut usb_tx, mut usb_rx) = class.split();
 
@@ -111,8 +108,8 @@ async fn main(_spawner: Spawner) {
             usb_rx.wait_connection().await;
             info!("Connected");
             let _ = join(
-                usb_read(&mut usb_rx, &mut uart_channel_tx_send),
-                usb_write(&mut usb_tx, &mut usb_channel_tx_recv),
+                usb_read(&mut usb_rx, &mut uart_pipe_writer),
+                usb_write(&mut usb_tx, &mut usb_pipe_reader),
             )
             .await;
             info!("Disconnected");
@@ -120,15 +117,10 @@ async fn main(_spawner: Spawner) {
     };
 
     // Read + write from UART
-    let uart_future = async {
-        loop {
-            let _ = join(
-                uart_read(&mut uart_rx, &mut usb_channel_tx_send),
-                uart_write(&mut uart_tx, &mut uart_channel_tx_recv),
-            )
-            .await;
-        }
-    };
+    let uart_future = join(
+        uart_read(&mut uart_rx, &mut usb_pipe_writer),
+        uart_write(&mut uart_tx, &mut uart_pipe_reader),
+    );
 
     // Run everything concurrently.
     // If we had made everything `'static` above instead, we could do this using separate tasks instead.
@@ -146,75 +138,73 @@ impl From<EndpointError> for Disconnected {
     }
 }
 
-/// Read from the USB and write it to the UART TX send channel
+/// Read from the USB and write it to the UART TX pipe
 async fn usb_read<'d, T: Instance + 'd>(
     usb_rx: &mut Receiver<'d, Driver<'d, T>>,
-    uart_tx_send: &mut embassy_sync::channel::Sender<'d, ThreadModeRawMutex, u8, 20>,
+    uart_pipe_writer: &mut embassy_sync::pipe::Writer<'static, ThreadModeRawMutex, 20>,
 ) -> Result<(), Disconnected> {
     let mut buf = [0; 64];
     loop {
         let n = usb_rx.read_packet(&mut buf).await?;
         let data = &buf[..n];
         trace!("USB IN: {:x}", data);
-        for byte in data {
-            uart_tx_send.send(*byte).await;
-        }
+        uart_pipe_writer.write(data).await;
     }
 }
 
-/// Read from the USB TX receive channel and write it to the USB
+/// Read from the USB TX pipe and write it to the USB
 async fn usb_write<'d, T: Instance + 'd>(
     usb_tx: &mut Sender<'d, Driver<'d, T>>,
-    usb_tx_recv: &mut embassy_sync::channel::Receiver<'d, ThreadModeRawMutex, u8, 20>,
+    usb_pipe_reader: &mut embassy_sync::pipe::Reader<'d, ThreadModeRawMutex, 20>,
 ) -> Result<(), Disconnected> {
+    let mut buf = [0; 64];
     loop {
-        let n = usb_tx_recv.recv().await;
-        let data = [n];
+        let n = usb_pipe_reader.read(&mut buf).await;
+        let data = &buf[..n];
         trace!("USB OUT: {:x}", data);
         usb_tx.write_packet(&data).await?;
     }
 }
 
-/// Read from the UART and write it to the USB TX send channel
+/// Read from the UART and write it to the USB TX pipe
 async fn uart_read<'a>(
     uart_rx: &mut PioUartRx<'a>,
-    usb_tx_send: &mut embassy_sync::channel::Sender<'a, ThreadModeRawMutex, u8, 20>,
-) -> Result<(), Disconnected> {
-    let mut buf = [0; 1];
+    usb_pipe_writer: &mut embassy_sync::pipe::Writer<'static, ThreadModeRawMutex, 20>,
+) -> ! {
+    let mut buf = [0; 64];
     loop {
         let n = uart_rx.read(&mut buf).await.expect("UART read error");
         if n == 0 {
             continue;
         }
+        let data = &buf[..n];
         trace!("UART IN: {:x}", buf);
-        usb_tx_send.send(buf[0]).await;
+        usb_pipe_writer.write(data).await;
     }
 }
 
-/// Read from the UART TX receive channel and write it to the UART
+/// Read from the UART TX pipe and write it to the UART
 async fn uart_write<'a>(
     uart_tx: &mut PioUartTx<'a>,
-    uart_rx_recv: &mut embassy_sync::channel::Receiver<'a, ThreadModeRawMutex, u8, 20>,
-) -> Result<(), Disconnected> {
+    uart_pipe_reader: &mut embassy_sync::pipe::Reader<'a, ThreadModeRawMutex, 20>,
+) -> ! {
+    let mut buf = [0; 64];
     loop {
-        let n = uart_rx_recv.recv().await;
-        let data = [n];
+        let n = uart_pipe_reader.read(&mut buf).await;
+        let data = &buf[..n];
         trace!("UART OUT: {:x}", data);
         let _ = uart_tx.write(&data).await;
     }
 }
 
 mod uart {
-    use core::fmt::Debug;
-
     use embassy_rp::peripherals::PIO0;
     use embassy_rp::pio::{Pio, PioPin};
     use embassy_rp::Peripheral;
-    use embedded_io::ErrorKind;
 
     use crate::uart_rx::PioUartRx;
     use crate::uart_tx::PioUartTx;
-    use crate::PioIrqs;
+    use crate::Irqs;
 
     pub struct PioUart<'a> {
         tx: PioUartTx<'a>,
@@ -222,7 +212,7 @@ mod uart {
     }
 
     impl<'a> PioUart<'a> {
-        pub async fn new(
+        pub fn new(
             baud: u64,
             pio: impl Peripheral<P = PIO0> + 'a,
             tx_pin: impl PioPin,
@@ -230,7 +220,7 @@ mod uart {
         ) -> PioUart<'a> {
             let Pio {
                 mut common, sm0, sm1, ..
-            } = Pio::new(pio, PioIrqs);
+            } = Pio::new(pio, Irqs);
 
             let (tx, origin) = PioUartTx::new(&mut common, sm0, tx_pin, baud, None);
             let (rx, _) = PioUartRx::new(&mut common, sm1, rx_pin, baud, Some(origin));
@@ -242,17 +232,11 @@ mod uart {
             (self.tx, self.rx)
         }
     }
-    #[derive(defmt::Format, Debug)]
-    pub struct PioUartError {}
-
-    impl embedded_io::Error for PioUartError {
-        fn kind(&self) -> ErrorKind {
-            ErrorKind::Other
-        }
-    }
 }
 
 mod uart_tx {
+    use core::convert::Infallible;
+
     use embassy_rp::gpio::Level;
     use embassy_rp::peripherals::PIO0;
     use embassy_rp::pio::{Common, Config, Direction, FifoJoin, PioPin, ShiftDirection, StateMachine};
@@ -262,8 +246,6 @@ mod uart_tx {
     use fixed::traits::ToFixed;
     use fixed_macro::types::U56F8;
 
-    use crate::uart::PioUartError;
-
     pub struct PioUartTx<'a> {
         sm_tx: StateMachine<'a, PIO0, 0>,
     }
@@ -328,11 +310,11 @@ mod uart_tx {
     }
 
     impl Io for PioUartTx<'_> {
-        type Error = PioUartError;
+        type Error = Infallible;
     }
 
     impl Write for PioUartTx<'_> {
-        async fn write(&mut self, buf: &[u8]) -> Result<usize, PioUartError> {
+        async fn write(&mut self, buf: &[u8]) -> Result<usize, Infallible> {
             for byte in buf {
                 self.write_u8(*byte).await;
             }
@@ -342,6 +324,8 @@ mod uart_tx {
 }
 
 mod uart_rx {
+    use core::convert::Infallible;
+
     use embassy_rp::gpio::Level;
     use embassy_rp::peripherals::PIO0;
     use embassy_rp::pio::{Common, Config, Direction, FifoJoin, PioPin, ShiftDirection, StateMachine};
@@ -351,8 +335,6 @@ mod uart_rx {
     use fixed::traits::ToFixed;
     use fixed_macro::types::U56F8;
 
-    use crate::uart::PioUartError;
-
     pub struct PioUartRx<'a> {
         sm_rx: StateMachine<'a, PIO0, 1>,
     }
@@ -415,11 +397,11 @@ mod uart_rx {
     }
 
     impl Io for PioUartRx<'_> {
-        type Error = PioUartError;
+        type Error = Infallible;
     }
 
     impl Read for PioUartRx<'_> {
-        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, PioUartError> {
+        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Infallible> {
             let mut i = 0;
             while i < buf.len() {
                 buf[i] = self.read_u8().await;
-- 
cgit 


From 38b5d1ee2b1319a6f84c8894f05c650bb3630ece Mon Sep 17 00:00:00 2001
From: chemicstry <chemicstry@gmail.com>
Date: Fri, 28 Jul 2023 14:22:24 +0300
Subject: stm32/can: implement more convenience methods

---
 embassy-stm32/src/can/bxcan.rs | 154 +++++++++++++++++++++++++++++++----------
 1 file changed, 116 insertions(+), 38 deletions(-)

diff --git a/embassy-stm32/src/can/bxcan.rs b/embassy-stm32/src/can/bxcan.rs
index 8b8244d4f..d4ec23816 100644
--- a/embassy-stm32/src/can/bxcan.rs
+++ b/embassy-stm32/src/can/bxcan.rs
@@ -77,6 +77,7 @@ pub struct Can<'d, T: Instance> {
 }
 
 #[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum BusError {
     Stuff,
     Form,
@@ -90,6 +91,22 @@ pub enum BusError {
     BusWarning,
 }
 
+#[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum TryReadError {
+    /// Bus error
+    BusError(BusError),
+    /// Receive buffer is empty
+    Empty,
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum TryWriteError {
+    /// All transmit mailboxes are full
+    Full,
+}
+
 impl<'d, T: Instance> Can<'d, T> {
     /// Creates a new Bxcan instance, keeping the peripheral in sleep mode.
     /// You must call [Can::enable_non_blocking] to use the peripheral.
@@ -175,56 +192,46 @@ impl<'d, T: Instance> Can<'d, T> {
 
     /// Queues the message to be sent but exerts backpressure
     pub async fn write(&mut self, frame: &Frame) -> bxcan::TransmitStatus {
-        poll_fn(|cx| {
-            T::state().tx_waker.register(cx.waker());
-            if let Ok(status) = self.can.borrow_mut().transmit(frame) {
-                return Poll::Ready(status);
-            }
+        CanTx { can: &self.can }.write(frame).await
+    }
 
-            Poll::Pending
-        })
-        .await
+    /// Attempts to transmit a frame without blocking.
+    ///
+    /// Returns [Err(TryWriteError::Full)] if all transmit mailboxes are full.
+    pub fn try_write(&mut self, frame: &Frame) -> Result<bxcan::TransmitStatus, TryWriteError> {
+        CanTx { can: &self.can }.try_write(frame)
     }
 
+    /// Waits for a specific transmit mailbox to become empty
     pub async fn flush(&self, mb: bxcan::Mailbox) {
-        poll_fn(|cx| {
-            T::state().tx_waker.register(cx.waker());
-            if T::regs().tsr().read().tme(mb.index()) {
-                return Poll::Ready(());
-            }
+        CanTx { can: &self.can }.flush(mb).await
+    }
 
-            Poll::Pending
-        })
-        .await;
+    /// Waits until any of the transmit mailboxes become empty
+    pub async fn flush_any(&self) {
+        CanTx { can: &self.can }.flush_any().await
+    }
+
+    /// Waits until all of the transmit mailboxes become empty
+    pub async fn flush_all(&self) {
+        CanTx { can: &self.can }.flush_all().await
     }
 
     /// Returns a tuple of the time the message was received and the message frame
     pub async fn read(&mut self) -> Result<(u16, bxcan::Frame), BusError> {
-        poll_fn(|cx| {
-            T::state().err_waker.register(cx.waker());
-            if let Poll::Ready((time, frame)) = T::state().rx_queue.recv().poll_unpin(cx) {
-                return Poll::Ready(Ok((time, frame)));
-            } else if let Some(err) = self.curr_error() {
-                return Poll::Ready(Err(err));
-            }
+        CanRx { can: &self.can }.read().await
+    }
 
-            Poll::Pending
-        })
-        .await
+    /// Attempts to read a can frame without blocking.
+    ///
+    /// Returns [Err(TryReadError::Empty)] if there are no frames in the rx queue.
+    pub fn try_read(&mut self) -> Result<(u16, bxcan::Frame), TryReadError> {
+        CanRx { can: &self.can }.try_read()
     }
 
-    fn curr_error(&self) -> Option<BusError> {
-        let err = { T::regs().esr().read() };
-        if err.boff() {
-            return Some(BusError::BusOff);
-        } else if err.epvf() {
-            return Some(BusError::BusPassive);
-        } else if err.ewgf() {
-            return Some(BusError::BusWarning);
-        } else if let Some(err) = err.lec().into_bus_err() {
-            return Some(err);
-        }
-        None
+    /// Waits while receive queue is empty.
+    pub async fn wait_not_empty(&mut self) {
+        CanRx { can: &self.can }.wait_not_empty().await
     }
 
     unsafe fn receive_fifo(fifo: RxFifo) {
@@ -386,6 +393,14 @@ impl<'c, 'd, T: Instance> CanTx<'c, 'd, T> {
         .await
     }
 
+    /// Attempts to transmit a frame without blocking.
+    ///
+    /// Returns [Err(TryWriteError::Full)] if all transmit mailboxes are full.
+    pub fn try_write(&mut self, frame: &Frame) -> Result<bxcan::TransmitStatus, TryWriteError> {
+        self.can.borrow_mut().transmit(frame).map_err(|_| TryWriteError::Full)
+    }
+
+    /// Waits for a specific transmit mailbox to become empty
     pub async fn flush(&self, mb: bxcan::Mailbox) {
         poll_fn(|cx| {
             T::state().tx_waker.register(cx.waker());
@@ -397,6 +412,42 @@ impl<'c, 'd, T: Instance> CanTx<'c, 'd, T> {
         })
         .await;
     }
+
+    /// Waits until any of the transmit mailboxes become empty
+    pub async fn flush_any(&self) {
+        poll_fn(|cx| {
+            T::state().tx_waker.register(cx.waker());
+
+            let tsr = T::regs().tsr().read();
+            if tsr.tme(bxcan::Mailbox::Mailbox0.index())
+                || tsr.tme(bxcan::Mailbox::Mailbox1.index())
+                || tsr.tme(bxcan::Mailbox::Mailbox2.index())
+            {
+                return Poll::Ready(());
+            }
+
+            Poll::Pending
+        })
+        .await;
+    }
+
+    /// Waits until all of the transmit mailboxes become empty
+    pub async fn flush_all(&self) {
+        poll_fn(|cx| {
+            T::state().tx_waker.register(cx.waker());
+
+            let tsr = T::regs().tsr().read();
+            if tsr.tme(bxcan::Mailbox::Mailbox0.index())
+                && tsr.tme(bxcan::Mailbox::Mailbox1.index())
+                && tsr.tme(bxcan::Mailbox::Mailbox2.index())
+            {
+                return Poll::Ready(());
+            }
+
+            Poll::Pending
+        })
+        .await;
+    }
 }
 
 #[allow(dead_code)]
@@ -419,6 +470,33 @@ impl<'c, 'd, T: Instance> CanRx<'c, 'd, T> {
         .await
     }
 
+    /// Attempts to read a CAN frame without blocking.
+    ///
+    /// Returns [Err(TryReadError::Empty)] if there are no frames in the rx queue.
+    pub fn try_read(&mut self) -> Result<(u16, bxcan::Frame), TryReadError> {
+        if let Ok(envelope) = T::state().rx_queue.try_recv() {
+            return Ok(envelope);
+        }
+
+        if let Some(err) = self.curr_error() {
+            return Err(TryReadError::BusError(err));
+        }
+
+        Err(TryReadError::Empty)
+    }
+
+    /// Waits while receive queue is empty.
+    pub async fn wait_not_empty(&mut self) {
+        poll_fn(|cx| {
+            if T::state().rx_queue.poll_ready_to_receive(cx) {
+                Poll::Ready(())
+            } else {
+                Poll::Pending
+            }
+        })
+        .await
+    }
+
     fn curr_error(&self) -> Option<BusError> {
         let err = { T::regs().esr().read() };
         if err.boff() {
-- 
cgit 


From 036e6ae30c9e772ef8ef20439f121e108b9106f0 Mon Sep 17 00:00:00 2001
From: Dario Nieuwenhuis <dirbaio@dirbaio.net>
Date: Fri, 28 Jul 2023 13:23:22 +0200
Subject: Rename embassy-hal-common to embassy-hal-internal, document it's for
 internal use only. (#1700)

---
 .github/ci/test.sh                             |   2 +-
 embassy-hal-common/Cargo.toml                  |  29 -
 embassy-hal-common/build.rs                    |  29 -
 embassy-hal-common/src/atomic_ring_buffer.rs   | 556 ----------------
 embassy-hal-common/src/drop.rs                 |  51 --
 embassy-hal-common/src/fmt.rs                  | 225 -------
 embassy-hal-common/src/interrupt.rs            | 846 -------------------------
 embassy-hal-common/src/lib.rs                  |  16 -
 embassy-hal-common/src/macros.rs               | 123 ----
 embassy-hal-common/src/peripheral.rs           | 174 -----
 embassy-hal-common/src/ratio.rs                | 129 ----
 embassy-hal-common/src/ring_buffer.rs          | 136 ----
 embassy-hal-internal/Cargo.toml                |  29 +
 embassy-hal-internal/README.md                 |  16 +
 embassy-hal-internal/build.rs                  |  29 +
 embassy-hal-internal/src/atomic_ring_buffer.rs | 556 ++++++++++++++++
 embassy-hal-internal/src/drop.rs               |  51 ++
 embassy-hal-internal/src/fmt.rs                | 225 +++++++
 embassy-hal-internal/src/interrupt.rs          | 846 +++++++++++++++++++++++++
 embassy-hal-internal/src/lib.rs                |  17 +
 embassy-hal-internal/src/macros.rs             | 123 ++++
 embassy-hal-internal/src/peripheral.rs         | 174 +++++
 embassy-hal-internal/src/ratio.rs              | 129 ++++
 embassy-hal-internal/src/ring_buffer.rs        | 136 ++++
 embassy-lora/Cargo.toml                        |   1 +
 embassy-nrf/Cargo.toml                         |   2 +-
 embassy-nrf/src/buffered_uarte.rs              |   4 +-
 embassy-nrf/src/chips/nrf52805.rs              |   4 +-
 embassy-nrf/src/chips/nrf52810.rs              |   4 +-
 embassy-nrf/src/chips/nrf52811.rs              |   4 +-
 embassy-nrf/src/chips/nrf52820.rs              |   4 +-
 embassy-nrf/src/chips/nrf52832.rs              |   4 +-
 embassy-nrf/src/chips/nrf52833.rs              |   4 +-
 embassy-nrf/src/chips/nrf52840.rs              |   4 +-
 embassy-nrf/src/chips/nrf5340_app.rs           |   4 +-
 embassy-nrf/src/chips/nrf5340_net.rs           |   4 +-
 embassy-nrf/src/chips/nrf9160.rs               |   4 +-
 embassy-nrf/src/gpio.rs                        |   2 +-
 embassy-nrf/src/gpiote.rs                      |   2 +-
 embassy-nrf/src/i2s.rs                         |   4 +-
 embassy-nrf/src/lib.rs                         |   4 +-
 embassy-nrf/src/nvmc.rs                        |   2 +-
 embassy-nrf/src/pdm.rs                         |   4 +-
 embassy-nrf/src/ppi/dppi.rs                    |   2 +-
 embassy-nrf/src/ppi/mod.rs                     |   2 +-
 embassy-nrf/src/ppi/ppi.rs                     |   2 +-
 embassy-nrf/src/pwm.rs                         |   2 +-
 embassy-nrf/src/qdec.rs                        |   2 +-
 embassy-nrf/src/qspi.rs                        |   4 +-
 embassy-nrf/src/rng.rs                         |   4 +-
 embassy-nrf/src/saadc.rs                       |   4 +-
 embassy-nrf/src/spim.rs                        |   2 +-
 embassy-nrf/src/spis.rs                        |   2 +-
 embassy-nrf/src/temp.rs                        |   4 +-
 embassy-nrf/src/timer.rs                       |   2 +-
 embassy-nrf/src/twim.rs                        |   2 +-
 embassy-nrf/src/twis.rs                        |   2 +-
 embassy-nrf/src/uarte.rs                       |   4 +-
 embassy-nrf/src/usb/mod.rs                     |   2 +-
 embassy-rp/Cargo.toml                          |   4 +-
 embassy-rp/src/adc.rs                          |   2 +-
 embassy-rp/src/clocks.rs                       |   2 +-
 embassy-rp/src/dma.rs                          |   2 +-
 embassy-rp/src/flash.rs                        |   2 +-
 embassy-rp/src/gpio.rs                         |   2 +-
 embassy-rp/src/i2c.rs                          |   2 +-
 embassy-rp/src/lib.rs                          |   8 +-
 embassy-rp/src/pio.rs                          |   2 +-
 embassy-rp/src/pwm.rs                          |   2 +-
 embassy-rp/src/rtc/mod.rs                      |   2 +-
 embassy-rp/src/spi.rs                          |   2 +-
 embassy-rp/src/uart/buffered.rs                |   2 +-
 embassy-rp/src/uart/mod.rs                     |   2 +-
 embassy-stm32-wpan/Cargo.toml                  |   4 +-
 embassy-stm32-wpan/src/lib.rs                  |   2 +-
 embassy-stm32/Cargo.toml                       |   4 +-
 embassy-stm32/build.rs                         |  10 +-
 embassy-stm32/src/adc/f1.rs                    |   2 +-
 embassy-stm32/src/adc/v1.rs                    |   2 +-
 embassy-stm32/src/adc/v2.rs                    |   2 +-
 embassy-stm32/src/adc/v3.rs                    |   2 +-
 embassy-stm32/src/adc/v4.rs                    |   2 +-
 embassy-stm32/src/can/bxcan.rs                 |   2 +-
 embassy-stm32/src/can/fdcan.rs                 |   2 +-
 embassy-stm32/src/crc/v1.rs                    |   2 +-
 embassy-stm32/src/crc/v2v3.rs                  |   2 +-
 embassy-stm32/src/dac/mod.rs                   |   2 +-
 embassy-stm32/src/dcmi.rs                      |   2 +-
 embassy-stm32/src/dma/bdma.rs                  |   2 +-
 embassy-stm32/src/dma/dma.rs                   |   2 +-
 embassy-stm32/src/dma/gpdma.rs                 |   2 +-
 embassy-stm32/src/dma/mod.rs                   |   2 +-
 embassy-stm32/src/eth/v1/mod.rs                |   2 +-
 embassy-stm32/src/eth/v2/mod.rs                |   2 +-
 embassy-stm32/src/exti.rs                      |   2 +-
 embassy-stm32/src/flash/asynch.rs              |   4 +-
 embassy-stm32/src/flash/common.rs              |   4 +-
 embassy-stm32/src/flash/f4.rs                  |   2 +-
 embassy-stm32/src/fmc.rs                       |   2 +-
 embassy-stm32/src/gpio.rs                      |   2 +-
 embassy-stm32/src/i2c/v1.rs                    |   2 +-
 embassy-stm32/src/i2c/v2.rs                    |   4 +-
 embassy-stm32/src/i2s.rs                       |   2 +-
 embassy-stm32/src/lib.rs                       |   4 +-
 embassy-stm32/src/pwm/complementary_pwm.rs     |   2 +-
 embassy-stm32/src/pwm/simple_pwm.rs            |   2 +-
 embassy-stm32/src/qspi/mod.rs                  |   2 +-
 embassy-stm32/src/rcc/f4.rs                    |   2 +-
 embassy-stm32/src/rcc/h7.rs                    |   2 +-
 embassy-stm32/src/rcc/l4.rs                    |   2 +-
 embassy-stm32/src/rng.rs                       |   2 +-
 embassy-stm32/src/rtc/mod.rs                   |   2 +-
 embassy-stm32/src/sdmmc/mod.rs                 |   4 +-
 embassy-stm32/src/spi/mod.rs                   |   2 +-
 embassy-stm32/src/usart/buffered.rs            |   2 +-
 embassy-stm32/src/usart/mod.rs                 |   4 +-
 embassy-stm32/src/usart/ringbuffered.rs        |   2 +-
 embassy-stm32/src/usb/usb.rs                   |   2 +-
 embassy-stm32/src/usb_otg/usb.rs               |   2 +-
 embassy-stm32/src/wdg/mod.rs                   |   2 +-
 examples/stm32g4/Cargo.toml                    |   1 -
 121 files changed, 2463 insertions(+), 2446 deletions(-)
 delete mode 100644 embassy-hal-common/Cargo.toml
 delete mode 100644 embassy-hal-common/build.rs
 delete mode 100644 embassy-hal-common/src/atomic_ring_buffer.rs
 delete mode 100644 embassy-hal-common/src/drop.rs
 delete mode 100644 embassy-hal-common/src/fmt.rs
 delete mode 100644 embassy-hal-common/src/interrupt.rs
 delete mode 100644 embassy-hal-common/src/lib.rs
 delete mode 100644 embassy-hal-common/src/macros.rs
 delete mode 100644 embassy-hal-common/src/peripheral.rs
 delete mode 100644 embassy-hal-common/src/ratio.rs
 delete mode 100644 embassy-hal-common/src/ring_buffer.rs
 create mode 100644 embassy-hal-internal/Cargo.toml
 create mode 100644 embassy-hal-internal/README.md
 create mode 100644 embassy-hal-internal/build.rs
 create mode 100644 embassy-hal-internal/src/atomic_ring_buffer.rs
 create mode 100644 embassy-hal-internal/src/drop.rs
 create mode 100644 embassy-hal-internal/src/fmt.rs
 create mode 100644 embassy-hal-internal/src/interrupt.rs
 create mode 100644 embassy-hal-internal/src/lib.rs
 create mode 100644 embassy-hal-internal/src/macros.rs
 create mode 100644 embassy-hal-internal/src/peripheral.rs
 create mode 100644 embassy-hal-internal/src/ratio.rs
 create mode 100644 embassy-hal-internal/src/ring_buffer.rs

diff --git a/.github/ci/test.sh b/.github/ci/test.sh
index d014e4bd7..2892bcf8d 100755
--- a/.github/ci/test.sh
+++ b/.github/ci/test.sh
@@ -13,7 +13,7 @@ hashtime save /ci/cache/filetime.json
 
 cargo test --manifest-path ./embassy-sync/Cargo.toml 
 cargo test --manifest-path ./embassy-embedded-hal/Cargo.toml 
-cargo test --manifest-path ./embassy-hal-common/Cargo.toml 
+cargo test --manifest-path ./embassy-hal-internal/Cargo.toml 
 cargo test --manifest-path ./embassy-time/Cargo.toml --features generic-queue
 
 cargo test --manifest-path ./embassy-boot/boot/Cargo.toml
diff --git a/embassy-hal-common/Cargo.toml b/embassy-hal-common/Cargo.toml
deleted file mode 100644
index 18c758d7b..000000000
--- a/embassy-hal-common/Cargo.toml
+++ /dev/null
@@ -1,29 +0,0 @@
-[package]
-name = "embassy-hal-common"
-version = "0.1.0"
-edition = "2021"
-license = "MIT OR Apache-2.0"
-
-[features]
-
-# Define the number of NVIC priority bits.
-prio-bits-0 = []
-prio-bits-1 = []
-prio-bits-2 = []
-prio-bits-3 = []
-prio-bits-4 = []
-prio-bits-5 = []
-prio-bits-6 = []
-prio-bits-7 = []
-prio-bits-8 = []
-
-cortex-m = ["dep:cortex-m", "dep:critical-section"]
-
-[dependencies]
-defmt = { version = "0.3", optional = true }
-log = { version = "0.4.14", optional = true }
-
-num-traits = { version = "0.2.14", default-features = false }
-
-cortex-m = { version = "0.7.6", optional = true }
-critical-section = { version = "1", optional = true }
\ No newline at end of file
diff --git a/embassy-hal-common/build.rs b/embassy-hal-common/build.rs
deleted file mode 100644
index 6fe82b44f..000000000
--- a/embassy-hal-common/build.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use std::env;
-
-fn main() {
-    let target = env::var("TARGET").unwrap();
-
-    if target.starts_with("thumbv6m-") {
-        println!("cargo:rustc-cfg=cortex_m");
-        println!("cargo:rustc-cfg=armv6m");
-    } else if target.starts_with("thumbv7m-") {
-        println!("cargo:rustc-cfg=cortex_m");
-        println!("cargo:rustc-cfg=armv7m");
-    } else if target.starts_with("thumbv7em-") {
-        println!("cargo:rustc-cfg=cortex_m");
-        println!("cargo:rustc-cfg=armv7m");
-        println!("cargo:rustc-cfg=armv7em"); // (not currently used)
-    } else if target.starts_with("thumbv8m.base") {
-        println!("cargo:rustc-cfg=cortex_m");
-        println!("cargo:rustc-cfg=armv8m");
-        println!("cargo:rustc-cfg=armv8m_base");
-    } else if target.starts_with("thumbv8m.main") {
-        println!("cargo:rustc-cfg=cortex_m");
-        println!("cargo:rustc-cfg=armv8m");
-        println!("cargo:rustc-cfg=armv8m_main");
-    }
-
-    if target.ends_with("-eabihf") {
-        println!("cargo:rustc-cfg=has_fpu");
-    }
-}
diff --git a/embassy-hal-common/src/atomic_ring_buffer.rs b/embassy-hal-common/src/atomic_ring_buffer.rs
deleted file mode 100644
index ea84925c4..000000000
--- a/embassy-hal-common/src/atomic_ring_buffer.rs
+++ /dev/null
@@ -1,556 +0,0 @@
-use core::slice;
-use core::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
-
-/// Atomic reusable ringbuffer
-///
-/// This ringbuffer implementation is designed to be stored in a `static`,
-/// therefore all methods take `&self` and not `&mut self`.
-///
-/// It is "reusable": when created it has no backing buffer, you can give it
-/// one with `init` and take it back with `deinit`, and init it again in the
-/// future if needed. This is very non-idiomatic, but helps a lot when storing
-/// it in a `static`.
-///
-/// One concurrent writer and one concurrent reader are supported, even at
-/// different execution priorities (like main and irq).
-pub struct RingBuffer {
-    pub buf: AtomicPtr<u8>,
-    pub len: AtomicUsize,
-
-    // start and end wrap at len*2, not at len.
-    // This allows distinguishing "full" and "empty".
-    // full is when start+len == end (modulo len*2)
-    // empty is when start == end
-    //
-    // This avoids having to consider the ringbuffer "full" at len-1 instead of len.
-    // The usual solution is adding a "full" flag, but that can't be made atomic
-    pub start: AtomicUsize,
-    pub end: AtomicUsize,
-}
-
-pub struct Reader<'a>(&'a RingBuffer);
-pub struct Writer<'a>(&'a RingBuffer);
-
-impl RingBuffer {
-    /// Create a new empty ringbuffer.
-    pub const fn new() -> Self {
-        Self {
-            buf: AtomicPtr::new(core::ptr::null_mut()),
-            len: AtomicUsize::new(0),
-            start: AtomicUsize::new(0),
-            end: AtomicUsize::new(0),
-        }
-    }
-
-    /// Initialize the ring buffer with a buffer.
-    ///
-    /// # Safety
-    /// - The buffer (`buf .. buf+len`) must be valid memory until `deinit` is called.
-    /// - Must not be called concurrently with any other methods.
-    pub unsafe fn init(&self, buf: *mut u8, len: usize) {
-        // Ordering: it's OK to use `Relaxed` because this is not called
-        // concurrently with other methods.
-        self.buf.store(buf, Ordering::Relaxed);
-        self.len.store(len, Ordering::Relaxed);
-        self.start.store(0, Ordering::Relaxed);
-        self.end.store(0, Ordering::Relaxed);
-    }
-
-    /// Deinitialize the ringbuffer.
-    ///
-    /// After calling this, the ringbuffer becomes empty, as if it was
-    /// just created with `new()`.
-    ///
-    /// # Safety
-    /// - Must not be called concurrently with any other methods.
-    pub unsafe fn deinit(&self) {
-        // Ordering: it's OK to use `Relaxed` because this is not called
-        // concurrently with other methods.
-        self.len.store(0, Ordering::Relaxed);
-        self.start.store(0, Ordering::Relaxed);
-        self.end.store(0, Ordering::Relaxed);
-    }
-
-    /// Create a reader.
-    ///
-    /// # Safety
-    ///
-    /// Only one reader can exist at a time.
-    pub unsafe fn reader(&self) -> Reader<'_> {
-        Reader(self)
-    }
-
-    /// Create a writer.
-    ///
-    /// # Safety
-    ///
-    /// Only one writer can exist at a time.
-    pub unsafe fn writer(&self) -> Writer<'_> {
-        Writer(self)
-    }
-
-    pub fn len(&self) -> usize {
-        self.len.load(Ordering::Relaxed)
-    }
-
-    pub fn is_full(&self) -> bool {
-        let len = self.len.load(Ordering::Relaxed);
-        let start = self.start.load(Ordering::Relaxed);
-        let end = self.end.load(Ordering::Relaxed);
-
-        self.wrap(start + len) == end
-    }
-
-    pub fn is_empty(&self) -> bool {
-        let start = self.start.load(Ordering::Relaxed);
-        let end = self.end.load(Ordering::Relaxed);
-
-        start == end
-    }
-
-    fn wrap(&self, mut n: usize) -> usize {
-        let len = self.len.load(Ordering::Relaxed);
-
-        if n >= len * 2 {
-            n -= len * 2
-        }
-        n
-    }
-}
-
-impl<'a> Writer<'a> {
-    /// Push data into the buffer in-place.
-    ///
-    /// The closure `f` is called with a free part of the buffer, it must write
-    /// some data to it and return the amount of bytes written.
-    pub fn push(&mut self, f: impl FnOnce(&mut [u8]) -> usize) -> usize {
-        let (p, n) = self.push_buf();
-        let buf = unsafe { slice::from_raw_parts_mut(p, n) };
-        let n = f(buf);
-        self.push_done(n);
-        n
-    }
-
-    /// Push one data byte.
-    ///
-    /// Returns true if pushed successfully.
-    pub fn push_one(&mut self, val: u8) -> bool {
-        let n = self.push(|f| match f {
-            [] => 0,
-            [x, ..] => {
-                *x = val;
-                1
-            }
-        });
-        n != 0
-    }
-
-    /// Get a buffer where data can be pushed to.
-    ///
-    /// Equivalent to [`Self::push_buf`] but returns a slice.
-    pub fn push_slice(&mut self) -> &mut [u8] {
-        let (data, len) = self.push_buf();
-        unsafe { slice::from_raw_parts_mut(data, len) }
-    }
-
-    /// Get up to two buffers where data can be pushed to.
-    ///
-    /// Equivalent to [`Self::push_bufs`] but returns slices.
-    pub fn push_slices(&mut self) -> [&mut [u8]; 2] {
-        let [(d0, l0), (d1, l1)] = self.push_bufs();
-        unsafe { [slice::from_raw_parts_mut(d0, l0), slice::from_raw_parts_mut(d1, l1)] }
-    }
-
-    /// Get a buffer where data can be pushed to.
-    ///
-    /// Write data to the start of the buffer, then call `push_done` with
-    /// however many bytes you've pushed.
-    ///
-    /// The buffer is suitable to DMA to.
-    ///
-    /// If the ringbuf is full, size=0 will be returned.
-    ///
-    /// The buffer stays valid as long as no other `Writer` method is called
-    /// and `init`/`deinit` aren't called on the ringbuf.
-    pub fn push_buf(&mut self) -> (*mut u8, usize) {
-        // Ordering: popping writes `start` last, so we read `start` first.
-        // Read it with Acquire ordering, so that the next accesses can't be reordered up past it.
-        let mut start = self.0.start.load(Ordering::Acquire);
-        let buf = self.0.buf.load(Ordering::Relaxed);
-        let len = self.0.len.load(Ordering::Relaxed);
-        let mut end = self.0.end.load(Ordering::Relaxed);
-
-        let empty = start == end;
-
-        if start >= len {
-            start -= len
-        }
-        if end >= len {
-            end -= len
-        }
-
-        if start == end && !empty {
-            // full
-            return (buf, 0);
-        }
-        let n = if start > end { start - end } else { len - end };
-
-        trace!("  ringbuf: push_buf {:?}..{:?}", end, end + n);
-        (unsafe { buf.add(end) }, n)
-    }
-
-    /// Get up to two buffers where data can be pushed to.
-    ///
-    /// Write data starting at the beginning of the first buffer, then call
-    /// `push_done` with however many bytes you've pushed.
-    ///
-    /// The buffers are suitable to DMA to.
-    ///
-    /// If the ringbuf is full, both buffers will be zero length.
-    /// If there is only area available, the second buffer will be zero length.
-    ///
-    /// The buffer stays valid as long as no other `Writer` method is called
-    /// and `init`/`deinit` aren't called on the ringbuf.
-    pub fn push_bufs(&mut self) -> [(*mut u8, usize); 2] {
-        // Ordering: as per push_buf()
-        let mut start = self.0.start.load(Ordering::Acquire);
-        let buf = self.0.buf.load(Ordering::Relaxed);
-        let len = self.0.len.load(Ordering::Relaxed);
-        let mut end = self.0.end.load(Ordering::Relaxed);
-
-        let empty = start == end;
-
-        if start >= len {
-            start -= len
-        }
-        if end >= len {
-            end -= len
-        }
-
-        if start == end && !empty {
-            // full
-            return [(buf, 0), (buf, 0)];
-        }
-        let n0 = if start > end { start - end } else { len - end };
-        let n1 = if start <= end { start } else { 0 };
-
-        trace!("  ringbuf: push_bufs [{:?}..{:?}, {:?}..{:?}]", end, end + n0, 0, n1);
-        [(unsafe { buf.add(end) }, n0), (buf, n1)]
-    }
-
-    pub fn push_done(&mut self, n: usize) {
-        trace!("  ringbuf: push {:?}", n);
-        let end = self.0.end.load(Ordering::Relaxed);
-
-        // Ordering: write `end` last, with Release ordering.
-        // The ordering ensures no preceding memory accesses (such as writing
-        // the actual data in the buffer) can be reordered down past it, which
-        // will guarantee the reader sees them after reading from `end`.
-        self.0.end.store(self.0.wrap(end + n), Ordering::Release);
-    }
-}
-
-impl<'a> Reader<'a> {
-    /// Pop data from the buffer in-place.
-    ///
-    /// The closure `f` is called with the next data, it must process
-    /// some data from it and return the amount of bytes processed.
-    pub fn pop(&mut self, f: impl FnOnce(&[u8]) -> usize) -> usize {
-        let (p, n) = self.pop_buf();
-        let buf = unsafe { slice::from_raw_parts(p, n) };
-        let n = f(buf);
-        self.pop_done(n);
-        n
-    }
-
-    /// Pop one data byte.
-    ///
-    /// Returns true if popped successfully.
-    pub fn pop_one(&mut self) -> Option<u8> {
-        let mut res = None;
-        self.pop(|f| match f {
-            &[] => 0,
-            &[x, ..] => {
-                res = Some(x);
-                1
-            }
-        });
-        res
-    }
-
-    /// Get a buffer where data can be popped from.
-    ///
-    /// Equivalent to [`Self::pop_buf`] but returns a slice.
-    pub fn pop_slice(&mut self) -> &mut [u8] {
-        let (data, len) = self.pop_buf();
-        unsafe { slice::from_raw_parts_mut(data, len) }
-    }
-
-    /// Get a buffer where data can be popped from.
-    ///
-    /// Read data from the start of the buffer, then call `pop_done` with
-    /// however many bytes you've processed.
-    ///
-    /// The buffer is suitable to DMA from.
-    ///
-    /// If the ringbuf is empty, size=0 will be returned.
-    ///
-    /// The buffer stays valid as long as no other `Reader` method is called
-    /// and `init`/`deinit` aren't called on the ringbuf.
-    pub fn pop_buf(&mut self) -> (*mut u8, usize) {
-        // Ordering: pushing writes `end` last, so we read `end` first.
-        // Read it with Acquire ordering, so that the next accesses can't be reordered up past it.
-        // This is needed to guarantee we "see" the data written by the writer.
-        let mut end = self.0.end.load(Ordering::Acquire);
-        let buf = self.0.buf.load(Ordering::Relaxed);
-        let len = self.0.len.load(Ordering::Relaxed);
-        let mut start = self.0.start.load(Ordering::Relaxed);
-
-        if start == end {
-            return (buf, 0);
-        }
-
-        if start >= len {
-            start -= len
-        }
-        if end >= len {
-            end -= len
-        }
-
-        let n = if end > start { end - start } else { len - start };
-
-        trace!("  ringbuf: pop_buf {:?}..{:?}", start, start + n);
-        (unsafe { buf.add(start) }, n)
-    }
-
-    pub fn pop_done(&mut self, n: usize) {
-        trace!("  ringbuf: pop {:?}", n);
-
-        let start = self.0.start.load(Ordering::Relaxed);
-
-        // Ordering: write `start` last, with Release ordering.
-        // The ordering ensures no preceding memory accesses (such as reading
-        // the actual data) can be reordered down past it. This is necessary
-        // because writing to `start` is effectively freeing the read part of the
-        // buffer, which "gives permission" to the writer to write to it again.
-        // Therefore, all buffer accesses must be completed before this.
-        self.0.start.store(self.0.wrap(start + n), Ordering::Release);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn push_pop() {
-        let mut b = [0; 4];
-        let rb = RingBuffer::new();
-        unsafe {
-            rb.init(b.as_mut_ptr(), 4);
-
-            assert_eq!(rb.is_empty(), true);
-            assert_eq!(rb.is_full(), false);
-
-            rb.writer().push(|buf| {
-                assert_eq!(4, buf.len());
-                buf[0] = 1;
-                buf[1] = 2;
-                buf[2] = 3;
-                buf[3] = 4;
-                4
-            });
-
-            assert_eq!(rb.is_empty(), false);
-            assert_eq!(rb.is_full(), true);
-
-            rb.writer().push(|buf| {
-                // If it's full, we can push 0 bytes.
-                assert_eq!(0, buf.len());
-                0
-            });
-
-            assert_eq!(rb.is_empty(), false);
-            assert_eq!(rb.is_full(), true);
-
-            rb.reader().pop(|buf| {
-                assert_eq!(4, buf.len());
-                assert_eq!(1, buf[0]);
-                1
-            });
-
-            assert_eq!(rb.is_empty(), false);
-            assert_eq!(rb.is_full(), false);
-
-            rb.reader().pop(|buf| {
-                assert_eq!(3, buf.len());
-                0
-            });
-
-            assert_eq!(rb.is_empty(), false);
-            assert_eq!(rb.is_full(), false);
-
-            rb.reader().pop(|buf| {
-                assert_eq!(3, buf.len());
-                assert_eq!(2, buf[0]);
-                assert_eq!(3, buf[1]);
-                2
-            });
-            rb.reader().pop(|buf| {
-                assert_eq!(1, buf.len());
-                assert_eq!(4, buf[0]);
-                1
-            });
-
-            assert_eq!(rb.is_empty(), true);
-            assert_eq!(rb.is_full(), false);
-
-            rb.reader().pop(|buf| {
-                assert_eq!(0, buf.len());
-                0
-            });
-
-            rb.writer().push(|buf| {
-                assert_eq!(4, buf.len());
-                buf[0] = 10;
-                1
-            });
-
-            rb.writer().push(|buf| {
-                assert_eq!(3, buf.len());
-                buf[0] = 11;
-                buf[1] = 12;
-                2
-            });
-
-            assert_eq!(rb.is_empty(), false);
-            assert_eq!(rb.is_full(), false);
-
-            rb.writer().push(|buf| {
-                assert_eq!(1, buf.len());
-                buf[0] = 13;
-                1
-            });
-
-            assert_eq!(rb.is_empty(), false);
-            assert_eq!(rb.is_full(), true);
-        }
-    }
-
-    #[test]
-    fn zero_len() {
-        let rb = RingBuffer::new();
-        unsafe {
-            assert_eq!(rb.is_empty(), true);
-            assert_eq!(rb.is_full(), true);
-
-            rb.writer().push(|buf| {
-                assert_eq!(0, buf.len());
-                0
-            });
-
-            rb.reader().pop(|buf| {
-                assert_eq!(0, buf.len());
-                0
-            });
-        }
-    }
-
-    #[test]
-    fn push_slices() {
-        let mut b = [0; 4];
-        let rb = RingBuffer::new();
-        unsafe {
-            rb.init(b.as_mut_ptr(), 4);
-
-            /* push 3 -> [1 2 3 x] */
-            let mut w = rb.writer();
-            let ps = w.push_slices();
-            assert_eq!(4, ps[0].len());
-            assert_eq!(0, ps[1].len());
-            ps[0][0] = 1;
-            ps[0][1] = 2;
-            ps[0][2] = 3;
-            w.push_done(3);
-            drop(w);
-
-            /* pop 2 -> [x x 3 x] */
-            rb.reader().pop(|buf| {
-                assert_eq!(3, buf.len());
-                assert_eq!(1, buf[0]);
-                assert_eq!(2, buf[1]);
-                assert_eq!(3, buf[2]);
-                2
-            });
-
-            /* push 3 -> [5 6 3 4] */
-            let mut w = rb.writer();
-            let ps = w.push_slices();
-            assert_eq!(1, ps[0].len());
-            assert_eq!(2, ps[1].len());
-            ps[0][0] = 4;
-            ps[1][0] = 5;
-            ps[1][1] = 6;
-            w.push_done(3);
-            drop(w);
-
-            /* buf is now full */
-            let mut w = rb.writer();
-            let ps = w.push_slices();
-            assert_eq!(0, ps[0].len());
-            assert_eq!(0, ps[1].len());
-
-            /* pop 2 -> [5 6 x x] */
-            rb.reader().pop(|buf| {
-                assert_eq!(2, buf.len());
-                assert_eq!(3, buf[0]);
-                assert_eq!(4, buf[1]);
-                2
-            });
-
-            /* should now have one push slice again */
-            let mut w = rb.writer();
-            let ps = w.push_slices();
-            assert_eq!(2, ps[0].len());
-            assert_eq!(0, ps[1].len());
-            drop(w);
-
-            /* pop 2 -> [x x x x] */
-            rb.reader().pop(|buf| {
-                assert_eq!(2, buf.len());
-                assert_eq!(5, buf[0]);
-                assert_eq!(6, buf[1]);
-                2
-            });
-
-            /* should now have two push slices */
-            let mut w = rb.writer();
-            let ps = w.push_slices();
-            assert_eq!(2, ps[0].len());
-            assert_eq!(2, ps[1].len());
-            drop(w);
-
-            /* make sure we exercise all wrap around cases properly */
-            for _ in 0..10 {
-                /* should be empty, push 1 */
-                let mut w = rb.writer();
-                let ps = w.push_slices();
-                assert_eq!(4, ps[0].len() + ps[1].len());
-                w.push_done(1);
-                drop(w);
-
-                /* should have 1 element */
-                let mut w = rb.writer();
-                let ps = w.push_slices();
-                assert_eq!(3, ps[0].len() + ps[1].len());
-                drop(w);
-
-                /* pop 1 */
-                rb.reader().pop(|buf| {
-                    assert_eq!(1, buf.len());
-                    1
-                });
-            }
-        }
-    }
-}
diff --git a/embassy-hal-common/src/drop.rs b/embassy-hal-common/src/drop.rs
deleted file mode 100644
index 7cd16aaec..000000000
--- a/embassy-hal-common/src/drop.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-use core::mem;
-use core::mem::MaybeUninit;
-
-#[must_use = "to delay the drop handler invokation to the end of the scope"]
-pub struct OnDrop<F: FnOnce()> {
-    f: MaybeUninit<F>,
-}
-
-impl<F: FnOnce()> OnDrop<F> {
-    pub fn new(f: F) -> Self {
-        Self { f: MaybeUninit::new(f) }
-    }
-
-    pub fn defuse(self) {
-        mem::forget(self)
-    }
-}
-
-impl<F: FnOnce()> Drop for OnDrop<F> {
-    fn drop(&mut self) {
-        unsafe { self.f.as_ptr().read()() }
-    }
-}
-
-/// An explosive ordinance that panics if it is improperly disposed of.
-///
-/// This is to forbid dropping futures, when there is absolutely no other choice.
-///
-/// To correctly dispose of this device, call the [defuse](struct.DropBomb.html#method.defuse)
-/// method before this object is dropped.
-#[must_use = "to delay the drop bomb invokation to the end of the scope"]
-pub struct DropBomb {
-    _private: (),
-}
-
-impl DropBomb {
-    pub fn new() -> Self {
-        Self { _private: () }
-    }
-
-    /// Defuses the bomb, rendering it safe to drop.
-    pub fn defuse(self) {
-        mem::forget(self)
-    }
-}
-
-impl Drop for DropBomb {
-    fn drop(&mut self) {
-        panic!("boom")
-    }
-}
diff --git a/embassy-hal-common/src/fmt.rs b/embassy-hal-common/src/fmt.rs
deleted file mode 100644
index 066970813..000000000
--- a/embassy-hal-common/src/fmt.rs
+++ /dev/null
@@ -1,225 +0,0 @@
-#![macro_use]
-#![allow(unused_macros)]
-
-#[cfg(all(feature = "defmt", feature = "log"))]
-compile_error!("You may not enable both `defmt` and `log` features.");
-
-macro_rules! assert {
-    ($($x:tt)*) => {
-        {
-            #[cfg(not(feature = "defmt"))]
-            ::core::assert!($($x)*);
-            #[cfg(feature = "defmt")]
-            ::defmt::assert!($($x)*);
-        }
-    };
-}
-
-macro_rules! assert_eq {
-    ($($x:tt)*) => {
-        {
-            #[cfg(not(feature = "defmt"))]
-            ::core::assert_eq!($($x)*);
-            #[cfg(feature = "defmt")]
-            ::defmt::assert_eq!($($x)*);
-        }
-    };
-}
-
-macro_rules! assert_ne {
-    ($($x:tt)*) => {
-        {
-            #[cfg(not(feature = "defmt"))]
-            ::core::assert_ne!($($x)*);
-            #[cfg(feature = "defmt")]
-            ::defmt::assert_ne!($($x)*);
-        }
-    };
-}
-
-macro_rules! debug_assert {
-    ($($x:tt)*) => {
-        {
-            #[cfg(not(feature = "defmt"))]
-            ::core::debug_assert!($($x)*);
-            #[cfg(feature = "defmt")]
-            ::defmt::debug_assert!($($x)*);
-        }
-    };
-}
-
-macro_rules! debug_assert_eq {
-    ($($x:tt)*) => {
-        {
-            #[cfg(not(feature = "defmt"))]
-            ::core::debug_assert_eq!($($x)*);
-            #[cfg(feature = "defmt")]
-            ::defmt::debug_assert_eq!($($x)*);
-        }
-    };
-}
-
-macro_rules! debug_assert_ne {
-    ($($x:tt)*) => {
-        {
-            #[cfg(not(feature = "defmt"))]
-            ::core::debug_assert_ne!($($x)*);
-            #[cfg(feature = "defmt")]
-            ::defmt::debug_assert_ne!($($x)*);
-        }
-    };
-}
-
-macro_rules! todo {
-    ($($x:tt)*) => {
-        {
-            #[cfg(not(feature = "defmt"))]
-            ::core::todo!($($x)*);
-            #[cfg(feature = "defmt")]
-            ::defmt::todo!($($x)*);
-        }
-    };
-}
-
-macro_rules! unreachable {
-    ($($x:tt)*) => {
-        {
-            #[cfg(not(feature = "defmt"))]
-            ::core::unreachable!($($x)*);
-            #[cfg(feature = "defmt")]
-            ::defmt::unreachable!($($x)*);
-        }
-    };
-}
-
-macro_rules! panic {
-    ($($x:tt)*) => {
-        {
-            #[cfg(not(feature = "defmt"))]
-            ::core::panic!($($x)*);
-            #[cfg(feature = "defmt")]
-            ::defmt::panic!($($x)*);
-        }
-    };
-}
-
-macro_rules! trace {
-    ($s:literal $(, $x:expr)* $(,)?) => {
-        {
-            #[cfg(feature = "log")]
-            ::log::trace!($s $(, $x)*);
-            #[cfg(feature = "defmt")]
-            ::defmt::trace!($s $(, $x)*);
-            #[cfg(not(any(feature = "log", feature="defmt")))]
-            let _ = ($( & $x ),*);
-        }
-    };
-}
-
-macro_rules! debug {
-    ($s:literal $(, $x:expr)* $(,)?) => {
-        {
-            #[cfg(feature = "log")]
-            ::log::debug!($s $(, $x)*);
-            #[cfg(feature = "defmt")]
-            ::defmt::debug!($s $(, $x)*);
-            #[cfg(not(any(feature = "log", feature="defmt")))]
-            let _ = ($( & $x ),*);
-        }
-    };
-}
-
-macro_rules! info {
-    ($s:literal $(, $x:expr)* $(,)?) => {
-        {
-            #[cfg(feature = "log")]
-            ::log::info!($s $(, $x)*);
-            #[cfg(feature = "defmt")]
-            ::defmt::info!($s $(, $x)*);
-            #[cfg(not(any(feature = "log", feature="defmt")))]
-            let _ = ($( & $x ),*);
-        }
-    };
-}
-
-macro_rules! warn {
-    ($s:literal $(, $x:expr)* $(,)?) => {
-        {
-            #[cfg(feature = "log")]
-            ::log::warn!($s $(, $x)*);
-            #[cfg(feature = "defmt")]
-            ::defmt::warn!($s $(, $x)*);
-            #[cfg(not(any(feature = "log", feature="defmt")))]
-            let _ = ($( & $x ),*);
-        }
-    };
-}
-
-macro_rules! error {
-    ($s:literal $(, $x:expr)* $(,)?) => {
-        {
-            #[cfg(feature = "log")]
-            ::log::error!($s $(, $x)*);
-            #[cfg(feature = "defmt")]
-            ::defmt::error!($s $(, $x)*);
-            #[cfg(not(any(feature = "log", feature="defmt")))]
-            let _ = ($( & $x ),*);
-        }
-    };
-}
-
-#[cfg(feature = "defmt")]
-macro_rules! unwrap {
-    ($($x:tt)*) => {
-        ::defmt::unwrap!($($x)*)
-    };
-}
-
-#[cfg(not(feature = "defmt"))]
-macro_rules! unwrap {
-    ($arg:expr) => {
-        match $crate::fmt::Try::into_result($arg) {
-            ::core::result::Result::Ok(t) => t,
-            ::core::result::Result::Err(e) => {
-                ::core::panic!("unwrap of `{}` failed: {:?}", ::core::stringify!($arg), e);
-            }
-        }
-    };
-    ($arg:expr, $($msg:expr),+ $(,)? ) => {
-        match $crate::fmt::Try::into_result($arg) {
-            ::core::result::Result::Ok(t) => t,
-            ::core::result::Result::Err(e) => {
-                ::core::panic!("unwrap of `{}` failed: {}: {:?}", ::core::stringify!($arg), ::core::format_args!($($msg,)*), e);
-            }
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub struct NoneError;
-
-pub trait Try {
-    type Ok;
-    type Error;
-    fn into_result(self) -> Result<Self::Ok, Self::Error>;
-}
-
-impl<T> Try for Option<T> {
-    type Ok = T;
-    type Error = NoneError;
-
-    #[inline]
-    fn into_result(self) -> Result<T, NoneError> {
-        self.ok_or(NoneError)
-    }
-}
-
-impl<T, E> Try for Result<T, E> {
-    type Ok = T;
-    type Error = E;
-
-    #[inline]
-    fn into_result(self) -> Self {
-        self
-    }
-}
diff --git a/embassy-hal-common/src/interrupt.rs b/embassy-hal-common/src/interrupt.rs
deleted file mode 100644
index b970aa2cd..000000000
--- a/embassy-hal-common/src/interrupt.rs
+++ /dev/null
@@ -1,846 +0,0 @@
-//! Interrupt handling for cortex-m devices.
-use core::mem;
-use core::sync::atomic::{compiler_fence, Ordering};
-
-use cortex_m::interrupt::InterruptNumber;
-use cortex_m::peripheral::NVIC;
-
-/// Generate a standard `mod interrupt` for a HAL.
-#[macro_export]
-macro_rules! interrupt_mod {
-    ($($irqs:ident),* $(,)?) => {
-        #[cfg(feature = "rt")]
-        pub use cortex_m_rt::interrupt;
-
-        /// Interrupt definitions.
-        pub mod interrupt {
-            pub use $crate::interrupt::{InterruptExt, Priority};
-            pub use crate::pac::Interrupt::*;
-            pub use crate::pac::Interrupt;
-
-            /// Type-level interrupt infrastructure.
-            ///
-            /// This module contains one *type* per interrupt. This is used for checking at compile time that
-            /// the interrupts are correctly bound to HAL drivers.
-            ///
-            /// As an end user, you shouldn't need to use this module directly. Use the [`crate::bind_interrupts!`] macro
-            /// to bind interrupts, and the [`crate::interrupt`] module to manually register interrupt handlers and manipulate
-            /// interrupts directly (pending/unpending, enabling/disabling, setting the priority, etc...)
-            pub mod typelevel {
-                use super::InterruptExt;
-
-                mod sealed {
-                    pub trait Interrupt {}
-                }
-
-                /// Type-level interrupt.
-                ///
-                /// This trait is implemented for all typelevel interrupt types in this module.
-                pub trait Interrupt: sealed::Interrupt {
-
-                    /// Interrupt enum variant.
-                    ///
-                    /// This allows going from typelevel interrupts (one type per interrupt) to
-                    /// non-typelevel interrupts (a single `Interrupt` enum type, with one variant per interrupt).
-                    const IRQ: super::Interrupt;
-
-                    /// Enable the interrupt.
-                    #[inline]
-                    unsafe fn enable() {
-                        Self::IRQ.enable()
-                    }
-
-                    /// Disable the interrupt.
-                    #[inline]
-                    fn disable() {
-                        Self::IRQ.disable()
-                    }
-
-                    /// Check if interrupt is enabled.
-                    #[inline]
-                    fn is_enabled() -> bool {
-                        Self::IRQ.is_enabled()
-                    }
-
-                    /// Check if interrupt is pending.
-                    #[inline]
-                    fn is_pending() -> bool {
-                        Self::IRQ.is_pending()
-                    }
-
-                    /// Set interrupt pending.
-                    #[inline]
-                    fn pend() {
-                        Self::IRQ.pend()
-                    }
-
-                    /// Unset interrupt pending.
-                    #[inline]
-                    fn unpend() {
-                        Self::IRQ.unpend()
-                    }
-
-                    /// Get the priority of the interrupt.
-                    #[inline]
-                    fn get_priority() -> crate::interrupt::Priority {
-                        Self::IRQ.get_priority()
-                    }
-
-                    /// Set the interrupt priority.
-                    #[inline]
-                    fn set_priority(prio: crate::interrupt::Priority) {
-                        Self::IRQ.set_priority(prio)
-                    }
-                }
-
-                $(
-                    #[allow(non_camel_case_types)]
-                    #[doc=stringify!($irqs)]
-                    #[doc=" typelevel interrupt."]
-                    pub enum $irqs {}
-                    impl sealed::Interrupt for $irqs{}
-                    impl Interrupt for $irqs {
-                        const IRQ: super::Interrupt = super::Interrupt::$irqs;
-                    }
-                )*
-
-                /// Interrupt handler trait.
-                ///
-                /// Drivers that need to handle interrupts implement this trait.
-                /// The user must ensure `on_interrupt()` is called every time the interrupt fires.
-                /// Drivers must use use [`Binding`] to assert at compile time that the user has done so.
-                pub trait Handler<I: Interrupt> {
-                    /// Interrupt handler function.
-                    ///
-                    /// Must be called every time the `I` interrupt fires, synchronously from
-                    /// the interrupt handler context.
-                    ///
-                    /// # Safety
-                    ///
-                    /// This function must ONLY be called from the interrupt handler for `I`.
-                    unsafe fn on_interrupt();
-                }
-
-                /// Compile-time assertion that an interrupt has been bound to a handler.
-                ///
-                /// For the vast majority of cases, you should use the `bind_interrupts!`
-                /// macro instead of writing `unsafe impl`s of this trait.
-                ///
-                /// # Safety
-                ///
-                /// By implementing this trait, you are asserting that you have arranged for `H::on_interrupt()`
-                /// to be called every time the `I` interrupt fires.
-                ///
-                /// This allows drivers to check bindings at compile-time.
-                pub unsafe trait Binding<I: Interrupt, H: Handler<I>> {}
-            }
-        }
-    };
-}
-
-/// Represents an interrupt type that can be configured by embassy to handle
-/// interrupts.
-pub unsafe trait InterruptExt: InterruptNumber + Copy {
-    /// Enable the interrupt.
-    #[inline]
-    unsafe fn enable(self) {
-        compiler_fence(Ordering::SeqCst);
-        NVIC::unmask(self)
-    }
-
-    /// Disable the interrupt.
-    #[inline]
-    fn disable(self) {
-        NVIC::mask(self);
-        compiler_fence(Ordering::SeqCst);
-    }
-
-    /// Check if interrupt is being handled.
-    #[inline]
-    #[cfg(not(armv6m))]
-    fn is_active(self) -> bool {
-        NVIC::is_active(self)
-    }
-
-    /// Check if interrupt is enabled.
-    #[inline]
-    fn is_enabled(self) -> bool {
-        NVIC::is_enabled(self)
-    }
-
-    /// Check if interrupt is pending.
-    #[inline]
-    fn is_pending(self) -> bool {
-        NVIC::is_pending(self)
-    }
-
-    /// Set interrupt pending.
-    #[inline]
-    fn pend(self) {
-        NVIC::pend(self)
-    }
-
-    /// Unset interrupt pending.
-    #[inline]
-    fn unpend(self) {
-        NVIC::unpend(self)
-    }
-
-    /// Get the priority of the interrupt.
-    #[inline]
-    fn get_priority(self) -> Priority {
-        Priority::from(NVIC::get_priority(self))
-    }
-
-    /// Set the interrupt priority.
-    #[inline]
-    fn set_priority(self, prio: Priority) {
-        critical_section::with(|_| unsafe {
-            let mut nvic: cortex_m::peripheral::NVIC = mem::transmute(());
-            nvic.set_priority(self, prio.into())
-        })
-    }
-}
-
-unsafe impl<T: InterruptNumber + Copy> InterruptExt for T {}
-
-impl From<u8> for Priority {
-    fn from(priority: u8) -> Self {
-        unsafe { mem::transmute(priority & PRIO_MASK) }
-    }
-}
-
-impl From<Priority> for u8 {
-    fn from(p: Priority) -> Self {
-        p as u8
-    }
-}
-
-#[cfg(feature = "prio-bits-0")]
-const PRIO_MASK: u8 = 0x00;
-#[cfg(feature = "prio-bits-1")]
-const PRIO_MASK: u8 = 0x80;
-#[cfg(feature = "prio-bits-2")]
-const PRIO_MASK: u8 = 0xc0;
-#[cfg(feature = "prio-bits-3")]
-const PRIO_MASK: u8 = 0xe0;
-#[cfg(feature = "prio-bits-4")]
-const PRIO_MASK: u8 = 0xf0;
-#[cfg(feature = "prio-bits-5")]
-const PRIO_MASK: u8 = 0xf8;
-#[cfg(feature = "prio-bits-6")]
-const PRIO_MASK: u8 = 0xfc;
-#[cfg(feature = "prio-bits-7")]
-const PRIO_MASK: u8 = 0xfe;
-#[cfg(feature = "prio-bits-8")]
-const PRIO_MASK: u8 = 0xff;
-
-/// The interrupt priority level.
-///
-/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
-#[cfg(feature = "prio-bits-0")]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[repr(u8)]
-#[allow(missing_docs)]
-pub enum Priority {
-    P0 = 0x0,
-}
-
-/// The interrupt priority level.
-///
-/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
-#[cfg(feature = "prio-bits-1")]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[repr(u8)]
-#[allow(missing_docs)]
-pub enum Priority {
-    P0 = 0x0,
-    P1 = 0x80,
-}
-
-/// The interrupt priority level.
-///
-/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
-#[cfg(feature = "prio-bits-2")]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[repr(u8)]
-#[allow(missing_docs)]
-pub enum Priority {
-    P0 = 0x0,
-    P1 = 0x40,
-    P2 = 0x80,
-    P3 = 0xc0,
-}
-
-/// The interrupt priority level.
-///
-/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
-#[cfg(feature = "prio-bits-3")]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[repr(u8)]
-#[allow(missing_docs)]
-pub enum Priority {
-    P0 = 0x0,
-    P1 = 0x20,
-    P2 = 0x40,
-    P3 = 0x60,
-    P4 = 0x80,
-    P5 = 0xa0,
-    P6 = 0xc0,
-    P7 = 0xe0,
-}
-
-/// The interrupt priority level.
-///
-/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
-#[cfg(feature = "prio-bits-4")]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[repr(u8)]
-#[allow(missing_docs)]
-pub enum Priority {
-    P0 = 0x0,
-    P1 = 0x10,
-    P2 = 0x20,
-    P3 = 0x30,
-    P4 = 0x40,
-    P5 = 0x50,
-    P6 = 0x60,
-    P7 = 0x70,
-    P8 = 0x80,
-    P9 = 0x90,
-    P10 = 0xa0,
-    P11 = 0xb0,
-    P12 = 0xc0,
-    P13 = 0xd0,
-    P14 = 0xe0,
-    P15 = 0xf0,
-}
-
-/// The interrupt priority level.
-///
-/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
-#[cfg(feature = "prio-bits-5")]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[repr(u8)]
-#[allow(missing_docs)]
-pub enum Priority {
-    P0 = 0x0,
-    P1 = 0x8,
-    P2 = 0x10,
-    P3 = 0x18,
-    P4 = 0x20,
-    P5 = 0x28,
-    P6 = 0x30,
-    P7 = 0x38,
-    P8 = 0x40,
-    P9 = 0x48,
-    P10 = 0x50,
-    P11 = 0x58,
-    P12 = 0x60,
-    P13 = 0x68,
-    P14 = 0x70,
-    P15 = 0x78,
-    P16 = 0x80,
-    P17 = 0x88,
-    P18 = 0x90,
-    P19 = 0x98,
-    P20 = 0xa0,
-    P21 = 0xa8,
-    P22 = 0xb0,
-    P23 = 0xb8,
-    P24 = 0xc0,
-    P25 = 0xc8,
-    P26 = 0xd0,
-    P27 = 0xd8,
-    P28 = 0xe0,
-    P29 = 0xe8,
-    P30 = 0xf0,
-    P31 = 0xf8,
-}
-
-/// The interrupt priority level.
-///
-/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
-#[cfg(feature = "prio-bits-6")]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[repr(u8)]
-#[allow(missing_docs)]
-pub enum Priority {
-    P0 = 0x0,
-    P1 = 0x4,
-    P2 = 0x8,
-    P3 = 0xc,
-    P4 = 0x10,
-    P5 = 0x14,
-    P6 = 0x18,
-    P7 = 0x1c,
-    P8 = 0x20,
-    P9 = 0x24,
-    P10 = 0x28,
-    P11 = 0x2c,
-    P12 = 0x30,
-    P13 = 0x34,
-    P14 = 0x38,
-    P15 = 0x3c,
-    P16 = 0x40,
-    P17 = 0x44,
-    P18 = 0x48,
-    P19 = 0x4c,
-    P20 = 0x50,
-    P21 = 0x54,
-    P22 = 0x58,
-    P23 = 0x5c,
-    P24 = 0x60,
-    P25 = 0x64,
-    P26 = 0x68,
-    P27 = 0x6c,
-    P28 = 0x70,
-    P29 = 0x74,
-    P30 = 0x78,
-    P31 = 0x7c,
-    P32 = 0x80,
-    P33 = 0x84,
-    P34 = 0x88,
-    P35 = 0x8c,
-    P36 = 0x90,
-    P37 = 0x94,
-    P38 = 0x98,
-    P39 = 0x9c,
-    P40 = 0xa0,
-    P41 = 0xa4,
-    P42 = 0xa8,
-    P43 = 0xac,
-    P44 = 0xb0,
-    P45 = 0xb4,
-    P46 = 0xb8,
-    P47 = 0xbc,
-    P48 = 0xc0,
-    P49 = 0xc4,
-    P50 = 0xc8,
-    P51 = 0xcc,
-    P52 = 0xd0,
-    P53 = 0xd4,
-    P54 = 0xd8,
-    P55 = 0xdc,
-    P56 = 0xe0,
-    P57 = 0xe4,
-    P58 = 0xe8,
-    P59 = 0xec,
-    P60 = 0xf0,
-    P61 = 0xf4,
-    P62 = 0xf8,
-    P63 = 0xfc,
-}
-
-/// The interrupt priority level.
-///
-/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
-#[cfg(feature = "prio-bits-7")]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[repr(u8)]
-#[allow(missing_docs)]
-pub enum Priority {
-    P0 = 0x0,
-    P1 = 0x2,
-    P2 = 0x4,
-    P3 = 0x6,
-    P4 = 0x8,
-    P5 = 0xa,
-    P6 = 0xc,
-    P7 = 0xe,
-    P8 = 0x10,
-    P9 = 0x12,
-    P10 = 0x14,
-    P11 = 0x16,
-    P12 = 0x18,
-    P13 = 0x1a,
-    P14 = 0x1c,
-    P15 = 0x1e,
-    P16 = 0x20,
-    P17 = 0x22,
-    P18 = 0x24,
-    P19 = 0x26,
-    P20 = 0x28,
-    P21 = 0x2a,
-    P22 = 0x2c,
-    P23 = 0x2e,
-    P24 = 0x30,
-    P25 = 0x32,
-    P26 = 0x34,
-    P27 = 0x36,
-    P28 = 0x38,
-    P29 = 0x3a,
-    P30 = 0x3c,
-    P31 = 0x3e,
-    P32 = 0x40,
-    P33 = 0x42,
-    P34 = 0x44,
-    P35 = 0x46,
-    P36 = 0x48,
-    P37 = 0x4a,
-    P38 = 0x4c,
-    P39 = 0x4e,
-    P40 = 0x50,
-    P41 = 0x52,
-    P42 = 0x54,
-    P43 = 0x56,
-    P44 = 0x58,
-    P45 = 0x5a,
-    P46 = 0x5c,
-    P47 = 0x5e,
-    P48 = 0x60,
-    P49 = 0x62,
-    P50 = 0x64,
-    P51 = 0x66,
-    P52 = 0x68,
-    P53 = 0x6a,
-    P54 = 0x6c,
-    P55 = 0x6e,
-    P56 = 0x70,
-    P57 = 0x72,
-    P58 = 0x74,
-    P59 = 0x76,
-    P60 = 0x78,
-    P61 = 0x7a,
-    P62 = 0x7c,
-    P63 = 0x7e,
-    P64 = 0x80,
-    P65 = 0x82,
-    P66 = 0x84,
-    P67 = 0x86,
-    P68 = 0x88,
-    P69 = 0x8a,
-    P70 = 0x8c,
-    P71 = 0x8e,
-    P72 = 0x90,
-    P73 = 0x92,
-    P74 = 0x94,
-    P75 = 0x96,
-    P76 = 0x98,
-    P77 = 0x9a,
-    P78 = 0x9c,
-    P79 = 0x9e,
-    P80 = 0xa0,
-    P81 = 0xa2,
-    P82 = 0xa4,
-    P83 = 0xa6,
-    P84 = 0xa8,
-    P85 = 0xaa,
-    P86 = 0xac,
-    P87 = 0xae,
-    P88 = 0xb0,
-    P89 = 0xb2,
-    P90 = 0xb4,
-    P91 = 0xb6,
-    P92 = 0xb8,
-    P93 = 0xba,
-    P94 = 0xbc,
-    P95 = 0xbe,
-    P96 = 0xc0,
-    P97 = 0xc2,
-    P98 = 0xc4,
-    P99 = 0xc6,
-    P100 = 0xc8,
-    P101 = 0xca,
-    P102 = 0xcc,
-    P103 = 0xce,
-    P104 = 0xd0,
-    P105 = 0xd2,
-    P106 = 0xd4,
-    P107 = 0xd6,
-    P108 = 0xd8,
-    P109 = 0xda,
-    P110 = 0xdc,
-    P111 = 0xde,
-    P112 = 0xe0,
-    P113 = 0xe2,
-    P114 = 0xe4,
-    P115 = 0xe6,
-    P116 = 0xe8,
-    P117 = 0xea,
-    P118 = 0xec,
-    P119 = 0xee,
-    P120 = 0xf0,
-    P121 = 0xf2,
-    P122 = 0xf4,
-    P123 = 0xf6,
-    P124 = 0xf8,
-    P125 = 0xfa,
-    P126 = 0xfc,
-    P127 = 0xfe,
-}
-
-/// The interrupt priority level.
-///
-/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
-#[cfg(feature = "prio-bits-8")]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-#[repr(u8)]
-#[allow(missing_docs)]
-pub enum Priority {
-    P0 = 0x0,
-    P1 = 0x1,
-    P2 = 0x2,
-    P3 = 0x3,
-    P4 = 0x4,
-    P5 = 0x5,
-    P6 = 0x6,
-    P7 = 0x7,
-    P8 = 0x8,
-    P9 = 0x9,
-    P10 = 0xa,
-    P11 = 0xb,
-    P12 = 0xc,
-    P13 = 0xd,
-    P14 = 0xe,
-    P15 = 0xf,
-    P16 = 0x10,
-    P17 = 0x11,
-    P18 = 0x12,
-    P19 = 0x13,
-    P20 = 0x14,
-    P21 = 0x15,
-    P22 = 0x16,
-    P23 = 0x17,
-    P24 = 0x18,
-    P25 = 0x19,
-    P26 = 0x1a,
-    P27 = 0x1b,
-    P28 = 0x1c,
-    P29 = 0x1d,
-    P30 = 0x1e,
-    P31 = 0x1f,
-    P32 = 0x20,
-    P33 = 0x21,
-    P34 = 0x22,
-    P35 = 0x23,
-    P36 = 0x24,
-    P37 = 0x25,
-    P38 = 0x26,
-    P39 = 0x27,
-    P40 = 0x28,
-    P41 = 0x29,
-    P42 = 0x2a,
-    P43 = 0x2b,
-    P44 = 0x2c,
-    P45 = 0x2d,
-    P46 = 0x2e,
-    P47 = 0x2f,
-    P48 = 0x30,
-    P49 = 0x31,
-    P50 = 0x32,
-    P51 = 0x33,
-    P52 = 0x34,
-    P53 = 0x35,
-    P54 = 0x36,
-    P55 = 0x37,
-    P56 = 0x38,
-    P57 = 0x39,
-    P58 = 0x3a,
-    P59 = 0x3b,
-    P60 = 0x3c,
-    P61 = 0x3d,
-    P62 = 0x3e,
-    P63 = 0x3f,
-    P64 = 0x40,
-    P65 = 0x41,
-    P66 = 0x42,
-    P67 = 0x43,
-    P68 = 0x44,
-    P69 = 0x45,
-    P70 = 0x46,
-    P71 = 0x47,
-    P72 = 0x48,
-    P73 = 0x49,
-    P74 = 0x4a,
-    P75 = 0x4b,
-    P76 = 0x4c,
-    P77 = 0x4d,
-    P78 = 0x4e,
-    P79 = 0x4f,
-    P80 = 0x50,
-    P81 = 0x51,
-    P82 = 0x52,
-    P83 = 0x53,
-    P84 = 0x54,
-    P85 = 0x55,
-    P86 = 0x56,
-    P87 = 0x57,
-    P88 = 0x58,
-    P89 = 0x59,
-    P90 = 0x5a,
-    P91 = 0x5b,
-    P92 = 0x5c,
-    P93 = 0x5d,
-    P94 = 0x5e,
-    P95 = 0x5f,
-    P96 = 0x60,
-    P97 = 0x61,
-    P98 = 0x62,
-    P99 = 0x63,
-    P100 = 0x64,
-    P101 = 0x65,
-    P102 = 0x66,
-    P103 = 0x67,
-    P104 = 0x68,
-    P105 = 0x69,
-    P106 = 0x6a,
-    P107 = 0x6b,
-    P108 = 0x6c,
-    P109 = 0x6d,
-    P110 = 0x6e,
-    P111 = 0x6f,
-    P112 = 0x70,
-    P113 = 0x71,
-    P114 = 0x72,
-    P115 = 0x73,
-    P116 = 0x74,
-    P117 = 0x75,
-    P118 = 0x76,
-    P119 = 0x77,
-    P120 = 0x78,
-    P121 = 0x79,
-    P122 = 0x7a,
-    P123 = 0x7b,
-    P124 = 0x7c,
-    P125 = 0x7d,
-    P126 = 0x7e,
-    P127 = 0x7f,
-    P128 = 0x80,
-    P129 = 0x81,
-    P130 = 0x82,
-    P131 = 0x83,
-    P132 = 0x84,
-    P133 = 0x85,
-    P134 = 0x86,
-    P135 = 0x87,
-    P136 = 0x88,
-    P137 = 0x89,
-    P138 = 0x8a,
-    P139 = 0x8b,
-    P140 = 0x8c,
-    P141 = 0x8d,
-    P142 = 0x8e,
-    P143 = 0x8f,
-    P144 = 0x90,
-    P145 = 0x91,
-    P146 = 0x92,
-    P147 = 0x93,
-    P148 = 0x94,
-    P149 = 0x95,
-    P150 = 0x96,
-    P151 = 0x97,
-    P152 = 0x98,
-    P153 = 0x99,
-    P154 = 0x9a,
-    P155 = 0x9b,
-    P156 = 0x9c,
-    P157 = 0x9d,
-    P158 = 0x9e,
-    P159 = 0x9f,
-    P160 = 0xa0,
-    P161 = 0xa1,
-    P162 = 0xa2,
-    P163 = 0xa3,
-    P164 = 0xa4,
-    P165 = 0xa5,
-    P166 = 0xa6,
-    P167 = 0xa7,
-    P168 = 0xa8,
-    P169 = 0xa9,
-    P170 = 0xaa,
-    P171 = 0xab,
-    P172 = 0xac,
-    P173 = 0xad,
-    P174 = 0xae,
-    P175 = 0xaf,
-    P176 = 0xb0,
-    P177 = 0xb1,
-    P178 = 0xb2,
-    P179 = 0xb3,
-    P180 = 0xb4,
-    P181 = 0xb5,
-    P182 = 0xb6,
-    P183 = 0xb7,
-    P184 = 0xb8,
-    P185 = 0xb9,
-    P186 = 0xba,
-    P187 = 0xbb,
-    P188 = 0xbc,
-    P189 = 0xbd,
-    P190 = 0xbe,
-    P191 = 0xbf,
-    P192 = 0xc0,
-    P193 = 0xc1,
-    P194 = 0xc2,
-    P195 = 0xc3,
-    P196 = 0xc4,
-    P197 = 0xc5,
-    P198 = 0xc6,
-    P199 = 0xc7,
-    P200 = 0xc8,
-    P201 = 0xc9,
-    P202 = 0xca,
-    P203 = 0xcb,
-    P204 = 0xcc,
-    P205 = 0xcd,
-    P206 = 0xce,
-    P207 = 0xcf,
-    P208 = 0xd0,
-    P209 = 0xd1,
-    P210 = 0xd2,
-    P211 = 0xd3,
-    P212 = 0xd4,
-    P213 = 0xd5,
-    P214 = 0xd6,
-    P215 = 0xd7,
-    P216 = 0xd8,
-    P217 = 0xd9,
-    P218 = 0xda,
-    P219 = 0xdb,
-    P220 = 0xdc,
-    P221 = 0xdd,
-    P222 = 0xde,
-    P223 = 0xdf,
-    P224 = 0xe0,
-    P225 = 0xe1,
-    P226 = 0xe2,
-    P227 = 0xe3,
-    P228 = 0xe4,
-    P229 = 0xe5,
-    P230 = 0xe6,
-    P231 = 0xe7,
-    P232 = 0xe8,
-    P233 = 0xe9,
-    P234 = 0xea,
-    P235 = 0xeb,
-    P236 = 0xec,
-    P237 = 0xed,
-    P238 = 0xee,
-    P239 = 0xef,
-    P240 = 0xf0,
-    P241 = 0xf1,
-    P242 = 0xf2,
-    P243 = 0xf3,
-    P244 = 0xf4,
-    P245 = 0xf5,
-    P246 = 0xf6,
-    P247 = 0xf7,
-    P248 = 0xf8,
-    P249 = 0xf9,
-    P250 = 0xfa,
-    P251 = 0xfb,
-    P252 = 0xfc,
-    P253 = 0xfd,
-    P254 = 0xfe,
-    P255 = 0xff,
-}
diff --git a/embassy-hal-common/src/lib.rs b/embassy-hal-common/src/lib.rs
deleted file mode 100644
index 235964aa4..000000000
--- a/embassy-hal-common/src/lib.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![no_std]
-#![allow(clippy::new_without_default)]
-
-// This mod MUST go first, so that the others see its macros.
-pub(crate) mod fmt;
-
-pub mod atomic_ring_buffer;
-pub mod drop;
-mod macros;
-mod peripheral;
-pub mod ratio;
-pub mod ring_buffer;
-pub use peripheral::{Peripheral, PeripheralRef};
-
-#[cfg(feature = "cortex-m")]
-pub mod interrupt;
diff --git a/embassy-hal-common/src/macros.rs b/embassy-hal-common/src/macros.rs
deleted file mode 100644
index f06b46002..000000000
--- a/embassy-hal-common/src/macros.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-#[macro_export]
-macro_rules! peripherals_definition {
-    ($($(#[$cfg:meta])? $name:ident),*$(,)?) => {
-        /// Types for the peripheral singletons.
-        pub mod peripherals {
-            $(
-                $(#[$cfg])?
-                #[allow(non_camel_case_types)]
-                #[doc = concat!(stringify!($name), " peripheral")]
-                pub struct $name { _private: () }
-
-                $(#[$cfg])?
-                impl $name {
-                    /// Unsafely create an instance of this peripheral out of thin air.
-                    ///
-                    /// # Safety
-                    ///
-                    /// You must ensure that you're only using one instance of this type at a time.
-                    #[inline]
-                    pub unsafe fn steal() -> Self {
-                        Self{ _private: ()}
-                    }
-                }
-
-                $(#[$cfg])?
-                $crate::impl_peripheral!($name);
-            )*
-        }
-    };
-}
-
-#[macro_export]
-macro_rules! peripherals_struct {
-    ($($(#[$cfg:meta])? $name:ident),*$(,)?) => {
-        /// Struct containing all the peripheral singletons.
-        ///
-        /// To obtain the peripherals, you must initialize the HAL, by calling [`crate::init`].
-        #[allow(non_snake_case)]
-        pub struct Peripherals {
-            $(
-                #[doc = concat!(stringify!($name), " peripheral")]
-                $(#[$cfg])?
-                pub $name: peripherals::$name,
-            )*
-        }
-
-        impl Peripherals {
-            ///Returns all the peripherals *once*
-            #[inline]
-            pub(crate) fn take() -> Self {
-
-                #[no_mangle]
-                static mut _EMBASSY_DEVICE_PERIPHERALS: bool = false;
-
-                critical_section::with(|_| unsafe {
-                    if _EMBASSY_DEVICE_PERIPHERALS {
-                        panic!("init called more than once!")
-                    }
-                    _EMBASSY_DEVICE_PERIPHERALS = true;
-                    Self::steal()
-                })
-            }
-        }
-
-        impl Peripherals {
-            /// Unsafely create an instance of this peripheral out of thin air.
-            ///
-            /// # Safety
-            ///
-            /// You must ensure that you're only using one instance of this type at a time.
-            #[inline]
-            pub unsafe fn steal() -> Self {
-                Self {
-                    $(
-                        $(#[$cfg])?
-                        $name: peripherals::$name::steal(),
-                    )*
-                }
-            }
-        }
-    };
-}
-
-#[macro_export]
-macro_rules! peripherals {
-    ($($(#[$cfg:meta])? $name:ident),*$(,)?) => {
-        $crate::peripherals_definition!(
-            $(
-                $(#[$cfg])?
-                $name,
-            )*
-        );
-        $crate::peripherals_struct!(
-            $(
-                $(#[$cfg])?
-                $name,
-            )*
-        );
-    };
-}
-
-#[macro_export]
-macro_rules! into_ref {
-    ($($name:ident),*) => {
-        $(
-            let mut $name = $name.into_ref();
-        )*
-    }
-}
-
-#[macro_export]
-macro_rules! impl_peripheral {
-    ($type:ident) => {
-        impl $crate::Peripheral for $type {
-            type P = $type;
-
-            #[inline]
-            unsafe fn clone_unchecked(&self) -> Self::P {
-                $type { ..*self }
-            }
-        }
-    };
-}
diff --git a/embassy-hal-common/src/peripheral.rs b/embassy-hal-common/src/peripheral.rs
deleted file mode 100644
index 38b4c452e..000000000
--- a/embassy-hal-common/src/peripheral.rs
+++ /dev/null
@@ -1,174 +0,0 @@
-use core::marker::PhantomData;
-use core::ops::{Deref, DerefMut};
-
-/// An exclusive reference to a peripheral.
-///
-/// This is functionally the same as a `&'a mut T`. There's a few advantages in having
-/// a dedicated struct instead:
-///
-/// - Memory efficiency: Peripheral singletons are typically either zero-sized (for concrete
-///   peripherals like `PA9` or `SPI4`) or very small (for example `AnyPin`, which is 1 byte).
-///   However `&mut T` is always 4 bytes for 32-bit targets, even if T is zero-sized.
-///   PeripheralRef stores a copy of `T` instead, so it's the same size.
-/// - Code size efficiency. If the user uses the same driver with both `SPI4` and `&mut SPI4`,
-///   the driver code would be monomorphized two times. With PeripheralRef, the driver is generic
-///   over a lifetime only. `SPI4` becomes `PeripheralRef<'static, SPI4>`, and `&mut SPI4` becomes
-///   `PeripheralRef<'a, SPI4>`. Lifetimes don't cause monomorphization.
-pub struct PeripheralRef<'a, T> {
-    inner: T,
-    _lifetime: PhantomData<&'a mut T>,
-}
-
-impl<'a, T> PeripheralRef<'a, T> {
-    #[inline]
-    pub fn new(inner: T) -> Self {
-        Self {
-            inner,
-            _lifetime: PhantomData,
-        }
-    }
-
-    /// Unsafely clone (duplicate) a peripheral singleton.
-    ///
-    /// # Safety
-    ///
-    /// This returns an owned clone of the peripheral. You must manually ensure
-    /// only one copy of the peripheral is in use at a time. For example, don't
-    /// create two SPI drivers on `SPI1`, because they will "fight" each other.
-    ///
-    /// You should strongly prefer using `reborrow()` instead. It returns a
-    /// `PeripheralRef` that borrows `self`, which allows the borrow checker
-    /// to enforce this at compile time.
-    pub unsafe fn clone_unchecked(&self) -> PeripheralRef<'a, T>
-    where
-        T: Peripheral<P = T>,
-    {
-        PeripheralRef::new(self.inner.clone_unchecked())
-    }
-
-    /// Reborrow into a "child" PeripheralRef.
-    ///
-    /// `self` will stay borrowed until the child PeripheralRef is dropped.
-    pub fn reborrow(&mut self) -> PeripheralRef<'_, T>
-    where
-        T: Peripheral<P = T>,
-    {
-        // safety: we're returning the clone inside a new PeripheralRef that borrows
-        // self, so user code can't use both at the same time.
-        PeripheralRef::new(unsafe { self.inner.clone_unchecked() })
-    }
-
-    /// Map the inner peripheral using `Into`.
-    ///
-    /// This converts from `PeripheralRef<'a, T>` to `PeripheralRef<'a, U>`, using an
-    /// `Into` impl to convert from `T` to `U`.
-    ///
-    /// For example, this can be useful to degrade GPIO pins: converting from PeripheralRef<'a, PB11>` to `PeripheralRef<'a, AnyPin>`.
-    #[inline]
-    pub fn map_into<U>(self) -> PeripheralRef<'a, U>
-    where
-        T: Into<U>,
-    {
-        PeripheralRef {
-            inner: self.inner.into(),
-            _lifetime: PhantomData,
-        }
-    }
-}
-
-impl<'a, T> Deref for PeripheralRef<'a, T> {
-    type Target = T;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl<'a, T> DerefMut for PeripheralRef<'a, T> {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.inner
-    }
-}
-
-/// Trait for any type that can be used as a peripheral of type `P`.
-///
-/// This is used in driver constructors, to allow passing either owned peripherals (e.g. `TWISPI0`),
-/// or borrowed peripherals (e.g. `&mut TWISPI0`).
-///
-/// For example, if you have a driver with a constructor like this:
-///
-/// ```ignore
-/// impl<'d, T: Instance> Twim<'d, T> {
-///     pub fn new(
-///         twim: impl Peripheral<P = T> + 'd,
-///         irq: impl Peripheral<P = T::Interrupt> + 'd,
-///         sda: impl Peripheral<P = impl GpioPin> + 'd,
-///         scl: impl Peripheral<P = impl GpioPin> + 'd,
-///         config: Config,
-///     ) -> Self { .. }
-/// }
-/// ```
-///
-/// You may call it with owned peripherals, which yields an instance that can live forever (`'static`):
-///
-/// ```ignore
-/// let mut twi: Twim<'static, ...> = Twim::new(p.TWISPI0, irq, p.P0_03, p.P0_04, config);
-/// ```
-///
-/// Or you may call it with borrowed peripherals, which yields an instance that can only live for as long
-/// as the borrows last:
-///
-/// ```ignore
-/// let mut twi: Twim<'_, ...> = Twim::new(&mut p.TWISPI0, &mut irq, &mut p.P0_03, &mut p.P0_04, config);
-/// ```
-///
-/// # Implementation details, for HAL authors
-///
-/// When writing a HAL, the intended way to use this trait is to take `impl Peripheral<P = ..>` in
-/// the HAL's public API (such as driver constructors), calling `.into_ref()` to obtain a `PeripheralRef`,
-/// and storing that in the driver struct.
-///
-/// `.into_ref()` on an owned `T` yields a `PeripheralRef<'static, T>`.
-/// `.into_ref()` on an `&'a mut T` yields a `PeripheralRef<'a, T>`.
-pub trait Peripheral: Sized {
-    /// Peripheral singleton type
-    type P;
-
-    /// Unsafely clone (duplicate) a peripheral singleton.
-    ///
-    /// # Safety
-    ///
-    /// This returns an owned clone of the peripheral. You must manually ensure
-    /// only one copy of the peripheral is in use at a time. For example, don't
-    /// create two SPI drivers on `SPI1`, because they will "fight" each other.
-    ///
-    /// You should strongly prefer using `into_ref()` instead. It returns a
-    /// `PeripheralRef`, which allows the borrow checker to enforce this at compile time.
-    unsafe fn clone_unchecked(&self) -> Self::P;
-
-    /// Convert a value into a `PeripheralRef`.
-    ///
-    /// When called on an owned `T`, yields a `PeripheralRef<'static, T>`.
-    /// When called on an `&'a mut T`, yields a `PeripheralRef<'a, T>`.
-    #[inline]
-    fn into_ref<'a>(self) -> PeripheralRef<'a, Self::P>
-    where
-        Self: 'a,
-    {
-        PeripheralRef::new(unsafe { self.clone_unchecked() })
-    }
-}
-
-impl<'b, T: DerefMut> Peripheral for T
-where
-    T::Target: Peripheral,
-{
-    type P = <T::Target as Peripheral>::P;
-
-    #[inline]
-    unsafe fn clone_unchecked(&self) -> Self::P {
-        self.deref().clone_unchecked()
-    }
-}
diff --git a/embassy-hal-common/src/ratio.rs b/embassy-hal-common/src/ratio.rs
deleted file mode 100644
index 9a8808a33..000000000
--- a/embassy-hal-common/src/ratio.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-use core::ops::{Add, Div, Mul};
-
-use num_traits::{CheckedAdd, CheckedDiv, CheckedMul};
-
-/// Represents the ratio between two numbers.
-#[derive(Copy, Clone, Debug)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub struct Ratio<T> {
-    /// Numerator.
-    numer: T,
-    /// Denominator.
-    denom: T,
-}
-
-impl<T> Ratio<T> {
-    /// Creates a new `Ratio`.
-    #[inline(always)]
-    pub const fn new_raw(numer: T, denom: T) -> Ratio<T> {
-        Ratio { numer, denom }
-    }
-
-    /// Gets an immutable reference to the numerator.
-    #[inline(always)]
-    pub const fn numer(&self) -> &T {
-        &self.numer
-    }
-
-    /// Gets an immutable reference to the denominator.
-    #[inline(always)]
-    pub const fn denom(&self) -> &T {
-        &self.denom
-    }
-}
-
-impl<T: CheckedDiv> Ratio<T> {
-    /// Converts to an integer, rounding towards zero.
-    #[inline(always)]
-    pub fn to_integer(&self) -> T {
-        unwrap!(self.numer().checked_div(self.denom()))
-    }
-}
-
-impl<T: CheckedMul> Div<T> for Ratio<T> {
-    type Output = Self;
-
-    #[inline(always)]
-    fn div(mut self, rhs: T) -> Self::Output {
-        self.denom = unwrap!(self.denom().checked_mul(&rhs));
-        self
-    }
-}
-
-impl<T: CheckedMul> Mul<T> for Ratio<T> {
-    type Output = Self;
-
-    #[inline(always)]
-    fn mul(mut self, rhs: T) -> Self::Output {
-        self.numer = unwrap!(self.numer().checked_mul(&rhs));
-        self
-    }
-}
-
-impl<T: CheckedMul + CheckedAdd> Add<T> for Ratio<T> {
-    type Output = Self;
-
-    #[inline(always)]
-    fn add(mut self, rhs: T) -> Self::Output {
-        self.numer = unwrap!(unwrap!(self.denom().checked_mul(&rhs)).checked_add(self.numer()));
-        self
-    }
-}
-
-macro_rules! impl_from_for_float {
-    ($from:ident) => {
-        impl From<Ratio<$from>> for f32 {
-            #[inline(always)]
-            fn from(r: Ratio<$from>) -> Self {
-                (r.numer as f32) / (r.denom as f32)
-            }
-        }
-
-        impl From<Ratio<$from>> for f64 {
-            #[inline(always)]
-            fn from(r: Ratio<$from>) -> Self {
-                (r.numer as f64) / (r.denom as f64)
-            }
-        }
-    };
-}
-
-impl_from_for_float!(u8);
-impl_from_for_float!(u16);
-impl_from_for_float!(u32);
-impl_from_for_float!(u64);
-impl_from_for_float!(u128);
-impl_from_for_float!(i8);
-impl_from_for_float!(i16);
-impl_from_for_float!(i32);
-impl_from_for_float!(i64);
-impl_from_for_float!(i128);
-
-impl<T: core::fmt::Display> core::fmt::Display for Ratio<T> {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        core::write!(f, "{} / {}", self.numer(), self.denom())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Ratio;
-
-    #[test]
-    fn basics() {
-        let mut r = Ratio::new_raw(1, 2) + 2;
-        assert_eq!(*r.numer(), 5);
-        assert_eq!(*r.denom(), 2);
-        assert_eq!(r.to_integer(), 2);
-
-        r = r * 2;
-        assert_eq!(*r.numer(), 10);
-        assert_eq!(*r.denom(), 2);
-        assert_eq!(r.to_integer(), 5);
-
-        r = r / 2;
-        assert_eq!(*r.numer(), 10);
-        assert_eq!(*r.denom(), 4);
-        assert_eq!(r.to_integer(), 2);
-    }
-}
diff --git a/embassy-hal-common/src/ring_buffer.rs b/embassy-hal-common/src/ring_buffer.rs
deleted file mode 100644
index fcad68bb1..000000000
--- a/embassy-hal-common/src/ring_buffer.rs
+++ /dev/null
@@ -1,136 +0,0 @@
-pub struct RingBuffer<'a> {
-    buf: &'a mut [u8],
-    start: usize,
-    end: usize,
-    empty: bool,
-}
-
-impl<'a> RingBuffer<'a> {
-    pub fn new(buf: &'a mut [u8]) -> Self {
-        Self {
-            buf,
-            start: 0,
-            end: 0,
-            empty: true,
-        }
-    }
-
-    pub fn push_buf(&mut self) -> &mut [u8] {
-        if self.start == self.end && !self.empty {
-            trace!("  ringbuf: push_buf empty");
-            return &mut self.buf[..0];
-        }
-
-        let n = if self.start <= self.end {
-            self.buf.len() - self.end
-        } else {
-            self.start - self.end
-        };
-
-        trace!("  ringbuf: push_buf {:?}..{:?}", self.end, self.end + n);
-        &mut self.buf[self.end..self.end + n]
-    }
-
-    pub fn push(&mut self, n: usize) {
-        trace!("  ringbuf: push {:?}", n);
-        if n == 0 {
-            return;
-        }
-
-        self.end = self.wrap(self.end + n);
-        self.empty = false;
-    }
-
-    pub fn pop_buf(&mut self) -> &mut [u8] {
-        if self.empty {
-            trace!("  ringbuf: pop_buf empty");
-            return &mut self.buf[..0];
-        }
-
-        let n = if self.end <= self.start {
-            self.buf.len() - self.start
-        } else {
-            self.end - self.start
-        };
-
-        trace!("  ringbuf: pop_buf {:?}..{:?}", self.start, self.start + n);
-        &mut self.buf[self.start..self.start + n]
-    }
-
-    pub fn pop(&mut self, n: usize) {
-        trace!("  ringbuf: pop {:?}", n);
-        if n == 0 {
-            return;
-        }
-
-        self.start = self.wrap(self.start + n);
-        self.empty = self.start == self.end;
-    }
-
-    pub fn is_full(&self) -> bool {
-        self.start == self.end && !self.empty
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.empty
-    }
-
-    pub fn clear(&mut self) {
-        self.start = 0;
-        self.end = 0;
-        self.empty = true;
-    }
-
-    fn wrap(&self, n: usize) -> usize {
-        assert!(n <= self.buf.len());
-        if n == self.buf.len() {
-            0
-        } else {
-            n
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn push_pop() {
-        let mut b = [0; 4];
-        let mut rb = RingBuffer::new(&mut b);
-        let buf = rb.push_buf();
-        assert_eq!(4, buf.len());
-        buf[0] = 1;
-        buf[1] = 2;
-        buf[2] = 3;
-        buf[3] = 4;
-        rb.push(4);
-
-        let buf = rb.pop_buf();
-        assert_eq!(4, buf.len());
-        assert_eq!(1, buf[0]);
-        rb.pop(1);
-
-        let buf = rb.pop_buf();
-        assert_eq!(3, buf.len());
-        assert_eq!(2, buf[0]);
-        rb.pop(1);
-
-        let buf = rb.pop_buf();
-        assert_eq!(2, buf.len());
-        assert_eq!(3, buf[0]);
-        rb.pop(1);
-
-        let buf = rb.pop_buf();
-        assert_eq!(1, buf.len());
-        assert_eq!(4, buf[0]);
-        rb.pop(1);
-
-        let buf = rb.pop_buf();
-        assert_eq!(0, buf.len());
-
-        let buf = rb.push_buf();
-        assert_eq!(4, buf.len());
-    }
-}
diff --git a/embassy-hal-internal/Cargo.toml b/embassy-hal-internal/Cargo.toml
new file mode 100644
index 000000000..42e03199c
--- /dev/null
+++ b/embassy-hal-internal/Cargo.toml
@@ -0,0 +1,29 @@
+[package]
+name = "embassy-hal-internal"
+version = "0.1.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+
+[features]
+
+# Define the number of NVIC priority bits.
+prio-bits-0 = []
+prio-bits-1 = []
+prio-bits-2 = []
+prio-bits-3 = []
+prio-bits-4 = []
+prio-bits-5 = []
+prio-bits-6 = []
+prio-bits-7 = []
+prio-bits-8 = []
+
+cortex-m = ["dep:cortex-m", "dep:critical-section"]
+
+[dependencies]
+defmt = { version = "0.3", optional = true }
+log = { version = "0.4.14", optional = true }
+
+num-traits = { version = "0.2.14", default-features = false }
+
+cortex-m = { version = "0.7.6", optional = true }
+critical-section = { version = "1", optional = true }
\ No newline at end of file
diff --git a/embassy-hal-internal/README.md b/embassy-hal-internal/README.md
new file mode 100644
index 000000000..d6539701b
--- /dev/null
+++ b/embassy-hal-internal/README.md
@@ -0,0 +1,16 @@
+# embassy-macros
+
+An [Embassy](https://embassy.dev) project.
+
+Internal implementation details for Embassy HALs. DO NOT USE DIRECTLY. Embassy HALs (`embassy-nrf`, `embassy-stm32`, `embassy-rp`) already reexport
+everything you need to use them effectively.
+
+## License
+
+This work is licensed under either of
+
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or
+  <http://www.apache.org/licenses/LICENSE-2.0>)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)
+
+at your option.
diff --git a/embassy-hal-internal/build.rs b/embassy-hal-internal/build.rs
new file mode 100644
index 000000000..6fe82b44f
--- /dev/null
+++ b/embassy-hal-internal/build.rs
@@ -0,0 +1,29 @@
+use std::env;
+
+fn main() {
+    let target = env::var("TARGET").unwrap();
+
+    if target.starts_with("thumbv6m-") {
+        println!("cargo:rustc-cfg=cortex_m");
+        println!("cargo:rustc-cfg=armv6m");
+    } else if target.starts_with("thumbv7m-") {
+        println!("cargo:rustc-cfg=cortex_m");
+        println!("cargo:rustc-cfg=armv7m");
+    } else if target.starts_with("thumbv7em-") {
+        println!("cargo:rustc-cfg=cortex_m");
+        println!("cargo:rustc-cfg=armv7m");
+        println!("cargo:rustc-cfg=armv7em"); // (not currently used)
+    } else if target.starts_with("thumbv8m.base") {
+        println!("cargo:rustc-cfg=cortex_m");
+        println!("cargo:rustc-cfg=armv8m");
+        println!("cargo:rustc-cfg=armv8m_base");
+    } else if target.starts_with("thumbv8m.main") {
+        println!("cargo:rustc-cfg=cortex_m");
+        println!("cargo:rustc-cfg=armv8m");
+        println!("cargo:rustc-cfg=armv8m_main");
+    }
+
+    if target.ends_with("-eabihf") {
+        println!("cargo:rustc-cfg=has_fpu");
+    }
+}
diff --git a/embassy-hal-internal/src/atomic_ring_buffer.rs b/embassy-hal-internal/src/atomic_ring_buffer.rs
new file mode 100644
index 000000000..ea84925c4
--- /dev/null
+++ b/embassy-hal-internal/src/atomic_ring_buffer.rs
@@ -0,0 +1,556 @@
+use core::slice;
+use core::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
+
+/// Atomic reusable ringbuffer
+///
+/// This ringbuffer implementation is designed to be stored in a `static`,
+/// therefore all methods take `&self` and not `&mut self`.
+///
+/// It is "reusable": when created it has no backing buffer, you can give it
+/// one with `init` and take it back with `deinit`, and init it again in the
+/// future if needed. This is very non-idiomatic, but helps a lot when storing
+/// it in a `static`.
+///
+/// One concurrent writer and one concurrent reader are supported, even at
+/// different execution priorities (like main and irq).
+pub struct RingBuffer {
+    pub buf: AtomicPtr<u8>,
+    pub len: AtomicUsize,
+
+    // start and end wrap at len*2, not at len.
+    // This allows distinguishing "full" and "empty".
+    // full is when start+len == end (modulo len*2)
+    // empty is when start == end
+    //
+    // This avoids having to consider the ringbuffer "full" at len-1 instead of len.
+    // The usual solution is adding a "full" flag, but that can't be made atomic
+    pub start: AtomicUsize,
+    pub end: AtomicUsize,
+}
+
+pub struct Reader<'a>(&'a RingBuffer);
+pub struct Writer<'a>(&'a RingBuffer);
+
+impl RingBuffer {
+    /// Create a new empty ringbuffer.
+    pub const fn new() -> Self {
+        Self {
+            buf: AtomicPtr::new(core::ptr::null_mut()),
+            len: AtomicUsize::new(0),
+            start: AtomicUsize::new(0),
+            end: AtomicUsize::new(0),
+        }
+    }
+
+    /// Initialize the ring buffer with a buffer.
+    ///
+    /// # Safety
+    /// - The buffer (`buf .. buf+len`) must be valid memory until `deinit` is called.
+    /// - Must not be called concurrently with any other methods.
+    pub unsafe fn init(&self, buf: *mut u8, len: usize) {
+        // Ordering: it's OK to use `Relaxed` because this is not called
+        // concurrently with other methods.
+        self.buf.store(buf, Ordering::Relaxed);
+        self.len.store(len, Ordering::Relaxed);
+        self.start.store(0, Ordering::Relaxed);
+        self.end.store(0, Ordering::Relaxed);
+    }
+
+    /// Deinitialize the ringbuffer.
+    ///
+    /// After calling this, the ringbuffer becomes empty, as if it was
+    /// just created with `new()`.
+    ///
+    /// # Safety
+    /// - Must not be called concurrently with any other methods.
+    pub unsafe fn deinit(&self) {
+        // Ordering: it's OK to use `Relaxed` because this is not called
+        // concurrently with other methods.
+        self.len.store(0, Ordering::Relaxed);
+        self.start.store(0, Ordering::Relaxed);
+        self.end.store(0, Ordering::Relaxed);
+    }
+
+    /// Create a reader.
+    ///
+    /// # Safety
+    ///
+    /// Only one reader can exist at a time.
+    pub unsafe fn reader(&self) -> Reader<'_> {
+        Reader(self)
+    }
+
+    /// Create a writer.
+    ///
+    /// # Safety
+    ///
+    /// Only one writer can exist at a time.
+    pub unsafe fn writer(&self) -> Writer<'_> {
+        Writer(self)
+    }
+
+    pub fn len(&self) -> usize {
+        self.len.load(Ordering::Relaxed)
+    }
+
+    pub fn is_full(&self) -> bool {
+        let len = self.len.load(Ordering::Relaxed);
+        let start = self.start.load(Ordering::Relaxed);
+        let end = self.end.load(Ordering::Relaxed);
+
+        self.wrap(start + len) == end
+    }
+
+    pub fn is_empty(&self) -> bool {
+        let start = self.start.load(Ordering::Relaxed);
+        let end = self.end.load(Ordering::Relaxed);
+
+        start == end
+    }
+
+    fn wrap(&self, mut n: usize) -> usize {
+        let len = self.len.load(Ordering::Relaxed);
+
+        if n >= len * 2 {
+            n -= len * 2
+        }
+        n
+    }
+}
+
+impl<'a> Writer<'a> {
+    /// Push data into the buffer in-place.
+    ///
+    /// The closure `f` is called with a free part of the buffer, it must write
+    /// some data to it and return the amount of bytes written.
+    pub fn push(&mut self, f: impl FnOnce(&mut [u8]) -> usize) -> usize {
+        let (p, n) = self.push_buf();
+        let buf = unsafe { slice::from_raw_parts_mut(p, n) };
+        let n = f(buf);
+        self.push_done(n);
+        n
+    }
+
+    /// Push one data byte.
+    ///
+    /// Returns true if pushed successfully.
+    pub fn push_one(&mut self, val: u8) -> bool {
+        let n = self.push(|f| match f {
+            [] => 0,
+            [x, ..] => {
+                *x = val;
+                1
+            }
+        });
+        n != 0
+    }
+
+    /// Get a buffer where data can be pushed to.
+    ///
+    /// Equivalent to [`Self::push_buf`] but returns a slice.
+    pub fn push_slice(&mut self) -> &mut [u8] {
+        let (data, len) = self.push_buf();
+        unsafe { slice::from_raw_parts_mut(data, len) }
+    }
+
+    /// Get up to two buffers where data can be pushed to.
+    ///
+    /// Equivalent to [`Self::push_bufs`] but returns slices.
+    pub fn push_slices(&mut self) -> [&mut [u8]; 2] {
+        let [(d0, l0), (d1, l1)] = self.push_bufs();
+        unsafe { [slice::from_raw_parts_mut(d0, l0), slice::from_raw_parts_mut(d1, l1)] }
+    }
+
+    /// Get a buffer where data can be pushed to.
+    ///
+    /// Write data to the start of the buffer, then call `push_done` with
+    /// however many bytes you've pushed.
+    ///
+    /// The buffer is suitable to DMA to.
+    ///
+    /// If the ringbuf is full, size=0 will be returned.
+    ///
+    /// The buffer stays valid as long as no other `Writer` method is called
+    /// and `init`/`deinit` aren't called on the ringbuf.
+    pub fn push_buf(&mut self) -> (*mut u8, usize) {
+        // Ordering: popping writes `start` last, so we read `start` first.
+        // Read it with Acquire ordering, so that the next accesses can't be reordered up past it.
+        let mut start = self.0.start.load(Ordering::Acquire);
+        let buf = self.0.buf.load(Ordering::Relaxed);
+        let len = self.0.len.load(Ordering::Relaxed);
+        let mut end = self.0.end.load(Ordering::Relaxed);
+
+        let empty = start == end;
+
+        if start >= len {
+            start -= len
+        }
+        if end >= len {
+            end -= len
+        }
+
+        if start == end && !empty {
+            // full
+            return (buf, 0);
+        }
+        let n = if start > end { start - end } else { len - end };
+
+        trace!("  ringbuf: push_buf {:?}..{:?}", end, end + n);
+        (unsafe { buf.add(end) }, n)
+    }
+
+    /// Get up to two buffers where data can be pushed to.
+    ///
+    /// Write data starting at the beginning of the first buffer, then call
+    /// `push_done` with however many bytes you've pushed.
+    ///
+    /// The buffers are suitable to DMA to.
+    ///
+    /// If the ringbuf is full, both buffers will be zero length.
+    /// If there is only area available, the second buffer will be zero length.
+    ///
+    /// The buffer stays valid as long as no other `Writer` method is called
+    /// and `init`/`deinit` aren't called on the ringbuf.
+    pub fn push_bufs(&mut self) -> [(*mut u8, usize); 2] {
+        // Ordering: as per push_buf()
+        let mut start = self.0.start.load(Ordering::Acquire);
+        let buf = self.0.buf.load(Ordering::Relaxed);
+        let len = self.0.len.load(Ordering::Relaxed);
+        let mut end = self.0.end.load(Ordering::Relaxed);
+
+        let empty = start == end;
+
+        if start >= len {
+            start -= len
+        }
+        if end >= len {
+            end -= len
+        }
+
+        if start == end && !empty {
+            // full
+            return [(buf, 0), (buf, 0)];
+        }
+        let n0 = if start > end { start - end } else { len - end };
+        let n1 = if start <= end { start } else { 0 };
+
+        trace!("  ringbuf: push_bufs [{:?}..{:?}, {:?}..{:?}]", end, end + n0, 0, n1);
+        [(unsafe { buf.add(end) }, n0), (buf, n1)]
+    }
+
+    pub fn push_done(&mut self, n: usize) {
+        trace!("  ringbuf: push {:?}", n);
+        let end = self.0.end.load(Ordering::Relaxed);
+
+        // Ordering: write `end` last, with Release ordering.
+        // The ordering ensures no preceding memory accesses (such as writing
+        // the actual data in the buffer) can be reordered down past it, which
+        // will guarantee the reader sees them after reading from `end`.
+        self.0.end.store(self.0.wrap(end + n), Ordering::Release);
+    }
+}
+
+impl<'a> Reader<'a> {
+    /// Pop data from the buffer in-place.
+    ///
+    /// The closure `f` is called with the next data, it must process
+    /// some data from it and return the amount of bytes processed.
+    pub fn pop(&mut self, f: impl FnOnce(&[u8]) -> usize) -> usize {
+        let (p, n) = self.pop_buf();
+        let buf = unsafe { slice::from_raw_parts(p, n) };
+        let n = f(buf);
+        self.pop_done(n);
+        n
+    }
+
+    /// Pop one data byte.
+    ///
+    /// Returns true if popped successfully.
+    pub fn pop_one(&mut self) -> Option<u8> {
+        let mut res = None;
+        self.pop(|f| match f {
+            &[] => 0,
+            &[x, ..] => {
+                res = Some(x);
+                1
+            }
+        });
+        res
+    }
+
+    /// Get a buffer where data can be popped from.
+    ///
+    /// Equivalent to [`Self::pop_buf`] but returns a slice.
+    pub fn pop_slice(&mut self) -> &mut [u8] {
+        let (data, len) = self.pop_buf();
+        unsafe { slice::from_raw_parts_mut(data, len) }
+    }
+
+    /// Get a buffer where data can be popped from.
+    ///
+    /// Read data from the start of the buffer, then call `pop_done` with
+    /// however many bytes you've processed.
+    ///
+    /// The buffer is suitable to DMA from.
+    ///
+    /// If the ringbuf is empty, size=0 will be returned.
+    ///
+    /// The buffer stays valid as long as no other `Reader` method is called
+    /// and `init`/`deinit` aren't called on the ringbuf.
+    pub fn pop_buf(&mut self) -> (*mut u8, usize) {
+        // Ordering: pushing writes `end` last, so we read `end` first.
+        // Read it with Acquire ordering, so that the next accesses can't be reordered up past it.
+        // This is needed to guarantee we "see" the data written by the writer.
+        let mut end = self.0.end.load(Ordering::Acquire);
+        let buf = self.0.buf.load(Ordering::Relaxed);
+        let len = self.0.len.load(Ordering::Relaxed);
+        let mut start = self.0.start.load(Ordering::Relaxed);
+
+        if start == end {
+            return (buf, 0);
+        }
+
+        if start >= len {
+            start -= len
+        }
+        if end >= len {
+            end -= len
+        }
+
+        let n = if end > start { end - start } else { len - start };
+
+        trace!("  ringbuf: pop_buf {:?}..{:?}", start, start + n);
+        (unsafe { buf.add(start) }, n)
+    }
+
+    pub fn pop_done(&mut self, n: usize) {
+        trace!("  ringbuf: pop {:?}", n);
+
+        let start = self.0.start.load(Ordering::Relaxed);
+
+        // Ordering: write `start` last, with Release ordering.
+        // The ordering ensures no preceding memory accesses (such as reading
+        // the actual data) can be reordered down past it. This is necessary
+        // because writing to `start` is effectively freeing the read part of the
+        // buffer, which "gives permission" to the writer to write to it again.
+        // Therefore, all buffer accesses must be completed before this.
+        self.0.start.store(self.0.wrap(start + n), Ordering::Release);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn push_pop() {
+        let mut b = [0; 4];
+        let rb = RingBuffer::new();
+        unsafe {
+            rb.init(b.as_mut_ptr(), 4);
+
+            assert_eq!(rb.is_empty(), true);
+            assert_eq!(rb.is_full(), false);
+
+            rb.writer().push(|buf| {
+                assert_eq!(4, buf.len());
+                buf[0] = 1;
+                buf[1] = 2;
+                buf[2] = 3;
+                buf[3] = 4;
+                4
+            });
+
+            assert_eq!(rb.is_empty(), false);
+            assert_eq!(rb.is_full(), true);
+
+            rb.writer().push(|buf| {
+                // If it's full, we can push 0 bytes.
+                assert_eq!(0, buf.len());
+                0
+            });
+
+            assert_eq!(rb.is_empty(), false);
+            assert_eq!(rb.is_full(), true);
+
+            rb.reader().pop(|buf| {
+                assert_eq!(4, buf.len());
+                assert_eq!(1, buf[0]);
+                1
+            });
+
+            assert_eq!(rb.is_empty(), false);
+            assert_eq!(rb.is_full(), false);
+
+            rb.reader().pop(|buf| {
+                assert_eq!(3, buf.len());
+                0
+            });
+
+            assert_eq!(rb.is_empty(), false);
+            assert_eq!(rb.is_full(), false);
+
+            rb.reader().pop(|buf| {
+                assert_eq!(3, buf.len());
+                assert_eq!(2, buf[0]);
+                assert_eq!(3, buf[1]);
+                2
+            });
+            rb.reader().pop(|buf| {
+                assert_eq!(1, buf.len());
+                assert_eq!(4, buf[0]);
+                1
+            });
+
+            assert_eq!(rb.is_empty(), true);
+            assert_eq!(rb.is_full(), false);
+
+            rb.reader().pop(|buf| {
+                assert_eq!(0, buf.len());
+                0
+            });
+
+            rb.writer().push(|buf| {
+                assert_eq!(4, buf.len());
+                buf[0] = 10;
+                1
+            });
+
+            rb.writer().push(|buf| {
+                assert_eq!(3, buf.len());
+                buf[0] = 11;
+                buf[1] = 12;
+                2
+            });
+
+            assert_eq!(rb.is_empty(), false);
+            assert_eq!(rb.is_full(), false);
+
+            rb.writer().push(|buf| {
+                assert_eq!(1, buf.len());
+                buf[0] = 13;
+                1
+            });
+
+            assert_eq!(rb.is_empty(), false);
+            assert_eq!(rb.is_full(), true);
+        }
+    }
+
+    #[test]
+    fn zero_len() {
+        let rb = RingBuffer::new();
+        unsafe {
+            assert_eq!(rb.is_empty(), true);
+            assert_eq!(rb.is_full(), true);
+
+            rb.writer().push(|buf| {
+                assert_eq!(0, buf.len());
+                0
+            });
+
+            rb.reader().pop(|buf| {
+                assert_eq!(0, buf.len());
+                0
+            });
+        }
+    }
+
+    #[test]
+    fn push_slices() {
+        let mut b = [0; 4];
+        let rb = RingBuffer::new();
+        unsafe {
+            rb.init(b.as_mut_ptr(), 4);
+
+            /* push 3 -> [1 2 3 x] */
+            let mut w = rb.writer();
+            let ps = w.push_slices();
+            assert_eq!(4, ps[0].len());
+            assert_eq!(0, ps[1].len());
+            ps[0][0] = 1;
+            ps[0][1] = 2;
+            ps[0][2] = 3;
+            w.push_done(3);
+            drop(w);
+
+            /* pop 2 -> [x x 3 x] */
+            rb.reader().pop(|buf| {
+                assert_eq!(3, buf.len());
+                assert_eq!(1, buf[0]);
+                assert_eq!(2, buf[1]);
+                assert_eq!(3, buf[2]);
+                2
+            });
+
+            /* push 3 -> [5 6 3 4] */
+            let mut w = rb.writer();
+            let ps = w.push_slices();
+            assert_eq!(1, ps[0].len());
+            assert_eq!(2, ps[1].len());
+            ps[0][0] = 4;
+            ps[1][0] = 5;
+            ps[1][1] = 6;
+            w.push_done(3);
+            drop(w);
+
+            /* buf is now full */
+            let mut w = rb.writer();
+            let ps = w.push_slices();
+            assert_eq!(0, ps[0].len());
+            assert_eq!(0, ps[1].len());
+
+            /* pop 2 -> [5 6 x x] */
+            rb.reader().pop(|buf| {
+                assert_eq!(2, buf.len());
+                assert_eq!(3, buf[0]);
+                assert_eq!(4, buf[1]);
+                2
+            });
+
+            /* should now have one push slice again */
+            let mut w = rb.writer();
+            let ps = w.push_slices();
+            assert_eq!(2, ps[0].len());
+            assert_eq!(0, ps[1].len());
+            drop(w);
+
+            /* pop 2 -> [x x x x] */
+            rb.reader().pop(|buf| {
+                assert_eq!(2, buf.len());
+                assert_eq!(5, buf[0]);
+                assert_eq!(6, buf[1]);
+                2
+            });
+
+            /* should now have two push slices */
+            let mut w = rb.writer();
+            let ps = w.push_slices();
+            assert_eq!(2, ps[0].len());
+            assert_eq!(2, ps[1].len());
+            drop(w);
+
+            /* make sure we exercise all wrap around cases properly */
+            for _ in 0..10 {
+                /* should be empty, push 1 */
+                let mut w = rb.writer();
+                let ps = w.push_slices();
+                assert_eq!(4, ps[0].len() + ps[1].len());
+                w.push_done(1);
+                drop(w);
+
+                /* should have 1 element */
+                let mut w = rb.writer();
+                let ps = w.push_slices();
+                assert_eq!(3, ps[0].len() + ps[1].len());
+                drop(w);
+
+                /* pop 1 */
+                rb.reader().pop(|buf| {
+                    assert_eq!(1, buf.len());
+                    1
+                });
+            }
+        }
+    }
+}
diff --git a/embassy-hal-internal/src/drop.rs b/embassy-hal-internal/src/drop.rs
new file mode 100644
index 000000000..7cd16aaec
--- /dev/null
+++ b/embassy-hal-internal/src/drop.rs
@@ -0,0 +1,51 @@
+use core::mem;
+use core::mem::MaybeUninit;
+
+#[must_use = "to delay the drop handler invokation to the end of the scope"]
+pub struct OnDrop<F: FnOnce()> {
+    f: MaybeUninit<F>,
+}
+
+impl<F: FnOnce()> OnDrop<F> {
+    pub fn new(f: F) -> Self {
+        Self { f: MaybeUninit::new(f) }
+    }
+
+    pub fn defuse(self) {
+        mem::forget(self)
+    }
+}
+
+impl<F: FnOnce()> Drop for OnDrop<F> {
+    fn drop(&mut self) {
+        unsafe { self.f.as_ptr().read()() }
+    }
+}
+
+/// An explosive ordinance that panics if it is improperly disposed of.
+///
+/// This is to forbid dropping futures, when there is absolutely no other choice.
+///
+/// To correctly dispose of this device, call the [defuse](struct.DropBomb.html#method.defuse)
+/// method before this object is dropped.
+#[must_use = "to delay the drop bomb invokation to the end of the scope"]
+pub struct DropBomb {
+    _private: (),
+}
+
+impl DropBomb {
+    pub fn new() -> Self {
+        Self { _private: () }
+    }
+
+    /// Defuses the bomb, rendering it safe to drop.
+    pub fn defuse(self) {
+        mem::forget(self)
+    }
+}
+
+impl Drop for DropBomb {
+    fn drop(&mut self) {
+        panic!("boom")
+    }
+}
diff --git a/embassy-hal-internal/src/fmt.rs b/embassy-hal-internal/src/fmt.rs
new file mode 100644
index 000000000..066970813
--- /dev/null
+++ b/embassy-hal-internal/src/fmt.rs
@@ -0,0 +1,225 @@
+#![macro_use]
+#![allow(unused_macros)]
+
+#[cfg(all(feature = "defmt", feature = "log"))]
+compile_error!("You may not enable both `defmt` and `log` features.");
+
+macro_rules! assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::debug_assert!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::debug_assert!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_eq {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::debug_assert_eq!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::debug_assert_eq!($($x)*);
+        }
+    };
+}
+
+macro_rules! debug_assert_ne {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::debug_assert_ne!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::debug_assert_ne!($($x)*);
+        }
+    };
+}
+
+macro_rules! todo {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::todo!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::todo!($($x)*);
+        }
+    };
+}
+
+macro_rules! unreachable {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::unreachable!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::unreachable!($($x)*);
+        }
+    };
+}
+
+macro_rules! panic {
+    ($($x:tt)*) => {
+        {
+            #[cfg(not(feature = "defmt"))]
+            ::core::panic!($($x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::panic!($($x)*);
+        }
+    };
+}
+
+macro_rules! trace {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::trace!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::trace!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+macro_rules! debug {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::debug!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::debug!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+macro_rules! info {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::info!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::info!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+macro_rules! warn {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::warn!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::warn!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+macro_rules! error {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            #[cfg(feature = "log")]
+            ::log::error!($s $(, $x)*);
+            #[cfg(feature = "defmt")]
+            ::defmt::error!($s $(, $x)*);
+            #[cfg(not(any(feature = "log", feature="defmt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+#[cfg(feature = "defmt")]
+macro_rules! unwrap {
+    ($($x:tt)*) => {
+        ::defmt::unwrap!($($x)*)
+    };
+}
+
+#[cfg(not(feature = "defmt"))]
+macro_rules! unwrap {
+    ($arg:expr) => {
+        match $crate::fmt::Try::into_result($arg) {
+            ::core::result::Result::Ok(t) => t,
+            ::core::result::Result::Err(e) => {
+                ::core::panic!("unwrap of `{}` failed: {:?}", ::core::stringify!($arg), e);
+            }
+        }
+    };
+    ($arg:expr, $($msg:expr),+ $(,)? ) => {
+        match $crate::fmt::Try::into_result($arg) {
+            ::core::result::Result::Ok(t) => t,
+            ::core::result::Result::Err(e) => {
+                ::core::panic!("unwrap of `{}` failed: {}: {:?}", ::core::stringify!($arg), ::core::format_args!($($msg,)*), e);
+            }
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub struct NoneError;
+
+pub trait Try {
+    type Ok;
+    type Error;
+    fn into_result(self) -> Result<Self::Ok, Self::Error>;
+}
+
+impl<T> Try for Option<T> {
+    type Ok = T;
+    type Error = NoneError;
+
+    #[inline]
+    fn into_result(self) -> Result<T, NoneError> {
+        self.ok_or(NoneError)
+    }
+}
+
+impl<T, E> Try for Result<T, E> {
+    type Ok = T;
+    type Error = E;
+
+    #[inline]
+    fn into_result(self) -> Self {
+        self
+    }
+}
diff --git a/embassy-hal-internal/src/interrupt.rs b/embassy-hal-internal/src/interrupt.rs
new file mode 100644
index 000000000..b970aa2cd
--- /dev/null
+++ b/embassy-hal-internal/src/interrupt.rs
@@ -0,0 +1,846 @@
+//! Interrupt handling for cortex-m devices.
+use core::mem;
+use core::sync::atomic::{compiler_fence, Ordering};
+
+use cortex_m::interrupt::InterruptNumber;
+use cortex_m::peripheral::NVIC;
+
+/// Generate a standard `mod interrupt` for a HAL.
+#[macro_export]
+macro_rules! interrupt_mod {
+    ($($irqs:ident),* $(,)?) => {
+        #[cfg(feature = "rt")]
+        pub use cortex_m_rt::interrupt;
+
+        /// Interrupt definitions.
+        pub mod interrupt {
+            pub use $crate::interrupt::{InterruptExt, Priority};
+            pub use crate::pac::Interrupt::*;
+            pub use crate::pac::Interrupt;
+
+            /// Type-level interrupt infrastructure.
+            ///
+            /// This module contains one *type* per interrupt. This is used for checking at compile time that
+            /// the interrupts are correctly bound to HAL drivers.
+            ///
+            /// As an end user, you shouldn't need to use this module directly. Use the [`crate::bind_interrupts!`] macro
+            /// to bind interrupts, and the [`crate::interrupt`] module to manually register interrupt handlers and manipulate
+            /// interrupts directly (pending/unpending, enabling/disabling, setting the priority, etc...)
+            pub mod typelevel {
+                use super::InterruptExt;
+
+                mod sealed {
+                    pub trait Interrupt {}
+                }
+
+                /// Type-level interrupt.
+                ///
+                /// This trait is implemented for all typelevel interrupt types in this module.
+                pub trait Interrupt: sealed::Interrupt {
+
+                    /// Interrupt enum variant.
+                    ///
+                    /// This allows going from typelevel interrupts (one type per interrupt) to
+                    /// non-typelevel interrupts (a single `Interrupt` enum type, with one variant per interrupt).
+                    const IRQ: super::Interrupt;
+
+                    /// Enable the interrupt.
+                    #[inline]
+                    unsafe fn enable() {
+                        Self::IRQ.enable()
+                    }
+
+                    /// Disable the interrupt.
+                    #[inline]
+                    fn disable() {
+                        Self::IRQ.disable()
+                    }
+
+                    /// Check if interrupt is enabled.
+                    #[inline]
+                    fn is_enabled() -> bool {
+                        Self::IRQ.is_enabled()
+                    }
+
+                    /// Check if interrupt is pending.
+                    #[inline]
+                    fn is_pending() -> bool {
+                        Self::IRQ.is_pending()
+                    }
+
+                    /// Set interrupt pending.
+                    #[inline]
+                    fn pend() {
+                        Self::IRQ.pend()
+                    }
+
+                    /// Unset interrupt pending.
+                    #[inline]
+                    fn unpend() {
+                        Self::IRQ.unpend()
+                    }
+
+                    /// Get the priority of the interrupt.
+                    #[inline]
+                    fn get_priority() -> crate::interrupt::Priority {
+                        Self::IRQ.get_priority()
+                    }
+
+                    /// Set the interrupt priority.
+                    #[inline]
+                    fn set_priority(prio: crate::interrupt::Priority) {
+                        Self::IRQ.set_priority(prio)
+                    }
+                }
+
+                $(
+                    #[allow(non_camel_case_types)]
+                    #[doc=stringify!($irqs)]
+                    #[doc=" typelevel interrupt."]
+                    pub enum $irqs {}
+                    impl sealed::Interrupt for $irqs{}
+                    impl Interrupt for $irqs {
+                        const IRQ: super::Interrupt = super::Interrupt::$irqs;
+                    }
+                )*
+
+                /// Interrupt handler trait.
+                ///
+                /// Drivers that need to handle interrupts implement this trait.
+                /// The user must ensure `on_interrupt()` is called every time the interrupt fires.
+                /// Drivers must use use [`Binding`] to assert at compile time that the user has done so.
+                pub trait Handler<I: Interrupt> {
+                    /// Interrupt handler function.
+                    ///
+                    /// Must be called every time the `I` interrupt fires, synchronously from
+                    /// the interrupt handler context.
+                    ///
+                    /// # Safety
+                    ///
+                    /// This function must ONLY be called from the interrupt handler for `I`.
+                    unsafe fn on_interrupt();
+                }
+
+                /// Compile-time assertion that an interrupt has been bound to a handler.
+                ///
+                /// For the vast majority of cases, you should use the `bind_interrupts!`
+                /// macro instead of writing `unsafe impl`s of this trait.
+                ///
+                /// # Safety
+                ///
+                /// By implementing this trait, you are asserting that you have arranged for `H::on_interrupt()`
+                /// to be called every time the `I` interrupt fires.
+                ///
+                /// This allows drivers to check bindings at compile-time.
+                pub unsafe trait Binding<I: Interrupt, H: Handler<I>> {}
+            }
+        }
+    };
+}
+
+/// Represents an interrupt type that can be configured by embassy to handle
+/// interrupts.
+pub unsafe trait InterruptExt: InterruptNumber + Copy {
+    /// Enable the interrupt.
+    #[inline]
+    unsafe fn enable(self) {
+        compiler_fence(Ordering::SeqCst);
+        NVIC::unmask(self)
+    }
+
+    /// Disable the interrupt.
+    #[inline]
+    fn disable(self) {
+        NVIC::mask(self);
+        compiler_fence(Ordering::SeqCst);
+    }
+
+    /// Check if interrupt is being handled.
+    #[inline]
+    #[cfg(not(armv6m))]
+    fn is_active(self) -> bool {
+        NVIC::is_active(self)
+    }
+
+    /// Check if interrupt is enabled.
+    #[inline]
+    fn is_enabled(self) -> bool {
+        NVIC::is_enabled(self)
+    }
+
+    /// Check if interrupt is pending.
+    #[inline]
+    fn is_pending(self) -> bool {
+        NVIC::is_pending(self)
+    }
+
+    /// Set interrupt pending.
+    #[inline]
+    fn pend(self) {
+        NVIC::pend(self)
+    }
+
+    /// Unset interrupt pending.
+    #[inline]
+    fn unpend(self) {
+        NVIC::unpend(self)
+    }
+
+    /// Get the priority of the interrupt.
+    #[inline]
+    fn get_priority(self) -> Priority {
+        Priority::from(NVIC::get_priority(self))
+    }
+
+    /// Set the interrupt priority.
+    #[inline]
+    fn set_priority(self, prio: Priority) {
+        critical_section::with(|_| unsafe {
+            let mut nvic: cortex_m::peripheral::NVIC = mem::transmute(());
+            nvic.set_priority(self, prio.into())
+        })
+    }
+}
+
+unsafe impl<T: InterruptNumber + Copy> InterruptExt for T {}
+
+impl From<u8> for Priority {
+    fn from(priority: u8) -> Self {
+        unsafe { mem::transmute(priority & PRIO_MASK) }
+    }
+}
+
+impl From<Priority> for u8 {
+    fn from(p: Priority) -> Self {
+        p as u8
+    }
+}
+
+#[cfg(feature = "prio-bits-0")]
+const PRIO_MASK: u8 = 0x00;
+#[cfg(feature = "prio-bits-1")]
+const PRIO_MASK: u8 = 0x80;
+#[cfg(feature = "prio-bits-2")]
+const PRIO_MASK: u8 = 0xc0;
+#[cfg(feature = "prio-bits-3")]
+const PRIO_MASK: u8 = 0xe0;
+#[cfg(feature = "prio-bits-4")]
+const PRIO_MASK: u8 = 0xf0;
+#[cfg(feature = "prio-bits-5")]
+const PRIO_MASK: u8 = 0xf8;
+#[cfg(feature = "prio-bits-6")]
+const PRIO_MASK: u8 = 0xfc;
+#[cfg(feature = "prio-bits-7")]
+const PRIO_MASK: u8 = 0xfe;
+#[cfg(feature = "prio-bits-8")]
+const PRIO_MASK: u8 = 0xff;
+
+/// The interrupt priority level.
+///
+/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
+#[cfg(feature = "prio-bits-0")]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[repr(u8)]
+#[allow(missing_docs)]
+pub enum Priority {
+    P0 = 0x0,
+}
+
+/// The interrupt priority level.
+///
+/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
+#[cfg(feature = "prio-bits-1")]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[repr(u8)]
+#[allow(missing_docs)]
+pub enum Priority {
+    P0 = 0x0,
+    P1 = 0x80,
+}
+
+/// The interrupt priority level.
+///
+/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
+#[cfg(feature = "prio-bits-2")]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[repr(u8)]
+#[allow(missing_docs)]
+pub enum Priority {
+    P0 = 0x0,
+    P1 = 0x40,
+    P2 = 0x80,
+    P3 = 0xc0,
+}
+
+/// The interrupt priority level.
+///
+/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
+#[cfg(feature = "prio-bits-3")]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[repr(u8)]
+#[allow(missing_docs)]
+pub enum Priority {
+    P0 = 0x0,
+    P1 = 0x20,
+    P2 = 0x40,
+    P3 = 0x60,
+    P4 = 0x80,
+    P5 = 0xa0,
+    P6 = 0xc0,
+    P7 = 0xe0,
+}
+
+/// The interrupt priority level.
+///
+/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
+#[cfg(feature = "prio-bits-4")]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[repr(u8)]
+#[allow(missing_docs)]
+pub enum Priority {
+    P0 = 0x0,
+    P1 = 0x10,
+    P2 = 0x20,
+    P3 = 0x30,
+    P4 = 0x40,
+    P5 = 0x50,
+    P6 = 0x60,
+    P7 = 0x70,
+    P8 = 0x80,
+    P9 = 0x90,
+    P10 = 0xa0,
+    P11 = 0xb0,
+    P12 = 0xc0,
+    P13 = 0xd0,
+    P14 = 0xe0,
+    P15 = 0xf0,
+}
+
+/// The interrupt priority level.
+///
+/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
+#[cfg(feature = "prio-bits-5")]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[repr(u8)]
+#[allow(missing_docs)]
+pub enum Priority {
+    P0 = 0x0,
+    P1 = 0x8,
+    P2 = 0x10,
+    P3 = 0x18,
+    P4 = 0x20,
+    P5 = 0x28,
+    P6 = 0x30,
+    P7 = 0x38,
+    P8 = 0x40,
+    P9 = 0x48,
+    P10 = 0x50,
+    P11 = 0x58,
+    P12 = 0x60,
+    P13 = 0x68,
+    P14 = 0x70,
+    P15 = 0x78,
+    P16 = 0x80,
+    P17 = 0x88,
+    P18 = 0x90,
+    P19 = 0x98,
+    P20 = 0xa0,
+    P21 = 0xa8,
+    P22 = 0xb0,
+    P23 = 0xb8,
+    P24 = 0xc0,
+    P25 = 0xc8,
+    P26 = 0xd0,
+    P27 = 0xd8,
+    P28 = 0xe0,
+    P29 = 0xe8,
+    P30 = 0xf0,
+    P31 = 0xf8,
+}
+
+/// The interrupt priority level.
+///
+/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
+#[cfg(feature = "prio-bits-6")]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[repr(u8)]
+#[allow(missing_docs)]
+pub enum Priority {
+    P0 = 0x0,
+    P1 = 0x4,
+    P2 = 0x8,
+    P3 = 0xc,
+    P4 = 0x10,
+    P5 = 0x14,
+    P6 = 0x18,
+    P7 = 0x1c,
+    P8 = 0x20,
+    P9 = 0x24,
+    P10 = 0x28,
+    P11 = 0x2c,
+    P12 = 0x30,
+    P13 = 0x34,
+    P14 = 0x38,
+    P15 = 0x3c,
+    P16 = 0x40,
+    P17 = 0x44,
+    P18 = 0x48,
+    P19 = 0x4c,
+    P20 = 0x50,
+    P21 = 0x54,
+    P22 = 0x58,
+    P23 = 0x5c,
+    P24 = 0x60,
+    P25 = 0x64,
+    P26 = 0x68,
+    P27 = 0x6c,
+    P28 = 0x70,
+    P29 = 0x74,
+    P30 = 0x78,
+    P31 = 0x7c,
+    P32 = 0x80,
+    P33 = 0x84,
+    P34 = 0x88,
+    P35 = 0x8c,
+    P36 = 0x90,
+    P37 = 0x94,
+    P38 = 0x98,
+    P39 = 0x9c,
+    P40 = 0xa0,
+    P41 = 0xa4,
+    P42 = 0xa8,
+    P43 = 0xac,
+    P44 = 0xb0,
+    P45 = 0xb4,
+    P46 = 0xb8,
+    P47 = 0xbc,
+    P48 = 0xc0,
+    P49 = 0xc4,
+    P50 = 0xc8,
+    P51 = 0xcc,
+    P52 = 0xd0,
+    P53 = 0xd4,
+    P54 = 0xd8,
+    P55 = 0xdc,
+    P56 = 0xe0,
+    P57 = 0xe4,
+    P58 = 0xe8,
+    P59 = 0xec,
+    P60 = 0xf0,
+    P61 = 0xf4,
+    P62 = 0xf8,
+    P63 = 0xfc,
+}
+
+/// The interrupt priority level.
+///
+/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
+#[cfg(feature = "prio-bits-7")]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[repr(u8)]
+#[allow(missing_docs)]
+pub enum Priority {
+    P0 = 0x0,
+    P1 = 0x2,
+    P2 = 0x4,
+    P3 = 0x6,
+    P4 = 0x8,
+    P5 = 0xa,
+    P6 = 0xc,
+    P7 = 0xe,
+    P8 = 0x10,
+    P9 = 0x12,
+    P10 = 0x14,
+    P11 = 0x16,
+    P12 = 0x18,
+    P13 = 0x1a,
+    P14 = 0x1c,
+    P15 = 0x1e,
+    P16 = 0x20,
+    P17 = 0x22,
+    P18 = 0x24,
+    P19 = 0x26,
+    P20 = 0x28,
+    P21 = 0x2a,
+    P22 = 0x2c,
+    P23 = 0x2e,
+    P24 = 0x30,
+    P25 = 0x32,
+    P26 = 0x34,
+    P27 = 0x36,
+    P28 = 0x38,
+    P29 = 0x3a,
+    P30 = 0x3c,
+    P31 = 0x3e,
+    P32 = 0x40,
+    P33 = 0x42,
+    P34 = 0x44,
+    P35 = 0x46,
+    P36 = 0x48,
+    P37 = 0x4a,
+    P38 = 0x4c,
+    P39 = 0x4e,
+    P40 = 0x50,
+    P41 = 0x52,
+    P42 = 0x54,
+    P43 = 0x56,
+    P44 = 0x58,
+    P45 = 0x5a,
+    P46 = 0x5c,
+    P47 = 0x5e,
+    P48 = 0x60,
+    P49 = 0x62,
+    P50 = 0x64,
+    P51 = 0x66,
+    P52 = 0x68,
+    P53 = 0x6a,
+    P54 = 0x6c,
+    P55 = 0x6e,
+    P56 = 0x70,
+    P57 = 0x72,
+    P58 = 0x74,
+    P59 = 0x76,
+    P60 = 0x78,
+    P61 = 0x7a,
+    P62 = 0x7c,
+    P63 = 0x7e,
+    P64 = 0x80,
+    P65 = 0x82,
+    P66 = 0x84,
+    P67 = 0x86,
+    P68 = 0x88,
+    P69 = 0x8a,
+    P70 = 0x8c,
+    P71 = 0x8e,
+    P72 = 0x90,
+    P73 = 0x92,
+    P74 = 0x94,
+    P75 = 0x96,
+    P76 = 0x98,
+    P77 = 0x9a,
+    P78 = 0x9c,
+    P79 = 0x9e,
+    P80 = 0xa0,
+    P81 = 0xa2,
+    P82 = 0xa4,
+    P83 = 0xa6,
+    P84 = 0xa8,
+    P85 = 0xaa,
+    P86 = 0xac,
+    P87 = 0xae,
+    P88 = 0xb0,
+    P89 = 0xb2,
+    P90 = 0xb4,
+    P91 = 0xb6,
+    P92 = 0xb8,
+    P93 = 0xba,
+    P94 = 0xbc,
+    P95 = 0xbe,
+    P96 = 0xc0,
+    P97 = 0xc2,
+    P98 = 0xc4,
+    P99 = 0xc6,
+    P100 = 0xc8,
+    P101 = 0xca,
+    P102 = 0xcc,
+    P103 = 0xce,
+    P104 = 0xd0,
+    P105 = 0xd2,
+    P106 = 0xd4,
+    P107 = 0xd6,
+    P108 = 0xd8,
+    P109 = 0xda,
+    P110 = 0xdc,
+    P111 = 0xde,
+    P112 = 0xe0,
+    P113 = 0xe2,
+    P114 = 0xe4,
+    P115 = 0xe6,
+    P116 = 0xe8,
+    P117 = 0xea,
+    P118 = 0xec,
+    P119 = 0xee,
+    P120 = 0xf0,
+    P121 = 0xf2,
+    P122 = 0xf4,
+    P123 = 0xf6,
+    P124 = 0xf8,
+    P125 = 0xfa,
+    P126 = 0xfc,
+    P127 = 0xfe,
+}
+
+/// The interrupt priority level.
+///
+/// NOTE: The contents of this enum differ according to the set `prio-bits-*` Cargo feature.
+#[cfg(feature = "prio-bits-8")]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[repr(u8)]
+#[allow(missing_docs)]
+pub enum Priority {
+    P0 = 0x0,
+    P1 = 0x1,
+    P2 = 0x2,
+    P3 = 0x3,
+    P4 = 0x4,
+    P5 = 0x5,
+    P6 = 0x6,
+    P7 = 0x7,
+    P8 = 0x8,
+    P9 = 0x9,
+    P10 = 0xa,
+    P11 = 0xb,
+    P12 = 0xc,
+    P13 = 0xd,
+    P14 = 0xe,
+    P15 = 0xf,
+    P16 = 0x10,
+    P17 = 0x11,
+    P18 = 0x12,
+    P19 = 0x13,
+    P20 = 0x14,
+    P21 = 0x15,
+    P22 = 0x16,
+    P23 = 0x17,
+    P24 = 0x18,
+    P25 = 0x19,
+    P26 = 0x1a,
+    P27 = 0x1b,
+    P28 = 0x1c,
+    P29 = 0x1d,
+    P30 = 0x1e,
+    P31 = 0x1f,
+    P32 = 0x20,
+    P33 = 0x21,
+    P34 = 0x22,
+    P35 = 0x23,
+    P36 = 0x24,
+    P37 = 0x25,
+    P38 = 0x26,
+    P39 = 0x27,
+    P40 = 0x28,
+    P41 = 0x29,
+    P42 = 0x2a,
+    P43 = 0x2b,
+    P44 = 0x2c,
+    P45 = 0x2d,
+    P46 = 0x2e,
+    P47 = 0x2f,
+    P48 = 0x30,
+    P49 = 0x31,
+    P50 = 0x32,
+    P51 = 0x33,
+    P52 = 0x34,
+    P53 = 0x35,
+    P54 = 0x36,
+    P55 = 0x37,
+    P56 = 0x38,
+    P57 = 0x39,
+    P58 = 0x3a,
+    P59 = 0x3b,
+    P60 = 0x3c,
+    P61 = 0x3d,
+    P62 = 0x3e,
+    P63 = 0x3f,
+    P64 = 0x40,
+    P65 = 0x41,
+    P66 = 0x42,
+    P67 = 0x43,
+    P68 = 0x44,
+    P69 = 0x45,
+    P70 = 0x46,
+    P71 = 0x47,
+    P72 = 0x48,
+    P73 = 0x49,
+    P74 = 0x4a,
+    P75 = 0x4b,
+    P76 = 0x4c,
+    P77 = 0x4d,
+    P78 = 0x4e,
+    P79 = 0x4f,
+    P80 = 0x50,
+    P81 = 0x51,
+    P82 = 0x52,
+    P83 = 0x53,
+    P84 = 0x54,
+    P85 = 0x55,
+    P86 = 0x56,
+    P87 = 0x57,
+    P88 = 0x58,
+    P89 = 0x59,
+    P90 = 0x5a,
+    P91 = 0x5b,
+    P92 = 0x5c,
+    P93 = 0x5d,
+    P94 = 0x5e,
+    P95 = 0x5f,
+    P96 = 0x60,
+    P97 = 0x61,
+    P98 = 0x62,
+    P99 = 0x63,
+    P100 = 0x64,
+    P101 = 0x65,
+    P102 = 0x66,
+    P103 = 0x67,
+    P104 = 0x68,
+    P105 = 0x69,
+    P106 = 0x6a,
+    P107 = 0x6b,
+    P108 = 0x6c,
+    P109 = 0x6d,
+    P110 = 0x6e,
+    P111 = 0x6f,
+    P112 = 0x70,
+    P113 = 0x71,
+    P114 = 0x72,
+    P115 = 0x73,
+    P116 = 0x74,
+    P117 = 0x75,
+    P118 = 0x76,
+    P119 = 0x77,
+    P120 = 0x78,
+    P121 = 0x79,
+    P122 = 0x7a,
+    P123 = 0x7b,
+    P124 = 0x7c,
+    P125 = 0x7d,
+    P126 = 0x7e,
+    P127 = 0x7f,
+    P128 = 0x80,
+    P129 = 0x81,
+    P130 = 0x82,
+    P131 = 0x83,
+    P132 = 0x84,
+    P133 = 0x85,
+    P134 = 0x86,
+    P135 = 0x87,
+    P136 = 0x88,
+    P137 = 0x89,
+    P138 = 0x8a,
+    P139 = 0x8b,
+    P140 = 0x8c,
+    P141 = 0x8d,
+    P142 = 0x8e,
+    P143 = 0x8f,
+    P144 = 0x90,
+    P145 = 0x91,
+    P146 = 0x92,
+    P147 = 0x93,
+    P148 = 0x94,
+    P149 = 0x95,
+    P150 = 0x96,
+    P151 = 0x97,
+    P152 = 0x98,
+    P153 = 0x99,
+    P154 = 0x9a,
+    P155 = 0x9b,
+    P156 = 0x9c,
+    P157 = 0x9d,
+    P158 = 0x9e,
+    P159 = 0x9f,
+    P160 = 0xa0,
+    P161 = 0xa1,
+    P162 = 0xa2,
+    P163 = 0xa3,
+    P164 = 0xa4,
+    P165 = 0xa5,
+    P166 = 0xa6,
+    P167 = 0xa7,
+    P168 = 0xa8,
+    P169 = 0xa9,
+    P170 = 0xaa,
+    P171 = 0xab,
+    P172 = 0xac,
+    P173 = 0xad,
+    P174 = 0xae,
+    P175 = 0xaf,
+    P176 = 0xb0,
+    P177 = 0xb1,
+    P178 = 0xb2,
+    P179 = 0xb3,
+    P180 = 0xb4,
+    P181 = 0xb5,
+    P182 = 0xb6,
+    P183 = 0xb7,
+    P184 = 0xb8,
+    P185 = 0xb9,
+    P186 = 0xba,
+    P187 = 0xbb,
+    P188 = 0xbc,
+    P189 = 0xbd,
+    P190 = 0xbe,
+    P191 = 0xbf,
+    P192 = 0xc0,
+    P193 = 0xc1,
+    P194 = 0xc2,
+    P195 = 0xc3,
+    P196 = 0xc4,
+    P197 = 0xc5,
+    P198 = 0xc6,
+    P199 = 0xc7,
+    P200 = 0xc8,
+    P201 = 0xc9,
+    P202 = 0xca,
+    P203 = 0xcb,
+    P204 = 0xcc,
+    P205 = 0xcd,
+    P206 = 0xce,
+    P207 = 0xcf,
+    P208 = 0xd0,
+    P209 = 0xd1,
+    P210 = 0xd2,
+    P211 = 0xd3,
+    P212 = 0xd4,
+    P213 = 0xd5,
+    P214 = 0xd6,
+    P215 = 0xd7,
+    P216 = 0xd8,
+    P217 = 0xd9,
+    P218 = 0xda,
+    P219 = 0xdb,
+    P220 = 0xdc,
+    P221 = 0xdd,
+    P222 = 0xde,
+    P223 = 0xdf,
+    P224 = 0xe0,
+    P225 = 0xe1,
+    P226 = 0xe2,
+    P227 = 0xe3,
+    P228 = 0xe4,
+    P229 = 0xe5,
+    P230 = 0xe6,
+    P231 = 0xe7,
+    P232 = 0xe8,
+    P233 = 0xe9,
+    P234 = 0xea,
+    P235 = 0xeb,
+    P236 = 0xec,
+    P237 = 0xed,
+    P238 = 0xee,
+    P239 = 0xef,
+    P240 = 0xf0,
+    P241 = 0xf1,
+    P242 = 0xf2,
+    P243 = 0xf3,
+    P244 = 0xf4,
+    P245 = 0xf5,
+    P246 = 0xf6,
+    P247 = 0xf7,
+    P248 = 0xf8,
+    P249 = 0xf9,
+    P250 = 0xfa,
+    P251 = 0xfb,
+    P252 = 0xfc,
+    P253 = 0xfd,
+    P254 = 0xfe,
+    P255 = 0xff,
+}
diff --git a/embassy-hal-internal/src/lib.rs b/embassy-hal-internal/src/lib.rs
new file mode 100644
index 000000000..3640ea184
--- /dev/null
+++ b/embassy-hal-internal/src/lib.rs
@@ -0,0 +1,17 @@
+#![no_std]
+#![allow(clippy::new_without_default)]
+#![doc = include_str!("../README.md")]
+
+// This mod MUST go first, so that the others see its macros.
+pub(crate) mod fmt;
+
+pub mod atomic_ring_buffer;
+pub mod drop;
+mod macros;
+mod peripheral;
+pub mod ratio;
+pub mod ring_buffer;
+pub use peripheral::{Peripheral, PeripheralRef};
+
+#[cfg(feature = "cortex-m")]
+pub mod interrupt;
diff --git a/embassy-hal-internal/src/macros.rs b/embassy-hal-internal/src/macros.rs
new file mode 100644
index 000000000..f06b46002
--- /dev/null
+++ b/embassy-hal-internal/src/macros.rs
@@ -0,0 +1,123 @@
+#[macro_export]
+macro_rules! peripherals_definition {
+    ($($(#[$cfg:meta])? $name:ident),*$(,)?) => {
+        /// Types for the peripheral singletons.
+        pub mod peripherals {
+            $(
+                $(#[$cfg])?
+                #[allow(non_camel_case_types)]
+                #[doc = concat!(stringify!($name), " peripheral")]
+                pub struct $name { _private: () }
+
+                $(#[$cfg])?
+                impl $name {
+                    /// Unsafely create an instance of this peripheral out of thin air.
+                    ///
+                    /// # Safety
+                    ///
+                    /// You must ensure that you're only using one instance of this type at a time.
+                    #[inline]
+                    pub unsafe fn steal() -> Self {
+                        Self{ _private: ()}
+                    }
+                }
+
+                $(#[$cfg])?
+                $crate::impl_peripheral!($name);
+            )*
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! peripherals_struct {
+    ($($(#[$cfg:meta])? $name:ident),*$(,)?) => {
+        /// Struct containing all the peripheral singletons.
+        ///
+        /// To obtain the peripherals, you must initialize the HAL, by calling [`crate::init`].
+        #[allow(non_snake_case)]
+        pub struct Peripherals {
+            $(
+                #[doc = concat!(stringify!($name), " peripheral")]
+                $(#[$cfg])?
+                pub $name: peripherals::$name,
+            )*
+        }
+
+        impl Peripherals {
+            ///Returns all the peripherals *once*
+            #[inline]
+            pub(crate) fn take() -> Self {
+
+                #[no_mangle]
+                static mut _EMBASSY_DEVICE_PERIPHERALS: bool = false;
+
+                critical_section::with(|_| unsafe {
+                    if _EMBASSY_DEVICE_PERIPHERALS {
+                        panic!("init called more than once!")
+                    }
+                    _EMBASSY_DEVICE_PERIPHERALS = true;
+                    Self::steal()
+                })
+            }
+        }
+
+        impl Peripherals {
+            /// Unsafely create an instance of this peripheral out of thin air.
+            ///
+            /// # Safety
+            ///
+            /// You must ensure that you're only using one instance of this type at a time.
+            #[inline]
+            pub unsafe fn steal() -> Self {
+                Self {
+                    $(
+                        $(#[$cfg])?
+                        $name: peripherals::$name::steal(),
+                    )*
+                }
+            }
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! peripherals {
+    ($($(#[$cfg:meta])? $name:ident),*$(,)?) => {
+        $crate::peripherals_definition!(
+            $(
+                $(#[$cfg])?
+                $name,
+            )*
+        );
+        $crate::peripherals_struct!(
+            $(
+                $(#[$cfg])?
+                $name,
+            )*
+        );
+    };
+}
+
+#[macro_export]
+macro_rules! into_ref {
+    ($($name:ident),*) => {
+        $(
+            let mut $name = $name.into_ref();
+        )*
+    }
+}
+
+#[macro_export]
+macro_rules! impl_peripheral {
+    ($type:ident) => {
+        impl $crate::Peripheral for $type {
+            type P = $type;
+
+            #[inline]
+            unsafe fn clone_unchecked(&self) -> Self::P {
+                $type { ..*self }
+            }
+        }
+    };
+}
diff --git a/embassy-hal-internal/src/peripheral.rs b/embassy-hal-internal/src/peripheral.rs
new file mode 100644
index 000000000..38b4c452e
--- /dev/null
+++ b/embassy-hal-internal/src/peripheral.rs
@@ -0,0 +1,174 @@
+use core::marker::PhantomData;
+use core::ops::{Deref, DerefMut};
+
+/// An exclusive reference to a peripheral.
+///
+/// This is functionally the same as a `&'a mut T`. There's a few advantages in having
+/// a dedicated struct instead:
+///
+/// - Memory efficiency: Peripheral singletons are typically either zero-sized (for concrete
+///   peripherals like `PA9` or `SPI4`) or very small (for example `AnyPin`, which is 1 byte).
+///   However `&mut T` is always 4 bytes for 32-bit targets, even if T is zero-sized.
+///   PeripheralRef stores a copy of `T` instead, so it's the same size.
+/// - Code size efficiency. If the user uses the same driver with both `SPI4` and `&mut SPI4`,
+///   the driver code would be monomorphized two times. With PeripheralRef, the driver is generic
+///   over a lifetime only. `SPI4` becomes `PeripheralRef<'static, SPI4>`, and `&mut SPI4` becomes
+///   `PeripheralRef<'a, SPI4>`. Lifetimes don't cause monomorphization.
+pub struct PeripheralRef<'a, T> {
+    inner: T,
+    _lifetime: PhantomData<&'a mut T>,
+}
+
+impl<'a, T> PeripheralRef<'a, T> {
+    #[inline]
+    pub fn new(inner: T) -> Self {
+        Self {
+            inner,
+            _lifetime: PhantomData,
+        }
+    }
+
+    /// Unsafely clone (duplicate) a peripheral singleton.
+    ///
+    /// # Safety
+    ///
+    /// This returns an owned clone of the peripheral. You must manually ensure
+    /// only one copy of the peripheral is in use at a time. For example, don't
+    /// create two SPI drivers on `SPI1`, because they will "fight" each other.
+    ///
+    /// You should strongly prefer using `reborrow()` instead. It returns a
+    /// `PeripheralRef` that borrows `self`, which allows the borrow checker
+    /// to enforce this at compile time.
+    pub unsafe fn clone_unchecked(&self) -> PeripheralRef<'a, T>
+    where
+        T: Peripheral<P = T>,
+    {
+        PeripheralRef::new(self.inner.clone_unchecked())
+    }
+
+    /// Reborrow into a "child" PeripheralRef.
+    ///
+    /// `self` will stay borrowed until the child PeripheralRef is dropped.
+    pub fn reborrow(&mut self) -> PeripheralRef<'_, T>
+    where
+        T: Peripheral<P = T>,
+    {
+        // safety: we're returning the clone inside a new PeripheralRef that borrows
+        // self, so user code can't use both at the same time.
+        PeripheralRef::new(unsafe { self.inner.clone_unchecked() })
+    }
+
+    /// Map the inner peripheral using `Into`.
+    ///
+    /// This converts from `PeripheralRef<'a, T>` to `PeripheralRef<'a, U>`, using an
+    /// `Into` impl to convert from `T` to `U`.
+    ///
+    /// For example, this can be useful to degrade GPIO pins: converting from PeripheralRef<'a, PB11>` to `PeripheralRef<'a, AnyPin>`.
+    #[inline]
+    pub fn map_into<U>(self) -> PeripheralRef<'a, U>
+    where
+        T: Into<U>,
+    {
+        PeripheralRef {
+            inner: self.inner.into(),
+            _lifetime: PhantomData,
+        }
+    }
+}
+
+impl<'a, T> Deref for PeripheralRef<'a, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<'a, T> DerefMut for PeripheralRef<'a, T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
+/// Trait for any type that can be used as a peripheral of type `P`.
+///
+/// This is used in driver constructors, to allow passing either owned peripherals (e.g. `TWISPI0`),
+/// or borrowed peripherals (e.g. `&mut TWISPI0`).
+///
+/// For example, if you have a driver with a constructor like this:
+///
+/// ```ignore
+/// impl<'d, T: Instance> Twim<'d, T> {
+///     pub fn new(
+///         twim: impl Peripheral<P = T> + 'd,
+///         irq: impl Peripheral<P = T::Interrupt> + 'd,
+///         sda: impl Peripheral<P = impl GpioPin> + 'd,
+///         scl: impl Peripheral<P = impl GpioPin> + 'd,
+///         config: Config,
+///     ) -> Self { .. }
+/// }
+/// ```
+///
+/// You may call it with owned peripherals, which yields an instance that can live forever (`'static`):
+///
+/// ```ignore
+/// let mut twi: Twim<'static, ...> = Twim::new(p.TWISPI0, irq, p.P0_03, p.P0_04, config);
+/// ```
+///
+/// Or you may call it with borrowed peripherals, which yields an instance that can only live for as long
+/// as the borrows last:
+///
+/// ```ignore
+/// let mut twi: Twim<'_, ...> = Twim::new(&mut p.TWISPI0, &mut irq, &mut p.P0_03, &mut p.P0_04, config);
+/// ```
+///
+/// # Implementation details, for HAL authors
+///
+/// When writing a HAL, the intended way to use this trait is to take `impl Peripheral<P = ..>` in
+/// the HAL's public API (such as driver constructors), calling `.into_ref()` to obtain a `PeripheralRef`,
+/// and storing that in the driver struct.
+///
+/// `.into_ref()` on an owned `T` yields a `PeripheralRef<'static, T>`.
+/// `.into_ref()` on an `&'a mut T` yields a `PeripheralRef<'a, T>`.
+pub trait Peripheral: Sized {
+    /// Peripheral singleton type
+    type P;
+
+    /// Unsafely clone (duplicate) a peripheral singleton.
+    ///
+    /// # Safety
+    ///
+    /// This returns an owned clone of the peripheral. You must manually ensure
+    /// only one copy of the peripheral is in use at a time. For example, don't
+    /// create two SPI drivers on `SPI1`, because they will "fight" each other.
+    ///
+    /// You should strongly prefer using `into_ref()` instead. It returns a
+    /// `PeripheralRef`, which allows the borrow checker to enforce this at compile time.
+    unsafe fn clone_unchecked(&self) -> Self::P;
+
+    /// Convert a value into a `PeripheralRef`.
+    ///
+    /// When called on an owned `T`, yields a `PeripheralRef<'static, T>`.
+    /// When called on an `&'a mut T`, yields a `PeripheralRef<'a, T>`.
+    #[inline]
+    fn into_ref<'a>(self) -> PeripheralRef<'a, Self::P>
+    where
+        Self: 'a,
+    {
+        PeripheralRef::new(unsafe { self.clone_unchecked() })
+    }
+}
+
+impl<'b, T: DerefMut> Peripheral for T
+where
+    T::Target: Peripheral,
+{
+    type P = <T::Target as Peripheral>::P;
+
+    #[inline]
+    unsafe fn clone_unchecked(&self) -> Self::P {
+        self.deref().clone_unchecked()
+    }
+}
diff --git a/embassy-hal-internal/src/ratio.rs b/embassy-hal-internal/src/ratio.rs
new file mode 100644
index 000000000..9a8808a33
--- /dev/null
+++ b/embassy-hal-internal/src/ratio.rs
@@ -0,0 +1,129 @@
+use core::ops::{Add, Div, Mul};
+
+use num_traits::{CheckedAdd, CheckedDiv, CheckedMul};
+
+/// Represents the ratio between two numbers.
+#[derive(Copy, Clone, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Ratio<T> {
+    /// Numerator.
+    numer: T,
+    /// Denominator.
+    denom: T,
+}
+
+impl<T> Ratio<T> {
+    /// Creates a new `Ratio`.
+    #[inline(always)]
+    pub const fn new_raw(numer: T, denom: T) -> Ratio<T> {
+        Ratio { numer, denom }
+    }
+
+    /// Gets an immutable reference to the numerator.
+    #[inline(always)]
+    pub const fn numer(&self) -> &T {
+        &self.numer
+    }
+
+    /// Gets an immutable reference to the denominator.
+    #[inline(always)]
+    pub const fn denom(&self) -> &T {
+        &self.denom
+    }
+}
+
+impl<T: CheckedDiv> Ratio<T> {
+    /// Converts to an integer, rounding towards zero.
+    #[inline(always)]
+    pub fn to_integer(&self) -> T {
+        unwrap!(self.numer().checked_div(self.denom()))
+    }
+}
+
+impl<T: CheckedMul> Div<T> for Ratio<T> {
+    type Output = Self;
+
+    #[inline(always)]
+    fn div(mut self, rhs: T) -> Self::Output {
+        self.denom = unwrap!(self.denom().checked_mul(&rhs));
+        self
+    }
+}
+
+impl<T: CheckedMul> Mul<T> for Ratio<T> {
+    type Output = Self;
+
+    #[inline(always)]
+    fn mul(mut self, rhs: T) -> Self::Output {
+        self.numer = unwrap!(self.numer().checked_mul(&rhs));
+        self
+    }
+}
+
+impl<T: CheckedMul + CheckedAdd> Add<T> for Ratio<T> {
+    type Output = Self;
+
+    #[inline(always)]
+    fn add(mut self, rhs: T) -> Self::Output {
+        self.numer = unwrap!(unwrap!(self.denom().checked_mul(&rhs)).checked_add(self.numer()));
+        self
+    }
+}
+
+macro_rules! impl_from_for_float {
+    ($from:ident) => {
+        impl From<Ratio<$from>> for f32 {
+            #[inline(always)]
+            fn from(r: Ratio<$from>) -> Self {
+                (r.numer as f32) / (r.denom as f32)
+            }
+        }
+
+        impl From<Ratio<$from>> for f64 {
+            #[inline(always)]
+            fn from(r: Ratio<$from>) -> Self {
+                (r.numer as f64) / (r.denom as f64)
+            }
+        }
+    };
+}
+
+impl_from_for_float!(u8);
+impl_from_for_float!(u16);
+impl_from_for_float!(u32);
+impl_from_for_float!(u64);
+impl_from_for_float!(u128);
+impl_from_for_float!(i8);
+impl_from_for_float!(i16);
+impl_from_for_float!(i32);
+impl_from_for_float!(i64);
+impl_from_for_float!(i128);
+
+impl<T: core::fmt::Display> core::fmt::Display for Ratio<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::write!(f, "{} / {}", self.numer(), self.denom())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Ratio;
+
+    #[test]
+    fn basics() {
+        let mut r = Ratio::new_raw(1, 2) + 2;
+        assert_eq!(*r.numer(), 5);
+        assert_eq!(*r.denom(), 2);
+        assert_eq!(r.to_integer(), 2);
+
+        r = r * 2;
+        assert_eq!(*r.numer(), 10);
+        assert_eq!(*r.denom(), 2);
+        assert_eq!(r.to_integer(), 5);
+
+        r = r / 2;
+        assert_eq!(*r.numer(), 10);
+        assert_eq!(*r.denom(), 4);
+        assert_eq!(r.to_integer(), 2);
+    }
+}
diff --git a/embassy-hal-internal/src/ring_buffer.rs b/embassy-hal-internal/src/ring_buffer.rs
new file mode 100644
index 000000000..fcad68bb1
--- /dev/null
+++ b/embassy-hal-internal/src/ring_buffer.rs
@@ -0,0 +1,136 @@
+pub struct RingBuffer<'a> {
+    buf: &'a mut [u8],
+    start: usize,
+    end: usize,
+    empty: bool,
+}
+
+impl<'a> RingBuffer<'a> {
+    pub fn new(buf: &'a mut [u8]) -> Self {
+        Self {
+            buf,
+            start: 0,
+            end: 0,
+            empty: true,
+        }
+    }
+
+    pub fn push_buf(&mut self) -> &mut [u8] {
+        if self.start == self.end && !self.empty {
+            trace!("  ringbuf: push_buf empty");
+            return &mut self.buf[..0];
+        }
+
+        let n = if self.start <= self.end {
+            self.buf.len() - self.end
+        } else {
+            self.start - self.end
+        };
+
+        trace!("  ringbuf: push_buf {:?}..{:?}", self.end, self.end + n);
+        &mut self.buf[self.end..self.end + n]
+    }
+
+    pub fn push(&mut self, n: usize) {
+        trace!("  ringbuf: push {:?}", n);
+        if n == 0 {
+            return;
+        }
+
+        self.end = self.wrap(self.end + n);
+        self.empty = false;
+    }
+
+    pub fn pop_buf(&mut self) -> &mut [u8] {
+        if self.empty {
+            trace!("  ringbuf: pop_buf empty");
+            return &mut self.buf[..0];
+        }
+
+        let n = if self.end <= self.start {
+            self.buf.len() - self.start
+        } else {
+            self.end - self.start
+        };
+
+        trace!("  ringbuf: pop_buf {:?}..{:?}", self.start, self.start + n);
+        &mut self.buf[self.start..self.start + n]
+    }
+
+    pub fn pop(&mut self, n: usize) {
+        trace!("  ringbuf: pop {:?}", n);
+        if n == 0 {
+            return;
+        }
+
+        self.start = self.wrap(self.start + n);
+        self.empty = self.start == self.end;
+    }
+
+    pub fn is_full(&self) -> bool {
+        self.start == self.end && !self.empty
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.empty
+    }
+
+    pub fn clear(&mut self) {
+        self.start = 0;
+        self.end = 0;
+        self.empty = true;
+    }
+
+    fn wrap(&self, n: usize) -> usize {
+        assert!(n <= self.buf.len());
+        if n == self.buf.len() {
+            0
+        } else {
+            n
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn push_pop() {
+        let mut b = [0; 4];
+        let mut rb = RingBuffer::new(&mut b);
+        let buf = rb.push_buf();
+        assert_eq!(4, buf.len());
+        buf[0] = 1;
+        buf[1] = 2;
+        buf[2] = 3;
+        buf[3] = 4;
+        rb.push(4);
+
+        let buf = rb.pop_buf();
+        assert_eq!(4, buf.len());
+        assert_eq!(1, buf[0]);
+        rb.pop(1);
+
+        let buf = rb.pop_buf();
+        assert_eq!(3, buf.len());
+        assert_eq!(2, buf[0]);
+        rb.pop(1);
+
+        let buf = rb.pop_buf();
+        assert_eq!(2, buf.len());
+        assert_eq!(3, buf[0]);
+        rb.pop(1);
+
+        let buf = rb.pop_buf();
+        assert_eq!(1, buf.len());
+        assert_eq!(4, buf[0]);
+        rb.pop(1);
+
+        let buf = rb.pop_buf();
+        assert_eq!(0, buf.len());
+
+        let buf = rb.push_buf();
+        assert_eq!(4, buf.len());
+    }
+}
diff --git a/embassy-lora/Cargo.toml b/embassy-lora/Cargo.toml
index a77ed003e..402ad2d70 100644
--- a/embassy-lora/Cargo.toml
+++ b/embassy-lora/Cargo.toml
@@ -26,5 +26,6 @@ embassy-stm32 = { version = "0.1.0", path = "../embassy-stm32", default-features
 embedded-hal-async = { version = "=0.2.0-alpha.2" }
 embedded-hal = { version = "0.2", features = ["unproven"] }
 
+futures = { version = "0.3.17", default-features = false, features = [ "async-await" ] }
 lora-phy = { version = "1" }
 lorawan-device = { version = "0.10.0", default-features = false, features = ["async"], optional = true }
diff --git a/embassy-nrf/Cargo.toml b/embassy-nrf/Cargo.toml
index 57dd22f1c..d10cd2c34 100644
--- a/embassy-nrf/Cargo.toml
+++ b/embassy-nrf/Cargo.toml
@@ -93,7 +93,7 @@ _gpio-p1 = []
 [dependencies]
 embassy-time = { version = "0.1.2", path = "../embassy-time", optional = true }
 embassy-sync = { version = "0.2.0", path = "../embassy-sync" }
-embassy-hal-common = {version = "0.1.0", path = "../embassy-hal-common", features = ["cortex-m", "prio-bits-3"] }
+embassy-hal-internal = {version = "0.1.0", path = "../embassy-hal-internal", features = ["cortex-m", "prio-bits-3"] }
 embassy-embedded-hal = {version = "0.1.0", path = "../embassy-embedded-hal" }
 embassy-usb-driver = {version = "0.1.0", path = "../embassy-usb-driver", optional=true }
 
diff --git a/embassy-nrf/src/buffered_uarte.rs b/embassy-nrf/src/buffered_uarte.rs
index 9bc1c1e7a..5a0a3c7c0 100644
--- a/embassy-nrf/src/buffered_uarte.rs
+++ b/embassy-nrf/src/buffered_uarte.rs
@@ -15,8 +15,8 @@ use core::slice;
 use core::sync::atomic::{compiler_fence, AtomicU8, AtomicUsize, Ordering};
 use core::task::Poll;
 
-use embassy_hal_common::atomic_ring_buffer::RingBuffer;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::atomic_ring_buffer::RingBuffer;
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 // Re-export SVD variants to allow user to directly set values
 pub use pac::uarte0::{baudrate::BAUDRATE_A as Baudrate, config::PARITY_A as Parity};
diff --git a/embassy-nrf/src/chips/nrf52805.rs b/embassy-nrf/src/chips/nrf52805.rs
index 8776000c8..70e4b4863 100644
--- a/embassy-nrf/src/chips/nrf52805.rs
+++ b/embassy-nrf/src/chips/nrf52805.rs
@@ -8,7 +8,7 @@ pub const FLASH_SIZE: usize = 192 * 1024;
 
 pub const RESET_PIN: u32 = 21;
 
-embassy_hal_common::peripherals! {
+embassy_hal_internal::peripherals! {
     // RTC
     RTC0,
     RTC1,
@@ -208,7 +208,7 @@ impl_ppi_channel!(PPI_CH31, 31 => static);
 impl_saadc_input!(P0_04, ANALOG_INPUT2);
 impl_saadc_input!(P0_05, ANALOG_INPUT3);
 
-embassy_hal_common::interrupt_mod!(
+embassy_hal_internal::interrupt_mod!(
     POWER_CLOCK,
     RADIO,
     UARTE0_UART0,
diff --git a/embassy-nrf/src/chips/nrf52810.rs b/embassy-nrf/src/chips/nrf52810.rs
index 5519e8953..7416d3912 100644
--- a/embassy-nrf/src/chips/nrf52810.rs
+++ b/embassy-nrf/src/chips/nrf52810.rs
@@ -8,7 +8,7 @@ pub const FLASH_SIZE: usize = 192 * 1024;
 
 pub const RESET_PIN: u32 = 21;
 
-embassy_hal_common::peripherals! {
+embassy_hal_internal::peripherals! {
     // RTC
     RTC0,
     RTC1,
@@ -234,7 +234,7 @@ impl_saadc_input!(P0_29, ANALOG_INPUT5);
 impl_saadc_input!(P0_30, ANALOG_INPUT6);
 impl_saadc_input!(P0_31, ANALOG_INPUT7);
 
-embassy_hal_common::interrupt_mod!(
+embassy_hal_internal::interrupt_mod!(
     POWER_CLOCK,
     RADIO,
     UARTE0_UART0,
diff --git a/embassy-nrf/src/chips/nrf52811.rs b/embassy-nrf/src/chips/nrf52811.rs
index d5367c59a..588010685 100644
--- a/embassy-nrf/src/chips/nrf52811.rs
+++ b/embassy-nrf/src/chips/nrf52811.rs
@@ -8,7 +8,7 @@ pub const FLASH_SIZE: usize = 192 * 1024;
 
 pub const RESET_PIN: u32 = 21;
 
-embassy_hal_common::peripherals! {
+embassy_hal_internal::peripherals! {
     // RTC
     RTC0,
     RTC1,
@@ -236,7 +236,7 @@ impl_saadc_input!(P0_29, ANALOG_INPUT5);
 impl_saadc_input!(P0_30, ANALOG_INPUT6);
 impl_saadc_input!(P0_31, ANALOG_INPUT7);
 
-embassy_hal_common::interrupt_mod!(
+embassy_hal_internal::interrupt_mod!(
     POWER_CLOCK,
     RADIO,
     UARTE0_UART0,
diff --git a/embassy-nrf/src/chips/nrf52820.rs b/embassy-nrf/src/chips/nrf52820.rs
index 785170447..0ecddaf31 100644
--- a/embassy-nrf/src/chips/nrf52820.rs
+++ b/embassy-nrf/src/chips/nrf52820.rs
@@ -8,7 +8,7 @@ pub const FLASH_SIZE: usize = 256 * 1024;
 
 pub const RESET_PIN: u32 = 18;
 
-embassy_hal_common::peripherals! {
+embassy_hal_internal::peripherals! {
     // USB
     USBD,
 
@@ -224,7 +224,7 @@ impl_ppi_channel!(PPI_CH29, 29 => static);
 impl_ppi_channel!(PPI_CH30, 30 => static);
 impl_ppi_channel!(PPI_CH31, 31 => static);
 
-embassy_hal_common::interrupt_mod!(
+embassy_hal_internal::interrupt_mod!(
     POWER_CLOCK,
     RADIO,
     UARTE0_UART0,
diff --git a/embassy-nrf/src/chips/nrf52832.rs b/embassy-nrf/src/chips/nrf52832.rs
index b77564a5c..ae39628d2 100644
--- a/embassy-nrf/src/chips/nrf52832.rs
+++ b/embassy-nrf/src/chips/nrf52832.rs
@@ -12,7 +12,7 @@ pub const FLASH_SIZE: usize = 512 * 1024;
 
 pub const RESET_PIN: u32 = 21;
 
-embassy_hal_common::peripherals! {
+embassy_hal_internal::peripherals! {
     // RTC
     RTC0,
     RTC1,
@@ -263,7 +263,7 @@ impl_saadc_input!(P0_31, ANALOG_INPUT7);
 
 impl_i2s!(I2S, I2S, I2S);
 
-embassy_hal_common::interrupt_mod!(
+embassy_hal_internal::interrupt_mod!(
     POWER_CLOCK,
     RADIO,
     UARTE0_UART0,
diff --git a/embassy-nrf/src/chips/nrf52833.rs b/embassy-nrf/src/chips/nrf52833.rs
index bff7f4ebb..b8830b338 100644
--- a/embassy-nrf/src/chips/nrf52833.rs
+++ b/embassy-nrf/src/chips/nrf52833.rs
@@ -8,7 +8,7 @@ pub const FLASH_SIZE: usize = 512 * 1024;
 
 pub const RESET_PIN: u32 = 18;
 
-embassy_hal_common::peripherals! {
+embassy_hal_internal::peripherals! {
     // USB
     USBD,
 
@@ -306,7 +306,7 @@ impl_saadc_input!(P0_31, ANALOG_INPUT7);
 
 impl_i2s!(I2S, I2S, I2S);
 
-embassy_hal_common::interrupt_mod!(
+embassy_hal_internal::interrupt_mod!(
     POWER_CLOCK,
     RADIO,
     UARTE0_UART0,
diff --git a/embassy-nrf/src/chips/nrf52840.rs b/embassy-nrf/src/chips/nrf52840.rs
index 9b0050823..a490cb079 100644
--- a/embassy-nrf/src/chips/nrf52840.rs
+++ b/embassy-nrf/src/chips/nrf52840.rs
@@ -8,7 +8,7 @@ pub const FLASH_SIZE: usize = 1024 * 1024;
 
 pub const RESET_PIN: u32 = 18;
 
-embassy_hal_common::peripherals! {
+embassy_hal_internal::peripherals! {
     // USB
     USBD,
 
@@ -311,7 +311,7 @@ impl_saadc_input!(P0_31, ANALOG_INPUT7);
 
 impl_i2s!(I2S, I2S, I2S);
 
-embassy_hal_common::interrupt_mod!(
+embassy_hal_internal::interrupt_mod!(
     POWER_CLOCK,
     RADIO,
     UARTE0_UART0,
diff --git a/embassy-nrf/src/chips/nrf5340_app.rs b/embassy-nrf/src/chips/nrf5340_app.rs
index 410ae921c..afc2c4a7e 100644
--- a/embassy-nrf/src/chips/nrf5340_app.rs
+++ b/embassy-nrf/src/chips/nrf5340_app.rs
@@ -218,7 +218,7 @@ pub const FORCE_COPY_BUFFER_SIZE: usize = 1024;
 
 pub const FLASH_SIZE: usize = 1024 * 1024;
 
-embassy_hal_common::peripherals! {
+embassy_hal_internal::peripherals! {
     // USB
     USBD,
 
@@ -506,7 +506,7 @@ impl_saadc_input!(P0_18, ANALOG_INPUT5);
 impl_saadc_input!(P0_19, ANALOG_INPUT6);
 impl_saadc_input!(P0_20, ANALOG_INPUT7);
 
-embassy_hal_common::interrupt_mod!(
+embassy_hal_internal::interrupt_mod!(
     FPU,
     CACHE,
     SPU,
diff --git a/embassy-nrf/src/chips/nrf5340_net.rs b/embassy-nrf/src/chips/nrf5340_net.rs
index 6ac783085..dee666a61 100644
--- a/embassy-nrf/src/chips/nrf5340_net.rs
+++ b/embassy-nrf/src/chips/nrf5340_net.rs
@@ -109,7 +109,7 @@ pub const FORCE_COPY_BUFFER_SIZE: usize = 1024;
 
 pub const FLASH_SIZE: usize = 256 * 1024;
 
-embassy_hal_common::peripherals! {
+embassy_hal_internal::peripherals! {
     // RTC
     RTC0,
     RTC1,
@@ -342,7 +342,7 @@ impl_ppi_channel!(PPI_CH29, 29 => configurable);
 impl_ppi_channel!(PPI_CH30, 30 => configurable);
 impl_ppi_channel!(PPI_CH31, 31 => configurable);
 
-embassy_hal_common::interrupt_mod!(
+embassy_hal_internal::interrupt_mod!(
     CLOCK_POWER,
     RADIO,
     RNG,
diff --git a/embassy-nrf/src/chips/nrf9160.rs b/embassy-nrf/src/chips/nrf9160.rs
index 67ea032ff..495285ba3 100644
--- a/embassy-nrf/src/chips/nrf9160.rs
+++ b/embassy-nrf/src/chips/nrf9160.rs
@@ -169,7 +169,7 @@ pub const FORCE_COPY_BUFFER_SIZE: usize = 1024;
 
 pub const FLASH_SIZE: usize = 1024 * 1024;
 
-embassy_hal_common::peripherals! {
+embassy_hal_internal::peripherals! {
     // RTC
     RTC0,
     RTC1,
@@ -368,7 +368,7 @@ impl_saadc_input!(P0_18, ANALOG_INPUT5);
 impl_saadc_input!(P0_19, ANALOG_INPUT6);
 impl_saadc_input!(P0_20, ANALOG_INPUT7);
 
-embassy_hal_common::interrupt_mod!(
+embassy_hal_internal::interrupt_mod!(
     SPU,
     CLOCK_POWER,
     UARTE0_SPIM0_SPIS0_TWIM0_TWIS0,
diff --git a/embassy-nrf/src/gpio.rs b/embassy-nrf/src/gpio.rs
index 895ab9340..ea2b76096 100644
--- a/embassy-nrf/src/gpio.rs
+++ b/embassy-nrf/src/gpio.rs
@@ -5,7 +5,7 @@ use core::convert::Infallible;
 use core::hint::unreachable_unchecked;
 
 use cfg_if::cfg_if;
-use embassy_hal_common::{impl_peripheral, into_ref, PeripheralRef};
+use embassy_hal_internal::{impl_peripheral, into_ref, PeripheralRef};
 
 use self::sealed::Pin as _;
 use crate::pac::p0 as gpio;
diff --git a/embassy-nrf/src/gpiote.rs b/embassy-nrf/src/gpiote.rs
index 6550f2abd..7488bc085 100644
--- a/embassy-nrf/src/gpiote.rs
+++ b/embassy-nrf/src/gpiote.rs
@@ -4,7 +4,7 @@ use core::convert::Infallible;
 use core::future::{poll_fn, Future};
 use core::task::{Context, Poll};
 
-use embassy_hal_common::{impl_peripheral, into_ref, Peripheral, PeripheralRef};
+use embassy_hal_internal::{impl_peripheral, into_ref, Peripheral, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 
 use crate::gpio::sealed::Pin as _;
diff --git a/embassy-nrf/src/i2s.rs b/embassy-nrf/src/i2s.rs
index fea38c4c0..907acdf4c 100644
--- a/embassy-nrf/src/i2s.rs
+++ b/embassy-nrf/src/i2s.rs
@@ -9,8 +9,8 @@ use core::ops::{Deref, DerefMut};
 use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
-use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::drop::OnDrop;
+use embassy_hal_internal::{into_ref, PeripheralRef};
 
 use crate::gpio::{AnyPin, Pin as GpioPin};
 use crate::interrupt::typelevel::Interrupt;
diff --git a/embassy-nrf/src/lib.rs b/embassy-nrf/src/lib.rs
index d23759f9d..355a00497 100644
--- a/embassy-nrf/src/lib.rs
+++ b/embassy-nrf/src/lib.rs
@@ -98,7 +98,7 @@ mod chip;
 /// This defines the right interrupt handlers, and creates a unit struct (like `struct Irqs;`)
 /// and implements the right [`Binding`]s for it. You can pass this struct to drivers to
 /// prove at compile-time that the right interrupts have been bound.
-// developer note: this macro can't be in `embassy-hal-common` due to the use of `$crate`.
+// developer note: this macro can't be in `embassy-hal-internal` due to the use of `$crate`.
 #[macro_export]
 macro_rules! bind_interrupts {
         ($vis:vis struct $name:ident { $($irq:ident => $($handler:ty),*;)* }) => {
@@ -127,7 +127,7 @@ pub use chip::pac;
 #[cfg(not(feature = "unstable-pac"))]
 pub(crate) use chip::pac;
 pub use chip::{peripherals, Peripherals, EASY_DMA_SIZE};
-pub use embassy_hal_common::{into_ref, Peripheral, PeripheralRef};
+pub use embassy_hal_internal::{into_ref, Peripheral, PeripheralRef};
 
 pub use crate::chip::interrupt;
 pub use crate::pac::NVIC_PRIO_BITS;
diff --git a/embassy-nrf/src/nvmc.rs b/embassy-nrf/src/nvmc.rs
index 91a5a272f..de840b886 100644
--- a/embassy-nrf/src/nvmc.rs
+++ b/embassy-nrf/src/nvmc.rs
@@ -2,7 +2,7 @@
 
 use core::{ptr, slice};
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embedded_storage::nor_flash::{
     ErrorType, MultiwriteNorFlash, NorFlash, NorFlashError, NorFlashErrorKind, ReadNorFlash,
 };
diff --git a/embassy-nrf/src/pdm.rs b/embassy-nrf/src/pdm.rs
index 217884d1c..01f41e9f9 100644
--- a/embassy-nrf/src/pdm.rs
+++ b/embassy-nrf/src/pdm.rs
@@ -6,8 +6,8 @@ use core::marker::PhantomData;
 use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
-use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::drop::OnDrop;
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use fixed::types::I7F1;
 use futures::future::poll_fn;
 
diff --git a/embassy-nrf/src/ppi/dppi.rs b/embassy-nrf/src/ppi/dppi.rs
index 40ccb2f09..0bc7f821e 100644
--- a/embassy-nrf/src/ppi/dppi.rs
+++ b/embassy-nrf/src/ppi/dppi.rs
@@ -1,4 +1,4 @@
-use embassy_hal_common::into_ref;
+use embassy_hal_internal::into_ref;
 
 use super::{Channel, ConfigurableChannel, Event, Ppi, Task};
 use crate::{pac, Peripheral};
diff --git a/embassy-nrf/src/ppi/mod.rs b/embassy-nrf/src/ppi/mod.rs
index ff6593bd5..5b4a64388 100644
--- a/embassy-nrf/src/ppi/mod.rs
+++ b/embassy-nrf/src/ppi/mod.rs
@@ -18,7 +18,7 @@
 use core::marker::PhantomData;
 use core::ptr::NonNull;
 
-use embassy_hal_common::{impl_peripheral, into_ref, PeripheralRef};
+use embassy_hal_internal::{impl_peripheral, into_ref, PeripheralRef};
 
 use crate::{peripherals, Peripheral};
 
diff --git a/embassy-nrf/src/ppi/ppi.rs b/embassy-nrf/src/ppi/ppi.rs
index 1fe898625..3e9e9fc81 100644
--- a/embassy-nrf/src/ppi/ppi.rs
+++ b/embassy-nrf/src/ppi/ppi.rs
@@ -1,4 +1,4 @@
-use embassy_hal_common::into_ref;
+use embassy_hal_internal::into_ref;
 
 use super::{Channel, ConfigurableChannel, Event, Ppi, StaticChannel, Task};
 use crate::{pac, Peripheral};
diff --git a/embassy-nrf/src/pwm.rs b/embassy-nrf/src/pwm.rs
index c8c81fa01..2f0397632 100644
--- a/embassy-nrf/src/pwm.rs
+++ b/embassy-nrf/src/pwm.rs
@@ -4,7 +4,7 @@
 
 use core::sync::atomic::{compiler_fence, Ordering};
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 
 use crate::gpio::sealed::Pin as _;
 use crate::gpio::{AnyPin, Pin as GpioPin, PselBits};
diff --git a/embassy-nrf/src/qdec.rs b/embassy-nrf/src/qdec.rs
index 8bac87d37..2aa50a2ba 100644
--- a/embassy-nrf/src/qdec.rs
+++ b/embassy-nrf/src/qdec.rs
@@ -6,7 +6,7 @@ use core::future::poll_fn;
 use core::marker::PhantomData;
 use core::task::Poll;
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 
 use crate::gpio::sealed::Pin as _;
 use crate::gpio::{AnyPin, Pin as GpioPin};
diff --git a/embassy-nrf/src/qspi.rs b/embassy-nrf/src/qspi.rs
index baefc7967..36ee33f6d 100644
--- a/embassy-nrf/src/qspi.rs
+++ b/embassy-nrf/src/qspi.rs
@@ -7,8 +7,8 @@ use core::marker::PhantomData;
 use core::ptr;
 use core::task::Poll;
 
-use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::drop::OnDrop;
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embedded_storage::nor_flash::{ErrorType, NorFlash, NorFlashError, NorFlashErrorKind, ReadNorFlash};
 
 use crate::gpio::{self, Pin as GpioPin};
diff --git a/embassy-nrf/src/rng.rs b/embassy-nrf/src/rng.rs
index 923b8b467..e2803f0d3 100644
--- a/embassy-nrf/src/rng.rs
+++ b/embassy-nrf/src/rng.rs
@@ -8,8 +8,8 @@ use core::ptr;
 use core::sync::atomic::{AtomicPtr, Ordering};
 use core::task::Poll;
 
-use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::drop::OnDrop;
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 
 use crate::interrupt::typelevel::Interrupt;
diff --git a/embassy-nrf/src/saadc.rs b/embassy-nrf/src/saadc.rs
index 23292924c..662b05614 100644
--- a/embassy-nrf/src/saadc.rs
+++ b/embassy-nrf/src/saadc.rs
@@ -6,8 +6,8 @@ use core::future::poll_fn;
 use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
-use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::{impl_peripheral, into_ref, PeripheralRef};
+use embassy_hal_internal::drop::OnDrop;
+use embassy_hal_internal::{impl_peripheral, into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 use pac::{saadc, SAADC};
 use saadc::ch::config::{GAIN_A, REFSEL_A, RESP_A, TACQ_A};
diff --git a/embassy-nrf/src/spim.rs b/embassy-nrf/src/spim.rs
index b7dc332e9..4673a0175 100644
--- a/embassy-nrf/src/spim.rs
+++ b/embassy-nrf/src/spim.rs
@@ -8,7 +8,7 @@ use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
 use embassy_embedded_hal::SetConfig;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 pub use embedded_hal_02::spi::{Mode, Phase, Polarity, MODE_0, MODE_1, MODE_2, MODE_3};
 pub use pac::spim0::frequency::FREQUENCY_A as Frequency;
 
diff --git a/embassy-nrf/src/spis.rs b/embassy-nrf/src/spis.rs
index aa438415a..212825121 100644
--- a/embassy-nrf/src/spis.rs
+++ b/embassy-nrf/src/spis.rs
@@ -7,7 +7,7 @@ use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
 use embassy_embedded_hal::SetConfig;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 pub use embedded_hal_02::spi::{Mode, Phase, Polarity, MODE_0, MODE_1, MODE_2, MODE_3};
 
 use crate::chip::FORCE_COPY_BUFFER_SIZE;
diff --git a/embassy-nrf/src/temp.rs b/embassy-nrf/src/temp.rs
index 491e92c04..cec46d8d0 100644
--- a/embassy-nrf/src/temp.rs
+++ b/embassy-nrf/src/temp.rs
@@ -3,8 +3,8 @@
 use core::future::poll_fn;
 use core::task::Poll;
 
-use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::drop::OnDrop;
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 use fixed::types::I30F2;
 
diff --git a/embassy-nrf/src/timer.rs b/embassy-nrf/src/timer.rs
index 04748238d..3dbfdac42 100644
--- a/embassy-nrf/src/timer.rs
+++ b/embassy-nrf/src/timer.rs
@@ -6,7 +6,7 @@
 
 #![macro_use]
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 
 use crate::ppi::{Event, Task};
 use crate::{pac, Peripheral};
diff --git a/embassy-nrf/src/twim.rs b/embassy-nrf/src/twim.rs
index 2ad0d19b1..fdea480e3 100644
--- a/embassy-nrf/src/twim.rs
+++ b/embassy-nrf/src/twim.rs
@@ -9,7 +9,7 @@ use core::sync::atomic::Ordering::SeqCst;
 use core::task::Poll;
 
 use embassy_embedded_hal::SetConfig;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 #[cfg(feature = "time")]
 use embassy_time::{Duration, Instant};
diff --git a/embassy-nrf/src/twis.rs b/embassy-nrf/src/twis.rs
index a115d5616..c6c020557 100644
--- a/embassy-nrf/src/twis.rs
+++ b/embassy-nrf/src/twis.rs
@@ -8,7 +8,7 @@ use core::sync::atomic::compiler_fence;
 use core::sync::atomic::Ordering::SeqCst;
 use core::task::Poll;
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 #[cfg(feature = "time")]
 use embassy_time::{Duration, Instant};
diff --git a/embassy-nrf/src/uarte.rs b/embassy-nrf/src/uarte.rs
index 48d57fea4..e79df3561 100644
--- a/embassy-nrf/src/uarte.rs
+++ b/embassy-nrf/src/uarte.rs
@@ -18,8 +18,8 @@ use core::marker::PhantomData;
 use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
-use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::drop::OnDrop;
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use pac::uarte0::RegisterBlock;
 // Re-export SVD variants to allow user to directly set values.
 pub use pac::uarte0::{baudrate::BAUDRATE_A as Baudrate, config::PARITY_A as Parity};
diff --git a/embassy-nrf/src/usb/mod.rs b/embassy-nrf/src/usb/mod.rs
index 76cf40ac7..e26b49db3 100644
--- a/embassy-nrf/src/usb/mod.rs
+++ b/embassy-nrf/src/usb/mod.rs
@@ -11,7 +11,7 @@ use core::sync::atomic::{compiler_fence, AtomicU32, Ordering};
 use core::task::Poll;
 
 use cortex_m::peripheral::NVIC;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 use embassy_usb_driver as driver;
 use embassy_usb_driver::{Direction, EndpointAddress, EndpointError, EndpointInfo, EndpointType, Event, Unsupported};
diff --git a/embassy-rp/Cargo.toml b/embassy-rp/Cargo.toml
index 8f3ed885d..b53c7a01a 100644
--- a/embassy-rp/Cargo.toml
+++ b/embassy-rp/Cargo.toml
@@ -16,7 +16,7 @@ flavors = [
 default = [ "rt" ]
 rt = [ "rp-pac/rt" ]
 
-defmt = ["dep:defmt", "embassy-usb-driver?/defmt", "embassy-hal-common/defmt"]
+defmt = ["dep:defmt", "embassy-usb-driver?/defmt", "embassy-hal-internal/defmt"]
 
 # critical section that is safe for multicore use
 critical-section-impl = ["critical-section/restore-state-u8"]
@@ -58,7 +58,7 @@ unstable-traits = ["embedded-hal-1", "embedded-hal-nb"]
 embassy-sync = { version = "0.2.0", path = "../embassy-sync" }
 embassy-time = { version = "0.1.2", path = "../embassy-time", features = [ "tick-hz-1_000_000" ] }
 embassy-futures = { version = "0.1.0", path = "../embassy-futures" }
-embassy-hal-common = {version = "0.1.0", path = "../embassy-hal-common", features = ["cortex-m", "prio-bits-2"] }
+embassy-hal-internal = {version = "0.1.0", path = "../embassy-hal-internal", features = ["cortex-m", "prio-bits-2"] }
 embassy-embedded-hal = {version = "0.1.0", path = "../embassy-embedded-hal" }
 embassy-usb-driver = {version = "0.1.0", path = "../embassy-usb-driver", optional = true }
 atomic-polyfill = "1.0.1"
diff --git a/embassy-rp/src/adc.rs b/embassy-rp/src/adc.rs
index 95780c068..4fba31169 100644
--- a/embassy-rp/src/adc.rs
+++ b/embassy-rp/src/adc.rs
@@ -3,7 +3,7 @@ use core::marker::PhantomData;
 use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 
 use crate::gpio::sealed::Pin as GpioPin;
diff --git a/embassy-rp/src/clocks.rs b/embassy-rp/src/clocks.rs
index acb21dce5..976d06de7 100644
--- a/embassy-rp/src/clocks.rs
+++ b/embassy-rp/src/clocks.rs
@@ -1,7 +1,7 @@
 use core::marker::PhantomData;
 use core::sync::atomic::{AtomicU16, AtomicU32, Ordering};
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use pac::clocks::vals::*;
 
 use crate::gpio::sealed::Pin;
diff --git a/embassy-rp/src/dma.rs b/embassy-rp/src/dma.rs
index 1a458778c..c8f741804 100644
--- a/embassy-rp/src/dma.rs
+++ b/embassy-rp/src/dma.rs
@@ -4,7 +4,7 @@ use core::pin::Pin;
 use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::{Context, Poll};
 
-use embassy_hal_common::{impl_peripheral, into_ref, Peripheral, PeripheralRef};
+use embassy_hal_internal::{impl_peripheral, into_ref, Peripheral, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 use pac::dma::vals::DataSize;
 
diff --git a/embassy-rp/src/flash.rs b/embassy-rp/src/flash.rs
index 96d2d4541..0ed6808eb 100644
--- a/embassy-rp/src/flash.rs
+++ b/embassy-rp/src/flash.rs
@@ -1,6 +1,6 @@
 use core::marker::PhantomData;
 
-use embassy_hal_common::Peripheral;
+use embassy_hal_internal::Peripheral;
 use embedded_storage::nor_flash::{
     check_erase, check_read, check_write, ErrorType, MultiwriteNorFlash, NorFlash, NorFlashError, NorFlashErrorKind,
     ReadNorFlash,
diff --git a/embassy-rp/src/gpio.rs b/embassy-rp/src/gpio.rs
index a3d330cdc..2807eb678 100644
--- a/embassy-rp/src/gpio.rs
+++ b/embassy-rp/src/gpio.rs
@@ -3,7 +3,7 @@ use core::future::Future;
 use core::pin::Pin as FuturePin;
 use core::task::{Context, Poll};
 
-use embassy_hal_common::{impl_peripheral, into_ref, PeripheralRef};
+use embassy_hal_internal::{impl_peripheral, into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 
 use crate::interrupt::InterruptExt;
diff --git a/embassy-rp/src/i2c.rs b/embassy-rp/src/i2c.rs
index 9b85b2345..536ad747d 100644
--- a/embassy-rp/src/i2c.rs
+++ b/embassy-rp/src/i2c.rs
@@ -2,7 +2,7 @@ use core::future;
 use core::marker::PhantomData;
 use core::task::Poll;
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 use pac::i2c;
 
diff --git a/embassy-rp/src/lib.rs b/embassy-rp/src/lib.rs
index 50f028d4c..ebec9fec6 100644
--- a/embassy-rp/src/lib.rs
+++ b/embassy-rp/src/lib.rs
@@ -36,7 +36,7 @@ pub mod pio_instr_util;
 pub mod relocate;
 
 // Reexports
-pub use embassy_hal_common::{into_ref, Peripheral, PeripheralRef};
+pub use embassy_hal_internal::{into_ref, Peripheral, PeripheralRef};
 #[cfg(feature = "unstable-pac")]
 pub use rp_pac as pac;
 #[cfg(not(feature = "unstable-pac"))]
@@ -45,7 +45,7 @@ pub(crate) use rp_pac as pac;
 #[cfg(feature = "rt")]
 pub use crate::pac::NVIC_PRIO_BITS;
 
-embassy_hal_common::interrupt_mod!(
+embassy_hal_internal::interrupt_mod!(
     TIMER_IRQ_0,
     TIMER_IRQ_1,
     TIMER_IRQ_2,
@@ -85,7 +85,7 @@ embassy_hal_common::interrupt_mod!(
 /// This defines the right interrupt handlers, and creates a unit struct (like `struct Irqs;`)
 /// and implements the right [`Binding`]s for it. You can pass this struct to drivers to
 /// prove at compile-time that the right interrupts have been bound.
-// developer note: this macro can't be in `embassy-hal-common` due to the use of `$crate`.
+// developer note: this macro can't be in `embassy-hal-internal` due to the use of `$crate`.
 #[macro_export]
 macro_rules! bind_interrupts {
     ($vis:vis struct $name:ident { $($irq:ident => $($handler:ty),*;)* }) => {
@@ -107,7 +107,7 @@ macro_rules! bind_interrupts {
     };
 }
 
-embassy_hal_common::peripherals! {
+embassy_hal_internal::peripherals! {
     PIN_0,
     PIN_1,
     PIN_2,
diff --git a/embassy-rp/src/pio.rs b/embassy-rp/src/pio.rs
index 72a2f44ed..464988b27 100644
--- a/embassy-rp/src/pio.rs
+++ b/embassy-rp/src/pio.rs
@@ -5,7 +5,7 @@ use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::{Context, Poll};
 
 use atomic_polyfill::{AtomicU32, AtomicU8};
-use embassy_hal_common::{into_ref, Peripheral, PeripheralRef};
+use embassy_hal_internal::{into_ref, Peripheral, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 use fixed::types::extra::U8;
 use fixed::FixedU32;
diff --git a/embassy-rp/src/pwm.rs b/embassy-rp/src/pwm.rs
index 20bb88446..c0ddb2a90 100644
--- a/embassy-rp/src/pwm.rs
+++ b/embassy-rp/src/pwm.rs
@@ -1,6 +1,6 @@
 //! Pulse Width Modulation (PWM)
 
-use embassy_hal_common::{into_ref, Peripheral, PeripheralRef};
+use embassy_hal_internal::{into_ref, Peripheral, PeripheralRef};
 use fixed::traits::ToFixed;
 use fixed::FixedU16;
 use pac::pwm::regs::{ChDiv, Intr};
diff --git a/embassy-rp/src/rtc/mod.rs b/embassy-rp/src/rtc/mod.rs
index 1b33fdf8d..60ca8627b 100644
--- a/embassy-rp/src/rtc/mod.rs
+++ b/embassy-rp/src/rtc/mod.rs
@@ -1,6 +1,6 @@
 mod filter;
 
-use embassy_hal_common::{into_ref, Peripheral, PeripheralRef};
+use embassy_hal_internal::{into_ref, Peripheral, PeripheralRef};
 
 pub use self::filter::DateTimeFilter;
 
diff --git a/embassy-rp/src/spi.rs b/embassy-rp/src/spi.rs
index af101cf4a..544b542e8 100644
--- a/embassy-rp/src/spi.rs
+++ b/embassy-rp/src/spi.rs
@@ -3,7 +3,7 @@ use core::marker::PhantomData;
 
 use embassy_embedded_hal::SetConfig;
 use embassy_futures::join::join;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 pub use embedded_hal_02::spi::{Phase, Polarity};
 
 use crate::dma::{AnyChannel, Channel};
diff --git a/embassy-rp/src/uart/buffered.rs b/embassy-rp/src/uart/buffered.rs
index 30eeb5476..9d96db12c 100644
--- a/embassy-rp/src/uart/buffered.rs
+++ b/embassy-rp/src/uart/buffered.rs
@@ -3,7 +3,7 @@ use core::slice;
 use core::task::Poll;
 
 use atomic_polyfill::{AtomicU8, Ordering};
-use embassy_hal_common::atomic_ring_buffer::RingBuffer;
+use embassy_hal_internal::atomic_ring_buffer::RingBuffer;
 use embassy_sync::waitqueue::AtomicWaker;
 use embassy_time::{Duration, Timer};
 
diff --git a/embassy-rp/src/uart/mod.rs b/embassy-rp/src/uart/mod.rs
index 7b94bce5e..69c6ac2f1 100644
--- a/embassy-rp/src/uart/mod.rs
+++ b/embassy-rp/src/uart/mod.rs
@@ -4,7 +4,7 @@ use core::task::Poll;
 
 use atomic_polyfill::{AtomicU16, Ordering};
 use embassy_futures::select::{select, Either};
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 use embassy_time::{Duration, Timer};
 use pac::uart::regs::Uartris;
diff --git a/embassy-stm32-wpan/Cargo.toml b/embassy-stm32-wpan/Cargo.toml
index 2c6089c56..96c474845 100644
--- a/embassy-stm32-wpan/Cargo.toml
+++ b/embassy-stm32-wpan/Cargo.toml
@@ -15,7 +15,7 @@ embassy-stm32 = { version = "0.1.0", path = "../embassy-stm32" }
 embassy-sync = { version = "0.2.0", path = "../embassy-sync" }
 embassy-time = { version = "0.1.2", path = "../embassy-time", optional = true }
 embassy-futures = { version = "0.1.0", path = "../embassy-futures" }
-embassy-hal-common = { version = "0.1.0", path = "../embassy-hal-common" }
+embassy-hal-internal = { version = "0.1.0", path = "../embassy-hal-internal" }
 embassy-embedded-hal = { version = "0.1.0", path = "../embassy-embedded-hal" }
 embassy-net-driver = { version = "0.1.0", path = "../embassy-net-driver", optional=true }
 
@@ -31,7 +31,7 @@ futures = { version = "0.3.17", default-features = false, features = ["async-awa
 bitflags = { version = "2.3.3", optional = true }
 
 [features]
-defmt = ["dep:defmt", "embassy-sync/defmt", "embassy-embedded-hal/defmt", "embassy-hal-common/defmt", "stm32wb-hci?/defmt"]
+defmt = ["dep:defmt", "embassy-sync/defmt", "embassy-embedded-hal/defmt", "embassy-hal-internal/defmt", "stm32wb-hci?/defmt"]
 
 ble = ["dep:stm32wb-hci"]
 mac = ["dep:bitflags", "dep:embassy-net-driver" ]
diff --git a/embassy-stm32-wpan/src/lib.rs b/embassy-stm32-wpan/src/lib.rs
index 6836d7a8b..5ecce2cc2 100644
--- a/embassy-stm32-wpan/src/lib.rs
+++ b/embassy-stm32-wpan/src/lib.rs
@@ -8,7 +8,7 @@ pub mod fmt;
 use core::mem::MaybeUninit;
 use core::sync::atomic::{compiler_fence, Ordering};
 
-use embassy_hal_common::{into_ref, Peripheral, PeripheralRef};
+use embassy_hal_internal::{into_ref, Peripheral, PeripheralRef};
 use embassy_stm32::interrupt;
 use embassy_stm32::ipcc::{Config, Ipcc, ReceiveInterruptHandler, TransmitInterruptHandler};
 use embassy_stm32::peripherals::IPCC;
diff --git a/embassy-stm32/Cargo.toml b/embassy-stm32/Cargo.toml
index 0fb6fdb56..6f34c7416 100644
--- a/embassy-stm32/Cargo.toml
+++ b/embassy-stm32/Cargo.toml
@@ -34,7 +34,7 @@ flavors = [
 embassy-sync = { version = "0.2.0", path = "../embassy-sync" }
 embassy-time = { version = "0.1.2", path = "../embassy-time", optional = true }
 embassy-futures = { version = "0.1.0", path = "../embassy-futures" }
-embassy-hal-common = {version = "0.1.0", path = "../embassy-hal-common", features = ["cortex-m", "prio-bits-4"] }
+embassy-hal-internal = {version = "0.1.0", path = "../embassy-hal-internal", features = ["cortex-m", "prio-bits-4"] }
 embassy-embedded-hal = {version = "0.1.0", path = "../embassy-embedded-hal" }
 embassy-net-driver = { version = "0.1.0", path = "../embassy-net-driver" }
 embassy-usb-driver = {version = "0.1.0", path = "../embassy-usb-driver", optional = true }
@@ -80,7 +80,7 @@ stm32-metapac = { version = "13", default-features = false, features = ["metadat
 default = ["rt"]
 rt = ["stm32-metapac/rt"]
 
-defmt = ["dep:defmt", "bxcan/unstable-defmt", "embassy-sync/defmt", "embassy-embedded-hal/defmt", "embassy-hal-common/defmt", "embedded-io?/defmt", "embassy-usb-driver?/defmt", "embassy-net-driver/defmt"]
+defmt = ["dep:defmt", "bxcan/unstable-defmt", "embassy-sync/defmt", "embassy-embedded-hal/defmt", "embassy-hal-internal/defmt", "embedded-io?/defmt", "embassy-usb-driver?/defmt", "embassy-net-driver/defmt"]
 memory-x = ["stm32-metapac/memory-x"]
 exti = []
 
diff --git a/embassy-stm32/build.rs b/embassy-stm32/build.rs
index 995ad1443..0e9606ec3 100644
--- a/embassy-stm32/build.rs
+++ b/embassy-stm32/build.rs
@@ -138,7 +138,7 @@ fn main() {
     let singleton_tokens: Vec<_> = singletons.iter().map(|s| format_ident!("{}", s)).collect();
 
     g.extend(quote! {
-        embassy_hal_common::peripherals_definition!(#(#singleton_tokens),*);
+        embassy_hal_internal::peripherals_definition!(#(#singleton_tokens),*);
     });
 
     let singleton_tokens: Vec<_> = singletons
@@ -148,7 +148,7 @@ fn main() {
         .collect();
 
     g.extend(quote! {
-        embassy_hal_common::peripherals_struct!(#(#singleton_tokens),*);
+        embassy_hal_internal::peripherals_struct!(#(#singleton_tokens),*);
     });
 
     // ========
@@ -160,7 +160,7 @@ fn main() {
     }
 
     g.extend(quote! {
-        embassy_hal_common::interrupt_mod!(
+        embassy_hal_internal::interrupt_mod!(
             #(
                 #irqs,
             )*
@@ -211,7 +211,7 @@ fn main() {
         let region_type = format_ident!("{}", get_flash_region_type_name(region.name));
         flash_regions.extend(quote! {
             #[cfg(flash)]
-            pub struct #region_type<'d, MODE = crate::flash::Async>(pub &'static crate::flash::FlashRegion, pub(crate) embassy_hal_common::PeripheralRef<'d, crate::peripherals::FLASH>, pub(crate) core::marker::PhantomData<MODE>);
+            pub struct #region_type<'d, MODE = crate::flash::Async>(pub &'static crate::flash::FlashRegion, pub(crate) embassy_hal_internal::PeripheralRef<'d, crate::peripherals::FLASH>, pub(crate) core::marker::PhantomData<MODE>);
         });
     }
 
@@ -243,7 +243,7 @@ fn main() {
 
         #[cfg(flash)]
         impl<'d, MODE> FlashLayout<'d, MODE> {
-            pub(crate) fn new(p: embassy_hal_common::PeripheralRef<'d, crate::peripherals::FLASH>) -> Self {
+            pub(crate) fn new(p: embassy_hal_internal::PeripheralRef<'d, crate::peripherals::FLASH>) -> Self {
                 Self {
                     #(#inits),*,
                     _mode: core::marker::PhantomData,
diff --git a/embassy-stm32/src/adc/f1.rs b/embassy-stm32/src/adc/f1.rs
index 2322204d5..e577ec289 100644
--- a/embassy-stm32/src/adc/f1.rs
+++ b/embassy-stm32/src/adc/f1.rs
@@ -1,4 +1,4 @@
-use embassy_hal_common::into_ref;
+use embassy_hal_internal::into_ref;
 use embedded_hal_02::blocking::delay::DelayUs;
 
 use crate::adc::{Adc, AdcPin, Instance, SampleTime};
diff --git a/embassy-stm32/src/adc/v1.rs b/embassy-stm32/src/adc/v1.rs
index d9af0c55e..e8245884e 100644
--- a/embassy-stm32/src/adc/v1.rs
+++ b/embassy-stm32/src/adc/v1.rs
@@ -1,4 +1,4 @@
-use embassy_hal_common::into_ref;
+use embassy_hal_internal::into_ref;
 use embedded_hal_02::blocking::delay::DelayUs;
 
 use crate::adc::{Adc, AdcPin, Instance, InternalChannel, Resolution, SampleTime};
diff --git a/embassy-stm32/src/adc/v2.rs b/embassy-stm32/src/adc/v2.rs
index 091c1d447..9a7acea53 100644
--- a/embassy-stm32/src/adc/v2.rs
+++ b/embassy-stm32/src/adc/v2.rs
@@ -1,4 +1,4 @@
-use embassy_hal_common::into_ref;
+use embassy_hal_internal::into_ref;
 use embedded_hal_02::blocking::delay::DelayUs;
 
 use super::InternalChannel;
diff --git a/embassy-stm32/src/adc/v3.rs b/embassy-stm32/src/adc/v3.rs
index 3a6e58cf6..821cc7f6a 100644
--- a/embassy-stm32/src/adc/v3.rs
+++ b/embassy-stm32/src/adc/v3.rs
@@ -1,4 +1,4 @@
-use embassy_hal_common::into_ref;
+use embassy_hal_internal::into_ref;
 use embedded_hal_02::blocking::delay::DelayUs;
 
 use crate::adc::{Adc, AdcPin, Instance, Resolution, SampleTime};
diff --git a/embassy-stm32/src/adc/v4.rs b/embassy-stm32/src/adc/v4.rs
index c51c6840f..64d0f0c75 100644
--- a/embassy-stm32/src/adc/v4.rs
+++ b/embassy-stm32/src/adc/v4.rs
@@ -226,7 +226,7 @@ impl Prescaler {
 
 impl<'d, T: Instance> Adc<'d, T> {
     pub fn new(adc: impl Peripheral<P = T> + 'd, delay: &mut impl DelayUs<u16>) -> Self {
-        embassy_hal_common::into_ref!(adc);
+        embassy_hal_internal::into_ref!(adc);
         T::enable();
         T::reset();
 
diff --git a/embassy-stm32/src/can/bxcan.rs b/embassy-stm32/src/can/bxcan.rs
index 8b8244d4f..55d34201f 100644
--- a/embassy-stm32/src/can/bxcan.rs
+++ b/embassy-stm32/src/can/bxcan.rs
@@ -6,7 +6,7 @@ use core::task::Poll;
 
 pub use bxcan;
 use bxcan::{Data, ExtendedId, Frame, Id, StandardId};
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use futures::FutureExt;
 
 use crate::gpio::sealed::AFType;
diff --git a/embassy-stm32/src/can/fdcan.rs b/embassy-stm32/src/can/fdcan.rs
index c31a7fc63..f77788db3 100644
--- a/embassy-stm32/src/can/fdcan.rs
+++ b/embassy-stm32/src/can/fdcan.rs
@@ -1,5 +1,5 @@
 pub use bxcan;
-use embassy_hal_common::PeripheralRef;
+use embassy_hal_internal::PeripheralRef;
 
 use crate::peripherals;
 
diff --git a/embassy-stm32/src/crc/v1.rs b/embassy-stm32/src/crc/v1.rs
index 3946a2d47..154f2eb91 100644
--- a/embassy-stm32/src/crc/v1.rs
+++ b/embassy-stm32/src/crc/v1.rs
@@ -1,4 +1,4 @@
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 
 use crate::pac::CRC as PAC_CRC;
 use crate::peripherals::CRC;
diff --git a/embassy-stm32/src/crc/v2v3.rs b/embassy-stm32/src/crc/v2v3.rs
index f337055a7..de0c08755 100644
--- a/embassy-stm32/src/crc/v2v3.rs
+++ b/embassy-stm32/src/crc/v2v3.rs
@@ -1,4 +1,4 @@
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 
 use crate::pac::crc::vals;
 use crate::pac::CRC as PAC_CRC;
diff --git a/embassy-stm32/src/dac/mod.rs b/embassy-stm32/src/dac/mod.rs
index 979748bb4..a2040b857 100644
--- a/embassy-stm32/src/dac/mod.rs
+++ b/embassy-stm32/src/dac/mod.rs
@@ -3,7 +3,7 @@
 //! Provide access to the STM32 digital-to-analog converter (DAC).
 use core::marker::PhantomData;
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 
 use crate::pac::dac;
 use crate::rcc::RccPeripheral;
diff --git a/embassy-stm32/src/dcmi.rs b/embassy-stm32/src/dcmi.rs
index 78b026cb6..7497f4aaa 100644
--- a/embassy-stm32/src/dcmi.rs
+++ b/embassy-stm32/src/dcmi.rs
@@ -2,7 +2,7 @@ use core::future::poll_fn;
 use core::marker::PhantomData;
 use core::task::Poll;
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 
 use crate::dma::Transfer;
diff --git a/embassy-stm32/src/dma/bdma.rs b/embassy-stm32/src/dma/bdma.rs
index 68c78123d..d956047d5 100644
--- a/embassy-stm32/src/dma/bdma.rs
+++ b/embassy-stm32/src/dma/bdma.rs
@@ -6,7 +6,7 @@ use core::sync::atomic::{fence, Ordering};
 use core::task::{Context, Poll, Waker};
 
 use atomic_polyfill::AtomicUsize;
-use embassy_hal_common::{into_ref, Peripheral, PeripheralRef};
+use embassy_hal_internal::{into_ref, Peripheral, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 
 use super::ringbuffer::{DmaCtrl, DmaRingBuffer, OverrunError};
diff --git a/embassy-stm32/src/dma/dma.rs b/embassy-stm32/src/dma/dma.rs
index c27ec7bd9..219ef2eb0 100644
--- a/embassy-stm32/src/dma/dma.rs
+++ b/embassy-stm32/src/dma/dma.rs
@@ -4,7 +4,7 @@ use core::pin::Pin;
 use core::sync::atomic::{fence, AtomicUsize, Ordering};
 use core::task::{Context, Poll, Waker};
 
-use embassy_hal_common::{into_ref, Peripheral, PeripheralRef};
+use embassy_hal_internal::{into_ref, Peripheral, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 
 use super::ringbuffer::{DmaCtrl, DmaRingBuffer, OverrunError};
diff --git a/embassy-stm32/src/dma/gpdma.rs b/embassy-stm32/src/dma/gpdma.rs
index b7bcf7795..97cc200d7 100644
--- a/embassy-stm32/src/dma/gpdma.rs
+++ b/embassy-stm32/src/dma/gpdma.rs
@@ -5,7 +5,7 @@ use core::pin::Pin;
 use core::sync::atomic::{fence, Ordering};
 use core::task::{Context, Poll};
 
-use embassy_hal_common::{into_ref, Peripheral, PeripheralRef};
+use embassy_hal_internal::{into_ref, Peripheral, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 
 use super::word::{Word, WordSize};
diff --git a/embassy-stm32/src/dma/mod.rs b/embassy-stm32/src/dma/mod.rs
index 0858587bd..4f1a58ae2 100644
--- a/embassy-stm32/src/dma/mod.rs
+++ b/embassy-stm32/src/dma/mod.rs
@@ -26,7 +26,7 @@ pub mod word;
 
 use core::mem;
 
-use embassy_hal_common::impl_peripheral;
+use embassy_hal_internal::impl_peripheral;
 
 #[cfg(dmamux)]
 pub use self::dmamux::*;
diff --git a/embassy-stm32/src/eth/v1/mod.rs b/embassy-stm32/src/eth/v1/mod.rs
index 2a6ea35ff..a1e0240c8 100644
--- a/embassy-stm32/src/eth/v1/mod.rs
+++ b/embassy-stm32/src/eth/v1/mod.rs
@@ -6,7 +6,7 @@ mod tx_desc;
 use core::marker::PhantomData;
 use core::sync::atomic::{fence, Ordering};
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use stm32_metapac::eth::vals::{Apcs, Cr, Dm, DmaomrSr, Fes, Ftf, Ifg, MbProgress, Mw, Pbl, Rsf, St, Tsf};
 
 pub(crate) use self::rx_desc::{RDes, RDesRing};
diff --git a/embassy-stm32/src/eth/v2/mod.rs b/embassy-stm32/src/eth/v2/mod.rs
index bb681c42b..ada495fdb 100644
--- a/embassy-stm32/src/eth/v2/mod.rs
+++ b/embassy-stm32/src/eth/v2/mod.rs
@@ -3,7 +3,7 @@ mod descriptors;
 use core::marker::PhantomData;
 use core::sync::atomic::{fence, Ordering};
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 
 pub(crate) use self::descriptors::{RDes, RDesRing, TDes, TDesRing};
 use super::*;
diff --git a/embassy-stm32/src/exti.rs b/embassy-stm32/src/exti.rs
index 3ff92c9e6..925cf39be 100644
--- a/embassy-stm32/src/exti.rs
+++ b/embassy-stm32/src/exti.rs
@@ -3,7 +3,7 @@ use core::marker::PhantomData;
 use core::pin::Pin;
 use core::task::{Context, Poll};
 
-use embassy_hal_common::impl_peripheral;
+use embassy_hal_internal::impl_peripheral;
 use embassy_sync::waitqueue::AtomicWaker;
 
 use crate::gpio::{AnyPin, Input, Pin as GpioPin};
diff --git a/embassy-stm32/src/flash/asynch.rs b/embassy-stm32/src/flash/asynch.rs
index f175349cd..e966e2a77 100644
--- a/embassy-stm32/src/flash/asynch.rs
+++ b/embassy-stm32/src/flash/asynch.rs
@@ -1,8 +1,8 @@
 use core::marker::PhantomData;
 use core::sync::atomic::{fence, Ordering};
 
-use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::into_ref;
+use embassy_hal_internal::drop::OnDrop;
+use embassy_hal_internal::into_ref;
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::mutex::Mutex;
 
diff --git a/embassy-stm32/src/flash/common.rs b/embassy-stm32/src/flash/common.rs
index 2a374733d..16c511295 100644
--- a/embassy-stm32/src/flash/common.rs
+++ b/embassy-stm32/src/flash/common.rs
@@ -1,8 +1,8 @@
 use core::marker::PhantomData;
 use core::sync::atomic::{fence, Ordering};
 
-use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::drop::OnDrop;
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use stm32_metapac::FLASH_BASE;
 
 use super::{
diff --git a/embassy-stm32/src/flash/f4.rs b/embassy-stm32/src/flash/f4.rs
index 4cb39e033..728f6d604 100644
--- a/embassy-stm32/src/flash/f4.rs
+++ b/embassy-stm32/src/flash/f4.rs
@@ -14,7 +14,7 @@ use crate::pac;
 mod alt_regions {
     use core::marker::PhantomData;
 
-    use embassy_hal_common::PeripheralRef;
+    use embassy_hal_internal::PeripheralRef;
     use stm32_metapac::FLASH_SIZE;
 
     use crate::_generated::flash_regions::{OTPRegion, BANK1_REGION1, BANK1_REGION2, BANK1_REGION3, OTP_REGION};
diff --git a/embassy-stm32/src/fmc.rs b/embassy-stm32/src/fmc.rs
index 60d7a00ee..177e66a91 100644
--- a/embassy-stm32/src/fmc.rs
+++ b/embassy-stm32/src/fmc.rs
@@ -1,6 +1,6 @@
 use core::marker::PhantomData;
 
-use embassy_hal_common::into_ref;
+use embassy_hal_internal::into_ref;
 
 use crate::gpio::sealed::AFType;
 use crate::gpio::{Pull, Speed};
diff --git a/embassy-stm32/src/gpio.rs b/embassy-stm32/src/gpio.rs
index af3a8eaca..cda597145 100644
--- a/embassy-stm32/src/gpio.rs
+++ b/embassy-stm32/src/gpio.rs
@@ -1,7 +1,7 @@
 #![macro_use]
 use core::convert::Infallible;
 
-use embassy_hal_common::{impl_peripheral, into_ref, PeripheralRef};
+use embassy_hal_internal::{impl_peripheral, into_ref, PeripheralRef};
 
 use crate::pac::gpio::{self, vals};
 use crate::{pac, peripherals, Peripheral};
diff --git a/embassy-stm32/src/i2c/v1.rs b/embassy-stm32/src/i2c/v1.rs
index aa485cd86..e5254a8cd 100644
--- a/embassy-stm32/src/i2c/v1.rs
+++ b/embassy-stm32/src/i2c/v1.rs
@@ -1,7 +1,7 @@
 use core::marker::PhantomData;
 
 use embassy_embedded_hal::SetConfig;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 
 use crate::dma::NoDma;
 use crate::gpio::sealed::AFType;
diff --git a/embassy-stm32/src/i2c/v2.rs b/embassy-stm32/src/i2c/v2.rs
index 208d1527d..eaf980a4d 100644
--- a/embassy-stm32/src/i2c/v2.rs
+++ b/embassy-stm32/src/i2c/v2.rs
@@ -4,8 +4,8 @@ use core::marker::PhantomData;
 use core::task::Poll;
 
 use embassy_embedded_hal::SetConfig;
-use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::drop::OnDrop;
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 
 use crate::dma::{NoDma, Transfer};
diff --git a/embassy-stm32/src/i2s.rs b/embassy-stm32/src/i2s.rs
index 62dda69b4..1ccad7328 100644
--- a/embassy-stm32/src/i2s.rs
+++ b/embassy-stm32/src/i2s.rs
@@ -1,4 +1,4 @@
-use embassy_hal_common::into_ref;
+use embassy_hal_internal::into_ref;
 
 use crate::gpio::sealed::{AFType, Pin as _};
 use crate::gpio::AnyPin;
diff --git a/embassy-stm32/src/lib.rs b/embassy-stm32/src/lib.rs
index 45a7b5476..ebd0e7cd5 100644
--- a/embassy-stm32/src/lib.rs
+++ b/embassy-stm32/src/lib.rs
@@ -79,7 +79,7 @@ pub use crate::_generated::interrupt;
 /// This defines the right interrupt handlers, and creates a unit struct (like `struct Irqs;`)
 /// and implements the right [`Binding`]s for it. You can pass this struct to drivers to
 /// prove at compile-time that the right interrupts have been bound.
-// developer note: this macro can't be in `embassy-hal-common` due to the use of `$crate`.
+// developer note: this macro can't be in `embassy-hal-internal` due to the use of `$crate`.
 #[macro_export]
 macro_rules! bind_interrupts {
     ($vis:vis struct $name:ident { $($irq:ident => $($handler:ty),*;)* }) => {
@@ -103,7 +103,7 @@ macro_rules! bind_interrupts {
 
 // Reexports
 pub use _generated::{peripherals, Peripherals};
-pub use embassy_hal_common::{into_ref, Peripheral, PeripheralRef};
+pub use embassy_hal_internal::{into_ref, Peripheral, PeripheralRef};
 #[cfg(feature = "unstable-pac")]
 pub use stm32_metapac as pac;
 #[cfg(not(feature = "unstable-pac"))]
diff --git a/embassy-stm32/src/pwm/complementary_pwm.rs b/embassy-stm32/src/pwm/complementary_pwm.rs
index 4d64d005c..64bb32c39 100644
--- a/embassy-stm32/src/pwm/complementary_pwm.rs
+++ b/embassy-stm32/src/pwm/complementary_pwm.rs
@@ -1,6 +1,6 @@
 use core::marker::PhantomData;
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use stm32_metapac::timer::vals::Ckd;
 
 use super::simple_pwm::*;
diff --git a/embassy-stm32/src/pwm/simple_pwm.rs b/embassy-stm32/src/pwm/simple_pwm.rs
index 995f59c23..514796930 100644
--- a/embassy-stm32/src/pwm/simple_pwm.rs
+++ b/embassy-stm32/src/pwm/simple_pwm.rs
@@ -1,6 +1,6 @@
 use core::marker::PhantomData;
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 
 use super::*;
 #[allow(unused_imports)]
diff --git a/embassy-stm32/src/qspi/mod.rs b/embassy-stm32/src/qspi/mod.rs
index 31b676088..32382fb28 100644
--- a/embassy-stm32/src/qspi/mod.rs
+++ b/embassy-stm32/src/qspi/mod.rs
@@ -2,7 +2,7 @@
 
 pub mod enums;
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use enums::*;
 
 use crate::dma::Transfer;
diff --git a/embassy-stm32/src/rcc/f4.rs b/embassy-stm32/src/rcc/f4.rs
index b84470440..7aa9f0fd2 100644
--- a/embassy-stm32/src/rcc/f4.rs
+++ b/embassy-stm32/src/rcc/f4.rs
@@ -1,6 +1,6 @@
 use core::marker::PhantomData;
 
-use embassy_hal_common::into_ref;
+use embassy_hal_internal::into_ref;
 use stm32_metapac::rcc::vals::{Mco1, Mco2, Mcopre};
 
 use super::sealed::RccPeripheral;
diff --git a/embassy-stm32/src/rcc/h7.rs b/embassy-stm32/src/rcc/h7.rs
index 7e5cd0d1a..bbc0e0831 100644
--- a/embassy-stm32/src/rcc/h7.rs
+++ b/embassy-stm32/src/rcc/h7.rs
@@ -1,6 +1,6 @@
 use core::marker::PhantomData;
 
-use embassy_hal_common::into_ref;
+use embassy_hal_internal::into_ref;
 pub use pll::PllConfig;
 use stm32_metapac::rcc::vals::{Mco1, Mco2};
 
diff --git a/embassy-stm32/src/rcc/l4.rs b/embassy-stm32/src/rcc/l4.rs
index 8a9b4adbf..dc5f55d0c 100644
--- a/embassy-stm32/src/rcc/l4.rs
+++ b/embassy-stm32/src/rcc/l4.rs
@@ -1,6 +1,6 @@
 use core::marker::PhantomData;
 
-use embassy_hal_common::into_ref;
+use embassy_hal_internal::into_ref;
 use stm32_metapac::rcc::regs::Cfgr;
 use stm32_metapac::rcc::vals::{Lsedrv, Mcopre, Mcosel};
 
diff --git a/embassy-stm32/src/rng.rs b/embassy-stm32/src/rng.rs
index b2faec53d..27415c2d7 100644
--- a/embassy-stm32/src/rng.rs
+++ b/embassy-stm32/src/rng.rs
@@ -3,7 +3,7 @@
 use core::future::poll_fn;
 use core::task::Poll;
 
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 use rand_core::{CryptoRng, RngCore};
 
diff --git a/embassy-stm32/src/rtc/mod.rs b/embassy-stm32/src/rtc/mod.rs
index 12a2ac795..323be3187 100644
--- a/embassy-stm32/src/rtc/mod.rs
+++ b/embassy-stm32/src/rtc/mod.rs
@@ -15,7 +15,7 @@ pub use self::datetime::{DateTime, DayOfWeek, Error as DateTimeError};
 #[cfg_attr(any(rtc_v3, rtc_v3u5), path = "v3.rs")]
 mod _version;
 pub use _version::*;
-use embassy_hal_common::Peripheral;
+use embassy_hal_internal::Peripheral;
 
 /// Errors that can occur on methods on [RtcClock]
 #[derive(Clone, Debug, PartialEq, Eq)]
diff --git a/embassy-stm32/src/sdmmc/mod.rs b/embassy-stm32/src/sdmmc/mod.rs
index 434c56a48..6b532363c 100644
--- a/embassy-stm32/src/sdmmc/mod.rs
+++ b/embassy-stm32/src/sdmmc/mod.rs
@@ -6,8 +6,8 @@ use core::marker::PhantomData;
 use core::ops::{Deref, DerefMut};
 use core::task::Poll;
 
-use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::drop::OnDrop;
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use embassy_sync::waitqueue::AtomicWaker;
 use sdio_host::{BusWidth, CardCapacity, CardStatus, CurrentState, SDStatus, CID, CSD, OCR, SCR};
 
diff --git a/embassy-stm32/src/spi/mod.rs b/embassy-stm32/src/spi/mod.rs
index d5f63f84e..bdf3c85b0 100644
--- a/embassy-stm32/src/spi/mod.rs
+++ b/embassy-stm32/src/spi/mod.rs
@@ -4,7 +4,7 @@ use core::ptr;
 
 use embassy_embedded_hal::SetConfig;
 use embassy_futures::join::join;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::{into_ref, PeripheralRef};
 pub use embedded_hal_02::spi::{Mode, Phase, Polarity, MODE_0, MODE_1, MODE_2, MODE_3};
 
 use crate::dma::{slice_ptr_parts, word, Transfer};
diff --git a/embassy-stm32/src/usart/buffered.rs b/embassy-stm32/src/usart/buffered.rs
index 433ad299c..ca117da82 100644
--- a/embassy-stm32/src/usart/buffered.rs
+++ b/embassy-stm32/src/usart/buffered.rs
@@ -2,7 +2,7 @@ use core::future::poll_fn;
 use core::slice;
 use core::task::Poll;
 
-use embassy_hal_common::atomic_ring_buffer::RingBuffer;
+use embassy_hal_internal::atomic_ring_buffer::RingBuffer;
 use embassy_sync::waitqueue::AtomicWaker;
 
 use super::*;
diff --git a/embassy-stm32/src/usart/mod.rs b/embassy-stm32/src/usart/mod.rs
index 3b9226fdf..d99034bca 100644
--- a/embassy-stm32/src/usart/mod.rs
+++ b/embassy-stm32/src/usart/mod.rs
@@ -5,8 +5,8 @@ use core::marker::PhantomData;
 use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
-use embassy_hal_common::drop::OnDrop;
-use embassy_hal_common::{into_ref, PeripheralRef};
+use embassy_hal_internal::drop::OnDrop;
+use embassy_hal_internal::{into_ref, PeripheralRef};
 use futures::future::{select, Either};
 
 use crate::dma::{NoDma, Transfer};
diff --git a/embassy-stm32/src/usart/ringbuffered.rs b/embassy-stm32/src/usart/ringbuffered.rs
index c74d7e092..80261d048 100644
--- a/embassy-stm32/src/usart/ringbuffered.rs
+++ b/embassy-stm32/src/usart/ringbuffered.rs
@@ -2,7 +2,7 @@ use core::future::poll_fn;
 use core::sync::atomic::{compiler_fence, Ordering};
 use core::task::Poll;
 
-use embassy_hal_common::PeripheralRef;
+use embassy_hal_internal::PeripheralRef;
 use futures::future::{select, Either};
 
 use super::{clear_interrupt_flags, rdr, sr, BasicInstance, Error, UartRx};
diff --git a/embassy-stm32/src/usb/usb.rs b/embassy-stm32/src/usb/usb.rs
index ecdd1d0b8..cef196355 100644
--- a/embassy-stm32/src/usb/usb.rs
+++ b/embassy-stm32/src/usb/usb.rs
@@ -5,7 +5,7 @@ use core::marker::PhantomData;
 use core::sync::atomic::{AtomicBool, Ordering};
 use core::task::Poll;
 
-use embassy_hal_common::into_ref;
+use embassy_hal_internal::into_ref;
 use embassy_sync::waitqueue::AtomicWaker;
 use embassy_usb_driver as driver;
 use embassy_usb_driver::{
diff --git a/embassy-stm32/src/usb_otg/usb.rs b/embassy-stm32/src/usb_otg/usb.rs
index fd0e22adf..348f0f79d 100644
--- a/embassy-stm32/src/usb_otg/usb.rs
+++ b/embassy-stm32/src/usb_otg/usb.rs
@@ -3,7 +3,7 @@ use core::marker::PhantomData;
 use core::sync::atomic::{AtomicBool, AtomicU16, Ordering};
 use core::task::Poll;
 
-use embassy_hal_common::{into_ref, Peripheral};
+use embassy_hal_internal::{into_ref, Peripheral};
 use embassy_sync::waitqueue::AtomicWaker;
 use embassy_usb_driver::{
     self, Bus as _, Direction, EndpointAddress, EndpointAllocError, EndpointError, EndpointIn, EndpointInfo,
diff --git a/embassy-stm32/src/wdg/mod.rs b/embassy-stm32/src/wdg/mod.rs
index b03e81d6e..eafd03364 100644
--- a/embassy-stm32/src/wdg/mod.rs
+++ b/embassy-stm32/src/wdg/mod.rs
@@ -1,6 +1,6 @@
 use core::marker::PhantomData;
 
-use embassy_hal_common::{into_ref, Peripheral};
+use embassy_hal_internal::{into_ref, Peripheral};
 use stm32_metapac::iwdg::vals::{Key, Pr};
 
 use crate::rcc::LSI_FREQ;
diff --git a/examples/stm32g4/Cargo.toml b/examples/stm32g4/Cargo.toml
index ce8838605..cf3e2ce9b 100644
--- a/examples/stm32g4/Cargo.toml
+++ b/examples/stm32g4/Cargo.toml
@@ -10,7 +10,6 @@ embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-hal-common = {version = "0.1.0", path = "../../embassy-hal-common" }
 embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defmt"] }
 
 defmt = "0.3"
-- 
cgit 


From d5f9d17b7c12c73cf16aa7414ce819bbd06efc2e Mon Sep 17 00:00:00 2001
From: Dario Nieuwenhuis <dirbaio@dirbaio.net>
Date: Fri, 28 Jul 2023 13:38:26 +0200
Subject: Make pipes local vars.

---
 examples/rp/src/bin/pio_uart.rs | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/examples/rp/src/bin/pio_uart.rs b/examples/rp/src/bin/pio_uart.rs
index c978f8f06..ca1c7f394 100644
--- a/examples/rp/src/bin/pio_uart.rs
+++ b/examples/rp/src/bin/pio_uart.rs
@@ -18,7 +18,7 @@ use embassy_rp::bind_interrupts;
 use embassy_rp::peripherals::{PIO0, USB};
 use embassy_rp::pio::InterruptHandler as PioInterruptHandler;
 use embassy_rp::usb::{Driver, Instance, InterruptHandler};
-use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_sync::blocking_mutex::raw::NoopRawMutex;
 use embassy_sync::pipe::Pipe;
 use embassy_usb::class::cdc_acm::{CdcAcmClass, Receiver, Sender, State};
 use embassy_usb::driver::EndpointError;
@@ -91,13 +91,13 @@ async fn main(_spawner: Spawner) {
     let (mut uart_tx, mut uart_rx) = uart.split();
 
     // Pipe setup
-    static USB_PIPE: Pipe<ThreadModeRawMutex, 20> = Pipe::new();
-    let mut usb_pipe_writer = USB_PIPE.writer();
-    let mut usb_pipe_reader = USB_PIPE.reader();
+    let usb_pipe: Pipe<NoopRawMutex, 20> = Pipe::new();
+    let mut usb_pipe_writer = usb_pipe.writer();
+    let mut usb_pipe_reader = usb_pipe.reader();
 
-    static UART_PIPE: Pipe<ThreadModeRawMutex, 20> = Pipe::new();
-    let mut uart_pipe_writer = UART_PIPE.writer();
-    let mut uart_pipe_reader = UART_PIPE.reader();
+    let uart_pipe: Pipe<NoopRawMutex, 20> = Pipe::new();
+    let mut uart_pipe_writer = uart_pipe.writer();
+    let mut uart_pipe_reader = uart_pipe.reader();
 
     let (mut usb_tx, mut usb_rx) = class.split();
 
@@ -141,7 +141,7 @@ impl From<EndpointError> for Disconnected {
 /// Read from the USB and write it to the UART TX pipe
 async fn usb_read<'d, T: Instance + 'd>(
     usb_rx: &mut Receiver<'d, Driver<'d, T>>,
-    uart_pipe_writer: &mut embassy_sync::pipe::Writer<'static, ThreadModeRawMutex, 20>,
+    uart_pipe_writer: &mut embassy_sync::pipe::Writer<'_, NoopRawMutex, 20>,
 ) -> Result<(), Disconnected> {
     let mut buf = [0; 64];
     loop {
@@ -155,7 +155,7 @@ async fn usb_read<'d, T: Instance + 'd>(
 /// Read from the USB TX pipe and write it to the USB
 async fn usb_write<'d, T: Instance + 'd>(
     usb_tx: &mut Sender<'d, Driver<'d, T>>,
-    usb_pipe_reader: &mut embassy_sync::pipe::Reader<'d, ThreadModeRawMutex, 20>,
+    usb_pipe_reader: &mut embassy_sync::pipe::Reader<'_, NoopRawMutex, 20>,
 ) -> Result<(), Disconnected> {
     let mut buf = [0; 64];
     loop {
@@ -167,9 +167,9 @@ async fn usb_write<'d, T: Instance + 'd>(
 }
 
 /// Read from the UART and write it to the USB TX pipe
-async fn uart_read<'a>(
-    uart_rx: &mut PioUartRx<'a>,
-    usb_pipe_writer: &mut embassy_sync::pipe::Writer<'static, ThreadModeRawMutex, 20>,
+async fn uart_read(
+    uart_rx: &mut PioUartRx<'_>,
+    usb_pipe_writer: &mut embassy_sync::pipe::Writer<'_, NoopRawMutex, 20>,
 ) -> ! {
     let mut buf = [0; 64];
     loop {
@@ -184,9 +184,9 @@ async fn uart_read<'a>(
 }
 
 /// Read from the UART TX pipe and write it to the UART
-async fn uart_write<'a>(
-    uart_tx: &mut PioUartTx<'a>,
-    uart_pipe_reader: &mut embassy_sync::pipe::Reader<'a, ThreadModeRawMutex, 20>,
+async fn uart_write(
+    uart_tx: &mut PioUartTx<'_>,
+    uart_pipe_reader: &mut embassy_sync::pipe::Reader<'_, NoopRawMutex, 20>,
 ) -> ! {
     let mut buf = [0; 64];
     loop {
-- 
cgit 


From f81ee103bf946bc42355474d5e125d1e5ab08da8 Mon Sep 17 00:00:00 2001
From: Ruben De Smet <ruben.de.smet@rubdos.be>
Date: Fri, 28 Jul 2023 14:52:03 +0200
Subject: Allow ethernet and 802.15.4 to coexist

Co-authored-by: Thibaut Vandervelden <thvdveld@vub.be>
---
 embassy-net/src/lib.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/embassy-net/src/lib.rs b/embassy-net/src/lib.rs
index 81c751a2c..3f9150168 100644
--- a/embassy-net/src/lib.rs
+++ b/embassy-net/src/lib.rs
@@ -32,12 +32,14 @@ pub use smoltcp::iface::MulticastError;
 use smoltcp::iface::{Interface, SocketHandle, SocketSet, SocketStorage};
 #[cfg(feature = "dhcpv4")]
 use smoltcp::socket::dhcpv4::{self, RetryConfig};
+#[cfg(feature = "medium-ethernet")]
+pub use smoltcp::wire::EthernetAddress;
+#[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
+pub use smoltcp::wire::HardwareAddress;
 #[cfg(feature = "udp")]
 pub use smoltcp::wire::IpListenEndpoint;
-#[cfg(feature = "medium-ethernet")]
-pub use smoltcp::wire::{EthernetAddress, HardwareAddress};
 #[cfg(feature = "medium-ieee802154")]
-pub use smoltcp::wire::{HardwareAddress, Ieee802154Address};
+pub use smoltcp::wire::{Ieee802154Address, Ieee802154Frame};
 pub use smoltcp::wire::{IpAddress, IpCidr, IpEndpoint};
 #[cfg(feature = "proto-ipv4")]
 pub use smoltcp::wire::{Ipv4Address, Ipv4Cidr};
@@ -583,7 +585,7 @@ impl SocketStack {
 impl<D: Driver + 'static> Inner<D> {
     #[cfg(feature = "proto-ipv4")]
     fn apply_config_v4(&mut self, s: &mut SocketStack, config: StaticConfigV4) {
-        #[cfg(feature = "medium-ethernet")]
+        #[cfg(any(feature = "medium-ethernet", feature = "medium-ieee802154"))]
         let medium = self.device.capabilities().medium;
 
         debug!("Acquired IP configuration:");
-- 
cgit 


From 3690af9bea5968653780d296146a91c63994d89d Mon Sep 17 00:00:00 2001
From: Dario Nieuwenhuis <dirbaio@dirbaio.net>
Date: Fri, 28 Jul 2023 15:29:27 +0200
Subject: stm32/timer: merge pwm module into timer. (#1703)

The traits there are applicable to timer use cases other than PWM.
It doesn't make sense to keep them separated.
---
 embassy-stm32/build.rs                          |  30 +--
 embassy-stm32/src/lib.rs                        |   1 -
 embassy-stm32/src/pwm/complementary_pwm.rs      | 250 ----------------------
 embassy-stm32/src/pwm/mod.rs                    | 269 -----------------------
 embassy-stm32/src/pwm/simple_pwm.rs             | 107 ----------
 embassy-stm32/src/timer/complementary_pwm.rs    | 250 ++++++++++++++++++++++
 embassy-stm32/src/timer/mod.rs                  | 271 +++++++++++++++++++++---
 embassy-stm32/src/timer/simple_pwm.rs           | 107 ++++++++++
 examples/stm32f4/src/bin/pwm.rs                 |   4 +-
 examples/stm32f4/src/bin/pwm_complementary.rs   |   6 +-
 examples/stm32g4/src/bin/pwm.rs                 |   4 +-
 examples/stm32h7/src/bin/low_level_timer_api.rs |   2 +-
 examples/stm32h7/src/bin/pwm.rs                 |   4 +-
 13 files changed, 628 insertions(+), 677 deletions(-)
 delete mode 100644 embassy-stm32/src/pwm/complementary_pwm.rs
 delete mode 100644 embassy-stm32/src/pwm/mod.rs
 delete mode 100644 embassy-stm32/src/pwm/simple_pwm.rs
 create mode 100644 embassy-stm32/src/timer/complementary_pwm.rs
 create mode 100644 embassy-stm32/src/timer/simple_pwm.rs

diff --git a/embassy-stm32/build.rs b/embassy-stm32/build.rs
index 0e9606ec3..409a943d2 100644
--- a/embassy-stm32/build.rs
+++ b/embassy-stm32/build.rs
@@ -572,21 +572,21 @@ fn main() {
         (("fmc", "Clk"), quote!(crate::fmc::ClkPin)),
         (("fmc", "BA0"), quote!(crate::fmc::BA0Pin)),
         (("fmc", "BA1"), quote!(crate::fmc::BA1Pin)),
-        (("timer", "CH1"), quote!(crate::pwm::Channel1Pin)),
-        (("timer", "CH1N"), quote!(crate::pwm::Channel1ComplementaryPin)),
-        (("timer", "CH2"), quote!(crate::pwm::Channel2Pin)),
-        (("timer", "CH2N"), quote!(crate::pwm::Channel2ComplementaryPin)),
-        (("timer", "CH3"), quote!(crate::pwm::Channel3Pin)),
-        (("timer", "CH3N"), quote!(crate::pwm::Channel3ComplementaryPin)),
-        (("timer", "CH4"), quote!(crate::pwm::Channel4Pin)),
-        (("timer", "CH4N"), quote!(crate::pwm::Channel4ComplementaryPin)),
-        (("timer", "ETR"), quote!(crate::pwm::ExternalTriggerPin)),
-        (("timer", "BKIN"), quote!(crate::pwm::BreakInputPin)),
-        (("timer", "BKIN_COMP1"), quote!(crate::pwm::BreakInputComparator1Pin)),
-        (("timer", "BKIN_COMP2"), quote!(crate::pwm::BreakInputComparator2Pin)),
-        (("timer", "BKIN2"), quote!(crate::pwm::BreakInput2Pin)),
-        (("timer", "BKIN2_COMP1"), quote!(crate::pwm::BreakInput2Comparator1Pin)),
-        (("timer", "BKIN2_COMP2"), quote!(crate::pwm::BreakInput2Comparator2Pin)),
+        (("timer", "CH1"), quote!(crate::timer::Channel1Pin)),
+        (("timer", "CH1N"), quote!(crate::timer::Channel1ComplementaryPin)),
+        (("timer", "CH2"), quote!(crate::timer::Channel2Pin)),
+        (("timer", "CH2N"), quote!(crate::timer::Channel2ComplementaryPin)),
+        (("timer", "CH3"), quote!(crate::timer::Channel3Pin)),
+        (("timer", "CH3N"), quote!(crate::timer::Channel3ComplementaryPin)),
+        (("timer", "CH4"), quote!(crate::timer::Channel4Pin)),
+        (("timer", "CH4N"), quote!(crate::timer::Channel4ComplementaryPin)),
+        (("timer", "ETR"), quote!(crate::timer::ExternalTriggerPin)),
+        (("timer", "BKIN"), quote!(crate::timer::BreakInputPin)),
+        (("timer", "BKIN_COMP1"), quote!(crate::timer::BreakInputComparator1Pin)),
+        (("timer", "BKIN_COMP2"), quote!(crate::timer::BreakInputComparator2Pin)),
+        (("timer", "BKIN2"), quote!(crate::timer::BreakInput2Pin)),
+        (("timer", "BKIN2_COMP1"), quote!(crate::timer::BreakInput2Comparator1Pin)),
+        (("timer", "BKIN2_COMP2"), quote!(crate::timer::BreakInput2Comparator2Pin)),
         (("sdmmc", "CK"), quote!(crate::sdmmc::CkPin)),
         (("sdmmc", "CMD"), quote!(crate::sdmmc::CmdPin)),
         (("sdmmc", "D0"), quote!(crate::sdmmc::D0Pin)),
diff --git a/embassy-stm32/src/lib.rs b/embassy-stm32/src/lib.rs
index ebd0e7cd5..bb2ef2fc0 100644
--- a/embassy-stm32/src/lib.rs
+++ b/embassy-stm32/src/lib.rs
@@ -43,7 +43,6 @@ pub mod flash;
 pub mod i2s;
 #[cfg(stm32wb)]
 pub mod ipcc;
-pub mod pwm;
 #[cfg(quadspi)]
 pub mod qspi;
 #[cfg(rng)]
diff --git a/embassy-stm32/src/pwm/complementary_pwm.rs b/embassy-stm32/src/pwm/complementary_pwm.rs
deleted file mode 100644
index 64bb32c39..000000000
--- a/embassy-stm32/src/pwm/complementary_pwm.rs
+++ /dev/null
@@ -1,250 +0,0 @@
-use core::marker::PhantomData;
-
-use embassy_hal_internal::{into_ref, PeripheralRef};
-use stm32_metapac::timer::vals::Ckd;
-
-use super::simple_pwm::*;
-use super::*;
-#[allow(unused_imports)]
-use crate::gpio::sealed::{AFType, Pin};
-use crate::gpio::AnyPin;
-use crate::time::Hertz;
-use crate::Peripheral;
-
-pub struct ComplementaryPwmPin<'d, Perip, Channel> {
-    _pin: PeripheralRef<'d, AnyPin>,
-    phantom: PhantomData<(Perip, Channel)>,
-}
-
-macro_rules! complementary_channel_impl {
-    ($new_chx:ident, $channel:ident, $pin_trait:ident, $complementary_pin_trait:ident) => {
-        impl<'d, Perip: CaptureCompare16bitInstance> ComplementaryPwmPin<'d, Perip, $channel> {
-            pub fn $new_chx(pin: impl Peripheral<P = impl $complementary_pin_trait<Perip>> + 'd) -> Self {
-                into_ref!(pin);
-                critical_section::with(|_| {
-                    pin.set_low();
-                    pin.set_as_af(pin.af_num(), AFType::OutputPushPull);
-                    #[cfg(gpio_v2)]
-                    pin.set_speed(crate::gpio::Speed::VeryHigh);
-                });
-                ComplementaryPwmPin {
-                    _pin: pin.map_into(),
-                    phantom: PhantomData,
-                }
-            }
-        }
-    };
-}
-
-complementary_channel_impl!(new_ch1, Ch1, Channel1Pin, Channel1ComplementaryPin);
-complementary_channel_impl!(new_ch2, Ch2, Channel2Pin, Channel2ComplementaryPin);
-complementary_channel_impl!(new_ch3, Ch3, Channel3Pin, Channel3ComplementaryPin);
-complementary_channel_impl!(new_ch4, Ch4, Channel4Pin, Channel4ComplementaryPin);
-
-pub struct ComplementaryPwm<'d, T> {
-    inner: PeripheralRef<'d, T>,
-}
-
-impl<'d, T: ComplementaryCaptureCompare16bitInstance> ComplementaryPwm<'d, T> {
-    pub fn new(
-        tim: impl Peripheral<P = T> + 'd,
-        _ch1: Option<PwmPin<'d, T, Ch1>>,
-        _ch1n: Option<ComplementaryPwmPin<'d, T, Ch1>>,
-        _ch2: Option<PwmPin<'d, T, Ch2>>,
-        _ch2n: Option<ComplementaryPwmPin<'d, T, Ch2>>,
-        _ch3: Option<PwmPin<'d, T, Ch3>>,
-        _ch3n: Option<ComplementaryPwmPin<'d, T, Ch3>>,
-        _ch4: Option<PwmPin<'d, T, Ch4>>,
-        _ch4n: Option<ComplementaryPwmPin<'d, T, Ch4>>,
-        freq: Hertz,
-    ) -> Self {
-        Self::new_inner(tim, freq)
-    }
-
-    fn new_inner(tim: impl Peripheral<P = T> + 'd, freq: Hertz) -> Self {
-        into_ref!(tim);
-
-        T::enable();
-        <T as crate::rcc::sealed::RccPeripheral>::reset();
-
-        let mut this = Self { inner: tim };
-
-        this.inner.set_frequency(freq);
-        this.inner.start();
-
-        this.inner.enable_outputs(true);
-
-        this.inner
-            .set_output_compare_mode(Channel::Ch1, OutputCompareMode::PwmMode1);
-        this.inner
-            .set_output_compare_mode(Channel::Ch2, OutputCompareMode::PwmMode1);
-        this.inner
-            .set_output_compare_mode(Channel::Ch3, OutputCompareMode::PwmMode1);
-        this.inner
-            .set_output_compare_mode(Channel::Ch4, OutputCompareMode::PwmMode1);
-        this
-    }
-
-    pub fn enable(&mut self, channel: Channel) {
-        self.inner.enable_channel(channel, true);
-        self.inner.enable_complementary_channel(channel, true);
-    }
-
-    pub fn disable(&mut self, channel: Channel) {
-        self.inner.enable_complementary_channel(channel, false);
-        self.inner.enable_channel(channel, false);
-    }
-
-    pub fn set_freq(&mut self, freq: Hertz) {
-        self.inner.set_frequency(freq);
-    }
-
-    pub fn get_max_duty(&self) -> u16 {
-        self.inner.get_max_compare_value()
-    }
-
-    pub fn set_duty(&mut self, channel: Channel, duty: u16) {
-        assert!(duty < self.get_max_duty());
-        self.inner.set_compare_value(channel, duty)
-    }
-
-    /// Set the dead time as a proportion of max_duty
-    pub fn set_dead_time(&mut self, value: u16) {
-        let (ckd, value) = compute_dead_time_value(value);
-
-        self.inner.set_dead_time_clock_division(ckd);
-        self.inner.set_dead_time_value(value);
-    }
-}
-
-fn compute_dead_time_value(value: u16) -> (Ckd, u8) {
-    /*
-        Dead-time = T_clk * T_dts * T_dtg
-
-        T_dts:
-        This bit-field indicates the division ratio between the timer clock (CK_INT) frequency and the
-        dead-time and sampling clock (tDTS)used by the dead-time generators and the digital filters
-        (ETR, TIx),
-        00: tDTS=tCK_INT
-        01: tDTS=2*tCK_INT
-        10: tDTS=4*tCK_INT
-
-        T_dtg:
-        This bit-field defines the duration of the dead-time inserted between the complementary
-        outputs. DT correspond to this duration.
-        DTG[7:5]=0xx => DT=DTG[7:0]x tdtg with tdtg=tDTS.
-        DTG[7:5]=10x => DT=(64+DTG[5:0])xtdtg with Tdtg=2xtDTS.
-        DTG[7:5]=110 => DT=(32+DTG[4:0])xtdtg with Tdtg=8xtDTS.
-        DTG[7:5]=111 => DT=(32+DTG[4:0])xtdtg with Tdtg=16xtDTS.
-        Example if TDTS=125ns (8MHz), dead-time possible values are:
-        0 to 15875 ns by 125 ns steps,
-        16 us to 31750 ns by 250 ns steps,
-        32 us to 63us by 1 us steps,
-        64 us to 126 us by 2 us steps
-    */
-
-    let mut error = u16::MAX;
-    let mut ckd = Ckd::DIV1;
-    let mut bits = 0u8;
-
-    for this_ckd in [Ckd::DIV1, Ckd::DIV2, Ckd::DIV4] {
-        let outdiv = match this_ckd {
-            Ckd::DIV1 => 1,
-            Ckd::DIV2 => 2,
-            Ckd::DIV4 => 4,
-            _ => unreachable!(),
-        };
-
-        // 127
-        // 128
-        // ..
-        // 254
-        // 256
-        // ..
-        // 504
-        // 512
-        // ..
-        // 1008
-
-        let target = value / outdiv;
-        let (these_bits, result) = if target < 128 {
-            (target as u8, target)
-        } else if target < 255 {
-            (64 + (target / 2) as u8, (target - target % 2))
-        } else if target < 508 {
-            (32 + (target / 8) as u8, (target - target % 8))
-        } else if target < 1008 {
-            (32 + (target / 16) as u8, (target - target % 16))
-        } else {
-            (u8::MAX, 1008)
-        };
-
-        let this_error = value.abs_diff(result * outdiv);
-        if error > this_error {
-            ckd = this_ckd;
-            bits = these_bits;
-            error = this_error;
-        }
-
-        match error {
-            0 => break,
-            _ => {}
-        }
-    }
-
-    (ckd, bits)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{compute_dead_time_value, Ckd};
-
-    #[test]
-    fn test_compute_dead_time_value() {
-        struct TestRun {
-            value: u16,
-            ckd: Ckd,
-            bits: u8,
-        }
-
-        let fn_results = [
-            TestRun {
-                value: 1,
-                ckd: Ckd::DIV1,
-                bits: 1,
-            },
-            TestRun {
-                value: 125,
-                ckd: Ckd::DIV1,
-                bits: 125,
-            },
-            TestRun {
-                value: 245,
-                ckd: Ckd::DIV1,
-                bits: 64 + 245 / 2,
-            },
-            TestRun {
-                value: 255,
-                ckd: Ckd::DIV2,
-                bits: 127,
-            },
-            TestRun {
-                value: 400,
-                ckd: Ckd::DIV1,
-                bits: 32 + (400u16 / 8) as u8,
-            },
-            TestRun {
-                value: 600,
-                ckd: Ckd::DIV4,
-                bits: 64 + (600u16 / 8) as u8,
-            },
-        ];
-
-        for test_run in fn_results {
-            let (ckd, bits) = compute_dead_time_value(test_run.value);
-
-            assert_eq!(ckd.to_bits(), test_run.ckd.to_bits());
-            assert_eq!(bits, test_run.bits);
-        }
-    }
-}
diff --git a/embassy-stm32/src/pwm/mod.rs b/embassy-stm32/src/pwm/mod.rs
deleted file mode 100644
index 5aba2663e..000000000
--- a/embassy-stm32/src/pwm/mod.rs
+++ /dev/null
@@ -1,269 +0,0 @@
-pub mod complementary_pwm;
-pub mod simple_pwm;
-
-use stm32_metapac::timer::vals::Ckd;
-
-#[cfg(feature = "unstable-pac")]
-pub mod low_level {
-    pub use super::sealed::*;
-}
-
-#[derive(Clone, Copy)]
-pub enum Channel {
-    Ch1,
-    Ch2,
-    Ch3,
-    Ch4,
-}
-
-impl Channel {
-    pub fn raw(&self) -> usize {
-        match self {
-            Channel::Ch1 => 0,
-            Channel::Ch2 => 1,
-            Channel::Ch3 => 2,
-            Channel::Ch4 => 3,
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-pub enum OutputCompareMode {
-    Frozen,
-    ActiveOnMatch,
-    InactiveOnMatch,
-    Toggle,
-    ForceInactive,
-    ForceActive,
-    PwmMode1,
-    PwmMode2,
-}
-
-impl From<OutputCompareMode> for stm32_metapac::timer::vals::Ocm {
-    fn from(mode: OutputCompareMode) -> Self {
-        match mode {
-            OutputCompareMode::Frozen => stm32_metapac::timer::vals::Ocm::FROZEN,
-            OutputCompareMode::ActiveOnMatch => stm32_metapac::timer::vals::Ocm::ACTIVEONMATCH,
-            OutputCompareMode::InactiveOnMatch => stm32_metapac::timer::vals::Ocm::INACTIVEONMATCH,
-            OutputCompareMode::Toggle => stm32_metapac::timer::vals::Ocm::TOGGLE,
-            OutputCompareMode::ForceInactive => stm32_metapac::timer::vals::Ocm::FORCEINACTIVE,
-            OutputCompareMode::ForceActive => stm32_metapac::timer::vals::Ocm::FORCEACTIVE,
-            OutputCompareMode::PwmMode1 => stm32_metapac::timer::vals::Ocm::PWMMODE1,
-            OutputCompareMode::PwmMode2 => stm32_metapac::timer::vals::Ocm::PWMMODE2,
-        }
-    }
-}
-
-pub(crate) mod sealed {
-    use super::*;
-
-    pub trait CaptureCompare16bitInstance: crate::timer::sealed::GeneralPurpose16bitInstance {
-        /// Global output enable. Does not do anything on non-advanced timers.
-        fn enable_outputs(&mut self, enable: bool);
-
-        fn set_output_compare_mode(&mut self, channel: Channel, mode: OutputCompareMode);
-
-        fn enable_channel(&mut self, channel: Channel, enable: bool);
-
-        fn set_compare_value(&mut self, channel: Channel, value: u16);
-
-        fn get_max_compare_value(&self) -> u16;
-    }
-
-    pub trait ComplementaryCaptureCompare16bitInstance: CaptureCompare16bitInstance {
-        fn set_dead_time_clock_division(&mut self, value: Ckd);
-
-        fn set_dead_time_value(&mut self, value: u8);
-
-        fn enable_complementary_channel(&mut self, channel: Channel, enable: bool);
-    }
-
-    pub trait CaptureCompare32bitInstance: crate::timer::sealed::GeneralPurpose32bitInstance {
-        fn set_output_compare_mode(&mut self, channel: Channel, mode: OutputCompareMode);
-
-        fn enable_channel(&mut self, channel: Channel, enable: bool);
-
-        fn set_compare_value(&mut self, channel: Channel, value: u32);
-
-        fn get_max_compare_value(&self) -> u32;
-    }
-}
-
-pub trait CaptureCompare16bitInstance:
-    sealed::CaptureCompare16bitInstance + crate::timer::GeneralPurpose16bitInstance + 'static
-{
-}
-
-pub trait ComplementaryCaptureCompare16bitInstance:
-    sealed::ComplementaryCaptureCompare16bitInstance + crate::timer::AdvancedControlInstance + 'static
-{
-}
-
-pub trait CaptureCompare32bitInstance:
-    sealed::CaptureCompare32bitInstance + CaptureCompare16bitInstance + crate::timer::GeneralPurpose32bitInstance + 'static
-{
-}
-
-#[allow(unused)]
-macro_rules! impl_compare_capable_16bit {
-    ($inst:ident) => {
-        impl crate::pwm::sealed::CaptureCompare16bitInstance for crate::peripherals::$inst {
-            fn enable_outputs(&mut self, _enable: bool) {}
-
-            fn set_output_compare_mode(&mut self, channel: crate::pwm::Channel, mode: OutputCompareMode) {
-                use crate::timer::sealed::GeneralPurpose16bitInstance;
-                let r = Self::regs_gp16();
-                let raw_channel: usize = channel.raw();
-                r.ccmr_output(raw_channel / 2)
-                    .modify(|w| w.set_ocm(raw_channel % 2, mode.into()));
-            }
-
-            fn enable_channel(&mut self, channel: Channel, enable: bool) {
-                use crate::timer::sealed::GeneralPurpose16bitInstance;
-                Self::regs_gp16()
-                    .ccer()
-                    .modify(|w| w.set_cce(channel.raw(), enable));
-            }
-
-            fn set_compare_value(&mut self, channel: Channel, value: u16) {
-                use crate::timer::sealed::GeneralPurpose16bitInstance;
-                Self::regs_gp16().ccr(channel.raw()).modify(|w| w.set_ccr(value));
-            }
-
-            fn get_max_compare_value(&self) -> u16 {
-                use crate::timer::sealed::GeneralPurpose16bitInstance;
-                Self::regs_gp16().arr().read().arr()
-            }
-        }
-    };
-}
-
-foreach_interrupt! {
-    ($inst:ident, timer, TIM_GP16, UP, $irq:ident) => {
-        impl_compare_capable_16bit!($inst);
-
-        impl CaptureCompare16bitInstance for crate::peripherals::$inst {
-
-        }
-    };
-
-    ($inst:ident, timer, TIM_GP32, UP, $irq:ident) => {
-        impl_compare_capable_16bit!($inst);
-        impl crate::pwm::sealed::CaptureCompare32bitInstance for crate::peripherals::$inst {
-            fn set_output_compare_mode(
-                &mut self,
-                channel: crate::pwm::Channel,
-                mode: OutputCompareMode,
-            ) {
-                use crate::timer::sealed::GeneralPurpose32bitInstance;
-                let raw_channel = channel.raw();
-                Self::regs_gp32().ccmr_output(raw_channel / 2).modify(|w| w.set_ocm(raw_channel % 2, mode.into()));
-            }
-
-            fn enable_channel(&mut self, channel: Channel, enable: bool) {
-                use crate::timer::sealed::GeneralPurpose32bitInstance;
-                Self::regs_gp32().ccer().modify(|w| w.set_cce(channel.raw(), enable));
-            }
-
-            fn set_compare_value(&mut self, channel: Channel, value: u32) {
-                use crate::timer::sealed::GeneralPurpose32bitInstance;
-                Self::regs_gp32().ccr(channel.raw()).modify(|w| w.set_ccr(value));
-            }
-
-            fn get_max_compare_value(&self) -> u32 {
-                use crate::timer::sealed::GeneralPurpose32bitInstance;
-                Self::regs_gp32().arr().read().arr() as u32
-            }
-        }
-        impl CaptureCompare16bitInstance for crate::peripherals::$inst {
-
-        }
-        impl CaptureCompare32bitInstance for crate::peripherals::$inst {
-
-        }
-    };
-
-    ($inst:ident, timer, TIM_ADV, UP, $irq:ident) => {
-        impl crate::pwm::sealed::CaptureCompare16bitInstance for crate::peripherals::$inst {
-            fn enable_outputs(&mut self, enable: bool) {
-                use crate::timer::sealed::AdvancedControlInstance;
-                let r = Self::regs_advanced();
-                r.bdtr().modify(|w| w.set_moe(enable));
-            }
-
-            fn set_output_compare_mode(
-                &mut self,
-                channel: crate::pwm::Channel,
-                mode: OutputCompareMode,
-            ) {
-                use crate::timer::sealed::AdvancedControlInstance;
-                let r = Self::regs_advanced();
-                let raw_channel: usize = channel.raw();
-                r.ccmr_output(raw_channel / 2)
-                    .modify(|w| w.set_ocm(raw_channel % 2, mode.into()));
-            }
-
-            fn enable_channel(&mut self, channel: Channel, enable: bool) {
-                use crate::timer::sealed::AdvancedControlInstance;
-                Self::regs_advanced()
-                    .ccer()
-                    .modify(|w| w.set_cce(channel.raw(), enable));
-            }
-
-            fn set_compare_value(&mut self, channel: Channel, value: u16) {
-                use crate::timer::sealed::AdvancedControlInstance;
-                Self::regs_advanced()
-                    .ccr(channel.raw())
-                    .modify(|w| w.set_ccr(value));
-            }
-
-            fn get_max_compare_value(&self) -> u16 {
-                use crate::timer::sealed::AdvancedControlInstance;
-                Self::regs_advanced().arr().read().arr()
-            }
-        }
-
-        impl CaptureCompare16bitInstance for crate::peripherals::$inst {
-
-        }
-
-        impl crate::pwm::sealed::ComplementaryCaptureCompare16bitInstance for crate::peripherals::$inst {
-            fn set_dead_time_clock_division(&mut self, value: Ckd) {
-                use crate::timer::sealed::AdvancedControlInstance;
-                Self::regs_advanced().cr1().modify(|w| w.set_ckd(value));
-            }
-
-            fn set_dead_time_value(&mut self, value: u8) {
-                use crate::timer::sealed::AdvancedControlInstance;
-                Self::regs_advanced().bdtr().modify(|w| w.set_dtg(value));
-            }
-
-            fn enable_complementary_channel(&mut self, channel: Channel, enable: bool) {
-                use crate::timer::sealed::AdvancedControlInstance;
-                Self::regs_advanced()
-                    .ccer()
-                    .modify(|w| w.set_ccne(channel.raw(), enable));
-            }
-        }
-
-        impl ComplementaryCaptureCompare16bitInstance for crate::peripherals::$inst {
-
-        }
-    };
-}
-
-pin_trait!(Channel1Pin, CaptureCompare16bitInstance);
-pin_trait!(Channel1ComplementaryPin, CaptureCompare16bitInstance);
-pin_trait!(Channel2Pin, CaptureCompare16bitInstance);
-pin_trait!(Channel2ComplementaryPin, CaptureCompare16bitInstance);
-pin_trait!(Channel3Pin, CaptureCompare16bitInstance);
-pin_trait!(Channel3ComplementaryPin, CaptureCompare16bitInstance);
-pin_trait!(Channel4Pin, CaptureCompare16bitInstance);
-pin_trait!(Channel4ComplementaryPin, CaptureCompare16bitInstance);
-pin_trait!(ExternalTriggerPin, CaptureCompare16bitInstance);
-pin_trait!(BreakInputPin, CaptureCompare16bitInstance);
-pin_trait!(BreakInputComparator1Pin, CaptureCompare16bitInstance);
-pin_trait!(BreakInputComparator2Pin, CaptureCompare16bitInstance);
-pin_trait!(BreakInput2Pin, CaptureCompare16bitInstance);
-pin_trait!(BreakInput2Comparator1Pin, CaptureCompare16bitInstance);
-pin_trait!(BreakInput2Comparator2Pin, CaptureCompare16bitInstance);
diff --git a/embassy-stm32/src/pwm/simple_pwm.rs b/embassy-stm32/src/pwm/simple_pwm.rs
deleted file mode 100644
index 514796930..000000000
--- a/embassy-stm32/src/pwm/simple_pwm.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-use core::marker::PhantomData;
-
-use embassy_hal_internal::{into_ref, PeripheralRef};
-
-use super::*;
-#[allow(unused_imports)]
-use crate::gpio::sealed::{AFType, Pin};
-use crate::gpio::AnyPin;
-use crate::time::Hertz;
-use crate::Peripheral;
-
-pub struct Ch1;
-pub struct Ch2;
-pub struct Ch3;
-pub struct Ch4;
-
-pub struct PwmPin<'d, Perip, Channel> {
-    _pin: PeripheralRef<'d, AnyPin>,
-    phantom: PhantomData<(Perip, Channel)>,
-}
-
-macro_rules! channel_impl {
-    ($new_chx:ident, $channel:ident, $pin_trait:ident) => {
-        impl<'d, Perip: CaptureCompare16bitInstance> PwmPin<'d, Perip, $channel> {
-            pub fn $new_chx(pin: impl Peripheral<P = impl $pin_trait<Perip>> + 'd) -> Self {
-                into_ref!(pin);
-                critical_section::with(|_| {
-                    pin.set_low();
-                    pin.set_as_af(pin.af_num(), AFType::OutputPushPull);
-                    #[cfg(gpio_v2)]
-                    pin.set_speed(crate::gpio::Speed::VeryHigh);
-                });
-                PwmPin {
-                    _pin: pin.map_into(),
-                    phantom: PhantomData,
-                }
-            }
-        }
-    };
-}
-
-channel_impl!(new_ch1, Ch1, Channel1Pin);
-channel_impl!(new_ch2, Ch2, Channel2Pin);
-channel_impl!(new_ch3, Ch3, Channel3Pin);
-channel_impl!(new_ch4, Ch4, Channel4Pin);
-
-pub struct SimplePwm<'d, T> {
-    inner: PeripheralRef<'d, T>,
-}
-
-impl<'d, T: CaptureCompare16bitInstance> SimplePwm<'d, T> {
-    pub fn new(
-        tim: impl Peripheral<P = T> + 'd,
-        _ch1: Option<PwmPin<'d, T, Ch1>>,
-        _ch2: Option<PwmPin<'d, T, Ch2>>,
-        _ch3: Option<PwmPin<'d, T, Ch3>>,
-        _ch4: Option<PwmPin<'d, T, Ch4>>,
-        freq: Hertz,
-    ) -> Self {
-        Self::new_inner(tim, freq)
-    }
-
-    fn new_inner(tim: impl Peripheral<P = T> + 'd, freq: Hertz) -> Self {
-        into_ref!(tim);
-
-        T::enable();
-        <T as crate::rcc::sealed::RccPeripheral>::reset();
-
-        let mut this = Self { inner: tim };
-
-        this.inner.set_frequency(freq);
-        this.inner.start();
-
-        this.inner.enable_outputs(true);
-
-        this.inner
-            .set_output_compare_mode(Channel::Ch1, OutputCompareMode::PwmMode1);
-        this.inner
-            .set_output_compare_mode(Channel::Ch2, OutputCompareMode::PwmMode1);
-        this.inner
-            .set_output_compare_mode(Channel::Ch3, OutputCompareMode::PwmMode1);
-        this.inner
-            .set_output_compare_mode(Channel::Ch4, OutputCompareMode::PwmMode1);
-        this
-    }
-
-    pub fn enable(&mut self, channel: Channel) {
-        self.inner.enable_channel(channel, true);
-    }
-
-    pub fn disable(&mut self, channel: Channel) {
-        self.inner.enable_channel(channel, false);
-    }
-
-    pub fn set_freq(&mut self, freq: Hertz) {
-        self.inner.set_frequency(freq);
-    }
-
-    pub fn get_max_duty(&self) -> u16 {
-        self.inner.get_max_compare_value()
-    }
-
-    pub fn set_duty(&mut self, channel: Channel, duty: u16) {
-        assert!(duty < self.get_max_duty());
-        self.inner.set_compare_value(channel, duty)
-    }
-}
diff --git a/embassy-stm32/src/timer/complementary_pwm.rs b/embassy-stm32/src/timer/complementary_pwm.rs
new file mode 100644
index 000000000..64bb32c39
--- /dev/null
+++ b/embassy-stm32/src/timer/complementary_pwm.rs
@@ -0,0 +1,250 @@
+use core::marker::PhantomData;
+
+use embassy_hal_internal::{into_ref, PeripheralRef};
+use stm32_metapac::timer::vals::Ckd;
+
+use super::simple_pwm::*;
+use super::*;
+#[allow(unused_imports)]
+use crate::gpio::sealed::{AFType, Pin};
+use crate::gpio::AnyPin;
+use crate::time::Hertz;
+use crate::Peripheral;
+
+pub struct ComplementaryPwmPin<'d, Perip, Channel> {
+    _pin: PeripheralRef<'d, AnyPin>,
+    phantom: PhantomData<(Perip, Channel)>,
+}
+
+macro_rules! complementary_channel_impl {
+    ($new_chx:ident, $channel:ident, $pin_trait:ident, $complementary_pin_trait:ident) => {
+        impl<'d, Perip: CaptureCompare16bitInstance> ComplementaryPwmPin<'d, Perip, $channel> {
+            pub fn $new_chx(pin: impl Peripheral<P = impl $complementary_pin_trait<Perip>> + 'd) -> Self {
+                into_ref!(pin);
+                critical_section::with(|_| {
+                    pin.set_low();
+                    pin.set_as_af(pin.af_num(), AFType::OutputPushPull);
+                    #[cfg(gpio_v2)]
+                    pin.set_speed(crate::gpio::Speed::VeryHigh);
+                });
+                ComplementaryPwmPin {
+                    _pin: pin.map_into(),
+                    phantom: PhantomData,
+                }
+            }
+        }
+    };
+}
+
+complementary_channel_impl!(new_ch1, Ch1, Channel1Pin, Channel1ComplementaryPin);
+complementary_channel_impl!(new_ch2, Ch2, Channel2Pin, Channel2ComplementaryPin);
+complementary_channel_impl!(new_ch3, Ch3, Channel3Pin, Channel3ComplementaryPin);
+complementary_channel_impl!(new_ch4, Ch4, Channel4Pin, Channel4ComplementaryPin);
+
+pub struct ComplementaryPwm<'d, T> {
+    inner: PeripheralRef<'d, T>,
+}
+
+impl<'d, T: ComplementaryCaptureCompare16bitInstance> ComplementaryPwm<'d, T> {
+    pub fn new(
+        tim: impl Peripheral<P = T> + 'd,
+        _ch1: Option<PwmPin<'d, T, Ch1>>,
+        _ch1n: Option<ComplementaryPwmPin<'d, T, Ch1>>,
+        _ch2: Option<PwmPin<'d, T, Ch2>>,
+        _ch2n: Option<ComplementaryPwmPin<'d, T, Ch2>>,
+        _ch3: Option<PwmPin<'d, T, Ch3>>,
+        _ch3n: Option<ComplementaryPwmPin<'d, T, Ch3>>,
+        _ch4: Option<PwmPin<'d, T, Ch4>>,
+        _ch4n: Option<ComplementaryPwmPin<'d, T, Ch4>>,
+        freq: Hertz,
+    ) -> Self {
+        Self::new_inner(tim, freq)
+    }
+
+    fn new_inner(tim: impl Peripheral<P = T> + 'd, freq: Hertz) -> Self {
+        into_ref!(tim);
+
+        T::enable();
+        <T as crate::rcc::sealed::RccPeripheral>::reset();
+
+        let mut this = Self { inner: tim };
+
+        this.inner.set_frequency(freq);
+        this.inner.start();
+
+        this.inner.enable_outputs(true);
+
+        this.inner
+            .set_output_compare_mode(Channel::Ch1, OutputCompareMode::PwmMode1);
+        this.inner
+            .set_output_compare_mode(Channel::Ch2, OutputCompareMode::PwmMode1);
+        this.inner
+            .set_output_compare_mode(Channel::Ch3, OutputCompareMode::PwmMode1);
+        this.inner
+            .set_output_compare_mode(Channel::Ch4, OutputCompareMode::PwmMode1);
+        this
+    }
+
+    pub fn enable(&mut self, channel: Channel) {
+        self.inner.enable_channel(channel, true);
+        self.inner.enable_complementary_channel(channel, true);
+    }
+
+    pub fn disable(&mut self, channel: Channel) {
+        self.inner.enable_complementary_channel(channel, false);
+        self.inner.enable_channel(channel, false);
+    }
+
+    pub fn set_freq(&mut self, freq: Hertz) {
+        self.inner.set_frequency(freq);
+    }
+
+    pub fn get_max_duty(&self) -> u16 {
+        self.inner.get_max_compare_value()
+    }
+
+    pub fn set_duty(&mut self, channel: Channel, duty: u16) {
+        assert!(duty < self.get_max_duty());
+        self.inner.set_compare_value(channel, duty)
+    }
+
+    /// Set the dead time as a proportion of max_duty
+    pub fn set_dead_time(&mut self, value: u16) {
+        let (ckd, value) = compute_dead_time_value(value);
+
+        self.inner.set_dead_time_clock_division(ckd);
+        self.inner.set_dead_time_value(value);
+    }
+}
+
+fn compute_dead_time_value(value: u16) -> (Ckd, u8) {
+    /*
+        Dead-time = T_clk * T_dts * T_dtg
+
+        T_dts:
+        This bit-field indicates the division ratio between the timer clock (CK_INT) frequency and the
+        dead-time and sampling clock (tDTS)used by the dead-time generators and the digital filters
+        (ETR, TIx),
+        00: tDTS=tCK_INT
+        01: tDTS=2*tCK_INT
+        10: tDTS=4*tCK_INT
+
+        T_dtg:
+        This bit-field defines the duration of the dead-time inserted between the complementary
+        outputs. DT correspond to this duration.
+        DTG[7:5]=0xx => DT=DTG[7:0]x tdtg with tdtg=tDTS.
+        DTG[7:5]=10x => DT=(64+DTG[5:0])xtdtg with Tdtg=2xtDTS.
+        DTG[7:5]=110 => DT=(32+DTG[4:0])xtdtg with Tdtg=8xtDTS.
+        DTG[7:5]=111 => DT=(32+DTG[4:0])xtdtg with Tdtg=16xtDTS.
+        Example if TDTS=125ns (8MHz), dead-time possible values are:
+        0 to 15875 ns by 125 ns steps,
+        16 us to 31750 ns by 250 ns steps,
+        32 us to 63us by 1 us steps,
+        64 us to 126 us by 2 us steps
+    */
+
+    let mut error = u16::MAX;
+    let mut ckd = Ckd::DIV1;
+    let mut bits = 0u8;
+
+    for this_ckd in [Ckd::DIV1, Ckd::DIV2, Ckd::DIV4] {
+        let outdiv = match this_ckd {
+            Ckd::DIV1 => 1,
+            Ckd::DIV2 => 2,
+            Ckd::DIV4 => 4,
+            _ => unreachable!(),
+        };
+
+        // 127
+        // 128
+        // ..
+        // 254
+        // 256
+        // ..
+        // 504
+        // 512
+        // ..
+        // 1008
+
+        let target = value / outdiv;
+        let (these_bits, result) = if target < 128 {
+            (target as u8, target)
+        } else if target < 255 {
+            (64 + (target / 2) as u8, (target - target % 2))
+        } else if target < 508 {
+            (32 + (target / 8) as u8, (target - target % 8))
+        } else if target < 1008 {
+            (32 + (target / 16) as u8, (target - target % 16))
+        } else {
+            (u8::MAX, 1008)
+        };
+
+        let this_error = value.abs_diff(result * outdiv);
+        if error > this_error {
+            ckd = this_ckd;
+            bits = these_bits;
+            error = this_error;
+        }
+
+        match error {
+            0 => break,
+            _ => {}
+        }
+    }
+
+    (ckd, bits)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{compute_dead_time_value, Ckd};
+
+    #[test]
+    fn test_compute_dead_time_value() {
+        struct TestRun {
+            value: u16,
+            ckd: Ckd,
+            bits: u8,
+        }
+
+        let fn_results = [
+            TestRun {
+                value: 1,
+                ckd: Ckd::DIV1,
+                bits: 1,
+            },
+            TestRun {
+                value: 125,
+                ckd: Ckd::DIV1,
+                bits: 125,
+            },
+            TestRun {
+                value: 245,
+                ckd: Ckd::DIV1,
+                bits: 64 + 245 / 2,
+            },
+            TestRun {
+                value: 255,
+                ckd: Ckd::DIV2,
+                bits: 127,
+            },
+            TestRun {
+                value: 400,
+                ckd: Ckd::DIV1,
+                bits: 32 + (400u16 / 8) as u8,
+            },
+            TestRun {
+                value: 600,
+                ckd: Ckd::DIV4,
+                bits: 64 + (600u16 / 8) as u8,
+            },
+        ];
+
+        for test_run in fn_results {
+            let (ckd, bits) = compute_dead_time_value(test_run.value);
+
+            assert_eq!(ckd.to_bits(), test_run.ckd.to_bits());
+            assert_eq!(bits, test_run.bits);
+        }
+    }
+}
diff --git a/embassy-stm32/src/timer/mod.rs b/embassy-stm32/src/timer/mod.rs
index 09b7a3776..6c2d6d827 100644
--- a/embassy-stm32/src/timer/mod.rs
+++ b/embassy-stm32/src/timer/mod.rs
@@ -1,3 +1,6 @@
+pub mod complementary_pwm;
+pub mod simple_pwm;
+
 use stm32_metapac::timer::vals;
 
 use crate::interrupt;
@@ -43,15 +46,123 @@ pub(crate) mod sealed {
     pub trait AdvancedControlInstance: GeneralPurpose16bitInstance {
         fn regs_advanced() -> crate::pac::timer::TimAdv;
     }
+
+    pub trait CaptureCompare16bitInstance: GeneralPurpose16bitInstance {
+        /// Global output enable. Does not do anything on non-advanced timers.
+        fn enable_outputs(&mut self, enable: bool);
+
+        fn set_output_compare_mode(&mut self, channel: Channel, mode: OutputCompareMode);
+
+        fn enable_channel(&mut self, channel: Channel, enable: bool);
+
+        fn set_compare_value(&mut self, channel: Channel, value: u16);
+
+        fn get_max_compare_value(&self) -> u16;
+    }
+
+    pub trait ComplementaryCaptureCompare16bitInstance: CaptureCompare16bitInstance {
+        fn set_dead_time_clock_division(&mut self, value: vals::Ckd);
+
+        fn set_dead_time_value(&mut self, value: u8);
+
+        fn enable_complementary_channel(&mut self, channel: Channel, enable: bool);
+    }
+
+    pub trait CaptureCompare32bitInstance: GeneralPurpose32bitInstance {
+        fn set_output_compare_mode(&mut self, channel: Channel, mode: OutputCompareMode);
+
+        fn enable_channel(&mut self, channel: Channel, enable: bool);
+
+        fn set_compare_value(&mut self, channel: Channel, value: u32);
+
+        fn get_max_compare_value(&self) -> u32;
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum Channel {
+    Ch1,
+    Ch2,
+    Ch3,
+    Ch4,
 }
 
+impl Channel {
+    pub fn raw(&self) -> usize {
+        match self {
+            Channel::Ch1 => 0,
+            Channel::Ch2 => 1,
+            Channel::Ch3 => 2,
+            Channel::Ch4 => 3,
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum OutputCompareMode {
+    Frozen,
+    ActiveOnMatch,
+    InactiveOnMatch,
+    Toggle,
+    ForceInactive,
+    ForceActive,
+    PwmMode1,
+    PwmMode2,
+}
+
+impl From<OutputCompareMode> for stm32_metapac::timer::vals::Ocm {
+    fn from(mode: OutputCompareMode) -> Self {
+        match mode {
+            OutputCompareMode::Frozen => stm32_metapac::timer::vals::Ocm::FROZEN,
+            OutputCompareMode::ActiveOnMatch => stm32_metapac::timer::vals::Ocm::ACTIVEONMATCH,
+            OutputCompareMode::InactiveOnMatch => stm32_metapac::timer::vals::Ocm::INACTIVEONMATCH,
+            OutputCompareMode::Toggle => stm32_metapac::timer::vals::Ocm::TOGGLE,
+            OutputCompareMode::ForceInactive => stm32_metapac::timer::vals::Ocm::FORCEINACTIVE,
+            OutputCompareMode::ForceActive => stm32_metapac::timer::vals::Ocm::FORCEACTIVE,
+            OutputCompareMode::PwmMode1 => stm32_metapac::timer::vals::Ocm::PWMMODE1,
+            OutputCompareMode::PwmMode2 => stm32_metapac::timer::vals::Ocm::PWMMODE2,
+        }
+    }
+}
+
+pub trait Basic16bitInstance: sealed::Basic16bitInstance + 'static {}
+
 pub trait GeneralPurpose16bitInstance: sealed::GeneralPurpose16bitInstance + 'static {}
 
 pub trait GeneralPurpose32bitInstance: sealed::GeneralPurpose32bitInstance + 'static {}
 
 pub trait AdvancedControlInstance: sealed::AdvancedControlInstance + 'static {}
 
-pub trait Basic16bitInstance: sealed::Basic16bitInstance + 'static {}
+pub trait CaptureCompare16bitInstance:
+    sealed::CaptureCompare16bitInstance + GeneralPurpose16bitInstance + 'static
+{
+}
+
+pub trait ComplementaryCaptureCompare16bitInstance:
+    sealed::ComplementaryCaptureCompare16bitInstance + AdvancedControlInstance + 'static
+{
+}
+
+pub trait CaptureCompare32bitInstance:
+    sealed::CaptureCompare32bitInstance + CaptureCompare16bitInstance + GeneralPurpose32bitInstance + 'static
+{
+}
+
+pin_trait!(Channel1Pin, CaptureCompare16bitInstance);
+pin_trait!(Channel1ComplementaryPin, CaptureCompare16bitInstance);
+pin_trait!(Channel2Pin, CaptureCompare16bitInstance);
+pin_trait!(Channel2ComplementaryPin, CaptureCompare16bitInstance);
+pin_trait!(Channel3Pin, CaptureCompare16bitInstance);
+pin_trait!(Channel3ComplementaryPin, CaptureCompare16bitInstance);
+pin_trait!(Channel4Pin, CaptureCompare16bitInstance);
+pin_trait!(Channel4ComplementaryPin, CaptureCompare16bitInstance);
+pin_trait!(ExternalTriggerPin, CaptureCompare16bitInstance);
+pin_trait!(BreakInputPin, CaptureCompare16bitInstance);
+pin_trait!(BreakInputComparator1Pin, CaptureCompare16bitInstance);
+pin_trait!(BreakInputComparator2Pin, CaptureCompare16bitInstance);
+pin_trait!(BreakInput2Pin, CaptureCompare16bitInstance);
+pin_trait!(BreakInput2Comparator1Pin, CaptureCompare16bitInstance);
+pin_trait!(BreakInput2Comparator2Pin, CaptureCompare16bitInstance);
 
 #[allow(unused)]
 macro_rules! impl_basic_16bit_timer {
@@ -140,33 +251,94 @@ macro_rules! impl_32bit_timer {
     };
 }
 
+#[allow(unused)]
+macro_rules! impl_compare_capable_16bit {
+    ($inst:ident) => {
+        impl sealed::CaptureCompare16bitInstance for crate::peripherals::$inst {
+            fn enable_outputs(&mut self, _enable: bool) {}
+
+            fn set_output_compare_mode(&mut self, channel: Channel, mode: OutputCompareMode) {
+                use sealed::GeneralPurpose16bitInstance;
+                let r = Self::regs_gp16();
+                let raw_channel: usize = channel.raw();
+                r.ccmr_output(raw_channel / 2)
+                    .modify(|w| w.set_ocm(raw_channel % 2, mode.into()));
+            }
+
+            fn enable_channel(&mut self, channel: Channel, enable: bool) {
+                use sealed::GeneralPurpose16bitInstance;
+                Self::regs_gp16()
+                    .ccer()
+                    .modify(|w| w.set_cce(channel.raw(), enable));
+            }
+
+            fn set_compare_value(&mut self, channel: Channel, value: u16) {
+                use sealed::GeneralPurpose16bitInstance;
+                Self::regs_gp16().ccr(channel.raw()).modify(|w| w.set_ccr(value));
+            }
+
+            fn get_max_compare_value(&self) -> u16 {
+                use sealed::GeneralPurpose16bitInstance;
+                Self::regs_gp16().arr().read().arr()
+            }
+        }
+    };
+}
+
 foreach_interrupt! {
     ($inst:ident, timer, TIM_BASIC, UP, $irq:ident) => {
         impl_basic_16bit_timer!($inst, $irq);
-
-        impl Basic16bitInstance for crate::peripherals::$inst {
-        }
+        impl Basic16bitInstance for crate::peripherals::$inst {}
     };
     ($inst:ident, timer, TIM_GP16, UP, $irq:ident) => {
         impl_basic_16bit_timer!($inst, $irq);
-
-        impl Basic16bitInstance for crate::peripherals::$inst {
-        }
+        impl_compare_capable_16bit!($inst);
+        impl Basic16bitInstance for crate::peripherals::$inst {}
+        impl GeneralPurpose16bitInstance for crate::peripherals::$inst {}
+        impl CaptureCompare16bitInstance for crate::peripherals::$inst {}
 
         impl sealed::GeneralPurpose16bitInstance for crate::peripherals::$inst {
             fn regs_gp16() -> crate::pac::timer::TimGp16 {
                 crate::pac::$inst
             }
         }
-
-        impl GeneralPurpose16bitInstance for crate::peripherals::$inst {
-        }
     };
 
     ($inst:ident, timer, TIM_GP32, UP, $irq:ident) => {
         impl_basic_16bit_timer!($inst, $irq);
+        impl_32bit_timer!($inst);
+        impl_compare_capable_16bit!($inst);
+        impl Basic16bitInstance for crate::peripherals::$inst {}
+        impl CaptureCompare16bitInstance for crate::peripherals::$inst {}
+        impl CaptureCompare32bitInstance for crate::peripherals::$inst {}
+        impl GeneralPurpose16bitInstance for crate::peripherals::$inst {}
+        impl GeneralPurpose32bitInstance for crate::peripherals::$inst {}
+
+        impl sealed::CaptureCompare32bitInstance for crate::peripherals::$inst {
+            fn set_output_compare_mode(
+                &mut self,
+                channel: Channel,
+                mode: OutputCompareMode,
+            ) {
+                use crate::timer::sealed::GeneralPurpose32bitInstance;
+                let raw_channel = channel.raw();
+                Self::regs_gp32().ccmr_output(raw_channel / 2).modify(|w| w.set_ocm(raw_channel % 2, mode.into()));
+            }
+
+            fn enable_channel(&mut self, channel: Channel, enable: bool) {
+                use crate::timer::sealed::GeneralPurpose32bitInstance;
+                Self::regs_gp32().ccer().modify(|w| w.set_cce(channel.raw(), enable));
+            }
 
-        impl Basic16bitInstance for crate::peripherals::$inst {
+            fn set_compare_value(&mut self, channel: Channel, value: u32) {
+                use crate::timer::sealed::GeneralPurpose32bitInstance;
+                Self::regs_gp32().ccr(channel.raw()).modify(|w| w.set_ccr(value));
+            }
+
+            fn get_max_compare_value(&self) -> u32 {
+                use crate::timer::sealed::GeneralPurpose32bitInstance;
+                Self::regs_gp32().arr().read().arr() as u32
+            }
         }
 
         impl sealed::GeneralPurpose16bitInstance for crate::peripherals::$inst {
@@ -174,21 +346,16 @@ foreach_interrupt! {
                 unsafe { crate::pac::timer::TimGp16::from_ptr(crate::pac::$inst.as_ptr()) }
             }
         }
-
-        impl GeneralPurpose16bitInstance for crate::peripherals::$inst {
-        }
-
-        impl_32bit_timer!($inst);
-
-        impl GeneralPurpose32bitInstance for crate::peripherals::$inst {
-        }
     };
 
     ($inst:ident, timer, TIM_ADV, UP, $irq:ident) => {
         impl_basic_16bit_timer!($inst, $irq);
 
-        impl Basic16bitInstance for crate::peripherals::$inst {
-        }
+        impl Basic16bitInstance for crate::peripherals::$inst {}
+        impl GeneralPurpose16bitInstance for crate::peripherals::$inst {}
+        impl CaptureCompare16bitInstance for crate::peripherals::$inst {}
+        impl ComplementaryCaptureCompare16bitInstance for crate::peripherals::$inst {}
+        impl AdvancedControlInstance for crate::peripherals::$inst {}
 
         impl sealed::GeneralPurpose16bitInstance for crate::peripherals::$inst {
             fn regs_gp16() -> crate::pac::timer::TimGp16 {
@@ -196,16 +363,70 @@ foreach_interrupt! {
             }
         }
 
-        impl GeneralPurpose16bitInstance for crate::peripherals::$inst {
-        }
-
         impl sealed::AdvancedControlInstance for crate::peripherals::$inst {
             fn regs_advanced() -> crate::pac::timer::TimAdv {
                 crate::pac::$inst
             }
         }
 
-        impl AdvancedControlInstance for crate::peripherals::$inst {
+        impl sealed::CaptureCompare16bitInstance for crate::peripherals::$inst {
+            fn enable_outputs(&mut self, enable: bool) {
+                use crate::timer::sealed::AdvancedControlInstance;
+                let r = Self::regs_advanced();
+                r.bdtr().modify(|w| w.set_moe(enable));
+            }
+
+            fn set_output_compare_mode(
+                &mut self,
+                channel: Channel,
+                mode: OutputCompareMode,
+            ) {
+                use crate::timer::sealed::AdvancedControlInstance;
+                let r = Self::regs_advanced();
+                let raw_channel: usize = channel.raw();
+                r.ccmr_output(raw_channel / 2)
+                    .modify(|w| w.set_ocm(raw_channel % 2, mode.into()));
+            }
+
+            fn enable_channel(&mut self, channel: Channel, enable: bool) {
+                use crate::timer::sealed::AdvancedControlInstance;
+                Self::regs_advanced()
+                    .ccer()
+                    .modify(|w| w.set_cce(channel.raw(), enable));
+            }
+
+            fn set_compare_value(&mut self, channel: Channel, value: u16) {
+                use crate::timer::sealed::AdvancedControlInstance;
+                Self::regs_advanced()
+                    .ccr(channel.raw())
+                    .modify(|w| w.set_ccr(value));
+            }
+
+            fn get_max_compare_value(&self) -> u16 {
+                use crate::timer::sealed::AdvancedControlInstance;
+                Self::regs_advanced().arr().read().arr()
+            }
+        }
+
+        impl sealed::ComplementaryCaptureCompare16bitInstance for crate::peripherals::$inst {
+            fn set_dead_time_clock_division(&mut self, value: vals::Ckd) {
+                use crate::timer::sealed::AdvancedControlInstance;
+                Self::regs_advanced().cr1().modify(|w| w.set_ckd(value));
+            }
+
+            fn set_dead_time_value(&mut self, value: u8) {
+                use crate::timer::sealed::AdvancedControlInstance;
+                Self::regs_advanced().bdtr().modify(|w| w.set_dtg(value));
+            }
+
+            fn enable_complementary_channel(&mut self, channel: Channel, enable: bool) {
+                use crate::timer::sealed::AdvancedControlInstance;
+                Self::regs_advanced()
+                    .ccer()
+                    .modify(|w| w.set_ccne(channel.raw(), enable));
+            }
         }
+
+
     };
 }
diff --git a/embassy-stm32/src/timer/simple_pwm.rs b/embassy-stm32/src/timer/simple_pwm.rs
new file mode 100644
index 000000000..514796930
--- /dev/null
+++ b/embassy-stm32/src/timer/simple_pwm.rs
@@ -0,0 +1,107 @@
+use core::marker::PhantomData;
+
+use embassy_hal_internal::{into_ref, PeripheralRef};
+
+use super::*;
+#[allow(unused_imports)]
+use crate::gpio::sealed::{AFType, Pin};
+use crate::gpio::AnyPin;
+use crate::time::Hertz;
+use crate::Peripheral;
+
+pub struct Ch1;
+pub struct Ch2;
+pub struct Ch3;
+pub struct Ch4;
+
+pub struct PwmPin<'d, Perip, Channel> {
+    _pin: PeripheralRef<'d, AnyPin>,
+    phantom: PhantomData<(Perip, Channel)>,
+}
+
+macro_rules! channel_impl {
+    ($new_chx:ident, $channel:ident, $pin_trait:ident) => {
+        impl<'d, Perip: CaptureCompare16bitInstance> PwmPin<'d, Perip, $channel> {
+            pub fn $new_chx(pin: impl Peripheral<P = impl $pin_trait<Perip>> + 'd) -> Self {
+                into_ref!(pin);
+                critical_section::with(|_| {
+                    pin.set_low();
+                    pin.set_as_af(pin.af_num(), AFType::OutputPushPull);
+                    #[cfg(gpio_v2)]
+                    pin.set_speed(crate::gpio::Speed::VeryHigh);
+                });
+                PwmPin {
+                    _pin: pin.map_into(),
+                    phantom: PhantomData,
+                }
+            }
+        }
+    };
+}
+
+channel_impl!(new_ch1, Ch1, Channel1Pin);
+channel_impl!(new_ch2, Ch2, Channel2Pin);
+channel_impl!(new_ch3, Ch3, Channel3Pin);
+channel_impl!(new_ch4, Ch4, Channel4Pin);
+
+pub struct SimplePwm<'d, T> {
+    inner: PeripheralRef<'d, T>,
+}
+
+impl<'d, T: CaptureCompare16bitInstance> SimplePwm<'d, T> {
+    pub fn new(
+        tim: impl Peripheral<P = T> + 'd,
+        _ch1: Option<PwmPin<'d, T, Ch1>>,
+        _ch2: Option<PwmPin<'d, T, Ch2>>,
+        _ch3: Option<PwmPin<'d, T, Ch3>>,
+        _ch4: Option<PwmPin<'d, T, Ch4>>,
+        freq: Hertz,
+    ) -> Self {
+        Self::new_inner(tim, freq)
+    }
+
+    fn new_inner(tim: impl Peripheral<P = T> + 'd, freq: Hertz) -> Self {
+        into_ref!(tim);
+
+        T::enable();
+        <T as crate::rcc::sealed::RccPeripheral>::reset();
+
+        let mut this = Self { inner: tim };
+
+        this.inner.set_frequency(freq);
+        this.inner.start();
+
+        this.inner.enable_outputs(true);
+
+        this.inner
+            .set_output_compare_mode(Channel::Ch1, OutputCompareMode::PwmMode1);
+        this.inner
+            .set_output_compare_mode(Channel::Ch2, OutputCompareMode::PwmMode1);
+        this.inner
+            .set_output_compare_mode(Channel::Ch3, OutputCompareMode::PwmMode1);
+        this.inner
+            .set_output_compare_mode(Channel::Ch4, OutputCompareMode::PwmMode1);
+        this
+    }
+
+    pub fn enable(&mut self, channel: Channel) {
+        self.inner.enable_channel(channel, true);
+    }
+
+    pub fn disable(&mut self, channel: Channel) {
+        self.inner.enable_channel(channel, false);
+    }
+
+    pub fn set_freq(&mut self, freq: Hertz) {
+        self.inner.set_frequency(freq);
+    }
+
+    pub fn get_max_duty(&self) -> u16 {
+        self.inner.get_max_compare_value()
+    }
+
+    pub fn set_duty(&mut self, channel: Channel, duty: u16) {
+        assert!(duty < self.get_max_duty());
+        self.inner.set_compare_value(channel, duty)
+    }
+}
diff --git a/examples/stm32f4/src/bin/pwm.rs b/examples/stm32f4/src/bin/pwm.rs
index 7c5902052..4f130c26b 100644
--- a/examples/stm32f4/src/bin/pwm.rs
+++ b/examples/stm32f4/src/bin/pwm.rs
@@ -4,9 +4,9 @@
 
 use defmt::*;
 use embassy_executor::Spawner;
-use embassy_stm32::pwm::simple_pwm::{PwmPin, SimplePwm};
-use embassy_stm32::pwm::Channel;
 use embassy_stm32::time::khz;
+use embassy_stm32::timer::simple_pwm::{PwmPin, SimplePwm};
+use embassy_stm32::timer::Channel;
 use embassy_time::{Duration, Timer};
 use {defmt_rtt as _, panic_probe as _};
 
diff --git a/examples/stm32f4/src/bin/pwm_complementary.rs b/examples/stm32f4/src/bin/pwm_complementary.rs
index a8a68ed6e..8cc2a4117 100644
--- a/examples/stm32f4/src/bin/pwm_complementary.rs
+++ b/examples/stm32f4/src/bin/pwm_complementary.rs
@@ -4,10 +4,10 @@
 
 use defmt::*;
 use embassy_executor::Spawner;
-use embassy_stm32::pwm::complementary_pwm::{ComplementaryPwm, ComplementaryPwmPin};
-use embassy_stm32::pwm::simple_pwm::PwmPin;
-use embassy_stm32::pwm::Channel;
 use embassy_stm32::time::khz;
+use embassy_stm32::timer::complementary_pwm::{ComplementaryPwm, ComplementaryPwmPin};
+use embassy_stm32::timer::simple_pwm::PwmPin;
+use embassy_stm32::timer::Channel;
 use embassy_time::{Duration, Timer};
 use {defmt_rtt as _, panic_probe as _};
 
diff --git a/examples/stm32g4/src/bin/pwm.rs b/examples/stm32g4/src/bin/pwm.rs
index 8f7842ed7..b5a9b9952 100644
--- a/examples/stm32g4/src/bin/pwm.rs
+++ b/examples/stm32g4/src/bin/pwm.rs
@@ -4,9 +4,9 @@
 
 use defmt::*;
 use embassy_executor::Spawner;
-use embassy_stm32::pwm::simple_pwm::{PwmPin, SimplePwm};
-use embassy_stm32::pwm::Channel;
 use embassy_stm32::time::khz;
+use embassy_stm32::timer::simple_pwm::{PwmPin, SimplePwm};
+use embassy_stm32::timer::Channel;
 use embassy_time::{Duration, Timer};
 use {defmt_rtt as _, panic_probe as _};
 
diff --git a/examples/stm32h7/src/bin/low_level_timer_api.rs b/examples/stm32h7/src/bin/low_level_timer_api.rs
index d360df085..45b0872b5 100644
--- a/examples/stm32h7/src/bin/low_level_timer_api.rs
+++ b/examples/stm32h7/src/bin/low_level_timer_api.rs
@@ -6,8 +6,8 @@ use defmt::*;
 use embassy_executor::Spawner;
 use embassy_stm32::gpio::low_level::AFType;
 use embassy_stm32::gpio::Speed;
-use embassy_stm32::pwm::*;
 use embassy_stm32::time::{khz, mhz, Hertz};
+use embassy_stm32::timer::*;
 use embassy_stm32::{into_ref, Config, Peripheral, PeripheralRef};
 use embassy_time::{Duration, Timer};
 use {defmt_rtt as _, panic_probe as _};
diff --git a/examples/stm32h7/src/bin/pwm.rs b/examples/stm32h7/src/bin/pwm.rs
index c5c0dd290..adf2ea9ce 100644
--- a/examples/stm32h7/src/bin/pwm.rs
+++ b/examples/stm32h7/src/bin/pwm.rs
@@ -4,9 +4,9 @@
 
 use defmt::*;
 use embassy_executor::Spawner;
-use embassy_stm32::pwm::simple_pwm::{PwmPin, SimplePwm};
-use embassy_stm32::pwm::Channel;
 use embassy_stm32::time::{khz, mhz};
+use embassy_stm32::timer::simple_pwm::{PwmPin, SimplePwm};
+use embassy_stm32::timer::Channel;
 use embassy_stm32::Config;
 use embassy_time::{Duration, Timer};
 use {defmt_rtt as _, panic_probe as _};
-- 
cgit 


From 973b152375d8ace2c247c602d39aea7b01fb636e Mon Sep 17 00:00:00 2001
From: Ruben De Smet <ruben.de.smet@rubdos.be>
Date: Fri, 28 Jul 2023 15:41:45 +0200
Subject: CI: ethernet and ieee802.15.4 should be able to co-exist

---
 ci.sh | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/ci.sh b/ci.sh
index 376cc8f44..19628b50e 100755
--- a/ci.sh
+++ b/ci.sh
@@ -27,6 +27,8 @@ cargo batch  \
     --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,dhcpv4,medium-ethernet,nightly \
     --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,dhcpv4,medium-ethernet,unstable-traits,nightly \
     --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv6,medium-ethernet \
+    --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv6,medium-ieee802154 \
+    --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv6,medium-ethernet,medium-ieee802154 \
     --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv6,medium-ethernet,unstable-traits \
     --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv6,medium-ethernet,nightly \
     --- build --release --manifest-path embassy-net/Cargo.toml --target thumbv7em-none-eabi --features defmt,tcp,udp,dns,proto-ipv6,medium-ethernet,unstable-traits,nightly \
-- 
cgit 


From b57ba84da5f287d7c2d4899c485b2732ff2745a2 Mon Sep 17 00:00:00 2001
From: JuliDi <20155974+JuliDi@users.noreply.github.com>
Date: Fri, 28 Jul 2023 16:34:20 +0200
Subject: add dac-dma example for h7, remove memory.x

---
 examples/stm32h7/Cargo.toml         |   2 +-
 examples/stm32h7/memory.x           |   5 --
 examples/stm32h7/src/bin/dac_dma.rs | 140 ++++++++++++++++++++++++++++++++++++
 3 files changed, 141 insertions(+), 6 deletions(-)
 delete mode 100644 examples/stm32h7/memory.x
 create mode 100644 examples/stm32h7/src/bin/dac_dma.rs

diff --git a/examples/stm32h7/Cargo.toml b/examples/stm32h7/Cargo.toml
index 2d82c0d0d..3c1232e67 100644
--- a/examples/stm32h7/Cargo.toml
+++ b/examples/stm32h7/Cargo.toml
@@ -6,7 +6,7 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 # Change stm32h743bi to your chip name, if necessary.
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32h743bi", "time-driver-any", "exti", "unstable-pac", "unstable-traits"] }
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32h743bi", "time-driver-any", "exti", "memory-x", "unstable-pac", "unstable-traits"] }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "unstable-traits", "tick-hz-32_768"] }
diff --git a/examples/stm32h7/memory.x b/examples/stm32h7/memory.x
deleted file mode 100644
index 026b14b9b..000000000
--- a/examples/stm32h7/memory.x
+++ /dev/null
@@ -1,5 +0,0 @@
-MEMORY
-{
-    FLASH : ORIGIN = 0x8000000, LENGTH = 1024K
-    RAM : ORIGIN = 0x24000000, LENGTH = 384K
-}
diff --git a/examples/stm32h7/src/bin/dac_dma.rs b/examples/stm32h7/src/bin/dac_dma.rs
new file mode 100644
index 000000000..a9cb5d1ed
--- /dev/null
+++ b/examples/stm32h7/src/bin/dac_dma.rs
@@ -0,0 +1,140 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_stm32::dac::{DacChannel, ValueArray};
+use embassy_stm32::pac::timer::vals::{Mms, Opm};
+use embassy_stm32::peripherals::{TIM6, TIM7};
+use embassy_stm32::rcc::low_level::RccPeripheral;
+use embassy_stm32::time::{mhz, Hertz};
+use embassy_stm32::timer::low_level::Basic16bitInstance;
+use micromath::F32Ext;
+use {defmt_rtt as _, panic_probe as _};
+
+pub type Dac1Type =
+    embassy_stm32::dac::DacCh1<'static, embassy_stm32::peripherals::DAC1, embassy_stm32::peripherals::DMA1_CH3>;
+
+pub type Dac2Type =
+    embassy_stm32::dac::DacCh2<'static, embassy_stm32::peripherals::DAC1, embassy_stm32::peripherals::DMA1_CH4>;
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let mut config = embassy_stm32::Config::default();
+    config.rcc.sys_ck = Some(mhz(400));
+    config.rcc.hclk = Some(mhz(100));
+    config.rcc.pll1.q_ck = Some(mhz(100));
+
+    // Initialize the board and obtain a Peripherals instance
+    let p: embassy_stm32::Peripherals = embassy_stm32::init(config);
+
+    // Obtain two independent channels (p.DAC1 can only be consumed once, though!)
+    let (dac_ch1, dac_ch2) = embassy_stm32::dac::Dac::new(p.DAC1, p.DMA1_CH3, p.DMA1_CH4, p.PA4, p.PA5).split();
+
+    spawner.spawn(dac_task1(dac_ch1)).ok();
+    spawner.spawn(dac_task2(dac_ch2)).ok();
+}
+
+#[embassy_executor::task]
+async fn dac_task1(mut dac: Dac1Type) {
+    let data: &[u8; 256] = &calculate_array::<256>();
+
+    info!("TIM6 frequency is {}", TIM6::frequency());
+    const FREQUENCY: Hertz = Hertz::hz(200);
+
+    // Compute the reload value such that we obtain the FREQUENCY for the sine
+    let reload: u32 = (TIM6::frequency().0 / FREQUENCY.0) / data.len() as u32;
+
+    // Depends on your clock and on the specific chip used, you may need higher or lower values here
+    if reload < 10 {
+        error!("Reload value {} below threshold!", reload);
+    }
+
+    dac.select_trigger(embassy_stm32::dac::Ch1Trigger::Tim6).unwrap();
+    dac.enable_channel().unwrap();
+
+    TIM6::enable();
+    TIM6::regs().arr().modify(|w| w.set_arr(reload as u16 - 1));
+    TIM6::regs().cr2().modify(|w| w.set_mms(Mms::UPDATE));
+    TIM6::regs().cr1().modify(|w| {
+        w.set_opm(Opm::DISABLED);
+        w.set_cen(true);
+    });
+
+    debug!(
+        "TIM6 Frequency {}, Target Frequency {}, Reload {}, Reload as u16 {}, Samples {}",
+        TIM6::frequency(),
+        FREQUENCY,
+        reload,
+        reload as u16,
+        data.len()
+    );
+
+    // Loop technically not necessary if DMA circular mode is enabled
+    loop {
+        info!("Loop DAC1");
+        if let Err(e) = dac.write(ValueArray::Bit8(data), true).await {
+            error!("Could not write to dac: {}", e);
+        }
+    }
+}
+
+#[embassy_executor::task]
+async fn dac_task2(mut dac: Dac2Type) {
+    let data: &[u8; 256] = &calculate_array::<256>();
+
+    info!("TIM7 frequency is {}", TIM7::frequency());
+
+    const FREQUENCY: Hertz = Hertz::hz(600);
+    let reload: u32 = (TIM7::frequency().0 / FREQUENCY.0) / data.len() as u32;
+
+    if reload < 10 {
+        error!("Reload value {} below threshold!", reload);
+    }
+
+    TIM7::enable();
+    TIM7::regs().arr().modify(|w| w.set_arr(reload as u16 - 1));
+    TIM7::regs().cr2().modify(|w| w.set_mms(Mms::UPDATE));
+    TIM7::regs().cr1().modify(|w| {
+        w.set_opm(Opm::DISABLED);
+        w.set_cen(true);
+    });
+
+    dac.select_trigger(embassy_stm32::dac::Ch2Trigger::Tim7).unwrap();
+
+    debug!(
+        "TIM7 Frequency {}, Target Frequency {}, Reload {}, Reload as u16 {}, Samples {}",
+        TIM7::frequency(),
+        FREQUENCY,
+        reload,
+        reload as u16,
+        data.len()
+    );
+
+    if let Err(e) = dac.write(ValueArray::Bit8(data), true).await {
+        error!("Could not write to dac: {}", e);
+    }
+}
+
+fn to_sine_wave(v: u8) -> u8 {
+    if v >= 128 {
+        // top half
+        let r = 3.14 * ((v - 128) as f32 / 128.0);
+        (r.sin() * 128.0 + 127.0) as u8
+    } else {
+        // bottom half
+        let r = 3.14 + 3.14 * (v as f32 / 128.0);
+        (r.sin() * 128.0 + 127.0) as u8
+    }
+}
+
+fn calculate_array<const N: usize>() -> [u8; N] {
+    let mut res = [0; N];
+    let mut i = 0;
+    while i < N {
+        res[i] = to_sine_wave(i as u8);
+        i += 1;
+    }
+    res
+}
-- 
cgit 


From 937a63ce28beee87ae78756ecf8377f465b8cf9d Mon Sep 17 00:00:00 2001
From: JuliDi <20155974+JuliDi@users.noreply.github.com>
Date: Fri, 28 Jul 2023 16:38:02 +0200
Subject: remove memory.x files for other stm32 examples

---
 examples/stm32f7/Cargo.toml         |  2 +-
 examples/stm32f7/build.rs           | 40 +------------------------------------
 examples/stm32f7/memory.x           | 12 -----------
 examples/stm32h5/Cargo.toml         |  2 +-
 examples/stm32h5/memory.x           |  5 -----
 examples/stm32h7/.cargo/config.toml |  2 +-
 examples/stm32l4/Cargo.toml         |  2 +-
 examples/stm32l4/build.rs           | 30 ----------------------------
 examples/stm32l4/memory.x           |  7 -------
 9 files changed, 5 insertions(+), 97 deletions(-)
 delete mode 100644 examples/stm32f7/memory.x
 delete mode 100644 examples/stm32h5/memory.x
 delete mode 100644 examples/stm32l4/memory.x

diff --git a/examples/stm32f7/Cargo.toml b/examples/stm32f7/Cargo.toml
index a6964c7bc..a379cbbe3 100644
--- a/examples/stm32f7/Cargo.toml
+++ b/examples/stm32f7/Cargo.toml
@@ -6,7 +6,7 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 # Change stm32f767zi to your chip name, if necessary.
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32f767zi", "unstable-pac", "time-driver-any", "exti"]  }
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32f767zi", "memory-x", "unstable-pac", "time-driver-any", "exti"]  }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
diff --git a/examples/stm32f7/build.rs b/examples/stm32f7/build.rs
index 2b5d412a9..8cd32d7ed 100644
--- a/examples/stm32f7/build.rs
+++ b/examples/stm32f7/build.rs
@@ -1,43 +1,5 @@
-//! adapted from https://github.com/stm32-rs/stm32f7xx-hal/blob/master/build.rs
-use std::fs::File;
-use std::io::prelude::*;
-use std::path::PathBuf;
-use std::{env, io};
-
-#[derive(Debug)]
-enum Error {
-    Env(env::VarError),
-    Io(io::Error),
-}
-
-impl From<env::VarError> for Error {
-    fn from(error: env::VarError) -> Self {
-        Self::Env(error)
-    }
-}
-
-impl From<io::Error> for Error {
-    fn from(error: io::Error) -> Self {
-        Self::Io(error)
-    }
-}
-
-fn main() -> Result<(), Error> {
-    println!("cargo:rerun-if-changed=build.rs");
-    println!("cargo:rerun-if-changed=memory.x");
-
-    let out_dir = env::var("OUT_DIR")?;
-    let out_dir = PathBuf::from(out_dir);
-
-    let memory_x = include_bytes!("memory.x").as_ref();
-    File::create(out_dir.join("memory.x"))?.write_all(memory_x)?;
-
-    // Tell Cargo where to find the file.
-    println!("cargo:rustc-link-search={}", out_dir.display());
-
+fn main() {
     println!("cargo:rustc-link-arg-bins=--nmagic");
     println!("cargo:rustc-link-arg-bins=-Tlink.x");
     println!("cargo:rustc-link-arg-bins=-Tdefmt.x");
-
-    Ok(())
 }
diff --git a/examples/stm32f7/memory.x b/examples/stm32f7/memory.x
deleted file mode 100644
index 899f7a4b8..000000000
--- a/examples/stm32f7/memory.x
+++ /dev/null
@@ -1,12 +0,0 @@
-/* For STM32F765,767,768,769,777,778,779 devices */
-MEMORY
-{
-  /* NOTE K = KiBi = 1024 bytes */
-  FLASH : ORIGIN = 0x08000000, LENGTH = 2M
-  RAM : ORIGIN = 0x20000000, LENGTH = 368K + 16K
-}
-
-/* This is where the call stack will be allocated. */
-/* The stack is of the full descending type. */
-/* NOTE Do NOT modify `_stack_start` unless you know what you are doing */
-_stack_start = ORIGIN(RAM) + LENGTH(RAM);
diff --git a/examples/stm32h5/Cargo.toml b/examples/stm32h5/Cargo.toml
index aebc795c1..51d3bad1f 100644
--- a/examples/stm32h5/Cargo.toml
+++ b/examples/stm32h5/Cargo.toml
@@ -6,7 +6,7 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 # Change stm32h563zi to your chip name, if necessary.
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32h563zi", "time-driver-any", "exti", "unstable-pac", "unstable-traits"] }
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32h563zi", "memory-x", "time-driver-any", "exti", "unstable-pac", "unstable-traits"] }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "unstable-traits", "tick-hz-32_768"] }
diff --git a/examples/stm32h5/memory.x b/examples/stm32h5/memory.x
deleted file mode 100644
index 456061509..000000000
--- a/examples/stm32h5/memory.x
+++ /dev/null
@@ -1,5 +0,0 @@
-MEMORY
-{
-    FLASH : ORIGIN = 0x08000000, LENGTH = 0x200000
-    RAM   : ORIGIN = 0x20000000, LENGTH =  0x50000
-}
diff --git a/examples/stm32h7/.cargo/config.toml b/examples/stm32h7/.cargo/config.toml
index 5f680dbce..4160bf855 100644
--- a/examples/stm32h7/.cargo/config.toml
+++ b/examples/stm32h7/.cargo/config.toml
@@ -1,5 +1,5 @@
 [target.thumbv7em-none-eabihf]
-runner = 'probe-rs run --chip STM32H743ZITx'
+runner = 'probe-rs run --chip STM32H7A3ZITxQ'
 
 [build]
 target = "thumbv7em-none-eabihf" # Cortex-M4F and Cortex-M7F (with FPU)
diff --git a/examples/stm32l4/Cargo.toml b/examples/stm32l4/Cargo.toml
index 0f770e2f0..3b27d8e81 100644
--- a/examples/stm32l4/Cargo.toml
+++ b/examples/stm32l4/Cargo.toml
@@ -6,7 +6,7 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 # Change stm32l4s5vi to your chip name, if necessary.
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "unstable-pac", "stm32l4s5vi", "time-driver-any", "exti", "unstable-traits", "chrono"]  }
+embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "unstable-pac", "stm32l4s5vi", "memory-x", "time-driver-any", "exti", "unstable-traits", "chrono"]  }
 embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.2.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
 embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
diff --git a/examples/stm32l4/build.rs b/examples/stm32l4/build.rs
index 30691aa97..8cd32d7ed 100644
--- a/examples/stm32l4/build.rs
+++ b/examples/stm32l4/build.rs
@@ -1,34 +1,4 @@
-//! This build script copies the `memory.x` file from the crate root into
-//! a directory where the linker can always find it at build time.
-//! For many projects this is optional, as the linker always searches the
-//! project root directory -- wherever `Cargo.toml` is. However, if you
-//! are using a workspace or have a more complicated build setup, this
-//! build script becomes required. Additionally, by requesting that
-//! Cargo re-run the build script whenever `memory.x` is changed,
-//! updating `memory.x` ensures a rebuild of the application with the
-//! new memory settings.
-
-use std::env;
-use std::fs::File;
-use std::io::Write;
-use std::path::PathBuf;
-
 fn main() {
-    // Put `memory.x` in our output directory and ensure it's
-    // on the linker search path.
-    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
-    File::create(out.join("memory.x"))
-        .unwrap()
-        .write_all(include_bytes!("memory.x"))
-        .unwrap();
-    println!("cargo:rustc-link-search={}", out.display());
-
-    // By default, Cargo will re-run a build script whenever
-    // any file in the project changes. By specifying `memory.x`
-    // here, we ensure the build script is only re-run when
-    // `memory.x` is changed.
-    println!("cargo:rerun-if-changed=memory.x");
-
     println!("cargo:rustc-link-arg-bins=--nmagic");
     println!("cargo:rustc-link-arg-bins=-Tlink.x");
     println!("cargo:rustc-link-arg-bins=-Tdefmt.x");
diff --git a/examples/stm32l4/memory.x b/examples/stm32l4/memory.x
deleted file mode 100644
index eb87d1b54..000000000
--- a/examples/stm32l4/memory.x
+++ /dev/null
@@ -1,7 +0,0 @@
-MEMORY
-{
-  /* NOTE 1 K = 1 KiBi = 1024 bytes */
-  /* These values correspond to the STM32L4S5 */
-  FLASH : ORIGIN = 0x08000000, LENGTH = 1024K
-  RAM : ORIGIN = 0x20000000, LENGTH = 128K
-}
-- 
cgit 


From 6dd2fc59418c9d96f049f184694ddaf4845a4425 Mon Sep 17 00:00:00 2001
From: JuliDi <20155974+JuliDi@users.noreply.github.com>
Date: Fri, 28 Jul 2023 16:59:13 +0200
Subject: add document-features

---
 embassy-stm32/Cargo.toml | 54 ++++++++++++++++++++++++++++++++++--------------
 embassy-stm32/src/lib.rs |  3 +++
 2 files changed, 42 insertions(+), 15 deletions(-)

diff --git a/embassy-stm32/Cargo.toml b/embassy-stm32/Cargo.toml
index 6f34c7416..ba279f795 100644
--- a/embassy-stm32/Cargo.toml
+++ b/embassy-stm32/Cargo.toml
@@ -67,6 +67,7 @@ cfg-if = "1.0.0"
 embedded-io = { version = "0.4.0", features = ["async"], optional = true }
 chrono = { version = "^0.4", default-features = false, optional = true}
 bit_field = "0.10.2"
+document-features = "0.2.7"
 
 [dev-dependencies]
 critical-section = { version = "1.1", features = ["std"] }
@@ -78,40 +79,63 @@ stm32-metapac = { version = "13", default-features = false, features = ["metadat
 
 [features]
 default = ["rt"]
+
+## Enable `stm32-metapac`'s `rt` feature
 rt = ["stm32-metapac/rt"]
 
+## Use [`defmt`](https://docs.rs/defmt/latest/defmt/) for logging
 defmt = ["dep:defmt", "bxcan/unstable-defmt", "embassy-sync/defmt", "embassy-embedded-hal/defmt", "embassy-hal-internal/defmt", "embedded-io?/defmt", "embassy-usb-driver?/defmt", "embassy-net-driver/defmt"]
-memory-x = ["stm32-metapac/memory-x"]
+
 exti = []
 
-# Enables additional driver features that depend on embassy-time
+## Automatically generate `memory.x` file using [`stm32-metapac`](https://docs.rs/stm32-metapac/)
+memory-x = ["stm32-metapac/memory-x"]
+
+## Enable nightly-only features
+nightly = ["embedded-hal-1", "embedded-hal-async", "embedded-storage-async", "dep:embedded-io", "dep:embassy-usb-driver", "embassy-embedded-hal/nightly"]
+
+## Re-export stm32-metapac at `embassy_stm32::pac`.
+## This is unstable because semver-minor (non-breaking) releases of embassy-stm32 may major-bump (breaking) the stm32-metapac version.
+## If this is an issue for you, you're encouraged to directly depend on a fixed version of the PAC.
+## There are no plans to make this stable.
+unstable-pac = []
+
+## Implement embedded-hal 1.0 alpha traits.
+## Implement embedded-hal-async traits if `nightly` is set as well.
+unstable-traits = ["embedded-hal-1", "dep:embedded-hal-nb"]
+
+#! ## Time
+
+## Enables additional driver features that depend on embassy-time
 time = ["dep:embassy-time"]
 
 # Features starting with `_` are for internal use only. They're not intended
 # to be enabled by other crates, and are not covered by semver guarantees.
 _time-driver = ["time"]
+
+## Use any time driver
 time-driver-any = ["_time-driver"]
+## Use TIM2 as time driver
 time-driver-tim2 = ["_time-driver"]
+## Use TIM3 as time driver
 time-driver-tim3 = ["_time-driver"]
+## Use TIM4 as time driver
 time-driver-tim4 = ["_time-driver"]
+## Use TIM5 as time driver
 time-driver-tim5 = ["_time-driver"]
+## Use TIM12 as time driver
 time-driver-tim12 = ["_time-driver"]
+## Use TIM15 as time driver
 time-driver-tim15 = ["_time-driver"]
 
-# Enable nightly-only features
-nightly = ["embedded-hal-1", "embedded-hal-async", "embedded-storage-async", "dep:embedded-io", "dep:embassy-usb-driver", "embassy-embedded-hal/nightly"]
-
-# Reexport stm32-metapac at `embassy_stm32::pac`.
-# This is unstable because semver-minor (non-breaking) releases of embassy-stm32 may major-bump (breaking) the stm32-metapac version.
-# If this is an issue for you, you're encouraged to directly depend on a fixed version of the PAC.
-# There are no plans to make this stable.
-unstable-pac = []
 
-# Implement embedded-hal 1.0 alpha traits.
-# Implement embedded-hal-async traits if `nightly` is set as well.
-unstable-traits = ["embedded-hal-1", "dep:embedded-hal-nb"]
+#! ## Chip-selection features
+#! Select your chip by specifying the model as a feature, e.g. `stm32c011d6`.
+#! Check the `Cargo.toml` for the latest list of supported chips.
+#!
+#! **Important:** Do not forget to adapt the target chip in your toolchain,
+#! e.g. in `.cargo/config.toml`.
 
-# Chip-selection features
 stm32c011d6 = [ "stm32-metapac/stm32c011d6" ]
 stm32c011f4 = [ "stm32-metapac/stm32c011f4" ]
 stm32c011f6 = [ "stm32-metapac/stm32c011f6" ]
@@ -1445,4 +1469,4 @@ stm32wle5cb = [ "stm32-metapac/stm32wle5cb" ]
 stm32wle5cc = [ "stm32-metapac/stm32wle5cc" ]
 stm32wle5j8 = [ "stm32-metapac/stm32wle5j8" ]
 stm32wle5jb = [ "stm32-metapac/stm32wle5jb" ]
-stm32wle5jc = [ "stm32-metapac/stm32wle5jc" ]
\ No newline at end of file
+stm32wle5jc = [ "stm32-metapac/stm32wle5jc" ]
diff --git a/embassy-stm32/src/lib.rs b/embassy-stm32/src/lib.rs
index bb2ef2fc0..9e67596b0 100644
--- a/embassy-stm32/src/lib.rs
+++ b/embassy-stm32/src/lib.rs
@@ -1,6 +1,9 @@
 #![cfg_attr(not(test), no_std)]
 #![cfg_attr(feature = "nightly", feature(async_fn_in_trait, impl_trait_projections))]
 
+//! ## Feature flags
+#![doc = document_features::document_features!(feature_label = r#"<span class="stab portability"><code>{feature}</code></span>"#)]
+
 // This must go FIRST so that all the other modules see its macros.
 pub mod fmt;
 include!(concat!(env!("OUT_DIR"), "/_macros.rs"));
-- 
cgit 


From cbc8871a0bb40eb5fec82e7c27ed4c0127844c3c Mon Sep 17 00:00:00 2001
From: pennae <github@quasiparticle.net>
Date: Fri, 28 Jul 2023 18:45:57 +0200
Subject: rp: relocate programs implicitly during load

this removed the RelocatedProgram construction step from pio uses.
there's not all that much to be said for the extra step because the
origin can be set on the input program itself, and the remaining
information exposed by RelocatedProgram can be exposed from
LoadedProgram instead (even though it's already available on the pio_asm
programs, albeit perhaps less convenient). we do lose access to the
relocated instruction iterator, but we also cannot think of anything
this iterator would actually be useful for outside of program loading.
---
 cyw43-pio/src/lib.rs               |   8 +--
 embassy-rp/src/lib.rs              |   2 +-
 embassy-rp/src/pio.rs              |  60 +++++++++++++++---
 embassy-rp/src/relocate.rs         |   5 --
 examples/rp/src/bin/pio_async.rs   |  10 +--
 examples/rp/src/bin/pio_dma.rs     |   4 +-
 examples/rp/src/bin/pio_hd44780.rs |   7 +--
 examples/rp/src/bin/pio_uart.rs    |  41 +++---------
 examples/rp/src/bin/pio_ws2812.rs  |   4 +-
 tests/rp/src/bin/pio_irq.rs        |   4 +-
 tests/rp/src/bin/pio_multi_load.rs | 126 +++++++++++++++++++++++++++++++++++++
 11 files changed, 200 insertions(+), 71 deletions(-)
 create mode 100644 tests/rp/src/bin/pio_multi_load.rs

diff --git a/cyw43-pio/src/lib.rs b/cyw43-pio/src/lib.rs
index dca30c74d..830a5b44a 100644
--- a/cyw43-pio/src/lib.rs
+++ b/cyw43-pio/src/lib.rs
@@ -8,7 +8,6 @@ use cyw43::SpiBusCyw43;
 use embassy_rp::dma::Channel;
 use embassy_rp::gpio::{Drive, Level, Output, Pin, Pull, SlewRate};
 use embassy_rp::pio::{Common, Config, Direction, Instance, Irq, PioPin, ShiftDirection, StateMachine};
-use embassy_rp::relocate::RelocatedProgram;
 use embassy_rp::{pio_instr_util, Peripheral, PeripheralRef};
 use fixed::FixedU32;
 use pio_proc::pio_asm;
@@ -88,8 +87,6 @@ where
             ".wrap"
         );
 
-        let relocated = RelocatedProgram::new(&program.program);
-
         let mut pin_io: embassy_rp::pio::Pin<PIO> = common.make_pio_pin(dio);
         pin_io.set_pull(Pull::None);
         pin_io.set_schmitt(true);
@@ -102,7 +99,8 @@ where
         pin_clk.set_slew_rate(SlewRate::Fast);
 
         let mut cfg = Config::default();
-        cfg.use_program(&common.load_program(&relocated), &[&pin_clk]);
+        let loaded_program = common.load_program(&program.program);
+        cfg.use_program(&loaded_program, &[&pin_clk]);
         cfg.set_out_pins(&[&pin_io]);
         cfg.set_in_pins(&[&pin_io]);
         cfg.set_set_pins(&[&pin_io]);
@@ -142,7 +140,7 @@ where
             sm,
             irq,
             dma: dma.into_ref(),
-            wrap_target: relocated.wrap().target,
+            wrap_target: loaded_program.wrap.target,
         }
     }
 
diff --git a/embassy-rp/src/lib.rs b/embassy-rp/src/lib.rs
index ebec9fec6..45156458d 100644
--- a/embassy-rp/src/lib.rs
+++ b/embassy-rp/src/lib.rs
@@ -33,7 +33,7 @@ pub mod watchdog;
 // TODO: move `pio_instr_util` and `relocate` to inside `pio`
 pub mod pio;
 pub mod pio_instr_util;
-pub mod relocate;
+pub(crate) mod relocate;
 
 // Reexports
 pub use embassy_hal_internal::{into_ref, Peripheral, PeripheralRef};
diff --git a/embassy-rp/src/pio.rs b/embassy-rp/src/pio.rs
index 464988b27..3de398af7 100644
--- a/embassy-rp/src/pio.rs
+++ b/embassy-rp/src/pio.rs
@@ -11,7 +11,7 @@ use fixed::types::extra::U8;
 use fixed::FixedU32;
 use pac::io::vals::Gpio0ctrlFuncsel;
 use pac::pio::vals::SmExecctrlStatusSel;
-use pio::{SideSet, Wrap};
+use pio::{Program, SideSet, Wrap};
 
 use crate::dma::{Channel, Transfer, Word};
 use crate::gpio::sealed::Pin as SealedPin;
@@ -734,23 +734,67 @@ pub struct InstanceMemory<'d, PIO: Instance> {
 
 pub struct LoadedProgram<'d, PIO: Instance> {
     pub used_memory: InstanceMemory<'d, PIO>,
-    origin: u8,
-    wrap: Wrap,
-    side_set: SideSet,
+    pub origin: u8,
+    pub wrap: Wrap,
+    pub side_set: SideSet,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum LoadError {
+    /// Insufficient consecutive free instruction space to load program.
+    InsufficientSpace,
+    /// Loading the program would overwrite an instruction address already
+    /// used by another program.
+    AddressInUse(usize),
 }
 
 impl<'d, PIO: Instance> Common<'d, PIO> {
-    pub fn load_program<const SIZE: usize>(&mut self, prog: &RelocatedProgram<SIZE>) -> LoadedProgram<'d, PIO> {
+    /// Load a PIO program. This will automatically relocate the program to
+    /// an available chunk of free instruction memory if the program origin
+    /// was not explicitly specified, otherwise it will attempt to load the
+    /// program only at its origin.
+    pub fn load_program<const SIZE: usize>(&mut self, prog: &Program<SIZE>) -> LoadedProgram<'d, PIO> {
         match self.try_load_program(prog) {
             Ok(r) => r,
-            Err(at) => panic!("Trying to write already used PIO instruction memory at {}", at),
+            Err(e) => panic!("Failed to load PIO program: {:?}", e),
         }
     }
 
+    /// Load a PIO program. This will automatically relocate the program to
+    /// an available chunk of free instruction memory if the program origin
+    /// was not explicitly specified, otherwise it will attempt to load the
+    /// program only at its origin.
     pub fn try_load_program<const SIZE: usize>(
         &mut self,
-        prog: &RelocatedProgram<SIZE>,
+        prog: &Program<SIZE>,
+    ) -> Result<LoadedProgram<'d, PIO>, LoadError> {
+        match prog.origin {
+            Some(origin) => self
+                .try_load_program_at(prog, origin)
+                .map_err(|a| LoadError::AddressInUse(a)),
+            None => {
+                // naively search for free space, allowing wraparound since
+                // PIO does support that. with only 32 instruction slots it
+                // doesn't make much sense to do anything more fancy.
+                let mut origin = 0;
+                while origin < 32 {
+                    match self.try_load_program_at(prog, origin as _) {
+                        Ok(r) => return Ok(r),
+                        Err(a) => origin = a + 1,
+                    }
+                }
+                Err(LoadError::InsufficientSpace)
+            }
+        }
+    }
+
+    fn try_load_program_at<const SIZE: usize>(
+        &mut self,
+        prog: &Program<SIZE>,
+        origin: u8,
     ) -> Result<LoadedProgram<'d, PIO>, usize> {
+        let prog = RelocatedProgram::new_with_origin(prog, origin);
         let used_memory = self.try_write_instr(prog.origin() as _, prog.code())?;
         Ok(LoadedProgram {
             used_memory,
@@ -760,7 +804,7 @@ impl<'d, PIO: Instance> Common<'d, PIO> {
         })
     }
 
-    pub fn try_write_instr<I>(&mut self, start: usize, instrs: I) -> Result<InstanceMemory<'d, PIO>, usize>
+    fn try_write_instr<I>(&mut self, start: usize, instrs: I) -> Result<InstanceMemory<'d, PIO>, usize>
     where
         I: Iterator<Item = u16>,
     {
diff --git a/embassy-rp/src/relocate.rs b/embassy-rp/src/relocate.rs
index 9cb279ccd..b35b4ed72 100644
--- a/embassy-rp/src/relocate.rs
+++ b/embassy-rp/src/relocate.rs
@@ -41,11 +41,6 @@ pub struct RelocatedProgram<'a, const PROGRAM_SIZE: usize> {
 }
 
 impl<'a, const PROGRAM_SIZE: usize> RelocatedProgram<'a, PROGRAM_SIZE> {
-    pub fn new(program: &Program<PROGRAM_SIZE>) -> RelocatedProgram<PROGRAM_SIZE> {
-        let origin = program.origin.unwrap_or(0);
-        RelocatedProgram { program, origin }
-    }
-
     pub fn new_with_origin(program: &Program<PROGRAM_SIZE>, origin: u8) -> RelocatedProgram<PROGRAM_SIZE> {
         RelocatedProgram { program, origin }
     }
diff --git a/examples/rp/src/bin/pio_async.rs b/examples/rp/src/bin/pio_async.rs
index c001d6440..a6d6144be 100644
--- a/examples/rp/src/bin/pio_async.rs
+++ b/examples/rp/src/bin/pio_async.rs
@@ -8,7 +8,6 @@ use embassy_executor::Spawner;
 use embassy_rp::bind_interrupts;
 use embassy_rp::peripherals::PIO0;
 use embassy_rp::pio::{Common, Config, InterruptHandler, Irq, Pio, PioPin, ShiftDirection, StateMachine};
-use embassy_rp::relocate::RelocatedProgram;
 use fixed::traits::ToFixed;
 use fixed_macro::types::U56F8;
 use {defmt_rtt as _, panic_probe as _};
@@ -29,9 +28,8 @@ fn setup_pio_task_sm0<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a,
         ".wrap",
     );
 
-    let relocated = RelocatedProgram::new(&prg.program);
     let mut cfg = Config::default();
-    cfg.use_program(&pio.load_program(&relocated), &[]);
+    cfg.use_program(&pio.load_program(&prg.program), &[]);
     let out_pin = pio.make_pio_pin(pin);
     cfg.set_out_pins(&[&out_pin]);
     cfg.set_set_pins(&[&out_pin]);
@@ -65,9 +63,8 @@ fn setup_pio_task_sm1<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a,
         ".wrap",
     );
 
-    let relocated = RelocatedProgram::new(&prg.program);
     let mut cfg = Config::default();
-    cfg.use_program(&pio.load_program(&relocated), &[]);
+    cfg.use_program(&pio.load_program(&prg.program), &[]);
     cfg.clock_divider = (U56F8!(125_000_000) / 2000).to_fixed();
     cfg.shift_in.auto_fill = true;
     cfg.shift_in.direction = ShiftDirection::Right;
@@ -96,9 +93,8 @@ fn setup_pio_task_sm2<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a,
         "irq 3 [15]",
         ".wrap",
     );
-    let relocated = RelocatedProgram::new(&prg.program);
     let mut cfg = Config::default();
-    cfg.use_program(&pio.load_program(&relocated), &[]);
+    cfg.use_program(&pio.load_program(&prg.program), &[]);
     cfg.clock_divider = (U56F8!(125_000_000) / 2000).to_fixed();
     sm.set_config(&cfg);
 }
diff --git a/examples/rp/src/bin/pio_dma.rs b/examples/rp/src/bin/pio_dma.rs
index 9ab72e1f3..86e5017ac 100644
--- a/examples/rp/src/bin/pio_dma.rs
+++ b/examples/rp/src/bin/pio_dma.rs
@@ -8,7 +8,6 @@ use embassy_executor::Spawner;
 use embassy_futures::join::join;
 use embassy_rp::peripherals::PIO0;
 use embassy_rp::pio::{Config, InterruptHandler, Pio, ShiftConfig, ShiftDirection};
-use embassy_rp::relocate::RelocatedProgram;
 use embassy_rp::{bind_interrupts, Peripheral};
 use fixed::traits::ToFixed;
 use fixed_macro::types::U56F8;
@@ -46,9 +45,8 @@ async fn main(_spawner: Spawner) {
         ".wrap",
     );
 
-    let relocated = RelocatedProgram::new(&prg.program);
     let mut cfg = Config::default();
-    cfg.use_program(&common.load_program(&relocated), &[]);
+    cfg.use_program(&common.load_program(&prg.program), &[]);
     cfg.clock_divider = (U56F8!(125_000_000) / U56F8!(10_000)).to_fixed();
     cfg.shift_in = ShiftConfig {
         auto_fill: true,
diff --git a/examples/rp/src/bin/pio_hd44780.rs b/examples/rp/src/bin/pio_hd44780.rs
index 8aedd24b6..d80c5c24b 100644
--- a/examples/rp/src/bin/pio_hd44780.rs
+++ b/examples/rp/src/bin/pio_hd44780.rs
@@ -14,7 +14,6 @@ use embassy_rp::pio::{
     Config, Direction, FifoJoin, InterruptHandler, Pio, PioPin, ShiftConfig, ShiftDirection, StateMachine,
 };
 use embassy_rp::pwm::{self, Pwm};
-use embassy_rp::relocate::RelocatedProgram;
 use embassy_rp::{bind_interrupts, into_ref, Peripheral, PeripheralRef};
 use embassy_time::{Duration, Instant, Timer};
 use {defmt_rtt as _, panic_probe as _};
@@ -127,9 +126,8 @@ impl<'l> HD44780<'l> {
 
         sm0.set_pin_dirs(Direction::Out, &[&rs, &rw, &e, &db4, &db5, &db6, &db7]);
 
-        let relocated = RelocatedProgram::new(&prg.program);
         let mut cfg = Config::default();
-        cfg.use_program(&common.load_program(&relocated), &[&e]);
+        cfg.use_program(&common.load_program(&prg.program), &[&e]);
         cfg.clock_divider = 125u8.into();
         cfg.set_out_pins(&[&db4, &db5, &db6, &db7]);
         cfg.shift_out = ShiftConfig {
@@ -201,9 +199,8 @@ impl<'l> HD44780<'l> {
             "#
         );
 
-        let relocated = RelocatedProgram::new(&prg.program);
         let mut cfg = Config::default();
-        cfg.use_program(&common.load_program(&relocated), &[&e]);
+        cfg.use_program(&common.load_program(&prg.program), &[&e]);
         cfg.clock_divider = 8u8.into(); // ~64ns/insn
         cfg.set_jmp_pin(&db7);
         cfg.set_set_pins(&[&rs, &rw]);
diff --git a/examples/rp/src/bin/pio_uart.rs b/examples/rp/src/bin/pio_uart.rs
index ca1c7f394..5fddbe292 100644
--- a/examples/rp/src/bin/pio_uart.rs
+++ b/examples/rp/src/bin/pio_uart.rs
@@ -222,8 +222,8 @@ mod uart {
                 mut common, sm0, sm1, ..
             } = Pio::new(pio, Irqs);
 
-            let (tx, origin) = PioUartTx::new(&mut common, sm0, tx_pin, baud, None);
-            let (rx, _) = PioUartRx::new(&mut common, sm1, rx_pin, baud, Some(origin));
+            let tx = PioUartTx::new(&mut common, sm0, tx_pin, baud);
+            let rx = PioUartRx::new(&mut common, sm1, rx_pin, baud);
 
             PioUart { tx, rx }
         }
@@ -240,7 +240,6 @@ mod uart_tx {
     use embassy_rp::gpio::Level;
     use embassy_rp::peripherals::PIO0;
     use embassy_rp::pio::{Common, Config, Direction, FifoJoin, PioPin, ShiftDirection, StateMachine};
-    use embassy_rp::relocate::RelocatedProgram;
     use embedded_io::asynch::Write;
     use embedded_io::Io;
     use fixed::traits::ToFixed;
@@ -256,9 +255,8 @@ mod uart_tx {
             mut sm_tx: StateMachine<'a, PIO0, 0>,
             tx_pin: impl PioPin,
             baud: u64,
-            origin: Option<u8>,
-        ) -> (Self, u8) {
-            let mut prg = pio_proc::pio_asm!(
+        ) -> Self {
+            let prg = pio_proc::pio_asm!(
                 r#"
                 .side_set 1 opt
 
@@ -272,17 +270,14 @@ mod uart_tx {
                     jmp x-- bitloop   [6]  ; Each loop iteration is 8 cycles.
             "#
             );
-            prg.program.origin = origin;
             let tx_pin = common.make_pio_pin(tx_pin);
             sm_tx.set_pins(Level::High, &[&tx_pin]);
             sm_tx.set_pin_dirs(Direction::Out, &[&tx_pin]);
 
-            let relocated = RelocatedProgram::new(&prg.program);
-
             let mut cfg = Config::default();
 
             cfg.set_out_pins(&[&tx_pin]);
-            cfg.use_program(&common.load_program(&relocated), &[&tx_pin]);
+            cfg.use_program(&common.load_program(&prg.program), &[&tx_pin]);
             cfg.shift_out.auto_fill = false;
             cfg.shift_out.direction = ShiftDirection::Right;
             cfg.fifo_join = FifoJoin::TxOnly;
@@ -290,18 +285,7 @@ mod uart_tx {
             sm_tx.set_config(&cfg);
             sm_tx.set_enable(true);
 
-            // The 4 state machines of the PIO each have their own program counter that starts taking
-            // instructions at an offset (origin) of the 32 instruction "space" the PIO device has.
-            // It is up to the programmer to sort out where to place these instructions.
-            // From the pio_asm! macro you get a ProgramWithDefines which has a field .program.origin
-            // which takes an Option<u8>.
-            //
-            // When you load more than one RelocatedProgram into the PIO,
-            // you load your first program at origin = 0.
-            // The RelocatedProgram has .code().count() which returns a usize,
-            // for which you can then use as your next program's origin.
-            let offset = relocated.code().count() as u8 + origin.unwrap_or_default();
-            (Self { sm_tx }, offset)
+            Self { sm_tx }
         }
 
         pub async fn write_u8(&mut self, data: u8) {
@@ -329,7 +313,6 @@ mod uart_rx {
     use embassy_rp::gpio::Level;
     use embassy_rp::peripherals::PIO0;
     use embassy_rp::pio::{Common, Config, Direction, FifoJoin, PioPin, ShiftDirection, StateMachine};
-    use embassy_rp::relocate::RelocatedProgram;
     use embedded_io::asynch::Read;
     use embedded_io::Io;
     use fixed::traits::ToFixed;
@@ -345,9 +328,8 @@ mod uart_rx {
             mut sm_rx: StateMachine<'a, PIO0, 1>,
             rx_pin: impl PioPin,
             baud: u64,
-            origin: Option<u8>,
-        ) -> (Self, u8) {
-            let mut prg = pio_proc::pio_asm!(
+        ) -> Self {
+            let prg = pio_proc::pio_asm!(
                 r#"
                 ; Slightly more fleshed-out 8n1 UART receiver which handles framing errors and
                 ; break conditions more gracefully.
@@ -369,10 +351,8 @@ mod uart_rx {
                     push                ; important in case the TX clock is slightly too fast.
             "#
             );
-            prg.program.origin = origin;
-            let relocated = RelocatedProgram::new(&prg.program);
             let mut cfg = Config::default();
-            cfg.use_program(&common.load_program(&relocated), &[]);
+            cfg.use_program(&common.load_program(&prg.program), &[]);
 
             let rx_pin = common.make_pio_pin(rx_pin);
             sm_rx.set_pins(Level::High, &[&rx_pin]);
@@ -387,8 +367,7 @@ mod uart_rx {
             sm_rx.set_config(&cfg);
             sm_rx.set_enable(true);
 
-            let offset = relocated.code().count() as u8 + origin.unwrap_or_default();
-            (Self { sm_rx }, offset)
+            Self { sm_rx }
         }
 
         pub async fn read_u8(&mut self) -> u8 {
diff --git a/examples/rp/src/bin/pio_ws2812.rs b/examples/rp/src/bin/pio_ws2812.rs
index 3de2bd48d..bc87016ec 100644
--- a/examples/rp/src/bin/pio_ws2812.rs
+++ b/examples/rp/src/bin/pio_ws2812.rs
@@ -12,7 +12,6 @@ use embassy_rp::peripherals::PIO0;
 use embassy_rp::pio::{
     Common, Config, FifoJoin, Instance, InterruptHandler, Pio, PioPin, ShiftConfig, ShiftDirection, StateMachine,
 };
-use embassy_rp::relocate::RelocatedProgram;
 use embassy_rp::{bind_interrupts, clocks, into_ref, Peripheral, PeripheralRef};
 use embassy_time::{Duration, Timer};
 use fixed::types::U24F8;
@@ -73,8 +72,7 @@ impl<'d, P: Instance, const S: usize, const N: usize> Ws2812<'d, P, S, N> {
         cfg.set_out_pins(&[&out_pin]);
         cfg.set_set_pins(&[&out_pin]);
 
-        let relocated = RelocatedProgram::new(&prg);
-        cfg.use_program(&pio.load_program(&relocated), &[&out_pin]);
+        cfg.use_program(&pio.load_program(&prg), &[&out_pin]);
 
         // Clock config, measured in kHz to avoid overflows
         // TODO CLOCK_FREQ should come from embassy_rp
diff --git a/tests/rp/src/bin/pio_irq.rs b/tests/rp/src/bin/pio_irq.rs
index 45004424a..bdea63eaa 100644
--- a/tests/rp/src/bin/pio_irq.rs
+++ b/tests/rp/src/bin/pio_irq.rs
@@ -9,7 +9,6 @@ use embassy_executor::Spawner;
 use embassy_rp::bind_interrupts;
 use embassy_rp::peripherals::PIO0;
 use embassy_rp::pio::{Config, InterruptHandler, Pio};
-use embassy_rp::relocate::RelocatedProgram;
 use {defmt_rtt as _, panic_probe as _};
 
 bind_interrupts!(struct Irqs {
@@ -35,9 +34,8 @@ async fn main(_spawner: Spawner) {
         "irq wait 1",
     );
 
-    let relocated = RelocatedProgram::new(&prg.program);
     let mut cfg = Config::default();
-    cfg.use_program(&common.load_program(&relocated), &[]);
+    cfg.use_program(&common.load_program(&prg.program), &[]);
     sm.set_config(&cfg);
     sm.set_enable(true);
 
diff --git a/tests/rp/src/bin/pio_multi_load.rs b/tests/rp/src/bin/pio_multi_load.rs
new file mode 100644
index 000000000..356f16795
--- /dev/null
+++ b/tests/rp/src/bin/pio_multi_load.rs
@@ -0,0 +1,126 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+#[path = "../common.rs"]
+mod common;
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::{Config, InterruptHandler, LoadError, Pio};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    PIO0_IRQ_0 => InterruptHandler<PIO0>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let pio = p.PIO0;
+    let Pio {
+        mut common,
+        mut sm0,
+        mut sm1,
+        mut sm2,
+        irq_flags,
+        ..
+    } = Pio::new(pio, Irqs);
+
+    // load with explicit origin works
+    let prg1 = pio_proc::pio_asm!(
+        ".origin 4"
+        "nop",
+        "nop",
+        "nop",
+        "nop",
+        "nop",
+        "nop",
+        "nop",
+        "irq 0",
+        "nop",
+        "nop",
+    );
+    let loaded1 = common.load_program(&prg1.program);
+    assert_eq!(loaded1.origin, 4);
+    assert_eq!(loaded1.wrap.source, 13);
+    assert_eq!(loaded1.wrap.target, 4);
+
+    // load without origin chooses a free space
+    let prg2 = pio_proc::pio_asm!("nop", "nop", "nop", "nop", "nop", "nop", "nop", "irq 1", "nop", "nop",);
+    let loaded2 = common.load_program(&prg2.program);
+    assert_eq!(loaded2.origin, 14);
+    assert_eq!(loaded2.wrap.source, 23);
+    assert_eq!(loaded2.wrap.target, 14);
+
+    // wrapping around the end of program space automatically works
+    let prg3 =
+        pio_proc::pio_asm!("nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "irq 2",);
+    let loaded3 = common.load_program(&prg3.program);
+    assert_eq!(loaded3.origin, 24);
+    assert_eq!(loaded3.wrap.source, 3);
+    assert_eq!(loaded3.wrap.target, 24);
+
+    // check that the programs actually work
+    {
+        let mut cfg = Config::default();
+        cfg.use_program(&loaded1, &[]);
+        sm0.set_config(&cfg);
+        sm0.set_enable(true);
+        while !irq_flags.check(0) {}
+        sm0.set_enable(false);
+    }
+    {
+        let mut cfg = Config::default();
+        cfg.use_program(&loaded2, &[]);
+        sm1.set_config(&cfg);
+        sm1.set_enable(true);
+        while !irq_flags.check(1) {}
+        sm1.set_enable(false);
+    }
+    {
+        let mut cfg = Config::default();
+        cfg.use_program(&loaded3, &[]);
+        sm2.set_config(&cfg);
+        sm2.set_enable(true);
+        while !irq_flags.check(2) {}
+        sm2.set_enable(false);
+    }
+
+    // instruction memory is full now. all loads should fail.
+    {
+        let prg = pio_proc::pio_asm!(".origin 0", "nop");
+        match common.try_load_program(&prg.program) {
+            Err(LoadError::AddressInUse(0)) => (),
+            _ => panic!("program loaded when it shouldn't"),
+        };
+
+        let prg = pio_proc::pio_asm!("nop");
+        match common.try_load_program(&prg.program) {
+            Err(LoadError::InsufficientSpace) => (),
+            _ => panic!("program loaded when it shouldn't"),
+        };
+    }
+
+    // freeing some memory should allow further loads though.
+    unsafe {
+        common.free_instr(loaded3.used_memory);
+    }
+    {
+        let prg = pio_proc::pio_asm!(".origin 0", "nop");
+        match common.try_load_program(&prg.program) {
+            Ok(_) => (),
+            _ => panic!("program didn't loaded when it shouldn"),
+        };
+
+        let prg = pio_proc::pio_asm!("nop");
+        match common.try_load_program(&prg.program) {
+            Ok(_) => (),
+            _ => panic!("program didn't loaded when it shouldn"),
+        };
+    }
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
-- 
cgit 


From b344c843c4ccebcacf27f68db6d335aed2615302 Mon Sep 17 00:00:00 2001
From: Brandon Ros <brandonros1@gmail.com>
Date: Fri, 28 Jul 2023 17:25:07 -0400
Subject: sync latest cyw43-firmware

---
 cyw43-firmware/43439A0.bin     | Bin 224190 -> 230321 bytes
 cyw43-firmware/43439A0_clm.bin | Bin 4752 -> 4752 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)

diff --git a/cyw43-firmware/43439A0.bin b/cyw43-firmware/43439A0.bin
index b46b3beff..017375277 100755
Binary files a/cyw43-firmware/43439A0.bin and b/cyw43-firmware/43439A0.bin differ
diff --git a/cyw43-firmware/43439A0_clm.bin b/cyw43-firmware/43439A0_clm.bin
index 6e3ba786b..1fedd753a 100755
Binary files a/cyw43-firmware/43439A0_clm.bin and b/cyw43-firmware/43439A0_clm.bin differ
-- 
cgit 


From cffb819e61a9cc87cad9a5351669e7dd28eeeba4 Mon Sep 17 00:00:00 2001
From: Brandon Ros <brandonros1@gmail.com>
Date: Fri, 28 Jul 2023 17:34:07 -0400
Subject: changelog

---
 cyw43-firmware/README.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/cyw43-firmware/README.md b/cyw43-firmware/README.md
index 7381fdc56..db3d9c9cf 100644
--- a/cyw43-firmware/README.md
+++ b/cyw43-firmware/README.md
@@ -2,4 +2,8 @@
 
 Firmware obtained from https://github.com/Infineon/wifi-host-driver/tree/master/WiFi_Host_Driver/resources/firmware/COMPONENT_43439
 
-Licensed under the [Infineon Permissive Binary License](./LICENSE-permissive-binary-license-1.0.txt)
\ No newline at end of file
+Licensed under the [Infineon Permissive Binary License](./LICENSE-permissive-binary-license-1.0.txt)
+
+## Changelog
+
+* 2023-07-28: synced with `ad3bad0` - Update 43439 fw from 7.95.55 ot 7.95.62
-- 
cgit 


From 29acc465017ae0b09ffb9d6364c9052e8b5f3937 Mon Sep 17 00:00:00 2001
From: Dario Nieuwenhuis <dirbaio@dirbaio.net>
Date: Fri, 28 Jul 2023 23:47:07 +0200
Subject: core::fmt devours your RAM and flash and explodes your stack. (#1708)

---
 embassy-net-esp-hosted/src/control.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/embassy-net-esp-hosted/src/control.rs b/embassy-net-esp-hosted/src/control.rs
index 79f8cde7b..37f220da0 100644
--- a/embassy-net-esp-hosted/src/control.rs
+++ b/embassy-net-esp-hosted/src/control.rs
@@ -1,5 +1,4 @@
 use ch::driver::LinkState;
-use defmt::Debug2Format;
 use embassy_net_driver_channel as ch;
 use heapless::String;
 
@@ -57,7 +56,6 @@ impl<'a> Control<'a> {
         let proto::CtrlMsgPayload::RespConnectAp(resp) = resp.payload.unwrap() else {
             panic!("unexpected resp")
         };
-        debug!("======= {:?}", Debug2Format(&resp));
         assert_eq!(resp.resp, 0);
         self.state_ch.set_link_state(LinkState::Up);
     }
-- 
cgit 


From d39404cddaa188790040fab00fe317205d4e5ab2 Mon Sep 17 00:00:00 2001
From: Dario Nieuwenhuis <dirbaio@dirbaio.net>
Date: Fri, 28 Jul 2023 23:49:37 +0200
Subject: fix flaky test wifi_esp_hosted_perf

---
 tests/nrf/src/bin/wifi_esp_hosted_perf.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/nrf/src/bin/wifi_esp_hosted_perf.rs b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
index 398ab9d27..e2adfe0be 100644
--- a/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
+++ b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
@@ -118,9 +118,9 @@ const WIFI_NETWORK: &str = "EmbassyTest";
 const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
 
 const TEST_DURATION: usize = 10;
-const TEST_EXPECTED_DOWNLOAD_KBPS: usize = 150;
-const TEST_EXPECTED_UPLOAD_KBPS: usize = 150;
-const TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS: usize = 150;
+const TEST_EXPECTED_DOWNLOAD_KBPS: usize = 50;
+const TEST_EXPECTED_UPLOAD_KBPS: usize = 50;
+const TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS: usize = 50;
 const RX_BUFFER_SIZE: usize = 4096;
 const TX_BUFFER_SIZE: usize = 4096;
 const SERVER_ADDRESS: Ipv4Address = Ipv4Address::new(192, 168, 2, 2);
-- 
cgit 


From fd47445d75eb3546b5581dbbcd9926611489b743 Mon Sep 17 00:00:00 2001
From: Dario Nieuwenhuis <dirbaio@dirbaio.net>
Date: Fri, 28 Jul 2023 23:58:47 +0200
Subject: cyw43: Update firmware in HIL test.

---
 tests/rp/src/bin/cyw43-perf.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/rp/src/bin/cyw43-perf.rs b/tests/rp/src/bin/cyw43-perf.rs
index bc127e2e5..fffdabc9b 100644
--- a/tests/rp/src/bin/cyw43-perf.rs
+++ b/tests/rp/src/bin/cyw43-perf.rs
@@ -48,9 +48,9 @@ async fn main(spawner: Spawner) {
     }
 
     // cyw43 firmware needs to be flashed manually:
-    //     probe-rs download 43439A0.bin     --format bin --chip RP2040 --base-address 0x101c0000
+    //     probe-rs download 43439A0.bin     --format bin --chip RP2040 --base-address 0x101b0000
     //     probe-rs download 43439A0_clm.bin --format bin --chip RP2040 --base-address 0x101f8000
-    let fw = unsafe { core::slice::from_raw_parts(0x101c0000 as *const u8, 224190) };
+    let fw = unsafe { core::slice::from_raw_parts(0x101b0000 as *const u8, 230321) };
     let clm = unsafe { core::slice::from_raw_parts(0x101f8000 as *const u8, 4752) };
 
     let pwr = Output::new(p.PIN_23, Level::Low);
-- 
cgit