Merge branch 'main' into u0-lcd

98 files changed, 3860 insertions, 686 deletions

diff --git a/tests/nrf51422/.cargo/config.toml b/tests/mspm0/.cargo/config.toml
index 634805633..825bf3ae9 100644
--- a/tests/nrf51422/.cargo/config.toml
+++ b/tests/mspm0/.cargo/config.toml
@@ -1,6 +1,5 @@
 [target.'cfg(all(target_arch = "arm", target_os = "none"))']
-#runner = "teleprobe local run --chip nRF51422_xxAA --elf"
-runner = "teleprobe client run"
+runner = "teleprobe local run --chip MSPM0G3507 --protocol swd --elf"
 
 [build]
 target = "thumbv6m-none-eabi"
diff --git a/tests/mspm0/Cargo.toml b/tests/mspm0/Cargo.toml
new file mode 100644
index 000000000..df52b538d
--- /dev/null
+++ b/tests/mspm0/Cargo.toml
@@ -0,0 +1,68 @@
+[package]
+edition = "2024"
+name = "embassy-mspm0-tests"
+version = "0.1.0"
+license = "MIT OR Apache-2.0"
+publish = false
+
+[features]
+mspm0g3507 = [ "embassy-mspm0/mspm0g3507pm" ]
+mspm0g3519 = [ "embassy-mspm0/mspm0g3519pz" ]
+
+[dependencies]
+teleprobe-meta = "1.1"
+
+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-futures = { version = "0.1.2", path = "../../embassy-futures" }
+embassy-time = { version = "0.5.0", path = "../../embassy-time", features = [ "defmt" ] }
+embassy-mspm0 = { version = "0.1.0", path = "../../embassy-mspm0", features = [ "rt", "defmt", "unstable-pac", "time-driver-any" ]  }
+embassy-embedded-hal = { version = "0.5.0", path = "../../embassy-embedded-hal/"}
+
+defmt = "1.0.1"
+defmt-rtt = "1.0.0"
+
+cortex-m = { version = "0.7.6", features = [ "inline-asm", "critical-section-single-core" ]}
+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"] }
+panic-probe = { version = "1.0.0", features = ["print-defmt"] }
+static_cell = "2"
+portable-atomic = { version = "1.5", features = ["critical-section"] }
+
+[profile.dev]
+debug = 2
+debug-assertions = true
+opt-level = 's'
+overflow-checks = true
+
+[profile.release]
+codegen-units = 1
+debug = 2
+debug-assertions = false
+incremental = false
+lto = "fat"
+opt-level = 's'
+overflow-checks = false
+
+# do not optimize proc-macro crates = faster builds from scratch
+[profile.dev.build-override]
+codegen-units = 8
+debug = false
+debug-assertions = false
+opt-level = 0
+overflow-checks = false
+
+[profile.release.build-override]
+codegen-units = 8
+debug = false
+debug-assertions = false
+opt-level = 0
+overflow-checks = false
+
+[package.metadata.embassy]
+build = [
+  { target = "thumbv6m-none-eabi", features = ["mspm0g3507"], artifact-dir = "out/tests/mspm0g3507" }
+]
diff --git a/tests/nrf52840/build.rs b/tests/mspm0/build.rs
index 71c82a70f..43a9ac04f 100644
--- a/tests/nrf52840/build.rs
+++ b/tests/mspm0/build.rs
@@ -4,14 +4,26 @@ use std::{env, fs};
 
 fn main() -> Result<(), Box<dyn Error>> {
     let out = PathBuf::from(env::var("OUT_DIR").unwrap());
-    fs::write(out.join("link_ram.x"), include_bytes!("../link_ram_cortex_m.x")).unwrap();
+
+    #[cfg(feature = "mspm0g3507")]
+    let memory_x = include_bytes!("memory_g3507.x");
+
+    #[cfg(feature = "mspm0g3519")]
+    let memory_x = include_bytes!("memory_g3519.x");
+
+    fs::write(out.join("memory.x"), memory_x).unwrap();
+
     println!("cargo:rustc-link-search={}", out.display());
     println!("cargo:rerun-if-changed=link_ram.x");
+    // copy main linker script.
+    fs::write(out.join("link_ram.x"), include_bytes!("../link_ram_cortex_m.x")).unwrap();
 
     println!("cargo:rustc-link-arg-bins=--nmagic");
     println!("cargo:rustc-link-arg-bins=-Tlink_ram.x");
     println!("cargo:rustc-link-arg-bins=-Tdefmt.x");
     println!("cargo:rustc-link-arg-bins=-Tteleprobe.x");
+    // You must tell cargo to link interrupt groups if the rt feature is enabled.
+    println!("cargo:rustc-link-arg-bins=-Tinterrupt_group.x");
 
     Ok(())
 }
diff --git a/tests/mspm0/memory_g3507.x b/tests/mspm0/memory_g3507.x
new file mode 100644
index 000000000..37e381fbd
--- /dev/null
+++ b/tests/mspm0/memory_g3507.x
@@ -0,0 +1,6 @@
+MEMORY
+{
+  FLASH : ORIGIN = 0x00000000, LENGTH = 128K
+  /* Select non-parity range of SRAM due to SRAM_ERR_01 errata in SLAZ758 */
+  RAM   : ORIGIN = 0x20200000, LENGTH = 32K
+}
diff --git a/tests/mspm0/memory_g3519.x b/tests/mspm0/memory_g3519.x
new file mode 100644
index 000000000..d62f10360
--- /dev/null
+++ b/tests/mspm0/memory_g3519.x
@@ -0,0 +1,6 @@
+MEMORY
+{
+  FLASH : ORIGIN = 0x00000000, LENGTH = 128K
+  /* Select non-parity range of SRAM due to SRAM_ERR_01 errata in SLAZ758 */
+  RAM   : ORIGIN = 0x20200000, LENGTH = 64K
+}
diff --git a/tests/mspm0/src/bin/dma.rs b/tests/mspm0/src/bin/dma.rs
new file mode 100644
index 000000000..9c56acadc
--- /dev/null
+++ b/tests/mspm0/src/bin/dma.rs
@@ -0,0 +1,503 @@
+#![no_std]
+#![no_main]
+
+#[cfg(feature = "mspm0g3507")]
+teleprobe_meta::target!(b"lp-mspm0g3507");
+
+#[cfg(feature = "mspm0g3519")]
+teleprobe_meta::target!(b"lp-mspm0g3519");
+
+use core::slice;
+
+use defmt::{assert, assert_eq, *};
+use embassy_executor::Spawner;
+use embassy_mspm0::Peri;
+use embassy_mspm0::dma::{Channel, Transfer, TransferMode, TransferOptions, Word};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut p = embassy_mspm0::init(Default::default());
+    info!("Hello World!");
+
+    {
+        info!("Single u8 read (blocking)");
+        single_read(p.DMA_CH0.reborrow(), 0x41_u8);
+
+        info!("Single u16 read (blocking)");
+        single_read(p.DMA_CH0.reborrow(), 0xFF41_u16);
+
+        info!("Single u32 read (blocking)");
+        single_read(p.DMA_CH0.reborrow(), 0xFFEE_FF41_u32);
+
+        info!("Single u64 read (blocking)");
+        single_read(p.DMA_CH0.reborrow(), 0x0011_2233_FFEE_FF41_u64);
+    }
+
+    // Widening transfers
+    {
+        info!("Single u8 read to u16");
+        widening_single_read::<u8, u16>(p.DMA_CH0.reborrow(), 0x41);
+
+        info!("Single u8 read to u32");
+        widening_single_read::<u8, u32>(p.DMA_CH0.reborrow(), 0x43);
+
+        info!("Single u8 read to u64");
+        widening_single_read::<u8, u64>(p.DMA_CH0.reborrow(), 0x47);
+
+        info!("Single u16 read to u32");
+        widening_single_read::<u16, u32>(p.DMA_CH0.reborrow(), 0xAE43);
+
+        info!("Single u16 read to u64");
+        widening_single_read::<u16, u64>(p.DMA_CH0.reborrow(), 0xAF47);
+
+        info!("Single u32 read to u64");
+        widening_single_read::<u32, u64>(p.DMA_CH0.reborrow(), 0xDEAD_AF47);
+    }
+
+    // Narrowing transfers.
+    {
+        info!("Single u16 read to u8");
+        narrowing_single_read::<u16, u8>(p.DMA_CH0.reborrow(), 0x4142);
+
+        info!("Single u32 read to u8");
+        narrowing_single_read::<u32, u8>(p.DMA_CH0.reborrow(), 0x4142_2414);
+
+        info!("Single u64 read to u8");
+        narrowing_single_read::<u64, u8>(p.DMA_CH0.reborrow(), 0x4142_2414_5153_7776);
+
+        info!("Single u32 read to u16");
+        narrowing_single_read::<u32, u16>(p.DMA_CH0.reborrow(), 0x4142_2414);
+
+        info!("Single u64 read to u16");
+        narrowing_single_read::<u64, u16>(p.DMA_CH0.reborrow(), 0x4142_2414_5153_7776);
+
+        info!("Single u64 read to u32");
+        narrowing_single_read::<u64, u32>(p.DMA_CH0.reborrow(), 0x4142_2414_5153_7776);
+    }
+
+    {
+        info!("Single u8 read (async)");
+        async_single_read(p.DMA_CH0.reborrow(), 0x42_u8).await;
+
+        info!("Single u16 read (async)");
+        async_single_read(p.DMA_CH0.reborrow(), 0xAE42_u16).await;
+
+        info!("Single u32 read (async)");
+        async_single_read(p.DMA_CH0.reborrow(), 0xFE44_1500_u32).await;
+
+        info!("Single u64 read (async)");
+        async_single_read(p.DMA_CH0.reborrow(), 0x8F7F_6F5F_4F3F_2F1F_u64).await;
+    }
+
+    {
+        info!("Multiple u8 reads (blocking)");
+        block_read::<_, 16>(p.DMA_CH0.reborrow(), 0x98_u8);
+
+        info!("Multiple u16 reads (blocking)");
+        block_read::<_, 2>(p.DMA_CH0.reborrow(), 0x9801_u16);
+
+        info!("Multiple u32 reads (blocking)");
+        block_read::<_, 4>(p.DMA_CH0.reborrow(), 0x9821_9801_u32);
+
+        info!("Multiple u64 reads (blocking)");
+        block_read::<_, 4>(p.DMA_CH0.reborrow(), 0xABCD_EF01_2345_6789_u64);
+    }
+
+    {
+        info!("Multiple u8 reads (async)");
+        async_block_read::<_, 8>(p.DMA_CH0.reborrow(), 0x86_u8).await;
+
+        info!("Multiple u16 reads (async)");
+        async_block_read::<_, 6>(p.DMA_CH0.reborrow(), 0x7777_u16).await;
+
+        info!("Multiple u32 reads (async)");
+        async_block_read::<_, 3>(p.DMA_CH0.reborrow(), 0xA5A5_A5A5_u32).await;
+
+        info!("Multiple u64 reads (async)");
+        async_block_read::<_, 14>(p.DMA_CH0.reborrow(), 0x5A5A_5A5A_A5A5_A5A5_u64).await;
+    }
+
+    // Intentionally skip testing multiple reads in single transfer mode.
+    //
+    // If the destination length is greater than 1 and single transfer mode is used then two transfers
+    // are performed in a trigger. Similarly with any other length of destination above 2, only 2 transfers
+    // are performed. Issuing another trigger (resume) results in no further progress. More than likely
+    // the test does not work due to some combination of a hardware bug and the datasheet being unclear
+    // regarding what ends a software trigger.
+    //
+    // However this case works fine with a hardware trigger (such as the ADC hardware trigger).
+
+    {
+        info!("Single u8 write (blocking)");
+        single_write(p.DMA_CH0.reborrow(), 0x41_u8);
+
+        info!("Single u16 write (blocking)");
+        single_write(p.DMA_CH0.reborrow(), 0x4142_u16);
+
+        info!("Single u32 write (blocking)");
+        single_write(p.DMA_CH0.reborrow(), 0x4142_4344_u32);
+
+        info!("Single u64 write (blocking)");
+        single_write(p.DMA_CH0.reborrow(), 0x4142_4344_4546_4748_u64);
+    }
+
+    {
+        info!("Single u8 write (async)");
+        async_single_write(p.DMA_CH0.reborrow(), 0xAA_u8).await;
+
+        info!("Single u16 write (async)");
+        async_single_write(p.DMA_CH0.reborrow(), 0xBBBB_u16).await;
+
+        info!("Single u32 write (async)");
+        async_single_write(p.DMA_CH0.reborrow(), 0xCCCC_CCCC_u32).await;
+
+        info!("Single u64 write (async)");
+        async_single_write(p.DMA_CH0.reborrow(), 0xDDDD_DDDD_DDDD_DDDD_u64).await;
+    }
+
+    {
+        info!("Multiple u8 writes (blocking)");
+        block_write(p.DMA_CH0.reborrow(), &[0xFF_u8, 0x7F, 0x3F, 0x1F]);
+
+        info!("Multiple u16 writes (blocking)");
+        block_write(p.DMA_CH0.reborrow(), &[0xFFFF_u16, 0xFF7F, 0xFF3F, 0xFF1F]);
+
+        info!("Multiple u32 writes (blocking)");
+        block_write(
+            p.DMA_CH0.reborrow(),
+            &[0xFF00_00FF_u32, 0xFF00_007F, 0x0000_FF3F, 0xFF1F_0000],
+        );
+
+        info!("Multiple u64 writes (blocking)");
+        block_write(
+            p.DMA_CH0.reborrow(),
+            &[
+                0xFF00_0000_0000_00FF_u64,
+                0x0000_FF00_007F_0000,
+                0x0000_FF3F_0000_0000,
+                0xFF1F_0000_1111_837A,
+            ],
+        );
+    }
+
+    {
+        info!("Multiple u8 writes (async)");
+        async_block_write(p.DMA_CH0.reborrow(), &[0u8, 1, 2, 3]).await;
+
+        info!("Multiple u16 writes (async)");
+        async_block_write(p.DMA_CH0.reborrow(), &[0x9801u16, 0x9802, 0x9803, 0x9800, 0x9000]).await;
+
+        info!("Multiple u32 writes (async)");
+        async_block_write(p.DMA_CH0.reborrow(), &[0x9801_ABCDu32, 0xFFAC_9802, 0xDEAD_9803]).await;
+
+        info!("Multiple u64 writes (async)");
+        async_block_write(
+            p.DMA_CH0.reborrow(),
+            &[
+                0xA55A_1111_3333_5555_u64,
+                0x1111_A55A_3333_5555,
+                0x5555_A55A_3333_1111,
+                0x01234_5678_89AB_CDEF,
+            ],
+        )
+        .await;
+    }
+
+    // TODO: Mixed byte and word transfers.
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
+
+fn single_read<W: Word + Copy + Default + Eq + defmt::Format>(mut channel: Peri<'_, impl Channel>, mut src: W) {
+    let options = TransferOptions::default();
+    let mut dst = W::default();
+
+    // SAFETY: src and dst outlive the transfer.
+    let transfer = unsafe {
+        unwrap!(Transfer::new_read(
+            channel.reborrow(),
+            Transfer::SOFTWARE_TRIGGER,
+            &mut src,
+            slice::from_mut(&mut dst),
+            options,
+        ))
+    };
+    transfer.blocking_wait();
+
+    assert_eq!(src, dst);
+}
+
+async fn async_single_read<W: Word + Copy + Default + Eq + defmt::Format>(
+    mut channel: Peri<'_, impl Channel>,
+    mut src: W,
+) {
+    let options = TransferOptions::default();
+    let mut dst = W::default();
+
+    // SAFETY: src and dst outlive the transfer.
+    let transfer = unsafe {
+        unwrap!(Transfer::new_read(
+            channel.reborrow(),
+            Transfer::SOFTWARE_TRIGGER,
+            &mut src,
+            slice::from_mut(&mut dst),
+            options,
+        ))
+    };
+    transfer.await;
+
+    assert_eq!(src, dst);
+}
+
+fn block_read<W: Word + Copy + Default + Eq + defmt::Format, const N: usize>(
+    mut channel: Peri<'_, impl Channel>,
+    mut src: W,
+) {
+    let mut options = TransferOptions::default();
+    // Complete the entire transfer.
+    options.mode = TransferMode::Block;
+
+    let mut dst = [W::default(); N];
+
+    // SAFETY: src and dst outlive the transfer.
+    let transfer = unsafe {
+        unwrap!(Transfer::new_read(
+            channel.reborrow(),
+            Transfer::SOFTWARE_TRIGGER,
+            &mut src,
+            &mut dst[..],
+            options,
+        ))
+    };
+    transfer.blocking_wait();
+
+    assert_eq!(dst, [src; N]);
+}
+
+async fn async_block_read<W: Word + Copy + Default + Eq + defmt::Format, const N: usize>(
+    mut channel: Peri<'_, impl Channel>,
+    mut src: W,
+) {
+    let mut options = TransferOptions::default();
+    // Complete the entire transfer.
+    options.mode = TransferMode::Block;
+
+    let mut dst = [W::default(); N];
+
+    // SAFETY: src and dst outlive the transfer.
+    let transfer = unsafe {
+        unwrap!(Transfer::new_read(
+            channel.reborrow(),
+            Transfer::SOFTWARE_TRIGGER,
+            &mut src,
+            &mut dst[..],
+            options,
+        ))
+    };
+    transfer.await;
+
+    assert_eq!(dst, [src; N]);
+}
+
+fn single_write<W: Word + Default + Eq + defmt::Format>(mut channel: Peri<'_, impl Channel>, src: W) {
+    let options = TransferOptions::default();
+    let mut dst = W::default();
+
+    // SAFETY: src and dst outlive the transfer.
+    let transfer = unsafe {
+        unwrap!(Transfer::new_write(
+            channel.reborrow(),
+            Transfer::SOFTWARE_TRIGGER,
+            slice::from_ref(&src),
+            &mut dst,
+            options,
+        ))
+    };
+    transfer.blocking_wait();
+
+    assert_eq!(src, dst);
+}
+
+async fn async_single_write<W: Word + Default + Eq + defmt::Format>(mut channel: Peri<'_, impl Channel>, src: W) {
+    let options = TransferOptions::default();
+    let mut dst = W::default();
+
+    // SAFETY: src and dst outlive the transfer.
+    let transfer = unsafe {
+        unwrap!(Transfer::new_write(
+            channel.reborrow(),
+            Transfer::SOFTWARE_TRIGGER,
+            slice::from_ref(&src),
+            &mut dst,
+            options,
+        ))
+    };
+    transfer.await;
+
+    assert_eq!(src, dst);
+}
+
+fn block_write<W: Word + Default + Eq + defmt::Format>(mut channel: Peri<'_, impl Channel>, src: &[W]) {
+    let mut options = TransferOptions::default();
+    // Complete the entire transfer.
+    options.mode = TransferMode::Block;
+
+    let mut dst = W::default();
+
+    // Starting from 1 because a zero length transfer does nothing.
+    for i in 1..src.len() {
+        info!("-> {} write(s)", i);
+
+        // SAFETY: src and dst outlive the transfer.
+        let transfer = unsafe {
+            unwrap!(Transfer::new_write(
+                channel.reborrow(),
+                Transfer::SOFTWARE_TRIGGER,
+                &src[..i],
+                &mut dst,
+                options,
+            ))
+        };
+        transfer.blocking_wait();
+
+        // The result will be the last value written.
+        assert_eq!(dst, src[i - 1]);
+    }
+}
+
+async fn async_block_write<W: Word + Default + Eq + defmt::Format>(mut channel: Peri<'_, impl Channel>, src: &[W]) {
+    let mut options = TransferOptions::default();
+    // Complete the entire transfer.
+    options.mode = TransferMode::Block;
+
+    let mut dst = W::default();
+
+    // Starting from 1 because a zero length transfer does nothing.
+    for i in 1..src.len() {
+        info!("-> {} write(s)", i);
+        // SAFETY: src and dst outlive the transfer.
+        let transfer = unsafe {
+            unwrap!(Transfer::new_write(
+                channel.reborrow(),
+                Transfer::SOFTWARE_TRIGGER,
+                &src[..i],
+                &mut dst,
+                options,
+            ))
+        };
+        transfer.await;
+
+        // The result will be the last value written.
+        assert_eq!(dst, src[i - 1]);
+    }
+}
+
+/// [`single_read`], but testing when the destination is wider than the source.
+///
+/// The MSPM0 DMA states that the upper bytes when the destination is longer than the source are zeroed.
+/// This matches the behavior in Rust for all unsigned integer types.
+fn widening_single_read<SW, DW>(mut channel: Peri<'_, impl Channel>, mut src: SW)
+where
+    SW: Word + Copy + Default + Eq + defmt::Format,
+    DW: Word + Copy + Default + Eq + defmt::Format + From<SW>,
+{
+    assert!(
+        DW::size() > SW::size(),
+        "This test only works when the destination is larger than the source"
+    );
+
+    let options = TransferOptions::default();
+    let mut dst = DW::default();
+
+    // SAFETY: src and dst outlive the transfer.
+    let transfer = unsafe {
+        unwrap!(Transfer::new_read(
+            channel.reborrow(),
+            Transfer::SOFTWARE_TRIGGER,
+            &mut src,
+            slice::from_mut(&mut dst),
+            options,
+        ))
+    };
+    transfer.blocking_wait();
+
+    assert_eq!(DW::from(src), dst);
+}
+
+/// [`single_read`], but testing when the destination is narrower than the source.
+///
+/// The MSPM0 DMA states that the upper bytes when the source is longer than the destination are dropped.
+/// This matches the behavior in Rust for all unsigned integer types.
+fn narrowing_single_read<SW, DW>(mut channel: Peri<'_, impl Channel>, mut src: SW)
+where
+    SW: Word + Copy + Default + Eq + defmt::Format + From<DW>,
+    DW: Word + Copy + Default + Eq + defmt::Format + Narrow<SW>,
+{
+    assert!(
+        SW::size() > DW::size(),
+        "This test only works when the source is larger than the destination"
+    );
+
+    let options = TransferOptions::default();
+    let mut dst = DW::default();
+
+    // SAFETY: src and dst outlive the transfer.
+    let transfer = unsafe {
+        unwrap!(Transfer::new_read(
+            channel.reborrow(),
+            Transfer::SOFTWARE_TRIGGER,
+            &mut src,
+            slice::from_mut(&mut dst),
+            options,
+        ))
+    };
+    transfer.blocking_wait();
+
+    // The expected value is the source value masked by the maximum destination value.
+    // This is effectively `src as DW as SW` to drop the upper byte(s).
+    let expect = SW::from(DW::narrow(src));
+    assert_eq!(expect, dst.into());
+}
+
+/// A pseudo `as` trait to allow downcasting integer types (TryFrom could fail).
+trait Narrow<T> {
+    fn narrow(value: T) -> Self;
+}
+
+impl Narrow<u16> for u8 {
+    fn narrow(value: u16) -> Self {
+        value as u8
+    }
+}
+
+impl Narrow<u32> for u8 {
+    fn narrow(value: u32) -> Self {
+        value as u8
+    }
+}
+
+impl Narrow<u64> for u8 {
+    fn narrow(value: u64) -> Self {
+        value as u8
+    }
+}
+
+impl Narrow<u32> for u16 {
+    fn narrow(value: u32) -> Self {
+        value as u16
+    }
+}
+
+impl Narrow<u64> for u16 {
+    fn narrow(value: u64) -> Self {
+        value as u16
+    }
+}
+
+impl Narrow<u64> for u32 {
+    fn narrow(value: u64) -> Self {
+        value as u32
+    }
+}
diff --git a/tests/mspm0/src/bin/uart.rs b/tests/mspm0/src/bin/uart.rs
new file mode 100644
index 000000000..916ce0d4b
--- /dev/null
+++ b/tests/mspm0/src/bin/uart.rs
@@ -0,0 +1,86 @@
+#![no_std]
+#![no_main]
+
+#[cfg(feature = "mspm0g3507")]
+teleprobe_meta::target!(b"lp-mspm0g3507");
+
+#[cfg(feature = "mspm0g3519")]
+teleprobe_meta::target!(b"lp-mspm0g3519");
+
+use defmt::{assert_eq, unwrap, *};
+use embassy_executor::Spawner;
+use embassy_mspm0::mode::Blocking;
+use embassy_mspm0::uart::{ClockSel, Config, Error, Uart};
+use {defmt_rtt as _, panic_probe as _};
+
+fn read<const N: usize>(uart: &mut Uart<'_, Blocking>) -> Result<[u8; N], Error> {
+    let mut buf = [255; N];
+    uart.blocking_read(&mut buf)?;
+    Ok(buf)
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_mspm0::init(Default::default());
+    info!("Hello World!");
+
+    // TODO: Allow creating a looped-back UART (so pins are not needed).
+    // Do not select default UART since the virtual COM port is attached to UART0.
+    #[cfg(any(feature = "mspm0g3507", feature = "mspm0g3519"))]
+    let (mut tx, mut rx, mut uart) = (p.PA8, p.PA9, p.UART1);
+
+    const MFCLK_BUAD_RATES: &[u32] = &[1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200];
+
+    for &rate in MFCLK_BUAD_RATES {
+        info!("{} baud using MFCLK", rate);
+
+        let mut config = Config::default();
+        // MSPM0 hardware supports a loopback mode to allow self test.
+        config.loop_back_enable = true;
+        config.baudrate = rate;
+
+        let mut uart = unwrap!(Uart::new_blocking(
+            uart.reborrow(),
+            rx.reborrow(),
+            tx.reborrow(),
+            config
+        ));
+
+        // We can't send too many bytes, they have to fit in the FIFO.
+        // This is because we aren't sending+receiving at the same time.
+
+        let data = [0xC0, 0xDE];
+        unwrap!(uart.blocking_write(&data));
+        assert_eq!(unwrap!(read(&mut uart)), data);
+    }
+
+    // 9600 is the maximum possible value for 32.768 kHz.
+    const LFCLK_BAUD_RATES: &[u32] = &[1200, 2400, 4800, 9600];
+
+    for &rate in LFCLK_BAUD_RATES {
+        info!("{} baud using LFCLK", rate);
+
+        let mut config = Config::default();
+        // MSPM0 hardware supports a loopback mode to allow self test.
+        config.loop_back_enable = true;
+        config.baudrate = rate;
+        config.clock_source = ClockSel::LfClk;
+
+        let mut uart = expect!(Uart::new_blocking(
+            uart.reborrow(),
+            rx.reborrow(),
+            tx.reborrow(),
+            config,
+        ));
+
+        // We can't send too many bytes, they have to fit in the FIFO.
+        // This is because we aren't sending+receiving at the same time.
+
+        let data = [0xC0, 0xDE];
+        unwrap!(uart.blocking_write(&data));
+        assert_eq!(unwrap!(read(&mut uart)), data);
+    }
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/mspm0/src/bin/uart_buffered.rs b/tests/mspm0/src/bin/uart_buffered.rs
new file mode 100644
index 000000000..135ac1287
--- /dev/null
+++ b/tests/mspm0/src/bin/uart_buffered.rs
@@ -0,0 +1,115 @@
+#![no_std]
+#![no_main]
+
+#[cfg(feature = "mspm0g3507")]
+teleprobe_meta::target!(b"lp-mspm0g3507");
+
+use defmt::{assert_eq, unwrap, *};
+use embassy_executor::Spawner;
+use embassy_mspm0::uart::{BufferedInterruptHandler, BufferedUart, Config};
+use embassy_mspm0::{bind_interrupts, peripherals};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    UART1 => BufferedInterruptHandler<peripherals::UART1>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_mspm0::init(Default::default());
+    info!("Hello World!");
+
+    // TODO: Allow creating a looped-back UART (so pins are not needed).
+    // Do not select default UART since the virtual COM port is attached to UART0.
+    #[cfg(any(feature = "mspm0g3507"))]
+    let (mut tx, mut rx, mut uart) = (p.PA8, p.PA9, p.UART1);
+
+    {
+        use embedded_io_async::{Read, Write};
+
+        let mut config = Config::default();
+        config.loop_back_enable = true;
+        config.fifo_enable = false;
+
+        let tx_buf = &mut [0u8; 16];
+        let rx_buf = &mut [0u8; 16];
+        let mut uart = unwrap!(BufferedUart::new(
+            uart.reborrow(),
+            tx.reborrow(),
+            rx.reborrow(),
+            Irqs,
+            tx_buf,
+            rx_buf,
+            config
+        ));
+
+        let mut buf = [0; 16];
+        for (j, b) in buf.iter_mut().enumerate() {
+            *b = j as u8;
+        }
+
+        unwrap!(uart.write_all(&buf).await);
+        unwrap!(uart.flush().await);
+
+        unwrap!(uart.read_exact(&mut buf).await);
+        for (j, b) in buf.iter().enumerate() {
+            assert_eq!(*b, j as u8);
+        }
+
+        // Buffer is unclogged, should be able to write again.
+        unwrap!(uart.write_all(&buf).await);
+        unwrap!(uart.flush().await);
+
+        unwrap!(uart.read_exact(&mut buf).await);
+        for (j, b) in buf.iter().enumerate() {
+            assert_eq!(*b, j as u8);
+        }
+    }
+
+    info!("Blocking buffered");
+    {
+        use embedded_io::{Read, Write};
+
+        let mut config = Config::default();
+        config.loop_back_enable = true;
+        config.fifo_enable = false;
+
+        let tx_buf = &mut [0u8; 16];
+        let rx_buf = &mut [0u8; 16];
+        let mut uart = unwrap!(BufferedUart::new(
+            uart.reborrow(),
+            tx.reborrow(),
+            rx.reborrow(),
+            Irqs,
+            tx_buf,
+            rx_buf,
+            config
+        ));
+
+        let mut buf = [0; 16];
+
+        for (j, b) in buf.iter_mut().enumerate() {
+            *b = j as u8;
+        }
+
+        unwrap!(uart.write_all(&buf));
+        unwrap!(uart.blocking_flush());
+        unwrap!(uart.read_exact(&mut buf));
+
+        for (j, b) in buf.iter().enumerate() {
+            assert_eq!(*b, j as u8);
+        }
+
+        // Buffer is unclogged, should be able to write again.
+        unwrap!(uart.write_all(&buf));
+        unwrap!(uart.blocking_flush());
+        unwrap!(uart.read_exact(&mut buf));
+
+        for (j, b) in buf.iter().enumerate() {
+            assert_eq!(*b, j as u8, "at {}", j);
+        }
+    }
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf52840/.cargo/config.toml b/tests/nrf/.cargo/config.toml
index 9d6b0313a..0192c10ae 100644
--- a/tests/nrf52840/.cargo/config.toml
+++ b/tests/nrf/.cargo/config.toml
@@ -1,9 +1,11 @@
 [target.'cfg(all(target_arch = "arm", target_os = "none"))']
-#runner = "teleprobe local run --chip nRF52840_xxAA --elf"
-runner = "teleprobe client run"
+runner = "teleprobe local run --chip nRF52840_xxAA --elf"
+#runner = "teleprobe client run"
 
 [build]
+#target = "thumbv6m-none-eabi"
 target = "thumbv7em-none-eabi"
+#target = "thumbv8m.main-none-eabihf"
 
 [env]
 DEFMT_LOG = "trace,embassy_hal_internal=debug,embassy_net_esp_hosted=debug,smoltcp=info"
diff --git a/tests/nrf/Cargo.toml b/tests/nrf/Cargo.toml
new file mode 100644
index 000000000..3a9b86cef
--- /dev/null
+++ b/tests/nrf/Cargo.toml
@@ -0,0 +1,125 @@
+[package]
+edition = "2024"
+name = "embassy-nrf-examples"
+version = "0.1.0"
+license = "MIT OR Apache-2.0"
+publish = false
+
+[dependencies]
+teleprobe-meta = "1"
+
+embassy-futures = { version = "0.1.2", path = "../../embassy-futures" }
+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-time = { version = "0.5.0", path = "../../embassy-time", features = ["defmt",  "defmt-timestamp-uptime"] }
+embassy-nrf = { version = "0.8.0", path = "../../embassy-nrf", features = ["defmt",  "time-driver-rtc1", "gpiote", "unstable-pac"] }
+embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
+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"] }
+embedded-hal-async = { version = "1.0" }
+embedded-hal-bus = { version = "0.1", features = ["async"] }
+static_cell = "2"
+perf-client = { path = "../perf-client" }
+
+defmt = "1.0.1"
+defmt-rtt = "1.0.0"
+
+cortex-m = { version = "0.7.6", features = ["critical-section-single-core"] }
+cortex-m-rt = "0.7.0"
+panic-probe = { version = "1.0.0", features = ["print-defmt"] }
+portable-atomic = { version = "1.6.0" }
+
+[features]
+nrf51422 = ["embassy-nrf/nrf51",         "portable-atomic/unsafe-assume-single-core"]
+nrf52832 = ["embassy-nrf/nrf52832",      "easydma"]
+nrf52833 = ["embassy-nrf/nrf52833",      "easydma", "two-uarts"]
+nrf52840 = ["embassy-nrf/nrf52840",      "easydma", "two-uarts"]
+nrf5340  = ["embassy-nrf/nrf5340-app-s", "easydma", "two-uarts"]
+nrf9160  = ["embassy-nrf/nrf9160-s",     "easydma", "two-uarts"]
+
+easydma = []
+two-uarts = []
+
+[profile.release]
+codegen-units = 1
+debug = 2
+debug-assertions = false
+incremental = false
+lto = "fat"
+opt-level = 's'
+overflow-checks = false
+
+# BEGIN TESTS
+# Generated by gen_test.py. DO NOT EDIT.
+[[bin]]
+name = "buffered_uart"
+path = "src/bin/buffered_uart.rs"
+required-features = [ "easydma",]
+
+[[bin]]
+name = "buffered_uart_full"
+path = "src/bin/buffered_uart_full.rs"
+required-features = [ "easydma",]
+
+[[bin]]
+name = "buffered_uart_halves"
+path = "src/bin/buffered_uart_halves.rs"
+required-features = [ "two-uarts",]
+
+[[bin]]
+name = "buffered_uart_spam"
+path = "src/bin/buffered_uart_spam.rs"
+required-features = [ "two-uarts",]
+
+[[bin]]
+name = "ethernet_enc28j60_perf"
+path = "src/bin/ethernet_enc28j60_perf.rs"
+required-features = [ "nrf52840",]
+
+[[bin]]
+name = "gpio"
+path = "src/bin/gpio.rs"
+required-features = []
+
+[[bin]]
+name = "gpiote"
+path = "src/bin/gpiote.rs"
+required-features = []
+
+[[bin]]
+name = "spim"
+path = "src/bin/spim.rs"
+required-features = [ "easydma",]
+
+[[bin]]
+name = "timer"
+path = "src/bin/timer.rs"
+required-features = []
+
+[[bin]]
+name = "uart_halves"
+path = "src/bin/uart_halves.rs"
+required-features = [ "two-uarts",]
+
+[[bin]]
+name = "uart_split"
+path = "src/bin/uart_split.rs"
+required-features = [ "easydma",]
+
+[[bin]]
+name = "wifi_esp_hosted_perf"
+path = "src/bin/wifi_esp_hosted_perf.rs"
+required-features = [ "nrf52840",]
+
+# END TESTS
+
+[package.metadata.embassy]
+build = [
+  { target = "thumbv6m-none-eabi", features = ["nrf51422"], artifact-dir = "out/tests/nrf51422-dk" },
+  { target = "thumbv7em-none-eabi", features = ["nrf52832"], artifact-dir = "out/tests/nrf52832-dk" },
+  { target = "thumbv7em-none-eabi", features = ["nrf52833"], artifact-dir = "out/tests/nrf52833-dk" },
+  { target = "thumbv7em-none-eabi", features = ["nrf52840"], artifact-dir = "out/tests/nrf52840-dk" },
+  { target = "thumbv8m.main-none-eabihf", features = ["nrf5340"], artifact-dir = "out/tests/nrf5340-dk" },
+  { target = "thumbv8m.main-none-eabihf", features = ["nrf9160"], artifact-dir = "out/tests/nrf9160-dk" }
+]
diff --git a/tests/nrf/build.rs b/tests/nrf/build.rs
new file mode 100644
index 000000000..3c15cf10f
--- /dev/null
+++ b/tests/nrf/build.rs
@@ -0,0 +1,37 @@
+use std::error::Error;
+use std::path::PathBuf;
+use std::{env, fs};
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let out = PathBuf::from(env::var("OUT_DIR").unwrap());
+
+    // copy the right memory.x
+    #[cfg(feature = "nrf51422")]
+    let memory_x = include_bytes!("memory-nrf51422.x");
+    #[cfg(feature = "nrf52832")]
+    let memory_x = include_bytes!("memory-nrf52832.x");
+    #[cfg(feature = "nrf52833")]
+    let memory_x = include_bytes!("memory-nrf52833.x");
+    #[cfg(feature = "nrf52840")]
+    let memory_x = include_bytes!("memory-nrf52840.x");
+    #[cfg(feature = "nrf5340")]
+    let memory_x = include_bytes!("memory-nrf5340.x");
+    #[cfg(feature = "nrf9160")]
+    let memory_x = include_bytes!("memory-nrf9160.x");
+    fs::write(out.join("memory.x"), memory_x).unwrap();
+
+    // copy main linker script.
+    fs::write(out.join("link_ram.x"), include_bytes!("../link_ram_cortex_m.x")).unwrap();
+    println!("cargo:rustc-link-search={}", out.display());
+    println!("cargo:rerun-if-changed=link_ram.x");
+
+    println!("cargo:rustc-link-arg-bins=--nmagic");
+    #[cfg(feature = "nrf51422")]
+    println!("cargo:rustc-link-arg-bins=-Tlink.x");
+    #[cfg(not(feature = "nrf51422"))]
+    println!("cargo:rustc-link-arg-bins=-Tlink_ram.x");
+    println!("cargo:rustc-link-arg-bins=-Tdefmt.x");
+    println!("cargo:rustc-link-arg-bins=-Tteleprobe.x");
+
+    Ok(())
+}
diff --git a/tests/nrf/gen_test.py b/tests/nrf/gen_test.py
new file mode 100644
index 000000000..daf714376
--- /dev/null
+++ b/tests/nrf/gen_test.py
@@ -0,0 +1,44 @@
+import os
+import toml
+from glob import glob
+
+abspath = os.path.abspath(__file__)
+dname = os.path.dirname(abspath)
+os.chdir(dname)
+
+# ======= load test list
+tests = {}
+for f in sorted(glob('./src/bin/*.rs')):
+    name = os.path.splitext(os.path.basename(f))[0]
+    features = []
+    with open(f, 'r') as f:
+        for line in f:
+            if line.startswith('// required-features:'):
+                features = [feature.strip() for feature in line.split(':', 2)[1].strip().split(',')]
+
+    tests[name] = features
+
+# ========= Update Cargo.toml
+
+things = {
+    'bin': [
+        {
+            'name': f'{name}',
+            'path': f'src/bin/{name}.rs',
+            'required-features': features,
+        }
+        for name, features in tests.items()
+    ]
+}
+
+SEPARATOR_START = '# BEGIN TESTS\n'
+SEPARATOR_END = '# END TESTS\n'
+HELP = '# Generated by gen_test.py. DO NOT EDIT.\n'
+with open('Cargo.toml', 'r') as f:
+    data = f.read()
+before, data = data.split(SEPARATOR_START, maxsplit=1)
+_, after = data.split(SEPARATOR_END, maxsplit=1)
+data = before + SEPARATOR_START + HELP + \
+    toml.dumps(things) + SEPARATOR_END + after
+with open('Cargo.toml', 'w') as f:
+    f.write(data)
diff --git a/tests/nrf/memory-nrf51422.x b/tests/nrf/memory-nrf51422.x
new file mode 100644
index 000000000..c140005ce
--- /dev/null
+++ b/tests/nrf/memory-nrf51422.x
@@ -0,0 +1,5 @@
+MEMORY
+{
+  FLASH : ORIGIN = 0x00000000, LENGTH = 256K
+  RAM : ORIGIN = 0x20000000, LENGTH = 32K
+}
diff --git a/tests/nrf/memory-nrf52832.x b/tests/nrf/memory-nrf52832.x
new file mode 100644
index 000000000..c140005ce
--- /dev/null
+++ b/tests/nrf/memory-nrf52832.x
@@ -0,0 +1,5 @@
+MEMORY
+{
+  FLASH : ORIGIN = 0x00000000, LENGTH = 256K
+  RAM : ORIGIN = 0x20000000, LENGTH = 32K
+}
diff --git a/tests/nrf/memory-nrf52833.x b/tests/nrf/memory-nrf52833.x
new file mode 100644
index 000000000..a4baa2dc4
--- /dev/null
+++ b/tests/nrf/memory-nrf52833.x
@@ -0,0 +1,5 @@
+MEMORY
+{
+  FLASH : ORIGIN = 0x00000000, LENGTH = 512K
+  RAM : ORIGIN = 0x20000000, LENGTH = 64K
+}
diff --git a/tests/nrf52840/memory.x b/tests/nrf/memory-nrf52840.x
index 58900a7bd..58900a7bd 100644
--- a/tests/nrf52840/memory.x
+++ b/tests/nrf/memory-nrf52840.x
diff --git a/tests/nrf/memory-nrf5340.x b/tests/nrf/memory-nrf5340.x
new file mode 100644
index 000000000..58900a7bd
--- /dev/null
+++ b/tests/nrf/memory-nrf5340.x
@@ -0,0 +1,5 @@
+MEMORY
+{
+  FLASH : ORIGIN = 0x00000000, LENGTH = 1024K
+  RAM : ORIGIN = 0x20000000, LENGTH = 256K
+}
diff --git a/tests/nrf/memory-nrf9160.x b/tests/nrf/memory-nrf9160.x
new file mode 100644
index 000000000..58900a7bd
--- /dev/null
+++ b/tests/nrf/memory-nrf9160.x
@@ -0,0 +1,5 @@
+MEMORY
+{
+  FLASH : ORIGIN = 0x00000000, LENGTH = 1024K
+  RAM : ORIGIN = 0x20000000, LENGTH = 256K
+}
diff --git a/tests/nrf52840/src/bin/buffered_uart.rs b/tests/nrf/src/bin/buffered_uart.rs
index a01d66d85..8c4827464 100644
--- a/tests/nrf52840/src/bin/buffered_uart.rs
+++ b/tests/nrf/src/bin/buffered_uart.rs
@@ -1,18 +1,17 @@
+// required-features: easydma
 #![no_std]
 #![no_main]
-teleprobe_meta::target!(b"nrf52840-dk");
 
-use defmt::{assert_eq, *};
+#[path = "../common.rs"]
+mod common;
+
+use defmt::{panic, *};
 use embassy_executor::Spawner;
 use embassy_futures::join::join;
 use embassy_nrf::buffered_uarte::{self, BufferedUarte};
-use embassy_nrf::{bind_interrupts, peripherals, uarte};
+use embassy_nrf::{peripherals, uarte};
 use {defmt_rtt as _, panic_probe as _};
 
-bind_interrupts!(struct Irqs {
-    UARTE0_UART0 => buffered_uarte::InterruptHandler<peripherals::UARTE0>;
-});
-
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let mut p = embassy_nrf::init(Default::default());
@@ -26,14 +25,14 @@ async fn main(_spawner: Spawner) {
     // test teardown + recreate of the buffereduarte works fine.
     for _ in 0..2 {
         let u = BufferedUarte::new(
-            &mut p.UARTE0,
-            &mut p.TIMER0,
-            &mut p.PPI_CH0,
-            &mut p.PPI_CH1,
-            &mut p.PPI_GROUP0,
-            Irqs,
-            &mut p.P1_03,
-            &mut p.P1_02,
+            peri!(p, UART0).reborrow(),
+            p.TIMER0.reborrow(),
+            p.PPI_CH0.reborrow(),
+            p.PPI_CH1.reborrow(),
+            p.PPI_GROUP0.reborrow(),
+            peri!(p, PIN_A).reborrow(),
+            peri!(p, PIN_B).reborrow(),
+            irqs!(UART0_BUFFERED),
             config.clone(),
             &mut rx_buffer,
             &mut tx_buffer,
@@ -64,7 +63,9 @@ async fn main(_spawner: Spawner) {
                 let buf = unwrap!(rx.fill_buf().await);
 
                 for &b in buf {
-                    assert_eq!(b, i as u8);
+                    if b != i as u8 {
+                        panic!("mismatch {} vs {}, index {}", b, i as u8, i);
+                    }
                     i = i + 1;
                 }
 
diff --git a/tests/nrf52840/src/bin/buffered_uart_full.rs b/tests/nrf/src/bin/buffered_uart_full.rs
index 62edaed25..e0f41b891 100644
--- a/tests/nrf52840/src/bin/buffered_uart_full.rs
+++ b/tests/nrf/src/bin/buffered_uart_full.rs
@@ -1,18 +1,17 @@
+// required-features: easydma
 #![no_std]
 #![no_main]
-teleprobe_meta::target!(b"nrf52840-dk");
+
+#[path = "../common.rs"]
+mod common;
 
 use defmt::{assert_eq, *};
 use embassy_executor::Spawner;
 use embassy_nrf::buffered_uarte::{self, BufferedUarte};
-use embassy_nrf::{bind_interrupts, peripherals, uarte};
+use embassy_nrf::{peripherals, uarte};
 use embedded_io_async::{Read, Write};
 use {defmt_rtt as _, panic_probe as _};
 
-bind_interrupts!(struct Irqs {
-    UARTE0_UART0 => buffered_uarte::InterruptHandler<peripherals::UARTE0>;
-});
-
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let p = embassy_nrf::init(Default::default());
@@ -20,18 +19,18 @@ async fn main(_spawner: Spawner) {
     config.parity = uarte::Parity::EXCLUDED;
     config.baudrate = uarte::Baudrate::BAUD1M;
 
-    let mut tx_buffer = [0u8; 1024];
-    let mut rx_buffer = [0u8; 1024];
+    let mut tx_buffer = [0u8; 500];
+    let mut rx_buffer = [0u8; 500];
 
     let u = BufferedUarte::new(
-        p.UARTE0,
+        peri!(p, UART0),
         p.TIMER0,
         p.PPI_CH0,
         p.PPI_CH1,
         p.PPI_GROUP0,
-        Irqs,
-        p.P1_03,
-        p.P1_02,
+        peri!(p, PIN_A),
+        peri!(p, PIN_B),
+        irqs!(UART0_BUFFERED),
         config.clone(),
         &mut rx_buffer,
         &mut tx_buffer,
@@ -41,22 +40,22 @@ async fn main(_spawner: Spawner) {
 
     let (mut rx, mut tx) = u.split();
 
-    let mut buf = [0; 1024];
+    let mut buf = [0; 500];
     for (j, b) in buf.iter_mut().enumerate() {
         *b = j as u8;
     }
 
-    // Write 1024b. This causes the rx buffer to get exactly full.
+    // Write 500b. This causes the rx buffer to get exactly full.
     unwrap!(tx.write_all(&buf).await);
     unwrap!(tx.flush().await);
 
-    // Read those 1024b.
+    // Read those 500b.
     unwrap!(rx.read_exact(&mut buf).await);
     for (j, b) in buf.iter().enumerate() {
         assert_eq!(*b, j as u8);
     }
 
-    // The buffer should now be unclogged. Write 1024b again.
+    // The buffer should now be unclogged. Write 500b again.
     unwrap!(tx.write_all(&buf).await);
     unwrap!(tx.flush().await);
 
diff --git a/tests/nrf52840/src/bin/buffered_uart_halves.rs b/tests/nrf/src/bin/buffered_uart_halves.rs
index 54a9fef5b..e6debd76e 100644
--- a/tests/nrf52840/src/bin/buffered_uart_halves.rs
+++ b/tests/nrf/src/bin/buffered_uart_halves.rs
@@ -1,19 +1,17 @@
+// required-features: two-uarts
 #![no_std]
 #![no_main]
-teleprobe_meta::target!(b"nrf52840-dk");
+
+#[path = "../common.rs"]
+mod common;
 
 use defmt::{assert_eq, *};
 use embassy_executor::Spawner;
 use embassy_futures::join::join;
 use embassy_nrf::buffered_uarte::{self, BufferedUarteRx, BufferedUarteTx};
-use embassy_nrf::{bind_interrupts, peripherals, uarte};
+use embassy_nrf::{peripherals, uarte};
 use {defmt_rtt as _, panic_probe as _};
 
-bind_interrupts!(struct Irqs {
-    UARTE0_UART0 => buffered_uarte::InterruptHandler<peripherals::UARTE0>;
-    UARTE1 => buffered_uarte::InterruptHandler<peripherals::UARTE1>;
-});
-
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let mut p = embassy_nrf::init(Default::default());
@@ -28,16 +26,22 @@ async fn main(_spawner: Spawner) {
     for _ in 0..2 {
         const COUNT: usize = 40_000;
 
-        let mut tx = BufferedUarteTx::new(&mut p.UARTE1, Irqs, &mut p.P1_02, config.clone(), &mut tx_buffer);
+        let mut tx = BufferedUarteTx::new(
+            peri!(p, UART1).reborrow(),
+            peri!(p, PIN_A).reborrow(),
+            irqs!(UART1_BUFFERED),
+            config.clone(),
+            &mut tx_buffer,
+        );
 
         let mut rx = BufferedUarteRx::new(
-            &mut p.UARTE0,
-            &mut p.TIMER0,
-            &mut p.PPI_CH0,
-            &mut p.PPI_CH1,
-            &mut p.PPI_GROUP0,
-            Irqs,
-            &mut p.P1_03,
+            peri!(p, UART0).reborrow(),
+            p.TIMER0.reborrow(),
+            p.PPI_CH0.reborrow(),
+            p.PPI_CH1.reborrow(),
+            p.PPI_GROUP0.reborrow(),
+            irqs!(UART0_BUFFERED),
+            peri!(p, PIN_B).reborrow(),
             config.clone(),
             &mut rx_buffer,
         );
diff --git a/tests/nrf52840/src/bin/buffered_uart_spam.rs b/tests/nrf/src/bin/buffered_uart_spam.rs
index 400c0df99..6d862e19d 100644
--- a/tests/nrf52840/src/bin/buffered_uart_spam.rs
+++ b/tests/nrf/src/bin/buffered_uart_spam.rs
@@ -1,25 +1,23 @@
+// required-features: two-uarts
 #![no_std]
 #![no_main]
-teleprobe_meta::target!(b"nrf52840-dk");
+
+#[path = "../common.rs"]
+mod common;
 
 use core::mem;
 use core::ptr::NonNull;
 
 use defmt::{assert_eq, *};
 use embassy_executor::Spawner;
-use embassy_nrf::buffered_uarte::{self, BufferedUarte};
+use embassy_nrf::buffered_uarte::{self, BufferedUarteRx};
 use embassy_nrf::gpio::{Level, Output, OutputDrive};
 use embassy_nrf::ppi::{Event, Ppi, Task};
-use embassy_nrf::uarte::Uarte;
-use embassy_nrf::{bind_interrupts, pac, peripherals, uarte};
+use embassy_nrf::uarte::UarteTx;
+use embassy_nrf::{pac, peripherals, uarte};
 use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
-bind_interrupts!(struct Irqs {
-    UARTE0_UART0 => buffered_uarte::InterruptHandler<peripherals::UARTE0>;
-    UARTE1 => uarte::InterruptHandler<peripherals::UARTE1>;
-});
-
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let mut p = embassy_nrf::init(Default::default());
@@ -27,23 +25,24 @@ async fn main(_spawner: Spawner) {
     config.parity = uarte::Parity::EXCLUDED;
     config.baudrate = uarte::Baudrate::BAUD1M;
 
-    let mut tx_buffer = [0u8; 1024];
     let mut rx_buffer = [0u8; 1024];
 
-    mem::forget(Output::new(&mut p.P1_02, Level::High, OutputDrive::Standard));
+    mem::forget(Output::new(
+        peri!(p, PIN_A).reborrow(),
+        Level::High,
+        OutputDrive::Standard,
+    ));
 
-    let mut u = BufferedUarte::new(
-        p.UARTE0,
+    let mut u = BufferedUarteRx::new(
+        peri!(p, UART0),
         p.TIMER0,
         p.PPI_CH0,
         p.PPI_CH1,
         p.PPI_GROUP0,
-        Irqs,
-        p.P1_03,
-        p.P1_04,
+        irqs!(UART0_BUFFERED),
+        peri!(p, PIN_B),
         config.clone(),
         &mut rx_buffer,
-        &mut tx_buffer,
     );
 
     info!("uarte initialized!");
@@ -54,16 +53,16 @@ async fn main(_spawner: Spawner) {
     // Tx spam in a loop.
     const NSPAM: usize = 17;
     static mut TX_BUF: [u8; NSPAM] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
-    let _spam = Uarte::new(p.UARTE1, Irqs, p.P1_01, p.P1_02, config.clone());
-    let spam_peri: pac::UARTE1 = unsafe { mem::transmute(()) };
-    let event = unsafe { Event::new_unchecked(NonNull::new_unchecked(&spam_peri.events_endtx as *const _ as _)) };
-    let task = unsafe { Task::new_unchecked(NonNull::new_unchecked(&spam_peri.tasks_starttx as *const _ as _)) };
+    let _spam = UarteTx::new(peri!(p, UART1), irqs!(UART1), peri!(p, PIN_A), config.clone());
+    let spam_peri = pac::UARTE1;
+    let event = unsafe { Event::new_unchecked(NonNull::new_unchecked(spam_peri.events_dma().tx().end().as_ptr())) };
+    let task = unsafe { Task::new_unchecked(NonNull::new_unchecked(spam_peri.tasks_dma().tx().start().as_ptr())) };
     let mut spam_ppi = Ppi::new_one_to_one(p.PPI_CH2, event, task);
     spam_ppi.enable();
-    let p = unsafe { TX_BUF.as_mut_ptr() };
-    spam_peri.txd.ptr.write(|w| unsafe { w.ptr().bits(p as u32) });
-    spam_peri.txd.maxcnt.write(|w| unsafe { w.maxcnt().bits(NSPAM as _) });
-    spam_peri.tasks_starttx.write(|w| unsafe { w.bits(1) });
+    let p = (&raw mut TX_BUF) as *mut u8;
+    spam_peri.dma().tx().ptr().write_value(p as u32);
+    spam_peri.dma().tx().maxcnt().write(|w| w.set_maxcnt(NSPAM as _));
+    spam_peri.tasks_dma().tx().start().write_value(1);
 
     let mut i = 0;
     let mut total = 0;
diff --git a/tests/nrf52840/src/bin/ethernet_enc28j60_perf.rs b/tests/nrf/src/bin/ethernet_enc28j60_perf.rs
index 33c2f4235..bd6a2effd 100644
--- a/tests/nrf52840/src/bin/ethernet_enc28j60_perf.rs
+++ b/tests/nrf/src/bin/ethernet_enc28j60_perf.rs
@@ -1,3 +1,4 @@
+// required-features: nrf52840
 #![no_std]
 #![no_main]
 teleprobe_meta::target!(b"ak-gwe-r7");
@@ -5,7 +6,7 @@ teleprobe_meta::timeout!(120);
 
 use defmt::{info, unwrap};
 use embassy_executor::Spawner;
-use embassy_net::{Stack, StackResources};
+use embassy_net::StackResources;
 use embassy_net_enc28j60::Enc28j60;
 use embassy_nrf::gpio::{Level, Output, OutputDrive};
 use embassy_nrf::rng::Rng;
@@ -21,11 +22,11 @@ bind_interrupts!(struct Irqs {
     RNG => embassy_nrf::rng::InterruptHandler<peripherals::RNG>;
 });
 
-type MyDriver = Enc28j60<ExclusiveDevice<Spim<'static, peripherals::SPI3>, Output<'static>, Delay>, Output<'static>>;
+type MyDriver = Enc28j60<ExclusiveDevice<Spim<'static>, Output<'static>, Delay>, Output<'static>>;
 
 #[embassy_executor::task]
-async fn net_task(stack: &'static Stack<MyDriver>) -> ! {
-    stack.run().await
+async fn net_task(mut runner: embassy_net::Runner<'static, MyDriver>) -> ! {
+    runner.run().await
 }
 
 #[embassy_executor::main]
@@ -64,16 +65,10 @@ async fn main(spawner: Spawner) {
     let seed = u64::from_le_bytes(seed);
 
     // Init network stack
-    static STACK: StaticCell<Stack<MyDriver>> = StaticCell::new();
     static RESOURCES: StaticCell<StackResources<2>> = StaticCell::new();
-    let stack = &*STACK.init(Stack::new(
-        device,
-        config,
-        RESOURCES.init(StackResources::<2>::new()),
-        seed,
-    ));
+    let (stack, runner) = embassy_net::new(device, config, RESOURCES.init(StackResources::new()), seed);
 
-    unwrap!(spawner.spawn(net_task(stack)));
+    spawner.spawn(unwrap!(net_task(runner)));
 
     perf_client::run(
         stack,
diff --git a/tests/nrf51422/src/bin/gpio.rs b/tests/nrf/src/bin/gpio.rs
index 6d5a87d0a..4995d244c 100644
--- a/tests/nrf51422/src/bin/gpio.rs
+++ b/tests/nrf/src/bin/gpio.rs
@@ -1,25 +1,28 @@
 #![no_std]
 #![no_main]
-teleprobe_meta::target!(b"nrf51-dk");
+
+#[path = "../common.rs"]
+mod common;
 
 use defmt::{assert, info};
 use embassy_executor::Spawner;
 use embassy_nrf::gpio::{Input, Level, Output, OutputDrive, Pull};
 use embassy_time::Timer;
-use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let p = embassy_nrf::init(Default::default());
 
-    let input = Input::new(p.P0_13, Pull::Up);
-    let mut output = Output::new(p.P0_14, Level::Low, OutputDrive::Standard);
+    let input = Input::new(peri!(p, PIN_A), Pull::Up);
+    let mut output = Output::new(peri!(p, PIN_B), Level::Low, OutputDrive::Standard);
 
     output.set_low();
+    assert!(output.is_set_low());
     Timer::after_millis(10).await;
     assert!(input.is_low());
 
     output.set_high();
+    assert!(output.is_set_high());
     Timer::after_millis(10).await;
     assert!(input.is_high());
 
diff --git a/tests/nrf51422/src/bin/gpiote.rs b/tests/nrf/src/bin/gpiote.rs
index 330fe993e..0700016d1 100644
--- a/tests/nrf51422/src/bin/gpiote.rs
+++ b/tests/nrf/src/bin/gpiote.rs
@@ -1,20 +1,21 @@
 #![no_std]
 #![no_main]
-teleprobe_meta::target!(b"nrf51-dk");
+
+#[path = "../common.rs"]
+mod common;
 
 use defmt::{assert, info};
 use embassy_executor::Spawner;
 use embassy_futures::join::join;
 use embassy_nrf::gpio::{Input, Level, Output, OutputDrive, Pull};
 use embassy_time::{Duration, Instant, Timer};
-use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let p = embassy_nrf::init(Default::default());
 
-    let mut input = Input::new(p.P0_13, Pull::Up);
-    let mut output = Output::new(p.P0_14, Level::Low, OutputDrive::Standard);
+    let mut input = Input::new(peri!(p, PIN_A), Pull::Up);
+    let mut output = Output::new(peri!(p, PIN_B), Level::Low, OutputDrive::Standard);
 
     let fut1 = async {
         Timer::after_millis(100).await;
@@ -24,6 +25,7 @@ async fn main(_spawner: Spawner) {
         let start = Instant::now();
         input.wait_for_high().await;
         let dur = Instant::now() - start;
+        info!("took {} ms", dur.as_millis());
         assert!((Duration::from_millis(90)..Duration::from_millis(110)).contains(&dur));
     };
 
@@ -37,6 +39,7 @@ async fn main(_spawner: Spawner) {
         let start = Instant::now();
         input.wait_for_low().await;
         let dur = Instant::now() - start;
+        info!("took {} ms", dur.as_millis());
         assert!((Duration::from_millis(90)..Duration::from_millis(110)).contains(&dur));
     };
 
diff --git a/tests/nrf/src/bin/spim.rs b/tests/nrf/src/bin/spim.rs
new file mode 100644
index 000000000..2b38f0409
--- /dev/null
+++ b/tests/nrf/src/bin/spim.rs
@@ -0,0 +1,42 @@
+// required-features: easydma
+#![no_std]
+#![no_main]
+
+#[path = "../common.rs"]
+mod common;
+
+use defmt::{assert_eq, *};
+use embassy_executor::Spawner;
+use embassy_nrf::spim::Spim;
+use embassy_nrf::{peripherals, spim};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut p = embassy_nrf::init(Default::default());
+    let mut config = spim::Config::default();
+    config.frequency = spim::Frequency::M1;
+    let mut spim = Spim::new(
+        peri!(p, SPIM0).reborrow(),
+        irqs!(SPIM0),
+        peri!(p, PIN_X).reborrow(),
+        peri!(p, PIN_A).reborrow(), // MISO
+        peri!(p, PIN_B).reborrow(), // MOSI
+        config.clone(),
+    );
+    let data = [
+        0x42, 0x43, 0x44, 0x45, 0x66, 0x12, 0x23, 0x34, 0x45, 0x19, 0x91, 0xaa, 0xff, 0xa5, 0x5a, 0x77,
+    ];
+    let mut buf = [0u8; 16];
+
+    buf.fill(0);
+    spim.blocking_transfer(&mut buf, &data).unwrap();
+    assert_eq!(data, buf);
+
+    buf.fill(0);
+    spim.transfer(&mut buf, &data).await.unwrap();
+    assert_eq!(data, buf);
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf51422/src/bin/timer.rs b/tests/nrf/src/bin/timer.rs
index cf9ea41a8..1ae9dd647 100644
--- a/tests/nrf51422/src/bin/timer.rs
+++ b/tests/nrf/src/bin/timer.rs
@@ -1,6 +1,8 @@
 #![no_std]
 #![no_main]
-teleprobe_meta::target!(b"nrf51-dk");
+
+#[path = "../common.rs"]
+mod common;
 
 use defmt::{assert, info};
 use embassy_executor::Spawner;
diff --git a/tests/nrf/src/bin/uart_halves.rs b/tests/nrf/src/bin/uart_halves.rs
new file mode 100644
index 000000000..a462f80ce
--- /dev/null
+++ b/tests/nrf/src/bin/uart_halves.rs
@@ -0,0 +1,51 @@
+// required-features: two-uarts
+#![no_std]
+#![no_main]
+
+#[path = "../common.rs"]
+mod common;
+
+use defmt::{assert_eq, *};
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_nrf::uarte::{UarteRx, UarteTx};
+use embassy_nrf::{peripherals, uarte};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut p = embassy_nrf::init(Default::default());
+    let mut config = uarte::Config::default();
+    config.parity = uarte::Parity::EXCLUDED;
+    config.baudrate = uarte::Baudrate::BAUD1M;
+
+    let mut tx = UarteTx::new(
+        peri!(p, UART0).reborrow(),
+        irqs!(UART0),
+        peri!(p, PIN_A).reborrow(),
+        config.clone(),
+    );
+    let mut rx = UarteRx::new(
+        peri!(p, UART1).reborrow(),
+        irqs!(UART1),
+        peri!(p, PIN_B).reborrow(),
+        config.clone(),
+    );
+
+    let data = [
+        0x42, 0x43, 0x44, 0x45, 0x66, 0x12, 0x23, 0x34, 0x45, 0x19, 0x91, 0xaa, 0xff, 0xa5, 0x5a, 0x77,
+    ];
+
+    let tx_fut = async {
+        tx.write(&data).await.unwrap();
+    };
+    let rx_fut = async {
+        let mut buf = [0u8; 16];
+        rx.read(&mut buf).await.unwrap();
+        assert_eq!(data, buf);
+    };
+    join(rx_fut, tx_fut).await;
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf/src/bin/uart_split.rs b/tests/nrf/src/bin/uart_split.rs
new file mode 100644
index 000000000..8fe710068
--- /dev/null
+++ b/tests/nrf/src/bin/uart_split.rs
@@ -0,0 +1,49 @@
+// required-features: easydma
+#![no_std]
+#![no_main]
+
+#[path = "../common.rs"]
+mod common;
+
+use defmt::{assert_eq, *};
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_nrf::uarte::Uarte;
+use embassy_nrf::{peripherals, uarte};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut p = embassy_nrf::init(Default::default());
+    let mut config = uarte::Config::default();
+    config.parity = uarte::Parity::EXCLUDED;
+    config.baudrate = uarte::Baudrate::BAUD9600;
+
+    let uarte = Uarte::new(
+        peri!(p, UART0).reborrow(),
+        peri!(p, PIN_A).reborrow(),
+        peri!(p, PIN_B).reborrow(),
+        irqs!(UART0),
+        config.clone(),
+    );
+    let (mut tx, mut rx) = uarte.split();
+
+    let data = [
+        0x42, 0x43, 0x44, 0x45, 0x66, 0x12, 0x23, 0x34, 0x45, 0x19, 0x91, 0xaa, 0xff, 0xa5, 0x5a, 0x77,
+    ];
+
+    let tx_fut = async {
+        Timer::after_millis(10).await;
+        tx.write(&data).await.unwrap();
+    };
+    let rx_fut = async {
+        let mut buf = [0u8; 16];
+        rx.read(&mut buf).await.unwrap();
+        assert_eq!(data, buf);
+    };
+    join(rx_fut, tx_fut).await;
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf52840/src/bin/wifi_esp_hosted_perf.rs b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
index b83edddc4..ac082dbb8 100644
--- a/tests/nrf52840/src/bin/wifi_esp_hosted_perf.rs
+++ b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
@@ -1,3 +1,4 @@
+// required-features: nrf52840
 #![no_std]
 #![no_main]
 teleprobe_meta::target!(b"nrf52840-dk");
@@ -5,7 +6,7 @@ teleprobe_meta::timeout!(120);
 
 use defmt::{info, unwrap};
 use embassy_executor::Spawner;
-use embassy_net::{Config, Stack, StackResources};
+use embassy_net::{Config, StackResources};
 use embassy_nrf::gpio::{Input, Level, Output, OutputDrive, Pull};
 use embassy_nrf::rng::Rng;
 use embassy_nrf::spim::{self, Spim};
@@ -28,8 +29,7 @@ const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
 async fn wifi_task(
     runner: hosted::Runner<
         'static,
-        ExclusiveDevice<Spim<'static, peripherals::SPI3>, Output<'static>, Delay>,
-        Input<'static>,
+        hosted::SpiInterface<ExclusiveDevice<Spim<'static>, Output<'static>, Delay>, Input<'static>>,
         Output<'static>,
     >,
 ) -> ! {
@@ -39,8 +39,8 @@ async fn wifi_task(
 type MyDriver = hosted::NetDriver<'static>;
 
 #[embassy_executor::task]
-async fn net_task(stack: &'static Stack<MyDriver>) -> ! {
-    stack.run().await
+async fn net_task(mut runner: embassy_net::Runner<'static, MyDriver>) -> ! {
+    runner.run().await
 }
 
 #[embassy_executor::main]
@@ -63,17 +63,13 @@ async fn main(spawner: Spawner) {
     let spi = spim::Spim::new(p.SPI3, Irqs, sck, miso, mosi, config);
     let spi = ExclusiveDevice::new(spi, cs, Delay);
 
+    let iface = hosted::SpiInterface::new(spi, handshake, ready);
+
     static STATE: StaticCell<embassy_net_esp_hosted::State> = StaticCell::new();
-    let (device, mut control, runner) = embassy_net_esp_hosted::new(
-        STATE.init(embassy_net_esp_hosted::State::new()),
-        spi,
-        handshake,
-        ready,
-        reset,
-    )
-    .await;
+    let (device, mut control, runner) =
+        embassy_net_esp_hosted::new(STATE.init(embassy_net_esp_hosted::State::new()), iface, reset).await;
 
-    unwrap!(spawner.spawn(wifi_task(runner)));
+    spawner.spawn(unwrap!(wifi_task(runner)));
 
     unwrap!(control.init().await);
     unwrap!(control.connect(WIFI_NETWORK, WIFI_PASSWORD).await);
@@ -85,16 +81,15 @@ async fn main(spawner: Spawner) {
     let seed = u64::from_le_bytes(seed);
 
     // Init network stack
-    static STACK: StaticCell<Stack<MyDriver>> = StaticCell::new();
     static RESOURCES: StaticCell<StackResources<2>> = StaticCell::new();
-    let stack = &*STACK.init(Stack::new(
+    let (stack, runner) = embassy_net::new(
         device,
         Config::dhcpv4(Default::default()),
-        RESOURCES.init(StackResources::<2>::new()),
+        RESOURCES.init(StackResources::new()),
         seed,
-    ));
+    );
 
-    unwrap!(spawner.spawn(net_task(stack)));
+    spawner.spawn(unwrap!(net_task(runner)));
 
     perf_client::run(
         stack,
diff --git a/tests/nrf/src/common.rs b/tests/nrf/src/common.rs
new file mode 100644
index 000000000..ebd332d15
--- /dev/null
+++ b/tests/nrf/src/common.rs
@@ -0,0 +1,117 @@
+#![macro_use]
+
+use {defmt_rtt as _, panic_probe as _};
+
+#[cfg(feature = "nrf52832")]
+teleprobe_meta::target!(b"nrf52832-dk");
+#[cfg(feature = "nrf52840")]
+teleprobe_meta::target!(b"nrf52840-dk");
+#[cfg(feature = "nrf52833")]
+teleprobe_meta::target!(b"nrf52833-dk");
+#[cfg(feature = "nrf5340")]
+teleprobe_meta::target!(b"nrf5340-dk");
+#[cfg(feature = "nrf9160")]
+teleprobe_meta::target!(b"nrf9160-dk");
+#[cfg(feature = "nrf51422")]
+teleprobe_meta::target!(b"nrf51-dk");
+
+macro_rules! define_peris {
+    ($($name:ident = $peri:ident,)* $(@irq $irq_name:ident = $irq_code:tt,)*) => {
+        #[allow(unused_macros)]
+        macro_rules! peri {
+            $(
+                ($p:expr, $name) => {
+                    $p.$peri
+                };
+            )*
+        }
+        #[allow(unused_macros)]
+        macro_rules! irqs {
+            $(
+                ($irq_name) => {{
+                    embassy_nrf::bind_interrupts!(struct Irqs $irq_code);
+                    Irqs
+                }};
+            )*
+            ( @ dummy ) => {};
+        }
+
+        #[allow(unused)]
+        #[allow(non_camel_case_types)]
+        pub mod peris {
+            $(
+                pub type $name = embassy_nrf::peripherals::$peri;
+            )*
+        }
+    };
+}
+
+#[cfg(feature = "nrf51422")]
+define_peris!(PIN_A = P0_13, PIN_B = P0_14,);
+
+#[cfg(feature = "nrf52832")]
+define_peris!(
+    PIN_A = P0_11, PIN_B = P0_12,
+    PIN_X = P0_13,
+    UART0 = UARTE0,
+    SPIM0 = TWISPI0,
+    @irq UART0 = {UARTE0 => uarte::InterruptHandler<peripherals::UARTE0>;},
+    @irq UART0_BUFFERED = {UARTE0 => buffered_uarte::InterruptHandler<peripherals::UARTE0>;},
+    @irq SPIM0 = {TWISPI0 => spim::InterruptHandler<peripherals::TWISPI0>;},
+);
+
+#[cfg(feature = "nrf52833")]
+define_peris!(
+    PIN_A = P1_01, PIN_B = P1_02,
+    PIN_X = P1_03,
+    UART0 = UARTE0,
+    UART1 = UARTE1,
+    SPIM0 = TWISPI0,
+    @irq UART0 = {UARTE0 => uarte::InterruptHandler<peripherals::UARTE0>;},
+    @irq UART1 = {UARTE1 => uarte::InterruptHandler<peripherals::UARTE1>;},
+    @irq UART0_BUFFERED = {UARTE0 => buffered_uarte::InterruptHandler<peripherals::UARTE0>;},
+    @irq UART1_BUFFERED = {UARTE1 => buffered_uarte::InterruptHandler<peripherals::UARTE1>;},
+    @irq SPIM0 = {TWISPI0 => spim::InterruptHandler<peripherals::TWISPI0>;},
+);
+
+#[cfg(feature = "nrf52840")]
+define_peris!(
+    PIN_A = P1_02, PIN_B = P1_03,
+    PIN_X = P1_04,
+    UART0 = UARTE0,
+    UART1 = UARTE1,
+    SPIM0 = TWISPI0,
+    @irq UART0 = {UARTE0 => uarte::InterruptHandler<peripherals::UARTE0>;},
+    @irq UART1 = {UARTE1 => uarte::InterruptHandler<peripherals::UARTE1>;},
+    @irq UART0_BUFFERED = {UARTE0 => buffered_uarte::InterruptHandler<peripherals::UARTE0>;},
+    @irq UART1_BUFFERED = {UARTE1 => buffered_uarte::InterruptHandler<peripherals::UARTE1>;},
+    @irq SPIM0 = {TWISPI0 => spim::InterruptHandler<peripherals::TWISPI0>;},
+);
+
+#[cfg(feature = "nrf5340")]
+define_peris!(
+    PIN_A = P1_08, PIN_B = P1_09,
+    PIN_X = P1_10,
+    UART0 = SERIAL0,
+    UART1 = SERIAL1,
+    SPIM0 = SERIAL0,
+    @irq UART0 = {SERIAL0 => uarte::InterruptHandler<peripherals::SERIAL0>;},
+    @irq UART1 = {SERIAL1 => uarte::InterruptHandler<peripherals::SERIAL1>;},
+    @irq UART0_BUFFERED = {SERIAL0 => buffered_uarte::InterruptHandler<peripherals::SERIAL0>;},
+    @irq UART1_BUFFERED = {SERIAL1 => buffered_uarte::InterruptHandler<peripherals::SERIAL1>;},
+    @irq SPIM0 = {SERIAL0 => spim::InterruptHandler<peripherals::SERIAL0>;},
+);
+
+#[cfg(feature = "nrf9160")]
+define_peris!(
+    PIN_A = P0_00, PIN_B = P0_01,
+    PIN_X = P0_02,
+    UART0 = SERIAL0,
+    UART1 = SERIAL1,
+    SPIM0 = SERIAL0,
+    @irq UART0 = {SERIAL0 => uarte::InterruptHandler<peripherals::SERIAL0>;},
+    @irq UART1 = {SERIAL1 => uarte::InterruptHandler<peripherals::SERIAL1>;},
+    @irq UART0_BUFFERED = {SERIAL0 => buffered_uarte::InterruptHandler<peripherals::SERIAL0>;},
+    @irq UART1_BUFFERED = {SERIAL1 => buffered_uarte::InterruptHandler<peripherals::SERIAL1>;},
+    @irq SPIM0 = {SERIAL0 => spim::InterruptHandler<peripherals::SERIAL0>;},
+);
diff --git a/tests/nrf51422/Cargo.toml b/tests/nrf51422/Cargo.toml
deleted file mode 100644
index 8bfcc2922..000000000
--- a/tests/nrf51422/Cargo.toml
+++ /dev/null
@@ -1,23 +0,0 @@
-[package]
-edition = "2021"
-name = "embassy-nrf51-tests"
-version = "0.1.0"
-license = "MIT OR Apache-2.0"
-
-[dependencies]
-teleprobe-meta = "1"
-
-embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
-embassy-sync = { version = "0.6.0", path = "../../embassy-sync", features = ["defmt", ] }
-embassy-executor = { version = "0.5.0", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "defmt", "task-arena-size-128", "integrated-timers"] }
-embassy-time = { version = "0.3.1", path = "../../embassy-time", features = ["defmt",  "defmt-timestamp-uptime"] }
-embassy-nrf = { version = "0.1.0", path = "../../embassy-nrf", features = ["defmt",  "nrf51", "time-driver-rtc1", "unstable-pac", "time", "gpiote"] }
-embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
-embedded-hal-async = { version = "1.0" }
-
-defmt = "0.3"
-defmt-rtt = "0.4"
-
-cortex-m = { version = "0.7.6", features = ["critical-section-single-core"] }
-cortex-m-rt = "0.7.0"
-panic-probe = { version = "0.3", features = ["print-defmt"] }
diff --git a/tests/nrf51422/build.rs b/tests/nrf51422/build.rs
deleted file mode 100644
index 13ebbe4ee..000000000
--- a/tests/nrf51422/build.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use std::error::Error;
-use std::path::PathBuf;
-use std::{env, fs};
-
-fn main() -> Result<(), Box<dyn Error>> {
-    let out = PathBuf::from(env::var("OUT_DIR").unwrap());
-    fs::write(out.join("memory.x"), include_bytes!("memory.x")).unwrap();
-    println!("cargo:rustc-link-search={}", out.display());
-    println!("cargo:rerun-if-changed=memory.x");
-
-    println!("cargo:rustc-link-arg-bins=--nmagic");
-    println!("cargo:rustc-link-arg-bins=-Tlink.x");
-    println!("cargo:rustc-link-arg-bins=-Tdefmt.x");
-    println!("cargo:rustc-link-arg-bins=-Tteleprobe.x");
-
-    Ok(())
-}
diff --git a/tests/nrf51422/memory.x b/tests/nrf51422/memory.x
deleted file mode 100644
index a5881e66f..000000000
--- a/tests/nrf51422/memory.x
+++ /dev/null
@@ -1,5 +0,0 @@
-MEMORY
-{
-  FLASH : ORIGIN = 0x00000000, LENGTH = 128K
-  RAM : ORIGIN = 0x20000000, LENGTH = 16K
-}
diff --git a/tests/nrf52840/Cargo.toml b/tests/nrf52840/Cargo.toml
deleted file mode 100644
index 1670b92ad..000000000
--- a/tests/nrf52840/Cargo.toml
+++ /dev/null
@@ -1,29 +0,0 @@
-[package]
-edition = "2021"
-name = "embassy-nrf-examples"
-version = "0.1.0"
-license = "MIT OR Apache-2.0"
-
-[dependencies]
-teleprobe-meta = "1"
-
-embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
-embassy-sync = { version = "0.6.0", path = "../../embassy-sync", features = ["defmt", ] }
-embassy-executor = { version = "0.5.0", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "defmt", "task-arena-size-16384", "integrated-timers"] }
-embassy-time = { version = "0.3.1", path = "../../embassy-time", features = ["defmt",  "defmt-timestamp-uptime"] }
-embassy-nrf = { version = "0.1.0", path = "../../embassy-nrf", features = ["defmt",  "nrf52840", "time-driver-rtc1", "gpiote", "unstable-pac"] }
-embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
-embassy-net = { version = "0.4.0", path = "../../embassy-net", features = ["defmt", "tcp", "dhcpv4", "medium-ethernet", ] }
-embassy-net-esp-hosted = { version = "0.1.0", path = "../../embassy-net-esp-hosted", features = ["defmt"] }
-embassy-net-enc28j60 = { version = "0.1.0", path = "../../embassy-net-enc28j60", features = ["defmt"] }
-embedded-hal-async = { version = "1.0" }
-embedded-hal-bus = { version = "0.1", features = ["async"] }
-static_cell = "2"
-perf-client = { path = "../perf-client" }
-
-defmt = "0.3"
-defmt-rtt = "0.4"
-
-cortex-m = { version = "0.7.6", features = ["critical-section-single-core"] }
-cortex-m-rt = "0.7.0"
-panic-probe = { version = "0.3", features = ["print-defmt"] }
diff --git a/tests/perf-client/Cargo.toml b/tests/perf-client/Cargo.toml
index 6ecc2d5e1..3756046fa 100644
--- a/tests/perf-client/Cargo.toml
+++ b/tests/perf-client/Cargo.toml
@@ -1,10 +1,12 @@
 [package]
 name = "perf-client"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
+license = "MIT OR Apache-2.0"
+publish = false
 
 [dependencies]
-embassy-net = { version = "0.4.0", path = "../../embassy-net", features = ["defmt", "tcp", "dhcpv4"] }
-embassy-time = { version = "0.3.1", path = "../../embassy-time", features = ["defmt", ] }
-embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
-defmt = "0.3.0"
+embassy-net = { version = "0.7.1", path = "../../embassy-net", features = ["defmt", "tcp", "dhcpv4"] }
+embassy-time = { version = "0.5.0", path = "../../embassy-time", features = ["defmt", ] }
+embassy-futures = { version = "0.1.2", path = "../../embassy-futures" }
+defmt = "1.0.1"
diff --git a/tests/perf-client/src/lib.rs b/tests/perf-client/src/lib.rs
index 54762379a..1ba071e8d 100644
--- a/tests/perf-client/src/lib.rs
+++ b/tests/perf-client/src/lib.rs
@@ -2,10 +2,9 @@
 
 use defmt::{assert, *};
 use embassy_futures::join::join;
-use embassy_net::driver::Driver;
 use embassy_net::tcp::TcpSocket;
 use embassy_net::{Ipv4Address, Stack};
-use embassy_time::{with_timeout, Duration, Timer};
+use embassy_time::{Duration, Timer, with_timeout};
 
 pub struct Expected {
     pub down_kbps: usize,
@@ -13,7 +12,7 @@ pub struct Expected {
     pub updown_kbps: usize,
 }
 
-pub async fn run<D: Driver>(stack: &Stack<D>, expected: Expected) {
+pub async fn run(stack: Stack<'_>, expected: Expected) {
     info!("Waiting for DHCP up...");
     while stack.config_v4().is_none() {
         Timer::after_millis(100).await;
@@ -38,7 +37,7 @@ const DOWNLOAD_PORT: u16 = 4321;
 const UPLOAD_PORT: u16 = 4322;
 const UPLOAD_DOWNLOAD_PORT: u16 = 4323;
 
-async fn test_download<D: Driver>(stack: &Stack<D>) -> usize {
+async fn test_download(stack: Stack<'_>) -> usize {
     info!("Testing download...");
 
     let mut rx_buffer = [0; RX_BUFFER_SIZE];
@@ -78,7 +77,7 @@ async fn test_download<D: Driver>(stack: &Stack<D>) -> usize {
     kbps
 }
 
-async fn test_upload<D: Driver>(stack: &Stack<D>) -> usize {
+async fn test_upload(stack: Stack<'_>) -> usize {
     info!("Testing upload...");
 
     let mut rx_buffer = [0; RX_BUFFER_SIZE];
@@ -118,7 +117,7 @@ async fn test_upload<D: Driver>(stack: &Stack<D>) -> usize {
     kbps
 }
 
-async fn test_upload_download<D: Driver>(stack: &Stack<D>) -> usize {
+async fn test_upload_download(stack: Stack<'_>) -> usize {
     info!("Testing upload+download...");
 
     let mut rx_buffer = [0; RX_BUFFER_SIZE];
diff --git a/tests/perf-server/Cargo.toml b/tests/perf-server/Cargo.toml
index 532039050..72f92ed8d 100644
--- a/tests/perf-server/Cargo.toml
+++ b/tests/perf-server/Cargo.toml
@@ -1,7 +1,9 @@
 [package]
 name = "perf-server"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
+license = "MIT OR Apache-2.0"
+publish = false
 
 [dependencies]
 log = "0.4.17"
diff --git a/tests/riscv32/Cargo.toml b/tests/riscv32/Cargo.toml
index 4f1d3e5c6..935c6a2ee 100644
--- a/tests/riscv32/Cargo.toml
+++ b/tests/riscv32/Cargo.toml
@@ -1,15 +1,16 @@
 [package]
-edition = "2021"
+edition = "2024"
 name = "embassy-riscv-tests"
 version = "0.1.0"
 license = "MIT OR Apache-2.0"
+publish = false
 
 [dependencies]
 critical-section = { version = "1.1.1", features = ["restore-state-bool"] }
-embassy-sync = { version = "0.6.0", path = "../../embassy-sync" }
-embassy-executor = { version = "0.5.0", path = "../../embassy-executor", features = ["arch-riscv32", "executor-thread"] }
-embassy-time = { version = "0.3.1", path = "../../embassy-time" }
-embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
+embassy-sync = { version = "0.7.2", path = "../../embassy-sync" }
+embassy-executor = { version = "0.9.0", path = "../../embassy-executor", features = ["arch-riscv32", "executor-thread"] }
+embassy-time = { version = "0.5.0", path = "../../embassy-time" }
+embassy-futures = { version = "0.1.2", path = "../../embassy-futures" }
 
 riscv-rt = "0.12.2"
 riscv = { version = "0.11.1", features = ["critical-section-single-hart"] }
@@ -44,3 +45,8 @@ debug = false
 debug-assertions = false
 opt-level = 0
 overflow-checks = false
+
+[package.metadata.embassy]
+build = [
+  { target = "riscv32imac-unknown-none-elf" }
+]
diff --git a/tests/rp/.cargo/config.toml b/tests/rp/.cargo/config.toml
index de7bb0e56..649c15048 100644
--- a/tests/rp/.cargo/config.toml
+++ b/tests/rp/.cargo/config.toml
@@ -5,18 +5,19 @@
 #build-std-features = ["panic_immediate_abort"]
 
 [target.'cfg(all(target_arch = "arm", target_os = "none"))']
-runner = "teleprobe client run"
+#runner = "teleprobe client run"
 #runner = "teleprobe local run --chip RP2040 --elf"
+runner = "teleprobe local run --chip RP235X --elf"
 
 rustflags = [
   # Code-size optimizations.
   #"-Z", "trap-unreachable=no",
-  "-C", "inline-threshold=5",
   "-C", "no-vectorize-loops",
 ]
 
 [build]
-target = "thumbv6m-none-eabi"
+#target = "thumbv6m-none-eabi"
+target = "thumbv8m.main-none-eabihf"
 
 [env]
 DEFMT_LOG = "trace,embassy_hal_internal=debug,embassy_net_esp_hosted=debug,cyw43=info,cyw43_pio=info,smoltcp=info"
diff --git a/tests/rp/Cargo.toml b/tests/rp/Cargo.toml
index 45050ee0e..640e58f11 100644
--- a/tests/rp/Cargo.toml
+++ b/tests/rp/Cargo.toml
@@ -1,26 +1,32 @@
 [package]
-edition = "2021"
+edition = "2024"
 name = "embassy-rp-tests"
 version = "0.1.0"
 license = "MIT OR Apache-2.0"
+publish = false
+
+[features]
+rp2040 = ["embassy-rp/rp2040"]
+rp235xa = ["embassy-rp/rp235xa"]
+rp235xb = ["embassy-rp/rp235xb"]
 
 [dependencies]
 teleprobe-meta = "1.1"
 
-embassy-sync = { version = "0.6.0", path = "../../embassy-sync", features = ["defmt"] }
-embassy-executor = { version = "0.5.0", path = "../../embassy-executor", features = ["task-arena-size-32768", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
-embassy-time = { version = "0.3.1", path = "../../embassy-time", features = ["defmt", ] }
-embassy-rp = { version = "0.1.0", path = "../../embassy-rp", features = [ "defmt", "unstable-pac", "time-driver", "critical-section-impl", "intrinsics", "rom-v2-intrinsics", "run-from-ram"]  }
-embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
-embassy-net = { version = "0.4.0", path = "../../embassy-net", features = ["defmt",  "tcp", "udp", "dhcpv4", "medium-ethernet"] }
-embassy-net-wiznet = { version = "0.1.0", path = "../../embassy-net-wiznet", features = ["defmt"] }
-embassy-embedded-hal = { version = "0.1.0", path = "../../embassy-embedded-hal/"}
+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-time = { version = "0.5.0", path = "../../embassy-time", features = ["defmt", ] }
+embassy-rp = { version = "0.8.0", path = "../../embassy-rp", features = [ "defmt", "unstable-pac", "time-driver", "critical-section-impl", "intrinsics", "rom-v2-intrinsics", "run-from-ram"]  }
+embassy-futures = { version = "0.1.2", path = "../../embassy-futures" }
+embassy-net = { version = "0.7.1", path = "../../embassy-net", features = ["defmt",  "tcp", "udp", "dhcpv4", "medium-ethernet"] }
+embassy-net-wiznet = { version = "0.2.1", path = "../../embassy-net-wiznet", features = ["defmt"] }
+embassy-embedded-hal = { version = "0.5.0", path = "../../embassy-embedded-hal/"}
 cyw43 = { path = "../../cyw43", features = ["defmt", "firmware-logs"] }
-cyw43-pio = { path = "../../cyw43-pio", features = ["defmt", "overclock"] }
+cyw43-pio = { path = "../../cyw43-pio", features = ["defmt"] }
 perf-client = { path = "../perf-client" }
 
-defmt = "0.3.0"
-defmt-rtt = "0.4"
+defmt = "1.0.1"
+defmt-rtt = "1.0.0"
 
 cortex-m = { version = "0.7.6" }
 cortex-m-rt = "0.7.0"
@@ -28,14 +34,41 @@ embedded-hal = "0.2.6"
 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 = "0.3.0", features = ["print-defmt"] }
+panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 embedded-io-async = { version = "0.6.1" }
 embedded-storage = { version = "0.3" }
 static_cell = "2"
 portable-atomic = { version = "1.5", features = ["critical-section"] }
-pio = "0.2"
-pio-proc = "0.2"
-rand = { version = "0.8.5", default-features = false }
+
+# bootsel not currently supported on 2350
+[[bin]]
+name = "bootsel"
+path = "src/bin/bootsel.rs"
+required-features = [ "rp2040",]
+
+# 2350 devboard isn't a W
+[[bin]]
+name = "cyw43-perf"
+path = "src/bin/cyw43-perf.rs"
+required-features = [ "rp2040",]
+
+# Eth test only for the w5100s-evb-pico
+[[bin]]
+name = "ethernet_w5100s_perf"
+path = "src/bin/ethernet_w5100s_perf.rs"
+required-features = [ "rp2040",]
+
+# Float intrinsics are only relevant for the 2040
+[[bin]]
+name = "float"
+path = "src/bin/float.rs"
+required-features = [ "rp2040",]
+
+# RTC is only available on RP2040
+[[bin]]
+name = "rtc"
+path = "src/bin/rtc.rs"
+required-features = [ "rp2040",]
 
 [profile.dev]
 debug = 2
@@ -66,3 +99,9 @@ debug = false
 debug-assertions = false
 opt-level = 0
 overflow-checks = false
+
+[package.metadata.embassy]
+build = [
+  { target = "thumbv6m-none-eabi", features = ["rp2040"], artifact-dir = "out/tests/rpi-pico" },
+  { target = "thumbv8m.main-none-eabihf", features = ["rp235xb"], artifact-dir = "out/tests/pimoroni-pico-plus-2" }
+]
diff --git a/tests/rp/readme.md b/tests/rp/readme.md
new file mode 100644
index 000000000..f8192a95a
--- /dev/null
+++ b/tests/rp/readme.md
@@ -0,0 +1,8 @@
+# Pico and Pico 2 Plus connections
+
+GP0-GP1
+GP3-GP4
+GP6-GP9
+GP7-GP11
+GP18-GP20 with 10k pullup
+GP19-GP21 with 10k pullup
diff --git a/tests/rp/src/bin/adc.rs b/tests/rp/src/bin/adc.rs
index 29eda95bf..c2175bc03 100644
--- a/tests/rp/src/bin/adc.rs
+++ b/tests/rp/src/bin/adc.rs
@@ -1,6 +1,9 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::*;
 use embassy_executor::Spawner;
@@ -20,14 +23,19 @@ async fn main(_spawner: Spawner) {
     let _wifi_off = Output::new(p.PIN_25, Level::High);
     let mut adc = Adc::new(p.ADC, Irqs, Config::default());
 
+    #[cfg(any(feature = "rp2040", feature = "rp235xa"))]
+    let (mut a, mut b, mut c, mut d) = (p.PIN_26, p.PIN_27, p.PIN_28, p.PIN_29);
+    #[cfg(feature = "rp235xb")]
+    let (mut a, mut b, mut c, mut d) = (p.PIN_44, p.PIN_45, p.PIN_46, p.PIN_47);
+
     {
         {
-            let mut p = Channel::new_pin(&mut p.PIN_26, Pull::Down);
+            let mut p = Channel::new_pin(a.reborrow(), Pull::Down);
             defmt::assert!(adc.blocking_read(&mut p).unwrap() < 0b01_0000_0000);
             defmt::assert!(adc.read(&mut p).await.unwrap() < 0b01_0000_0000);
         }
         {
-            let mut p = Channel::new_pin(&mut p.PIN_26, Pull::Up);
+            let mut p = Channel::new_pin(a.reborrow(), Pull::Up);
             defmt::assert!(adc.blocking_read(&mut p).unwrap() > 0b11_0000_0000);
             defmt::assert!(adc.read(&mut p).await.unwrap() > 0b11_0000_0000);
         }
@@ -35,21 +43,21 @@ async fn main(_spawner: Spawner) {
     // not bothering with async reads from now on
     {
         {
-            let mut p = Channel::new_pin(&mut p.PIN_27, Pull::Down);
+            let mut p = Channel::new_pin(b.reborrow(), Pull::Down);
             defmt::assert!(adc.blocking_read(&mut p).unwrap() < 0b01_0000_0000);
         }
         {
-            let mut p = Channel::new_pin(&mut p.PIN_27, Pull::Up);
+            let mut p = Channel::new_pin(b.reborrow(), Pull::Up);
             defmt::assert!(adc.blocking_read(&mut p).unwrap() > 0b11_0000_0000);
         }
     }
     {
         {
-            let mut p = Channel::new_pin(&mut p.PIN_28, Pull::Down);
+            let mut p = Channel::new_pin(c.reborrow(), Pull::Down);
             defmt::assert!(adc.blocking_read(&mut p).unwrap() < 0b01_0000_0000);
         }
         {
-            let mut p = Channel::new_pin(&mut p.PIN_28, Pull::Up);
+            let mut p = Channel::new_pin(c.reborrow(), Pull::Up);
             defmt::assert!(adc.blocking_read(&mut p).unwrap() > 0b11_0000_0000);
         }
     }
@@ -57,15 +65,15 @@ async fn main(_spawner: Spawner) {
         // gp29 is connected to vsys through a 200k/100k divider,
         // adding pulls should change the value
         let low = {
-            let mut p = Channel::new_pin(&mut p.PIN_29, Pull::Down);
+            let mut p = Channel::new_pin(d.reborrow(), Pull::Down);
             adc.blocking_read(&mut p).unwrap()
         };
         let none = {
-            let mut p = Channel::new_pin(&mut p.PIN_29, Pull::None);
+            let mut p = Channel::new_pin(d.reborrow(), Pull::None);
             adc.blocking_read(&mut p).unwrap()
         };
         let up = {
-            let mut p = Channel::new_pin(&mut p.PIN_29, Pull::Up);
+            let mut p = Channel::new_pin(d.reborrow(), Pull::Up);
             adc.blocking_read(&mut p).unwrap()
         };
         defmt::assert!(low < none);
@@ -73,7 +81,7 @@ async fn main(_spawner: Spawner) {
     }
     {
         let temp = convert_to_celsius(
-            adc.read(&mut Channel::new_temp_sensor(&mut p.ADC_TEMP_SENSOR))
+            adc.read(&mut Channel::new_temp_sensor(p.ADC_TEMP_SENSOR.reborrow()))
                 .await
                 .unwrap(),
         );
@@ -90,26 +98,26 @@ async fn main(_spawner: Spawner) {
         let mut none = [0u8; 16];
         let mut up = [Sample::default(); 16];
         adc.read_many(
-            &mut Channel::new_pin(&mut p.PIN_29, Pull::Down),
+            &mut Channel::new_pin(d.reborrow(), Pull::Down),
             &mut low,
             1,
-            &mut p.DMA_CH0,
+            p.DMA_CH0.reborrow(),
         )
         .await
         .unwrap();
         adc.read_many(
-            &mut Channel::new_pin(&mut p.PIN_29, Pull::None),
+            &mut Channel::new_pin(d.reborrow(), Pull::None),
             &mut none,
             1,
-            &mut p.DMA_CH0,
+            p.DMA_CH0.reborrow(),
         )
         .await
         .unwrap();
         adc.read_many_raw(
-            &mut Channel::new_pin(&mut p.PIN_29, Pull::Up),
+            &mut Channel::new_pin(d.reborrow(), Pull::Up),
             &mut up,
             1,
-            &mut p.DMA_CH0,
+            p.DMA_CH0.reborrow(),
         )
         .await;
         defmt::assert!(low.iter().zip(none.iter()).all(|(l, n)| *l >> 4 < *n as u16));
@@ -119,10 +127,10 @@ async fn main(_spawner: Spawner) {
     {
         let mut temp = [0u16; 16];
         adc.read_many(
-            &mut Channel::new_temp_sensor(&mut p.ADC_TEMP_SENSOR),
+            &mut Channel::new_temp_sensor(p.ADC_TEMP_SENSOR.reborrow()),
             &mut temp,
             1,
-            &mut p.DMA_CH0,
+            p.DMA_CH0.reborrow(),
         )
         .await
         .unwrap();
@@ -130,6 +138,19 @@ async fn main(_spawner: Spawner) {
         defmt::assert!(temp.iter().all(|t| *t > 0.0));
         defmt::assert!(temp.iter().all(|t| *t < 60.0));
     }
+    {
+        let mut multi = [0u16; 2];
+        let mut channels = [
+            Channel::new_pin(a.reborrow(), Pull::Up),
+            Channel::new_temp_sensor(p.ADC_TEMP_SENSOR.reborrow()),
+        ];
+        adc.read_many_multichannel(&mut channels, &mut multi, 1, p.DMA_CH0.reborrow())
+            .await
+            .unwrap();
+        defmt::assert!(multi[0] > 3_000);
+        let temp = convert_to_celsius(multi[1]);
+        defmt::assert!(temp > 0.0 && temp < 60.0);
+    }
 
     info!("Test OK");
     cortex_m::asm::bkpt();
diff --git a/tests/rp/src/bin/bootsel.rs b/tests/rp/src/bin/bootsel.rs
index e88d8bf6c..aa123ab03 100644
--- a/tests/rp/src/bin/bootsel.rs
+++ b/tests/rp/src/bin/bootsel.rs
@@ -4,12 +4,13 @@ teleprobe_meta::target!(b"rpi-pico");
 
 use defmt::{assert_eq, *};
 use embassy_executor::Spawner;
+use embassy_rp::bootsel::is_bootsel_pressed;
 use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let mut p = embassy_rp::init(Default::default());
+    let p = embassy_rp::init(Default::default());
     info!("Hello World!");
 
     // add some delay to give an attached debug probe time to parse the
@@ -18,7 +19,7 @@ async fn main(_spawner: Spawner) {
     // https://github.com/knurling-rs/defmt/pull/683
     Timer::after_millis(10).await;
 
-    assert_eq!(p.BOOTSEL.is_pressed(), false);
+    assert_eq!(is_bootsel_pressed(p.BOOTSEL), false);
 
     info!("Test OK");
     cortex_m::asm::bkpt();
diff --git a/tests/rp/src/bin/cyw43-perf.rs b/tests/rp/src/bin/cyw43-perf.rs
index 4b0c7f7b9..9487f5e1a 100644
--- a/tests/rp/src/bin/cyw43-perf.rs
+++ b/tests/rp/src/bin/cyw43-perf.rs
@@ -2,10 +2,11 @@
 #![no_main]
 teleprobe_meta::target!(b"rpi-pico");
 
-use cyw43_pio::PioSpi;
+use cyw43::JoinOptions;
+use cyw43_pio::{DEFAULT_CLOCK_DIVIDER, PioSpi};
 use defmt::{panic, *};
 use embassy_executor::Spawner;
-use embassy_net::{Config, Stack, StackResources};
+use embassy_net::{Config, StackResources};
 use embassy_rp::gpio::{Level, Output};
 use embassy_rp::peripherals::{DMA_CH0, PIO0};
 use embassy_rp::pio::{InterruptHandler, Pio};
@@ -20,7 +21,7 @@ bind_interrupts!(struct Irqs {
 teleprobe_meta::timeout!(120);
 
 // Test-only wifi network, no internet access!
-const WIFI_NETWORK: &str = "EmbassyTest";
+const WIFI_NETWORK: &str = "EmbassyTestWPA2";
 const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
 
 #[embassy_executor::task]
@@ -29,8 +30,8 @@ async fn wifi_task(runner: cyw43::Runner<'static, Output<'static>, PioSpi<'stati
 }
 
 #[embassy_executor::task]
-async fn net_task(stack: &'static Stack<cyw43::NetDriver<'static>>) -> ! {
-    stack.run().await
+async fn net_task(mut runner: embassy_net::Runner<'static, cyw43::NetDriver<'static>>) -> ! {
+    runner.run().await
 }
 
 #[embassy_executor::main]
@@ -45,20 +46,31 @@ async fn main(spawner: Spawner) {
     }
 
     // cyw43 firmware needs to be flashed manually:
-    //     probe-rs download 43439A0.bin     ---binary-format --chip RP2040 --base-address 0x101b0000
-    //     probe-rs download 43439A0_clm.bin ---binary-format --chip RP2040 --base-address 0x101f8000
-    let fw = unsafe { core::slice::from_raw_parts(0x101b0000 as *const u8, 230321) };
-    let clm = unsafe { core::slice::from_raw_parts(0x101f8000 as *const u8, 4752) };
+    //     probe-rs download 43439A0.bin --binary-format bin --chip RP2040 --base-address 0x101b0000
+    //     probe-rs download 43439A0_btfw.bin --binary-format bin --chip RP2040 --base-address 0x101f0000
+    //     probe-rs download 43439A0_clm.bin --binary-format bin --chip RP2040 --base-address 0x101f8000
+    let fw = unsafe { core::slice::from_raw_parts(0x101b0000 as *const u8, 231077) };
+    let _btfw = unsafe { core::slice::from_raw_parts(0x101f0000 as *const u8, 6164) };
+    let clm = unsafe { core::slice::from_raw_parts(0x101f8000 as *const u8, 984) };
 
     let pwr = Output::new(p.PIN_23, Level::Low);
     let cs = Output::new(p.PIN_25, Level::High);
     let mut pio = Pio::new(p.PIO0, Irqs);
-    let spi = PioSpi::new(&mut pio.common, pio.sm0, pio.irq0, cs, p.PIN_24, p.PIN_29, p.DMA_CH0);
+    let spi = PioSpi::new(
+        &mut pio.common,
+        pio.sm0,
+        DEFAULT_CLOCK_DIVIDER,
+        pio.irq0,
+        cs,
+        p.PIN_24,
+        p.PIN_29,
+        p.DMA_CH0,
+    );
 
     static STATE: StaticCell<cyw43::State> = StaticCell::new();
     let state = STATE.init(cyw43::State::new());
     let (net_device, mut control, runner) = cyw43::new(state, pwr, spi, fw).await;
-    unwrap!(spawner.spawn(wifi_task(runner)));
+    spawner.spawn(unwrap!(wifi_task(runner)));
 
     control.init(clm).await;
     control
@@ -69,19 +81,21 @@ async fn main(spawner: Spawner) {
     let seed = 0x0123_4567_89ab_cdef; // chosen by fair dice roll. guarenteed to be random.
 
     // Init network stack
-    static STACK: StaticCell<Stack<cyw43::NetDriver<'static>>> = StaticCell::new();
     static RESOURCES: StaticCell<StackResources<2>> = StaticCell::new();
-    let stack = &*STACK.init(Stack::new(
+    let (stack, runner) = embassy_net::new(
         net_device,
         Config::dhcpv4(Default::default()),
-        RESOURCES.init(StackResources::<2>::new()),
+        RESOURCES.init(StackResources::new()),
         seed,
-    ));
+    );
 
-    unwrap!(spawner.spawn(net_task(stack)));
+    spawner.spawn(unwrap!(net_task(runner)));
 
     loop {
-        match control.join_wpa2(WIFI_NETWORK, WIFI_PASSWORD).await {
+        match control
+            .join(WIFI_NETWORK, JoinOptions::new(WIFI_PASSWORD.as_bytes()))
+            .await
+        {
             Ok(_) => break,
             Err(err) => {
                 panic!("join failed with status={}", err.status);
@@ -92,9 +106,9 @@ async fn main(spawner: Spawner) {
     perf_client::run(
         stack,
         perf_client::Expected {
-            down_kbps: 300,
-            up_kbps: 300,
-            updown_kbps: 300,
+            down_kbps: 200,
+            up_kbps: 200,
+            updown_kbps: 200,
         },
     )
     .await;
diff --git a/tests/rp/src/bin/dma_copy_async.rs b/tests/rp/src/bin/dma_copy_async.rs
index 7c64bc396..3dcf4f4d8 100644
--- a/tests/rp/src/bin/dma_copy_async.rs
+++ b/tests/rp/src/bin/dma_copy_async.rs
@@ -1,6 +1,9 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::{assert_eq, *};
 use embassy_executor::Spawner;
diff --git a/tests/rp/src/bin/ethernet_w5100s_perf.rs b/tests/rp/src/bin/ethernet_w5100s_perf.rs
index 5d5547773..3f2bc728d 100644
--- a/tests/rp/src/bin/ethernet_w5100s_perf.rs
+++ b/tests/rp/src/bin/ethernet_w5100s_perf.rs
@@ -5,7 +5,7 @@ teleprobe_meta::timeout!(120);
 
 use defmt::*;
 use embassy_executor::Spawner;
-use embassy_net::{Stack, StackResources};
+use embassy_net::StackResources;
 use embassy_net_wiznet::chip::W5100S;
 use embassy_net_wiznet::*;
 use embassy_rp::clocks::RoscRng;
@@ -14,7 +14,6 @@ use embassy_rp::peripherals::SPI0;
 use embassy_rp::spi::{Async, Config as SpiConfig, Spi};
 use embassy_time::Delay;
 use embedded_hal_bus::spi::ExclusiveDevice;
-use rand::RngCore;
 use static_cell::StaticCell;
 use {defmt_rtt as _, panic_probe as _};
 
@@ -32,8 +31,8 @@ async fn ethernet_task(
 }
 
 #[embassy_executor::task]
-async fn net_task(stack: &'static Stack<Device<'static>>) -> ! {
-    stack.run().await
+async fn net_task(mut runner: embassy_net::Runner<'static, Device<'static>>) -> ! {
+    runner.run().await
 }
 
 #[embassy_executor::main]
@@ -59,24 +58,24 @@ async fn main(spawner: Spawner) {
         w5500_int,
         w5500_reset,
     )
-    .await;
-    unwrap!(spawner.spawn(ethernet_task(runner)));
+    .await
+    .unwrap();
+    spawner.spawn(unwrap!(ethernet_task(runner)));
 
     // Generate random seed
     let seed = rng.next_u64();
 
     // Init network stack
-    static STACK: StaticCell<Stack<Device<'static>>> = StaticCell::new();
     static RESOURCES: StaticCell<StackResources<2>> = StaticCell::new();
-    let stack = &*STACK.init(Stack::new(
+    let (stack, runner) = embassy_net::new(
         device,
         embassy_net::Config::dhcpv4(Default::default()),
-        RESOURCES.init(StackResources::<2>::new()),
+        RESOURCES.init(StackResources::new()),
         seed,
-    ));
+    );
 
     // Launch network task
-    unwrap!(spawner.spawn(net_task(&stack)));
+    spawner.spawn(unwrap!(net_task(runner)));
 
     perf_client::run(
         stack,
diff --git a/tests/rp/src/bin/flash.rs b/tests/rp/src/bin/flash.rs
index 310f0d586..548a6ee72 100644
--- a/tests/rp/src/bin/flash.rs
+++ b/tests/rp/src/bin/flash.rs
@@ -1,6 +1,9 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::*;
 use embassy_executor::Spawner;
@@ -24,13 +27,19 @@ async fn main(_spawner: Spawner) {
     let mut flash = embassy_rp::flash::Flash::<_, Async, { 2 * 1024 * 1024 }>::new(p.FLASH, p.DMA_CH0);
 
     // Get JEDEC id
-    let jedec = defmt::unwrap!(flash.blocking_jedec_id());
-    info!("jedec id: 0x{:x}", jedec);
+    #[cfg(feature = "rp2040")]
+    {
+        let jedec = defmt::unwrap!(flash.blocking_jedec_id());
+        info!("jedec id: 0x{:x}", jedec);
+    }
 
     // Get unique id
-    let mut uid = [0; 8];
-    defmt::unwrap!(flash.blocking_unique_id(&mut uid));
-    info!("unique id: {:?}", uid);
+    #[cfg(feature = "rp2040")]
+    {
+        let mut uid = [0; 8];
+        defmt::unwrap!(flash.blocking_unique_id(&mut uid));
+        info!("unique id: {:?}", uid);
+    }
 
     let mut buf = [0u8; ERASE_SIZE];
     defmt::unwrap!(flash.blocking_read(ADDR_OFFSET, &mut buf));
diff --git a/tests/rp/src/bin/gpio.rs b/tests/rp/src/bin/gpio.rs
index e0c309887..8bd0df8d8 100644
--- a/tests/rp/src/bin/gpio.rs
+++ b/tests/rp/src/bin/gpio.rs
@@ -1,10 +1,15 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::{assert, *};
 use embassy_executor::Spawner;
-use embassy_rp::gpio::{Flex, Input, Level, Output, OutputOpenDrain, Pull};
+#[cfg(feature = "rp2040")]
+use embassy_rp::gpio::OutputOpenDrain;
+use embassy_rp::gpio::{Flex, Input, Level, Output, Pull};
 use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::main]
@@ -16,10 +21,10 @@ async fn main(_spawner: Spawner) {
 
     // Test initial output
     {
-        let b = Input::new(&mut b, Pull::None);
+        let b = Input::new(b.reborrow(), Pull::None);
 
         {
-            let a = Output::new(&mut a, Level::Low);
+            let a = Output::new(a.reborrow(), Level::Low);
             delay();
             assert!(b.is_low());
             assert!(!b.is_high());
@@ -27,7 +32,7 @@ async fn main(_spawner: Spawner) {
             assert!(!a.is_set_high());
         }
         {
-            let mut a = Output::new(&mut a, Level::High);
+            let mut a = Output::new(a.reborrow(), Level::High);
             delay();
             assert!(!b.is_low());
             assert!(b.is_high());
@@ -62,12 +67,46 @@ async fn main(_spawner: Spawner) {
         }
     }
 
+    // Test input inversion
+    {
+        let mut b = Input::new(b.reborrow(), Pull::None);
+        b.set_inversion(true);
+        // no pull, the status is undefined
+
+        let mut a = Output::new(a.reborrow(), Level::Low);
+        delay();
+        assert!(b.is_high());
+        a.set_high();
+        delay();
+        assert!(b.is_low());
+
+        b.set_inversion(false);
+        a.set_inversion(true);
+
+        a.set_low();
+        delay();
+        assert!(b.is_high());
+
+        a.set_high();
+        delay();
+        assert!(b.is_low());
+
+        b.set_inversion(true);
+        a.set_high();
+        delay();
+        assert!(b.is_high());
+
+        a.set_high();
+        delay();
+        assert!(b.is_high());
+    }
+
     // Test input no pull
     {
-        let b = Input::new(&mut b, Pull::None);
+        let b = Input::new(b.reborrow(), Pull::None);
         // no pull, the status is undefined
 
-        let mut a = Output::new(&mut a, Level::Low);
+        let mut a = Output::new(a.reborrow(), Level::Low);
         delay();
         assert!(b.is_low());
         a.set_high();
@@ -76,12 +115,13 @@ async fn main(_spawner: Spawner) {
     }
 
     // Test input pulldown
+    #[cfg(feature = "rp2040")]
     {
-        let b = Input::new(&mut b, Pull::Down);
+        let b = Input::new(b.reborrow(), Pull::Down);
         delay();
         assert!(b.is_low());
 
-        let mut a = Output::new(&mut a, Level::Low);
+        let mut a = Output::new(a.reborrow(), Level::Low);
         delay();
         assert!(b.is_low());
         a.set_high();
@@ -91,11 +131,11 @@ async fn main(_spawner: Spawner) {
 
     // Test input pullup
     {
-        let b = Input::new(&mut b, Pull::Up);
+        let b = Input::new(b.reborrow(), Pull::Up);
         delay();
         assert!(b.is_high());
 
-        let mut a = Output::new(&mut a, Level::Low);
+        let mut a = Output::new(a.reborrow(), Level::Low);
         delay();
         assert!(b.is_low());
         a.set_high();
@@ -104,9 +144,10 @@ async fn main(_spawner: Spawner) {
     }
 
     // OUTPUT OPEN DRAIN
+    #[cfg(feature = "rp2040")]
     {
-        let mut b = OutputOpenDrain::new(&mut b, Level::High);
-        let mut a = Flex::new(&mut a);
+        let mut b = OutputOpenDrain::new(b.reborrow(), Level::High);
+        let mut a = Flex::new(a.reborrow());
         a.set_as_input();
 
         // When an OutputOpenDrain is high, it doesn't drive the pin.
@@ -163,12 +204,12 @@ async fn main(_spawner: Spawner) {
     // Test initial output
     {
         //Flex pin configured as input
-        let mut b = Flex::new(&mut b);
+        let mut b = Flex::new(b.reborrow());
         b.set_as_input();
 
         {
             //Flex pin configured as output
-            let mut a = Flex::new(&mut a); //Flex pin configured as output
+            let mut a = Flex::new(a.reborrow()); //Flex pin configured as output
             a.set_low(); // Pin state must be set before configuring the pin, thus we avoid unknown state
             a.set_as_output();
             delay();
@@ -176,7 +217,7 @@ async fn main(_spawner: Spawner) {
         }
         {
             //Flex pin configured as output
-            let mut a = Flex::new(&mut a);
+            let mut a = Flex::new(a.reborrow());
             a.set_high();
             a.set_as_output();
 
@@ -187,10 +228,10 @@ async fn main(_spawner: Spawner) {
 
     // Test input no pull
     {
-        let mut b = Flex::new(&mut b);
+        let mut b = Flex::new(b.reborrow());
         b.set_as_input(); // no pull by default.
 
-        let mut a = Flex::new(&mut a);
+        let mut a = Flex::new(a.reborrow());
         a.set_low();
         a.set_as_output();
 
@@ -202,14 +243,15 @@ async fn main(_spawner: Spawner) {
     }
 
     // Test input pulldown
+    #[cfg(feature = "rp2040")]
     {
-        let mut b = Flex::new(&mut b);
+        let mut b = Flex::new(b.reborrow());
         b.set_as_input();
         b.set_pull(Pull::Down);
         delay();
         assert!(b.is_low());
 
-        let mut a = Flex::new(&mut a);
+        let mut a = Flex::new(a.reborrow());
         a.set_low();
         a.set_as_output();
         delay();
@@ -221,13 +263,13 @@ async fn main(_spawner: Spawner) {
 
     // Test input pullup
     {
-        let mut b = Flex::new(&mut b);
+        let mut b = Flex::new(b.reborrow());
         b.set_as_input();
         b.set_pull(Pull::Up);
         delay();
         assert!(b.is_high());
 
-        let mut a = Flex::new(&mut a);
+        let mut a = Flex::new(a.reborrow());
         a.set_high();
         a.set_as_output();
         delay();
diff --git a/tests/rp/src/bin/gpio_async.rs b/tests/rp/src/bin/gpio_async.rs
index 40a304464..72fb0910d 100644
--- a/tests/rp/src/bin/gpio_async.rs
+++ b/tests/rp/src/bin/gpio_async.rs
@@ -1,6 +1,9 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::{assert, *};
 use embassy_executor::Spawner;
@@ -19,8 +22,8 @@ async fn main(_spawner: Spawner) {
 
     {
         info!("test wait_for_high");
-        let mut output = Output::new(&mut output_pin, Level::Low);
-        let mut input = Input::new(&mut input_pin, Pull::None);
+        let mut output = Output::new(output_pin.reborrow(), Level::Low);
+        let mut input = Input::new(input_pin.reborrow(), Pull::None);
 
         assert!(input.is_low(), "input was expected to be low");
 
@@ -40,8 +43,8 @@ async fn main(_spawner: Spawner) {
 
     {
         info!("test wait_for_low");
-        let mut output = Output::new(&mut output_pin, Level::High);
-        let mut input = Input::new(&mut input_pin, Pull::None);
+        let mut output = Output::new(output_pin.reborrow(), Level::High);
+        let mut input = Input::new(input_pin.reborrow(), Pull::None);
 
         assert!(input.is_high(), "input was expected to be high");
 
@@ -60,8 +63,8 @@ async fn main(_spawner: Spawner) {
 
     {
         info!("test wait_for_rising_edge");
-        let mut output = Output::new(&mut output_pin, Level::Low);
-        let mut input = Input::new(&mut input_pin, Pull::None);
+        let mut output = Output::new(output_pin.reborrow(), Level::Low);
+        let mut input = Input::new(input_pin.reborrow(), Pull::None);
 
         assert!(input.is_low(), "input was expected to be low");
 
@@ -80,8 +83,8 @@ async fn main(_spawner: Spawner) {
 
     {
         info!("test wait_for_falling_edge");
-        let mut output = Output::new(&mut output_pin, Level::High);
-        let mut input = Input::new(&mut input_pin, Pull::None);
+        let mut output = Output::new(output_pin.reborrow(), Level::High);
+        let mut input = Input::new(input_pin.reborrow(), Pull::None);
 
         assert!(input.is_high(), "input was expected to be high");
 
@@ -100,8 +103,8 @@ async fn main(_spawner: Spawner) {
 
     {
         info!("test wait_for_any_edge (falling)");
-        let mut output = Output::new(&mut output_pin, Level::High);
-        let mut input = Input::new(&mut input_pin, Pull::None);
+        let mut output = Output::new(output_pin.reborrow(), Level::High);
+        let mut input = Input::new(input_pin.reborrow(), Pull::None);
 
         assert!(input.is_high(), "input was expected to be high");
 
@@ -120,8 +123,8 @@ async fn main(_spawner: Spawner) {
 
     {
         info!("test wait_for_any_edge (rising)");
-        let mut output = Output::new(&mut output_pin, Level::Low);
-        let mut input = Input::new(&mut input_pin, Pull::None);
+        let mut output = Output::new(output_pin.reborrow(), Level::Low);
+        let mut input = Input::new(input_pin.reborrow(), Pull::None);
 
         assert!(input.is_low(), "input was expected to be low");
 
diff --git a/tests/rp/src/bin/gpio_multicore.rs b/tests/rp/src/bin/gpio_multicore.rs
index e9c6f3122..6abcba590 100644
--- a/tests/rp/src/bin/gpio_multicore.rs
+++ b/tests/rp/src/bin/gpio_multicore.rs
@@ -1,11 +1,15 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::{info, unwrap};
 use embassy_executor::Executor;
+use embassy_rp::Peri;
 use embassy_rp::gpio::{Input, Level, Output, Pull};
-use embassy_rp::multicore::{spawn_core1, Stack};
+use embassy_rp::multicore::{Stack, spawn_core1};
 use embassy_rp::peripherals::{PIN_0, PIN_1};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::channel::Channel;
@@ -26,15 +30,15 @@ fn main() -> ! {
         unsafe { &mut *core::ptr::addr_of_mut!(CORE1_STACK) },
         move || {
             let executor1 = EXECUTOR1.init(Executor::new());
-            executor1.run(|spawner| unwrap!(spawner.spawn(core1_task(p.PIN_1))));
+            executor1.run(|spawner| spawner.spawn(unwrap!(core1_task(p.PIN_1))));
         },
     );
     let executor0 = EXECUTOR0.init(Executor::new());
-    executor0.run(|spawner| unwrap!(spawner.spawn(core0_task(p.PIN_0))));
+    executor0.run(|spawner| spawner.spawn(unwrap!(core0_task(p.PIN_0))));
 }
 
 #[embassy_executor::task]
-async fn core0_task(p: PIN_0) {
+async fn core0_task(p: Peri<'static, PIN_0>) {
     info!("CORE0 is running");
 
     let mut pin = Output::new(p, Level::Low);
@@ -51,12 +55,12 @@ async fn core0_task(p: PIN_0) {
 }
 
 #[embassy_executor::task]
-async fn core1_task(p: PIN_1) {
+async fn core1_task(p: Peri<'static, PIN_1>) {
     info!("CORE1 is running");
 
     CHANNEL0.receive().await;
 
-    let mut pin = Input::new(p, Pull::Down);
+    let mut pin = Input::new(p, Pull::None);
     let wait = pin.wait_for_rising_edge();
 
     CHANNEL1.send(()).await;
diff --git a/tests/rp/src/bin/i2c.rs b/tests/rp/src/bin/i2c.rs
index 9615007bd..21761b98b 100644
--- a/tests/rp/src/bin/i2c.rs
+++ b/tests/rp/src/bin/i2c.rs
@@ -1,23 +1,21 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
-use defmt::{assert_eq, info, panic, unwrap};
+use defmt::{assert_eq, info, panic};
 use embassy_embedded_hal::SetConfig;
-use embassy_executor::{Executor, Spawner};
+use embassy_executor::Spawner;
 use embassy_rp::clocks::{PllConfig, XoscConfig};
 use embassy_rp::config::Config as rpConfig;
-use embassy_rp::multicore::{spawn_core1, Stack};
 use embassy_rp::peripherals::{I2C0, I2C1};
 use embassy_rp::{bind_interrupts, i2c, i2c_slave};
 use embedded_hal_1::i2c::Operation;
 use embedded_hal_async::i2c::I2c;
-use static_cell::StaticCell;
 use {defmt_rtt as _, panic_probe as _, panic_probe as _, panic_probe as _};
 
-static mut CORE1_STACK: Stack<1024> = Stack::new();
-static EXECUTOR1: StaticCell<Executor> = StaticCell::new();
-
 use crate::i2c::AbortReason;
 
 bind_interrupts!(struct Irqs {
@@ -106,7 +104,7 @@ async fn device_task(mut dev: i2c_slave::I2cSlave<'static, I2C1>) -> ! {
 }
 
 async fn controller_task(con: &mut i2c::I2c<'static, I2C0, i2c::Async>) {
-    info!("Device start");
+    info!("Controller start");
 
     {
         let buf = [0xCA, 0x11];
@@ -180,7 +178,7 @@ async fn controller_task(con: &mut i2c::I2c<'static, I2C0, i2c::Async>) {
     }
 
     #[embassy_executor::main]
-    async fn main(_core0_spawner: Spawner) {
+    async fn main(spawner: Spawner) {
         let mut config = rpConfig::default();
         // Configure clk_sys to 48MHz to support 1kHz scl.
         // In theory it can go lower, but we won't bother to test below 1kHz.
@@ -210,14 +208,7 @@ async fn controller_task(con: &mut i2c::I2c<'static, I2C0, i2c::Async>) {
         config.addr = DEV_ADDR as u16;
         let device = i2c_slave::I2cSlave::new(p.I2C1, d_sda, d_scl, Irqs, config);
 
-        spawn_core1(
-            p.CORE1,
-            unsafe { &mut *core::ptr::addr_of_mut!(CORE1_STACK) },
-            move || {
-                let executor1 = EXECUTOR1.init(Executor::new());
-                executor1.run(|spawner| unwrap!(spawner.spawn(device_task(device))));
-            },
-        );
+        spawner.spawn(device_task(device).unwrap());
 
         let c_sda = p.PIN_21;
         let c_scl = p.PIN_20;
diff --git a/tests/rp/src/bin/multicore.rs b/tests/rp/src/bin/multicore.rs
index 783ea0f27..7e34bc778 100644
--- a/tests/rp/src/bin/multicore.rs
+++ b/tests/rp/src/bin/multicore.rs
@@ -1,10 +1,13 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::{info, unwrap};
 use embassy_executor::Executor;
-use embassy_rp::multicore::{spawn_core1, Stack};
+use embassy_rp::multicore::{Stack, spawn_core1};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::channel::Channel;
 use static_cell::StaticCell;
@@ -24,11 +27,11 @@ fn main() -> ! {
         unsafe { &mut *core::ptr::addr_of_mut!(CORE1_STACK) },
         move || {
             let executor1 = EXECUTOR1.init(Executor::new());
-            executor1.run(|spawner| unwrap!(spawner.spawn(core1_task())));
+            executor1.run(|spawner| spawner.spawn(unwrap!(core1_task())));
         },
     );
     let executor0 = EXECUTOR0.init(Executor::new());
-    executor0.run(|spawner| unwrap!(spawner.spawn(core0_task())));
+    executor0.run(|spawner| spawner.spawn(unwrap!(core0_task())));
 }
 
 #[embassy_executor::task]
diff --git a/tests/rp/src/bin/overclock.rs b/tests/rp/src/bin/overclock.rs
new file mode 100644
index 000000000..87a03b5e2
--- /dev/null
+++ b/tests/rp/src/bin/overclock.rs
@@ -0,0 +1,69 @@
+#![no_std]
+#![no_main]
+
+#[cfg(feature = "rp2040")]
+teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_rp::clocks::{ClockConfig, CoreVoltage, clk_sys_freq, core_voltage};
+use embassy_rp::config::Config;
+use embassy_time::Instant;
+use {defmt_rtt as _, panic_probe as _};
+
+const COUNT_TO: i64 = 10_000_000;
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut config = Config::default();
+
+    // Initialize with 200MHz clock configuration
+    config.clocks = ClockConfig::system_freq(200_000_000).unwrap();
+
+    // if we are rp235x, we need to manually set the core voltage. rp2040 should do this automatically
+    #[cfg(feature = "rp235xb")]
+    {
+        config.clocks.core_voltage = CoreVoltage::V1_15;
+    }
+
+    let _p = embassy_rp::init(config);
+
+    // We should be at core voltage of 1.15V
+    assert_eq!(core_voltage().unwrap(), CoreVoltage::V1_15, "Core voltage is not 1.15V");
+    // We should be at 200MHz
+    assert_eq!(clk_sys_freq(), 200_000_000, "System clock frequency is not 200MHz");
+
+    // Test the system speed
+    let time_elapsed = {
+        let mut counter = 0;
+        let start = Instant::now();
+        while counter < COUNT_TO {
+            counter += 1;
+        }
+        let elapsed = Instant::now() - start;
+
+        elapsed.as_millis()
+    };
+
+    // Tests will fail if unused variables are detected:
+    // Report the elapsed time, so that the compiler doesn't optimize it away for the chip not on test
+    info!(
+        "At {}Mhz: Elapsed time to count to {}: {}ms",
+        clk_sys_freq() / 1_000_000,
+        COUNT_TO,
+        time_elapsed
+    );
+
+    // Check if the elapsed time is within expected limits
+    // for rp2040 we expect about 600ms
+    #[cfg(feature = "rp2040")]
+    // allow 1% error
+    assert!(time_elapsed < 606, "Elapsed time is too long");
+    // for rp235x we expect about 450ms
+    #[cfg(feature = "rp235xb")]
+    assert!(time_elapsed < 455, "Elapsed time is too long");
+
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/rp/src/bin/pio_irq.rs b/tests/rp/src/bin/pio_irq.rs
index 33cdaaac9..dc37dd83d 100644
--- a/tests/rp/src/bin/pio_irq.rs
+++ b/tests/rp/src/bin/pio_irq.rs
@@ -1,11 +1,15 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::info;
 use embassy_executor::Spawner;
 use embassy_rp::bind_interrupts;
 use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::program::pio_asm;
 use embassy_rp::pio::{Config, InterruptHandler, Pio};
 use {defmt_rtt as _, panic_probe as _};
 
@@ -24,7 +28,7 @@ async fn main(_spawner: Spawner) {
         ..
     } = Pio::new(pio, Irqs);
 
-    let prg = pio_proc::pio_asm!(
+    let prg = pio_asm!(
         "irq set 0",
         "irq wait 0",
         "irq set 1",
diff --git a/tests/rp/src/bin/pio_multi_load.rs b/tests/rp/src/bin/pio_multi_load.rs
index cd28f99b6..82bbab272 100644
--- a/tests/rp/src/bin/pio_multi_load.rs
+++ b/tests/rp/src/bin/pio_multi_load.rs
@@ -1,11 +1,15 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::info;
 use embassy_executor::Spawner;
 use embassy_rp::bind_interrupts;
 use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::program::pio_asm;
 use embassy_rp::pio::{Config, InterruptHandler, LoadError, Pio};
 use {defmt_rtt as _, panic_probe as _};
 
@@ -27,7 +31,7 @@ async fn main(_spawner: Spawner) {
     } = Pio::new(pio, Irqs);
 
     // load with explicit origin works
-    let prg1 = pio_proc::pio_asm!(
+    let prg1 = pio_asm!(
         ".origin 4"
         "nop",
         "nop",
@@ -46,15 +50,16 @@ async fn main(_spawner: Spawner) {
     assert_eq!(loaded1.wrap.target, 4);
 
     // load without origin chooses a free space
-    let prg2 = pio_proc::pio_asm!("nop", "nop", "nop", "nop", "nop", "nop", "nop", "irq 1", "nop", "nop",);
+    let prg2 = pio_asm!("nop", "nop", "nop", "nop", "nop", "nop", "nop", "irq 1", "nop", "nop",);
     let loaded2 = common.load_program(&prg2.program);
     assert_eq!(loaded2.origin, 14);
     assert_eq!(loaded2.wrap.source, 23);
     assert_eq!(loaded2.wrap.target, 14);
 
     // wrapping around the end of program space automatically works
-    let prg3 =
-        pio_proc::pio_asm!("nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "irq 2",);
+    let prg3 = pio_asm!(
+        "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "irq 2",
+    );
     let loaded3 = common.load_program(&prg3.program);
     assert_eq!(loaded3.origin, 24);
     assert_eq!(loaded3.wrap.source, 3);
@@ -88,13 +93,13 @@ async fn main(_spawner: Spawner) {
 
     // instruction memory is full now. all loads should fail.
     {
-        let prg = pio_proc::pio_asm!(".origin 0", "nop");
+        let prg = pio_asm!(".origin 0", "nop");
         match common.try_load_program(&prg.program) {
             Err(LoadError::AddressInUse(0)) => (),
             _ => panic!("program loaded when it shouldn't"),
         };
 
-        let prg = pio_proc::pio_asm!("nop");
+        let prg = pio_asm!("nop");
         match common.try_load_program(&prg.program) {
             Err(LoadError::InsufficientSpace) => (),
             _ => panic!("program loaded when it shouldn't"),
@@ -106,13 +111,13 @@ async fn main(_spawner: Spawner) {
         common.free_instr(loaded3.used_memory);
     }
     {
-        let prg = pio_proc::pio_asm!(".origin 0", "nop");
+        let prg = pio_asm!(".origin 0", "nop");
         match common.try_load_program(&prg.program) {
             Ok(_) => (),
             _ => panic!("program didn't loaded when it shouldn"),
         };
 
-        let prg = pio_proc::pio_asm!("nop");
+        let prg = pio_asm!("nop");
         match common.try_load_program(&prg.program) {
             Ok(_) => (),
             _ => panic!("program didn't loaded when it shouldn"),
diff --git a/tests/rp/src/bin/pwm.rs b/tests/rp/src/bin/pwm.rs
index c05197000..5f890cd50 100644
--- a/tests/rp/src/bin/pwm.rs
+++ b/tests/rp/src/bin/pwm.rs
@@ -1,10 +1,15 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::{assert, assert_eq, assert_ne, *};
 use embassy_executor::Spawner;
-use embassy_rp::gpio::{Input, Level, Output, Pull};
+use embassy_rp::gpio::{Input, Pull};
+#[cfg(feature = "rp2040")]
+use embassy_rp::gpio::{Level, Output};
 use embassy_rp::pwm::{Config, InputMode, Pwm};
 use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
@@ -28,7 +33,7 @@ async fn main(_spawner: Spawner) {
 
     // Test free-running clock
     {
-        let pwm = Pwm::new_free(&mut p.PWM_SLICE3, cfg.clone());
+        let pwm = Pwm::new_free(p.PWM_SLICE3.reborrow(), cfg.clone());
         cortex_m::asm::delay(125);
         let ctr = pwm.counter();
         assert!(ctr > 0);
@@ -45,8 +50,8 @@ async fn main(_spawner: Spawner) {
 
         // Test output from A
         {
-            let pin1 = Input::new(&mut p9, Pull::None);
-            let _pwm = Pwm::new_output_a(&mut p.PWM_SLICE3, &mut p6, cfg.clone());
+            let pin1 = Input::new(p9.reborrow(), Pull::None);
+            let _pwm = Pwm::new_output_a(p.PWM_SLICE3.reborrow(), p6.reborrow(), cfg.clone());
             Timer::after_millis(1).await;
             assert_eq!(pin1.is_low(), invert_a);
             Timer::after_millis(5).await;
@@ -59,8 +64,8 @@ async fn main(_spawner: Spawner) {
 
         // Test output from B
         {
-            let pin2 = Input::new(&mut p11, Pull::None);
-            let _pwm = Pwm::new_output_b(&mut p.PWM_SLICE3, &mut p7, cfg.clone());
+            let pin2 = Input::new(p11.reborrow(), Pull::None);
+            let _pwm = Pwm::new_output_b(p.PWM_SLICE3.reborrow(), p7.reborrow(), cfg.clone());
             Timer::after_millis(1).await;
             assert_ne!(pin2.is_low(), invert_a);
             Timer::after_millis(5).await;
@@ -73,9 +78,9 @@ async fn main(_spawner: Spawner) {
 
         // Test output from A+B
         {
-            let pin1 = Input::new(&mut p9, Pull::None);
-            let pin2 = Input::new(&mut p11, Pull::None);
-            let _pwm = Pwm::new_output_ab(&mut p.PWM_SLICE3, &mut p6, &mut p7, cfg.clone());
+            let pin1 = Input::new(p9.reborrow(), Pull::None);
+            let pin2 = Input::new(p11.reborrow(), Pull::None);
+            let _pwm = Pwm::new_output_ab(p.PWM_SLICE3.reborrow(), p6.reborrow(), p7.reborrow(), cfg.clone());
             Timer::after_millis(1).await;
             assert_eq!(pin1.is_low(), invert_a);
             assert_ne!(pin2.is_low(), invert_a);
@@ -92,9 +97,16 @@ async fn main(_spawner: Spawner) {
     }
 
     // Test level-gated
+    #[cfg(feature = "rp2040")]
     {
-        let mut pin2 = Output::new(&mut p11, Level::Low);
-        let pwm = Pwm::new_input(&mut p.PWM_SLICE3, &mut p7, Pull::None, InputMode::Level, cfg.clone());
+        let mut pin2 = Output::new(p11.reborrow(), Level::Low);
+        let pwm = Pwm::new_input(
+            p.PWM_SLICE3.reborrow(),
+            p7.reborrow(),
+            Pull::None,
+            InputMode::Level,
+            cfg.clone(),
+        );
         assert_eq!(pwm.counter(), 0);
         Timer::after_millis(5).await;
         assert_eq!(pwm.counter(), 0);
@@ -102,17 +114,19 @@ async fn main(_spawner: Spawner) {
         Timer::after_millis(1).await;
         pin2.set_low();
         let ctr = pwm.counter();
+        info!("ctr: {}", ctr);
         assert!(ctr >= 1000);
         Timer::after_millis(1).await;
         assert_eq!(pwm.counter(), ctr);
     }
 
     // Test rising-gated
+    #[cfg(feature = "rp2040")]
     {
-        let mut pin2 = Output::new(&mut p11, Level::Low);
+        let mut pin2 = Output::new(p11.reborrow(), Level::Low);
         let pwm = Pwm::new_input(
-            &mut p.PWM_SLICE3,
-            &mut p7,
+            p.PWM_SLICE3.reborrow(),
+            p7.reborrow(),
             Pull::None,
             InputMode::RisingEdge,
             cfg.clone(),
@@ -129,11 +143,12 @@ async fn main(_spawner: Spawner) {
     }
 
     // Test falling-gated
+    #[cfg(feature = "rp2040")]
     {
-        let mut pin2 = Output::new(&mut p11, Level::High);
+        let mut pin2 = Output::new(p11.reborrow(), Level::High);
         let pwm = Pwm::new_input(
-            &mut p.PWM_SLICE3,
-            &mut p7,
+            p.PWM_SLICE3.reborrow(),
+            p7.reborrow(),
             Pull::None,
             InputMode::FallingEdge,
             cfg.clone(),
@@ -151,10 +166,10 @@ async fn main(_spawner: Spawner) {
 
     // pull-down
     {
-        let pin2 = Input::new(&mut p11, Pull::None);
+        let pin2 = Input::new(p11.reborrow(), Pull::None);
         Pwm::new_input(
-            &mut p.PWM_SLICE3,
-            &mut p7,
+            p.PWM_SLICE3.reborrow(),
+            p7.reborrow(),
             Pull::Down,
             InputMode::FallingEdge,
             cfg.clone(),
@@ -165,10 +180,10 @@ async fn main(_spawner: Spawner) {
 
     // pull-up
     {
-        let pin2 = Input::new(&mut p11, Pull::None);
+        let pin2 = Input::new(p11.reborrow(), Pull::None);
         Pwm::new_input(
-            &mut p.PWM_SLICE3,
-            &mut p7,
+            p.PWM_SLICE3.reborrow(),
+            p7.reborrow(),
             Pull::Up,
             InputMode::FallingEdge,
             cfg.clone(),
diff --git a/tests/rp/src/bin/rtc.rs b/tests/rp/src/bin/rtc.rs
new file mode 100644
index 000000000..e1def7b5b
--- /dev/null
+++ b/tests/rp/src/bin/rtc.rs
@@ -0,0 +1,125 @@
+#![no_std]
+#![no_main]
+#[cfg(feature = "rp2040")]
+teleprobe_meta::target!(b"rpi-pico");
+
+use defmt::{assert, *};
+use embassy_executor::Spawner;
+use embassy_futures::select::{Either, select};
+use embassy_rp::bind_interrupts;
+use embassy_rp::rtc::{DateTime, DateTimeFilter, DayOfWeek, Rtc};
+use embassy_time::{Duration, Instant, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+// Bind the RTC interrupt to the handler
+bind_interrupts!(struct Irqs {
+    RTC_IRQ => embassy_rp::rtc::InterruptHandler;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let mut rtc = Rtc::new(p.RTC, Irqs);
+
+    info!("RTC test started");
+
+    // Initialize RTC if not running
+    if !rtc.is_running() {
+        info!("Starting RTC");
+        let now = DateTime {
+            year: 2000,
+            month: 1,
+            day: 1,
+            day_of_week: DayOfWeek::Saturday,
+            hour: 0,
+            minute: 0,
+            second: 0,
+        };
+        rtc.set_datetime(now).unwrap();
+        Timer::after_millis(100).await;
+    }
+
+    // Test 1: Basic RTC functionality - read current time
+    let initial_time = rtc.now().unwrap();
+    info!(
+        "Initial time: {}-{:02}-{:02} {}:{:02}:{:02}",
+        initial_time.year,
+        initial_time.month,
+        initial_time.day,
+        initial_time.hour,
+        initial_time.minute,
+        initial_time.second
+    );
+
+    // Test 2: Schedule and wait for alarm
+    info!("Testing alarm scheduling");
+
+    // Wait until we're at a predictable second, then schedule for a future second
+    loop {
+        let current = rtc.now().unwrap();
+        if current.second <= 55 {
+            break;
+        }
+        Timer::after_millis(100).await;
+    }
+
+    // Now schedule alarm for 3 seconds from current time
+    let current_time = rtc.now().unwrap();
+    let alarm_second = (current_time.second + 3) % 60;
+    let alarm_filter = DateTimeFilter::default().second(alarm_second);
+
+    info!("Scheduling alarm for second: {}", alarm_second);
+    rtc.schedule_alarm(alarm_filter);
+
+    // Verify alarm is scheduled
+    let scheduled = rtc.alarm_scheduled();
+    assert!(scheduled.is_some(), "Alarm should be scheduled");
+    info!("Alarm scheduled successfully: {}", scheduled.unwrap());
+
+    // Wait for alarm with timeout
+    let alarm_start = Instant::now();
+    match select(Timer::after_secs(5), rtc.wait_for_alarm()).await {
+        Either::First(_) => {
+            core::panic!("Alarm timeout - alarm should have triggered by now");
+        }
+        Either::Second(_) => {
+            let alarm_duration = Instant::now() - alarm_start;
+            info!("ALARM TRIGGERED after {:?}", alarm_duration);
+
+            // Verify timing is reasonable (should be around 3 seconds)
+            assert!(
+                alarm_duration >= Duration::from_secs(2) && alarm_duration <= Duration::from_secs(4),
+                "Alarm timing incorrect: {:?}",
+                alarm_duration
+            );
+        }
+    }
+
+    // Test 3: Verify RTC is still running and time has advanced
+    let final_time = rtc.now().unwrap();
+    info!(
+        "Final time: {}-{:02}-{:02} {}:{:02}:{:02}",
+        final_time.year, final_time.month, final_time.day, final_time.hour, final_time.minute, final_time.second
+    );
+
+    // Verify time has advanced (allowing for minute/hour rollover)
+    let time_diff = if final_time.second >= initial_time.second {
+        final_time.second - initial_time.second
+    } else {
+        60 - initial_time.second + final_time.second
+    };
+
+    assert!(time_diff >= 3, "RTC should have advanced by at least 3 seconds");
+    info!("Time advanced by {} seconds", time_diff);
+
+    // Test 4: Verify alarm is no longer scheduled after triggering
+    let post_alarm_scheduled = rtc.alarm_scheduled();
+    assert!(
+        post_alarm_scheduled.is_none(),
+        "Alarm should not be scheduled after triggering"
+    );
+    info!("Alarm correctly cleared after triggering");
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/rp/src/bin/spi.rs b/tests/rp/src/bin/spi.rs
index 4b02942a7..6802bfc99 100644
--- a/tests/rp/src/bin/spi.rs
+++ b/tests/rp/src/bin/spi.rs
@@ -1,6 +1,9 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::{assert_eq, *};
 use embassy_executor::Spawner;
diff --git a/tests/rp/src/bin/spi_async.rs b/tests/rp/src/bin/spi_async.rs
index efdc80b53..e50667435 100644
--- a/tests/rp/src/bin/spi_async.rs
+++ b/tests/rp/src/bin/spi_async.rs
@@ -3,7 +3,10 @@
 //!
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::{assert_eq, *};
 use embassy_executor::Spawner;
diff --git a/tests/rp/src/bin/spinlock_mutex_multicore.rs b/tests/rp/src/bin/spinlock_mutex_multicore.rs
new file mode 100644
index 000000000..25c4faf37
--- /dev/null
+++ b/tests/rp/src/bin/spinlock_mutex_multicore.rs
@@ -0,0 +1,54 @@
+#![no_std]
+#![no_main]
+#[cfg(feature = "rp2040")]
+teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
+
+use defmt::{info, unwrap};
+use embassy_executor::Executor;
+use embassy_rp::multicore::{Stack, spawn_core1};
+use embassy_rp::spinlock_mutex::SpinlockRawMutex;
+use embassy_sync::channel::Channel;
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+static mut CORE1_STACK: Stack<1024> = Stack::new();
+static EXECUTOR0: StaticCell<Executor> = StaticCell::new();
+static EXECUTOR1: StaticCell<Executor> = StaticCell::new();
+static CHANNEL0: Channel<SpinlockRawMutex<0>, bool, 1> = Channel::new();
+static CHANNEL1: Channel<SpinlockRawMutex<1>, bool, 1> = Channel::new();
+
+#[cortex_m_rt::entry]
+fn main() -> ! {
+    let p = embassy_rp::init(Default::default());
+    spawn_core1(
+        p.CORE1,
+        unsafe { &mut *core::ptr::addr_of_mut!(CORE1_STACK) },
+        move || {
+            let executor1 = EXECUTOR1.init(Executor::new());
+            executor1.run(|spawner| spawner.spawn(unwrap!(core1_task())));
+        },
+    );
+    let executor0 = EXECUTOR0.init(Executor::new());
+    executor0.run(|spawner| spawner.spawn(unwrap!(core0_task())));
+}
+
+#[embassy_executor::task]
+async fn core0_task() {
+    info!("CORE0 is running");
+    let ping = true;
+    CHANNEL0.send(ping).await;
+    let pong = CHANNEL1.receive().await;
+    assert_eq!(ping, pong);
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
+
+#[embassy_executor::task]
+async fn core1_task() {
+    info!("CORE1 is running");
+    let ping = CHANNEL0.receive().await;
+    CHANNEL1.send(ping).await;
+}
diff --git a/tests/nrf52840/src/bin/timer.rs b/tests/rp/src/bin/timer.rs
index 117947a94..12a4d7daa 100644
--- a/tests/nrf52840/src/bin/timer.rs
+++ b/tests/rp/src/bin/timer.rs
@@ -1,15 +1,18 @@
 #![no_std]
 #![no_main]
-teleprobe_meta::target!(b"nrf52840-dk");
+#[cfg(feature = "rp2040")]
+teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
-use defmt::{assert, info};
+use defmt::{assert, *};
 use embassy_executor::Spawner;
 use embassy_time::{Instant, Timer};
 use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let _p = embassy_nrf::init(Default::default());
+    let _p = embassy_rp::init(Default::default());
     info!("Hello World!");
 
     let start = Instant::now();
@@ -18,6 +21,7 @@ async fn main(_spawner: Spawner) {
     let ms = (end - start).as_millis();
     info!("slept for {} ms", ms);
     assert!(ms >= 99);
+    assert!(ms < 110);
 
     info!("Test OK");
     cortex_m::asm::bkpt();
diff --git a/tests/rp/src/bin/uart.rs b/tests/rp/src/bin/uart.rs
index 6e6e5517b..80230f3fe 100644
--- a/tests/rp/src/bin/uart.rs
+++ b/tests/rp/src/bin/uart.rs
@@ -1,21 +1,24 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::{assert_eq, *};
 use embassy_executor::Spawner;
 use embassy_rp::gpio::{Level, Output};
-use embassy_rp::uart::{Blocking, Config, Error, Instance, Parity, Uart, UartRx};
+use embassy_rp::uart::{Blocking, Config, Error, Parity, Uart, UartRx};
 use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
-fn read<const N: usize>(uart: &mut Uart<'_, impl Instance, Blocking>) -> Result<[u8; N], Error> {
+fn read<const N: usize>(uart: &mut Uart<'_, Blocking>) -> Result<[u8; N], Error> {
     let mut buf = [255; N];
     uart.blocking_read(&mut buf)?;
     Ok(buf)
 }
 
-fn read1<const N: usize>(uart: &mut UartRx<'_, impl Instance, Blocking>) -> Result<[u8; N], Error> {
+fn read1<const N: usize>(uart: &mut UartRx<'_, Blocking>) -> Result<[u8; N], Error> {
     let mut buf = [255; N];
     uart.blocking_read(&mut buf)?;
     Ok(buf)
@@ -53,7 +56,7 @@ async fn main(_spawner: Spawner) {
 
     {
         let config = Config::default();
-        let mut uart = Uart::new_blocking(&mut uart, &mut tx, &mut rx, config);
+        let mut uart = Uart::new_blocking(uart.reborrow(), tx.reborrow(), rx.reborrow(), config);
 
         // We can't send too many bytes, they have to fit in the FIFO.
         // This is because we aren't sending+receiving at the same time.
@@ -66,7 +69,7 @@ async fn main(_spawner: Spawner) {
     info!("test overflow detection");
     {
         let config = Config::default();
-        let mut uart = Uart::new_blocking(&mut uart, &mut tx, &mut rx, config);
+        let mut uart = Uart::new_blocking(uart.reborrow(), tx.reborrow(), rx.reborrow(), config);
 
         let data = [
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
@@ -90,7 +93,7 @@ async fn main(_spawner: Spawner) {
     info!("test break detection");
     {
         let config = Config::default();
-        let mut uart = Uart::new_blocking(&mut uart, &mut tx, &mut rx, config);
+        let mut uart = Uart::new_blocking(uart.reborrow(), tx.reborrow(), rx.reborrow(), config);
 
         // break on empty fifo
         uart.send_break(20).await;
@@ -110,11 +113,11 @@ async fn main(_spawner: Spawner) {
     // parity detection. here we bitbang to not require two uarts.
     info!("test parity error detection");
     {
-        let mut pin = Output::new(&mut tx, Level::High);
+        let mut pin = Output::new(tx.reborrow(), Level::High);
         let mut config = Config::default();
         config.baudrate = 1000;
         config.parity = Parity::ParityEven;
-        let mut uart = UartRx::new_blocking(&mut uart, &mut rx, config);
+        let mut uart = UartRx::new_blocking(uart.reborrow(), rx.reborrow(), config);
 
         async fn chr(pin: &mut Output<'_>, v: u8, parity: u8) {
             send(pin, v, Some(parity != 0)).await;
@@ -137,10 +140,10 @@ async fn main(_spawner: Spawner) {
     // framing error detection. here we bitbang because there's no other way.
     info!("test framing error detection");
     {
-        let mut pin = Output::new(&mut tx, Level::High);
+        let mut pin = Output::new(tx.reborrow(), Level::High);
         let mut config = Config::default();
         config.baudrate = 1000;
-        let mut uart = UartRx::new_blocking(&mut uart, &mut rx, config);
+        let mut uart = UartRx::new_blocking(uart.reborrow(), rx.reborrow(), config);
 
         async fn chr(pin: &mut Output<'_>, v: u8, good: bool) {
             if good {
diff --git a/tests/rp/src/bin/uart_buffered.rs b/tests/rp/src/bin/uart_buffered.rs
index d68c23cbd..cb78fc142 100644
--- a/tests/rp/src/bin/uart_buffered.rs
+++ b/tests/rp/src/bin/uart_buffered.rs
@@ -1,13 +1,16 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::{assert_eq, panic, *};
 use embassy_executor::Spawner;
 use embassy_rp::bind_interrupts;
 use embassy_rp::gpio::{Level, Output};
 use embassy_rp::peripherals::UART0;
-use embassy_rp::uart::{BufferedInterruptHandler, BufferedUart, BufferedUartRx, Config, Error, Instance, Parity};
+use embassy_rp::uart::{BufferedInterruptHandler, BufferedUart, BufferedUartRx, Config, Error, Parity};
 use embassy_time::Timer;
 use embedded_io_async::{Read, ReadExactError, Write};
 use {defmt_rtt as _, panic_probe as _};
@@ -16,7 +19,7 @@ bind_interrupts!(struct Irqs {
     UART0_IRQ => BufferedInterruptHandler<UART0>;
 });
 
-async fn read<const N: usize>(uart: &mut BufferedUart<'_, impl Instance>) -> Result<[u8; N], Error> {
+async fn read<const N: usize>(uart: &mut BufferedUart) -> Result<[u8; N], Error> {
     let mut buf = [255; N];
     match uart.read_exact(&mut buf).await {
         Ok(()) => Ok(buf),
@@ -26,7 +29,7 @@ async fn read<const N: usize>(uart: &mut BufferedUart<'_, impl Instance>) -> Res
     }
 }
 
-async fn read1<const N: usize>(uart: &mut BufferedUartRx<'_, impl Instance>) -> Result<[u8; N], Error> {
+async fn read1<const N: usize>(uart: &mut BufferedUartRx) -> Result<[u8; N], Error> {
     let mut buf = [255; N];
     match uart.read_exact(&mut buf).await {
         Ok(()) => Ok(buf),
@@ -70,7 +73,15 @@ async fn main(_spawner: Spawner) {
         let config = Config::default();
         let tx_buf = &mut [0u8; 16];
         let rx_buf = &mut [0u8; 16];
-        let mut uart = BufferedUart::new(&mut uart, Irqs, &mut tx, &mut rx, tx_buf, rx_buf, config);
+        let mut uart = BufferedUart::new(
+            uart.reborrow(),
+            tx.reborrow(),
+            rx.reborrow(),
+            Irqs,
+            tx_buf,
+            rx_buf,
+            config,
+        );
 
         // Make sure we send more bytes than fits in the FIFO, to test the actual
         // bufferedUart.
@@ -90,7 +101,15 @@ async fn main(_spawner: Spawner) {
         let config = Config::default();
         let tx_buf = &mut [0u8; 16];
         let rx_buf = &mut [0u8; 16];
-        let mut uart = BufferedUart::new(&mut uart, Irqs, &mut tx, &mut rx, tx_buf, rx_buf, config);
+        let mut uart = BufferedUart::new(
+            uart.reborrow(),
+            tx.reborrow(),
+            rx.reborrow(),
+            Irqs,
+            tx_buf,
+            rx_buf,
+            config,
+        );
 
         // Make sure we send more bytes than fits in the FIFO, to test the actual
         // bufferedUart.
@@ -125,7 +144,15 @@ async fn main(_spawner: Spawner) {
         config.baudrate = 1000;
         let tx_buf = &mut [0u8; 16];
         let rx_buf = &mut [0u8; 16];
-        let mut uart = BufferedUart::new(&mut uart, Irqs, &mut tx, &mut rx, tx_buf, rx_buf, config);
+        let mut uart = BufferedUart::new(
+            uart.reborrow(),
+            tx.reborrow(),
+            rx.reborrow(),
+            Irqs,
+            tx_buf,
+            rx_buf,
+            config,
+        );
 
         // break on empty buffer
         uart.send_break(20).await;
@@ -153,13 +180,13 @@ async fn main(_spawner: Spawner) {
     // parity detection. here we bitbang to not require two uarts.
     info!("test parity error detection");
     {
-        let mut pin = Output::new(&mut tx, Level::High);
+        let mut pin = Output::new(tx.reborrow(), Level::High);
         // choose a very slow baud rate to make tests reliable even with O0
         let mut config = Config::default();
         config.baudrate = 1000;
         config.parity = Parity::ParityEven;
         let rx_buf = &mut [0u8; 16];
-        let mut uart = BufferedUartRx::new(&mut uart, Irqs, &mut rx, rx_buf, config);
+        let mut uart = BufferedUartRx::new(uart.reborrow(), Irqs, rx.reborrow(), rx_buf, config);
 
         async fn chr(pin: &mut Output<'_>, v: u8, parity: u32) {
             send(pin, v, Some(parity != 0)).await;
@@ -201,12 +228,12 @@ async fn main(_spawner: Spawner) {
     // framing error detection. here we bitbang because there's no other way.
     info!("test framing error detection");
     {
-        let mut pin = Output::new(&mut tx, Level::High);
+        let mut pin = Output::new(tx.reborrow(), Level::High);
         // choose a very slow baud rate to make tests reliable even with O0
         let mut config = Config::default();
         config.baudrate = 1000;
         let rx_buf = &mut [0u8; 16];
-        let mut uart = BufferedUartRx::new(&mut uart, Irqs, &mut rx, rx_buf, config);
+        let mut uart = BufferedUartRx::new(uart.reborrow(), Irqs, rx.reborrow(), rx_buf, config);
 
         async fn chr(pin: &mut Output<'_>, v: u8, good: bool) {
             if good {
diff --git a/tests/rp/src/bin/uart_dma.rs b/tests/rp/src/bin/uart_dma.rs
index edc87175a..a7af81f5f 100644
--- a/tests/rp/src/bin/uart_dma.rs
+++ b/tests/rp/src/bin/uart_dma.rs
@@ -1,13 +1,16 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::{assert_eq, *};
 use embassy_executor::Spawner;
 use embassy_rp::bind_interrupts;
 use embassy_rp::gpio::{Level, Output};
 use embassy_rp::peripherals::UART0;
-use embassy_rp::uart::{Async, Config, Error, Instance, InterruptHandler, Parity, Uart, UartRx};
+use embassy_rp::uart::{Async, Config, Error, InterruptHandler, Parity, Uart, UartRx};
 use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
@@ -15,13 +18,13 @@ bind_interrupts!(struct Irqs {
     UART0_IRQ => InterruptHandler<UART0>;
 });
 
-async fn read<const N: usize>(uart: &mut Uart<'_, impl Instance, Async>) -> Result<[u8; N], Error> {
+async fn read<const N: usize>(uart: &mut Uart<'_, Async>) -> Result<[u8; N], Error> {
     let mut buf = [255; N];
     uart.read(&mut buf).await?;
     Ok(buf)
 }
 
-async fn read1<const N: usize>(uart: &mut UartRx<'_, impl Instance, Async>) -> Result<[u8; N], Error> {
+async fn read1<const N: usize>(uart: &mut UartRx<'_, Async>) -> Result<[u8; N], Error> {
     let mut buf = [255; N];
     uart.read(&mut buf).await?;
     Ok(buf)
@@ -62,12 +65,12 @@ async fn main(_spawner: Spawner) {
     {
         let config = Config::default();
         let mut uart = Uart::new(
-            &mut uart,
-            &mut tx,
-            &mut rx,
+            uart.reborrow(),
+            tx.reborrow(),
+            rx.reborrow(),
             Irqs,
-            &mut p.DMA_CH0,
-            &mut p.DMA_CH1,
+            p.DMA_CH0.reborrow(),
+            p.DMA_CH1.reborrow(),
             config,
         );
 
@@ -83,12 +86,12 @@ async fn main(_spawner: Spawner) {
     {
         let config = Config::default();
         let mut uart = Uart::new(
-            &mut uart,
-            &mut tx,
-            &mut rx,
+            uart.reborrow(),
+            tx.reborrow(),
+            rx.reborrow(),
             Irqs,
-            &mut p.DMA_CH0,
-            &mut p.DMA_CH1,
+            p.DMA_CH0.reborrow(),
+            p.DMA_CH1.reborrow(),
             config,
         );
 
@@ -112,12 +115,12 @@ async fn main(_spawner: Spawner) {
     {
         let config = Config::default();
         let (mut tx, mut rx) = Uart::new(
-            &mut uart,
-            &mut tx,
-            &mut rx,
+            uart.reborrow(),
+            tx.reborrow(),
+            rx.reborrow(),
             Irqs,
-            &mut p.DMA_CH0,
-            &mut p.DMA_CH1,
+            p.DMA_CH0.reborrow(),
+            p.DMA_CH1.reborrow(),
             config,
         )
         .split();
@@ -153,12 +156,12 @@ async fn main(_spawner: Spawner) {
     // parity detection. here we bitbang to not require two uarts.
     info!("test parity error detection");
     {
-        let mut pin = Output::new(&mut tx, Level::High);
+        let mut pin = Output::new(tx.reborrow(), Level::High);
         // choose a very slow baud rate to make tests reliable even with O0
         let mut config = Config::default();
         config.baudrate = 1000;
         config.parity = Parity::ParityEven;
-        let mut uart = UartRx::new(&mut uart, &mut rx, Irqs, &mut p.DMA_CH0, config);
+        let mut uart = UartRx::new(uart.reborrow(), rx.reborrow(), Irqs, p.DMA_CH0.reborrow(), config);
 
         async fn chr(pin: &mut Output<'_>, v: u8, parity: u32) {
             send(pin, v, Some(parity != 0)).await;
@@ -199,11 +202,11 @@ async fn main(_spawner: Spawner) {
     // framing error detection. here we bitbang because there's no other way.
     info!("test framing error detection");
     {
-        let mut pin = Output::new(&mut tx, Level::High);
+        let mut pin = Output::new(tx.reborrow(), Level::High);
         // choose a very slow baud rate to make tests reliable even with O0
         let mut config = Config::default();
         config.baudrate = 1000;
-        let mut uart = UartRx::new(&mut uart, &mut rx, Irqs, &mut p.DMA_CH0, config);
+        let mut uart = UartRx::new(uart.reborrow(), rx.reborrow(), Irqs, p.DMA_CH0.reborrow(), config);
 
         async fn chr(pin: &mut Output<'_>, v: u8, good: bool) {
             if good {
diff --git a/tests/rp/src/bin/uart_upgrade.rs b/tests/rp/src/bin/uart_upgrade.rs
index 603e20f2f..f658b6b8c 100644
--- a/tests/rp/src/bin/uart_upgrade.rs
+++ b/tests/rp/src/bin/uart_upgrade.rs
@@ -1,6 +1,9 @@
 #![no_std]
 #![no_main]
+#[cfg(feature = "rp2040")]
 teleprobe_meta::target!(b"rpi-pico");
+#[cfg(feature = "rp235xb")]
+teleprobe_meta::target!(b"pimoroni-pico-plus-2");
 
 use defmt::{assert_eq, *};
 use embassy_executor::Spawner;
diff --git a/tests/stm32/.cargo/config.toml b/tests/stm32/.cargo/config.toml
index 8752da59b..d94342598 100644
--- a/tests/stm32/.cargo/config.toml
+++ b/tests/stm32/.cargo/config.toml
@@ -9,7 +9,6 @@ runner = "teleprobe client run"
 rustflags = [
   # Code-size optimizations.
   #"-Z", "trap-unreachable=no",
-  "-C", "inline-threshold=5",
   "-C", "no-vectorize-loops",
 ]
 
diff --git a/tests/stm32/Cargo.toml b/tests/stm32/Cargo.toml
index f94814e70..8fcb6b2b4 100644
--- a/tests/stm32/Cargo.toml
+++ b/tests/stm32/Cargo.toml
@@ -1,45 +1,50 @@
 [package]
-edition = "2021"
+edition = "2024"
 name = "embassy-stm32-tests"
 version = "0.1.0"
 license = "MIT OR Apache-2.0"
 autobins = false
+publish = false
 
 [features]
 stm32c031c6 = ["embassy-stm32/stm32c031c6", "cm0", "not-gpdma"]
-stm32f103c8 = ["embassy-stm32/stm32f103c8", "spi-v1", "not-gpdma"]
+stm32c071rb = ["embassy-stm32/stm32c071rb", "cm0", "not-gpdma"]
+stm32f100rd = ["embassy-stm32/stm32f100rd", "spi-v1", "not-gpdma", "afio", "afio-value-line"]
+stm32f103c8 = ["embassy-stm32/stm32f103c8", "spi-v1", "not-gpdma", "afio"]
+stm32f107vc = ["embassy-stm32/stm32f107vc", "spi-v1", "not-gpdma", "afio", "afio-connectivity-line"]
 stm32f207zg = ["embassy-stm32/stm32f207zg", "spi-v1", "chrono", "not-gpdma", "eth", "rng"]
 stm32f303ze = ["embassy-stm32/stm32f303ze", "chrono", "not-gpdma"]
 stm32f429zi = ["embassy-stm32/stm32f429zi", "spi-v1", "chrono", "eth", "stop", "can", "not-gpdma", "dac", "rng"]
 stm32f446re = ["embassy-stm32/stm32f446re", "spi-v1", "chrono", "stop", "can", "not-gpdma", "dac", "sdmmc"]
-stm32f767zi = ["embassy-stm32/stm32f767zi", "chrono", "not-gpdma", "eth", "rng"]
+stm32f767zi = ["embassy-stm32/stm32f767zi", "chrono", "not-gpdma", "eth", "rng", "single-bank"]
 stm32g071rb = ["embassy-stm32/stm32g071rb", "cm0", "not-gpdma", "dac", "ucpd"]
 stm32g491re = ["embassy-stm32/stm32g491re", "chrono", "stop", "not-gpdma", "rng", "fdcan", "cordic"]
-stm32h563zi = ["embassy-stm32/stm32h563zi", "spi-v345", "chrono", "eth", "rng", "fdcan", "hash", "cordic", "stop"]
+stm32h563zi = ["embassy-stm32/stm32h563zi", "spi-v345", "chrono", "eth", "rng", "fdcan", "hash-v34", "cordic", "stop"]
 stm32h753zi = ["embassy-stm32/stm32h753zi", "spi-v345", "chrono", "not-gpdma", "eth", "rng", "fdcan", "hash", "cryp"]
 stm32h755zi = ["embassy-stm32/stm32h755zi-cm7", "spi-v345", "chrono", "not-gpdma", "eth", "dac", "rng", "fdcan", "hash", "cryp"]
 stm32h7a3zi = ["embassy-stm32/stm32h7a3zi", "spi-v345", "not-gpdma", "rng", "fdcan"]
-stm32l073rz = ["embassy-stm32/stm32l073rz", "cm0", "not-gpdma", "rng"]
-stm32l152re = ["embassy-stm32/stm32l152re", "spi-v1", "chrono", "not-gpdma"]
+stm32l073rz = ["embassy-stm32/stm32l073rz", "cm0", "not-gpdma", "rng", "eeprom"]
+stm32l152re = ["embassy-stm32/stm32l152re", "spi-v1", "chrono", "not-gpdma", "eeprom"]
 stm32l496zg = ["embassy-stm32/stm32l496zg", "not-gpdma", "rng"]
 stm32l4a6zg = ["embassy-stm32/stm32l4a6zg", "chrono", "not-gpdma", "rng", "hash"]
-stm32l4r5zi = ["embassy-stm32/stm32l4r5zi", "chrono", "not-gpdma", "rng"]
-stm32l552ze = ["embassy-stm32/stm32l552ze", "not-gpdma", "rng", "hash"]
+stm32l4r5zi = ["embassy-stm32/stm32l4r5zi", "chrono", "not-gpdma", "rng", "dual-bank"]
+stm32l552ze = ["embassy-stm32/stm32l552ze", "not-gpdma", "rng", "hash", "dual-bank"]
 stm32u585ai = ["embassy-stm32/stm32u585ai", "spi-v345", "chrono", "rng", "hash", "cordic"]
 stm32u5a5zj = ["embassy-stm32/stm32u5a5zj", "spi-v345", "chrono", "rng", "hash"] # FIXME: cordic test cause it crash
-stm32wb55rg = ["embassy-stm32/stm32wb55rg", "chrono", "not-gpdma", "ble", "mac" , "rng"]
+stm32wb55rg = ["embassy-stm32/stm32wb55rg", "chrono", "not-gpdma", "ble", "mac" , "rng", "hsem", "stop"]
 stm32wba52cg = ["embassy-stm32/stm32wba52cg", "spi-v345", "chrono", "rng", "hash"]
-stm32wl55jc = ["embassy-stm32/stm32wl55jc-cm4", "not-gpdma", "rng", "chrono"]
+stm32wl55jc = ["embassy-stm32/stm32wl55jc-cm4", "not-gpdma", "rng", "chrono", "hsem"]
 stm32f091rc = ["embassy-stm32/stm32f091rc", "cm0", "not-gpdma", "chrono"]
 stm32h503rb = ["embassy-stm32/stm32h503rb", "spi-v345", "rng", "stop"]
-stm32h7s3l8 = ["embassy-stm32/stm32h7s3l8", "spi-v345", "rng", "cordic", "hash"] # TODO: fdcan crashes, cryp dma hangs.
+stm32h7s3l8 = ["embassy-stm32/stm32h7s3l8", "spi-v345", "rng", "cordic", "hash-v34"] # TODO: fdcan crashes, cryp dma hangs.
 stm32u083rc = ["embassy-stm32/stm32u083rc", "cm0", "rng", "chrono"]
 
 spi-v1 = []
 spi-v345 = []
 cryp = []
 hash = []
-eth = ["embassy-executor/task-arena-size-16384"]
+hash-v34 = ["hash"]
+eth = []
 rng = []
 sdmmc = []
 stop = ["embassy-stm32/low-power", "embassy-stm32/low-power-debug-with-sleep"]
@@ -53,23 +58,30 @@ not-gpdma = []
 dac = []
 ucpd = []
 cordic = ["dep:num-traits"]
+hsem = []
+dual-bank = ["embassy-stm32/dual-bank"]
+single-bank = ["embassy-stm32/single-bank"]
+eeprom = []
+afio = []
+afio-connectivity-line = []
+afio-value-line = []
 
 cm0 = ["portable-atomic/unsafe-assume-single-core"]
 
 [dependencies]
 teleprobe-meta = "1"
 
-embassy-sync = { version = "0.6.0", path = "../../embassy-sync", features = ["defmt"] }
-embassy-executor = { version = "0.5.0", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
-embassy-time = { version = "0.3.1", path = "../../embassy-time", features = ["defmt", "tick-hz-131_072", "defmt-timestamp-uptime"] }
-embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = [ "defmt", "unstable-pac", "memory-x", "time-driver-any"]  }
-embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
+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-time = { version = "0.5.0", path = "../../embassy-time", features = ["defmt", "tick-hz-131_072", "defmt-timestamp-uptime"] }
+embassy-stm32 = { version = "0.4.0", path = "../../embassy-stm32", features = [ "defmt", "unstable-pac", "memory-x", "time-driver-any", "_allow-disable-rtc"]  }
+embassy-futures = { version = "0.1.2", path = "../../embassy-futures" }
 embassy-stm32-wpan = { version = "0.1.0", path = "../../embassy-stm32-wpan", optional = true, features = ["defmt", "stm32wb55rg", "ble"] }
-embassy-net = { version = "0.4.0", path = "../../embassy-net", features = ["defmt",  "tcp", "udp", "dhcpv4", "medium-ethernet"] }
+embassy-net = { version = "0.7.1", path = "../../embassy-net", features = ["defmt",  "tcp", "udp", "dhcpv4", "medium-ethernet"] }
 perf-client = { path = "../perf-client" }
 
-defmt = "0.3.0"
-defmt-rtt = "0.4"
+defmt = "1.0.1"
+defmt-rtt = "1.0.0"
 
 cortex-m = { version = "0.7.6", features = ["critical-section-single-core"] }
 cortex-m-rt = "0.7.0"
@@ -78,21 +90,27 @@ embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = { version = "1.0" }
 embedded-can = { version = "0.4" }
 micromath = "2.0.0"
-panic-probe = { version = "0.3.0", features = ["print-defmt"] }
-rand_core = { version = "0.6", default-features = false }
-rand_chacha = { version = "0.3", default-features = false }
+panic-probe = { version = "1.0.0", features = ["print-defmt"] }
+rand_core = { version = "0.9.1", default-features = false }
+rand_chacha = { version = "0.9.0", default-features = false }
 static_cell = "2"
 portable-atomic = { version = "1.5", features = [] }
+critical-section = "1.1"
 
 chrono = { version = "^0.4", default-features = false, optional = true}
 sha2 = { version = "0.10.8", default-features = false }
 hmac = "0.12.1"
-aes-gcm = {version = "0.10.3", default-features = false, features = ["aes", "heapless"] }
-num-traits = {version="0.2", default-features = false,features = ["libm"], optional = true}
+aes-gcm = { version = "0.10.3", default-features = false, features = ["aes", "heapless"] }
+num-traits = { version="0.2", default-features = false,features = ["libm"], optional = true}
 
 # BEGIN TESTS
 # Generated by gen_test.py. DO NOT EDIT.
 [[bin]]
+name = "afio"
+path = "src/bin/afio.rs"
+required-features = [ "afio",]
+
+[[bin]]
 name = "can"
 path = "src/bin/can.rs"
 required-features = [ "can",]
@@ -118,6 +136,11 @@ path = "src/bin/dac_l1.rs"
 required-features = [ "stm32l152re",]
 
 [[bin]]
+name = "eeprom"
+path = "src/bin/eeprom.rs"
+required-features = [ "eeprom",]
+
+[[bin]]
 name = "eth"
 path = "src/bin/eth.rs"
 required-features = [ "eth",]
@@ -202,6 +225,11 @@ name = "wpan_mac"
 path = "src/bin/wpan_mac.rs"
 required-features = [ "mac",]
 
+[[bin]]
+name = "hsem"
+path = "src/bin/hsem.rs"
+required-features = [ "hsem",]
+
 # END TESTS
 
 [profile.dev]
@@ -233,3 +261,36 @@ debug = false
 debug-assertions = false
 opt-level = 0
 overflow-checks = false
+
+[package.metadata.embassy]
+build = [
+  { target = "thumbv7m-none-eabi", features = ["stm32f103c8"], artifact-dir = "out/tests/stm32f103c8" },
+  { target = "thumbv7em-none-eabi", features = ["stm32f429zi"], artifact-dir = "out/tests/stm32f429zi" },
+  { target = "thumbv7em-none-eabi", features = ["stm32f446re"], artifact-dir = "out/tests/stm32f446re" },
+  { target = "thumbv7em-none-eabi", features = ["stm32g491re"], artifact-dir = "out/tests/stm32g491re" },
+  { target = "thumbv6m-none-eabi", features = ["stm32g071rb"], artifact-dir = "out/tests/stm32g071rb" },
+  { target = "thumbv6m-none-eabi", features = ["stm32c031c6"], artifact-dir = "out/tests/stm32c031c6" },
+  { target = "thumbv6m-none-eabi", features = ["stm32c071rb"], artifact-dir = "out/tests/stm32c071rb" },
+  { target = "thumbv7em-none-eabi", features = ["stm32h755zi"], artifact-dir = "out/tests/stm32h755zi" },
+  { target = "thumbv7em-none-eabi", features = ["stm32h753zi"], artifact-dir = "out/tests/stm32h753zi" },
+  { target = "thumbv7em-none-eabi", features = ["stm32h7a3zi"], artifact-dir = "out/tests/stm32h7a3zi" },
+  { target = "thumbv7em-none-eabi", features = ["stm32wb55rg"], artifact-dir = "out/tests/stm32wb55rg" },
+  { target = "thumbv8m.main-none-eabihf", features = ["stm32h563zi"], artifact-dir = "out/tests/stm32h563zi" },
+  { target = "thumbv8m.main-none-eabihf", features = ["stm32u585ai"], artifact-dir = "out/tests/stm32u585ai" },
+  { target = "thumbv8m.main-none-eabihf", features = ["stm32u5a5zj"], artifact-dir = "out/tests/stm32u5a5zj" },
+  { target = "thumbv8m.main-none-eabihf", features = ["stm32wba52cg"], artifact-dir = "out/tests/stm32wba52cg" },
+  { target = "thumbv6m-none-eabi", features = ["stm32l073rz"], artifact-dir = "out/tests/stm32l073rz" },
+  { target = "thumbv7m-none-eabi", features = ["stm32l152re"], artifact-dir = "out/tests/stm32l152re" },
+  { target = "thumbv7em-none-eabi", features = ["stm32l4a6zg"], artifact-dir = "out/tests/stm32l4a6zg" },
+  { target = "thumbv7em-none-eabi", features = ["stm32l4r5zi"], artifact-dir = "out/tests/stm32l4r5zi" },
+  { target = "thumbv8m.main-none-eabihf", features = ["stm32l552ze"], artifact-dir = "out/tests/stm32l552ze" },
+  { target = "thumbv7em-none-eabi", features = ["stm32f767zi"], artifact-dir = "out/tests/stm32f767zi" },
+  { target = "thumbv7m-none-eabi", features = ["stm32f207zg"], artifact-dir = "out/tests/stm32f207zg" },
+  { target = "thumbv7em-none-eabi", features = ["stm32f303ze"], artifact-dir = "out/tests/stm32f303ze" },
+  { target = "thumbv7em-none-eabi", features = ["stm32l496zg"], artifact-dir = "out/tests/stm32l496zg" },
+  { target = "thumbv7em-none-eabi", features = ["stm32wl55jc"], artifact-dir = "out/tests/stm32wl55jc" },
+  { target = "thumbv7em-none-eabi", features = ["stm32h7s3l8"], artifact-dir = "out/tests/stm32h7s3l8" },
+  { target = "thumbv6m-none-eabi", features = ["stm32f091rc"], artifact-dir = "out/tests/stm32f091rc" },
+  { target = "thumbv8m.main-none-eabihf", features = ["stm32h503rb"], artifact-dir = "out/tests/stm32h503rb" },
+  { target = "thumbv6m-none-eabi", features = ["stm32u083rc"], artifact-dir = "out/tests/stm32u083rc" }
+]
diff --git a/tests/stm32/build.rs b/tests/stm32/build.rs
index 722671bf1..556d77a20 100644
--- a/tests/stm32/build.rs
+++ b/tests/stm32/build.rs
@@ -12,6 +12,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         // too little RAM to run from RAM.
         feature = "stm32f103c8", // 20 kb
         feature = "stm32c031c6", // 6 kb
+        feature = "stm32c071rb", // 24 kb
         feature = "stm32l073rz", // 20 kb
         feature = "stm32h503rb", // 32 kb
         // no VTOR, so interrupts can't work when running from RAM
diff --git a/tests/stm32/src/bin/afio.rs b/tests/stm32/src/bin/afio.rs
new file mode 100644
index 000000000..d88765717
--- /dev/null
+++ b/tests/stm32/src/bin/afio.rs
@@ -0,0 +1,1158 @@
+// required-features: afio
+#![no_std]
+#![no_main]
+#[path = "../common.rs"]
+mod common;
+
+use common::*;
+use embassy_executor::Spawner;
+use embassy_stm32::gpio::{AfioRemap, OutputType, Pull};
+use embassy_stm32::pac::AFIO;
+use embassy_stm32::time::khz;
+use embassy_stm32::timer::complementary_pwm::{ComplementaryPwm, ComplementaryPwmPin};
+use embassy_stm32::timer::input_capture::{CapturePin, InputCapture};
+use embassy_stm32::timer::pwm_input::PwmInput;
+use embassy_stm32::timer::qei::Qei;
+use embassy_stm32::timer::simple_pwm::{PwmPin, SimplePwm};
+use embassy_stm32::timer::{Ch1, Ch2};
+use embassy_stm32::usart::{Uart, UartRx, UartTx};
+use embassy_stm32::{Peripherals, bind_interrupts};
+
+#[cfg(not(feature = "afio-connectivity-line"))]
+bind_interrupts!(struct Irqs {
+    USART3 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART3>;
+    TIM1_CC => embassy_stm32::timer::CaptureCompareInterruptHandler<embassy_stm32::peripherals::TIM1>;
+});
+
+#[cfg(feature = "afio-connectivity-line")]
+bind_interrupts!(struct Irqs {
+    CAN1_RX0 => embassy_stm32::can::Rx0InterruptHandler<embassy_stm32::peripherals::CAN1>;
+    CAN1_RX1 => embassy_stm32::can::Rx1InterruptHandler<embassy_stm32::peripherals::CAN1>;
+    CAN1_SCE => embassy_stm32::can::SceInterruptHandler<embassy_stm32::peripherals::CAN1>;
+    CAN1_TX => embassy_stm32::can::TxInterruptHandler<embassy_stm32::peripherals::CAN1>;
+
+    CAN2_RX0 => embassy_stm32::can::Rx0InterruptHandler<embassy_stm32::peripherals::CAN2>;
+    CAN2_RX1 => embassy_stm32::can::Rx1InterruptHandler<embassy_stm32::peripherals::CAN2>;
+    CAN2_SCE => embassy_stm32::can::SceInterruptHandler<embassy_stm32::peripherals::CAN2>;
+    CAN2_TX => embassy_stm32::can::TxInterruptHandler<embassy_stm32::peripherals::CAN2>;
+
+    ETH => embassy_stm32::eth::InterruptHandler;
+    USART3 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART3>;
+    TIM1_CC => embassy_stm32::timer::CaptureCompareInterruptHandler<embassy_stm32::peripherals::TIM1>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut p = init();
+    info!("Hello World!");
+
+    // USART3
+    {
+        // no remap RX/TX/RTS/CTS
+        afio_registers_set_remap();
+        Uart::new_blocking_with_rtscts(
+            p.USART3.reborrow(),
+            p.PB11.reborrow(),
+            p.PB10.reborrow(),
+            p.PB14.reborrow(),
+            p.PB13.reborrow(),
+            Default::default(),
+        )
+        .unwrap();
+        defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 0);
+    }
+    {
+        // no remap RX/TX
+        afio_registers_set_remap();
+        Uart::new_blocking(
+            p.USART3.reborrow(),
+            p.PB11.reborrow(),
+            p.PB10.reborrow(),
+            Default::default(),
+        )
+        .unwrap();
+        defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 0);
+    }
+    {
+        // no remap TX
+        afio_registers_set_remap();
+        Uart::new_blocking_half_duplex(
+            p.USART3.reborrow(),
+            p.PB10.reborrow(),
+            Default::default(),
+            embassy_stm32::usart::HalfDuplexReadback::NoReadback,
+        )
+        .unwrap();
+        defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 0);
+    }
+    {
+        // no remap TX async
+        afio_registers_set_remap();
+        UartTx::new(
+            p.USART3.reborrow(),
+            p.PB10.reborrow(),
+            p.DMA1_CH2.reborrow(),
+            Default::default(),
+        )
+        .unwrap();
+        defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 0);
+    }
+    {
+        // no remap TX/CTS async
+        afio_registers_set_remap();
+        UartTx::new_with_cts(
+            p.USART3.reborrow(),
+            p.PB10.reborrow(),
+            p.PB13.reborrow(),
+            p.DMA1_CH2.reborrow(),
+            Default::default(),
+        )
+        .unwrap();
+        defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 0);
+    }
+    {
+        // no remap RX async
+        afio_registers_set_remap();
+        UartRx::new(
+            p.USART3.reborrow(),
+            Irqs,
+            p.PB11.reborrow(),
+            p.DMA1_CH3.reborrow(),
+            Default::default(),
+        )
+        .unwrap();
+        defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 0);
+    }
+    {
+        // no remap RX async
+        afio_registers_set_remap();
+        UartRx::new_with_rts(
+            p.USART3.reborrow(),
+            Irqs,
+            p.PB11.reborrow(),
+            p.PB14.reborrow(),
+            p.DMA1_CH3.reborrow(),
+            Default::default(),
+        )
+        .unwrap();
+        defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 0);
+    }
+    {
+        // no remap RX/TX async
+        afio_registers_set_remap();
+        Uart::new(
+            p.USART3.reborrow(),
+            p.PB11.reborrow(),
+            p.PB10.reborrow(),
+            Irqs,
+            p.DMA1_CH2.reborrow(),
+            p.DMA1_CH3.reborrow(),
+            Default::default(),
+        )
+        .unwrap();
+        defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 0);
+    }
+    {
+        // no remap RX/TX/RTS/CTS async
+        afio_registers_set_remap();
+        Uart::new_with_rtscts(
+            p.USART3.reborrow(),
+            p.PB11.reborrow(),
+            p.PB10.reborrow(),
+            Irqs,
+            p.PB14.reborrow(),
+            p.PB13.reborrow(),
+            p.DMA1_CH2.reborrow(),
+            p.DMA1_CH3.reborrow(),
+            Default::default(),
+        )
+        .unwrap();
+        defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 0);
+    }
+
+    // TIM1
+    {
+        // no remap
+        afio_registers_set_remap();
+        SimplePwm::new::<AfioRemap<0>>(
+            p.TIM1.reborrow(),
+            Some(PwmPin::new(p.PA8.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PA9.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PA10.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PA11.reborrow(), OutputType::PushPull)),
+            khz(10),
+            Default::default(),
+        );
+        defmt::assert_eq!(AFIO.mapr().read().tim1_remap(), 0);
+    }
+    {
+        // no remap
+        afio_registers_set_remap();
+        SimplePwm::new::<AfioRemap<0>>(
+            p.TIM1.reborrow(),
+            Some(PwmPin::new(p.PA8.reborrow(), OutputType::PushPull)),
+            None,
+            None,
+            None,
+            khz(10),
+            Default::default(),
+        );
+        defmt::assert_eq!(AFIO.mapr().read().tim1_remap(), 0);
+    }
+    {
+        // partial remap
+        reset_afio_registers();
+        ComplementaryPwm::new::<AfioRemap<1>>(
+            p.TIM1.reborrow(),
+            Some(PwmPin::new(p.PA8.reborrow(), OutputType::PushPull)),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            khz(10),
+            Default::default(),
+        );
+        defmt::assert_eq!(AFIO.mapr().read().tim1_remap(), 1);
+    }
+    {
+        // partial remap
+        reset_afio_registers();
+        ComplementaryPwm::new::<AfioRemap<1>>(
+            p.TIM1.reborrow(),
+            Some(PwmPin::new(p.PA8.reborrow(), OutputType::PushPull)),
+            Some(ComplementaryPwmPin::new(p.PA7.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PA9.reborrow(), OutputType::PushPull)),
+            Some(ComplementaryPwmPin::new(p.PB0.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PA10.reborrow(), OutputType::PushPull)),
+            None, // pin does not exist on medium-density devices
+            Some(PwmPin::new(p.PA11.reborrow(), OutputType::PushPull)),
+            None, // signal does not exist
+            khz(10),
+            Default::default(),
+        );
+        defmt::assert_eq!(AFIO.mapr().read().tim1_remap(), 1);
+    }
+    {
+        // partial remap
+        reset_afio_registers();
+        InputCapture::new::<AfioRemap<1>>(
+            p.TIM1.reborrow(),
+            Some(CapturePin::new(p.PA8.reborrow(), Pull::Down)),
+            None,
+            None,
+            None,
+            Irqs,
+            khz(10),
+            Default::default(),
+        );
+        defmt::assert_eq!(AFIO.mapr().read().tim1_remap(), 1);
+    }
+    {
+        // partial remap
+        reset_afio_registers();
+        PwmInput::new_ch1::<AfioRemap<1>>(p.TIM1.reborrow(), p.PA8.reborrow(), Pull::Down, khz(10));
+        defmt::assert_eq!(AFIO.mapr().read().tim1_remap(), 1);
+    }
+    {
+        // partial remap
+        reset_afio_registers();
+        Qei::new::<Ch1, Ch2, AfioRemap<1>>(
+            p.TIM1.reborrow(),
+            p.PA8.reborrow(),
+            p.PA9.reborrow(),
+            Default::default(),
+        );
+        defmt::assert_eq!(AFIO.mapr().read().tim1_remap(), 1);
+    }
+
+    // TIM2
+    {
+        // no remap
+        afio_registers_set_remap();
+        SimplePwm::new::<AfioRemap<0>>(
+            p.TIM2.reborrow(),
+            Some(PwmPin::new(p.PA0.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PA1.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PA2.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PA3.reborrow(), OutputType::PushPull)),
+            khz(10),
+            Default::default(),
+        );
+        defmt::assert_eq!(AFIO.mapr().read().tim2_remap(), 0);
+    }
+    {
+        // partial remap 1
+        reset_afio_registers();
+        SimplePwm::new::<AfioRemap<1>>(
+            p.TIM2.reborrow(),
+            Some(PwmPin::new(p.PA15.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PB3.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PA2.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PA3.reborrow(), OutputType::PushPull)),
+            khz(10),
+            Default::default(),
+        );
+        defmt::assert_eq!(AFIO.mapr().read().tim2_remap(), 1);
+    }
+    {
+        // partial remap 2
+        reset_afio_registers();
+        SimplePwm::new::<AfioRemap<2>>(
+            p.TIM2.reborrow(),
+            Some(PwmPin::new(p.PA0.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PA1.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PB10.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PB11.reborrow(), OutputType::PushPull)),
+            khz(10),
+            Default::default(),
+        );
+        defmt::assert_eq!(AFIO.mapr().read().tim2_remap(), 2);
+    }
+    {
+        // full remap
+        reset_afio_registers();
+        SimplePwm::new::<AfioRemap<3>>(
+            p.TIM2.reborrow(),
+            Some(PwmPin::new(p.PA15.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PB3.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PB10.reborrow(), OutputType::PushPull)),
+            Some(PwmPin::new(p.PB11.reborrow(), OutputType::PushPull)),
+            khz(10),
+            Default::default(),
+        );
+        defmt::assert_eq!(AFIO.mapr().read().tim2_remap(), 3);
+    }
+
+    connectivity_line::run(&mut p);
+    value_line::run(&mut p);
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
+
+#[cfg(feature = "afio-connectivity-line")]
+mod connectivity_line {
+    use embassy_stm32::can::Can;
+    use embassy_stm32::eth::{Ethernet, GenericPhy, PacketQueue};
+    use embassy_stm32::i2s::I2S;
+    use embassy_stm32::spi::Spi;
+
+    use super::*;
+
+    pub fn run(p: &mut Peripherals) {
+        // USART3
+        {
+            // partial remap RX/TX/RTS/CTS
+            reset_afio_registers();
+            Uart::new_blocking_with_rtscts(
+                p.USART3.reborrow(),
+                p.PC11.reborrow(),
+                p.PC10.reborrow(),
+                p.PB14.reborrow(),
+                p.PB13.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 1);
+        }
+        {
+            // partial remap RX/TX
+            reset_afio_registers();
+            Uart::new_blocking(
+                p.USART3.reborrow(),
+                p.PC11.reborrow(),
+                p.PC10.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 1);
+        }
+        {
+            // partial remap TX
+            reset_afio_registers();
+            Uart::new_blocking_half_duplex(
+                p.USART3.reborrow(),
+                p.PC10.reborrow(),
+                Default::default(),
+                embassy_stm32::usart::HalfDuplexReadback::NoReadback,
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 1);
+        }
+        {
+            // partial remap TX async
+            reset_afio_registers();
+            UartTx::new(
+                p.USART3.reborrow(),
+                p.PC10.reborrow(),
+                p.DMA1_CH2.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 1);
+        }
+        {
+            // partial remap TX/CTS async
+            reset_afio_registers();
+            UartTx::new_with_cts(
+                p.USART3.reborrow(),
+                p.PC10.reborrow(),
+                p.PB13.reborrow(),
+                p.DMA1_CH2.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 1);
+        }
+        {
+            // partial remap RX async
+            reset_afio_registers();
+            UartRx::new(
+                p.USART3.reborrow(),
+                Irqs,
+                p.PC11.reborrow(),
+                p.DMA1_CH3.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 1);
+        }
+        {
+            // partial remap RX async
+            reset_afio_registers();
+            UartRx::new_with_rts(
+                p.USART3.reborrow(),
+                Irqs,
+                p.PC11.reborrow(),
+                p.PB14.reborrow(),
+                p.DMA1_CH3.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 1);
+        }
+        {
+            // partial remap RX/TX async
+            reset_afio_registers();
+            Uart::new(
+                p.USART3.reborrow(),
+                p.PC11.reborrow(),
+                p.PC10.reborrow(),
+                Irqs,
+                p.DMA1_CH2.reborrow(),
+                p.DMA1_CH3.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 1);
+        }
+        {
+            // partial remap RX/TX/RTS/CTS async
+            reset_afio_registers();
+            Uart::new_with_rtscts(
+                p.USART3.reborrow(),
+                p.PC11.reborrow(),
+                p.PC10.reborrow(),
+                Irqs,
+                p.PB14.reborrow(),
+                p.PB13.reborrow(),
+                p.DMA1_CH2.reborrow(),
+                p.DMA1_CH3.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 1);
+        }
+        {
+            // full remap RX/TX/RTS/CTS
+            reset_afio_registers();
+            Uart::new_blocking_with_rtscts(
+                p.USART3.reborrow(),
+                p.PD9.reborrow(),
+                p.PD8.reborrow(),
+                p.PD12.reborrow(),
+                p.PD11.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 3);
+        }
+        {
+            // full remap RX/TX
+            reset_afio_registers();
+            Uart::new_blocking(
+                p.USART3.reborrow(),
+                p.PD9.reborrow(),
+                p.PD8.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 3);
+        }
+        {
+            // full remap TX
+            reset_afio_registers();
+            Uart::new_blocking_half_duplex(
+                p.USART3.reborrow(),
+                p.PD8.reborrow(),
+                Default::default(),
+                embassy_stm32::usart::HalfDuplexReadback::NoReadback,
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 3);
+        }
+        {
+            // full remap TX async
+            reset_afio_registers();
+            UartTx::new(
+                p.USART3.reborrow(),
+                p.PD8.reborrow(),
+                p.DMA1_CH2.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 3);
+        }
+        {
+            // full remap TX/CTS async
+            reset_afio_registers();
+            UartTx::new_with_cts(
+                p.USART3.reborrow(),
+                p.PD8.reborrow(),
+                p.PD11.reborrow(),
+                p.DMA1_CH2.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 3);
+        }
+        {
+            // full remap RX async
+            reset_afio_registers();
+            UartRx::new(
+                p.USART3.reborrow(),
+                Irqs,
+                p.PD9.reborrow(),
+                p.DMA1_CH3.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 3);
+        }
+        {
+            // full remap RX async
+            reset_afio_registers();
+            UartRx::new_with_rts(
+                p.USART3.reborrow(),
+                Irqs,
+                p.PD9.reborrow(),
+                p.PD12.reborrow(),
+                p.DMA1_CH3.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 3);
+        }
+        {
+            // full remap RX/TX async
+            reset_afio_registers();
+            Uart::new(
+                p.USART3.reborrow(),
+                p.PD9.reborrow(),
+                p.PD8.reborrow(),
+                Irqs,
+                p.DMA1_CH2.reborrow(),
+                p.DMA1_CH3.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 3);
+        }
+        {
+            // full remap RX/TX/RTS/CTS async
+            reset_afio_registers();
+            Uart::new_with_rtscts(
+                p.USART3.reborrow(),
+                p.PD9.reborrow(),
+                p.PD8.reborrow(),
+                Irqs,
+                p.PD12.reborrow(),
+                p.PD11.reborrow(),
+                p.DMA1_CH2.reborrow(),
+                p.DMA1_CH3.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart3_remap(), 3);
+        }
+
+        // SPI3
+        {
+            // no remap SCK/MISO/MOSI
+            afio_registers_set_remap();
+            Spi::new_blocking(
+                p.SPI3.reborrow(),
+                p.PB3.reborrow(),
+                p.PB5.reborrow(),
+                p.PB4.reborrow(),
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().spi3_remap(), false);
+        }
+        {
+            // no remap SCK/MOSI
+            afio_registers_set_remap();
+            Spi::new_blocking_txonly(
+                p.SPI3.reborrow(),
+                p.PB3.reborrow(),
+                p.PB5.reborrow(),
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().spi3_remap(), false);
+        }
+        {
+            // no remap MOSI
+            afio_registers_set_remap();
+            Spi::new_blocking_txonly_nosck(p.SPI3.reborrow(), p.PB5.reborrow(), Default::default());
+            defmt::assert_eq!(AFIO.mapr().read().spi3_remap(), false);
+        }
+        {
+            // no remap SCK/MISO
+            afio_registers_set_remap();
+            Spi::new_blocking_rxonly(
+                p.SPI3.reborrow(),
+                p.PB3.reborrow(),
+                p.PB4.reborrow(),
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().spi3_remap(), false);
+        }
+        {
+            // remap SCK/MISO/MOSI
+            reset_afio_registers();
+            Spi::new_blocking(
+                p.SPI3.reborrow(),
+                p.PC10.reborrow(),
+                p.PC12.reborrow(),
+                p.PC11.reborrow(),
+                Default::default(),
+            );
+
+            defmt::assert_eq!(AFIO.mapr().read().spi3_remap(), true);
+        }
+        {
+            // remap SCK/MOSI
+            reset_afio_registers();
+            Spi::new_blocking_txonly(
+                p.SPI3.reborrow(),
+                p.PC10.reborrow(),
+                p.PC12.reborrow(),
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().spi3_remap(), true);
+        }
+        {
+            // remap MOSI
+            reset_afio_registers();
+            Spi::new_blocking_txonly_nosck(p.SPI3.reborrow(), p.PB5.reborrow(), Default::default());
+            defmt::assert_eq!(AFIO.mapr().read().spi3_remap(), true);
+        }
+        {
+            // remap SCK/MISO
+            reset_afio_registers();
+            Spi::new_blocking_rxonly(
+                p.SPI3.reborrow(),
+                p.PC10.reborrow(),
+                p.PC11.reborrow(),
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().spi3_remap(), true);
+        }
+
+        // I2S3
+        {
+            // no remap SD/WS/CK/MCK
+            afio_registers_set_remap();
+            I2S::new_txonly(
+                p.SPI3.reborrow(),
+                p.PB5.reborrow(),
+                p.PA15.reborrow(),
+                p.PB3.reborrow(),
+                p.PC7.reborrow(),
+                p.DMA2_CH2.reborrow(),
+                &mut [0u16; 0],
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().spi3_remap(), false);
+        }
+        {
+            // no remap SD/WS/CK
+            afio_registers_set_remap();
+            I2S::new_txonly_nomck(
+                p.SPI3.reborrow(),
+                p.PB5.reborrow(),
+                p.PA15.reborrow(),
+                p.PB3.reborrow(),
+                p.DMA2_CH2.reborrow(),
+                &mut [0u16; 0],
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().spi3_remap(), false);
+        }
+        {
+            // no remap SD/WS/CK/MCK
+            afio_registers_set_remap();
+            I2S::new_rxonly(
+                p.SPI3.reborrow(),
+                p.PB4.reborrow(),
+                p.PA15.reborrow(),
+                p.PB3.reborrow(),
+                p.PC7.reborrow(),
+                p.DMA2_CH1.reborrow(),
+                &mut [0u16; 0],
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().spi3_remap(), true);
+        }
+        {
+            // remap SD/WS/CK/MCK
+            reset_afio_registers();
+            I2S::new_txonly(
+                p.SPI3.reborrow(),
+                p.PC12.reborrow(),
+                p.PA4.reborrow(),
+                p.PC10.reborrow(),
+                p.PC7.reborrow(),
+                p.DMA2_CH2.reborrow(),
+                &mut [0u16; 0],
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().spi3_remap(), true);
+        }
+        {
+            // remap SD/WS/CK
+            reset_afio_registers();
+            I2S::new_txonly_nomck(
+                p.SPI3.reborrow(),
+                p.PC12.reborrow(),
+                p.PA4.reborrow(),
+                p.PC10.reborrow(),
+                p.DMA2_CH2.reborrow(),
+                &mut [0u16; 0],
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().spi3_remap(), true);
+        }
+        {
+            // remap SD/WS/CK/MCK
+            reset_afio_registers();
+            I2S::new_rxonly(
+                p.SPI3.reborrow(),
+                p.PC11.reborrow(),
+                p.PA4.reborrow(),
+                p.PC10.reborrow(),
+                p.PC7.reborrow(),
+                p.DMA2_CH1.reborrow(),
+                &mut [0u16; 0],
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().spi3_remap(), true);
+        }
+
+        // CAN2
+        {
+            // no remap
+            afio_registers_set_remap();
+            Can::new(p.CAN2.reborrow(), p.PB12.reborrow(), p.PB13.reborrow(), Irqs);
+            defmt::assert_eq!(AFIO.mapr().read().can2_remap(), false);
+        }
+        {
+            // remap
+            reset_afio_registers();
+            Can::new(p.CAN2.reborrow(), p.PB5.reborrow(), p.PB6.reborrow(), Irqs);
+            defmt::assert_eq!(AFIO.mapr().read().can2_remap(), true);
+        }
+
+        // Ethernet
+        {
+            // no remap RMII
+            afio_registers_set_remap();
+            Ethernet::new(
+                &mut PacketQueue::<1, 1>::new(),
+                p.ETH.reborrow(),
+                Irqs,
+                p.PA1.reborrow(),
+                p.PA2.reborrow(),
+                p.PC1.reborrow(),
+                p.PA7.reborrow(),
+                p.PC4.reborrow(),
+                p.PC5.reborrow(),
+                p.PB12.reborrow(),
+                p.PB13.reborrow(),
+                p.PB11.reborrow(),
+                GenericPhy::new_auto(),
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().eth_remap(), false);
+        }
+        {
+            // no remap MII
+            afio_registers_set_remap();
+            Ethernet::new_mii(
+                &mut PacketQueue::<1, 1>::new(),
+                p.ETH.reborrow(),
+                Irqs,
+                p.PA1.reborrow(),
+                p.PC3.reborrow(),
+                p.PA2.reborrow(),
+                p.PC1.reborrow(),
+                p.PA7.reborrow(),
+                p.PC4.reborrow(),
+                p.PC5.reborrow(),
+                p.PB0.reborrow(),
+                p.PB1.reborrow(),
+                p.PB12.reborrow(),
+                p.PB13.reborrow(),
+                p.PC2.reborrow(),
+                p.PB8.reborrow(),
+                p.PB11.reborrow(),
+                GenericPhy::new_auto(),
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().eth_remap(), false);
+        }
+        {
+            // remap RMII
+            reset_afio_registers();
+            Ethernet::new(
+                &mut PacketQueue::<1, 1>::new(),
+                p.ETH.reborrow(),
+                Irqs,
+                p.PA1.reborrow(),
+                p.PA2.reborrow(),
+                p.PC1.reborrow(),
+                p.PD8.reborrow(),
+                p.PD9.reborrow(),
+                p.PD10.reborrow(),
+                p.PB12.reborrow(),
+                p.PB13.reborrow(),
+                p.PB11.reborrow(),
+                GenericPhy::new_auto(),
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().eth_remap(), true);
+        }
+        {
+            // remap MII
+            reset_afio_registers();
+            Ethernet::new_mii(
+                &mut PacketQueue::<1, 1>::new(),
+                p.ETH.reborrow(),
+                Irqs,
+                p.PA1.reborrow(),
+                p.PC3.reborrow(),
+                p.PA2.reborrow(),
+                p.PC1.reborrow(),
+                p.PD8.reborrow(),
+                p.PD9.reborrow(),
+                p.PD10.reborrow(),
+                p.PD11.reborrow(),
+                p.PD12.reborrow(),
+                p.PB12.reborrow(),
+                p.PB13.reborrow(),
+                p.PC2.reborrow(),
+                p.PB8.reborrow(),
+                p.PB11.reborrow(),
+                GenericPhy::new_auto(),
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().eth_remap(), true);
+        }
+
+        // CAN1
+        {
+            // no remap
+            afio_registers_set_remap();
+            Can::new(p.CAN1.reborrow(), p.PA11.reborrow(), p.PA12.reborrow(), Irqs);
+            defmt::assert_eq!(AFIO.mapr().read().can1_remap(), 0);
+        }
+        {
+            // partial remap
+            reset_afio_registers();
+            Can::new(p.CAN1.reborrow(), p.PB8.reborrow(), p.PB9.reborrow(), Irqs);
+            defmt::assert_eq!(AFIO.mapr().read().can1_remap(), 2);
+        }
+        {
+            // full remap
+            reset_afio_registers();
+            Can::new(p.CAN1.reborrow(), p.PD0.reborrow(), p.PD1.reborrow(), Irqs);
+            defmt::assert_eq!(AFIO.mapr().read().can1_remap(), 3);
+        }
+
+        // USART2
+        {
+            // no remap RX/TX/RTS/CTS
+            afio_registers_set_remap();
+            Uart::new_blocking_with_rtscts(
+                p.USART2.reborrow(),
+                p.PA3.reborrow(),
+                p.PA2.reborrow(),
+                p.PA1.reborrow(),
+                p.PA0.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart2_remap(), false);
+        }
+        {
+            // no remap RX/TX
+            afio_registers_set_remap();
+            Uart::new_blocking(
+                p.USART2.reborrow(),
+                p.PA3.reborrow(),
+                p.PA2.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart2_remap(), false);
+        }
+        {
+            // no remap TX
+            afio_registers_set_remap();
+            Uart::new_blocking_half_duplex(
+                p.USART2.reborrow(),
+                p.PA2.reborrow(),
+                Default::default(),
+                embassy_stm32::usart::HalfDuplexReadback::NoReadback,
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart2_remap(), false);
+        }
+        {
+            // full remap RX/TX/RTS/CTS
+            reset_afio_registers();
+            Uart::new_blocking_with_rtscts(
+                p.USART2.reborrow(),
+                p.PD6.reborrow(),
+                p.PD5.reborrow(),
+                p.PD4.reborrow(),
+                p.PD3.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart2_remap(), false);
+        }
+        {
+            // full remap RX/TX
+            reset_afio_registers();
+            Uart::new_blocking(
+                p.USART2.reborrow(),
+                p.PD6.reborrow(),
+                p.PD5.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart2_remap(), false);
+        }
+        {
+            // full remap TX
+            reset_afio_registers();
+            Uart::new_blocking_half_duplex(
+                p.USART2.reborrow(),
+                p.PD5.reborrow(),
+                Default::default(),
+                embassy_stm32::usart::HalfDuplexReadback::NoReadback,
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart2_remap(), true);
+        }
+
+        // USART1
+        {
+            // no remap RX/TX/RTS/CTS
+            afio_registers_set_remap();
+            Uart::new_blocking_with_rtscts(
+                p.USART1.reborrow(),
+                p.PA10.reborrow(),
+                p.PA9.reborrow(),
+                p.PA12.reborrow(),
+                p.PA11.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart1_remap(), false);
+        }
+        {
+            // no remap RX/TX
+            afio_registers_set_remap();
+            Uart::new_blocking(
+                p.USART1.reborrow(),
+                p.PA10.reborrow(),
+                p.PA9.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart1_remap(), false);
+        }
+        {
+            // no remap TX
+            afio_registers_set_remap();
+            Uart::new_blocking_half_duplex(
+                p.USART1.reborrow(),
+                p.PA9.reborrow(),
+                Default::default(),
+                embassy_stm32::usart::HalfDuplexReadback::NoReadback,
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart1_remap(), false);
+        }
+        {
+            // remap RX/TX/RTS/CTS
+            reset_afio_registers();
+            Uart::new_blocking_with_rtscts(
+                p.USART1.reborrow(),
+                p.PB7.reborrow(),
+                p.PB6.reborrow(),
+                p.PA12.reborrow(),
+                p.PA11.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart1_remap(), true);
+        }
+        {
+            // remap RX/TX
+            reset_afio_registers();
+            Uart::new_blocking(
+                p.USART1.reborrow(),
+                p.PB7.reborrow(),
+                p.PB6.reborrow(),
+                Default::default(),
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart1_remap(), true);
+        }
+        {
+            // remap TX
+            reset_afio_registers();
+            Uart::new_blocking_half_duplex(
+                p.USART1.reborrow(),
+                p.PB6.reborrow(),
+                Default::default(),
+                embassy_stm32::usart::HalfDuplexReadback::NoReadback,
+            )
+            .unwrap();
+            defmt::assert_eq!(AFIO.mapr().read().usart1_remap(), true);
+        }
+
+        // TIM1
+        {
+            // full remap
+            reset_afio_registers();
+            SimplePwm::new(
+                p.TIM1.reborrow(),
+                Some(PwmPin::new(p.PE9.reborrow(), OutputType::PushPull)),
+                Some(PwmPin::new(p.PE11.reborrow(), OutputType::PushPull)),
+                None,
+                None,
+                khz(10),
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr().read().tim1_remap(), 3);
+        }
+    }
+}
+
+#[cfg(feature = "afio-value-line")]
+mod value_line {
+    use super::*;
+
+    pub fn run(p: &mut Peripherals) {
+        // TIM13
+        {
+            // no remap
+            reset_afio_registers();
+            SimplePwm::new(
+                p.TIM13.reborrow(),
+                Some(PwmPin::new(p.PC8.reborrow(), OutputType::PushPull)),
+                None,
+                None,
+                None,
+                khz(10),
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr2().read().tim13_remap(), false);
+        }
+        {
+            // remap
+            reset_afio_registers();
+            SimplePwm::new(
+                p.TIM13.reborrow(),
+                Some(PwmPin::new(p.PB0.reborrow(), OutputType::PushPull)),
+                None,
+                None,
+                None,
+                khz(10),
+                Default::default(),
+            );
+            defmt::assert_eq!(AFIO.mapr2().read().tim13_remap(), true);
+        }
+    }
+}
+
+#[cfg(not(feature = "afio-connectivity-line"))]
+mod connectivity_line {
+    use super::*;
+
+    pub fn run(_: &mut Peripherals) {}
+}
+
+#[cfg(not(feature = "afio-value-line"))]
+mod value_line {
+    use super::*;
+
+    pub fn run(_: &mut Peripherals) {}
+}
+
+fn reset_afio_registers() {
+    set_afio_registers(false, 0);
+}
+
+fn afio_registers_set_remap() {
+    set_afio_registers(true, 1);
+}
+
+fn set_afio_registers(bool_val: bool, num_val: u8) {
+    AFIO.mapr().modify(|w| {
+        w.set_swj_cfg(embassy_stm32::pac::afio::vals::SwjCfg::NO_OP);
+        w.set_can1_remap(num_val);
+        w.set_can2_remap(bool_val);
+        w.set_eth_remap(bool_val);
+        w.set_i2c1_remap(bool_val);
+        w.set_spi1_remap(bool_val);
+        w.set_spi3_remap(bool_val);
+        w.set_tim1_remap(num_val);
+        w.set_tim2_remap(num_val);
+        w.set_tim3_remap(num_val);
+        w.set_tim4_remap(bool_val);
+        w.set_usart1_remap(bool_val);
+        w.set_usart2_remap(bool_val);
+        w.set_usart3_remap(num_val);
+    });
+
+    AFIO.mapr2().modify(|w| {
+        w.set_cec_remap(bool_val);
+        w.set_tim9_remap(bool_val);
+        w.set_tim10_remap(bool_val);
+        w.set_tim11_remap(bool_val);
+        w.set_tim12_remap(bool_val);
+        w.set_tim13_remap(bool_val);
+        w.set_tim14_remap(bool_val);
+        w.set_tim15_remap(bool_val);
+        w.set_tim16_remap(bool_val);
+        w.set_tim17_remap(bool_val);
+    });
+}
diff --git a/tests/stm32/src/bin/can.rs b/tests/stm32/src/bin/can.rs
index ba8a33e34..348cd049d 100644
--- a/tests/stm32/src/bin/can.rs
+++ b/tests/stm32/src/bin/can.rs
@@ -15,6 +15,7 @@ use embassy_stm32::peripherals::CAN1;
 use embassy_time::Duration;
 use {defmt_rtt as _, panic_probe as _};
 
+#[path = "../can_common.rs"]
 mod can_common;
 use can_common::*;
 
@@ -27,7 +28,7 @@ bind_interrupts!(struct Irqs {
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let p = embassy_stm32::init(config());
+    let p = init();
     info!("Hello World!");
 
     let options = TestOptions {
@@ -43,7 +44,7 @@ async fn main(_spawner: Spawner) {
     // To synchronise to the bus the RX input needs to see a high level.
     // Use `mem::forget()` to release the borrow on the pin but keep the
     // pull-up resistor enabled.
-    let rx_pin = Input::new(&mut rx, Pull::Up);
+    let rx_pin = Input::new(rx.reborrow(), Pull::Up);
     core::mem::forget(rx_pin);
 
     let mut can = embassy_stm32::can::Can::new(can, rx, tx, Irqs);
diff --git a/tests/stm32/src/bin/cordic.rs b/tests/stm32/src/bin/cordic.rs
index e09226de8..e86eea58b 100644
--- a/tests/stm32/src/bin/cordic.rs
+++ b/tests/stm32/src/bin/cordic.rs
@@ -29,7 +29,7 @@ const OUTPUT_LENGTH: usize = (INPUT_U32_COUNT - 1) * 2;
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let dp = embassy_stm32::init(config());
+    let dp = init();
 
     //
     // use RNG generate random Q1.31 value
@@ -82,8 +82,8 @@ async fn main(_spawner: Spawner) {
     let cnt1 = defmt::unwrap!(
         cordic
             .async_calc_32bit(
-                &mut write_dma,
-                &mut read_dma,
+                write_dma.reborrow(),
+                read_dma.reborrow(),
                 &input_q1_31[2..],
                 &mut output_q1_31[cnt0..],
                 true,
diff --git a/tests/stm32/src/bin/cryp.rs b/tests/stm32/src/bin/cryp.rs
index 60778bdaa..640de50e3 100644
--- a/tests/stm32/src/bin/cryp.rs
+++ b/tests/stm32/src/bin/cryp.rs
@@ -5,9 +5,9 @@
 #[path = "../common.rs"]
 mod common;
 
+use aes_gcm::Aes128Gcm;
 use aes_gcm::aead::heapless::Vec;
 use aes_gcm::aead::{AeadInPlace, KeyInit};
-use aes_gcm::Aes128Gcm;
 use common::*;
 use embassy_executor::Spawner;
 use embassy_stm32::cryp::{self, *};
@@ -20,7 +20,7 @@ bind_interrupts!(struct Irqs {
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let p: embassy_stm32::Peripherals = embassy_stm32::init(config());
+    let p: embassy_stm32::Peripherals = init();
 
     const PAYLOAD1: &[u8] = b"payload data 1 ;zdfhzdfhS;GKJASBDG;ASKDJBAL,zdfhzdfhzdfhzdfhvljhb,jhbjhb,sdhsdghsdhsfhsghzdfhzdfhzdfhzdfdhsdthsthsdhsgaadfhhgkdgfuoyguoft6783567";
     const PAYLOAD2: &[u8] = b"payload data 2 ;SKEzdfhzdfhzbhgvljhb,jhbjhb,sdhsdghsdhsfhsghshsfhshstsdthadfhsdfjhsfgjsfgjxfgjzdhgDFghSDGHjtfjtjszftjzsdtjhstdsdhsdhsdhsdhsdthsthsdhsgfh";
@@ -72,7 +72,7 @@ async fn main(_spawner: Spawner) {
     defmt::assert!(encrypt_tag == payload_vec[ciphertext.len()..ciphertext.len() + encrypt_tag.len()]);
 
     // Decrypt in software using AES-GCM 128-bit
-    let _ = cipher.decrypt_in_place(&iv.into(), &aad, &mut payload_vec);
+    cipher.decrypt_in_place(&iv.into(), &aad, &mut payload_vec).unwrap();
 
     info!("Test OK");
     cortex_m::asm::bkpt();
diff --git a/tests/stm32/src/bin/dac.rs b/tests/stm32/src/bin/dac.rs
index 06501ab14..747b11e7f 100644
--- a/tests/stm32/src/bin/dac.rs
+++ b/tests/stm32/src/bin/dac.rs
@@ -10,9 +10,8 @@ use core::f32::consts::PI;
 use common::*;
 use defmt::assert;
 use embassy_executor::Spawner;
-use embassy_stm32::adc::Adc;
+use embassy_stm32::adc::{Adc, SampleTime};
 use embassy_stm32::dac::{DacCh1, Value};
-use embassy_stm32::dma::NoDma;
 use embassy_time::Timer;
 use micromath::F32Ext;
 use {defmt_rtt as _, panic_probe as _};
@@ -20,14 +19,14 @@ use {defmt_rtt as _, panic_probe as _};
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     // Initialize the board and obtain a Peripherals instance
-    let p: embassy_stm32::Peripherals = embassy_stm32::init(config());
+    let p: embassy_stm32::Peripherals = init();
 
     let adc = peri!(p, ADC);
     let dac = peri!(p, DAC);
     let dac_pin = peri!(p, DAC_PIN);
     let mut adc_pin = unsafe { core::ptr::read(&dac_pin) };
 
-    let mut dac = DacCh1::new(dac, NoDma, dac_pin);
+    let mut dac = DacCh1::new_blocking(dac, dac_pin);
     let mut adc = Adc::new(adc);
 
     #[cfg(feature = "stm32h755zi")]
@@ -38,7 +37,7 @@ async fn main(_spawner: Spawner) {
     dac.set(Value::Bit8(0));
     // Now wait a little to obtain a stable value
     Timer::after_millis(30).await;
-    let offset = adc.read(&mut adc_pin);
+    let offset = adc.blocking_read(&mut adc_pin, SampleTime::from_bits(0));
 
     for v in 0..=255 {
         // First set the DAC output value
@@ -49,7 +48,10 @@ async fn main(_spawner: Spawner) {
         Timer::after_millis(30).await;
 
         // Need to steal the peripherals here because PA4 is obviously in use already
-        let measured = adc.read(&mut unsafe { embassy_stm32::Peripherals::steal() }.PA4);
+        let measured = adc.blocking_read(
+            &mut unsafe { embassy_stm32::Peripherals::steal() }.PA4,
+            SampleTime::from_bits(0),
+        );
         // Calibrate and normalize the measurement to get close to the dac_output_val
         let measured_normalized = ((measured as i32 - offset as i32) / normalization_factor) as i16;
 
diff --git a/tests/stm32/src/bin/dac_l1.rs b/tests/stm32/src/bin/dac_l1.rs
index d5e9c9722..2fe0cf1f1 100644
--- a/tests/stm32/src/bin/dac_l1.rs
+++ b/tests/stm32/src/bin/dac_l1.rs
@@ -10,9 +10,8 @@ use core::f32::consts::PI;
 use common::*;
 use defmt::assert;
 use embassy_executor::Spawner;
-use embassy_stm32::adc::Adc;
+use embassy_stm32::adc::{Adc, SampleTime};
 use embassy_stm32::dac::{DacCh1, Value};
-use embassy_stm32::dma::NoDma;
 use embassy_stm32::{bind_interrupts, peripherals};
 use embassy_time::Timer;
 use micromath::F32Ext;
@@ -25,14 +24,14 @@ bind_interrupts!(struct Irqs {
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     // Initialize the board and obtain a Peripherals instance
-    let p: embassy_stm32::Peripherals = embassy_stm32::init(config());
+    let p: embassy_stm32::Peripherals = init();
 
     let adc = peri!(p, ADC);
     let dac = peri!(p, DAC);
     let dac_pin = peri!(p, DAC_PIN);
     let mut adc_pin = unsafe { core::ptr::read(&dac_pin) };
 
-    let mut dac = DacCh1::new(dac, NoDma, dac_pin);
+    let mut dac = DacCh1::new_blocking(dac, dac_pin);
     let mut adc = Adc::new(adc, Irqs);
 
     #[cfg(feature = "stm32h755zi")]
@@ -48,7 +47,7 @@ async fn main(_spawner: Spawner) {
     dac.set(Value::Bit8(0));
     // Now wait a little to obtain a stable value
     Timer::after_millis(30).await;
-    let offset = adc.read(&mut adc_pin).await;
+    let offset = adc.read(&mut adc_pin, SampleTime::from_bits(0)).await;
 
     for v in 0..=255 {
         // First set the DAC output value
@@ -59,7 +58,12 @@ async fn main(_spawner: Spawner) {
         Timer::after_millis(30).await;
 
         // Need to steal the peripherals here because PA4 is obviously in use already
-        let measured = adc.read(&mut unsafe { embassy_stm32::Peripherals::steal() }.PA4).await;
+        let measured = adc
+            .read(
+                &mut unsafe { embassy_stm32::Peripherals::steal() }.PA4,
+                SampleTime::from_bits(0),
+            )
+            .await;
         // Calibrate and normalize the measurement to get close to the dac_output_val
         let measured_normalized = ((measured as i32 - offset as i32) / normalization_factor) as i16;
 
diff --git a/tests/stm32/src/bin/eeprom.rs b/tests/stm32/src/bin/eeprom.rs
new file mode 100644
index 000000000..61d249fd7
--- /dev/null
+++ b/tests/stm32/src/bin/eeprom.rs
@@ -0,0 +1,30 @@
+#![no_std]
+#![no_main]
+
+// required-features: eeprom
+
+#[path = "../common.rs"]
+mod common;
+
+use common::*;
+use defmt::assert_eq;
+use embassy_executor::Spawner;
+use embassy_stm32::flash::Flash;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    // Initialize the board and obtain a Peripherals instance
+    let p: embassy_stm32::Peripherals = init();
+
+    let mut f = Flash::new_blocking(p.FLASH);
+    const ADDR: u32 = 0x0;
+
+    unwrap!(f.eeprom_write_slice(ADDR, &[1, 2, 3, 4, 5, 6, 7, 8]));
+    let mut buf = [0u8; 8];
+    unwrap!(f.eeprom_read_slice(ADDR, &mut buf));
+    assert_eq!(&buf[..], &[1, 2, 3, 4, 5, 6, 7, 8]);
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/stm32/src/bin/eth.rs b/tests/stm32/src/bin/eth.rs
index 7c02f0354..ffc76b96f 100644
--- a/tests/stm32/src/bin/eth.rs
+++ b/tests/stm32/src/bin/eth.rs
@@ -6,13 +6,11 @@
 mod common;
 use common::*;
 use embassy_executor::Spawner;
-use embassy_net::{Stack, StackResources};
-use embassy_stm32::eth::generic_smi::GenericSMI;
-use embassy_stm32::eth::{Ethernet, PacketQueue};
-use embassy_stm32::peripherals::ETH;
+use embassy_net::StackResources;
+use embassy_stm32::eth::{Ethernet, GenericPhy, PacketQueue, Sma};
+use embassy_stm32::peripherals::{ETH, ETH_SMA};
 use embassy_stm32::rng::Rng;
 use embassy_stm32::{bind_interrupts, eth, peripherals, rng};
-use rand_core::RngCore;
 use static_cell::StaticCell;
 use {defmt_rtt as _, panic_probe as _};
 
@@ -29,16 +27,16 @@ bind_interrupts!(struct Irqs {
     RNG => rng::InterruptHandler<peripherals::RNG>;
 });
 
-type Device = Ethernet<'static, ETH, GenericSMI>;
+type Device = Ethernet<'static, ETH, GenericPhy<Sma<'static, ETH_SMA>>>;
 
 #[embassy_executor::task]
-async fn net_task(stack: &'static Stack<Device>) -> ! {
-    stack.run().await
+async fn net_task(mut runner: embassy_net::Runner<'static, Device>) -> ! {
+    runner.run().await
 }
 
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
-    let p = embassy_stm32::init(config());
+    let p = init();
     info!("Hello World!");
 
     // Generate random seed.
@@ -71,13 +69,12 @@ async fn main(spawner: Spawner) {
     const PACKET_QUEUE_SIZE: usize = 4;
 
     static PACKETS: StaticCell<PacketQueue<PACKET_QUEUE_SIZE, PACKET_QUEUE_SIZE>> = StaticCell::new();
+
     let device = Ethernet::new(
         PACKETS.init(PacketQueue::<PACKET_QUEUE_SIZE, PACKET_QUEUE_SIZE>::new()),
         p.ETH,
         Irqs,
         p.PA1,
-        p.PA2,
-        p.PC1,
         p.PA7,
         p.PC4,
         p.PC5,
@@ -87,8 +84,10 @@ async fn main(spawner: Spawner) {
         #[cfg(feature = "stm32h563zi")]
         p.PB15,
         p.PG11,
-        GenericSMI::new(0),
         mac_addr,
+        p.ETH_SMA,
+        p.PA2,
+        p.PC1,
     );
 
     let config = embassy_net::Config::dhcpv4(Default::default());
@@ -99,17 +98,11 @@ async fn main(spawner: Spawner) {
     //});
 
     // Init network stack
-    static STACK: StaticCell<Stack<Device>> = StaticCell::new();
     static RESOURCES: StaticCell<StackResources<2>> = StaticCell::new();
-    let stack = &*STACK.init(Stack::new(
-        device,
-        config,
-        RESOURCES.init(StackResources::<2>::new()),
-        seed,
-    ));
+    let (stack, runner) = embassy_net::new(device, config, RESOURCES.init(StackResources::new()), seed);
 
     // Launch network task
-    unwrap!(spawner.spawn(net_task(&stack)));
+    spawner.spawn(unwrap!(net_task(runner)));
 
     perf_client::run(
         stack,
diff --git a/tests/stm32/src/bin/fdcan.rs b/tests/stm32/src/bin/fdcan.rs
index bc2b7edd4..d97f493df 100644
--- a/tests/stm32/src/bin/fdcan.rs
+++ b/tests/stm32/src/bin/fdcan.rs
@@ -8,10 +8,11 @@ mod common;
 use common::*;
 use embassy_executor::Spawner;
 use embassy_stm32::peripherals::*;
-use embassy_stm32::{bind_interrupts, can, Config};
+use embassy_stm32::{Config, bind_interrupts, can};
 use embassy_time::Duration;
 use {defmt_rtt as _, panic_probe as _};
 
+#[path = "../can_common.rs"]
 mod can_common;
 use can_common::*;
 
@@ -102,10 +103,10 @@ fn options() -> (Config, TestOptions) {
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    //let peripherals = embassy_stm32::init(config());
+    //let peripherals = init();
 
     let (config, options) = options();
-    let peripherals = embassy_stm32::init(config);
+    let peripherals = init_with_config(config);
 
     let mut can = can::CanConfigurator::new(peripherals.FDCAN1, peripherals.PB8, peripherals.PB9, Irqs1);
     let mut can2 = can::CanConfigurator::new(peripherals.FDCAN2, peripherals.PB12, peripherals.PB13, Irqs2);
diff --git a/tests/stm32/src/bin/gpio.rs b/tests/stm32/src/bin/gpio.rs
index dfa299ab5..40b03201c 100644
--- a/tests/stm32/src/bin/gpio.rs
+++ b/tests/stm32/src/bin/gpio.rs
@@ -10,7 +10,7 @@ use embassy_stm32::gpio::{Flex, Input, Level, Output, OutputOpenDrain, Pull, Spe
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let p = embassy_stm32::init(config());
+    let p = init();
     info!("Hello World!");
 
     // Arduino pins D0 and D1
@@ -20,10 +20,10 @@ async fn main(_spawner: Spawner) {
 
     // Test initial output
     {
-        let b = Input::new(&mut b, Pull::None);
+        let b = Input::new(b.reborrow(), Pull::None);
 
         {
-            let a = Output::new(&mut a, Level::Low, Speed::Low);
+            let a = Output::new(a.reborrow(), Level::Low, Speed::Low);
             delay();
             assert!(b.is_low());
             assert!(!b.is_high());
@@ -31,7 +31,7 @@ async fn main(_spawner: Spawner) {
             assert!(!a.is_set_high());
         }
         {
-            let mut a = Output::new(&mut a, Level::High, Speed::Low);
+            let mut a = Output::new(a.reborrow(), Level::High, Speed::Low);
             delay();
             assert!(!b.is_low());
             assert!(b.is_high());
@@ -68,10 +68,10 @@ async fn main(_spawner: Spawner) {
 
     // Test input no pull
     {
-        let b = Input::new(&mut b, Pull::None);
+        let b = Input::new(b.reborrow(), Pull::None);
         // no pull, the status is undefined
 
-        let mut a = Output::new(&mut a, Level::Low, Speed::Low);
+        let mut a = Output::new(a.reborrow(), Level::Low, Speed::Low);
         delay();
         assert!(b.is_low());
         a.set_high();
@@ -81,11 +81,11 @@ async fn main(_spawner: Spawner) {
 
     // Test input pulldown
     {
-        let b = Input::new(&mut b, Pull::Down);
+        let b = Input::new(b.reborrow(), Pull::Down);
         delay();
         assert!(b.is_low());
 
-        let mut a = Output::new(&mut a, Level::Low, Speed::Low);
+        let mut a = Output::new(a.reborrow(), Level::Low, Speed::Low);
         delay();
         assert!(b.is_low());
         a.set_high();
@@ -95,11 +95,11 @@ async fn main(_spawner: Spawner) {
 
     // Test input pullup
     {
-        let b = Input::new(&mut b, Pull::Up);
+        let b = Input::new(b.reborrow(), Pull::Up);
         delay();
         assert!(b.is_high());
 
-        let mut a = Output::new(&mut a, Level::Low, Speed::Low);
+        let mut a = Output::new(a.reborrow(), Level::Low, Speed::Low);
         delay();
         assert!(b.is_low());
         a.set_high();
@@ -109,10 +109,10 @@ async fn main(_spawner: Spawner) {
 
     // Test output open drain
     {
-        let b = Input::new(&mut b, Pull::Down);
+        let b = Input::new(b.reborrow(), Pull::Down);
         // no pull, the status is undefined
 
-        let mut a = OutputOpenDrain::new(&mut a, Level::Low, Speed::Low, Pull::None);
+        let mut a = OutputOpenDrain::new(a.reborrow(), Level::Low, Speed::Low);
         delay();
         assert!(b.is_low());
         a.set_high(); // High-Z output
@@ -124,12 +124,12 @@ async fn main(_spawner: Spawner) {
     // Test initial output
     {
         //Flex pin configured as input
-        let mut b = Flex::new(&mut b);
+        let mut b = Flex::new(b.reborrow());
         b.set_as_input(Pull::None);
 
         {
             //Flex pin configured as output
-            let mut a = Flex::new(&mut a); //Flex pin configured as output
+            let mut a = Flex::new(a.reborrow()); //Flex pin configured as output
             a.set_low(); // Pin state must be set before configuring the pin, thus we avoid unknown state
             a.set_as_output(Speed::Low);
             delay();
@@ -137,7 +137,7 @@ async fn main(_spawner: Spawner) {
         }
         {
             //Flex pin configured as output
-            let mut a = Flex::new(&mut a);
+            let mut a = Flex::new(a.reborrow());
             a.set_high();
             a.set_as_output(Speed::Low);
 
@@ -148,10 +148,10 @@ async fn main(_spawner: Spawner) {
 
     // Test input no pull
     {
-        let mut b = Flex::new(&mut b);
+        let mut b = Flex::new(b.reborrow());
         b.set_as_input(Pull::None); // no pull, the status is undefined
 
-        let mut a = Flex::new(&mut a);
+        let mut a = Flex::new(a.reborrow());
         a.set_low();
         a.set_as_output(Speed::Low);
 
@@ -164,12 +164,12 @@ async fn main(_spawner: Spawner) {
 
     // Test input pulldown
     {
-        let mut b = Flex::new(&mut b);
+        let mut b = Flex::new(b.reborrow());
         b.set_as_input(Pull::Down);
         delay();
         assert!(b.is_low());
 
-        let mut a = Flex::new(&mut a);
+        let mut a = Flex::new(a.reborrow());
         a.set_low();
         a.set_as_output(Speed::Low);
         delay();
@@ -181,12 +181,12 @@ async fn main(_spawner: Spawner) {
 
     // Test input pullup
     {
-        let mut b = Flex::new(&mut b);
+        let mut b = Flex::new(b.reborrow());
         b.set_as_input(Pull::Up);
         delay();
         assert!(b.is_high());
 
-        let mut a = Flex::new(&mut a);
+        let mut a = Flex::new(a.reborrow());
         a.set_high();
         a.set_as_output(Speed::Low);
         delay();
@@ -198,12 +198,12 @@ async fn main(_spawner: Spawner) {
 
     // Test output open drain
     {
-        let mut b = Flex::new(&mut b);
+        let mut b = Flex::new(b.reborrow());
         b.set_as_input(Pull::Down);
 
-        let mut a = Flex::new(&mut a);
+        let mut a = Flex::new(a.reborrow());
         a.set_low();
-        a.set_as_input_output(Speed::Low, Pull::None);
+        a.set_as_input_output(Speed::Low);
         delay();
         assert!(b.is_low());
         a.set_high(); // High-Z output
diff --git a/tests/stm32/src/bin/hash.rs b/tests/stm32/src/bin/hash.rs
index 5f54ea435..bb08d0cf1 100644
--- a/tests/stm32/src/bin/hash.rs
+++ b/tests/stm32/src/bin/hash.rs
@@ -6,8 +6,8 @@
 mod common;
 use common::*;
 use embassy_executor::Spawner;
-use embassy_stm32::dma::NoDma;
 use embassy_stm32::hash::*;
+use embassy_stm32::mode::Blocking;
 use embassy_stm32::{bind_interrupts, hash, peripherals};
 use hmac::{Hmac, Mac};
 use sha2::{Digest, Sha224, Sha256};
@@ -33,11 +33,7 @@ bind_interrupts!(struct Irqs {
     HASH => hash::InterruptHandler<peripherals::HASH>;
 });
 
-#[embassy_executor::main]
-async fn main(_spawner: Spawner) {
-    let p: embassy_stm32::Peripherals = embassy_stm32::init(config());
-    let mut hw_hasher = Hash::new(p.HASH, NoDma, Irqs);
-
+fn test_interrupt(hw_hasher: &mut Hash<'_, peripherals::HASH, Blocking>) {
     let test_1: &[u8] = b"as;dfhaslfhas;oifvnasd;nifvnhasd;nifvhndlkfghsd;nvfnahssdfgsdafgsasdfasdfasdfasdfasdfghjklmnbvcalskdjghalskdjgfbaslkdjfgbalskdjgbalskdjbdfhsdfhsfghsfghfgh";
     let test_2: &[u8] = b"fdhalksdjfhlasdjkfhalskdjfhgal;skdjfgalskdhfjgalskdjfglafgadfgdfgdafgaadsfgfgdfgadrgsyfthxfgjfhklhjkfgukhulkvhlvhukgfhfsrghzdhxyfufynufyuszeradrtydyytserr";
     let test_3: &[u8] = b"a.ewtkluGWEBR.KAJRBTA,RMNRBG,FDMGB.kger.tkasjrbt.akrjtba.krjtba.ktmyna,nmbvtyliasd;gdrtba,sfvs.kgjzshd.gkbsr.tksejb.SDkfBSE.gkfgb>ESkfbSE>gkJSBESE>kbSE>fk";
@@ -96,6 +92,47 @@ async fn main(_spawner: Spawner) {
     info!("Hardware HMAC: {:?}", hw_hmac);
     info!("Software HMAC: {:?}", sw_hmac[..]);
     defmt::assert!(hw_hmac == sw_hmac[..]);
+}
+
+// This uses sha512, so only supported on hash_v3 and up
+#[cfg(feature = "hash-v34")]
+fn test_sizes(hw_hasher: &mut Hash<'_, peripherals::HASH, Blocking>) {
+    let in1 = b"4BPuGudaDK";
+    let in2 = b"cfFIGf0XSNhFBQ5LaIqzjnRKDRkoWweJI06HLUcicIUGjpuDNfOTQNSrRxDoveDPlazeZtt06SIYO5CvHvsJ98XSfO9yJEMHoDpDAmNQtwZOPlKmdiagRXsJ7w7IjdKpQH6I2t";
+
+    for i in 1..10 {
+        // sha512 block size is 128, so test around there
+        for j in [1, 1, 2, 3, 4, 5, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133] {
+            info!("test_sizes i {} j {}", i, j);
+            let mut sw = sha2::Sha512::new();
+            let mut ctx = hw_hasher.start(Algorithm::SHA512, DataType::Width8, None);
+
+            sw.update(&in1[..i]);
+            sw.update(&in2[..j]);
+            hw_hasher.update_blocking(&mut ctx, &in1[..i]);
+            hw_hasher.update_blocking(&mut ctx, &in2[..j]);
+
+            let sw_digest = sw.finalize();
+            let mut hw_digest = [0u8; 64];
+            hw_hasher.finish_blocking(ctx, &mut hw_digest);
+            info!("Hardware: {:?}", hw_digest);
+            info!("Software: {:?}", sw_digest[..]);
+            defmt::assert!(hw_digest == *sw_digest);
+        }
+    }
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p: embassy_stm32::Peripherals = init();
+    let mut hw_hasher = Hash::new_blocking(p.HASH, Irqs);
+
+    test_interrupt(&mut hw_hasher);
+    // Run it a second time to check hash-after-hmac
+    test_interrupt(&mut hw_hasher);
+
+    #[cfg(feature = "hash-v34")]
+    test_sizes(&mut hw_hasher);
 
     info!("Test OK");
     cortex_m::asm::bkpt();
diff --git a/tests/stm32/src/bin/hsem.rs b/tests/stm32/src/bin/hsem.rs
new file mode 100644
index 000000000..fa69f22b2
--- /dev/null
+++ b/tests/stm32/src/bin/hsem.rs
@@ -0,0 +1,50 @@
+// required-features: hsem
+#![no_std]
+#![no_main]
+
+#[path = "../common.rs"]
+mod common;
+
+use common::*;
+use embassy_executor::Spawner;
+use embassy_stm32::bind_interrupts;
+use embassy_stm32::hsem::{HardwareSemaphore, HardwareSemaphoreInterruptHandler};
+use embassy_stm32::peripherals::HSEM;
+
+bind_interrupts!(struct Irqs{
+    HSEM => HardwareSemaphoreInterruptHandler<HSEM>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p: embassy_stm32::Peripherals = init();
+
+    let hsem = HardwareSemaphore::new(p.HSEM, Irqs);
+
+    //    if hsem.channel_for(SemaphoreNumber::Channel5).is_semaphore_locked() {
+    //        defmt::panic!("Semaphore 5 already locked!")
+    //    }
+    //
+    //    hsem.channel_for(SemaphoreNumber::Channel5).one_step_lock().unwrap();
+    //    hsem.channel_for(SemaphoreNumber::Channel1).two_step_lock(0).unwrap();
+    //
+    //    hsem.channel_for(SemaphoreNumber::Channel5).unlock(0);
+
+    #[cfg(feature = "stm32wb55rg")]
+    let [_channel1, _channel2, mut channel5, _channel6] = hsem.split();
+    #[cfg(not(feature = "stm32wb55rg"))]
+    let [_channel1, _channel2, _channel3, _channel4, mut channel5, _channel6] = hsem.split();
+
+    info!("Locking channel 5");
+
+    let mutex = channel5.lock(0).await;
+
+    info!("Locked channel 5");
+
+    drop(mutex);
+
+    info!("Unlocked channel 5");
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/stm32/src/bin/rng.rs b/tests/stm32/src/bin/rng.rs
index 15ef4fb60..8438353a8 100644
--- a/tests/stm32/src/bin/rng.rs
+++ b/tests/stm32/src/bin/rng.rs
@@ -41,7 +41,7 @@ bind_interrupts!(struct Irqs {
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let p: embassy_stm32::Peripherals = embassy_stm32::init(config());
+    let p: embassy_stm32::Peripherals = init();
 
     let mut rng = Rng::new(p.RNG, Irqs);
 
diff --git a/tests/stm32/src/bin/rtc.rs b/tests/stm32/src/bin/rtc.rs
index c04d616ac..eb27af4ca 100644
--- a/tests/stm32/src/bin/rtc.rs
+++ b/tests/stm32/src/bin/rtc.rs
@@ -10,15 +10,21 @@ use common::*;
 use defmt::assert;
 use embassy_executor::Spawner;
 use embassy_stm32::rcc::LsConfig;
+#[cfg(feature = "stop")]
+use embassy_stm32::rtc::Rtc;
+#[cfg(not(feature = "stop"))]
 use embassy_stm32::rtc::{Rtc, RtcConfig};
 use embassy_time::Timer;
-
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let mut config = config();
     config.rcc.ls = LsConfig::default_lse();
+    #[cfg(feature = "stop")]
+    {
+        config.rtc._disable_rtc = false;
+    }
 
-    let p = embassy_stm32::init(config);
+    let p = init_with_config(config);
     info!("Hello World!");
 
     let now = NaiveDate::from_ymd_opt(2020, 5, 15)
@@ -26,14 +32,25 @@ async fn main(_spawner: Spawner) {
         .and_hms_opt(10, 30, 15)
         .unwrap();
 
-    let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
+    #[cfg(not(feature = "stop"))]
+    let (mut rtc, time_provider) = Rtc::new(p.RTC, RtcConfig::default());
+
+    #[cfg(feature = "stop")]
+    let (rtc, time_provider) = Rtc::new(p.RTC);
 
+    #[cfg(not(feature = "stop"))]
     rtc.set_datetime(now.into()).expect("datetime not set");
 
+    #[cfg(feature = "stop")]
+    critical_section::with(|cs| {
+        rtc.borrow_mut(cs).set_datetime(now.into()).expect("datetime not set");
+    });
+
     info!("Waiting 5 seconds");
     Timer::after_millis(5000).await;
 
-    let then: NaiveDateTime = rtc.now().unwrap().into();
+    let then: NaiveDateTime = time_provider.now().unwrap().into();
+
     let seconds = (then - now).num_seconds();
 
     info!("measured = {}", seconds);
diff --git a/tests/stm32/src/bin/sdmmc.rs b/tests/stm32/src/bin/sdmmc.rs
index 54f55d2d6..9f9c526e1 100644
--- a/tests/stm32/src/bin/sdmmc.rs
+++ b/tests/stm32/src/bin/sdmmc.rs
@@ -20,7 +20,7 @@ bind_interrupts!(struct Irqs {
 async fn main(_spawner: Spawner) {
     info!("Hello World!");
 
-    let p = embassy_stm32::init(config());
+    let p = init();
 
     let (mut sdmmc, mut dma, mut clk, mut cmd, mut d0, mut d1, mut d2, mut d3) =
         (p.SDIO, p.DMA2_CH3, p.PC12, p.PD2, p.PC8, p.PC9, p.PC10, p.PC11);
@@ -34,27 +34,29 @@ async fn main(_spawner: Spawner) {
         pattern1[i] = i as u8;
         pattern2[i] = !i as u8;
     }
+    let patterns = [pattern1.clone(), pattern2.clone()];
 
     let mut block = DataBlock([0u8; 512]);
+    let mut blocks = [DataBlock([0u8; 512]), DataBlock([0u8; 512])];
 
     // ======== Try 4bit. ==============
     info!("initializing in 4-bit mode...");
     let mut s = Sdmmc::new_4bit(
-        &mut sdmmc,
+        sdmmc.reborrow(),
         Irqs,
-        &mut dma,
-        &mut clk,
-        &mut cmd,
-        &mut d0,
-        &mut d1,
-        &mut d2,
-        &mut d3,
+        dma.reborrow(),
+        clk.reborrow(),
+        cmd.reborrow(),
+        d0.reborrow(),
+        d1.reborrow(),
+        d2.reborrow(),
+        d3.reborrow(),
         Default::default(),
     );
 
     let mut err = None;
     loop {
-        match s.init_card(mhz(24)).await {
+        match s.init_sd_card(mhz(24)).await {
             Ok(_) => break,
             Err(e) => {
                 if err != Some(e) {
@@ -84,23 +86,33 @@ async fn main(_spawner: Spawner) {
     s.read_block(block_idx, &mut block).await.unwrap();
     assert_eq!(block, pattern2);
 
+    info!("writing blocks [pattern1, pattern2]...");
+    s.write_blocks(block_idx, &patterns).await.unwrap();
+
+    info!("reading blocks...");
+    s.read_blocks(block_idx, &mut blocks).await.unwrap();
+    assert_eq!(&blocks, &patterns);
+
     drop(s);
 
+    // FIXME: this hangs on Rust 1.86 and higher.
+    // I haven't been able to figure out why.
+    /*
     // ======== Try 1bit. ==============
     info!("initializing in 1-bit mode...");
     let mut s = Sdmmc::new_1bit(
-        &mut sdmmc,
+        sdmmc.reborrow(),
         Irqs,
-        &mut dma,
-        &mut clk,
-        &mut cmd,
-        &mut d0,
+        dma.reborrow(),
+        clk.reborrow(),
+        cmd.reborrow(),
+        d0.reborrow(),
         Default::default(),
     );
 
     let mut err = None;
     loop {
-        match s.init_card(mhz(24)).await {
+        match s.init_sd_card(mhz(24)).await {
             Ok(_) => break,
             Err(e) => {
                 if err != Some(e) {
@@ -116,9 +128,9 @@ async fn main(_spawner: Spawner) {
     info!("Card: {:#?}", Debug2Format(card));
     info!("Clock: {}", s.clock());
 
-    info!("reading pattern2 written in 4bit mode...");
+    info!("reading pattern1 written in 4bit mode...");
     s.read_block(block_idx, &mut block).await.unwrap();
-    assert_eq!(block, pattern2);
+    assert_eq!(block, pattern1);
 
     info!("writing pattern1...");
     s.write_block(block_idx, &pattern1).await.unwrap();
@@ -134,7 +146,15 @@ async fn main(_spawner: Spawner) {
     s.read_block(block_idx, &mut block).await.unwrap();
     assert_eq!(block, pattern2);
 
+    info!("writing blocks [pattern1, pattern2]...");
+    s.write_blocks(block_idx, &patterns).await.unwrap();
+
+    info!("reading blocks...");
+    s.read_blocks(block_idx, &mut blocks).await.unwrap();
+    assert_eq!(&blocks, &patterns);
+
     drop(s);
+    */
 
     info!("Test OK");
     cortex_m::asm::bkpt();
diff --git a/tests/stm32/src/bin/spi.rs b/tests/stm32/src/bin/spi.rs
index 0ffd0f653..cedff772c 100644
--- a/tests/stm32/src/bin/spi.rs
+++ b/tests/stm32/src/bin/spi.rs
@@ -7,12 +7,14 @@ use common::*;
 use defmt::assert_eq;
 use embassy_executor::Spawner;
 use embassy_stm32::gpio::{Level, Output, Speed};
-use embassy_stm32::spi::{self, Spi};
+use embassy_stm32::mode::Blocking;
+use embassy_stm32::spi::mode::Master;
+use embassy_stm32::spi::{self, Spi, Word};
 use embassy_stm32::time::Hertz;
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let p = embassy_stm32::init(config());
+    let p = init();
     info!("Hello World!");
 
     let mut spi_peri = peri!(p, SPI);
@@ -24,18 +26,65 @@ async fn main(_spawner: Spawner) {
     spi_config.frequency = Hertz(1_000_000);
 
     let mut spi = Spi::new_blocking(
-        &mut spi_peri,
-        &mut sck,  // Arduino D13
-        &mut mosi, // Arduino D11
-        &mut miso, // Arduino D12
+        spi_peri.reborrow(),
+        sck.reborrow(),  // Arduino D13
+        mosi.reborrow(), // Arduino D11
+        miso.reborrow(), // Arduino D12
         spi_config,
     );
 
-    let data: [u8; 9] = [0x00, 0xFF, 0xAA, 0x55, 0xC0, 0xFF, 0xEE, 0xC0, 0xDE];
+    test_txrx::<u8>(&mut spi);
+    test_txrx::<u16>(&mut spi);
+
+    // Assert the RCC bit gets disabled on drop.
+    #[cfg(feature = "stm32f429zi")]
+    defmt::assert!(embassy_stm32::pac::RCC.apb2enr().read().spi1en());
+    drop(spi);
+    #[cfg(feature = "stm32f429zi")]
+    defmt::assert!(!embassy_stm32::pac::RCC.apb2enr().read().spi1en());
+
+    // test rx-only configuration
+    let mut spi = Spi::new_blocking_rxonly(spi_peri.reborrow(), sck.reborrow(), miso.reborrow(), spi_config);
+    let mut mosi_out = Output::new(mosi.reborrow(), Level::Low, Speed::VeryHigh);
+
+    test_rx::<u8>(&mut spi, &mut mosi_out);
+    test_rx::<u16>(&mut spi, &mut mosi_out);
+    drop(spi);
+    drop(mosi_out);
+
+    let mut spi = Spi::new_blocking_txonly(spi_peri.reborrow(), sck.reborrow(), mosi.reborrow(), spi_config);
+    test_tx::<u8>(&mut spi);
+    test_tx::<u16>(&mut spi);
+    drop(spi);
+
+    let mut spi = Spi::new_blocking_txonly_nosck(spi_peri.reborrow(), mosi.reborrow(), spi_config);
+    test_tx::<u8>(&mut spi);
+    test_tx::<u16>(&mut spi);
+    drop(spi);
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
+
+fn test_txrx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Blocking, Master>)
+where
+    W: core::ops::Not<Output = W>,
+{
+    let data: [W; 9] = [
+        0x00u8.into(),
+        0xFFu8.into(),
+        0xAAu8.into(),
+        0x55u8.into(),
+        0xC0u8.into(),
+        0xFFu8.into(),
+        0xEEu8.into(),
+        0xC0u8.into(),
+        0xDEu8.into(),
+    ];
 
     // Arduino pins D11 and D12 (MOSI-MISO) are connected together with a 1K resistor.
     // so we should get the data we sent back.
-    let mut buf = [0; 9];
+    let mut buf = [W::default(); 9];
     spi.blocking_transfer(&mut buf, &data).unwrap();
     assert_eq!(buf, data);
 
@@ -59,47 +108,33 @@ async fn main(_spawner: Spawner) {
     spi.blocking_transfer_in_place::<u8>(&mut []).unwrap();
     spi.blocking_read::<u8>(&mut []).unwrap();
     spi.blocking_write::<u8>(&[]).unwrap();
+}
 
-    // Assert the RCC bit gets disabled on drop.
-    #[cfg(feature = "stm32f429zi")]
-    defmt::assert!(embassy_stm32::pac::RCC.apb2enr().read().spi1en());
-    drop(spi);
-    #[cfg(feature = "stm32f429zi")]
-    defmt::assert!(!embassy_stm32::pac::RCC.apb2enr().read().spi1en());
+fn test_rx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Blocking, Master>, mosi_out: &mut Output<'_>)
+where
+    W: core::ops::Not<Output = W>,
+{
+    let mut buf = [W::default(); 9];
 
-    // test rx-only configuration
-    let mut spi = Spi::new_blocking_rxonly(&mut spi_peri, &mut sck, &mut miso, spi_config);
-    let mut mosi_out = Output::new(&mut mosi, Level::Low, Speed::VeryHigh);
     mosi_out.set_high();
     spi.blocking_read(&mut buf).unwrap();
-    assert_eq!(buf, [0xff; 9]);
+    assert_eq!(buf, [!W::default(); 9]);
     mosi_out.set_low();
     spi.blocking_read(&mut buf).unwrap();
-    assert_eq!(buf, [0x00; 9]);
+    assert_eq!(buf, [W::default(); 9]);
     spi.blocking_read::<u8>(&mut []).unwrap();
     spi.blocking_read::<u8>(&mut []).unwrap();
-    drop(mosi_out);
-    drop(spi);
+}
+
+fn test_tx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Blocking, Master>)
+where
+    W: core::ops::Not<Output = W>,
+{
+    let buf = [W::default(); 9];
 
     // Test tx-only. Just check it doesn't hang, not much else we can do without using SPI slave.
-    let mut spi = Spi::new_blocking_txonly(&mut spi_peri, &mut sck, &mut mosi, spi_config);
-    spi.blocking_transfer(&mut buf, &data).unwrap();
-    spi.blocking_transfer_in_place(&mut buf).unwrap();
     spi.blocking_write(&buf).unwrap();
-    spi.blocking_read(&mut buf).unwrap();
-    spi.blocking_transfer::<u8>(&mut [], &[]).unwrap();
-    spi.blocking_transfer_in_place::<u8>(&mut []).unwrap();
-    spi.blocking_read::<u8>(&mut []).unwrap();
     spi.blocking_write::<u8>(&[]).unwrap();
-    drop(spi);
-
-    // Test tx-only nosck.
-    let mut spi = Spi::new_blocking_txonly_nosck(&mut spi_peri, &mut mosi, spi_config);
     spi.blocking_write(&buf).unwrap();
     spi.blocking_write::<u8>(&[]).unwrap();
-    spi.blocking_write(&buf).unwrap();
-    drop(spi);
-
-    info!("Test OK");
-    cortex_m::asm::bkpt();
 }
diff --git a/tests/stm32/src/bin/spi_dma.rs b/tests/stm32/src/bin/spi_dma.rs
index fd26d3f71..c8cd92401 100644
--- a/tests/stm32/src/bin/spi_dma.rs
+++ b/tests/stm32/src/bin/spi_dma.rs
@@ -7,12 +7,14 @@ use common::*;
 use defmt::assert_eq;
 use embassy_executor::Spawner;
 use embassy_stm32::gpio::{Level, Output, Speed};
-use embassy_stm32::spi::{self, Spi};
+use embassy_stm32::mode::Async;
+use embassy_stm32::spi::mode::Master;
+use embassy_stm32::spi::{self, Spi, Word};
 use embassy_stm32::time::Hertz;
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let p = embassy_stm32::init(config());
+    let p = init();
     info!("Hello World!");
 
     let mut spi_peri = peri!(p, SPI);
@@ -26,20 +28,76 @@ async fn main(_spawner: Spawner) {
     spi_config.frequency = Hertz(1_000_000);
 
     let mut spi = Spi::new(
-        &mut spi_peri,
-        &mut sck,  // Arduino D13
-        &mut mosi, // Arduino D11
-        &mut miso, // Arduino D12
-        &mut tx_dma,
-        &mut rx_dma,
+        spi_peri.reborrow(),
+        sck.reborrow(),  // Arduino D13
+        mosi.reborrow(), // Arduino D11
+        miso.reborrow(), // Arduino D12
+        tx_dma.reborrow(),
+        rx_dma.reborrow(),
         spi_config,
     );
 
-    let data: [u8; 9] = [0x00, 0xFF, 0xAA, 0x55, 0xC0, 0xFF, 0xEE, 0xC0, 0xDE];
+    test_txrx::<u8>(&mut spi).await;
+    test_txrx::<u16>(&mut spi).await;
+    drop(spi);
+
+    // test rx-only configuration
+    let mut spi = Spi::new_rxonly(
+        spi_peri.reborrow(),
+        sck.reborrow(),
+        miso.reborrow(),
+        // SPIv1/f1 requires txdma even if rxonly.
+        #[cfg(not(feature = "spi-v345"))]
+        tx_dma.reborrow(),
+        rx_dma.reborrow(),
+        spi_config,
+    );
+    let mut mosi_out = Output::new(mosi.reborrow(), Level::Low, Speed::VeryHigh);
+
+    test_rx::<u8>(&mut spi, &mut mosi_out).await;
+    test_rx::<u16>(&mut spi, &mut mosi_out).await;
+    drop(spi);
+    drop(mosi_out);
+
+    let mut spi = Spi::new_txonly(
+        spi_peri.reborrow(),
+        sck.reborrow(),
+        mosi.reborrow(),
+        tx_dma.reborrow(),
+        spi_config,
+    );
+    test_tx::<u8>(&mut spi).await;
+    test_tx::<u16>(&mut spi).await;
+    drop(spi);
+
+    let mut spi = Spi::new_txonly_nosck(spi_peri.reborrow(), mosi.reborrow(), tx_dma.reborrow(), spi_config);
+    test_tx::<u8>(&mut spi).await;
+    test_tx::<u16>(&mut spi).await;
+    drop(spi);
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
+
+async fn test_txrx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Async, Master>)
+where
+    W: core::ops::Not<Output = W>,
+{
+    let data: [W; 9] = [
+        0x00u8.into(),
+        0xFFu8.into(),
+        0xAAu8.into(),
+        0x55u8.into(),
+        0xC0u8.into(),
+        0xFFu8.into(),
+        0xEEu8.into(),
+        0xC0u8.into(),
+        0xDEu8.into(),
+    ];
 
     // Arduino pins D11 and D12 (MOSI-MISO) are connected together with a 1K resistor.
     // so we should get the data we sent back.
-    let mut buf = [0; 9];
+    let mut buf = [W::default(); 9];
     spi.transfer(&mut buf, &data).await.unwrap();
     assert_eq!(buf, data);
 
@@ -83,56 +141,41 @@ async fn main(_spawner: Spawner) {
     spi.blocking_write(&buf).unwrap();
     spi.blocking_read(&mut buf).unwrap();
     spi.write(&buf).await.unwrap();
+}
 
-    core::mem::drop(spi);
+async fn test_rx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Async, Master>, mosi_out: &mut Output<'_>)
+where
+    W: core::ops::Not<Output = W>,
+{
+    let mut buf = [W::default(); 9];
 
-    // test rx-only configuration
-    let mut spi = Spi::new_rxonly(
-        &mut spi_peri,
-        &mut sck,
-        &mut miso,
-        // SPIv1/f1 requires txdma even if rxonly.
-        #[cfg(not(feature = "spi-v345"))]
-        &mut tx_dma,
-        &mut rx_dma,
-        spi_config,
-    );
-    let mut mosi_out = Output::new(&mut mosi, Level::Low, Speed::VeryHigh);
     mosi_out.set_high();
     spi.read(&mut buf).await.unwrap();
-    assert_eq!(buf, [0xff; 9]);
+    assert_eq!(buf, [!W::default(); 9]);
     spi.blocking_read(&mut buf).unwrap();
-    assert_eq!(buf, [0xff; 9]);
+    assert_eq!(buf, [!W::default(); 9]);
     spi.read(&mut buf).await.unwrap();
-    assert_eq!(buf, [0xff; 9]);
+    assert_eq!(buf, [!W::default(); 9]);
     spi.read(&mut buf).await.unwrap();
-    assert_eq!(buf, [0xff; 9]);
+    assert_eq!(buf, [!W::default(); 9]);
     spi.blocking_read(&mut buf).unwrap();
-    assert_eq!(buf, [0xff; 9]);
+    assert_eq!(buf, [!W::default(); 9]);
     spi.blocking_read(&mut buf).unwrap();
-    assert_eq!(buf, [0xff; 9]);
+    assert_eq!(buf, [!W::default(); 9]);
     mosi_out.set_low();
     spi.read(&mut buf).await.unwrap();
-    assert_eq!(buf, [0x00; 9]);
+    assert_eq!(buf, [W::default(); 9]);
     spi.read::<u8>(&mut []).await.unwrap();
     spi.blocking_read::<u8>(&mut []).unwrap();
-    drop(mosi_out);
-    drop(spi);
+}
 
-    // Test tx-only. Just check it doesn't hang, not much else we can do without using SPI slave.
-    let mut spi = Spi::new_txonly(&mut spi_peri, &mut sck, &mut mosi, &mut tx_dma, spi_config);
-    spi.blocking_write(&buf).unwrap();
-    spi.write(&buf).await.unwrap();
-    spi.blocking_write(&buf).unwrap();
-    spi.blocking_write(&buf).unwrap();
-    spi.write(&buf).await.unwrap();
-    spi.write(&buf).await.unwrap();
-    spi.write::<u8>(&[]).await.unwrap();
-    spi.blocking_write::<u8>(&[]).unwrap();
-    drop(spi);
+async fn test_tx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Async, Master>)
+where
+    W: core::ops::Not<Output = W>,
+{
+    let buf = [W::default(); 9];
 
-    // Test tx-only nosck.
-    let mut spi = Spi::new_txonly_nosck(&mut spi_peri, &mut mosi, &mut tx_dma, spi_config);
+    // Test tx-only. Just check it doesn't hang, not much else we can do without using SPI slave.
     spi.blocking_write(&buf).unwrap();
     spi.write(&buf).await.unwrap();
     spi.blocking_write(&buf).unwrap();
@@ -141,8 +184,4 @@ async fn main(_spawner: Spawner) {
     spi.write(&buf).await.unwrap();
     spi.write::<u8>(&[]).await.unwrap();
     spi.blocking_write::<u8>(&[]).unwrap();
-    drop(spi);
-
-    info!("Test OK");
-    cortex_m::asm::bkpt();
 }
diff --git a/tests/stm32/src/bin/stop.rs b/tests/stm32/src/bin/stop.rs
index c1106bb2f..83c375bc5 100644
--- a/tests/stm32/src/bin/stop.rs
+++ b/tests/stm32/src/bin/stop.rs
@@ -7,21 +7,12 @@ mod common;
 
 use chrono::NaiveDate;
 use common::*;
-use cortex_m_rt::entry;
 use embassy_executor::Spawner;
-use embassy_stm32::low_power::{stop_ready, stop_with_rtc, Executor, StopMode};
+use embassy_stm32::low_power::{StopMode, stop_ready};
 use embassy_stm32::rcc::LsConfig;
-use embassy_stm32::rtc::{Rtc, RtcConfig};
-use embassy_stm32::Config;
+use embassy_stm32::rtc::Rtc;
+use embassy_stm32::{Config, low_power};
 use embassy_time::Timer;
-use static_cell::StaticCell;
-
-#[entry]
-fn main() -> ! {
-    Executor::take().run(|spawner| {
-        unwrap!(spawner.spawn(async_main(spawner)));
-    });
-}
 
 #[embassy_executor::task]
 async fn task_1() {
@@ -44,12 +35,13 @@ async fn task_2() {
     cortex_m::asm::bkpt();
 }
 
-#[embassy_executor::task]
+#[embassy_executor::main(executor = "low_power::Executor")]
 async fn async_main(spawner: Spawner) {
     let _ = config();
 
     let mut config = Config::default();
     config.rcc.ls = LsConfig::default_lse();
+    config.rtc._disable_rtc = false;
 
     // System Clock seems cannot be greater than 16 MHz
     #[cfg(any(feature = "stm32h563zi", feature = "stm32h503rb"))]
@@ -58,7 +50,7 @@ async fn async_main(spawner: Spawner) {
         config.rcc.hsi = Some(HSIPrescaler::DIV4); // 64 MHz HSI will need a /4
     }
 
-    let p = embassy_stm32::init(config);
+    let p = init_with_config(config);
     info!("Hello World!");
 
     let now = NaiveDate::from_ymd_opt(2020, 5, 15)
@@ -66,15 +58,12 @@ async fn async_main(spawner: Spawner) {
         .and_hms_opt(10, 30, 15)
         .unwrap();
 
-    let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
+    let (rtc, _time_provider) = Rtc::new(p.RTC);
 
-    rtc.set_datetime(now.into()).expect("datetime not set");
-
-    static RTC: StaticCell<Rtc> = StaticCell::new();
-    let rtc = RTC.init(rtc);
-
-    stop_with_rtc(rtc);
+    critical_section::with(|cs| {
+        rtc.borrow_mut(cs).set_datetime(now.into()).expect("datetime not set");
+    });
 
-    spawner.spawn(task_1()).unwrap();
-    spawner.spawn(task_2()).unwrap();
+    spawner.spawn(task_1().unwrap());
+    spawner.spawn(task_2().unwrap());
 }
diff --git a/tests/stm32/src/bin/timer.rs b/tests/stm32/src/bin/timer.rs
index d86f54ad2..8719e7670 100644
--- a/tests/stm32/src/bin/timer.rs
+++ b/tests/stm32/src/bin/timer.rs
@@ -10,7 +10,7 @@ use embassy_time::{Instant, Timer};
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let _p = embassy_stm32::init(config());
+    let _p = init();
     info!("Hello World!");
 
     let start = Instant::now();
diff --git a/tests/stm32/src/bin/ucpd.rs b/tests/stm32/src/bin/ucpd.rs
index c09334ec8..c794afff8 100644
--- a/tests/stm32/src/bin/ucpd.rs
+++ b/tests/stm32/src/bin/ucpd.rs
@@ -9,7 +9,7 @@ use defmt::{assert, assert_eq};
 use embassy_executor::Spawner;
 use embassy_futures::join::join;
 use embassy_stm32::ucpd::{self, CcPhy, CcPull, CcSel, CcVState, RxError, Ucpd};
-use embassy_stm32::{bind_interrupts, peripherals};
+use embassy_stm32::{Peri, bind_interrupts, peripherals};
 use embassy_time::Timer;
 
 bind_interrupts!(struct Irqs {
@@ -28,8 +28,8 @@ async fn wait_for_vstate<T: ucpd::Instance>(cc_phy: &mut CcPhy<'_, T>, vstate: C
 
 async fn source(
     mut ucpd: Ucpd<'static, peripherals::UCPD1>,
-    rx_dma: peripherals::DMA1_CH1,
-    tx_dma: peripherals::DMA1_CH2,
+    rx_dma: Peri<'static, peripherals::DMA1_CH1>,
+    tx_dma: Peri<'static, peripherals::DMA1_CH2>,
 ) {
     debug!("source: setting default current pull-up");
     ucpd.cc_phy().set_pull(CcPull::SourceDefaultUsb);
@@ -65,8 +65,8 @@ async fn source(
 
 async fn sink(
     mut ucpd: Ucpd<'static, peripherals::UCPD2>,
-    rx_dma: peripherals::DMA1_CH3,
-    tx_dma: peripherals::DMA1_CH4,
+    rx_dma: Peri<'static, peripherals::DMA1_CH3>,
+    tx_dma: Peri<'static, peripherals::DMA1_CH4>,
 ) {
     debug!("sink: setting pull down");
     ucpd.cc_phy().set_pull(CcPull::Sink);
@@ -102,12 +102,12 @@ async fn sink(
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let p = embassy_stm32::init(config());
+    let p = init();
     info!("Hello World!");
 
     // Wire between PD0 and PA8
-    let ucpd1 = Ucpd::new(p.UCPD1, Irqs {}, p.PA8, p.PB15);
-    let ucpd2 = Ucpd::new(p.UCPD2, Irqs {}, p.PD0, p.PD2);
+    let ucpd1 = Ucpd::new(p.UCPD1, Irqs {}, p.PA8, p.PB15, Default::default());
+    let ucpd2 = Ucpd::new(p.UCPD2, Irqs {}, p.PD0, p.PD2, Default::default());
 
     join(
         source(ucpd1, p.DMA1_CH1, p.DMA1_CH2),
diff --git a/tests/stm32/src/bin/usart.rs b/tests/stm32/src/bin/usart.rs
index a6e34674d..0b98d3eeb 100644
--- a/tests/stm32/src/bin/usart.rs
+++ b/tests/stm32/src/bin/usart.rs
@@ -7,11 +7,11 @@ use common::*;
 use defmt::{assert, assert_eq, unreachable};
 use embassy_executor::Spawner;
 use embassy_stm32::usart::{Config, ConfigError, Error, Uart};
-use embassy_time::{block_for, Duration, Instant};
+use embassy_time::{Duration, Instant, block_for};
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let p = embassy_stm32::init(config());
+    let p = init();
     info!("Hello World!");
 
     // Arduino pins D0 and D1
@@ -22,7 +22,7 @@ async fn main(_spawner: Spawner) {
 
     {
         let config = Config::default();
-        let mut usart = Uart::new_blocking(&mut usart, &mut rx, &mut tx, config).unwrap();
+        let mut usart = Uart::new_blocking(usart.reborrow(), rx.reborrow(), tx.reborrow(), config).unwrap();
 
         // We can't send too many bytes, they have to fit in the FIFO.
         // This is because we aren't sending+receiving at the same time.
@@ -33,12 +33,19 @@ async fn main(_spawner: Spawner) {
         let mut buf = [0; 2];
         usart.blocking_read(&mut buf).unwrap();
         assert_eq!(buf, data);
+
+        // Test flush doesn't hang.
+        usart.blocking_write(&data).unwrap();
+        usart.blocking_flush().unwrap();
+
+        // Test flush doesn't hang if there's nothing to flush
+        usart.blocking_flush().unwrap();
     }
 
     // Test error handling with with an overflow error
     {
         let config = Config::default();
-        let mut usart = Uart::new_blocking(&mut usart, &mut rx, &mut tx, config).unwrap();
+        let mut usart = Uart::new_blocking(usart.reborrow(), rx.reborrow(), tx.reborrow(), config).unwrap();
 
         // Send enough bytes to fill the RX FIFOs off all USART versions.
         let data = [0; 64];
@@ -68,7 +75,7 @@ async fn main(_spawner: Spawner) {
 
         let mut config = Config::default();
         config.baudrate = baudrate;
-        let mut usart = match Uart::new_blocking(&mut usart, &mut rx, &mut tx, config) {
+        let mut usart = match Uart::new_blocking(usart.reborrow(), rx.reborrow(), tx.reborrow(), config) {
             Ok(x) => x,
             Err(ConfigError::BaudrateTooHigh) => {
                 info!("baudrate too high");
diff --git a/tests/stm32/src/bin/usart_dma.rs b/tests/stm32/src/bin/usart_dma.rs
index 24e2b2896..a34498376 100644
--- a/tests/stm32/src/bin/usart_dma.rs
+++ b/tests/stm32/src/bin/usart_dma.rs
@@ -11,7 +11,7 @@ use embassy_stm32::usart::{Config, Uart};
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let p = embassy_stm32::init(config());
+    let p = init();
     info!("Hello World!");
 
     // Arduino pins D0 and D1
@@ -51,6 +51,23 @@ async fn main(_spawner: Spawner) {
         assert_eq!(tx_buf, rx_buf);
     }
 
+    // Test flush doesn't hang. Check multiple combinations of async+blocking.
+    tx.write(&tx_buf).await.unwrap();
+    tx.flush().await.unwrap();
+    tx.flush().await.unwrap();
+
+    tx.write(&tx_buf).await.unwrap();
+    tx.blocking_flush().unwrap();
+    tx.flush().await.unwrap();
+
+    tx.blocking_write(&tx_buf).unwrap();
+    tx.blocking_flush().unwrap();
+    tx.flush().await.unwrap();
+
+    tx.blocking_write(&tx_buf).unwrap();
+    tx.flush().await.unwrap();
+    tx.blocking_flush().unwrap();
+
     info!("Test OK");
     cortex_m::asm::bkpt();
 }
diff --git a/tests/stm32/src/bin/usart_rx_ringbuffered.rs b/tests/stm32/src/bin/usart_rx_ringbuffered.rs
index ea1e52358..15a0b0d60 100644
--- a/tests/stm32/src/bin/usart_rx_ringbuffered.rs
+++ b/tests/stm32/src/bin/usart_rx_ringbuffered.rs
@@ -18,7 +18,7 @@ const DMA_BUF_SIZE: usize = 256;
 
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
-    let p = embassy_stm32::init(config());
+    let p = init();
     info!("Hello World!");
 
     // Arduino pins D0 and D1
@@ -43,12 +43,11 @@ async fn main(spawner: Spawner) {
     let usart = Uart::new(usart, rx, tx, irq, tx_dma, rx_dma, config).unwrap();
     let (tx, rx) = usart.split();
     static mut DMA_BUF: [u8; DMA_BUF_SIZE] = [0; DMA_BUF_SIZE];
-    let dma_buf = unsafe { DMA_BUF.as_mut() };
-    let rx = rx.into_ring_buffered(dma_buf);
+    let rx = rx.into_ring_buffered(unsafe { &mut *core::ptr::addr_of_mut!(DMA_BUF) });
 
     info!("Spawning tasks");
-    spawner.spawn(transmit_task(tx)).unwrap();
-    spawner.spawn(receive_task(rx)).unwrap();
+    spawner.spawn(transmit_task(tx).unwrap());
+    spawner.spawn(receive_task(rx).unwrap());
 }
 
 #[embassy_executor::task]
diff --git a/tests/stm32/src/bin/wpan_ble.rs b/tests/stm32/src/bin/wpan_ble.rs
index 82a540d45..0f396b848 100644
--- a/tests/stm32/src/bin/wpan_ble.rs
+++ b/tests/stm32/src/bin/wpan_ble.rs
@@ -12,16 +12,16 @@ use embassy_executor::Spawner;
 use embassy_stm32::bind_interrupts;
 use embassy_stm32::ipcc::{Config, ReceiveInterruptHandler, TransmitInterruptHandler};
 use embassy_stm32::rcc::WPAN_DEFAULT;
+use embassy_stm32_wpan::TlMbox;
+use embassy_stm32_wpan::hci::BdAddr;
 use embassy_stm32_wpan::hci::host::uart::UartHci;
 use embassy_stm32_wpan::hci::host::{AdvertisingFilterPolicy, EncryptionKey, HostHci, OwnAddressType};
 use embassy_stm32_wpan::hci::types::AdvertisingType;
 use embassy_stm32_wpan::hci::vendor::command::gap::{AdvertisingDataType, DiscoverableParameters, GapCommands, Role};
 use embassy_stm32_wpan::hci::vendor::command::gatt::GattCommands;
 use embassy_stm32_wpan::hci::vendor::command::hal::{ConfigData, HalCommands, PowerLevel};
-use embassy_stm32_wpan::hci::BdAddr;
 use embassy_stm32_wpan::lhci::LhciC1DeviceInformationCcrp;
 use embassy_stm32_wpan::sub::mm;
-use embassy_stm32_wpan::TlMbox;
 use {defmt_rtt as _, panic_probe as _};
 
 bind_interrupts!(struct Irqs{
@@ -41,13 +41,13 @@ async fn main(spawner: Spawner) {
     let mut config = config();
     config.rcc = WPAN_DEFAULT;
 
-    let p = embassy_stm32::init(config);
+    let p = init_with_config(config);
     info!("Hello World!");
 
     let config = Config::default();
     let mut mbox = TlMbox::init(p.IPCC, Irqs, config);
 
-    spawner.spawn(run_mm_queue(mbox.mm_subsystem)).unwrap();
+    spawner.spawn(run_mm_queue(mbox.mm_subsystem).unwrap());
 
     let sys_event = mbox.sys_subsystem.read().await;
     info!("sys event: {}", sys_event.payload());
diff --git a/tests/stm32/src/bin/wpan_mac.rs b/tests/stm32/src/bin/wpan_mac.rs
index fe53b8786..f27146c44 100644
--- a/tests/stm32/src/bin/wpan_mac.rs
+++ b/tests/stm32/src/bin/wpan_mac.rs
@@ -10,13 +10,13 @@ use embassy_executor::Spawner;
 use embassy_stm32::bind_interrupts;
 use embassy_stm32::ipcc::{Config, ReceiveInterruptHandler, TransmitInterruptHandler};
 use embassy_stm32::rcc::WPAN_DEFAULT;
+use embassy_stm32_wpan::TlMbox;
 use embassy_stm32_wpan::mac::commands::{AssociateRequest, GetRequest, ResetRequest, SetRequest};
 use embassy_stm32_wpan::mac::event::MacEvent;
 use embassy_stm32_wpan::mac::typedefs::{
     AddressMode, Capabilities, KeyIdMode, MacAddress, MacChannel, PanId, PibId, SecurityLevel,
 };
 use embassy_stm32_wpan::sub::mm;
-use embassy_stm32_wpan::TlMbox;
 use {defmt_rtt as _, panic_probe as _};
 
 bind_interrupts!(struct Irqs{
@@ -34,13 +34,13 @@ async fn main(spawner: Spawner) {
     let mut config = config();
     config.rcc = WPAN_DEFAULT;
 
-    let p = embassy_stm32::init(config);
+    let p = init_with_config(config);
     info!("Hello World!");
 
     let config = Config::default();
     let mbox = TlMbox::init(p.IPCC, Irqs, config);
 
-    spawner.spawn(run_mm_queue(mbox.mm_subsystem)).unwrap();
+    spawner.spawn(run_mm_queue(mbox.mm_subsystem).unwrap());
 
     let sys_event = mbox.sys_subsystem.read().await;
     info!("sys event: {}", sys_event.payload());
diff --git a/tests/stm32/src/bin/can_common.rs b/tests/stm32/src/can_common.rs
index 4e1740ad5..4e1740ad5 100644
--- a/tests/stm32/src/bin/can_common.rs
+++ b/tests/stm32/src/can_common.rs
diff --git a/tests/stm32/src/common.rs b/tests/stm32/src/common.rs
index 4e0231858..096cce947 100644
--- a/tests/stm32/src/common.rs
+++ b/tests/stm32/src/common.rs
@@ -1,11 +1,11 @@
 #![macro_use]
 
 pub use defmt::*;
+use embassy_stm32::Config;
 #[allow(unused)]
 use embassy_stm32::rcc::*;
 #[allow(unused)]
 use embassy_stm32::time::Hertz;
-use embassy_stm32::Config;
 use {defmt_rtt as _, panic_probe as _};
 
 #[cfg(feature = "stm32f103c8")]
@@ -34,6 +34,8 @@ teleprobe_meta::target!(b"nucleo-stm32u5a5zj");
 teleprobe_meta::target!(b"nucleo-stm32h563zi");
 #[cfg(feature = "stm32c031c6")]
 teleprobe_meta::target!(b"nucleo-stm32c031c6");
+#[cfg(feature = "stm32c071rb")]
+teleprobe_meta::target!(b"nucleo-stm32c071rb");
 #[cfg(feature = "stm32l073rz")]
 teleprobe_meta::target!(b"nucleo-stm32l073rz");
 #[cfg(feature = "stm32l152re")]
@@ -101,7 +103,7 @@ define_peris!(
     SPI = SPI1, SPI_SCK = PA5, SPI_MOSI = PA7, SPI_MISO = PA6, SPI_TX_DMA = DMA1_CH3, SPI_RX_DMA = DMA1_CH2,
     @irq UART = {USART1 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART1>;},
 );
-#[cfg(feature = "stm32f103c8")]
+#[cfg(any(feature = "stm32f100rd", feature = "stm32f103c8", feature = "stm32f107vc"))]
 define_peris!(
     UART = USART1, UART_TX = PA9, UART_RX = PA10, UART_TX_DMA = DMA1_CH4, UART_RX_DMA = DMA1_CH5,
     SPI = SPI1, SPI_SCK = PA5, SPI_MOSI = PA7, SPI_MISO = PA6, SPI_TX_DMA = DMA1_CH3, SPI_RX_DMA = DMA1_CH2,
@@ -186,6 +188,12 @@ define_peris!(
     SPI = SPI1, SPI_SCK = PA5, SPI_MOSI = PA7, SPI_MISO = PA6, SPI_TX_DMA = DMA1_CH1, SPI_RX_DMA = DMA1_CH2,
     @irq UART = {USART1 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART1>;},
 );
+#[cfg(feature = "stm32c071rb")]
+define_peris!(
+    UART = USART1, UART_TX = PB6, UART_RX = PB7, UART_TX_DMA = DMA1_CH1, UART_RX_DMA = DMA1_CH2,
+    SPI = SPI1, SPI_SCK = PA5, SPI_MOSI = PA7, SPI_MISO = PA6, SPI_TX_DMA = DMA1_CH1, SPI_RX_DMA = DMA1_CH2,
+    @irq UART = {USART1 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART1>;},
+);
 #[cfg(feature = "stm32l496zg")]
 define_peris!(
     UART = USART3, UART_TX = PD8, UART_RX = PD9, UART_TX_DMA = DMA1_CH2, UART_RX_DMA = DMA1_CH3,
@@ -271,7 +279,7 @@ pub fn config() -> Config {
     #[allow(unused_mut)]
     let mut config = Config::default();
 
-    #[cfg(feature = "stm32c031c6")]
+    #[cfg(any(feature = "stm32c031c6", feature = "stm32c071rb"))]
     {
         config.rcc.hsi = Some(Hsi {
             sys_div: HsiSysDiv::DIV1, // 48Mhz
@@ -284,7 +292,9 @@ pub fn config() -> Config {
 
     #[cfg(feature = "stm32g071rb")]
     {
-        config.rcc.hsi = true;
+        config.rcc.hsi = Some(Hsi {
+            sys_div: HsiSysDiv::DIV1,
+        });
         config.rcc.pll = Some(Pll {
             source: PllSource::HSI,
             prediv: PllPreDiv::DIV1,
@@ -458,6 +468,8 @@ pub fn config() -> Config {
         config.rcc.apb3_pre = APBPrescaler::DIV1;
         config.rcc.sys = Sysclk::PLL1_P;
         config.rcc.voltage_scale = VoltageScale::Scale0;
+
+        config.rtc._disable_rtc = true;
     }
 
     #[cfg(feature = "stm32h503rb")]
@@ -671,6 +683,8 @@ pub fn config() -> Config {
             divp: Some(PllDiv::DIV2),  // 600Mhz
             divq: Some(PllDiv::DIV25), // 48Mhz
             divr: None,
+            divs: None,
+            divt: None,
         });
         config.rcc.sys = Sysclk::PLL1_P; // 600 Mhz
         config.rcc.ahb_pre = AHBPrescaler::DIV2; // 300 Mhz
@@ -699,3 +713,21 @@ pub fn config() -> Config {
 
     config
 }
+
+#[allow(unused)]
+pub fn init() -> embassy_stm32::Peripherals {
+    init_with_config(config())
+}
+
+#[allow(unused)]
+pub fn init_with_config(config: Config) -> embassy_stm32::Peripherals {
+    #[cfg(any(feature = "stm32wl55jc", feature = "stm32h755zi"))]
+    {
+        // Not in shared memory, but we're not running the second core, so it's fine
+        static SHARED_DATA: core::mem::MaybeUninit<embassy_stm32::SharedData> = core::mem::MaybeUninit::uninit();
+        embassy_stm32::init_primary(config, &SHARED_DATA)
+    }
+
+    #[cfg(not(any(feature = "stm32wl55jc", feature = "stm32h755zi")))]
+    embassy_stm32::init(config)
+}
diff --git a/tests/utils/Cargo.toml b/tests/utils/Cargo.toml
index 7b54a4f52..da04a1f5d 100644
--- a/tests/utils/Cargo.toml
+++ b/tests/utils/Cargo.toml
@@ -1,8 +1,10 @@
 [package]
 name = "test-utils"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
+license = "MIT OR Apache-2.0"
+publish = false
 
 [dependencies]
-rand = "0.8"
+rand = "0.9"
 serial = "0.4"
diff --git a/tests/utils/src/bin/saturate_serial.rs b/tests/utils/src/bin/saturate_serial.rs
index 18ca12fb7..1c8a8b322 100644
--- a/tests/utils/src/bin/saturate_serial.rs
+++ b/tests/utils/src/bin/saturate_serial.rs
@@ -2,7 +2,7 @@ use std::path::Path;
 use std::time::Duration;
 use std::{env, io, process, thread};
 
-use rand::random;
+use rand::{Rng, rng};
 use serial::SerialPort;
 
 pub fn main() {
@@ -34,14 +34,15 @@ fn saturate<T: SerialPort>(port: &mut T, idles: bool) -> io::Result<()> {
     })?;
 
     let mut written = 0;
+    let mut rng = rng();
     loop {
-        let len = random::<usize>() % 0x1000;
+        let len = rng.random_range(1..=0x1000);
         let buf: Vec<u8> = (written..written + len).map(|x| x as u8).collect();
 
         port.write_all(&buf)?;
 
         if idles {
-            let micros = (random::<usize>() % 1000) as u64;
+            let micros = rng.random_range(1..=1000) as u64;
             println!("Sleeping {}us", micros);
             port.flush().unwrap();
             thread::sleep(Duration::from_micros(micros));