97 files changed, 1440 insertions, 371 deletions

diff --git a/ci.sh b/ci.sh
index e489982a7..1eecd158f 100755
--- a/ci.sh
+++ b/ci.sh
@@ -35,8 +35,8 @@ rm -rf out/tests/nrf5340-dk
 # disabled because these boards are not on the shelf
 rm -rf out/tests/mspm0g3507
 
-# rm out/tests/stm32wb55rg/wpan_mac
-# rm out/tests/stm32wb55rg/wpan_ble
+rm out/tests/stm32wb55rg/wpan_mac
+rm out/tests/stm32wb55rg/wpan_ble
 
 # unstable, I think it's running out of RAM?
 rm out/tests/stm32f207zg/eth
diff --git a/cyw43/Cargo.toml b/cyw43/Cargo.toml
index 6d7647697..c4f5c0ebd 100644
--- a/cyw43/Cargo.toml
+++ b/cyw43/Cargo.toml
@@ -10,7 +10,7 @@ repository = "https://github.com/embassy-rs/embassy"
 documentation = "https://docs.embassy.dev/cyw43"
 
 [features]
-defmt = ["dep:defmt", "heapless/defmt-03", "embassy-time/defmt", "bt-hci?/defmt", "embedded-io-async?/defmt-03"]
+defmt = ["dep:defmt", "heapless/defmt-03", "embassy-time/defmt", "bt-hci?/defmt", "embedded-io-async?/defmt"]
 log = ["dep:log"]
 bluetooth = ["dep:bt-hci", "dep:embedded-io-async"]
 
@@ -35,8 +35,8 @@ num_enum = { version = "0.5.7", default-features = false }
 heapless = "0.8.0"
 
 # Bluetooth deps
-embedded-io-async = { version = "0.6.0", optional = true }
-bt-hci = { version = "0.6.0", optional = true }
+embedded-io-async = { version = "0.7.0", optional = true }
+bt-hci = { git = "https://github.com/embassy-rs/bt-hci", rev = "51791fd4d422449dd0eca5ddead32886101215f7", optional = true }
 
 [package.metadata.embassy]
 build = [
diff --git a/cyw43/src/bluetooth.rs b/cyw43/src/bluetooth.rs
index 332b7048d..256451fae 100644
--- a/cyw43/src/bluetooth.rs
+++ b/cyw43/src/bluetooth.rs
@@ -490,6 +490,14 @@ impl From<FromHciBytesError> for Error {
     }
 }
 
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Debug::fmt(self, f)
+    }
+}
+
+impl core::error::Error for Error {}
+
 impl<'d> embedded_io_async::ErrorType for BtDriver<'d> {
     type Error = Error;
 }
diff --git a/embassy-imxrt/Cargo.toml b/embassy-imxrt/Cargo.toml
index 81377579b..5ffa054f1 100644
--- a/embassy-imxrt/Cargo.toml
+++ b/embassy-imxrt/Cargo.toml
@@ -85,8 +85,8 @@ cfg-if = "1.0.0"
 cortex-m-rt = ">=0.7.3,<0.8"
 cortex-m = "0.7.6"
 critical-section = "1.1"
-embedded-io = { version = "0.6.1" }
-embedded-io-async = { version = "0.6.1" }
+embedded-io = { version = "0.7.1" }
+embedded-io-async = { version = "0.7.0" }
 fixed = "1.23.1"
 
 rand-core-06 = { package = "rand_core", version = "0.6" }
diff --git a/embassy-mcxa/Cargo.toml b/embassy-mcxa/Cargo.toml
index 76ce59f5a..0d9663879 100644
--- a/embassy-mcxa/Cargo.toml
+++ b/embassy-mcxa/Cargo.toml
@@ -36,8 +36,8 @@ embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-02 = { package = "embedded-hal", version = "0.2.6", features = ["unproven"] }
 embedded-hal-async = { version = "1.0" }
 embedded-hal-nb = { version = "1.0" }
-embedded-io = "0.6"
-embedded-io-async = { version = "0.6.1" }
+embedded-io = "0.7"
+embedded-io-async = { version = "0.7.0" }
 heapless = "0.8"
 mcxa-pac = { version = "0.1.0", features = ["rt", "critical-section"] }
 nb = "1.1.0"
diff --git a/embassy-mcxa/src/clkout.rs b/embassy-mcxa/src/clkout.rs
index 5b21f24b0..3495eb886 100644
--- a/embassy-mcxa/src/clkout.rs
+++ b/embassy-mcxa/src/clkout.rs
@@ -20,6 +20,7 @@ pub struct ClockOut<'a> {
 }
 
 /// Selected clock source to output
+#[derive(Copy, Clone)]
 pub enum ClockOutSel {
     /// 12MHz Internal Oscillator
     Fro12M,
@@ -36,6 +37,7 @@ pub enum ClockOutSel {
 }
 
 /// Configuration for the ClockOut
+#[derive(Copy, Clone)]
 pub struct Config {
     /// Selected Source Clock
     pub sel: ClockOutSel,
@@ -157,6 +159,12 @@ mod sealed {
                 fn mux(&self) {
                     self.set_function(crate::pac::port0::pcr0::Mux::$func);
                     self.set_pull(Pull::Disabled);
+
+                    // TODO: we may want to expose these as options to allow the slew rate
+                    // and drive strength for clocks if they are particularly high speed.
+                    //
+                    // self.set_drive_strength(crate::pac::port0::pcr0::Dse::Dse1);
+                    // self.set_slew_rate(crate::pac::port0::pcr0::Sre::Sre0);
                 }
             }
         };
diff --git a/embassy-mcxa/src/clocks/config.rs b/embassy-mcxa/src/clocks/config.rs
index 0563b8917..4beca5f27 100644
--- a/embassy-mcxa/src/clocks/config.rs
+++ b/embassy-mcxa/src/clocks/config.rs
@@ -119,6 +119,140 @@ pub struct ClocksConfig {
     pub sirc: SircConfig,
     /// FRO16K clock source
     pub fro16k: Option<Fro16KConfig>,
+    /// SOSC, clk_in clock source
+    pub sosc: Option<SoscConfig>,
+    /// SPLL
+    pub spll: Option<SpllConfig>,
+}
+
+// SOSC
+
+/// The mode of the external reference clock
+#[derive(Copy, Clone)]
+pub enum SoscMode {
+    /// Passive crystal oscillators
+    CrystalOscillator,
+    /// Active external reference clock
+    ActiveClock,
+}
+
+/// SOSC/clk_in configuration
+#[derive(Copy, Clone)]
+pub struct SoscConfig {
+    /// Mode of the external reference clock
+    pub mode: SoscMode,
+    /// Specific frequency of the external reference clock
+    pub frequency: u32,
+    /// Power state of the external reference clock
+    pub power: PoweredClock,
+}
+
+// SPLL
+
+/// PLL1/SPLL configuration
+pub struct SpllConfig {
+    /// Input clock source for the PLL1/SPLL
+    pub source: SpllSource,
+    /// Mode of operation for the PLL1/SPLL
+    pub mode: SpllMode,
+    /// Power state of the SPLL
+    pub power: PoweredClock,
+    /// Is the "pll1_clk_div" clock enabled?
+    pub pll1_clk_div: Option<Div8>,
+}
+
+/// Input clock source for the PLL1/SPLL
+pub enum SpllSource {
+    /// External Oscillator (8-50MHz)
+    Sosc,
+    /// Fast Internal Oscillator (45MHz)
+    // NOTE: Figure 69 says "firc_45mhz"/"clk_45m", not "fro_hf_gated",
+    // so this is is always 45MHz.
+    Firc,
+    /// S Internal Oscillator (12M)
+    Sirc,
+    // TODO: the reference manual hints that ROSC is possible,
+    // however the minimum input frequency is 32K, but ROSC is 16K.
+    // Some diagrams show this option, and some diagrams omit it.
+    // SVD shows it as "reserved".
+    //
+    // /// Realtime Internal Oscillator (16K Osc)
+    // Rosc,
+}
+
+/// Mode of operation for the SPLL/PLL1
+///
+/// NOTE: Currently, only "Mode 1" normal operational modes are implemented,
+/// as described in the Reference Manual.
+#[non_exhaustive]
+pub enum SpllMode {
+    /// Mode 1a does not use the Pre/Post dividers.
+    ///
+    /// `Fout = m_mult x SpllSource`
+    ///
+    /// Both of the following constraints must be met:
+    ///
+    /// * Fout: 275MHz to 550MHz
+    /// * Fout: 4.3MHz to 2x Max CPU Frequency
+    Mode1a {
+        /// PLL Multiplier. Must be in the range 1..=65535.
+        m_mult: u16,
+    },
+
+    /// Mode 1b does not use the Pre-divider.
+    ///
+    /// * `if !bypass_p2_div: Fout = (M / (2 x P)) x Fin`
+    /// * `if  bypass_p2_div: Fout = (M /    P   ) x Fin`
+    ///
+    /// Both of the following constraints must be met:
+    ///
+    /// * Fcco: 275MHz to 550MHz
+    ///   * `Fcco = m_mult x SpllSource`
+    /// * Fout: 4.3MHz to 2x Max CPU Frequency
+    Mode1b {
+        /// PLL Multiplier. `m_mult` must be in the range 1..=65535.
+        m_mult: u16,
+        /// Post Divider. `p_div` must be in the range 1..=31.
+        p_div: u8,
+        /// Bonus post divider
+        bypass_p2_div: bool,
+    },
+
+    /// Mode 1c does use the Pre-divider, but does not use the Post-divider
+    ///
+    /// `Fout = (M / N) x Fin`
+    ///
+    /// Both of the following constraints must be met:
+    ///
+    /// * Fout: 275MHz to 550MHz
+    /// * Fout: 4.3MHz to 2x Max CPU Frequency
+    Mode1c {
+        /// PLL Multiplier. `m_mult` must be in the range 1..=65535.
+        m_mult: u16,
+        /// Pre Divider. `n_div` must be in the range 1..=255.
+        n_div: u8,
+    },
+
+    /// Mode 1b uses both the Pre and Post dividers.
+    ///
+    /// * `if !bypass_p2_div: Fout = (M / (N x 2 x P)) x Fin`
+    /// * `if  bypass_p2_div: Fout = (M / (  N x P  )) x Fin`
+    ///
+    /// Both of the following constraints must be met:
+    ///
+    /// * Fcco: 275MHz to 550MHz
+    ///   * `Fcco = (m_mult x SpllSource) / (n_div x p_div (x 2))`
+    /// * Fout: 4.3MHz to 2x Max CPU Frequency
+    Mode1d {
+        /// PLL Multiplier. `m_mult` must be in the range 1..=65535.
+        m_mult: u16,
+        /// Pre Divider. `n_div` must be in the range 1..=255.
+        n_div: u8,
+        /// Post Divider. `p_div` must be in the range 1..=31.
+        p_div: u8,
+        /// Bonus post divider
+        bypass_p2_div: bool,
+    },
 }
 
 // FIRC/FRO180M
@@ -199,6 +333,8 @@ impl Default for ClocksConfig {
                 vsys_domain_active: true,
                 vdd_core_domain_active: true,
             }),
+            sosc: None,
+            spll: None,
         }
     }
 }
diff --git a/embassy-mcxa/src/clocks/mod.rs b/embassy-mcxa/src/clocks/mod.rs
index 037f0a656..04559fd04 100644
--- a/embassy-mcxa/src/clocks/mod.rs
+++ b/embassy-mcxa/src/clocks/mod.rs
@@ -87,6 +87,8 @@ pub fn init(settings: ClocksConfig) -> Result<(), ClockError> {
     operator.configure_firc_clocks()?;
     operator.configure_sirc_clocks()?;
     operator.configure_fro16k_clocks()?;
+    operator.configure_sosc()?;
+    operator.configure_spll()?;
 
     // For now, just use FIRC as the main/cpu clock, which should already be
     // the case on reset
@@ -136,6 +138,7 @@ pub fn with_clocks<R: 'static, F: FnOnce(&Clocks) -> R>(f: F) -> Option<R> {
 #[non_exhaustive]
 pub struct Clocks {
     /// The `clk_in` is a clock provided by an external oscillator
+    /// AKA SOSC
     pub clk_in: Option<Clock>,
 
     // FRO180M stuff
@@ -197,6 +200,9 @@ pub struct Clocks {
 
     /// `pll1_clk` is the output of the main system PLL, `pll1`.
     pub pll1_clk: Option<Clock>,
+
+    /// `pll1_clk_div` is a configurable frequency clock, sourced from `pll1_clk`
+    pub pll1_clk_div: Option<Clock>,
 }
 
 /// `ClockError` is the main error returned when configuring or checking clock state
@@ -433,60 +439,49 @@ pub unsafe fn pulse_reset<G: Gate>() {
 /// selected clocks are active at a suitable level at time of construction. These methods
 /// return the frequency of the requested clock, in Hertz, or a [`ClockError`].
 impl Clocks {
-    /// Ensure the `fro_lf_div` clock is active and valid at the given power state.
-    pub fn ensure_fro_lf_div_active(&self, at_level: &PoweredClock) -> Result<u32, ClockError> {
-        let Some(clk) = self.fro_lf_div.as_ref() else {
+    fn ensure_clock_active(
+        &self,
+        clock: &Option<Clock>,
+        name: &'static str,
+        at_level: &PoweredClock,
+    ) -> Result<u32, ClockError> {
+        let Some(clk) = clock.as_ref() else {
             return Err(ClockError::BadConfig {
-                clock: "fro_lf_div",
+                clock: name,
                 reason: "required but not active",
             });
         };
         if !clk.power.meets_requirement_of(at_level) {
             return Err(ClockError::BadConfig {
-                clock: "fro_lf_div",
+                clock: name,
                 reason: "not low power active",
             });
         }
         Ok(clk.frequency)
     }
 
+    /// Ensure the `fro_lf_div` clock is active and valid at the given power state.
+    #[inline]
+    pub fn ensure_fro_lf_div_active(&self, at_level: &PoweredClock) -> Result<u32, ClockError> {
+        self.ensure_clock_active(&self.fro_lf_div, "fro_lf_div", at_level)
+    }
+
     /// Ensure the `fro_hf` clock is active and valid at the given power state.
+    #[inline]
     pub fn ensure_fro_hf_active(&self, at_level: &PoweredClock) -> Result<u32, ClockError> {
-        let Some(clk) = self.fro_hf.as_ref() else {
-            return Err(ClockError::BadConfig {
-                clock: "fro_hf",
-                reason: "required but not active",
-            });
-        };
-        if !clk.power.meets_requirement_of(at_level) {
-            return Err(ClockError::BadConfig {
-                clock: "fro_hf",
-                reason: "not low power active",
-            });
-        }
-        Ok(clk.frequency)
+        self.ensure_clock_active(&self.fro_hf, "fro_hf", at_level)
     }
 
     /// Ensure the `fro_hf_div` clock is active and valid at the given power state.
+    #[inline]
     pub fn ensure_fro_hf_div_active(&self, at_level: &PoweredClock) -> Result<u32, ClockError> {
-        let Some(clk) = self.fro_hf_div.as_ref() else {
-            return Err(ClockError::BadConfig {
-                clock: "fro_hf_div",
-                reason: "required but not active",
-            });
-        };
-        if !clk.power.meets_requirement_of(at_level) {
-            return Err(ClockError::BadConfig {
-                clock: "fro_hf_div",
-                reason: "not low power active",
-            });
-        }
-        Ok(clk.frequency)
+        self.ensure_clock_active(&self.fro_hf_div, "fro_hf_div", at_level)
     }
 
     /// Ensure the `clk_in` clock is active and valid at the given power state.
-    pub fn ensure_clk_in_active(&self, _at_level: &PoweredClock) -> Result<u32, ClockError> {
-        Err(ClockError::NotImplemented { clock: "clk_in" })
+    #[inline]
+    pub fn ensure_clk_in_active(&self, at_level: &PoweredClock) -> Result<u32, ClockError> {
+        self.ensure_clock_active(&self.clk_in, "clk_in", at_level)
     }
 
     /// Ensure the `clk_16k_vsys` clock is active and valid at the given power state.
@@ -516,30 +511,21 @@ impl Clocks {
     }
 
     /// Ensure the `clk_1m` clock is active and valid at the given power state.
+    #[inline]
     pub fn ensure_clk_1m_active(&self, at_level: &PoweredClock) -> Result<u32, ClockError> {
-        let Some(clk) = self.clk_1m.as_ref() else {
-            return Err(ClockError::BadConfig {
-                clock: "clk_1m",
-                reason: "required but not active",
-            });
-        };
-        if !clk.power.meets_requirement_of(at_level) {
-            return Err(ClockError::BadConfig {
-                clock: "clk_1m",
-                reason: "not low power active",
-            });
-        }
-        Ok(clk.frequency)
+        self.ensure_clock_active(&self.clk_1m, "clk_1m", at_level)
     }
 
     /// Ensure the `pll1_clk` clock is active and valid at the given power state.
-    pub fn ensure_pll1_clk_active(&self, _at_level: &PoweredClock) -> Result<u32, ClockError> {
-        Err(ClockError::NotImplemented { clock: "pll1_clk" })
+    #[inline]
+    pub fn ensure_pll1_clk_active(&self, at_level: &PoweredClock) -> Result<u32, ClockError> {
+        self.ensure_clock_active(&self.pll1_clk, "pll1_clk", at_level)
     }
 
     /// Ensure the `pll1_clk_div` clock is active and valid at the given power state.
-    pub fn ensure_pll1_clk_div_active(&self, _at_level: &PoweredClock) -> Result<u32, ClockError> {
-        Err(ClockError::NotImplemented { clock: "pll1_clk_div" })
+    #[inline]
+    pub fn ensure_pll1_clk_div_active(&self, at_level: &PoweredClock) -> Result<u32, ClockError> {
+        self.ensure_clock_active(&self.pll1_clk_div, "pll1_clk_div", at_level)
     }
 
     /// Ensure the `CPU_CLK` or `SYSTEM_CLK` is active
@@ -811,7 +797,7 @@ impl ClockOperator<'_> {
         Ok(())
     }
 
-    /// Configure the FRO16K/clk_16k clock family
+    /// Configure the ROSC/FRO16K/clk_16k clock family
     fn configure_fro16k_clocks(&mut self) -> Result<(), ClockError> {
         let Some(fro16k) = self.config.fro16k.as_ref() else {
             return Ok(());
@@ -851,6 +837,485 @@ impl ClockOperator<'_> {
 
         Ok(())
     }
+
+    fn ensure_ldo_active(&mut self) {
+        // TODO: Config for the LDO? For now, just enable
+        // using the default settings:
+        // LDOBYPASS: 0/not bypassed
+        // VOUT_SEL: 0b100: 1.1v
+        // LDOEN: 0/Disabled
+        let already_enabled = {
+            let ldocsr = self.scg0.ldocsr().read();
+            ldocsr.ldoen().is_enabled() && ldocsr.vout_ok().is_enabled()
+        };
+        if !already_enabled {
+            self.scg0.ldocsr().modify(|_r, w| w.ldoen().enabled());
+            while self.scg0.ldocsr().read().vout_ok().is_disabled() {}
+        }
+    }
+
+    /// Configure the SOSC/clk_in oscillator
+    fn configure_sosc(&mut self) -> Result<(), ClockError> {
+        let Some(parts) = self.config.sosc.as_ref() else {
+            return Ok(());
+        };
+
+        // Enable (and wait for) LDO to be active
+        self.ensure_ldo_active();
+
+        // TODO: something something pins? This seems to work when the pins are
+        // not enabled, even if GPIO hasn't been initialized at all yet.
+        let eref = match parts.mode {
+            config::SoscMode::CrystalOscillator => pac::scg0::sosccfg::Erefs::Internal,
+            config::SoscMode::ActiveClock => pac::scg0::sosccfg::Erefs::External,
+        };
+        let freq = parts.frequency;
+
+        // TODO: Fix PAC names here
+        //
+        // #[doc = "0: Frequency range select of 8-16 MHz."]
+        // Freq16to20mhz = 0,
+        // #[doc = "1: Frequency range select of 16-25 MHz."]
+        // LowFreq = 1,
+        // #[doc = "2: Frequency range select of 25-40 MHz."]
+        // MediumFreq = 2,
+        // #[doc = "3: Frequency range select of 40-50 MHz."]
+        // HighFreq = 3,
+        let range = match freq {
+            0..8_000_000 => {
+                return Err(ClockError::BadConfig {
+                    clock: "clk_in",
+                    reason: "freq too low",
+                });
+            }
+            8_000_000..16_000_000 => pac::scg0::sosccfg::Range::Freq16to20mhz,
+            16_000_000..25_000_000 => pac::scg0::sosccfg::Range::LowFreq,
+            25_000_000..40_000_000 => pac::scg0::sosccfg::Range::MediumFreq,
+            40_000_000..50_000_001 => pac::scg0::sosccfg::Range::HighFreq,
+            50_000_001.. => {
+                return Err(ClockError::BadConfig {
+                    clock: "clk_in",
+                    reason: "freq too high",
+                });
+            }
+        };
+
+        // Set source/erefs and range
+        self.scg0.sosccfg().modify(|_r, w| {
+            w.erefs().variant(eref);
+            w.range().variant(range);
+            w
+        });
+
+        // Disable lock
+        self.scg0.sosccsr().modify(|_r, w| w.lk().clear_bit());
+
+        // TODO: We could enable the SOSC clock monitor. There are some things to
+        // figure out first:
+        //
+        // * This requires SIRC to be enabled, not sure which branch. Maybe fro12m_root?
+        // * If SOSC needs to work in deep sleep, AND the monitor is enabled:
+        //   * SIRC also need needs to be low power
+        // * We need to decide if we need an interrupt or a reset if the monitor trips
+
+        // Apply remaining config
+        self.scg0.sosccsr().modify(|_r, w| {
+            // For now, just disable the monitor. See above.
+            w.sosccm().disabled();
+
+            // Set deep sleep mode
+            match parts.power {
+                PoweredClock::NormalEnabledDeepSleepDisabled => {
+                    w.soscsten().clear_bit();
+                }
+                PoweredClock::AlwaysEnabled => {
+                    w.soscsten().set_bit();
+                }
+            }
+
+            // Enable SOSC
+            w.soscen().enabled()
+        });
+
+        // Wait for SOSC to be valid, check for errors
+        while !self.scg0.sosccsr().read().soscvld().bit_is_set() {}
+        if self.scg0.sosccsr().read().soscerr().is_enabled_and_error() {
+            return Err(ClockError::BadConfig {
+                clock: "clk_in",
+                reason: "soscerr is set",
+            });
+        }
+
+        // Re-lock the sosc
+        self.scg0.sosccsr().modify(|_r, w| w.lk().set_bit());
+
+        self.clocks.clk_in = Some(Clock {
+            frequency: freq,
+            power: parts.power,
+        });
+
+        Ok(())
+    }
+
+    fn configure_spll(&mut self) -> Result<(), ClockError> {
+        // # Vocab
+        //
+        // | Name   | Meaning                                                     |
+        // | :---   | :---                                                        |
+        // | Fin    | Frequency of clkin                                          |
+        // | clkout | Output clock of the PLL                                     |
+        // | Fout   | Frequency of clkout (depends on mode)                       |
+        // | clkref | PLL Reference clock, the input clock to the PFD             |
+        // | Fref   | Frequency of clkref, Fref = Fin / N                         |
+        // | Fcco   | Frequency of the output clock of the CCO, Fcco = M * Fref   |
+        // | N      | Predivider value                                            |
+        // | M      | Feedback divider value                                      |
+        // | P      | Postdivider value                                           |
+        // | Tpon   | PLL start-up time                                           |
+
+        // No PLL? Nothing to do!
+        let Some(cfg) = self.config.spll.as_ref() else {
+            return Ok(());
+        };
+
+        // Ensure the LDO is active
+        self.ensure_ldo_active();
+
+        // match on the source, ensure it is active already
+        let res = match cfg.source {
+            config::SpllSource::Sosc => self
+                .clocks
+                .clk_in
+                .as_ref()
+                .map(|c| (c, pac::scg0::spllctrl::Source::Sosc))
+                .ok_or("sosc not active"),
+            config::SpllSource::Firc => self
+                .clocks
+                .clk_45m
+                .as_ref()
+                .map(|c| (c, pac::scg0::spllctrl::Source::Firc))
+                .ok_or("firc not active"),
+            config::SpllSource::Sirc => self
+                .clocks
+                .fro_12m
+                .as_ref()
+                .map(|c| (c, pac::scg0::spllctrl::Source::Sirc))
+                .ok_or("sirc not active"),
+        };
+        // This checks if active
+        let (clk, variant) = res.map_err(|s| ClockError::BadConfig {
+            clock: "spll",
+            reason: s,
+        })?;
+        // This checks the correct power reqs
+        if !clk.power.meets_requirement_of(&cfg.power) {
+            return Err(ClockError::BadConfig {
+                clock: "spll",
+                reason: "needs low power source",
+            });
+        }
+
+        // Bandwidth calc
+        //
+        // > In normal applications, you must calculate the bandwidth manually by using the feedback divider M (ranging from 1 to 216-1),
+        // > Equation 1, and Equation 2. The PLL is automatically stable in such case. In normal applications, SPLLCTRL[BANDDIRECT] must
+        // > be 0; in this case, the bandwidth changes as a function of M.
+        if clk.frequency == 0 {
+            return Err(ClockError::BadConfig {
+                clock: "spll",
+                reason: "internal error",
+            });
+        }
+
+        // These are calculated differently depending on the mode.
+        let f_in = clk.frequency;
+        let bp_pre: bool;
+        let bp_post: bool;
+        let bp_post2: bool;
+        let m: u16;
+        let p: Option<u8>;
+        let n: Option<u8>;
+
+        // Calculate both Fout and Fcco so we can ensure they don't overflow
+        // and are in range
+        let fout: Option<u32>;
+        let fcco: Option<u32>;
+
+        let m_check = |m: u16| {
+            if !(1..=u16::MAX).contains(&m) {
+                Err(ClockError::BadConfig {
+                    clock: "spll",
+                    reason: "m_mult out of range",
+                })
+            } else {
+                Ok(m)
+            }
+        };
+        let p_check = |p: u8| {
+            if !(1..=31).contains(&p) {
+                Err(ClockError::BadConfig {
+                    clock: "spll",
+                    reason: "p_div out of range",
+                })
+            } else {
+                Ok(p)
+            }
+        };
+        let n_check = |n: u8| {
+            if !(1..=u8::MAX).contains(&n) {
+                Err(ClockError::BadConfig {
+                    clock: "spll",
+                    reason: "n_div out of range",
+                })
+            } else {
+                Ok(n)
+            }
+        };
+
+        match cfg.mode {
+            // Fout = M x Fin
+            config::SpllMode::Mode1a { m_mult } => {
+                bp_pre = true;
+                bp_post = true;
+                bp_post2 = false;
+                m = m_check(m_mult)?;
+                p = None;
+                n = None;
+                fcco = f_in.checked_mul(m_mult as u32);
+                fout = fcco;
+            }
+            // if !bypass_p2_div: Fout = (M / (2 x P)) x Fin
+            // if  bypass_p2_div: Fout = (M /    P   ) x Fin
+            config::SpllMode::Mode1b {
+                m_mult,
+                p_div,
+                bypass_p2_div,
+            } => {
+                bp_pre = true;
+                bp_post = false;
+                bp_post2 = bypass_p2_div;
+                m = m_check(m_mult)?;
+                p = Some(p_check(p_div)?);
+                n = None;
+                let mut div = p_div as u32;
+                if !bypass_p2_div {
+                    div *= 2;
+                }
+                fcco = f_in.checked_mul(m_mult as u32);
+                fout = (f_in / div).checked_mul(m_mult as u32);
+            }
+            // Fout = (M / N) x Fin
+            config::SpllMode::Mode1c { m_mult, n_div } => {
+                bp_pre = false;
+                bp_post = true;
+                bp_post2 = false;
+                m = m_check(m_mult)?;
+                p = None;
+                n = Some(n_check(n_div)?);
+                fcco = (f_in / (n_div as u32)).checked_mul(m_mult as u32);
+                fout = fcco;
+            }
+            // if !bypass_p2_div: Fout = (M / (N x 2 x P)) x Fin
+            // if  bypass_p2_div: Fout = (M / (  N x P  )) x Fin
+            config::SpllMode::Mode1d {
+                m_mult,
+                n_div,
+                p_div,
+                bypass_p2_div,
+            } => {
+                bp_pre = false;
+                bp_post = false;
+                bp_post2 = bypass_p2_div;
+                m = m_check(m_mult)?;
+                p = Some(p_check(p_div)?);
+                n = Some(n_check(n_div)?);
+                // This can't overflow: u8 x u8 (x 2) always fits in u32
+                let mut div = (p_div as u32) * (n_div as u32);
+                if !bypass_p2_div {
+                    div *= 2;
+                }
+                fcco = (f_in / (n_div as u32)).checked_mul(m_mult as u32);
+                fout = (f_in / div).checked_mul(m_mult as u32);
+            }
+        };
+
+        // Dump all the PLL calcs if needed for debugging
+        #[cfg(feature = "defmt")]
+        {
+            defmt::debug!("f_in: {:?}", f_in);
+            defmt::debug!("bp_pre: {:?}", bp_pre);
+            defmt::debug!("bp_post: {:?}", bp_post);
+            defmt::debug!("bp_post2: {:?}", bp_post2);
+            defmt::debug!("m: {:?}", m);
+            defmt::debug!("p: {:?}", p);
+            defmt::debug!("n: {:?}", n);
+            defmt::debug!("fout: {:?}", fout);
+            defmt::debug!("fcco: {:?}", fcco);
+        }
+
+        // Ensure the Fcco and Fout calcs didn't overflow
+        let fcco = fcco.ok_or(ClockError::BadConfig {
+            clock: "spll",
+            reason: "fcco invalid1",
+        })?;
+        let fout = fout.ok_or(ClockError::BadConfig {
+            clock: "spll",
+            reason: "fout invalid",
+        })?;
+
+        // Fcco: 275MHz to 550MHz
+        if !(275_000_000..=550_000_000).contains(&fcco) {
+            return Err(ClockError::BadConfig {
+                clock: "spll",
+                reason: "fcco invalid2",
+            });
+        }
+
+        // TODO: Different for different CPUs?
+        const CPU_MAX_FREQ: u32 = 180_000_000;
+
+        // Fout: 4.3MHz to 2x Max CPU Frequency
+        if !(4_300_000..=(2 * CPU_MAX_FREQ)).contains(&fout) {
+            return Err(ClockError::BadConfig {
+                clock: "spll",
+                reason: "fout invalid",
+            });
+        }
+
+        // A = floor(m / 4) + 1
+        let selp_a = (m / 4) + 1;
+        // SELP = A  if A <  31
+        //      = 31 if A >= 31
+        let selp = selp_a.min(31);
+
+        // A = 1                    if        M >= 8000
+        //   = floor(8000 / M)      if 8000 > M >= 122
+        //   = 2 x floor(M / 4) / 3 if 122  > M >= 1
+        let seli_a = if m >= 8000 {
+            1
+        } else if m >= 122 {
+            8000 / m
+        } else {
+            (2 * (m / 4)) / 3
+        };
+        // SELI = A  if A <  63
+        //      = 63 if A >= 63
+        let seli = seli_a.min(63);
+        // SELR must be 0.
+        let selr = 0;
+
+        self.scg0.spllctrl().modify(|_r, w| {
+            w.source().variant(variant);
+            unsafe {
+                w.selp().bits(selp as u8);
+                w.seli().bits(seli as u8);
+                w.selr().bits(selr);
+            }
+            w
+        });
+
+        if let Some(n) = n {
+            self.scg0.spllndiv().modify(|_r, w| unsafe { w.ndiv().bits(n) });
+        }
+        if let Some(p) = p {
+            self.scg0.spllpdiv().modify(|_r, w| unsafe { w.pdiv().bits(p) });
+        }
+        self.scg0.spllmdiv().modify(|_r, w| unsafe { w.mdiv().bits(m) });
+
+        self.scg0.spllctrl().modify(|_r, w| {
+            w.bypassprediv().bit(bp_pre);
+            w.bypasspostdiv().bit(bp_post);
+            w.bypasspostdiv2().bit(bp_post2);
+
+            // TODO: support FRM?
+            w.frm().disabled();
+
+            w
+        });
+
+        // Unlock
+        self.scg0.spllcsr().modify(|_r, w| w.lk().write_enabled());
+
+        // TODO: Support clock monitors?
+        // self.scg0.spllcsr().modify(|_r, w| w.spllcm().?);
+
+        self.scg0.trim_lock().write(|w| unsafe {
+            w.trim_lock_key().bits(0x5a5a);
+            w.trim_unlock().not_locked()
+        });
+
+        // SPLLLOCK_CNFG: The lock time programmed in this register must be
+        // equal to meet the PLL 500μs lock time plus the 300 refclk count startup.
+        //
+        // LOCK_TIME = 500μs/T ref + 300, F ref = F in /N (input frequency divided by pre-divider ratio).
+        //
+        // 500us is 1/2000th of a second, therefore Fref / 2000 is the number of cycles in 500us.
+        let f_ref = if let Some(n) = n { f_in / (n as u32) } else { f_in };
+        let lock_time = f_ref.div_ceil(2000) + 300;
+        self.scg0
+            .splllock_cnfg()
+            .write(|w| unsafe { w.lock_time().bits(lock_time) });
+
+        // TODO: Support Spread spectrum?
+
+        self.scg0.spllcsr().modify(|_r, w| {
+            w.spllclken().enabled();
+            w.spllpwren().enabled();
+            w.spllsten().bit(matches!(cfg.power, PoweredClock::AlwaysEnabled));
+            w
+        });
+
+        // Wait for SPLL to set up
+        loop {
+            let csr = self.scg0.spllcsr().read();
+            if csr.spll_lock().is_enabled_and_valid() {
+                if csr.spllerr().is_enabled_and_error() {
+                    return Err(ClockError::BadConfig {
+                        clock: "spll",
+                        reason: "spllerr is set",
+                    });
+                }
+                break;
+            }
+        }
+
+        // Re-lock SPLL CSR
+        self.scg0.spllcsr().modify(|_r, w| w.lk().write_disabled());
+
+        // Store clock state
+        self.clocks.pll1_clk = Some(Clock {
+            frequency: fout,
+            power: cfg.power,
+        });
+
+        // Do we enable the `pll1_clk_div` output?
+        if let Some(d) = cfg.pll1_clk_div.as_ref() {
+            // Halt and reset the div; then set our desired div.
+            self.syscon.pll1clkdiv().write(|w| {
+                w.halt().halt();
+                w.reset().asserted();
+                unsafe { w.div().bits(d.into_bits()) };
+                w
+            });
+            // Then unhalt it, and reset it
+            self.syscon.pll1clkdiv().write(|w| {
+                w.halt().run();
+                w.reset().released();
+                w
+            });
+
+            // Wait for clock to stabilize
+            while self.syscon.pll1clkdiv().read().unstab().is_ongoing() {}
+
+            // Store off the clock info
+            self.clocks.pll1_clk_div = Some(Clock {
+                frequency: fout / d.into_divisor(),
+                power: cfg.power,
+            });
+        }
+
+        Ok(())
+    }
 }
 
 //
diff --git a/embassy-mcxa/src/dma.rs b/embassy-mcxa/src/dma.rs
index 8d519d99b..b68f55e65 100644
--- a/embassy-mcxa/src/dma.rs
+++ b/embassy-mcxa/src/dma.rs
@@ -1924,7 +1924,7 @@ impl Iterator for TransferErrorRawIter {
 
         for (mask, var) in TransferErrorRaw::MAP {
             // If the bit is set...
-            if self.0 | mask != 0 {
+            if self.0 & mask != 0 {
                 // clear the bit
                 self.0 &= !mask;
                 // and return the answer
diff --git a/embassy-mcxa/src/gpio.rs b/embassy-mcxa/src/gpio.rs
index 65f8df985..29d66656d 100644
--- a/embassy-mcxa/src/gpio.rs
+++ b/embassy-mcxa/src/gpio.rs
@@ -81,7 +81,7 @@ fn GPIO4() {
     irq_handler(4, crate::pac::Gpio4::ptr());
 }
 
-pub(crate) unsafe fn init() {
+pub(crate) unsafe fn interrupt_init() {
     use embassy_hal_internal::interrupt::InterruptExt;
 
     crate::pac::interrupt::GPIO0.enable();
@@ -320,8 +320,12 @@ impl GpioPin for AnyPin {}
 
 macro_rules! impl_pin {
     ($peri:ident, $port:expr, $pin:expr, $block:ident) => {
+        impl_pin!(crate::peripherals, $peri, $port, $pin, $block);
+    };
+
+    ($perip:path, $peri:ident, $port:expr, $pin:expr, $block:ident) => {
         paste! {
-            impl SealedPin for crate::peripherals::$peri {
+            impl SealedPin for $perip::$peri {
                 fn pin_port(&self) -> usize {
                     $port * 32 + $pin
                 }
@@ -372,15 +376,15 @@ macro_rules! impl_pin {
                 }
             }
 
-            impl GpioPin for crate::peripherals::$peri {}
+            impl GpioPin for $perip::$peri {}
 
-            impl From<crate::peripherals::$peri> for AnyPin {
-                fn from(value: crate::peripherals::$peri) -> Self {
+            impl From<$perip::$peri> for AnyPin {
+                fn from(value: $perip::$peri) -> Self {
                     value.degrade()
                 }
             }
 
-            impl crate::peripherals::$peri {
+            impl $perip::$peri {
                 /// Convenience helper to obtain a type-erased handle to this pin.
                 pub fn degrade(&self) -> AnyPin {
                     AnyPin::new(self.port(), self.pin(), self.gpio(), self.port_reg(), self.pcr_reg())
@@ -453,8 +457,8 @@ impl_pin!(P1_26, 1, 26, Gpio1);
 impl_pin!(P1_27, 1, 27, Gpio1);
 impl_pin!(P1_28, 1, 28, Gpio1);
 impl_pin!(P1_29, 1, 29, Gpio1);
-impl_pin!(P1_30, 1, 30, Gpio1);
-impl_pin!(P1_31, 1, 31, Gpio1);
+impl_pin!(crate::internal_peripherals, P1_30, 1, 30, Gpio1);
+impl_pin!(crate::internal_peripherals, P1_31, 1, 31, Gpio1);
 
 impl_pin!(P2_0, 2, 0, Gpio2);
 impl_pin!(P2_1, 2, 1, Gpio2);
diff --git a/embassy-mcxa/src/i2c/mod.rs b/embassy-mcxa/src/i2c/mod.rs
index 9a014224a..55c933f71 100644
--- a/embassy-mcxa/src/i2c/mod.rs
+++ b/embassy-mcxa/src/i2c/mod.rs
@@ -180,8 +180,11 @@ impl_pin!(P1_12, LPI2C1, Mux2, SdaPin);
 impl_pin!(P1_13, LPI2C1, Mux2, SclPin);
 impl_pin!(P1_14, LPI2C1, Mux2, SclPin);
 impl_pin!(P1_15, LPI2C1, Mux2, SdaPin);
-impl_pin!(P1_30, LPI2C0, Mux3, SdaPin);
-impl_pin!(P1_31, LPI2C0, Mux3, SclPin);
+// NOTE: P1_30 and P1_31 are typically used for the external oscillator
+// For now, we just don't give users these pins.
+//
+// impl_pin!(P1_30, LPI2C0, Mux3, SdaPin);
+// impl_pin!(P1_31, LPI2C0, Mux3, SclPin);
 impl_pin!(P3_27, LPI2C3, Mux2, SclPin);
 impl_pin!(P3_28, LPI2C3, Mux2, SdaPin);
 // impl_pin!(P3_29, LPI2C3, Mux2, HreqPin); What is this HREQ pin?
diff --git a/embassy-mcxa/src/lib.rs b/embassy-mcxa/src/lib.rs
index 6383353db..76fd58210 100644
--- a/embassy-mcxa/src/lib.rs
+++ b/embassy-mcxa/src/lib.rs
@@ -175,8 +175,18 @@ embassy_hal_internal::peripherals!(
     P1_27,
     P1_28,
     P1_29,
-    P1_30,
-    P1_31,
+    // TODO: These pins are optionally used as the clock sources for SOSC.
+    // Ideally, we'd want to have a custom version of the `peripheral!` macro
+    // that presented these as `Option<Peri<'_, P1_30>>` instead of `Peri<'_, P1_30>`
+    // when the user DOES enable the external SOSC. For now, I'm guessing MOST designs
+    // will have an external clock sitting on these pins anyway, so we just notch them
+    // out from the `Peripherals` struct given to users.
+    //
+    // If you find this and want your extra two pins to be available: please open an
+    // embassy issue to discuss how we could do this.
+    //
+    // P1_30,
+    // P1_31,
 
     P2_0,
     P2_1,
@@ -337,6 +347,14 @@ embassy_hal_internal::peripherals!(
     WWDT0,
 );
 
+// See commented out items above to understand why we create the instances
+// here but don't give them to the user.
+pub(crate) mod internal_peripherals {
+    embassy_hal_internal::peripherals_definition!(P1_30, P1_31,);
+
+    pub(crate) use peripherals::*;
+}
+
 // Use cortex-m-rt's #[interrupt] attribute directly; PAC does not re-export it.
 
 // Re-export interrupt traits and types
@@ -369,7 +387,7 @@ pub fn init(cfg: crate::config::Config) -> Peripherals {
     crate::clocks::init(cfg.clock_cfg).unwrap();
 
     unsafe {
-        crate::gpio::init();
+        crate::gpio::interrupt_init();
     }
 
     // Initialize DMA controller (clock, reset, configuration)
diff --git a/embassy-mcxa/src/lpuart/mod.rs b/embassy-mcxa/src/lpuart/mod.rs
index bce3986b5..ae511e8d3 100644
--- a/embassy-mcxa/src/lpuart/mod.rs
+++ b/embassy-mcxa/src/lpuart/mod.rs
@@ -568,6 +568,27 @@ pub enum Error {
     ClockSetup(ClockError),
 }
 
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Error::Read => write!(f, "Read error"),
+            Error::Overrun => write!(f, "Buffer overflow"),
+            Error::Noise => write!(f, "Noise error"),
+            Error::Framing => write!(f, "Framing error"),
+            Error::Parity => write!(f, "Parity error"),
+            Error::Fail => write!(f, "Failure"),
+            Error::InvalidArgument => write!(f, "Invalid argument"),
+            Error::UnsupportedBaudrate => write!(f, "Unsupported baud rate"),
+            Error::RxFifoEmpty => write!(f, "RX FIFO empty"),
+            Error::TxFifoFull => write!(f, "TX FIFO full"),
+            Error::TxBusy => write!(f, "TX busy"),
+            Error::ClockSetup(e) => write!(f, "Clock setup error: {:?}", e),
+        }
+    }
+}
+
+impl core::error::Error for Error {}
+
 /// A specialized Result type for LPUART operations
 pub type Result<T> = core::result::Result<T, Error>;
 
diff --git a/embassy-mcxa/src/reset_reason.rs b/embassy-mcxa/src/reset_reason.rs
index f9a9ce096..1787690a7 100644
--- a/embassy-mcxa/src/reset_reason.rs
+++ b/embassy-mcxa/src/reset_reason.rs
@@ -6,45 +6,158 @@
 
 /// Reads the most recent reset reason from the Core Mode Controller
 /// (CMC).
-pub fn reset_reason() -> ResetReason {
+pub fn reset_reason() -> ResetReasonRaw {
     let regs = unsafe { &*crate::pac::Cmc::steal() };
+    let srs = regs.srs().read().bits();
+    ResetReasonRaw(srs)
+}
+
+/// Raw reset reason bits. Can be queried or all reasons can be iterated over
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Copy, Clone, Debug)]
+pub struct ResetReasonRaw(u32);
+
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Copy, Clone, Debug)]
+pub struct ResetReasonRawIter(u32);
+
+impl ResetReasonRaw {
+    const MAP: &[(u32, ResetReason)] = &[
+        (1 << 0, ResetReason::WakeUp),
+        (1 << 1, ResetReason::Por),
+        (1 << 2, ResetReason::VoltageDetect),
+        (1 << 4, ResetReason::Warm),
+        (1 << 5, ResetReason::Fatal),
+        (1 << 8, ResetReason::Pin),
+        (1 << 9, ResetReason::Dap),
+        (1 << 10, ResetReason::ResetAckTimeout),
+        (1 << 11, ResetReason::LowPowerAckTimeout),
+        (1 << 12, ResetReason::SystemClockGeneration),
+        (1 << 13, ResetReason::Wwdt0),
+        (1 << 14, ResetReason::Software),
+        (1 << 15, ResetReason::Lockup),
+        (1 << 26, ResetReason::Cdog0),
+        (1 << 27, ResetReason::Cdog1),
+        (1 << 28, ResetReason::Jtag),
+    ];
+
+    /// Convert to an iterator of contained reset reasons
+    pub fn into_iter(self) -> ResetReasonRawIter {
+        ResetReasonRawIter(self.0)
+    }
+
+    /// Wake up
+    #[inline]
+    pub fn is_wakeup(&self) -> bool {
+        (self.0 & (1 << 0)) != 0
+    }
+
+    /// Power-on Reset
+    #[inline]
+    pub fn is_por(&self) -> bool {
+        (self.0 & (1 << 1)) != 0
+    }
+
+    /// Voltage detect
+    #[inline]
+    pub fn is_voltage_detect(&self) -> bool {
+        (self.0 & (1 << 2)) != 0
+    }
+
+    /// Warm
+    #[inline]
+    pub fn is_warm(&self) -> bool {
+        (self.0 & (1 << 4)) != 0
+    }
+
+    /// Fatal
+    #[inline]
+    pub fn is_fatal(&self) -> bool {
+        (self.0 & (1 << 5)) != 0
+    }
+
+    /// Pin
+    #[inline]
+    pub fn is_pin(&self) -> bool {
+        (self.0 & (1 << 8)) != 0
+    }
+
+    /// DAP
+    #[inline]
+    pub fn is_dap(&self) -> bool {
+        (self.0 & (1 << 9)) != 0
+    }
+
+    /// Reset ack timeout
+    #[inline]
+    pub fn is_reset_ack_timeout(&self) -> bool {
+        (self.0 & (1 << 10)) != 0
+    }
+
+    /// Low power ack timeout
+    #[inline]
+    pub fn is_low_power_ack_timeout(&self) -> bool {
+        (self.0 & (1 << 11)) != 0
+    }
+
+    /// System clock generation
+    #[inline]
+    pub fn is_system_clock_generation(&self) -> bool {
+        (self.0 & (1 << 12)) != 0
+    }
+
+    /// Watchdog 0
+    #[inline]
+    pub fn is_watchdog0(&self) -> bool {
+        (self.0 & (1 << 13)) != 0
+    }
+
+    /// Software
+    pub fn is_software(&self) -> bool {
+        (self.0 & (1 << 14)) != 0
+    }
+
+    /// Lockup
+    pub fn is_lockup(&self) -> bool {
+        (self.0 & (1 << 15)) != 0
+    }
+
+    /// Code watchdog 0
+    pub fn is_code_watchdog0(&self) -> bool {
+        (self.0 & (1 << 26)) != 0
+    }
+
+    /// Code watchdog 1
+    pub fn is_code_watchdog1(&self) -> bool {
+        (self.0 & (1 << 27)) != 0
+    }
+
+    /// JTAG
+    pub fn is_jtag(&self) -> bool {
+        (self.0 & (1 << 28)) != 0
+    }
+}
 
-    let srs = regs.srs().read();
-
-    if srs.wakeup().is_enabled() {
-        ResetReason::WakeUp
-    } else if srs.por().bit_is_set() {
-        ResetReason::Por
-    } else if srs.vd().bit_is_set() {
-        ResetReason::VoltageDetect
-    } else if srs.warm().bit_is_set() {
-        ResetReason::Warm
-    } else if srs.fatal().bit_is_set() {
-        ResetReason::Fatal
-    } else if srs.pin().bit_is_set() {
-        ResetReason::Pin
-    } else if srs.dap().bit_is_set() {
-        ResetReason::Dap
-    } else if srs.rstack().bit_is_set() {
-        ResetReason::ResetAckTimeout
-    } else if srs.lpack().bit_is_set() {
-        ResetReason::LowPowerAckTimeout
-    } else if srs.scg().bit_is_set() {
-        ResetReason::SystemClockGeneration
-    } else if srs.wwdt0().bit_is_set() {
-        ResetReason::Wwdt0
-    } else if srs.sw().bit_is_set() {
-        ResetReason::Software
-    } else if srs.lockup().bit_is_set() {
-        ResetReason::Lockup
-    } else if srs.cdog0().bit_is_set() {
-        ResetReason::Cdog0
-    } else if srs.cdog1().bit_is_set() {
-        ResetReason::Cdog1
-    } else if srs.jtag().bit_is_set() {
-        ResetReason::Jtag
-    } else {
-        ResetReason::Tamper
+impl Iterator for ResetReasonRawIter {
+    type Item = ResetReason;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.0 == 0 {
+            return None;
+        }
+
+        for (mask, var) in ResetReasonRaw::MAP {
+            // If the bit is set...
+            if self.0 & mask != 0 {
+                // clear the bit
+                self.0 &= !mask;
+                // and return the answer
+                return Some(*var);
+            }
+        }
+
+        // Shouldn't happen, but oh well.
+        None
     }
 }
 
diff --git a/embassy-mspm0/Cargo.toml b/embassy-mspm0/Cargo.toml
index cf2346328..c7f5de6a1 100644
--- a/embassy-mspm0/Cargo.toml
+++ b/embassy-mspm0/Cargo.toml
@@ -61,8 +61,8 @@ embedded-hal-02 = { package = "embedded-hal", version = "0.2.6", features = ["un
 embedded-hal = { version = "1.0" }
 embedded-hal-nb = { version = "1.0" }
 embedded-hal-async = { version = "1.0" }
-embedded-io = "0.6.1"
-embedded-io-async = "0.6.1"
+embedded-io = { version = "0.7.1" }
+embedded-io-async = { version = "0.7.0" }
 
 defmt = { version = "1.0.1", optional = true }
 fixed = "1.29"
diff --git a/embassy-mspm0/src/uart/buffered.rs b/embassy-mspm0/src/uart/buffered.rs
index 89e6bcc7b..d1b75b177 100644
--- a/embassy-mspm0/src/uart/buffered.rs
+++ b/embassy-mspm0/src/uart/buffered.rs
@@ -436,6 +436,10 @@ impl embedded_io_async::Write for BufferedUart<'_> {
     async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
         self.tx.write_inner(buf).await
     }
+
+    async fn flush(&mut self) -> Result<(), Self::Error> {
+        self.tx.flush_inner().await
+    }
 }
 
 impl embedded_io_async::Write for BufferedUartTx<'_> {
diff --git a/embassy-net-nrf91/Cargo.toml b/embassy-net-nrf91/Cargo.toml
index 349ff2880..c5c582fc3 100644
--- a/embassy-net-nrf91/Cargo.toml
+++ b/embassy-net-nrf91/Cargo.toml
@@ -27,7 +27,7 @@ embassy-futures = { version = "0.1.2", path = "../embassy-futures" }
 embassy-net-driver-channel = { version = "0.3.2", path = "../embassy-net-driver-channel" }
 
 heapless = "0.8"
-embedded-io = "0.6.1"
+embedded-io = { version = "0.7.1" }
 at-commands = "0.5.4"
 
 [package.metadata.embassy]
diff --git a/embassy-net-ppp/Cargo.toml b/embassy-net-ppp/Cargo.toml
index 45ee2f6b5..1dda5017f 100644
--- a/embassy-net-ppp/Cargo.toml
+++ b/embassy-net-ppp/Cargo.toml
@@ -17,7 +17,7 @@ log = ["dep:log", "ppproto/log"]
 defmt = { version = "1.0.1", optional = true }
 log = { version = "0.4.14", optional = true }
 
-embedded-io-async = { version = "0.6.1" }
+embedded-io-async = { version = "0.7.0" }
 embassy-net-driver-channel = { version = "0.3.2", path = "../embassy-net-driver-channel" }
 embassy-futures = { version = "0.1.2", path = "../embassy-futures" }
 ppproto = { version = "0.2.1"}
diff --git a/embassy-net/Cargo.toml b/embassy-net/Cargo.toml
index 4c8075c43..d66ba1133 100644
--- a/embassy-net/Cargo.toml
+++ b/embassy-net/Cargo.toml
@@ -109,9 +109,9 @@ smoltcp = { version = "0.12.0", default-features = false, features = [
 embassy-net-driver = { version = "0.2.0", path = "../embassy-net-driver" }
 embassy-time = { version = "0.5.0", path = "../embassy-time" }
 embassy-sync = { version = "0.7.2", path = "../embassy-sync" }
-embedded-io-async = { version = "0.6.1" }
+embedded-io-async = { version = "0.7.0" }
 
 managed = { version = "0.8.0", default-features = false, features = [ "map" ] }
 heapless = { version = "0.8", default-features = false }
-embedded-nal-async = "0.8.0"
+embedded-nal-async = "0.9.0"
 document-features = "0.2.7"
diff --git a/embassy-net/src/tcp.rs b/embassy-net/src/tcp.rs
index b4db7b88c..74672df1c 100644
--- a/embassy-net/src/tcp.rs
+++ b/embassy-net/src/tcp.rs
@@ -670,6 +670,13 @@ impl<'d> TcpIo<'d> {
 mod embedded_io_impls {
     use super::*;
 
+    impl core::fmt::Display for ConnectError {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            f.write_str("ConnectError")
+        }
+    }
+    impl core::error::Error for ConnectError {}
+
     impl embedded_io_async::Error for ConnectError {
         fn kind(&self) -> embedded_io_async::ErrorKind {
             match self {
@@ -681,6 +688,15 @@ mod embedded_io_impls {
         }
     }
 
+    impl core::fmt::Display for Error {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            match self {
+                Self::ConnectionReset => f.write_str("ConnectionReset"),
+            }
+        }
+    }
+    impl core::error::Error for Error {}
+
     impl embedded_io_async::Error for Error {
         fn kind(&self) -> embedded_io_async::ErrorKind {
             match self {
diff --git a/embassy-nrf/CHANGELOG.md b/embassy-nrf/CHANGELOG.md
index 0d7bfb5f0..921835417 100644
--- a/embassy-nrf/CHANGELOG.md
+++ b/embassy-nrf/CHANGELOG.md
@@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <!-- next-header -->
 ## Unreleased - ReleaseDate
 
+- bugfix: avoid hang if calling now() before syscounter is enabled on nrf54
+
 ## 0.9.0 - 2025-12-15
 
 - changed: apply trimming values from FICR.TRIMCNF on nrf53/54l
diff --git a/embassy-nrf/Cargo.toml b/embassy-nrf/Cargo.toml
index f8a6ef864..a8070aa45 100644
--- a/embassy-nrf/Cargo.toml
+++ b/embassy-nrf/Cargo.toml
@@ -217,8 +217,8 @@ embassy-futures = { version = "0.1.2", path = "../embassy-futures", optional = t
 embedded-hal-02 = { package = "embedded-hal", version = "0.2.6", features = ["unproven"] }
 embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = { version = "1.0" }
-embedded-io = { version = "0.6.0" }
-embedded-io-async = { version = "0.6.1" }
+embedded-io = { version = "0.7.1" }
+embedded-io-async = { version = "0.7.0" }
 
 rand-core-06 = { package = "rand_core", version = "0.6" }
 rand-core-09 = { package = "rand_core", version = "0.9" }
diff --git a/embassy-nrf/src/buffered_uarte/v1.rs b/embassy-nrf/src/buffered_uarte/v1.rs
index ec360f7d0..c14cdfadb 100644
--- a/embassy-nrf/src/buffered_uarte/v1.rs
+++ b/embassy-nrf/src/buffered_uarte/v1.rs
@@ -874,6 +874,15 @@ impl<'a> Drop for BufferedUarteRx<'a> {
     }
 }
 
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match *self {
+            Error::Overrun => write!(f, "Buffer Overrun"),
+        }
+    }
+}
+impl core::error::Error for Error {}
+
 mod _embedded_io {
     use super::*;
 
diff --git a/embassy-nrf/src/buffered_uarte/v2.rs b/embassy-nrf/src/buffered_uarte/v2.rs
index d0d2d97d1..4a6360b69 100644
--- a/embassy-nrf/src/buffered_uarte/v2.rs
+++ b/embassy-nrf/src/buffered_uarte/v2.rs
@@ -50,6 +50,14 @@ pub enum Error {
     // No errors for now
 }
 
+impl core::fmt::Display for Error {
+    fn fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match *self {}
+    }
+}
+
+impl core::error::Error for Error {}
+
 impl State {
     pub(crate) const fn new() -> Self {
         Self {
diff --git a/embassy-nrf/src/time_driver.rs b/embassy-nrf/src/time_driver.rs
index 35f65bd64..21d94cc30 100644
--- a/embassy-nrf/src/time_driver.rs
+++ b/embassy-nrf/src/time_driver.rs
@@ -79,6 +79,10 @@ fn calc_now(period: u32, counter: u32) -> u64 {
 #[cfg(feature = "_grtc")]
 fn syscounter() -> u64 {
     let r = rtc();
+    if !r.mode().read().syscounteren() {
+        return 0;
+    }
+
     r.syscounter(0).active().write(|w| w.set_active(true));
     loop {
         let countl: u32 = r.syscounter(0).syscounterl().read();
diff --git a/embassy-nrf/src/uarte.rs b/embassy-nrf/src/uarte.rs
index 049830aed..ef5d6c6d1 100644
--- a/embassy-nrf/src/uarte.rs
+++ b/embassy-nrf/src/uarte.rs
@@ -1092,6 +1092,20 @@ mod eh02 {
     }
 }
 
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match *self {
+            Self::BufferTooLong => f.write_str("BufferTooLong"),
+            Self::BufferNotInRAM => f.write_str("BufferNotInRAM"),
+            Self::Framing => f.write_str("Framing"),
+            Self::Parity => f.write_str("Parity"),
+            Self::Overrun => f.write_str("Overrun"),
+            Self::Break => f.write_str("Break"),
+        }
+    }
+}
+impl core::error::Error for Error {}
+
 mod _embedded_io {
     use super::*;
 
@@ -1121,6 +1135,9 @@ mod _embedded_io {
             self.write(buf).await?;
             Ok(buf.len())
         }
+        async fn flush(&mut self) -> Result<(), Self::Error> {
+            Ok(())
+        }
     }
 
     impl<'d> embedded_io_async::Write for UarteTx<'d> {
@@ -1128,5 +1145,8 @@ mod _embedded_io {
             self.write(buf).await?;
             Ok(buf.len())
         }
+        async fn flush(&mut self) -> Result<(), Self::Error> {
+            Ok(())
+        }
     }
 }
diff --git a/embassy-nxp/Cargo.toml b/embassy-nxp/Cargo.toml
index b78c26c77..d5ef38531 100644
--- a/embassy-nxp/Cargo.toml
+++ b/embassy-nxp/Cargo.toml
@@ -35,7 +35,7 @@ log = { version = "0.4.27", optional = true }
 embassy-time = { version = "0.5.0", path = "../embassy-time", optional = true }
 embassy-time-driver = { version = "0.2.1", path = "../embassy-time-driver", optional = true }
 embassy-time-queue-utils = { version = "0.3.0", path = "../embassy-time-queue-utils", optional = true }
-embedded-io = "0.6.1"
+embedded-io = { version = "0.7.1" }
 embedded-hal-02 = { package = "embedded-hal", version = "0.2.6", features = ["unproven"] }
 ## Chip dependencies
 nxp-pac = { version = "0.1.0", optional = true, git = "https://github.com/i509VCB/nxp-pac", rev = "af5122e1cbe1483833c5d2e5af96b26a34ed5d62"}
diff --git a/embassy-nxp/src/usart/lpc55.rs b/embassy-nxp/src/usart/lpc55.rs
index d77f08fd8..319e29054 100644
--- a/embassy-nxp/src/usart/lpc55.rs
+++ b/embassy-nxp/src/usart/lpc55.rs
@@ -51,6 +51,15 @@ impl embedded_io::Error for Error {
         }
     }
 }
+
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Debug::fmt(self, f)
+    }
+}
+
+impl core::error::Error for Error {}
+
 /// Word length.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum DataBits {
diff --git a/embassy-rp/Cargo.toml b/embassy-rp/Cargo.toml
index 8e4bb927f..585acc064 100644
--- a/embassy-rp/Cargo.toml
+++ b/embassy-rp/Cargo.toml
@@ -167,8 +167,8 @@ cortex-m-rt = ">=0.6.15,<0.8"
 cortex-m = "0.7.6"
 critical-section = "1.2.0"
 chrono = { version = "0.4", default-features = false, optional = true }
-embedded-io = { version = "0.6.1" }
-embedded-io-async = { version = "0.6.1" }
+embedded-io = { version = "0.7.1" }
+embedded-io-async = { version = "0.7.0" }
 embedded-storage = { version = "0.3" }
 embedded-storage-async = { version = "0.4.1" }
 fixed = "1.28.0"
diff --git a/embassy-rp/src/pio_programs/uart.rs b/embassy-rp/src/pio_programs/uart.rs
index d59596dd1..a16d89a75 100644
--- a/embassy-rp/src/pio_programs/uart.rs
+++ b/embassy-rp/src/pio_programs/uart.rs
@@ -90,6 +90,10 @@ impl<PIO: Instance, const SM: usize> Write for PioUartTx<'_, PIO, SM> {
         }
         Ok(buf.len())
     }
+
+    async fn flush(&mut self) -> Result<(), Infallible> {
+        Ok(())
+    }
 }
 
 /// This struct represents a Uart Rx program loaded into pio instruction memory.
diff --git a/embassy-rp/src/uart/mod.rs b/embassy-rp/src/uart/mod.rs
index b7b569dd5..f53b2f88e 100644
--- a/embassy-rp/src/uart/mod.rs
+++ b/embassy-rp/src/uart/mod.rs
@@ -118,6 +118,14 @@ pub enum Error {
     Framing,
 }
 
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Debug::fmt(self, f)
+    }
+}
+
+impl core::error::Error for Error {}
+
 /// Read To Break error
 #[derive(Debug, Eq, PartialEq, Copy, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
diff --git a/embassy-stm32-wpan/src/wb55/mod.rs b/embassy-stm32-wpan/src/wb55/mod.rs
index 95cfe09f1..814303a05 100644
--- a/embassy-stm32-wpan/src/wb55/mod.rs
+++ b/embassy-stm32-wpan/src/wb55/mod.rs
@@ -176,7 +176,7 @@ impl<'d> TlMbox<'d> {
         let mm = sub::mm::MemoryManager::new(ipcc_mm_release_buffer_channel);
         let mut sys = sub::sys::Sys::new(ipcc_system_cmd_rsp_channel, ipcc_system_event_channel);
 
-        debug!("sys event: {}", sys.read().await.payload());
+        debug!("sys event: {}", sys.read_ready().await);
 
         Self {
             sys_subsystem: sys,
diff --git a/embassy-stm32-wpan/src/wb55/shci.rs b/embassy-stm32-wpan/src/wb55/shci.rs
index 3faa79209..3eb9525d3 100644
--- a/embassy-stm32-wpan/src/wb55/shci.rs
+++ b/embassy-stm32-wpan/src/wb55/shci.rs
@@ -12,6 +12,28 @@ const fn opcode(ogf: u16, ocf: u16) -> isize {
     ((ogf << 10) + ocf) as isize
 }
 
+pub(crate) trait SealedSchiFromPacket: Sized {
+    unsafe fn from_packet(cmd_buf: *const CmdPacket) -> Result<Self, ()>;
+}
+
+#[allow(private_bounds)]
+pub trait SchiFromPacket: SealedSchiFromPacket {}
+impl<T: SealedSchiFromPacket> SchiFromPacket for T {}
+
+trait ShciFromEventSerial: TryFrom<u8, Error = ()> {}
+
+impl<T: ShciFromEventSerial> SealedSchiFromPacket for T {
+    unsafe fn from_packet(cmd_buf: *const CmdPacket) -> Result<Self, ()> {
+        let p_cmd_serial = (cmd_buf as *mut u8).add(size_of::<PacketHeader>());
+        let p_evt_payload = p_cmd_serial.add(size_of::<EvtStub>());
+
+        compiler_fence(Ordering::Acquire);
+        let cc_evt = ptr::read_unaligned(p_evt_payload as *const CcEvt);
+
+        cc_evt.payload[0].try_into()
+    }
+}
+
 #[allow(dead_code)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum SchiCommandStatus {
@@ -25,37 +47,20 @@ pub enum SchiCommandStatus {
     ShciFusCmdNotSupported = 0xFF,
 }
 
-impl SchiCommandStatus {
-    pub unsafe fn from_packet(cmd_buf: *const CmdPacket) -> Result<Self, ()> {
-        let p_cmd_serial = (cmd_buf as *mut u8).add(size_of::<PacketHeader>());
-        let p_evt_payload = p_cmd_serial.add(size_of::<EvtStub>());
-
-        compiler_fence(Ordering::Acquire);
-        let cc_evt = ptr::read_unaligned(p_evt_payload as *const CcEvt);
-
-        cc_evt.payload[0].try_into()
-    }
-}
-
+impl ShciFromEventSerial for SchiCommandStatus {}
 impl TryFrom<u8> for SchiCommandStatus {
     type Error = ();
 
     fn try_from(v: u8) -> Result<Self, Self::Error> {
         match v {
-            x if x == SchiCommandStatus::ShciSuccess as u8 => Ok(SchiCommandStatus::ShciSuccess),
-            x if x == SchiCommandStatus::ShciUnknownCmd as u8 => Ok(SchiCommandStatus::ShciUnknownCmd),
-            x if x == SchiCommandStatus::ShciMemoryCapacityExceededErrCode as u8 => {
-                Ok(SchiCommandStatus::ShciMemoryCapacityExceededErrCode)
-            }
-            x if x == SchiCommandStatus::ShciErrUnsupportedFeature as u8 => {
-                Ok(SchiCommandStatus::ShciErrUnsupportedFeature)
-            }
-            x if x == SchiCommandStatus::ShciErrInvalidHciCmdParams as u8 => {
-                Ok(SchiCommandStatus::ShciErrInvalidHciCmdParams)
-            }
-            x if x == SchiCommandStatus::ShciErrInvalidParams as u8 => Ok(SchiCommandStatus::ShciErrInvalidParams), /* only used for release < v1.13.0 */
-            x if x == SchiCommandStatus::ShciErrInvalidParamsV2 as u8 => Ok(SchiCommandStatus::ShciErrInvalidParamsV2), /* available for release >= v1.13.0 */
-            x if x == SchiCommandStatus::ShciFusCmdNotSupported as u8 => Ok(SchiCommandStatus::ShciFusCmdNotSupported),
+            0x00 => Ok(Self::ShciSuccess),
+            0x01 => Ok(Self::ShciUnknownCmd),
+            0x07 => Ok(Self::ShciMemoryCapacityExceededErrCode),
+            0x11 => Ok(Self::ShciErrUnsupportedFeature),
+            0x12 => Ok(Self::ShciErrInvalidHciCmdParams),
+            0x42 => Ok(Self::ShciErrInvalidParams), /* only used for release < v1.13.0 */
+            0x92 => Ok(Self::ShciErrInvalidParamsV2), /* available for release >= v1.13.0 */
+            0xFF => Ok(Self::ShciFusCmdNotSupported),
             _ => Err(()),
         }
     }
@@ -107,6 +112,71 @@ pub enum ShciOpcode {
     Mac802_15_4DeInit = opcode(SHCI_OGF, 0x78),
 }
 
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum ShciFusGetStateErrorCode {
+    FusStateErrorNoError = 0x00,
+    FusStateErrorImgNotFound = 0x01,
+    FusStateErrorImgCorrupt = 0x02,
+    FusStateErrorImgNotAuthentic = 0x03,
+    FusStateErrorImgNotEnoughSpace = 0x04,
+    FusStateErrorImageUsrAbort = 0x05,
+    FusStateErrorImageErsError = 0x06,
+    FusStateErrorImageWrtError = 0x07,
+    FusStateErrorAuthTagStNotFound = 0x08,
+    FusStateErrorAuthTagCustNotFound = 0x09,
+    FusStateErrorAuthKeyLocked = 0x0A,
+    FusStateErrorFwRollbackError = 0x11,
+    FusStateErrorStateNotRunning = 0xFE,
+    FusStateErrorErrUnknown = 0xFF,
+}
+
+impl ShciFromEventSerial for ShciFusGetStateErrorCode {}
+impl TryFrom<u8> for ShciFusGetStateErrorCode {
+    type Error = ();
+
+    fn try_from(v: u8) -> Result<Self, Self::Error> {
+        match v {
+            0x00 => Ok(Self::FusStateErrorNoError),
+            0x01 => Ok(Self::FusStateErrorImgNotFound),
+            0x02 => Ok(Self::FusStateErrorImgCorrupt),
+            0x03 => Ok(Self::FusStateErrorImgNotAuthentic),
+            0x04 => Ok(Self::FusStateErrorImgNotEnoughSpace),
+            0x05 => Ok(Self::FusStateErrorImageUsrAbort),
+            0x06 => Ok(Self::FusStateErrorImageErsError),
+            0x07 => Ok(Self::FusStateErrorImageWrtError),
+            0x08 => Ok(Self::FusStateErrorAuthTagStNotFound),
+            0x09 => Ok(Self::FusStateErrorAuthTagCustNotFound),
+            0x0A => Ok(Self::FusStateErrorAuthKeyLocked),
+            0x11 => Ok(Self::FusStateErrorFwRollbackError),
+            0xFE => Ok(Self::FusStateErrorStateNotRunning),
+            0xFF => Ok(Self::FusStateErrorErrUnknown),
+            _ => Err(()),
+        }
+    }
+}
+
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum SchiSysEventReady {
+    WirelessFwRunning = 0x00,
+    FusFwRunning = 0x01,
+    NvmBackupRunning = 0x10,
+    NvmRestoreRunning = 0x11,
+}
+
+impl TryFrom<u8> for SchiSysEventReady {
+    type Error = ();
+
+    fn try_from(v: u8) -> Result<Self, Self::Error> {
+        match v {
+            0x00 => Ok(Self::WirelessFwRunning),
+            0x01 => Ok(Self::FusFwRunning),
+            0x10 => Ok(Self::NvmBackupRunning),
+            0x11 => Ok(Self::NvmRestoreRunning),
+            _ => Err(()),
+        }
+    }
+}
+
 pub const SHCI_C2_CONFIG_EVTMASK1_BIT0_ERROR_NOTIF_ENABLE: u8 = 1 << 0;
 pub const SHCI_C2_CONFIG_EVTMASK1_BIT1_BLE_NVM_RAM_UPDATE_ENABLE: u8 = 1 << 1;
 pub const SHCI_C2_CONFIG_EVTMASK1_BIT2_THREAD_NVM_RAM_UPDATE_ENABLE: u8 = 1 << 2;
diff --git a/embassy-stm32-wpan/src/wb55/sub/sys.rs b/embassy-stm32-wpan/src/wb55/sub/sys.rs
index 2e625a677..3d774eeb7 100644
--- a/embassy-stm32-wpan/src/wb55/sub/sys.rs
+++ b/embassy-stm32-wpan/src/wb55/sub/sys.rs
@@ -1,3 +1,5 @@
+use core::slice;
+
 use embassy_stm32::ipcc::{IpccRxChannel, IpccTxChannel};
 
 use crate::cmd::CmdPacket;
@@ -5,12 +7,17 @@ use crate::consts::TlPacketType;
 use crate::evt::EvtBox;
 #[cfg(feature = "wb55_ble")]
 use crate::shci::ShciBleInitCmdParam;
-use crate::shci::{SchiCommandStatus, ShciOpcode};
+use crate::shci::{SchiCommandStatus, SchiFromPacket, SchiSysEventReady, ShciFusGetStateErrorCode, ShciOpcode};
 use crate::sub::mm;
 use crate::tables::{SysTable, WirelessFwInfoTable};
 use crate::unsafe_linked_list::LinkedListNode;
 use crate::wb55::{SYS_CMD_BUF, SYSTEM_EVT_QUEUE, TL_DEVICE_INFO_TABLE, TL_SYS_TABLE};
 
+const fn slice8_ref(x: &[u32]) -> &[u8] {
+    let len = x.len() * 4;
+    unsafe { slice::from_raw_parts(x.as_ptr() as *const u8, len) }
+}
+
 /// A guard that, once constructed, allows for sys commands to be sent to CPU2.
 pub struct Sys<'a> {
     ipcc_system_cmd_rsp_channel: IpccTxChannel<'a>,
@@ -55,15 +62,15 @@ impl<'a> Sys<'a> {
     }
 
     /// `HW_IPCC_SYS_CmdEvtNot`
-    pub async fn write_and_get_response(
+    pub async fn write_and_get_response<T: SchiFromPacket>(
         &mut self,
         opcode: ShciOpcode,
         payload: &[u8],
-    ) -> Result<SchiCommandStatus, ()> {
+    ) -> Result<T, ()> {
         self.write(opcode, payload).await;
         self.ipcc_system_cmd_rsp_channel.flush().await;
 
-        unsafe { SchiCommandStatus::from_packet(SYS_CMD_BUF.as_ptr()) }
+        unsafe { T::from_packet(SYS_CMD_BUF.as_ptr()) }
     }
 
     #[cfg(feature = "wb55_mac")]
@@ -82,6 +89,36 @@ impl<'a> Sys<'a> {
         self.write_and_get_response(ShciOpcode::BleInit, param.payload()).await
     }
 
+    pub async fn shci_c2_fus_getstate(&mut self) -> Result<ShciFusGetStateErrorCode, ()> {
+        self.write_and_get_response(ShciOpcode::FusStartWirelessStack, &[])
+            .await
+    }
+
+    /// Send a request to CPU2 to start the wireless stack
+    pub async fn shci_c2_fus_startws(&mut self) -> Result<SchiCommandStatus, ()> {
+        self.write_and_get_response(ShciOpcode::FusStartWirelessStack, &[])
+            .await
+    }
+
+    /// Send a request to CPU2 to upgrade the firmware
+    pub async fn shci_c2_fus_fwupgrade(&mut self, fw_src_add: u32, fw_dst_add: u32) -> Result<SchiCommandStatus, ()> {
+        let buf = [fw_src_add, fw_dst_add];
+        let len = if fw_dst_add != 0 {
+            2
+        } else if fw_src_add != 0 {
+            1
+        } else {
+            0
+        };
+
+        self.write_and_get_response(ShciOpcode::FusFirmwareUpgrade, slice8_ref(&buf[..len]))
+            .await
+    }
+
+    pub async fn read_ready(&mut self) -> Result<SchiSysEventReady, ()> {
+        self.read().await.payload()[0].try_into()
+    }
+
     /// `HW_IPCC_SYS_EvtNot`
     ///
     /// This method takes the place of the `HW_IPCC_SYS_EvtNot`/`SysUserEvtRx`/`APPE_SysUserEvtRx`,
diff --git a/embassy-stm32/Cargo.toml b/embassy-stm32/Cargo.toml
index e96933b78..27f26df28 100644
--- a/embassy-stm32/Cargo.toml
+++ b/embassy-stm32/Cargo.toml
@@ -184,8 +184,8 @@ vcell = "0.1.3"
 nb = "1.0.0"
 stm32-fmc = "0.4.0"
 cfg-if = "1.0.0"
-embedded-io = { version = "0.6.0" }
-embedded-io-async = { version = "0.6.1" }
+embedded-io = { version = "0.7.1" }
+embedded-io-async = { version = "0.7.0" }
 chrono = { version = "^0.4", default-features = false, optional = true }
 bit_field = "0.10.2"
 trait-set = "0.3.0"
@@ -228,7 +228,7 @@ defmt = [
     "embassy-sync/defmt",
     "embassy-embedded-hal/defmt",
     "embassy-hal-internal/defmt",
-    "embedded-io-async/defmt-03",
+    "embedded-io-async/defmt",
     "embassy-usb-driver/defmt",
     "embassy-net-driver/defmt",
     "embassy-time?/defmt",
@@ -241,9 +241,9 @@ log = ["dep:log"]
 chrono = ["dep:chrono"]
 
 exti = []
-low-power = [ "dep:embassy-executor", "time" ]
-low-power-pender = [ ]
-low-power-debug-with-sleep = []
+low-power = [ "dep:embassy-executor", "time", "chrono" ]
+low-power-pender = [ "low-power" ]
+low-power-debug-with-sleep = [ "low-power" ]
 
 ## Automatically generate `memory.x` file based on the memory map from [`stm32-metapac`](https://docs.rs/stm32-metapac/)
 memory-x = []
diff --git a/embassy-stm32/src/lib.rs b/embassy-stm32/src/lib.rs
index 2f783bf64..a0b2f045c 100644
--- a/embassy-stm32/src/lib.rs
+++ b/embassy-stm32/src/lib.rs
@@ -138,6 +138,9 @@ pub mod wdg;
 #[cfg(xspi)]
 pub mod xspi;
 
+#[cfg(feature = "low-power")]
+pub use low_power::Executor;
+
 // This must go last, so that it sees all the impl_foo! macros defined earlier.
 pub(crate) mod _generated {
     #![allow(dead_code)]
diff --git a/embassy-stm32/src/low_power.rs b/embassy-stm32/src/low_power.rs
index 5c10c1a5d..02116e08a 100644
--- a/embassy-stm32/src/low_power.rs
+++ b/embassy-stm32/src/low_power.rs
@@ -3,31 +3,31 @@
 //! The STM32 line of microcontrollers support various deep-sleep modes which exploit clock-gating
 //! to reduce power consumption. `embassy-stm32` provides a low-power executor, [`Executor`] which
 //! can use knowledge of which peripherals are currently blocked upon to transparently and safely
-//! enter such low-power modes (currently, only `STOP2`) when idle.
+//! enter such low-power modes including `STOP1` and `STOP2` when idle.
 //!
 //! The executor determines which peripherals are active by their RCC state; consequently,
-//! low-power states can only be entered if all peripherals have been `drop`'d. There are a few
-//! exceptions to this rule:
+//! low-power states can only be entered if peripherals which block stop have been `drop`'d and if
+//! peripherals that do not block stop are busy. Peripherals which never block stop include:
 //!
 //!  * `GPIO`
 //!  * `RTC`
 //!
+//! Other peripherals which block stop when busy include (this list may be stale):
+//!
+//!  * `I2C`
+//!  * `USART`
+//!
 //! Since entering and leaving low-power modes typically incurs a significant latency, the
 //! low-power executor will only attempt to enter when the next timer event is at least
-//! [`time_driver::min_stop_pause`] in the future.
+//! [`config.min_stop_pause`] in the future.
 //!
-//! Currently there is no macro analogous to `embassy_executor::main` for this executor;
-//! consequently one must define their entrypoint manually. Moreover, you must relinquish control
-//! of the `RTC` peripheral to the executor. This will typically look like
 //!
 //! ```rust,no_run
 //! use embassy_executor::Spawner;
-//! use embassy_stm32::low_power;
-//! use embassy_stm32::rtc::{Rtc, RtcConfig};
 //! use embassy_time::Duration;
 //!
-//! #[embassy_executor::main(executor = "low_power::Executor")]
-//! async fn async_main(spawner: Spawner) {
+//! #[embassy_executor::main(executor = "embassy_stm32::Executor", entry = "cortex_m_rt::entry")]
+//! async fn main(spawner: Spawner) {
 //!     // initialize the platform...
 //!     let mut config = embassy_stm32::Config::default();
 //!     // the default value, but can be adjusted
@@ -210,7 +210,7 @@ impl Executor {
                     w.set_c1cssf(false);
                 });
 
-                let has_stopped2 = {
+                let _has_stopped2 = {
                     #[cfg(stm32wb)]
                     {
                         es.c2stopf()
@@ -222,10 +222,11 @@ impl Executor {
                     }
                 };
 
-                if es.c1stopf() || has_stopped2 {
+                #[cfg(not(stm32wb))]
+                if es.c1stopf() || _has_stopped2 {
                     // when we wake from any stop mode we need to re-initialize the rcc
                     crate::rcc::init(RCC_CONFIG.unwrap());
-                    if has_stopped2 {
+                    if _has_stopped2 {
                         // when we wake from STOP2, we need to re-initialize the time driver
                         get_driver().init_timer(cs);
                         // reset the refcounts for STOP2 and STOP1 (initializing the time driver will increment one of them for the timer)
diff --git a/embassy-stm32/src/rcc/c0.rs b/embassy-stm32/src/rcc/c0.rs
index 99f22273d..7801078c3 100644
--- a/embassy-stm32/src/rcc/c0.rs
+++ b/embassy-stm32/src/rcc/c0.rs
@@ -185,6 +185,12 @@ pub(crate) unsafe fn init(config: Config) {
         RCC.cr().modify(|w| w.set_hsion(false));
     }
 
+    // Disable the HSI48, if not used
+    #[cfg(crs)]
+    if config.hsi48.is_none() {
+        super::disable_hsi48();
+    }
+
     config.mux.init();
 
     set_clocks!(
diff --git a/embassy-stm32/src/rcc/f013.rs b/embassy-stm32/src/rcc/f013.rs
index 1155b6acd..92cf9fca7 100644
--- a/embassy-stm32/src/rcc/f013.rs
+++ b/embassy-stm32/src/rcc/f013.rs
@@ -480,6 +480,12 @@ pub(crate) unsafe fn init(config: Config) {
     };
      */
 
+    // Disable the HSI48, if not used
+    #[cfg(crs)]
+    if config.hsi48.is_none() {
+        super::disable_hsi48();
+    }
+
     config.mux.init();
 
     set_clocks!(
diff --git a/embassy-stm32/src/rcc/g0.rs b/embassy-stm32/src/rcc/g0.rs
index ce6398afd..2665c20f9 100644
--- a/embassy-stm32/src/rcc/g0.rs
+++ b/embassy-stm32/src/rcc/g0.rs
@@ -294,6 +294,12 @@ pub(crate) unsafe fn init(config: Config) {
         RCC.cr().modify(|w| w.set_hsion(false));
     }
 
+    // Disable the HSI48, if not used
+    #[cfg(crs)]
+    if config.hsi48.is_none() {
+        super::disable_hsi48();
+    }
+
     if config.low_power_run {
         assert!(sys <= Hertz(2_000_000));
         PWR.cr1().modify(|w| w.set_lpr(true));
diff --git a/embassy-stm32/src/rcc/g4.rs b/embassy-stm32/src/rcc/g4.rs
index da13e16aa..0dd3713c8 100644
--- a/embassy-stm32/src/rcc/g4.rs
+++ b/embassy-stm32/src/rcc/g4.rs
@@ -300,6 +300,12 @@ pub(crate) unsafe fn init(config: Config) {
         RCC.cr().modify(|w| w.set_hsion(false));
     }
 
+    // Disable the HSI48, if not used
+    #[cfg(crs)]
+    if config.hsi48.is_none() {
+        super::disable_hsi48();
+    }
+
     if config.low_power_run {
         assert!(sys <= Hertz(2_000_000));
         PWR.cr1().modify(|w| w.set_lpr(true));
diff --git a/embassy-stm32/src/rcc/h.rs b/embassy-stm32/src/rcc/h.rs
index 485edd390..2fe2a435c 100644
--- a/embassy-stm32/src/rcc/h.rs
+++ b/embassy-stm32/src/rcc/h.rs
@@ -671,6 +671,12 @@ pub(crate) unsafe fn init(config: Config) {
         RCC.cr().modify(|w| w.set_hsion(false));
     }
 
+    // Disable the HSI48, if not used
+    #[cfg(crs)]
+    if config.hsi48.is_none() {
+        super::disable_hsi48();
+    }
+
     // IO compensation cell - Requires CSI clock and SYSCFG
     #[cfg(any(stm32h7))] // TODO h5, h7rs
     if csi.is_some() {
diff --git a/embassy-stm32/src/rcc/hsi48.rs b/embassy-stm32/src/rcc/hsi48.rs
index 49be4af5e..50ac162a4 100644
--- a/embassy-stm32/src/rcc/hsi48.rs
+++ b/embassy-stm32/src/rcc/hsi48.rs
@@ -66,3 +66,24 @@ pub(crate) fn init_hsi48(config: Hsi48Config) -> Hertz {
 
     HSI48_FREQ
 }
+
+pub(crate) fn disable_hsi48() {
+    // disable CRS if it is enabled
+    rcc::disable::<crate::peripherals::CRS>();
+
+    // Disable HSI48
+    #[cfg(not(any(stm32u5, stm32g0, stm32h5, stm32h7, stm32h7rs, stm32u5, stm32wba, stm32f0, stm32c071)))]
+    let r = RCC.crrcr();
+    #[cfg(any(stm32u5, stm32g0, stm32h5, stm32h7, stm32h7rs, stm32u5, stm32wba, stm32c071))]
+    let r = RCC.cr();
+    #[cfg(any(stm32f0))]
+    let r = RCC.cr2();
+
+    r.modify(|w| w.set_hsi48on(false));
+
+    // Disable VREFINT reference for HSI48 oscillator
+    #[cfg(stm32l0)]
+    crate::pac::SYSCFG.cfgr3().modify(|w| {
+        w.set_enref_hsi48(false);
+    });
+}
diff --git a/embassy-stm32/src/rcc/l.rs b/embassy-stm32/src/rcc/l.rs
index 0d668103c..55f383374 100644
--- a/embassy-stm32/src/rcc/l.rs
+++ b/embassy-stm32/src/rcc/l.rs
@@ -385,6 +385,17 @@ pub(crate) unsafe fn init(config: Config) {
         while !RCC.extcfgr().read().c2hpref() {}
     }
 
+    // Disable HSI if not used
+    if !config.hsi {
+        RCC.cr().modify(|w| w.set_hsion(false));
+    }
+
+    // Disable the HSI48, if not used
+    #[cfg(crs)]
+    if config.hsi48.is_none() {
+        super::disable_hsi48();
+    }
+
     config.mux.init();
 
     set_clocks!(
diff --git a/embassy-stm32/src/rcc/u5.rs b/embassy-stm32/src/rcc/u5.rs
index 47cc29c6f..9f37107a3 100644
--- a/embassy-stm32/src/rcc/u5.rs
+++ b/embassy-stm32/src/rcc/u5.rs
@@ -467,6 +467,17 @@ pub(crate) unsafe fn init(config: Config) {
     let lse = config.ls.lse.map(|l| l.frequency);
     let lsi = config.ls.lsi.then_some(LSI_FREQ);
 
+    // Disable HSI if not used
+    if !config.hsi {
+        RCC.cr().modify(|w| w.set_hsion(false));
+    }
+
+    // Disable the HSI48, if not used
+    #[cfg(crs)]
+    if config.hsi48.is_none() {
+        super::disable_hsi48();
+    }
+
     config.mux.init();
 
     set_clocks!(
diff --git a/embassy-stm32/src/rcc/wba.rs b/embassy-stm32/src/rcc/wba.rs
index 2528996d5..4ab3067bc 100644
--- a/embassy-stm32/src/rcc/wba.rs
+++ b/embassy-stm32/src/rcc/wba.rs
@@ -269,6 +269,11 @@ pub(crate) unsafe fn init(config: Config) {
 
     let lsi = config.ls.lsi.then_some(LSI_FREQ);
 
+    // Disable HSI if not used
+    if !config.hsi {
+        RCC.cr().modify(|w| w.set_hsion(false));
+    }
+
     config.mux.init();
 
     set_clocks!(
diff --git a/embassy-stm32/src/rtc/low_power.rs b/embassy-stm32/src/rtc/low_power.rs
index f049d6b12..cd5cea081 100644
--- a/embassy-stm32/src/rtc/low_power.rs
+++ b/embassy-stm32/src/rtc/low_power.rs
@@ -1,64 +1,12 @@
-#[cfg(feature = "time")]
-use embassy_time::{Duration, TICK_HZ};
+use chrono::{DateTime, NaiveDateTime, TimeDelta, Utc};
+use embassy_time::{Duration, Instant, TICK_HZ};
 
-use super::{DateTimeError, Rtc, RtcError, bcd2_to_byte};
+use super::Rtc;
 use crate::interrupt::typelevel::Interrupt;
 use crate::pac::rtc::vals::Wucksel;
 use crate::peripherals::RTC;
 use crate::rtc::{RtcTimeProvider, SealedInstance};
 
-/// Represents an instant in time that can be substracted to compute a duration
-pub(super) struct RtcInstant {
-    /// 0..59
-    second: u8,
-    /// 0..256
-    subsecond: u16,
-}
-
-impl RtcInstant {
-    #[cfg(not(rtc_v2_f2))]
-    const fn from(second: u8, subsecond: u16) -> Result<Self, DateTimeError> {
-        if second > 59 {
-            Err(DateTimeError::InvalidSecond)
-        } else {
-            Ok(Self { second, subsecond })
-        }
-    }
-}
-
-#[cfg(feature = "defmt")]
-impl defmt::Format for RtcInstant {
-    fn format(&self, fmt: defmt::Formatter) {
-        defmt::write!(
-            fmt,
-            "{}:{}",
-            self.second,
-            RTC::regs().prer().read().prediv_s() - self.subsecond,
-        )
-    }
-}
-
-#[cfg(feature = "time")]
-impl core::ops::Sub for RtcInstant {
-    type Output = embassy_time::Duration;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        let second = if self.second < rhs.second {
-            self.second + 60
-        } else {
-            self.second
-        };
-
-        let psc = RTC::regs().prer().read().prediv_s() as u32;
-
-        let self_ticks = second as u32 * (psc + 1) + (psc - self.subsecond as u32);
-        let other_ticks = rhs.second as u32 * (psc + 1) + (psc - rhs.subsecond as u32);
-        let rtc_ticks = self_ticks - other_ticks;
-
-        Duration::from_ticks(((rtc_ticks * TICK_HZ as u32) / (psc + 1)) as u64)
-    }
-}
-
 fn wucksel_compute_min(val: u32) -> (Wucksel, u32) {
     *[
         (Wucksel::DIV2, 2),
@@ -72,22 +20,15 @@ fn wucksel_compute_min(val: u32) -> (Wucksel, u32) {
 }
 
 impl Rtc {
-    /// Return the current instant.
-    fn instant(&self) -> Result<RtcInstant, RtcError> {
-        RtcTimeProvider::new().read(|_, tr, ss| {
-            let second = bcd2_to_byte((tr.st(), tr.su()));
+    pub(super) fn calc_epoch(&self) -> DateTime<Utc> {
+        let now: NaiveDateTime = RtcTimeProvider::new().now().unwrap().into();
 
-            RtcInstant::from(second, ss).map_err(RtcError::InvalidDateTime)
-        })
+        now.and_utc() - TimeDelta::microseconds(Instant::now().as_micros().try_into().unwrap())
     }
 
     /// start the wakeup alarm and with a duration that is as close to but less than
     /// the requested duration, and record the instant the wakeup alarm was started
-    pub(crate) fn start_wakeup_alarm(
-        &mut self,
-        requested_duration: embassy_time::Duration,
-        cs: critical_section::CriticalSection,
-    ) {
+    pub(crate) fn start_wakeup_alarm(&mut self, requested_duration: embassy_time::Duration) {
         // Panic if the rcc mod knows we're not using low-power rtc
         #[cfg(any(rcc_wb, rcc_f4, rcc_f410))]
         unsafe { crate::rcc::get_freqs() }.rtc.to_hertz().unwrap();
@@ -122,27 +63,19 @@ impl Rtc {
             regs.cr().modify(|w| w.set_wutie(true));
         });
 
-        let instant = self.instant().unwrap();
         trace!(
-            "rtc: start wakeup alarm for {} ms (psc: {}, ticks: {}) at {}",
+            "rtc: start wakeup alarm for {} ms (psc: {}, ticks: {})",
             Duration::from_ticks(rtc_ticks as u64 * TICK_HZ * prescaler as u64 / rtc_hz).as_millis(),
             prescaler as u32,
             rtc_ticks,
-            instant,
         );
-
-        assert!(self.stop_time.borrow(cs).replace(Some(instant)).is_none())
     }
 
     /// stop the wakeup alarm and return the time elapsed since `start_wakeup_alarm`
     /// was called, otherwise none
-    pub(crate) fn stop_wakeup_alarm(
-        &mut self,
-        cs: critical_section::CriticalSection,
-    ) -> Option<embassy_time::Duration> {
-        let instant = self.instant().unwrap();
+    pub(crate) fn stop_wakeup_alarm(&mut self) -> embassy_time::Instant {
         if RTC::regs().cr().read().wute() {
-            trace!("rtc: stop wakeup alarm at {}", instant);
+            trace!("rtc: stop wakeup alarm");
 
             self.write(false, |regs| {
                 regs.cr().modify(|w| w.set_wutie(false));
@@ -166,10 +99,13 @@ impl Rtc {
             });
         }
 
-        self.stop_time.borrow(cs).take().map(|stop_time| instant - stop_time)
+        let datetime: NaiveDateTime = RtcTimeProvider::new().now().expect("failed to read now").into();
+        let offset = datetime.and_utc() - self.epoch;
+
+        Instant::from_micros(offset.num_microseconds().unwrap().try_into().unwrap())
     }
 
-    pub(crate) fn enable_wakeup_line(&self) {
+    pub(super) fn enable_wakeup_line(&mut self) {
         <RTC as crate::rtc::SealedInstance>::WakeupInterrupt::unpend();
         unsafe { <RTC as crate::rtc::SealedInstance>::WakeupInterrupt::enable() };
 
diff --git a/embassy-stm32/src/rtc/mod.rs b/embassy-stm32/src/rtc/mod.rs
index e88bd7ab2..94ba13ae1 100644
--- a/embassy-stm32/src/rtc/mod.rs
+++ b/embassy-stm32/src/rtc/mod.rs
@@ -5,7 +5,7 @@ mod datetime;
 mod low_power;
 
 #[cfg(feature = "low-power")]
-use core::cell::{Cell, RefCell, RefMut};
+use core::cell::{RefCell, RefMut};
 #[cfg(feature = "low-power")]
 use core::ops;
 
@@ -163,7 +163,7 @@ impl<'a> ops::DerefMut for RtcBorrow<'a> {
 /// RTC driver.
 pub struct Rtc {
     #[cfg(feature = "low-power")]
-    stop_time: Mutex<CriticalSectionRawMutex, Cell<Option<low_power::RtcInstant>>>,
+    epoch: chrono::DateTime<chrono::Utc>,
     _private: (),
 }
 
@@ -225,7 +225,7 @@ impl Rtc {
 
         let mut this = Self {
             #[cfg(feature = "low-power")]
-            stop_time: Mutex::const_new(CriticalSectionRawMutex::new(), Cell::new(None)),
+            epoch: chrono::DateTime::from_timestamp_secs(0).unwrap(),
             _private: (),
         };
 
@@ -243,7 +243,10 @@ impl Rtc {
         }
 
         #[cfg(feature = "low-power")]
-        this.enable_wakeup_line();
+        {
+            this.enable_wakeup_line();
+            this.epoch = this.calc_epoch();
+        }
 
         this
     }
@@ -293,6 +296,11 @@ impl Rtc {
             });
         });
 
+        #[cfg(feature = "low-power")]
+        {
+            self.epoch = self.calc_epoch();
+        }
+
         Ok(())
     }
 
diff --git a/embassy-stm32/src/time_driver.rs b/embassy-stm32/src/time_driver.rs
index ed5d902bd..59ec58575 100644
--- a/embassy-stm32/src/time_driver.rs
+++ b/embassy-stm32/src/time_driver.rs
@@ -251,8 +251,8 @@ impl RtcDriver {
 
     #[cfg(feature = "low-power")]
     /// Add the given offset to the current time
-    fn add_time(&self, offset: embassy_time::Duration, cs: CriticalSection) {
-        let (period, counter) = calc_period_counter(self.now() + offset.as_ticks());
+    fn set_time(&self, instant: u64, cs: CriticalSection) {
+        let (period, counter) = calc_period_counter(core::cmp::max(self.now(), instant));
 
         self.period.store(period, Ordering::SeqCst);
         regs_gp16().cnt().write(|w| w.set_cnt(counter));
@@ -269,10 +269,17 @@ impl RtcDriver {
     #[cfg(feature = "low-power")]
     /// Stop the wakeup alarm, if enabled, and add the appropriate offset
     fn stop_wakeup_alarm(&self, cs: CriticalSection) {
-        if !regs_gp16().cr1().read().cen()
-            && let Some(offset) = self.rtc.borrow(cs).borrow_mut().as_mut().unwrap().stop_wakeup_alarm(cs)
-        {
-            self.add_time(offset, cs);
+        if !regs_gp16().cr1().read().cen() {
+            self.set_time(
+                self.rtc
+                    .borrow(cs)
+                    .borrow_mut()
+                    .as_mut()
+                    .unwrap()
+                    .stop_wakeup_alarm()
+                    .as_ticks(),
+                cs,
+            );
         }
     }
 
@@ -287,7 +294,7 @@ impl RtcDriver {
     #[cfg(feature = "low-power")]
     /// Set the rtc but panic if it's already been set
     pub(crate) fn set_rtc(&self, cs: CriticalSection, mut rtc: Rtc) {
-        rtc.stop_wakeup_alarm(cs);
+        rtc.stop_wakeup_alarm();
 
         assert!(self.rtc.borrow(cs).replace(Some(rtc)).is_none());
     }
@@ -310,7 +317,7 @@ impl RtcDriver {
                 .borrow_mut()
                 .as_mut()
                 .unwrap()
-                .start_wakeup_alarm(time_until_next_alarm, cs);
+                .start_wakeup_alarm(time_until_next_alarm);
 
             regs_gp16().cr1().modify(|w| w.set_cen(false));
             // save the count for the timer as its lost in STOP2 for stm32wlex
diff --git a/embassy-sync/Cargo.toml b/embassy-sync/Cargo.toml
index 0c28cec7d..86c87b7b1 100644
--- a/embassy-sync/Cargo.toml
+++ b/embassy-sync/Cargo.toml
@@ -41,7 +41,7 @@ futures-core = { version = "0.3.31", default-features = false }
 critical-section = "1.1"
 heapless = "0.8"
 cfg-if = "1.0.0"
-embedded-io-async = { version = "0.6.1" }
+embedded-io-async = { version = "0.7.0" }
 
 [dev-dependencies]
 futures-executor = { version = "0.3.17", features = [ "thread-pool" ] }
diff --git a/embassy-usb-driver/Cargo.toml b/embassy-usb-driver/Cargo.toml
index 3f43f60a3..a11658213 100644
--- a/embassy-usb-driver/Cargo.toml
+++ b/embassy-usb-driver/Cargo.toml
@@ -19,6 +19,7 @@ target = "thumbv7em-none-eabi"
 features = ["defmt"]
 
 [dependencies]
+# TODO: remove before releasing embassy-usb-driver v0.3
 embedded-io-async = "0.6.1"
 defmt = { version = "1", optional = true }
 
diff --git a/embassy-usb-driver/src/lib.rs b/embassy-usb-driver/src/lib.rs
index f19e0a401..782f130f6 100644
--- a/embassy-usb-driver/src/lib.rs
+++ b/embassy-usb-driver/src/lib.rs
@@ -429,6 +429,7 @@ pub enum EndpointError {
     Disabled,
 }
 
+// TODO: remove before releasing embassy-usb-driver v0.3
 impl embedded_io_async::Error for EndpointError {
     fn kind(&self) -> embedded_io_async::ErrorKind {
         match self {
diff --git a/embassy-usb/Cargo.toml b/embassy-usb/Cargo.toml
index 3d1e005e4..6c3ddc1db 100644
--- a/embassy-usb/Cargo.toml
+++ b/embassy-usb/Cargo.toml
@@ -66,7 +66,7 @@ embassy-net-driver-channel = { version = "0.3.2", path = "../embassy-net-driver-
 defmt = { version = "1", optional = true }
 log = { version = "0.4.14", optional = true }
 heapless = "0.8"
-embedded-io-async = "0.6.1"
+embedded-io-async = { version = "0.7.0" }
 
 # for HID
 usbd-hid = { version = "0.9.0", optional = true }
diff --git a/embassy-usb/src/class/cdc_acm.rs b/embassy-usb/src/class/cdc_acm.rs
index ab2311f4e..56acdb2a6 100644
--- a/embassy-usb/src/class/cdc_acm.rs
+++ b/embassy-usb/src/class/cdc_acm.rs
@@ -33,6 +33,30 @@ const REQ_SET_LINE_CODING: u8 = 0x20;
 const REQ_GET_LINE_CODING: u8 = 0x21;
 const REQ_SET_CONTROL_LINE_STATE: u8 = 0x22;
 
+/// CDC ACM error.
+#[derive(Clone, Debug)]
+pub enum CdcAcmError {
+    /// USB is not connected.
+    NotConnected,
+}
+
+impl core::fmt::Display for CdcAcmError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match *self {
+            Self::NotConnected => f.write_str("NotConnected"),
+        }
+    }
+}
+
+impl core::error::Error for CdcAcmError {}
+impl embedded_io_async::Error for CdcAcmError {
+    fn kind(&self) -> embedded_io_async::ErrorKind {
+        match *self {
+            Self::NotConnected => embedded_io_async::ErrorKind::NotConnected,
+        }
+    }
+}
+
 /// Internal state for CDC-ACM
 pub struct State<'a> {
     control: MaybeUninit<Control<'a>>,
@@ -421,14 +445,21 @@ impl<'d, D: Driver<'d>> Sender<'d, D> {
 }
 
 impl<'d, D: Driver<'d>> embedded_io_async::ErrorType for Sender<'d, D> {
-    type Error = EndpointError;
+    type Error = CdcAcmError;
 }
 
 impl<'d, D: Driver<'d>> embedded_io_async::Write for Sender<'d, D> {
     async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
         let len = core::cmp::min(buf.len(), self.max_packet_size() as usize);
-        self.write_packet(&buf[..len]).await?;
-        Ok(len)
+        match self.write_packet(&buf[..len]).await {
+            Ok(()) => Ok(len),
+            Err(EndpointError::BufferOverflow) => unreachable!(),
+            Err(EndpointError::Disabled) => Err(CdcAcmError::NotConnected),
+        }
+    }
+
+    async fn flush(&mut self) -> Result<(), Self::Error> {
+        Ok(())
     }
 }
 
@@ -539,7 +570,7 @@ impl<'d, D: Driver<'d>> BufferedReceiver<'d, D> {
 }
 
 impl<'d, D: Driver<'d>> embedded_io_async::ErrorType for BufferedReceiver<'d, D> {
-    type Error = EndpointError;
+    type Error = CdcAcmError;
 }
 
 impl<'d, D: Driver<'d>> embedded_io_async::Read for BufferedReceiver<'d, D> {
@@ -552,14 +583,22 @@ impl<'d, D: Driver<'d>> embedded_io_async::Read for BufferedReceiver<'d, D> {
         // If the caller's buffer is large enough to contain an entire packet, read directly into
         // that instead of buffering the packet internally.
         if buf.len() > self.receiver.max_packet_size() as usize {
-            return self.receiver.read_packet(buf).await;
+            return match self.receiver.read_packet(buf).await {
+                Ok(n) => Ok(n),
+                Err(EndpointError::BufferOverflow) => unreachable!(),
+                Err(EndpointError::Disabled) => Err(CdcAcmError::NotConnected),
+            };
         }
 
         // Otherwise read a packet into the internal buffer, and return some of it to the caller.
         //
         // It's important that `start` and `end` be updated in this order so they're left in a
         // consistent state if the `read` future is dropped mid-execution, e.g. from a timeout.
-        self.end = self.receiver.read_packet(&mut self.buffer).await?;
+        match self.receiver.read_packet(&mut self.buffer).await {
+            Ok(n) => self.end = n,
+            Err(EndpointError::BufferOverflow) => unreachable!(),
+            Err(EndpointError::Disabled) => return Err(CdcAcmError::NotConnected),
+        }
         self.start = 0;
         return Ok(self.read_from_buffer(buf));
     }
diff --git a/examples/mcxa/Cargo.toml b/examples/mcxa/Cargo.toml
index 347659f5b..29d319375 100644
--- a/examples/mcxa/Cargo.toml
+++ b/examples/mcxa/Cargo.toml
@@ -18,7 +18,7 @@ embassy-mcxa = { path = "../../embassy-mcxa", features = ["defmt", "unstable-pac
 embassy-sync = "0.7.2"
 embassy-time = "0.5.0"
 embassy-time-driver = "0.2.1"
-embedded-io-async = "0.6.1"
+embedded-io-async = "0.7.0"
 heapless = "0.9.2"
 panic-probe = { version = "1.0", features = ["print-defmt"] }
 rand_core = "0.9"
diff --git a/examples/mcxa/src/bin/clkout.rs b/examples/mcxa/src/bin/clkout.rs
index 1e52912d3..c0e8c330d 100644
--- a/examples/mcxa/src/bin/clkout.rs
+++ b/examples/mcxa/src/bin/clkout.rs
@@ -4,6 +4,7 @@
 use embassy_executor::Spawner;
 use embassy_mcxa::clkout::{ClockOut, ClockOutSel, Config, Div4};
 use embassy_mcxa::clocks::PoweredClock;
+use embassy_mcxa::clocks::config::{SoscConfig, SoscMode, SpllConfig, SpllMode, SpllSource};
 use embassy_mcxa::gpio::{DriveStrength, Level, Output, SlewRate};
 use embassy_time::Timer;
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
@@ -11,58 +12,81 @@ use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
 /// Demonstrate CLKOUT, using Pin P4.2
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let p = hal::init(hal::config::Config::default());
+    let mut cfg = hal::config::Config::default();
+    cfg.clock_cfg.sosc = Some(SoscConfig {
+        mode: SoscMode::CrystalOscillator,
+        frequency: 8_000_000,
+        power: PoweredClock::NormalEnabledDeepSleepDisabled,
+    });
+    cfg.clock_cfg.spll = Some(SpllConfig {
+        source: SpllSource::Sirc,
+        // 12MHz
+        // 12 x 32 => 384MHz
+        // 384 / (16 x 2) => 12.0MHz
+        mode: SpllMode::Mode1b {
+            m_mult: 32,
+            p_div: 16,
+            bypass_p2_div: false,
+        },
+        power: PoweredClock::NormalEnabledDeepSleepDisabled,
+        pll1_clk_div: None,
+    });
+
+    let p = hal::init(cfg);
+
     let mut pin = p.P4_2;
     let mut clkout = p.CLKOUT;
 
-    loop {
-        defmt::info!("Set Low...");
-        let mut output = Output::new(pin.reborrow(), Level::Low, DriveStrength::Normal, SlewRate::Slow);
-        Timer::after_millis(500).await;
+    const K16_CONFIG: Config = Config {
+        sel: ClockOutSel::Clk16K,
+        div: Div4::no_div(),
+        level: PoweredClock::NormalEnabledDeepSleepDisabled,
+    };
+    const M4_CONFIG: Config = Config {
+        sel: ClockOutSel::Fro12M,
+        div: const { Div4::from_divisor(3).unwrap() },
+        level: PoweredClock::NormalEnabledDeepSleepDisabled,
+    };
+    const K512_CONFIG: Config = Config {
+        sel: ClockOutSel::ClkIn,
+        div: const { Div4::from_divisor(16).unwrap() },
+        level: PoweredClock::NormalEnabledDeepSleepDisabled,
+    };
+    const M1_CONFIG: Config = Config {
+        sel: ClockOutSel::Pll1Clk,
+        div: const { Div4::from_divisor(12).unwrap() },
+        level: PoweredClock::NormalEnabledDeepSleepDisabled,
+    };
 
+    #[rustfmt::skip]
+    let configs = [
+        ("16K -> /1 = 16K",  K16_CONFIG),
+        ("12M -> /3 = 4M",   M4_CONFIG),
+        ("8M -> /16 = 512K", K512_CONFIG),
+        ("12M-> /12 = 1M",   M1_CONFIG),
+    ];
+
+    loop {
         defmt::info!("Set High...");
-        output.set_high();
-        Timer::after_millis(400).await;
+        let mut output = Output::new(pin.reborrow(), Level::High, DriveStrength::Normal, SlewRate::Slow);
+        Timer::after_millis(250).await;
 
         defmt::info!("Set Low...");
         output.set_low();
-        Timer::after_millis(500).await;
+        Timer::after_millis(750).await;
 
-        defmt::info!("16k...");
-        // Run Clock Out with the 16K clock
-        let _clock_out = ClockOut::new(
-            clkout.reborrow(),
-            pin.reborrow(),
-            Config {
-                sel: ClockOutSel::Clk16K,
-                div: Div4::no_div(),
-                level: PoweredClock::NormalEnabledDeepSleepDisabled,
-            },
-        )
-        .unwrap();
+        for (name, conf) in configs.iter() {
+            defmt::info!("Running {=str}", name);
 
-        Timer::after_millis(3000).await;
-
-        defmt::info!("Set Low...");
-        drop(_clock_out);
+            let _clock_out = ClockOut::new(clkout.reborrow(), pin.reborrow(), *conf).unwrap();
 
-        let _output = Output::new(pin.reborrow(), Level::Low, DriveStrength::Normal, SlewRate::Slow);
-        Timer::after_millis(500).await;
+            Timer::after_millis(3000).await;
 
-        // Run Clock Out with the 12M clock, divided by 3
-        defmt::info!("4M...");
-        let _clock_out = ClockOut::new(
-            clkout.reborrow(),
-            pin.reborrow(),
-            Config {
-                sel: ClockOutSel::Fro12M,
-                div: const { Div4::from_divisor(3).unwrap() },
-                level: PoweredClock::NormalEnabledDeepSleepDisabled,
-            },
-        )
-        .unwrap();
+            defmt::info!("Set Low...");
+            drop(_clock_out);
 
-        // Let it run for 3 seconds...
-        Timer::after_millis(3000).await;
+            let _output = Output::new(pin.reborrow(), Level::Low, DriveStrength::Normal, SlewRate::Slow);
+            Timer::after_millis(500).await;
+        }
     }
 }
diff --git a/examples/mcxa/src/bin/reset-reason.rs b/examples/mcxa/src/bin/reset-reason.rs
index c244fbe04..2d48a92b1 100644
--- a/examples/mcxa/src/bin/reset-reason.rs
+++ b/examples/mcxa/src/bin/reset-reason.rs
@@ -11,5 +11,7 @@ async fn main(_spawner: Spawner) {
     let config = Config::default();
     let _p = hal::init(config);
 
-    defmt::info!("Reset Reason: '{}'", reset_reason());
+    for reason in reset_reason().into_iter() {
+        defmt::info!("Reset Reason: '{}'", reason);
+    }
 }
diff --git a/examples/mspm0g3507/Cargo.toml b/examples/mspm0g3507/Cargo.toml
index 8c230f038..f4fc7e09f 100644
--- a/examples/mspm0g3507/Cargo.toml
+++ b/examples/mspm0g3507/Cargo.toml
@@ -18,7 +18,7 @@ defmt-rtt = "1.0.0"
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 panic-semihosting = "0.6.0"
 
-embedded-io-async = "0.6.1"
+embedded-io-async = { version = "0.7.0" }
 
 [profile.release]
 debug = 2
diff --git a/examples/nrf52840/Cargo.toml b/examples/nrf52840/Cargo.toml
index a57bd7b24..15c187328 100644
--- a/examples/nrf52840/Cargo.toml
+++ b/examples/nrf52840/Cargo.toml
@@ -13,8 +13,8 @@ embassy-time = { version = "0.5.0", path = "../../embassy-time", features = ["de
 embassy-nrf = { version = "0.9.0", path = "../../embassy-nrf", features = ["defmt", "nrf52840", "time-driver-rtc1", "gpiote", "unstable-pac", "time", "net-driver"] }
 embassy-net = { version = "0.7.1", path = "../../embassy-net", features = ["defmt", "tcp", "dhcpv4", "medium-ethernet","udp", "medium-ieee802154", "proto-ipv6"] }
 embassy-usb = { version = "0.5.1", path = "../../embassy-usb", features = ["defmt"] }
-embedded-io = { version = "0.6.0", features = ["defmt-03"]  }
-embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
+embedded-io = { version = "0.7.1", features = ["defmt"]  }
+embedded-io-async = { version = "0.7.0", features = ["defmt"] }
 embassy-net-esp-hosted = { version = "0.2.1", path = "../../embassy-net-esp-hosted", features = ["defmt"] }
 embassy-net-enc28j60 = { version = "0.2.1", path = "../../embassy-net-enc28j60", features = ["defmt"] }
 
diff --git a/examples/nrf5340/Cargo.toml b/examples/nrf5340/Cargo.toml
index b8d5dbfb1..c54a84d22 100644
--- a/examples/nrf5340/Cargo.toml
+++ b/examples/nrf5340/Cargo.toml
@@ -13,7 +13,7 @@ embassy-time = { version = "0.5.0", path = "../../embassy-time", features = ["de
 embassy-nrf = { version = "0.9.0", path = "../../embassy-nrf", features = ["defmt", "nrf5340-app-s", "time-driver-rtc1", "gpiote", "unstable-pac"] }
 embassy-net = { version = "0.7.1", path = "../../embassy-net", features = ["defmt", "tcp", "dhcpv4", "medium-ethernet"] }
 embassy-usb = { version = "0.5.1", path = "../../embassy-usb", features = ["defmt"] }
-embedded-io-async = { version = "0.6.1" }
+embedded-io-async = { version = "0.7.0" }
 
 defmt = "1.0.1"
 defmt-rtt = "1.0.0"
diff --git a/examples/nrf54l15/Cargo.toml b/examples/nrf54l15/Cargo.toml
index 353d1b46e..9940443ff 100644
--- a/examples/nrf54l15/Cargo.toml
+++ b/examples/nrf54l15/Cargo.toml
@@ -11,8 +11,8 @@ embassy-executor = { version = "0.9.0", path = "../../embassy-executor", feature
 embassy-time = { version = "0.5.0", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime"] }
 embassy-sync = { version = "0.7.2", path = "../../embassy-sync", features = ["defmt"] }
 embassy-nrf = { version = "0.9.0", path = "../../embassy-nrf", features = ["defmt", "nrf54l15-app-s", "time-driver-grtc", "gpiote", "unstable-pac", "time"] }
-embedded-io = { version = "0.6.0", features = ["defmt-03"]  }
-embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
+embedded-io = { version = "0.7.0", features = ["defmt"]  }
+embedded-io-async = { version = "0.7.0", features = ["defmt"] }
 
 rand = { version = "0.9.0", default-features = false }
 
diff --git a/examples/nrf54lm20/Cargo.toml b/examples/nrf54lm20/Cargo.toml
index e3bf22b25..78ce60596 100644
--- a/examples/nrf54lm20/Cargo.toml
+++ b/examples/nrf54lm20/Cargo.toml
@@ -11,8 +11,8 @@ embassy-executor = { version = "0.9.0", path = "../../embassy-executor", feature
 embassy-time = { version = "0.5.0", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime"] }
 embassy-sync = { version = "0.7.2", path = "../../embassy-sync", features = ["defmt"] }
 embassy-nrf = { version = "0.9.0", path = "../../embassy-nrf", features = ["defmt", "nrf54lm20-app-s", "time-driver-grtc", "gpiote", "unstable-pac", "time"] }
-embedded-io = { version = "0.6.0", features = ["defmt-03"]  }
-embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
+embedded-io = { version = "0.7.0", features = ["defmt"]  }
+embedded-io-async = { version = "0.7.0", features = ["defmt"] }
 
 rand = { version = "0.9.0", default-features = false }
 
diff --git a/examples/nrf9160/Cargo.toml b/examples/nrf9160/Cargo.toml
index 907b06e6d..bad7fdc79 100644
--- a/examples/nrf9160/Cargo.toml
+++ b/examples/nrf9160/Cargo.toml
@@ -20,8 +20,8 @@ cortex-m = { version = "0.7.6", features = ["inline-asm", "critical-section-sing
 cortex-m-rt = "0.7.0"
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 static_cell = { version = "2" }
-embedded-io = "0.6.1"
-embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
+embedded-io = { version = "0.7.1" }
+embedded-io-async = { version = "0.7.0", features = ["defmt"] }
 
 [profile.release]
 debug = 2
diff --git a/examples/rp/Cargo.toml b/examples/rp/Cargo.toml
index e247f6f7a..1a5712dd3 100644
--- a/examples/rp/Cargo.toml
+++ b/examples/rp/Cargo.toml
@@ -26,7 +26,7 @@ fixed = "1.23.1"
 fixed-macro = "1.2"
 
 # for web request example
-reqwless = { version = "0.13.0", features = ["defmt"] }
+reqwless = { git = "https://github.com/drogue-iot/reqwless", rev = "68f703dfc16e6f7f964b7238c922c0d433118872", features = ["defmt"] }
 serde = { version = "1.0.203", default-features = false, features = ["derive"] }
 serde-json-core = "0.5.1"
 
@@ -50,7 +50,7 @@ usbd-hid = "0.9.0"
 embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = "1.0"
 embedded-hal-bus = { version = "0.1", features = ["async"] }
-embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
+embedded-io-async = { version = "0.7.0", features = ["defmt"] }
 embedded-storage = { version = "0.3" }
 static_cell = "2.1"
 portable-atomic = { version = "1.5", features = ["critical-section"] }
diff --git a/examples/rp235x/Cargo.toml b/examples/rp235x/Cargo.toml
index 16dfb5b77..bc2bcf5b6 100644
--- a/examples/rp235x/Cargo.toml
+++ b/examples/rp235x/Cargo.toml
@@ -51,7 +51,7 @@ usbd-hid = "0.9.0"
 embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = "1.0"
 embedded-hal-bus = { version = "0.1", features = ["async"] }
-embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
+embedded-io-async = { version = "0.7.0", features = ["defmt"] }
 embedded-storage = { version = "0.3" }
 static_cell = "2.1"
 portable-atomic = { version = "1.5", features = ["critical-section"] }
diff --git a/examples/std/Cargo.toml b/examples/std/Cargo.toml
index 0e3b3c6d5..06f1ba67e 100644
--- a/examples/std/Cargo.toml
+++ b/examples/std/Cargo.toml
@@ -12,8 +12,8 @@ embassy-time = { version = "0.5.0", path = "../../embassy-time", features = ["lo
 embassy-net = { version = "0.7.1", path = "../../embassy-net", features=[ "log", "medium-ethernet", "medium-ip", "tcp", "udp", "dns", "dhcpv4", "proto-ipv6"] }
 embassy-net-tuntap = { version = "0.1.1", path = "../../embassy-net-tuntap" }
 embassy-net-ppp = { version = "0.2.1", path = "../../embassy-net-ppp", features = ["log"]}
-embedded-io-async = { version = "0.6.1" }
-embedded-io-adapters = { version = "0.6.1", features = ["futures-03"] }
+embedded-io-async = { version = "0.7.0" }
+embedded-io-adapters = { version = "0.7.0", features = ["futures-03"] }
 critical-section = { version = "1.1", features = ["std"] }
 
 async-io = "1.6.0"
diff --git a/examples/stm32f4/Cargo.toml b/examples/stm32f4/Cargo.toml
index b4555045a..5bcf66ade 100644
--- a/examples/stm32f4/Cargo.toml
+++ b/examples/stm32f4/Cargo.toml
@@ -23,8 +23,8 @@ cortex-m = { version = "0.7.6", features = ["inline-asm", "critical-section-sing
 cortex-m-rt = "0.7.0"
 embedded-hal = "0.2.6"
 embedded-hal-bus = { version = "0.2", features = ["async"] }
-embedded-io = { version = "0.6.0" }
-embedded-io-async = { version = "0.6.1" }
+embedded-io = { version = "0.7.1" }
+embedded-io-async = { version = "0.7.0" }
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 futures-util = { version = "0.3.30", default-features = false }
 heapless = { version = "0.8", default-features = false }
diff --git a/examples/stm32f7/Cargo.toml b/examples/stm32f7/Cargo.toml
index 565277394..a952b770b 100644
--- a/examples/stm32f7/Cargo.toml
+++ b/examples/stm32f7/Cargo.toml
@@ -12,7 +12,7 @@ embassy-sync = { version = "0.7.2", path = "../../embassy-sync", features = ["de
 embassy-executor = { version = "0.9.0", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "defmt"] }
 embassy-time = { version = "0.5.0", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
 embassy-net = { version = "0.7.1", path = "../../embassy-net", features = ["defmt", "tcp", "dhcpv4", "medium-ethernet"] }
-embedded-io-async = { version = "0.6.1" }
+embedded-io-async = { version = "0.7.0" }
 embassy-usb = { version = "0.5.0", path = "../../embassy-usb", features = ["defmt"] }
 embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
 
diff --git a/examples/stm32g0/Cargo.toml b/examples/stm32g0/Cargo.toml
index 16f28500d..a25a01e59 100644
--- a/examples/stm32g0/Cargo.toml
+++ b/examples/stm32g0/Cargo.toml
@@ -24,7 +24,7 @@ panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 portable-atomic = { version = "1.5", features = ["unsafe-assume-single-core"] }
 
-embedded-io-async = { version = "0.6.1" }
+embedded-io-async = { version = "0.7.0" }
 
 [profile.release]
 debug = 2
diff --git a/examples/stm32h5/Cargo.toml b/examples/stm32h5/Cargo.toml
index 512186c3d..f674a2936 100644
--- a/examples/stm32h5/Cargo.toml
+++ b/examples/stm32h5/Cargo.toml
@@ -23,8 +23,8 @@ cortex-m-rt = "0.7.0"
 embedded-hal = "0.2.6"
 embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = { version = "1.0" }
-embedded-io-async = { version = "0.6.1" }
-embedded-nal-async = "0.8.0"
+embedded-io-async = { version = "0.7.0" }
+embedded-nal-async = "0.9.0"
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 critical-section = "1.1"
diff --git a/examples/stm32h7/Cargo.toml b/examples/stm32h7/Cargo.toml
index 09b734054..8f4b2bf4f 100644
--- a/examples/stm32h7/Cargo.toml
+++ b/examples/stm32h7/Cargo.toml
@@ -24,8 +24,8 @@ cortex-m-rt = "0.7.0"
 embedded-hal = "0.2.6"
 embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = { version = "1.0" }
-embedded-nal-async = "0.8.0"
-embedded-io-async = { version = "0.6.1" }
+embedded-nal-async = "0.9.0"
+embedded-io-async = { version = "0.7.0" }
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 critical-section = "1.1"
diff --git a/examples/stm32h723/Cargo.toml b/examples/stm32h723/Cargo.toml
index 93a5109e2..8b3f8dc55 100644
--- a/examples/stm32h723/Cargo.toml
+++ b/examples/stm32h723/Cargo.toml
@@ -21,8 +21,8 @@ cortex-m-rt = "0.7.0"
 embedded-hal = "0.2.6"
 embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = { version = "1.0" }
-embedded-nal-async = "0.8.0"
-embedded-io-async = { version = "0.6.1" }
+embedded-nal-async = "0.9.0"
+embedded-io-async = { version = "0.7.0" }
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 critical-section = "1.1"
diff --git a/examples/stm32h742/Cargo.toml b/examples/stm32h742/Cargo.toml
index 9b5e5d93d..7ff4dfbe4 100644
--- a/examples/stm32h742/Cargo.toml
+++ b/examples/stm32h742/Cargo.toml
@@ -33,7 +33,7 @@ embassy-net = { version = "0.7.1", path = "../../embassy-net", features = [
     "dhcpv4",
     "medium-ethernet",
 ] }
-embedded-io-async = { version = "0.6.1" }
+embedded-io-async = { version = "0.7.0" }
 embassy-usb = { version = "0.5.1", path = "../../embassy-usb", features = [
     "defmt",
 ] }
diff --git a/examples/stm32h755cm4/Cargo.toml b/examples/stm32h755cm4/Cargo.toml
index d69f0228e..e5be0056f 100644
--- a/examples/stm32h755cm4/Cargo.toml
+++ b/examples/stm32h755cm4/Cargo.toml
@@ -24,8 +24,8 @@ cortex-m-rt = "0.7.0"
 embedded-hal = "0.2.6"
 embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = { version = "1.0" }
-embedded-nal-async = "0.8.0"
-embedded-io-async = { version = "0.6.1" }
+embedded-nal-async = "0.9.0"
+embedded-io-async = { version = "0.7.0" }
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 critical-section = "1.1"
diff --git a/examples/stm32h755cm7/Cargo.toml b/examples/stm32h755cm7/Cargo.toml
index f4e1e53b7..42c05549b 100644
--- a/examples/stm32h755cm7/Cargo.toml
+++ b/examples/stm32h755cm7/Cargo.toml
@@ -24,8 +24,8 @@ cortex-m-rt = "0.7.0"
 embedded-hal = "0.2.6"
 embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = { version = "1.0" }
-embedded-nal-async = "0.8.0"
-embedded-io-async = { version = "0.6.1" }
+embedded-nal-async = "0.9.0"
+embedded-io-async = { version = "0.7.0" }
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 critical-section = "1.1"
diff --git a/examples/stm32h7b0/Cargo.toml b/examples/stm32h7b0/Cargo.toml
index 0509d394d..434bfebce 100644
--- a/examples/stm32h7b0/Cargo.toml
+++ b/examples/stm32h7b0/Cargo.toml
@@ -23,8 +23,8 @@ cortex-m-rt = "0.7.0"
 embedded-hal = "0.2.6"
 embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = { version = "1.0" }
-embedded-nal-async = "0.8.0"
-embedded-io-async = { version = "0.6.1" }
+embedded-nal-async = "0.9.0"
+embedded-io-async = { version = "0.7.0" }
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 critical-section = "1.1"
diff --git a/examples/stm32h7rs/Cargo.toml b/examples/stm32h7rs/Cargo.toml
index ab525ad91..74664432f 100644
--- a/examples/stm32h7rs/Cargo.toml
+++ b/examples/stm32h7rs/Cargo.toml
@@ -23,8 +23,8 @@ cortex-m-rt = "0.7.0"
 embedded-hal = "0.2.6"
 embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = { version = "1.0" }
-embedded-nal-async = "0.8.0"
-embedded-io-async = { version = "0.6.1" }
+embedded-nal-async = "0.9.0"
+embedded-io-async = { version = "0.7.0" }
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 critical-section = "1.1"
diff --git a/examples/stm32l0/Cargo.toml b/examples/stm32l0/Cargo.toml
index a9c71d655..c06c761c9 100644
--- a/examples/stm32l0/Cargo.toml
+++ b/examples/stm32l0/Cargo.toml
@@ -18,8 +18,8 @@ defmt = "1.0.1"
 defmt-rtt = "1.0.0"
 
 embedded-storage = "0.3.1"
-embedded-io = { version = "0.6.0" }
-embedded-io-async = { version = "0.6.1" }
+embedded-io = { version = "0.7.1" }
+embedded-io-async = { version = "0.7.0" }
 
 cortex-m = { version = "0.7.6", features = ["inline-asm", "critical-section-single-core"] }
 cortex-m-rt = "0.7.0"
diff --git a/examples/stm32l4/Cargo.toml b/examples/stm32l4/Cargo.toml
index 936472199..995c8c694 100644
--- a/examples/stm32l4/Cargo.toml
+++ b/examples/stm32l4/Cargo.toml
@@ -16,8 +16,8 @@ embassy-usb = { version = "0.5.0", path = "../../embassy-usb", features = ["defm
 embassy-net-adin1110 = { version = "0.3.1", path = "../../embassy-net-adin1110" }
 embassy-net = { version = "0.7.1", path = "../../embassy-net", features = ["defmt",  "udp", "tcp", "dhcpv4", "medium-ethernet"] }
 embassy-futures = { version = "0.1.2", path = "../../embassy-futures" }
-embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
-embedded-io = { version = "0.6.0", features = ["defmt-03"] }
+embedded-io-async = { version = "0.7.0", features = ["defmt"] }
+embedded-io = { version = "0.7.1", features = ["defmt"] }
 
 defmt = "1.0.1"
 defmt-rtt = "1.0.0"
diff --git a/examples/stm32l5/Cargo.toml b/examples/stm32l5/Cargo.toml
index 586b00836..b6d14ce25 100644
--- a/examples/stm32l5/Cargo.toml
+++ b/examples/stm32l5/Cargo.toml
@@ -24,7 +24,7 @@ cortex-m = { version = "0.7.6", features = ["inline-asm", "critical-section-sing
 cortex-m-rt = "0.7.0"
 embedded-hal = "0.2.6"
 heapless = { version = "0.8", default-features = false }
-embedded-io-async = { version = "0.6.1" }
+embedded-io-async = { version = "0.7.0" }
 static_cell = "2"
 
 [profile.release]
diff --git a/examples/stm32n6/Cargo.toml b/examples/stm32n6/Cargo.toml
index 5ad5b97ce..fdfaed531 100644
--- a/examples/stm32n6/Cargo.toml
+++ b/examples/stm32n6/Cargo.toml
@@ -23,7 +23,7 @@ cortex-m-rt = "0.7.0"
 embedded-hal = "0.2.6"
 embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = { version = "1.0" }
-embedded-io-async = { version = "0.6.1" }
+embedded-io-async = { version = "0.7.0" }
 embedded-nal-async = "0.8.0"
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
diff --git a/examples/stm32wb/Cargo.toml b/examples/stm32wb/Cargo.toml
index 83f7cb56b..496500f75 100644
--- a/examples/stm32wb/Cargo.toml
+++ b/examples/stm32wb/Cargo.toml
@@ -7,10 +7,10 @@ publish = false
 
 [dependencies]
 # Change stm32wb55rg to your chip name in both dependencies, if necessary.
-embassy-stm32 = { version = "0.4.0", path = "../../embassy-stm32", features = [ "defmt", "stm32wb55rg", "time-driver-any", "memory-x", "exti", "low-power"]  }
+embassy-stm32 = { version = "0.4.0", path = "../../embassy-stm32", features = [ "defmt", "stm32wb55rg", "time-driver-any", "memory-x", "exti", "low-power-pender"]  }
 embassy-stm32-wpan = { version = "0.1.0", path = "../../embassy-stm32-wpan", features = ["defmt", "stm32wb55rg"] }
 embassy-sync = { version = "0.7.2", path = "../../embassy-sync", features = ["defmt"] }
-embassy-executor = { version = "0.9.0", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "defmt"] }
+embassy-executor = { version = "0.9.0", path = "../../embassy-executor", features = ["defmt"] }
 embassy-time = { version = "0.5.0", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
 embassy-net = { version = "0.7.1", path = "../../embassy-net", features = ["defmt", "udp", "proto-ipv6", "medium-ieee802154", ], optional = true }
 
diff --git a/examples/stm32wb/src/bin/blinky.rs b/examples/stm32wb/src/bin/blinky.rs
index f37e8b1d8..e2737fcd5 100644
--- a/examples/stm32wb/src/bin/blinky.rs
+++ b/examples/stm32wb/src/bin/blinky.rs
@@ -7,7 +7,7 @@ use embassy_stm32::gpio::{Level, Output, Speed};
 use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
-#[embassy_executor::main]
+#[embassy_executor::main(executor = "embassy_stm32::Executor", entry = "cortex_m_rt::entry")]
 async fn main(_spawner: Spawner) {
     let p = embassy_stm32::init(Default::default());
     info!("Hello World!");
diff --git a/examples/stm32wb/src/bin/button_exti.rs b/examples/stm32wb/src/bin/button_exti.rs
index 3c58eb556..37a207519 100644
--- a/examples/stm32wb/src/bin/button_exti.rs
+++ b/examples/stm32wb/src/bin/button_exti.rs
@@ -13,7 +13,7 @@ bind_interrupts!(
         EXTI4 => exti::InterruptHandler<interrupt::typelevel::EXTI4>;
 });
 
-#[embassy_executor::main]
+#[embassy_executor::main(executor = "embassy_stm32::Executor", entry = "cortex_m_rt::entry")]
 async fn main(_spawner: Spawner) {
     let p = embassy_stm32::init(Default::default());
     info!("Hello World!");
diff --git a/examples/stm32wb/src/bin/eddystone_beacon.rs b/examples/stm32wb/src/bin/eddystone_beacon.rs
index 413b1ac8f..a679e6fb1 100644
--- a/examples/stm32wb/src/bin/eddystone_beacon.rs
+++ b/examples/stm32wb/src/bin/eddystone_beacon.rs
@@ -26,7 +26,7 @@ bind_interrupts!(struct Irqs{
 
 const BLE_GAP_DEVICE_NAME_LENGTH: u8 = 7;
 
-#[embassy_executor::main]
+#[embassy_executor::main(executor = "embassy_stm32::Executor", entry = "cortex_m_rt::entry")]
 async fn main(_spawner: Spawner) {
     /*
         How to make this work:
diff --git a/examples/stm32wb/src/bin/gatt_server.rs b/examples/stm32wb/src/bin/gatt_server.rs
index 3484f1844..10c7fd0ba 100644
--- a/examples/stm32wb/src/bin/gatt_server.rs
+++ b/examples/stm32wb/src/bin/gatt_server.rs
@@ -38,7 +38,7 @@ bind_interrupts!(struct Irqs{
 
 const BLE_GAP_DEVICE_NAME_LENGTH: u8 = 7;
 
-#[embassy_executor::main]
+#[embassy_executor::main(executor = "embassy_stm32::Executor", entry = "cortex_m_rt::entry")]
 async fn main(spawner: Spawner) {
     /*
         How to make this work:
diff --git a/examples/stm32wb/src/bin/mac_ffd.rs b/examples/stm32wb/src/bin/mac_ffd.rs
index 4bab6ea9f..cd15968d2 100644
--- a/examples/stm32wb/src/bin/mac_ffd.rs
+++ b/examples/stm32wb/src/bin/mac_ffd.rs
@@ -23,7 +23,7 @@ async fn run_mm_queue(mut memory_manager: mm::MemoryManager<'static>) {
     memory_manager.run_queue().await;
 }
 
-#[embassy_executor::main]
+#[embassy_executor::main(executor = "embassy_stm32::Executor", entry = "cortex_m_rt::entry")]
 async fn main(spawner: Spawner) {
     /*
         How to make this work:
diff --git a/examples/stm32wb/src/bin/mac_ffd_net.rs b/examples/stm32wb/src/bin/mac_ffd_net.rs
index b4789e3ee..244b35243 100644
--- a/examples/stm32wb/src/bin/mac_ffd_net.rs
+++ b/examples/stm32wb/src/bin/mac_ffd_net.rs
@@ -41,7 +41,7 @@ async fn run_net(mut runner: embassy_net::Runner<'static, Driver<'static>>) -> !
     runner.run().await
 }
 
-#[embassy_executor::main]
+#[embassy_executor::main(executor = "embassy_stm32::Executor", entry = "cortex_m_rt::entry")]
 async fn main(spawner: Spawner) {
     /*
         How to make this work:
diff --git a/examples/stm32wb/src/bin/mac_rfd.rs b/examples/stm32wb/src/bin/mac_rfd.rs
index dae3c5200..f3e65c66b 100644
--- a/examples/stm32wb/src/bin/mac_rfd.rs
+++ b/examples/stm32wb/src/bin/mac_rfd.rs
@@ -25,7 +25,7 @@ async fn run_mm_queue(mut memory_manager: mm::MemoryManager<'static>) {
     memory_manager.run_queue().await;
 }
 
-#[embassy_executor::main]
+#[embassy_executor::main(executor = "embassy_stm32::Executor", entry = "cortex_m_rt::entry")]
 async fn main(spawner: Spawner) {
     /*
         How to make this work:
diff --git a/examples/stm32wb/src/bin/tl_mbox.rs b/examples/stm32wb/src/bin/tl_mbox.rs
index 0902e28e8..adb6eff7b 100644
--- a/examples/stm32wb/src/bin/tl_mbox.rs
+++ b/examples/stm32wb/src/bin/tl_mbox.rs
@@ -15,7 +15,7 @@ bind_interrupts!(struct Irqs{
     IPCC_C1_TX => TransmitInterruptHandler;
 });
 
-#[embassy_executor::main]
+#[embassy_executor::main(executor = "embassy_stm32::Executor", entry = "cortex_m_rt::entry")]
 async fn main(_spawner: Spawner) {
     /*
         How to make this work:
diff --git a/examples/stm32wb/src/bin/tl_mbox_ble.rs b/examples/stm32wb/src/bin/tl_mbox_ble.rs
index 763dc32cd..376b808de 100644
--- a/examples/stm32wb/src/bin/tl_mbox_ble.rs
+++ b/examples/stm32wb/src/bin/tl_mbox_ble.rs
@@ -20,7 +20,7 @@ async fn run_mm_queue(mut memory_manager: mm::MemoryManager<'static>) {
     memory_manager.run_queue().await;
 }
 
-#[embassy_executor::main]
+#[embassy_executor::main(executor = "embassy_stm32::Executor", entry = "cortex_m_rt::entry")]
 async fn main(spawner: Spawner) {
     /*
         How to make this work:
diff --git a/examples/stm32wb/src/bin/tl_mbox_mac.rs b/examples/stm32wb/src/bin/tl_mbox_mac.rs
index 235a48241..697e061c1 100644
--- a/examples/stm32wb/src/bin/tl_mbox_mac.rs
+++ b/examples/stm32wb/src/bin/tl_mbox_mac.rs
@@ -20,7 +20,7 @@ async fn run_mm_queue(mut memory_manager: mm::MemoryManager<'static>) {
     memory_manager.run_queue().await;
 }
 
-#[embassy_executor::main]
+#[embassy_executor::main(executor = "embassy_stm32::Executor", entry = "cortex_m_rt::entry")]
 async fn main(spawner: Spawner) {
     /*
         How to make this work:
diff --git a/examples/stm32wle5/Cargo.toml b/examples/stm32wle5/Cargo.toml
index f2fc4dd3d..64c81c761 100644
--- a/examples/stm32wle5/Cargo.toml
+++ b/examples/stm32wle5/Cargo.toml
@@ -15,7 +15,7 @@ embassy-embedded-hal = { version = "0.5.0", path = "../../embassy-embedded-hal"
 
 defmt = "1.0.1"
 defmt-rtt = { version = "1.1.0", optional = true }
-defmt-serial = { version = "0.10.0", optional = true }
+defmt-serial = { git = "https://github.com/gauteh/defmt-serial", rev = "411ae7fa909b4fd2667885aff687e009b9108190", optional = true }
 
 cortex-m = { version = "0.7.6", features = ["inline-asm", "critical-section-single-core"] }
 cortex-m-rt = "0.7.0"
diff --git a/tests/mspm0/Cargo.toml b/tests/mspm0/Cargo.toml
index df52b538d..56b027feb 100644
--- a/tests/mspm0/Cargo.toml
+++ b/tests/mspm0/Cargo.toml
@@ -26,8 +26,8 @@ cortex-m = { version = "0.7.6", features = [ "inline-asm", "critical-section-sin
 cortex-m-rt = "0.7.0"
 embedded-hal = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = { version = "1.0" }
-embedded-io = { version = "0.6.1", features = ["defmt-03"] }
-embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
+embedded-io = { version = "0.7.1", features = ["defmt"] }
+embedded-io-async = { version = "0.7.0", features = ["defmt"] }
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 static_cell = "2"
 portable-atomic = { version = "1.5", features = ["critical-section"] }
diff --git a/tests/nrf/Cargo.toml b/tests/nrf/Cargo.toml
index 50f059b34..b1e0a68c2 100644
--- a/tests/nrf/Cargo.toml
+++ b/tests/nrf/Cargo.toml
@@ -13,7 +13,7 @@ embassy-sync = { version = "0.7.2", path = "../../embassy-sync", features = ["de
 embassy-executor = { version = "0.9.0", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "defmt"] }
 embassy-time = { version = "0.5.0", path = "../../embassy-time", features = ["defmt",  "defmt-timestamp-uptime"] }
 embassy-nrf = { version = "0.9.0", path = "../../embassy-nrf", features = ["defmt",  "time-driver-rtc1", "gpiote", "unstable-pac"] }
-embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
+embedded-io-async = { version = "0.7.0", features = ["defmt"] }
 embassy-net = { version = "0.7.1", path = "../../embassy-net", features = ["defmt", "tcp", "dhcpv4", "medium-ethernet", ] }
 embassy-net-esp-hosted = { version = "0.2.1", path = "../../embassy-net-esp-hosted", features = ["defmt"] }
 embassy-net-enc28j60 = { version = "0.2.1", path = "../../embassy-net-enc28j60", features = ["defmt"] }
diff --git a/tests/rp/Cargo.toml b/tests/rp/Cargo.toml
index 4dfe6904e..375a613d2 100644
--- a/tests/rp/Cargo.toml
+++ b/tests/rp/Cargo.toml
@@ -35,7 +35,7 @@ embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = { version = "1.0" }
 embedded-hal-bus = { version = "0.1", features = ["async"] }
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
-embedded-io-async = { version = "0.6.1" }
+embedded-io-async = { version = "0.7.0" }
 embedded-storage = { version = "0.3" }
 static_cell = "2"
 portable-atomic = { version = "1.5", features = ["critical-section"] }
diff --git a/tests/stm32/src/bin/stop.rs b/tests/stm32/src/bin/stop.rs
index 83c375bc5..75dacbe7e 100644
--- a/tests/stm32/src/bin/stop.rs
+++ b/tests/stm32/src/bin/stop.rs
@@ -60,10 +60,12 @@ async fn async_main(spawner: Spawner) {
 
     let (rtc, _time_provider) = Rtc::new(p.RTC);
 
+    info!("set datetime");
     critical_section::with(|cs| {
         rtc.borrow_mut(cs).set_datetime(now.into()).expect("datetime not set");
     });
 
+    info!("spawn");
     spawner.spawn(task_1().unwrap());
     spawner.spawn(task_2().unwrap());
 }