Merge branch 'main' into issue-1974-add-sai-driver

24 files changed, 828 insertions, 968 deletions

diff --git a/tests/nrf/.cargo/config.toml b/tests/nrf/.cargo/config.toml
index 03995f963..9d6b0313a 100644
--- a/tests/nrf/.cargo/config.toml
+++ b/tests/nrf/.cargo/config.toml
@@ -6,4 +6,4 @@ runner = "teleprobe client run"
 target = "thumbv7em-none-eabi"
 
 [env]
-DEFMT_LOG = "trace"
+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
index 4e31bed59..08fe1a4b5 100644
--- a/tests/nrf/Cargo.toml
+++ b/tests/nrf/Cargo.toml
@@ -8,9 +8,9 @@ license = "MIT OR Apache-2.0"
 teleprobe-meta = "1"
 
 embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
-embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt", "nightly"] }
+embassy-sync = { version = "0.3.0", path = "../../embassy-sync", features = ["defmt", "nightly"] }
 embassy-executor = { version = "0.3.0", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "defmt", "nightly", "integrated-timers"] }
-embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "nightly", "unstable-traits", "defmt-timestamp-uptime"] }
+embassy-time = { version = "0.1.3", path = "../../embassy-time", features = ["defmt", "nightly", "unstable-traits", "defmt-timestamp-uptime"] }
 embassy-nrf = { version = "0.1.0", path = "../../embassy-nrf", features = ["defmt", "nightly", "unstable-traits", "nrf52840", "time-driver-rtc1", "gpiote", "unstable-pac"] }
 embedded-io-async = { version = "0.5.0" }
 embassy-net = { version = "0.1.0", path = "../../embassy-net", features = ["defmt", "tcp", "dhcpv4", "medium-ethernet", "nightly"] }
@@ -19,10 +19,11 @@ embassy-net-enc28j60 = { version = "0.1.0", path = "../../embassy-net-enc28j60",
 embedded-hal-async = { version = "1.0.0-rc.1" }
 embedded-hal-bus = { version = "0.1.0-rc.1", features = ["async"] }
 static_cell = { version = "1.1", features = [ "nightly" ] }
+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"] }
\ No newline at end of file
+panic-probe = { version = "0.3", features = ["print-defmt"] }
diff --git a/tests/nrf/src/bin/ethernet_enc28j60_perf.rs b/tests/nrf/src/bin/ethernet_enc28j60_perf.rs
index 0446d39ac..60d30a2ff 100644
--- a/tests/nrf/src/bin/ethernet_enc28j60_perf.rs
+++ b/tests/nrf/src/bin/ethernet_enc28j60_perf.rs
@@ -4,17 +4,15 @@
 teleprobe_meta::target!(b"ak-gwe-r7");
 teleprobe_meta::timeout!(120);
 
-use defmt::{error, info, unwrap};
+use defmt::{info, unwrap};
 use embassy_executor::Spawner;
-use embassy_futures::join::join;
-use embassy_net::tcp::TcpSocket;
-use embassy_net::{Ipv4Address, Stack, StackResources};
+use embassy_net::{Stack, StackResources};
 use embassy_net_enc28j60::Enc28j60;
 use embassy_nrf::gpio::{Level, Output, OutputDrive};
 use embassy_nrf::rng::Rng;
 use embassy_nrf::spim::{self, Spim};
 use embassy_nrf::{bind_interrupts, peripherals};
-use embassy_time::{with_timeout, Delay, Duration, Timer};
+use embassy_time::Delay;
 use embedded_hal_bus::spi::ExclusiveDevice;
 use static_cell::make_static;
 use {defmt_rtt as _, panic_probe as _};
@@ -79,172 +77,16 @@ async fn main(spawner: Spawner) {
 
     unwrap!(spawner.spawn(net_task(stack)));
 
-    info!("Waiting for DHCP up...");
-    while stack.config_v4().is_none() {
-        Timer::after(Duration::from_millis(100)).await;
-    }
-    info!("IP addressing up!");
-
-    let down = test_download(stack).await;
-    let up = test_upload(stack).await;
-    let updown = test_upload_download(stack).await;
-
-    assert!(down > TEST_EXPECTED_DOWNLOAD_KBPS);
-    assert!(up > TEST_EXPECTED_UPLOAD_KBPS);
-    assert!(updown > TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS);
+    perf_client::run(
+        stack,
+        perf_client::Expected {
+            down_kbps: 200,
+            up_kbps: 200,
+            updown_kbps: 150,
+        },
+    )
+    .await;
 
     info!("Test OK");
     cortex_m::asm::bkpt();
 }
-
-const TEST_DURATION: usize = 10;
-const TEST_EXPECTED_DOWNLOAD_KBPS: usize = 200;
-const TEST_EXPECTED_UPLOAD_KBPS: usize = 200;
-const TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS: usize = 150;
-const RX_BUFFER_SIZE: usize = 4096;
-const TX_BUFFER_SIZE: usize = 4096;
-const SERVER_ADDRESS: Ipv4Address = Ipv4Address::new(192, 168, 2, 2);
-const DOWNLOAD_PORT: u16 = 4321;
-const UPLOAD_PORT: u16 = 4322;
-const UPLOAD_DOWNLOAD_PORT: u16 = 4323;
-
-async fn test_download(stack: &'static Stack<MyDriver>) -> usize {
-    info!("Testing download...");
-
-    let mut rx_buffer = [0; RX_BUFFER_SIZE];
-    let mut tx_buffer = [0; TX_BUFFER_SIZE];
-    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-    socket.set_timeout(Some(Duration::from_secs(10)));
-
-    info!("connecting to {:?}:{}...", SERVER_ADDRESS, DOWNLOAD_PORT);
-    if let Err(e) = socket.connect((SERVER_ADDRESS, DOWNLOAD_PORT)).await {
-        error!("connect error: {:?}", e);
-        return 0;
-    }
-    info!("connected, testing...");
-
-    let mut rx_buf = [0; 4096];
-    let mut total: usize = 0;
-    with_timeout(Duration::from_secs(TEST_DURATION as _), async {
-        loop {
-            match socket.read(&mut rx_buf).await {
-                Ok(0) => {
-                    error!("read EOF");
-                    return 0;
-                }
-                Ok(n) => total += n,
-                Err(e) => {
-                    error!("read error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    })
-    .await
-    .ok();
-
-    let kbps = (total + 512) / 1024 / TEST_DURATION;
-    info!("download: {} kB/s", kbps);
-    kbps
-}
-
-async fn test_upload(stack: &'static Stack<MyDriver>) -> usize {
-    info!("Testing upload...");
-
-    let mut rx_buffer = [0; RX_BUFFER_SIZE];
-    let mut tx_buffer = [0; TX_BUFFER_SIZE];
-    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-    socket.set_timeout(Some(Duration::from_secs(10)));
-
-    info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_PORT);
-    if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_PORT)).await {
-        error!("connect error: {:?}", e);
-        return 0;
-    }
-    info!("connected, testing...");
-
-    let buf = [0; 4096];
-    let mut total: usize = 0;
-    with_timeout(Duration::from_secs(TEST_DURATION as _), async {
-        loop {
-            match socket.write(&buf).await {
-                Ok(0) => {
-                    error!("write zero?!??!?!");
-                    return 0;
-                }
-                Ok(n) => total += n,
-                Err(e) => {
-                    error!("write error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    })
-    .await
-    .ok();
-
-    let kbps = (total + 512) / 1024 / TEST_DURATION;
-    info!("upload: {} kB/s", kbps);
-    kbps
-}
-
-async fn test_upload_download(stack: &'static Stack<MyDriver>) -> usize {
-    info!("Testing upload+download...");
-
-    let mut rx_buffer = [0; RX_BUFFER_SIZE];
-    let mut tx_buffer = [0; TX_BUFFER_SIZE];
-    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-    socket.set_timeout(Some(Duration::from_secs(10)));
-
-    info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT);
-    if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT)).await {
-        error!("connect error: {:?}", e);
-        return 0;
-    }
-    info!("connected, testing...");
-
-    let (mut reader, mut writer) = socket.split();
-
-    let tx_buf = [0; 4096];
-    let mut rx_buf = [0; 4096];
-    let mut total: usize = 0;
-    let tx_fut = async {
-        loop {
-            match writer.write(&tx_buf).await {
-                Ok(0) => {
-                    error!("write zero?!??!?!");
-                    return 0;
-                }
-                Ok(_) => {}
-                Err(e) => {
-                    error!("write error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    };
-
-    let rx_fut = async {
-        loop {
-            match reader.read(&mut rx_buf).await {
-                Ok(0) => {
-                    error!("read EOF");
-                    return 0;
-                }
-                Ok(n) => total += n,
-                Err(e) => {
-                    error!("read error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    };
-
-    with_timeout(Duration::from_secs(TEST_DURATION as _), join(tx_fut, rx_fut))
-        .await
-        .ok();
-
-    let kbps = (total + 512) / 1024 / TEST_DURATION;
-    info!("upload+download: {} kB/s", kbps);
-    kbps
-}
diff --git a/tests/nrf/src/bin/wifi_esp_hosted_perf.rs b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
index 97ebafec8..9eee39ccf 100644
--- a/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
+++ b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
@@ -4,16 +4,14 @@
 teleprobe_meta::target!(b"nrf52840-dk");
 teleprobe_meta::timeout!(120);
 
-use defmt::{error, info, unwrap};
+use defmt::{info, unwrap};
 use embassy_executor::Spawner;
-use embassy_futures::join::join;
-use embassy_net::tcp::TcpSocket;
-use embassy_net::{Config, Ipv4Address, Stack, StackResources};
+use embassy_net::{Config, Stack, StackResources};
 use embassy_nrf::gpio::{AnyPin, Input, Level, Output, OutputDrive, Pin, Pull};
 use embassy_nrf::rng::Rng;
 use embassy_nrf::spim::{self, Spim};
 use embassy_nrf::{bind_interrupts, peripherals};
-use embassy_time::{with_timeout, Delay, Duration, Timer};
+use embassy_time::Delay;
 use embedded_hal_bus::spi::ExclusiveDevice;
 use static_cell::make_static;
 use {defmt_rtt as _, embassy_net_esp_hosted as hosted, panic_probe as _};
@@ -23,6 +21,10 @@ bind_interrupts!(struct Irqs {
     RNG => embassy_nrf::rng::InterruptHandler<peripherals::RNG>;
 });
 
+// Test-only wifi network, no internet access!
+const WIFI_NETWORK: &str = "EmbassyTest";
+const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
+
 #[embassy_executor::task]
 async fn wifi_task(
     runner: hosted::Runner<
@@ -92,176 +94,16 @@ async fn main(spawner: Spawner) {
 
     unwrap!(spawner.spawn(net_task(stack)));
 
-    info!("Waiting for DHCP up...");
-    while stack.config_v4().is_none() {
-        Timer::after(Duration::from_millis(100)).await;
-    }
-    info!("IP addressing up!");
-
-    let down = test_download(stack).await;
-    let up = test_upload(stack).await;
-    let updown = test_upload_download(stack).await;
-
-    assert!(down > TEST_EXPECTED_DOWNLOAD_KBPS);
-    assert!(up > TEST_EXPECTED_UPLOAD_KBPS);
-    assert!(updown > TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS);
+    perf_client::run(
+        stack,
+        perf_client::Expected {
+            down_kbps: 50,
+            up_kbps: 50,
+            updown_kbps: 50,
+        },
+    )
+    .await;
 
     info!("Test OK");
     cortex_m::asm::bkpt();
 }
-
-// Test-only wifi network, no internet access!
-const WIFI_NETWORK: &str = "EmbassyTest";
-const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
-
-const TEST_DURATION: usize = 10;
-const TEST_EXPECTED_DOWNLOAD_KBPS: usize = 50;
-const TEST_EXPECTED_UPLOAD_KBPS: usize = 50;
-const TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS: usize = 50;
-const RX_BUFFER_SIZE: usize = 4096;
-const TX_BUFFER_SIZE: usize = 4096;
-const SERVER_ADDRESS: Ipv4Address = Ipv4Address::new(192, 168, 2, 2);
-const DOWNLOAD_PORT: u16 = 4321;
-const UPLOAD_PORT: u16 = 4322;
-const UPLOAD_DOWNLOAD_PORT: u16 = 4323;
-
-async fn test_download(stack: &'static Stack<MyDriver>) -> usize {
-    info!("Testing download...");
-
-    let mut rx_buffer = [0; RX_BUFFER_SIZE];
-    let mut tx_buffer = [0; TX_BUFFER_SIZE];
-    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-    socket.set_timeout(Some(Duration::from_secs(10)));
-
-    info!("connecting to {:?}:{}...", SERVER_ADDRESS, DOWNLOAD_PORT);
-    if let Err(e) = socket.connect((SERVER_ADDRESS, DOWNLOAD_PORT)).await {
-        error!("connect error: {:?}", e);
-        return 0;
-    }
-    info!("connected, testing...");
-
-    let mut rx_buf = [0; 4096];
-    let mut total: usize = 0;
-    with_timeout(Duration::from_secs(TEST_DURATION as _), async {
-        loop {
-            match socket.read(&mut rx_buf).await {
-                Ok(0) => {
-                    error!("read EOF");
-                    return 0;
-                }
-                Ok(n) => total += n,
-                Err(e) => {
-                    error!("read error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    })
-    .await
-    .ok();
-
-    let kbps = (total + 512) / 1024 / TEST_DURATION;
-    info!("download: {} kB/s", kbps);
-    kbps
-}
-
-async fn test_upload(stack: &'static Stack<MyDriver>) -> usize {
-    info!("Testing upload...");
-
-    let mut rx_buffer = [0; RX_BUFFER_SIZE];
-    let mut tx_buffer = [0; TX_BUFFER_SIZE];
-    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-    socket.set_timeout(Some(Duration::from_secs(10)));
-
-    info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_PORT);
-    if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_PORT)).await {
-        error!("connect error: {:?}", e);
-        return 0;
-    }
-    info!("connected, testing...");
-
-    let buf = [0; 4096];
-    let mut total: usize = 0;
-    with_timeout(Duration::from_secs(TEST_DURATION as _), async {
-        loop {
-            match socket.write(&buf).await {
-                Ok(0) => {
-                    error!("write zero?!??!?!");
-                    return 0;
-                }
-                Ok(n) => total += n,
-                Err(e) => {
-                    error!("write error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    })
-    .await
-    .ok();
-
-    let kbps = (total + 512) / 1024 / TEST_DURATION;
-    info!("upload: {} kB/s", kbps);
-    kbps
-}
-
-async fn test_upload_download(stack: &'static Stack<MyDriver>) -> usize {
-    info!("Testing upload+download...");
-
-    let mut rx_buffer = [0; RX_BUFFER_SIZE];
-    let mut tx_buffer = [0; TX_BUFFER_SIZE];
-    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-    socket.set_timeout(Some(Duration::from_secs(10)));
-
-    info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT);
-    if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT)).await {
-        error!("connect error: {:?}", e);
-        return 0;
-    }
-    info!("connected, testing...");
-
-    let (mut reader, mut writer) = socket.split();
-
-    let tx_buf = [0; 4096];
-    let mut rx_buf = [0; 4096];
-    let mut total: usize = 0;
-    let tx_fut = async {
-        loop {
-            match writer.write(&tx_buf).await {
-                Ok(0) => {
-                    error!("write zero?!??!?!");
-                    return 0;
-                }
-                Ok(_) => {}
-                Err(e) => {
-                    error!("write error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    };
-
-    let rx_fut = async {
-        loop {
-            match reader.read(&mut rx_buf).await {
-                Ok(0) => {
-                    error!("read EOF");
-                    return 0;
-                }
-                Ok(n) => total += n,
-                Err(e) => {
-                    error!("read error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    };
-
-    with_timeout(Duration::from_secs(TEST_DURATION as _), join(tx_fut, rx_fut))
-        .await
-        .ok();
-
-    let kbps = (total + 512) / 1024 / TEST_DURATION;
-    info!("upload+download: {} kB/s", kbps);
-    kbps
-}
diff --git a/tests/perf-client/Cargo.toml b/tests/perf-client/Cargo.toml
new file mode 100644
index 000000000..3284664d9
--- /dev/null
+++ b/tests/perf-client/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "perf-client"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+embassy-net = { version = "0.1.0", path = "../../embassy-net", features = ["defmt", "tcp", "dhcpv4"] }
+embassy-time = { version = "0.1.3", path = "../../embassy-time", features = ["defmt", "nightly", "unstable-traits"] }
+embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
+defmt = "0.3.0"
diff --git a/tests/perf-client/src/lib.rs b/tests/perf-client/src/lib.rs
new file mode 100644
index 000000000..a36147dbb
--- /dev/null
+++ b/tests/perf-client/src/lib.rs
@@ -0,0 +1,179 @@
+#![no_std]
+
+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};
+
+pub struct Expected {
+    pub down_kbps: usize,
+    pub up_kbps: usize,
+    pub updown_kbps: usize,
+}
+
+pub async fn run<D: Driver>(stack: &Stack<D>, expected: Expected) {
+    info!("Waiting for DHCP up...");
+    while stack.config_v4().is_none() {
+        Timer::after(Duration::from_millis(100)).await;
+    }
+    info!("IP addressing up!");
+
+    let down = test_download(stack).await;
+    let up = test_upload(stack).await;
+    let updown = test_upload_download(stack).await;
+
+    assert!(down > expected.down_kbps);
+    assert!(up > expected.up_kbps);
+    assert!(updown > expected.updown_kbps);
+}
+
+const TEST_DURATION: usize = 10;
+const RX_BUFFER_SIZE: usize = 4096;
+const TX_BUFFER_SIZE: usize = 4096;
+const SERVER_ADDRESS: Ipv4Address = Ipv4Address::new(192, 168, 2, 2);
+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 {
+    info!("Testing download...");
+
+    let mut rx_buffer = [0; RX_BUFFER_SIZE];
+    let mut tx_buffer = [0; TX_BUFFER_SIZE];
+    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
+    socket.set_timeout(Some(Duration::from_secs(10)));
+
+    info!("connecting to {:?}:{}...", SERVER_ADDRESS, DOWNLOAD_PORT);
+    if let Err(e) = socket.connect((SERVER_ADDRESS, DOWNLOAD_PORT)).await {
+        error!("connect error: {:?}", e);
+        return 0;
+    }
+    info!("connected, testing...");
+
+    let mut rx_buf = [0; 4096];
+    let mut total: usize = 0;
+    with_timeout(Duration::from_secs(TEST_DURATION as _), async {
+        loop {
+            match socket.read(&mut rx_buf).await {
+                Ok(0) => {
+                    error!("read EOF");
+                    return 0;
+                }
+                Ok(n) => total += n,
+                Err(e) => {
+                    error!("read error: {:?}", e);
+                    return 0;
+                }
+            }
+        }
+    })
+    .await
+    .ok();
+
+    let kbps = (total + 512) / 1024 / TEST_DURATION;
+    info!("download: {} kB/s", kbps);
+    kbps
+}
+
+async fn test_upload<D: Driver>(stack: &Stack<D>) -> usize {
+    info!("Testing upload...");
+
+    let mut rx_buffer = [0; RX_BUFFER_SIZE];
+    let mut tx_buffer = [0; TX_BUFFER_SIZE];
+    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
+    socket.set_timeout(Some(Duration::from_secs(10)));
+
+    info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_PORT);
+    if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_PORT)).await {
+        error!("connect error: {:?}", e);
+        return 0;
+    }
+    info!("connected, testing...");
+
+    let buf = [0; 4096];
+    let mut total: usize = 0;
+    with_timeout(Duration::from_secs(TEST_DURATION as _), async {
+        loop {
+            match socket.write(&buf).await {
+                Ok(0) => {
+                    error!("write zero?!??!?!");
+                    return 0;
+                }
+                Ok(n) => total += n,
+                Err(e) => {
+                    error!("write error: {:?}", e);
+                    return 0;
+                }
+            }
+        }
+    })
+    .await
+    .ok();
+
+    let kbps = (total + 512) / 1024 / TEST_DURATION;
+    info!("upload: {} kB/s", kbps);
+    kbps
+}
+
+async fn test_upload_download<D: Driver>(stack: &Stack<D>) -> usize {
+    info!("Testing upload+download...");
+
+    let mut rx_buffer = [0; RX_BUFFER_SIZE];
+    let mut tx_buffer = [0; TX_BUFFER_SIZE];
+    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
+    socket.set_timeout(Some(Duration::from_secs(10)));
+
+    info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT);
+    if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT)).await {
+        error!("connect error: {:?}", e);
+        return 0;
+    }
+    info!("connected, testing...");
+
+    let (mut reader, mut writer) = socket.split();
+
+    let tx_buf = [0; 4096];
+    let mut rx_buf = [0; 4096];
+    let mut total: usize = 0;
+    let tx_fut = async {
+        loop {
+            match writer.write(&tx_buf).await {
+                Ok(0) => {
+                    error!("write zero?!??!?!");
+                    return 0;
+                }
+                Ok(_) => {}
+                Err(e) => {
+                    error!("write error: {:?}", e);
+                    return 0;
+                }
+            }
+        }
+    };
+
+    let rx_fut = async {
+        loop {
+            match reader.read(&mut rx_buf).await {
+                Ok(0) => {
+                    error!("read EOF");
+                    return 0;
+                }
+                Ok(n) => total += n,
+                Err(e) => {
+                    error!("read error: {:?}", e);
+                    return 0;
+                }
+            }
+        }
+    };
+
+    with_timeout(Duration::from_secs(TEST_DURATION as _), join(tx_fut, rx_fut))
+        .await
+        .ok();
+
+    let kbps = (total + 512) / 1024 / TEST_DURATION;
+    info!("upload+download: {} kB/s", kbps);
+    kbps
+}
diff --git a/tests/riscv32/Cargo.toml b/tests/riscv32/Cargo.toml
index be610b1c5..490f037b9 100644
--- a/tests/riscv32/Cargo.toml
+++ b/tests/riscv32/Cargo.toml
@@ -6,9 +6,9 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 critical-section = { version = "1.1.1", features = ["restore-state-bool"] }
-embassy-sync = { version = "0.2.0", path = "../../embassy-sync" }
+embassy-sync = { version = "0.3.0", path = "../../embassy-sync" }
 embassy-executor = { version = "0.3.0", path = "../../embassy-executor", features = ["arch-riscv32", "nightly", "executor-thread"] }
-embassy-time = { version = "0.1.2", path = "../../embassy-time" }
+embassy-time = { version = "0.1.3", path = "../../embassy-time" }
 embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
 
 riscv-rt = "0.11"
diff --git a/tests/rp/.cargo/config.toml b/tests/rp/.cargo/config.toml
index bc92e788b..40b5d7000 100644
--- a/tests/rp/.cargo/config.toml
+++ b/tests/rp/.cargo/config.toml
@@ -19,4 +19,4 @@ rustflags = [
 target = "thumbv6m-none-eabi"
 
 [env]
-DEFMT_LOG = "trace"
+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 c494b66ee..8bb0de6c6 100644
--- a/tests/rp/Cargo.toml
+++ b/tests/rp/Cargo.toml
@@ -7,15 +7,16 @@ license = "MIT OR Apache-2.0"
 [dependencies]
 teleprobe-meta = "1.1"
 
-embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
+embassy-sync = { version = "0.3.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.3.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
-embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "nightly", "unstable-traits"] }
+embassy-time = { version = "0.1.3", path = "../../embassy-time", features = ["defmt", "nightly", "unstable-traits"] }
 embassy-rp = { version = "0.1.0", path = "../../embassy-rp", features = ["nightly", "defmt", "unstable-pac", "unstable-traits", "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.1.0", path = "../../embassy-net", features = ["defmt", "nightly", "tcp", "udp", "dhcpv4", "medium-ethernet"] }
 embassy-net-wiznet = { version = "0.1.0", path = "../../embassy-net-wiznet", features = ["defmt"] }
 cyw43 = { path = "../../cyw43", features = ["defmt", "firmware-logs"] }
 cyw43-pio = { path = "../../cyw43-pio", features = ["defmt", "overclock"] }
+perf-client = { path = "../perf-client" }
 
 defmt = "0.3.0"
 defmt-rtt = "0.4"
diff --git a/tests/rp/src/bin/cyw43-perf.rs b/tests/rp/src/bin/cyw43-perf.rs
index 1c665f95d..de29c06dd 100644
--- a/tests/rp/src/bin/cyw43-perf.rs
+++ b/tests/rp/src/bin/cyw43-perf.rs
@@ -4,16 +4,13 @@
 teleprobe_meta::target!(b"rpi-pico");
 
 use cyw43_pio::PioSpi;
-use defmt::{assert, panic, *};
+use defmt::{panic, *};
 use embassy_executor::Spawner;
-use embassy_futures::join::join;
-use embassy_net::tcp::TcpSocket;
-use embassy_net::{Config, Ipv4Address, Stack, StackResources};
+use embassy_net::{Config, Stack, StackResources};
 use embassy_rp::gpio::{Level, Output};
 use embassy_rp::peripherals::{DMA_CH0, PIN_23, PIN_25, PIO0};
 use embassy_rp::pio::{InterruptHandler, Pio};
 use embassy_rp::{bind_interrupts, rom_data};
-use embassy_time::{with_timeout, Duration, Timer};
 use static_cell::make_static;
 use {defmt_rtt as _, panic_probe as _};
 
@@ -23,6 +20,10 @@ bind_interrupts!(struct Irqs {
 
 teleprobe_meta::timeout!(120);
 
+// Test-only wifi network, no internet access!
+const WIFI_NETWORK: &str = "EmbassyTest";
+const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
+
 #[embassy_executor::task]
 async fn wifi_task(
     runner: cyw43::Runner<'static, Output<'static, PIN_23>, PioSpi<'static, PIN_25, PIO0, 0, DMA_CH0>>,
@@ -88,176 +89,16 @@ async fn main(spawner: Spawner) {
         }
     }
 
-    info!("Waiting for DHCP up...");
-    while stack.config_v4().is_none() {
-        Timer::after(Duration::from_millis(100)).await;
-    }
-    info!("IP addressing up!");
-
-    let down = test_download(stack).await;
-    let up = test_upload(stack).await;
-    let updown = test_upload_download(stack).await;
-
-    assert!(down > TEST_EXPECTED_DOWNLOAD_KBPS);
-    assert!(up > TEST_EXPECTED_UPLOAD_KBPS);
-    assert!(updown > TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS);
+    perf_client::run(
+        stack,
+        perf_client::Expected {
+            down_kbps: 300,
+            up_kbps: 300,
+            updown_kbps: 300,
+        },
+    )
+    .await;
 
     info!("Test OK");
     cortex_m::asm::bkpt();
 }
-
-// Test-only wifi network, no internet access!
-const WIFI_NETWORK: &str = "EmbassyTest";
-const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
-
-const TEST_DURATION: usize = 10;
-const TEST_EXPECTED_DOWNLOAD_KBPS: usize = 300;
-const TEST_EXPECTED_UPLOAD_KBPS: usize = 300;
-const TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS: usize = 300;
-const RX_BUFFER_SIZE: usize = 4096;
-const TX_BUFFER_SIZE: usize = 4096;
-const SERVER_ADDRESS: Ipv4Address = Ipv4Address::new(192, 168, 2, 2);
-const DOWNLOAD_PORT: u16 = 4321;
-const UPLOAD_PORT: u16 = 4322;
-const UPLOAD_DOWNLOAD_PORT: u16 = 4323;
-
-async fn test_download(stack: &'static Stack<cyw43::NetDriver<'static>>) -> usize {
-    info!("Testing download...");
-
-    let mut rx_buffer = [0; RX_BUFFER_SIZE];
-    let mut tx_buffer = [0; TX_BUFFER_SIZE];
-    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-    socket.set_timeout(Some(Duration::from_secs(10)));
-
-    info!("connecting to {:?}:{}...", SERVER_ADDRESS, DOWNLOAD_PORT);
-    if let Err(e) = socket.connect((SERVER_ADDRESS, DOWNLOAD_PORT)).await {
-        error!("connect error: {:?}", e);
-        return 0;
-    }
-    info!("connected, testing...");
-
-    let mut rx_buf = [0; 4096];
-    let mut total: usize = 0;
-    with_timeout(Duration::from_secs(TEST_DURATION as _), async {
-        loop {
-            match socket.read(&mut rx_buf).await {
-                Ok(0) => {
-                    error!("read EOF");
-                    return 0;
-                }
-                Ok(n) => total += n,
-                Err(e) => {
-                    error!("read error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    })
-    .await
-    .ok();
-
-    let kbps = (total + 512) / 1024 / TEST_DURATION;
-    info!("download: {} kB/s", kbps);
-    kbps
-}
-
-async fn test_upload(stack: &'static Stack<cyw43::NetDriver<'static>>) -> usize {
-    info!("Testing upload...");
-
-    let mut rx_buffer = [0; RX_BUFFER_SIZE];
-    let mut tx_buffer = [0; TX_BUFFER_SIZE];
-    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-    socket.set_timeout(Some(Duration::from_secs(10)));
-
-    info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_PORT);
-    if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_PORT)).await {
-        error!("connect error: {:?}", e);
-        return 0;
-    }
-    info!("connected, testing...");
-
-    let buf = [0; 4096];
-    let mut total: usize = 0;
-    with_timeout(Duration::from_secs(TEST_DURATION as _), async {
-        loop {
-            match socket.write(&buf).await {
-                Ok(0) => {
-                    error!("write zero?!??!?!");
-                    return 0;
-                }
-                Ok(n) => total += n,
-                Err(e) => {
-                    error!("write error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    })
-    .await
-    .ok();
-
-    let kbps = (total + 512) / 1024 / TEST_DURATION;
-    info!("upload: {} kB/s", kbps);
-    kbps
-}
-
-async fn test_upload_download(stack: &'static Stack<cyw43::NetDriver<'static>>) -> usize {
-    info!("Testing upload+download...");
-
-    let mut rx_buffer = [0; RX_BUFFER_SIZE];
-    let mut tx_buffer = [0; TX_BUFFER_SIZE];
-    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-    socket.set_timeout(Some(Duration::from_secs(10)));
-
-    info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT);
-    if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT)).await {
-        error!("connect error: {:?}", e);
-        return 0;
-    }
-    info!("connected, testing...");
-
-    let (mut reader, mut writer) = socket.split();
-
-    let tx_buf = [0; 4096];
-    let mut rx_buf = [0; 4096];
-    let mut total: usize = 0;
-    let tx_fut = async {
-        loop {
-            match writer.write(&tx_buf).await {
-                Ok(0) => {
-                    error!("write zero?!??!?!");
-                    return 0;
-                }
-                Ok(_) => {}
-                Err(e) => {
-                    error!("write error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    };
-
-    let rx_fut = async {
-        loop {
-            match reader.read(&mut rx_buf).await {
-                Ok(0) => {
-                    error!("read EOF");
-                    return 0;
-                }
-                Ok(n) => total += n,
-                Err(e) => {
-                    error!("read error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    };
-
-    with_timeout(Duration::from_secs(TEST_DURATION as _), join(tx_fut, rx_fut))
-        .await
-        .ok();
-
-    let kbps = (total + 512) / 1024 / TEST_DURATION;
-    info!("upload+download: {} kB/s", kbps);
-    kbps
-}
diff --git a/tests/rp/src/bin/ethernet_w5100s_perf.rs b/tests/rp/src/bin/ethernet_w5100s_perf.rs
index faa8638c0..a4d253b3c 100644
--- a/tests/rp/src/bin/ethernet_w5100s_perf.rs
+++ b/tests/rp/src/bin/ethernet_w5100s_perf.rs
@@ -4,18 +4,16 @@
 teleprobe_meta::target!(b"w5100s-evb-pico");
 teleprobe_meta::timeout!(120);
 
-use defmt::{assert, *};
+use defmt::*;
 use embassy_executor::Spawner;
-use embassy_futures::join::join;
-use embassy_net::tcp::TcpSocket;
-use embassy_net::{Ipv4Address, Stack, StackResources};
+use embassy_net::{Stack, StackResources};
 use embassy_net_wiznet::chip::W5100S;
 use embassy_net_wiznet::*;
 use embassy_rp::clocks::RoscRng;
 use embassy_rp::gpio::{Input, Level, Output, Pull};
 use embassy_rp::peripherals::{PIN_17, PIN_20, PIN_21, SPI0};
 use embassy_rp::spi::{Async, Config as SpiConfig, Spi};
-use embassy_time::{with_timeout, Delay, Duration, Timer};
+use embassy_time::Delay;
 use embedded_hal_bus::spi::ExclusiveDevice;
 use rand::RngCore;
 use static_cell::make_static;
@@ -78,172 +76,16 @@ async fn main(spawner: Spawner) {
     // Launch network task
     unwrap!(spawner.spawn(net_task(&stack)));
 
-    info!("Waiting for DHCP up...");
-    while stack.config_v4().is_none() {
-        Timer::after(Duration::from_millis(100)).await;
-    }
-    info!("IP addressing up!");
-
-    let down = test_download(stack).await;
-    let up = test_upload(stack).await;
-    let updown = test_upload_download(stack).await;
-
-    assert!(down > TEST_EXPECTED_DOWNLOAD_KBPS);
-    assert!(up > TEST_EXPECTED_UPLOAD_KBPS);
-    assert!(updown > TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS);
+    perf_client::run(
+        stack,
+        perf_client::Expected {
+            down_kbps: 500,
+            up_kbps: 500,
+            updown_kbps: 300,
+        },
+    )
+    .await;
 
     info!("Test OK");
     cortex_m::asm::bkpt();
 }
-
-const TEST_DURATION: usize = 10;
-const TEST_EXPECTED_DOWNLOAD_KBPS: usize = 500;
-const TEST_EXPECTED_UPLOAD_KBPS: usize = 500;
-const TEST_EXPECTED_UPLOAD_DOWNLOAD_KBPS: usize = 300;
-const RX_BUFFER_SIZE: usize = 4096;
-const TX_BUFFER_SIZE: usize = 4096;
-const SERVER_ADDRESS: Ipv4Address = Ipv4Address::new(192, 168, 2, 2);
-const DOWNLOAD_PORT: u16 = 4321;
-const UPLOAD_PORT: u16 = 4322;
-const UPLOAD_DOWNLOAD_PORT: u16 = 4323;
-
-async fn test_download(stack: &'static Stack<cyw43::NetDriver<'static>>) -> usize {
-    info!("Testing download...");
-
-    let mut rx_buffer = [0; RX_BUFFER_SIZE];
-    let mut tx_buffer = [0; TX_BUFFER_SIZE];
-    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-    socket.set_timeout(Some(Duration::from_secs(10)));
-
-    info!("connecting to {:?}:{}...", SERVER_ADDRESS, DOWNLOAD_PORT);
-    if let Err(e) = socket.connect((SERVER_ADDRESS, DOWNLOAD_PORT)).await {
-        error!("connect error: {:?}", e);
-        return 0;
-    }
-    info!("connected, testing...");
-
-    let mut rx_buf = [0; 4096];
-    let mut total: usize = 0;
-    with_timeout(Duration::from_secs(TEST_DURATION as _), async {
-        loop {
-            match socket.read(&mut rx_buf).await {
-                Ok(0) => {
-                    error!("read EOF");
-                    return 0;
-                }
-                Ok(n) => total += n,
-                Err(e) => {
-                    error!("read error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    })
-    .await
-    .ok();
-
-    let kbps = (total + 512) / 1024 / TEST_DURATION;
-    info!("download: {} kB/s", kbps);
-    kbps
-}
-
-async fn test_upload(stack: &'static Stack<cyw43::NetDriver<'static>>) -> usize {
-    info!("Testing upload...");
-
-    let mut rx_buffer = [0; RX_BUFFER_SIZE];
-    let mut tx_buffer = [0; TX_BUFFER_SIZE];
-    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-    socket.set_timeout(Some(Duration::from_secs(10)));
-
-    info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_PORT);
-    if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_PORT)).await {
-        error!("connect error: {:?}", e);
-        return 0;
-    }
-    info!("connected, testing...");
-
-    let buf = [0; 4096];
-    let mut total: usize = 0;
-    with_timeout(Duration::from_secs(TEST_DURATION as _), async {
-        loop {
-            match socket.write(&buf).await {
-                Ok(0) => {
-                    error!("write zero?!??!?!");
-                    return 0;
-                }
-                Ok(n) => total += n,
-                Err(e) => {
-                    error!("write error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    })
-    .await
-    .ok();
-
-    let kbps = (total + 512) / 1024 / TEST_DURATION;
-    info!("upload: {} kB/s", kbps);
-    kbps
-}
-
-async fn test_upload_download(stack: &'static Stack<cyw43::NetDriver<'static>>) -> usize {
-    info!("Testing upload+download...");
-
-    let mut rx_buffer = [0; RX_BUFFER_SIZE];
-    let mut tx_buffer = [0; TX_BUFFER_SIZE];
-    let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-    socket.set_timeout(Some(Duration::from_secs(10)));
-
-    info!("connecting to {:?}:{}...", SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT);
-    if let Err(e) = socket.connect((SERVER_ADDRESS, UPLOAD_DOWNLOAD_PORT)).await {
-        error!("connect error: {:?}", e);
-        return 0;
-    }
-    info!("connected, testing...");
-
-    let (mut reader, mut writer) = socket.split();
-
-    let tx_buf = [0; 4096];
-    let mut rx_buf = [0; 4096];
-    let mut total: usize = 0;
-    let tx_fut = async {
-        loop {
-            match writer.write(&tx_buf).await {
-                Ok(0) => {
-                    error!("write zero?!??!?!");
-                    return 0;
-                }
-                Ok(_) => {}
-                Err(e) => {
-                    error!("write error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    };
-
-    let rx_fut = async {
-        loop {
-            match reader.read(&mut rx_buf).await {
-                Ok(0) => {
-                    error!("read EOF");
-                    return 0;
-                }
-                Ok(n) => total += n,
-                Err(e) => {
-                    error!("read error: {:?}", e);
-                    return 0;
-                }
-            }
-        }
-    };
-
-    with_timeout(Duration::from_secs(TEST_DURATION as _), join(tx_fut, rx_fut))
-        .await
-        .ok();
-
-    let kbps = (total + 512) / 1024 / TEST_DURATION;
-    info!("upload+download: {} kB/s", kbps);
-    kbps
-}
diff --git a/tests/rp/src/bin/i2c.rs b/tests/rp/src/bin/i2c.rs
new file mode 100644
index 000000000..425f2d086
--- /dev/null
+++ b/tests/rp/src/bin/i2c.rs
@@ -0,0 +1,212 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+teleprobe_meta::target!(b"rpi-pico");
+
+use defmt::{assert_eq, info, panic, unwrap};
+use embassy_executor::Executor;
+use embassy_executor::_export::StaticCell;
+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 {defmt_rtt as _, panic_probe as _, panic_probe as _, panic_probe as _};
+
+static mut CORE1_STACK: Stack<1024> = Stack::new();
+static EXECUTOR0: StaticCell<Executor> = StaticCell::new();
+static EXECUTOR1: StaticCell<Executor> = StaticCell::new();
+
+use crate::i2c::AbortReason;
+
+bind_interrupts!(struct Irqs {
+    I2C0_IRQ => i2c::InterruptHandler<I2C0>;
+    I2C1_IRQ => i2c::InterruptHandler<I2C1>;
+});
+
+const DEV_ADDR: u8 = 0x42;
+
+#[embassy_executor::task]
+async fn device_task(mut dev: i2c_slave::I2cSlave<'static, I2C1>) -> ! {
+    info!("Device start");
+
+    let mut count = 0xD0;
+
+    loop {
+        let mut buf = [0u8; 128];
+        match dev.listen(&mut buf).await {
+            Ok(i2c_slave::Command::GeneralCall(len)) => {
+                assert_eq!(buf[..len], [0xCA, 0x11], "recieving the general call failed");
+                info!("General Call - OK");
+            }
+            Ok(i2c_slave::Command::Read) => {
+                loop {
+                    match dev.respond_to_read(&[count]).await {
+                        Ok(x) => match x {
+                            i2c_slave::ReadStatus::Done => break,
+                            i2c_slave::ReadStatus::NeedMoreBytes => count += 1,
+                            i2c_slave::ReadStatus::LeftoverBytes(x) => {
+                                info!("tried to write {} extra bytes", x);
+                                break;
+                            }
+                        },
+                        Err(e) => match e {
+                            embassy_rp::i2c_slave::Error::Abort(AbortReason::Other(n)) => panic!("Other {:b}", n),
+                            _ => panic!("{}", e),
+                        },
+                    }
+                }
+                count += 1;
+            }
+            Ok(i2c_slave::Command::Write(len)) => match len {
+                1 => {
+                    assert_eq!(buf[..len], [0xAA], "recieving a single byte failed");
+                    info!("Single Byte Write - OK")
+                }
+                4 => {
+                    assert_eq!(buf[..len], [0xAA, 0xBB, 0xCC, 0xDD], "recieving 4 bytes failed");
+                    info!("4 Byte Write - OK")
+                }
+                32 => {
+                    assert_eq!(
+                        buf[..len],
+                        [
+                            0, 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, 30, 31
+                        ],
+                        "recieving 32 bytes failed"
+                    );
+                    info!("32 Byte Write - OK")
+                }
+                _ => panic!("Invalid write length {}", len),
+            },
+            Ok(i2c_slave::Command::WriteRead(len)) => {
+                info!("device recieved write read: {:x}", buf[..len]);
+                match buf[0] {
+                    0xC2 => {
+                        let resp_buff = [0xD1, 0xD2, 0xD3, 0xD4];
+                        dev.respond_to_read(&resp_buff).await.unwrap();
+                    }
+                    0xC8 => {
+                        let mut resp_buff = [0u8; 32];
+                        for i in 0..32 {
+                            resp_buff[i] = i as u8;
+                        }
+                        dev.respond_to_read(&resp_buff).await.unwrap();
+                    }
+                    x => panic!("Invalid Write Read {:x}", x),
+                }
+            }
+            Err(e) => match e {
+                embassy_rp::i2c_slave::Error::Abort(AbortReason::Other(n)) => panic!("Other {:b}", n),
+                _ => panic!("{}", e),
+            },
+        }
+    }
+}
+
+#[embassy_executor::task]
+async fn controller_task(mut con: i2c::I2c<'static, I2C0, i2c::Async>) {
+    info!("Device start");
+
+    {
+        let buf = [0xCA, 0x11];
+        con.write(0u16, &buf).await.unwrap();
+        info!("Controler general call write");
+        embassy_futures::yield_now().await;
+    }
+
+    {
+        let mut buf = [0u8];
+        con.read(DEV_ADDR, &mut buf).await.unwrap();
+        assert_eq!(buf, [0xD0], "single byte read failed");
+        info!("single byte read - OK");
+        embassy_futures::yield_now().await;
+    }
+
+    {
+        let mut buf = [0u8; 4];
+        con.read(DEV_ADDR, &mut buf).await.unwrap();
+        assert_eq!(buf, [0xD1, 0xD2, 0xD3, 0xD4], "single byte read failed");
+        info!("4 byte read - OK");
+        embassy_futures::yield_now().await;
+    }
+
+    {
+        let buf = [0xAA];
+        con.write(DEV_ADDR, &buf).await.unwrap();
+        info!("Controler single byte write");
+        embassy_futures::yield_now().await;
+    }
+
+    {
+        let buf = [0xAA, 0xBB, 0xCC, 0xDD];
+        con.write(DEV_ADDR, &buf).await.unwrap();
+        info!("Controler 4 byte write");
+        embassy_futures::yield_now().await;
+    }
+
+    {
+        let mut buf = [0u8; 32];
+        for i in 0..32 {
+            buf[i] = i as u8;
+        }
+        con.write(DEV_ADDR, &buf).await.unwrap();
+        info!("Controler 32 byte write");
+        embassy_futures::yield_now().await;
+    }
+
+    {
+        let mut buf = [0u8; 4];
+        let mut ops = [Operation::Write(&[0xC2]), Operation::Read(&mut buf)];
+        con.transaction(DEV_ADDR, &mut ops).await.unwrap();
+        assert_eq!(buf, [0xD1, 0xD2, 0xD3, 0xD4], "write_read failed");
+        info!("write_read - OK");
+        embassy_futures::yield_now().await;
+    }
+
+    {
+        let mut buf = [0u8; 32];
+        let mut ops = [Operation::Write(&[0xC8]), Operation::Read(&mut buf)];
+        con.transaction(DEV_ADDR, &mut ops).await.unwrap();
+        assert_eq!(
+            buf,
+            [
+                0, 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, 30, 31
+            ],
+            "write_read of 32 bytes failed"
+        );
+        info!("large write_read - OK")
+    }
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
+
+#[cortex_m_rt::entry]
+fn main() -> ! {
+    let p = embassy_rp::init(Default::default());
+    info!("Hello World!");
+
+    let d_sda = p.PIN_19;
+    let d_scl = p.PIN_18;
+    let mut config = i2c_slave::Config::default();
+    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 CORE1_STACK }, move || {
+        let executor1 = EXECUTOR1.init(Executor::new());
+        executor1.run(|spawner| unwrap!(spawner.spawn(device_task(device))));
+    });
+
+    let executor0 = EXECUTOR0.init(Executor::new());
+
+    let c_sda = p.PIN_21;
+    let c_scl = p.PIN_20;
+    let mut config = i2c::Config::default();
+    config.frequency = 5_000;
+    let controller = i2c::I2c::new_async(p.I2C0, c_sda, c_scl, Irqs, config);
+
+    executor0.run(|spawner| unwrap!(spawner.spawn(controller_task(controller))));
+}
diff --git a/tests/stm32/.cargo/config.toml b/tests/stm32/.cargo/config.toml
index 07761b01c..2e3f055d4 100644
--- a/tests/stm32/.cargo/config.toml
+++ b/tests/stm32/.cargo/config.toml
@@ -14,7 +14,10 @@ rustflags = [
 ]
 
 [build]
-target = "thumbv7m-none-eabi"
+target = "thumbv6m-none-eabi"
+#target = "thumbv7m-none-eabi"
+#target = "thumbv7em-none-eabi"
+#target = "thumbv8m.main-none-eabihf"
 
 [env]
-DEFMT_LOG = "trace"
\ No newline at end of file
+DEFMT_LOG = "trace,embassy_hal_internal=debug,embassy_net_esp_hosted=debug,smoltcp=info"
\ No newline at end of file
diff --git a/tests/stm32/Cargo.toml b/tests/stm32/Cargo.toml
index 754356cb5..bfe5bc823 100644
--- a/tests/stm32/Cargo.toml
+++ b/tests/stm32/Cargo.toml
@@ -7,7 +7,7 @@ autobins = false
 
 [features]
 stm32f103c8 = ["embassy-stm32/stm32f103c8", "not-gpdma"]     # Blue Pill
-stm32f429zi = ["embassy-stm32/stm32f429zi", "chrono", "can", "not-gpdma", "dac-adc-pin"]     # Nucleo "sdmmc"
+stm32f429zi = ["embassy-stm32/stm32f429zi", "chrono", "stop", "can", "not-gpdma", "dac-adc-pin"]     # Nucleo "sdmmc"
 stm32g071rb = ["embassy-stm32/stm32g071rb", "not-gpdma", "dac-adc-pin"]     # Nucleo
 stm32c031c6 = ["embassy-stm32/stm32c031c6", "not-gpdma"]     # Nucleo
 stm32g491re = ["embassy-stm32/stm32g491re", "not-gpdma"]     # Nucleo
@@ -15,8 +15,14 @@ stm32h755zi = ["embassy-stm32/stm32h755zi-cm7", "not-gpdma", "dac-adc-pin"] # Nu
 stm32wb55rg = ["embassy-stm32/stm32wb55rg", "not-gpdma", "ble", "mac" ]     # Nucleo
 stm32h563zi = ["embassy-stm32/stm32h563zi"]     # Nucleo
 stm32u585ai = ["embassy-stm32/stm32u585ai"]     # IoT board
+stm32l073rz = ["embassy-stm32/stm32l073rz", "not-gpdma"]     # Nucleo
+stm32l152re = ["embassy-stm32/stm32l152re", "not-gpdma"]     # Nucleo
+stm32l4a6zg = ["embassy-stm32/stm32l4a6zg", "not-gpdma"]     # Nucleo
+stm32l4r5zi = ["embassy-stm32/stm32l4r5zi", "not-gpdma"]     # Nucleo
+stm32l552ze = ["embassy-stm32/stm32l552ze", "not-gpdma"]     # Nucleo
 
 sdmmc = []
+stop = ["embassy-stm32/low-power"]
 chrono = ["embassy-stm32/chrono", "dep:chrono"]
 can = []
 ble = ["dep:embassy-stm32-wpan", "embassy-stm32-wpan/ble"]
@@ -28,9 +34,9 @@ dac-adc-pin = []
 [dependencies]
 teleprobe-meta = "1"
 
-embassy-sync = { version = "0.2.0", path = "../../embassy-sync", features = ["defmt"] }
+embassy-sync = { version = "0.3.0", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.3.0", path = "../../embassy-executor", features = ["nightly", "arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
-embassy-time = { version = "0.1.2", path = "../../embassy-time", features = ["defmt", "tick-hz-32_768", "defmt-timestamp-uptime"] }
+embassy-time = { version = "0.1.3", path = "../../embassy-time", features = ["defmt", "tick-hz-32_768", "defmt-timestamp-uptime"] }
 embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "unstable-pac", "memory-x", "time-driver-any"]  }
 embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
 embassy-stm32-wpan = { version = "0.1.0", path = "../../embassy-stm32-wpan", optional = true, features = ["defmt", "stm32wb55rg", "ble"] }
@@ -47,6 +53,7 @@ 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 }
+static_cell = {version = "1.1", features = ["nightly"] }
 
 chrono = { version = "^0.4", default-features = false, optional = true}
 
@@ -88,6 +95,11 @@ path = "src/bin/spi_dma.rs"
 required-features = []
 
 [[bin]]
+name = "stop"
+path = "src/bin/stop.rs"
+required-features = [ "stop", "chrono",]
+
+[[bin]]
 name = "timer"
 path = "src/bin/timer.rs"
 required-features = []
diff --git a/tests/stm32/build.rs b/tests/stm32/build.rs
index 2e71954d7..9aabf8541 100644
--- a/tests/stm32/build.rs
+++ b/tests/stm32/build.rs
@@ -12,7 +12,8 @@ fn main() -> Result<(), Box<dyn Error>> {
     if cfg!(any(
         feature = "stm32f103c8",
         feature = "stm32c031c6",
-        feature = "stm32wb55rg"
+        feature = "stm32wb55rg",
+        feature = "stm32l073rz",
     )) {
         println!("cargo:rustc-link-arg-bins=-Tlink.x");
         println!("cargo:rerun-if-changed=link.x");
diff --git a/tests/stm32/src/bin/gpio.rs b/tests/stm32/src/bin/gpio.rs
index aad174431..49d9a60f7 100644
--- a/tests/stm32/src/bin/gpio.rs
+++ b/tests/stm32/src/bin/gpio.rs
@@ -16,24 +16,8 @@ async fn main(_spawner: Spawner) {
 
     // Arduino pins D0 and D1
     // They're connected together with a 1K resistor.
-    #[cfg(feature = "stm32f103c8")]
-    let (mut a, mut b) = (p.PA9, p.PA10);
-    #[cfg(feature = "stm32g491re")]
-    let (mut a, mut b) = (p.PC4, p.PC5);
-    #[cfg(feature = "stm32g071rb")]
-    let (mut a, mut b) = (p.PC4, p.PC5);
-    #[cfg(feature = "stm32f429zi")]
-    let (mut a, mut b) = (p.PG14, p.PG9);
-    #[cfg(feature = "stm32wb55rg")]
-    let (mut a, mut b) = (p.PA3, p.PA2);
-    #[cfg(feature = "stm32h755zi")]
-    let (mut a, mut b) = (p.PB6, p.PB7);
-    #[cfg(feature = "stm32u585ai")]
-    let (mut a, mut b) = (p.PD9, p.PD8);
-    #[cfg(feature = "stm32h563zi")]
-    let (mut a, mut b) = (p.PB6, p.PB7);
-    #[cfg(feature = "stm32c031c6")]
-    let (mut a, mut b) = (p.PB6, p.PB7);
+    let mut a = peri!(p, UART_RX);
+    let mut b = peri!(p, UART_TX);
 
     // Test initial output
     {
diff --git a/tests/stm32/src/bin/rtc.rs b/tests/stm32/src/bin/rtc.rs
index 7df415b44..22be6fac5 100644
--- a/tests/stm32/src/bin/rtc.rs
+++ b/tests/stm32/src/bin/rtc.rs
@@ -10,14 +10,17 @@ use chrono::{NaiveDate, NaiveDateTime};
 use common::*;
 use defmt::assert;
 use embassy_executor::Spawner;
-use embassy_stm32::rtc::{Rtc, RtcClockSource, RtcConfig};
+use embassy_stm32::rcc::RtcClockSource;
+use embassy_stm32::rtc::{Rtc, RtcConfig};
+use embassy_stm32::time::Hertz;
 use embassy_time::{Duration, Timer};
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let mut config = config();
 
-    config.rcc.rtc = Some(RtcClockSource::LSI);
+    config.rcc.lse = Some(Hertz(32_768));
+    config.rcc.rtc = Some(RtcClockSource::LSE);
 
     let p = embassy_stm32::init(config);
     info!("Hello World!");
diff --git a/tests/stm32/src/bin/spi.rs b/tests/stm32/src/bin/spi.rs
index e51dd5bf2..b0fb75d69 100644
--- a/tests/stm32/src/bin/spi.rs
+++ b/tests/stm32/src/bin/spi.rs
@@ -16,24 +16,10 @@ async fn main(_spawner: Spawner) {
     let p = embassy_stm32::init(config());
     info!("Hello World!");
 
-    #[cfg(feature = "stm32f103c8")]
-    let (spi, sck, mosi, miso) = (p.SPI1, p.PA5, p.PA7, p.PA6);
-    #[cfg(feature = "stm32f429zi")]
-    let (spi, sck, mosi, miso) = (p.SPI1, p.PA5, p.PA7, p.PA6);
-    #[cfg(feature = "stm32h755zi")]
-    let (spi, sck, mosi, miso) = (p.SPI1, p.PA5, p.PB5, p.PA6);
-    #[cfg(feature = "stm32g491re")]
-    let (spi, sck, mosi, miso) = (p.SPI1, p.PA5, p.PA7, p.PA6);
-    #[cfg(feature = "stm32g071rb")]
-    let (spi, sck, mosi, miso) = (p.SPI1, p.PA5, p.PA7, p.PA6);
-    #[cfg(feature = "stm32wb55rg")]
-    let (spi, sck, mosi, miso) = (p.SPI1, p.PA5, p.PA7, p.PA6);
-    #[cfg(feature = "stm32u585ai")]
-    let (spi, sck, mosi, miso) = (p.SPI1, p.PE13, p.PE15, p.PE14);
-    #[cfg(feature = "stm32h563zi")]
-    let (spi, sck, mosi, miso) = (p.SPI4, p.PE12, p.PE14, p.PE13);
-    #[cfg(feature = "stm32c031c6")]
-    let (spi, sck, mosi, miso) = (p.SPI1, p.PA5, p.PA7, p.PA6);
+    let spi = peri!(p, SPI);
+    let sck = peri!(p, SPI_SCK);
+    let mosi = peri!(p, SPI_MOSI);
+    let miso = peri!(p, SPI_MISO);
 
     let mut spi_config = spi::Config::default();
     spi_config.frequency = Hertz(1_000_000);
diff --git a/tests/stm32/src/bin/spi_dma.rs b/tests/stm32/src/bin/spi_dma.rs
index d45cbe45b..212cfae5d 100644
--- a/tests/stm32/src/bin/spi_dma.rs
+++ b/tests/stm32/src/bin/spi_dma.rs
@@ -15,24 +15,12 @@ async fn main(_spawner: Spawner) {
     let p = embassy_stm32::init(config());
     info!("Hello World!");
 
-    #[cfg(feature = "stm32f103c8")]
-    let (spi, sck, mosi, miso, tx_dma, rx_dma) = (p.SPI1, p.PA5, p.PA7, p.PA6, p.DMA1_CH3, p.DMA1_CH2);
-    #[cfg(feature = "stm32f429zi")]
-    let (spi, sck, mosi, miso, tx_dma, rx_dma) = (p.SPI1, p.PA5, p.PA7, p.PA6, p.DMA2_CH3, p.DMA2_CH2);
-    #[cfg(feature = "stm32h755zi")]
-    let (spi, sck, mosi, miso, tx_dma, rx_dma) = (p.SPI1, p.PA5, p.PB5, p.PA6, p.DMA1_CH0, p.DMA1_CH1);
-    #[cfg(feature = "stm32g491re")]
-    let (spi, sck, mosi, miso, tx_dma, rx_dma) = (p.SPI1, p.PA5, p.PA7, p.PA6, p.DMA1_CH1, p.DMA1_CH2);
-    #[cfg(feature = "stm32g071rb")]
-    let (spi, sck, mosi, miso, tx_dma, rx_dma) = (p.SPI1, p.PA5, p.PA7, p.PA6, p.DMA1_CH1, p.DMA1_CH2);
-    #[cfg(feature = "stm32wb55rg")]
-    let (spi, sck, mosi, miso, tx_dma, rx_dma) = (p.SPI1, p.PA5, p.PA7, p.PA6, p.DMA1_CH1, p.DMA1_CH2);
-    #[cfg(feature = "stm32u585ai")]
-    let (spi, sck, mosi, miso, tx_dma, rx_dma) = (p.SPI1, p.PE13, p.PE15, p.PE14, p.GPDMA1_CH0, p.GPDMA1_CH1);
-    #[cfg(feature = "stm32h563zi")]
-    let (spi, sck, mosi, miso, tx_dma, rx_dma) = (p.SPI4, p.PE12, p.PE14, p.PE13, p.GPDMA1_CH0, p.GPDMA1_CH1);
-    #[cfg(feature = "stm32c031c6")]
-    let (spi, sck, mosi, miso, tx_dma, rx_dma) = (p.SPI1, p.PA5, p.PA7, p.PA6, p.DMA1_CH1, p.DMA1_CH2);
+    let spi = peri!(p, SPI);
+    let sck = peri!(p, SPI_SCK);
+    let mosi = peri!(p, SPI_MOSI);
+    let miso = peri!(p, SPI_MISO);
+    let tx_dma = peri!(p, SPI_TX_DMA);
+    let rx_dma = peri!(p, SPI_RX_DMA);
 
     let mut spi_config = spi::Config::default();
     spi_config.frequency = Hertz(1_000_000);
diff --git a/tests/stm32/src/bin/stop.rs b/tests/stm32/src/bin/stop.rs
new file mode 100644
index 000000000..48d59b794
--- /dev/null
+++ b/tests/stm32/src/bin/stop.rs
@@ -0,0 +1,71 @@
+// required-features: stop,chrono
+
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+#[path = "../common.rs"]
+mod common;
+
+use chrono::NaiveDate;
+use common::*;
+use cortex_m_rt::entry;
+use embassy_executor::Spawner;
+use embassy_stm32::low_power::{stop_with_rtc, Executor};
+use embassy_stm32::rcc::RtcClockSource;
+use embassy_stm32::rtc::{Rtc, RtcConfig};
+use embassy_stm32::time::Hertz;
+use embassy_time::{Duration, Timer};
+use static_cell::make_static;
+
+#[entry]
+fn main() -> ! {
+    Executor::take().run(|spawner| {
+        unwrap!(spawner.spawn(async_main(spawner)));
+    });
+}
+
+#[embassy_executor::task]
+async fn task_1() {
+    for _ in 0..9 {
+        info!("task 1: waiting for 500ms...");
+        Timer::after(Duration::from_millis(500)).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn task_2() {
+    for _ in 0..5 {
+        info!("task 2: waiting for 1000ms...");
+        Timer::after(Duration::from_millis(1000)).await;
+    }
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
+
+#[embassy_executor::task]
+async fn async_main(spawner: Spawner) {
+    let mut config = config();
+
+    config.rcc.lse = Some(Hertz(32_768));
+    config.rcc.rtc = Some(RtcClockSource::LSE);
+
+    let p = embassy_stm32::init(config);
+    info!("Hello World!");
+
+    let now = NaiveDate::from_ymd_opt(2020, 5, 15)
+        .unwrap()
+        .and_hms_opt(10, 30, 15)
+        .unwrap();
+
+    let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
+
+    rtc.set_datetime(now.into()).expect("datetime not set");
+
+    let rtc = make_static!(rtc);
+
+    stop_with_rtc(rtc);
+
+    spawner.spawn(task_1()).unwrap();
+    spawner.spawn(task_2()).unwrap();
+}
diff --git a/tests/stm32/src/bin/usart.rs b/tests/stm32/src/bin/usart.rs
index 394005b82..74a81b4ec 100644
--- a/tests/stm32/src/bin/usart.rs
+++ b/tests/stm32/src/bin/usart.rs
@@ -5,38 +5,11 @@
 mod common;
 
 use common::*;
-use defmt::assert_eq;
+use defmt::{assert, assert_eq, unreachable};
 use embassy_executor::Spawner;
 use embassy_stm32::dma::NoDma;
-use embassy_stm32::usart::{Config, Error, Uart};
-use embassy_stm32::{bind_interrupts, peripherals, usart};
-use embassy_time::{Duration, Instant};
-
-#[cfg(any(
-    feature = "stm32f103c8",
-    feature = "stm32g491re",
-    feature = "stm32g071rb",
-    feature = "stm32h755zi",
-    feature = "stm32c031c6",
-))]
-bind_interrupts!(struct Irqs {
-    USART1 => usart::InterruptHandler<peripherals::USART1>;
-});
-
-#[cfg(feature = "stm32u585ai")]
-bind_interrupts!(struct Irqs {
-    USART3 => usart::InterruptHandler<peripherals::USART3>;
-});
-
-#[cfg(feature = "stm32f429zi")]
-bind_interrupts!(struct Irqs {
-    USART6 => usart::InterruptHandler<peripherals::USART6>;
-});
-
-#[cfg(any(feature = "stm32wb55rg", feature = "stm32h563zi"))]
-bind_interrupts!(struct Irqs {
-    LPUART1 => usart::InterruptHandler<peripherals::LPUART1>;
-});
+use embassy_stm32::usart::{Config, ConfigError, Error, Uart};
+use embassy_time::{block_for, Duration, Instant};
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
@@ -45,28 +18,14 @@ async fn main(_spawner: Spawner) {
 
     // Arduino pins D0 and D1
     // They're connected together with a 1K resistor.
-    #[cfg(feature = "stm32f103c8")]
-    let (mut tx, mut rx, mut usart) = (p.PA9, p.PA10, p.USART1);
-    #[cfg(feature = "stm32g491re")]
-    let (mut tx, mut rx, mut usart) = (p.PC4, p.PC5, p.USART1);
-    #[cfg(feature = "stm32g071rb")]
-    let (mut tx, mut rx, mut usart) = (p.PC4, p.PC5, p.USART1);
-    #[cfg(feature = "stm32f429zi")]
-    let (mut tx, mut rx, mut usart) = (p.PG14, p.PG9, p.USART6);
-    #[cfg(feature = "stm32wb55rg")]
-    let (mut tx, mut rx, mut usart) = (p.PA2, p.PA3, p.LPUART1);
-    #[cfg(feature = "stm32h755zi")]
-    let (mut tx, mut rx, mut usart) = (p.PB6, p.PB7, p.USART1);
-    #[cfg(feature = "stm32u585ai")]
-    let (mut tx, mut rx, mut usart) = (p.PD8, p.PD9, p.USART3);
-    #[cfg(feature = "stm32h563zi")]
-    let (mut tx, mut rx, mut usart) = (p.PB6, p.PB7, p.LPUART1);
-    #[cfg(feature = "stm32c031c6")]
-    let (mut tx, mut rx, mut usart) = (p.PB6, p.PB7, p.USART1);
+    let mut usart = peri!(p, UART);
+    let mut rx = peri!(p, UART_RX);
+    let mut tx = peri!(p, UART_TX);
+    let irq = irqs!(UART);
 
     {
         let config = Config::default();
-        let mut usart = Uart::new(&mut usart, &mut rx, &mut tx, Irqs, NoDma, NoDma, config);
+        let mut usart = Uart::new(&mut usart, &mut rx, &mut tx, irq, NoDma, NoDma, 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.
@@ -82,13 +41,19 @@ async fn main(_spawner: Spawner) {
     // Test error handling with with an overflow error
     {
         let config = Config::default();
-        let mut usart = Uart::new(&mut usart, &mut rx, &mut tx, Irqs, NoDma, NoDma, config);
+        let mut usart = Uart::new(&mut usart, &mut rx, &mut tx, irq, NoDma, NoDma, config).unwrap();
 
         // Send enough bytes to fill the RX FIFOs off all USART versions.
-        let data = [0xC0, 0xDE, 0x12, 0x23, 0x34];
+        let data = [0; 64];
         usart.blocking_write(&data).unwrap();
         usart.blocking_flush().unwrap();
 
+        // USART can still take up to 1 bit time (?) to receive the last byte
+        // that we just flushed, so wait a bit.
+        // otherwise, we might clear the overrun flag from an *earlier* byte and
+        // it gets set again when receiving the last byte is done.
+        block_for(Duration::from_millis(1));
+
         // The error should be reported first.
         let mut buf = [0; 1];
         let err = usart.blocking_read(&mut buf);
@@ -101,22 +66,25 @@ async fn main(_spawner: Spawner) {
 
     // Test that baudrate divider is calculated correctly.
     // Do it by comparing the time it takes to send a known number of bytes.
-    for baudrate in [
-        300,
-        9600,
-        115200,
-        250_000,
-        337_934,
-        #[cfg(not(feature = "stm32f103c8"))]
-        1_000_000,
-        #[cfg(not(feature = "stm32f103c8"))]
-        2_000_000,
-    ] {
+    for baudrate in [300, 9600, 115200, 250_000, 337_934, 1_000_000, 2_000_000] {
         info!("testing baudrate {}", baudrate);
 
         let mut config = Config::default();
         config.baudrate = baudrate;
-        let mut usart = Uart::new(&mut usart, &mut rx, &mut tx, Irqs, NoDma, NoDma, config);
+        let mut usart = match Uart::new(&mut usart, &mut rx, &mut tx, irq, NoDma, NoDma, config) {
+            Ok(x) => x,
+            Err(ConfigError::BaudrateTooHigh) => {
+                info!("baudrate too high");
+                assert!(baudrate >= 1_000_000);
+                continue;
+            }
+            Err(ConfigError::BaudrateTooLow) => {
+                info!("baudrate too low");
+                assert!(baudrate <= 300);
+                continue;
+            }
+            Err(_) => unreachable!(),
+        };
 
         let n = (baudrate as usize / 100).max(64);
 
@@ -124,6 +92,7 @@ async fn main(_spawner: Spawner) {
         for _ in 0..n {
             usart.blocking_write(&[0x00]).unwrap();
         }
+        usart.blocking_flush().unwrap();
         let dur = Instant::now() - start;
         let want_dur = Duration::from_micros(n as u64 * 10 * 1_000_000 / (baudrate as u64));
         let fuzz = want_dur / 5;
diff --git a/tests/stm32/src/bin/usart_dma.rs b/tests/stm32/src/bin/usart_dma.rs
index c34d9574b..1421f6605 100644
--- a/tests/stm32/src/bin/usart_dma.rs
+++ b/tests/stm32/src/bin/usart_dma.rs
@@ -9,33 +9,6 @@ use defmt::assert_eq;
 use embassy_executor::Spawner;
 use embassy_futures::join::join;
 use embassy_stm32::usart::{Config, Uart};
-use embassy_stm32::{bind_interrupts, peripherals, usart};
-
-#[cfg(any(
-    feature = "stm32f103c8",
-    feature = "stm32g491re",
-    feature = "stm32g071rb",
-    feature = "stm32h755zi",
-    feature = "stm32c031c6",
-))]
-bind_interrupts!(struct Irqs {
-    USART1 => usart::InterruptHandler<peripherals::USART1>;
-});
-
-#[cfg(feature = "stm32u585ai")]
-bind_interrupts!(struct Irqs {
-    USART3 => usart::InterruptHandler<peripherals::USART3>;
-});
-
-#[cfg(feature = "stm32f429zi")]
-bind_interrupts!(struct Irqs {
-    USART6 => usart::InterruptHandler<peripherals::USART6>;
-});
-
-#[cfg(any(feature = "stm32wb55rg", feature = "stm32h563zi"))]
-bind_interrupts!(struct Irqs {
-    LPUART1 => usart::InterruptHandler<peripherals::LPUART1>;
-});
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
@@ -44,27 +17,15 @@ async fn main(_spawner: Spawner) {
 
     // Arduino pins D0 and D1
     // They're connected together with a 1K resistor.
-    #[cfg(feature = "stm32f103c8")]
-    let (tx, rx, usart, irq, tx_dma, rx_dma) = (p.PA9, p.PA10, p.USART1, Irqs, p.DMA1_CH4, p.DMA1_CH5);
-    #[cfg(feature = "stm32g491re")]
-    let (tx, rx, usart, irq, tx_dma, rx_dma) = (p.PC4, p.PC5, p.USART1, Irqs, p.DMA1_CH1, p.DMA1_CH2);
-    #[cfg(feature = "stm32g071rb")]
-    let (tx, rx, usart, irq, tx_dma, rx_dma) = (p.PC4, p.PC5, p.USART1, Irqs, p.DMA1_CH1, p.DMA1_CH2);
-    #[cfg(feature = "stm32f429zi")]
-    let (tx, rx, usart, irq, tx_dma, rx_dma) = (p.PG14, p.PG9, p.USART6, Irqs, p.DMA2_CH6, p.DMA2_CH1);
-    #[cfg(feature = "stm32wb55rg")]
-    let (tx, rx, usart, irq, tx_dma, rx_dma) = (p.PA2, p.PA3, p.LPUART1, Irqs, p.DMA1_CH1, p.DMA1_CH2);
-    #[cfg(feature = "stm32h755zi")]
-    let (tx, rx, usart, irq, tx_dma, rx_dma) = (p.PB6, p.PB7, p.USART1, Irqs, p.DMA1_CH0, p.DMA1_CH1);
-    #[cfg(feature = "stm32u585ai")]
-    let (tx, rx, usart, irq, tx_dma, rx_dma) = (p.PD8, p.PD9, p.USART3, Irqs, p.GPDMA1_CH0, p.GPDMA1_CH1);
-    #[cfg(feature = "stm32h563zi")]
-    let (tx, rx, usart, irq, tx_dma, rx_dma) = (p.PB6, p.PB7, p.LPUART1, Irqs, p.GPDMA1_CH0, p.GPDMA1_CH1);
-    #[cfg(feature = "stm32c031c6")]
-    let (tx, rx, usart, irq, tx_dma, rx_dma) = (p.PB6, p.PB7, p.USART1, Irqs, p.DMA1_CH1, p.DMA1_CH2);
+    let usart = peri!(p, UART);
+    let rx = peri!(p, UART_RX);
+    let tx = peri!(p, UART_TX);
+    let rx_dma = peri!(p, UART_RX_DMA);
+    let tx_dma = peri!(p, UART_TX_DMA);
+    let irq = irqs!(UART);
 
     let config = Config::default();
-    let usart = Uart::new(usart, rx, tx, irq, tx_dma, rx_dma, config);
+    let usart = Uart::new(usart, rx, tx, irq, tx_dma, rx_dma, config).unwrap();
 
     const LEN: usize = 128;
     let mut tx_buf = [0; LEN];
diff --git a/tests/stm32/src/bin/usart_rx_ringbuffered.rs b/tests/stm32/src/bin/usart_rx_ringbuffered.rs
index c8dd2643b..1ee7e596d 100644
--- a/tests/stm32/src/bin/usart_rx_ringbuffered.rs
+++ b/tests/stm32/src/bin/usart_rx_ringbuffered.rs
@@ -10,87 +10,10 @@ use common::*;
 use defmt::{assert_eq, panic};
 use embassy_executor::Spawner;
 use embassy_stm32::usart::{Config, DataBits, Parity, RingBufferedUartRx, StopBits, Uart, UartTx};
-use embassy_stm32::{bind_interrupts, peripherals, usart};
 use embassy_time::{Duration, Timer};
 use rand_chacha::ChaCha8Rng;
 use rand_core::{RngCore, SeedableRng};
 
-#[cfg(any(
-    feature = "stm32f103c8",
-    feature = "stm32g491re",
-    feature = "stm32g071rb",
-    feature = "stm32h755zi",
-    feature = "stm32c031c6",
-))]
-bind_interrupts!(struct Irqs {
-    USART1 => usart::InterruptHandler<peripherals::USART1>;
-});
-
-#[cfg(feature = "stm32u585ai")]
-bind_interrupts!(struct Irqs {
-    USART3 => usart::InterruptHandler<peripherals::USART3>;
-});
-
-#[cfg(feature = "stm32f429zi")]
-bind_interrupts!(struct Irqs {
-    USART1 => usart::InterruptHandler<peripherals::USART1>;
-    USART6 => usart::InterruptHandler<peripherals::USART6>;
-});
-
-#[cfg(any(feature = "stm32wb55rg", feature = "stm32h563zi"))]
-bind_interrupts!(struct Irqs {
-    LPUART1 => usart::InterruptHandler<peripherals::LPUART1>;
-});
-
-#[cfg(feature = "stm32f103c8")]
-mod board {
-    pub type Uart = embassy_stm32::peripherals::USART1;
-    pub type TxDma = embassy_stm32::peripherals::DMA1_CH4;
-    pub type RxDma = embassy_stm32::peripherals::DMA1_CH5;
-}
-#[cfg(feature = "stm32g491re")]
-mod board {
-    pub type Uart = embassy_stm32::peripherals::USART1;
-    pub type TxDma = embassy_stm32::peripherals::DMA1_CH1;
-    pub type RxDma = embassy_stm32::peripherals::DMA1_CH2;
-}
-#[cfg(feature = "stm32g071rb")]
-mod board {
-    pub type Uart = embassy_stm32::peripherals::USART1;
-    pub type TxDma = embassy_stm32::peripherals::DMA1_CH1;
-    pub type RxDma = embassy_stm32::peripherals::DMA1_CH2;
-}
-#[cfg(feature = "stm32f429zi")]
-mod board {
-    pub type Uart = embassy_stm32::peripherals::USART6;
-    pub type TxDma = embassy_stm32::peripherals::DMA2_CH6;
-    pub type RxDma = embassy_stm32::peripherals::DMA2_CH1;
-}
-#[cfg(feature = "stm32wb55rg")]
-mod board {
-    pub type Uart = embassy_stm32::peripherals::LPUART1;
-    pub type TxDma = embassy_stm32::peripherals::DMA1_CH1;
-    pub type RxDma = embassy_stm32::peripherals::DMA1_CH2;
-}
-#[cfg(feature = "stm32h755zi")]
-mod board {
-    pub type Uart = embassy_stm32::peripherals::USART1;
-    pub type TxDma = embassy_stm32::peripherals::DMA1_CH0;
-    pub type RxDma = embassy_stm32::peripherals::DMA1_CH1;
-}
-#[cfg(feature = "stm32u585ai")]
-mod board {
-    pub type Uart = embassy_stm32::peripherals::USART3;
-    pub type TxDma = embassy_stm32::peripherals::GPDMA1_CH0;
-    pub type RxDma = embassy_stm32::peripherals::GPDMA1_CH1;
-}
-#[cfg(feature = "stm32c031c6")]
-mod board {
-    pub type Uart = embassy_stm32::peripherals::USART1;
-    pub type TxDma = embassy_stm32::peripherals::DMA1_CH1;
-    pub type RxDma = embassy_stm32::peripherals::DMA1_CH2;
-}
-
 const DMA_BUF_SIZE: usize = 256;
 
 #[embassy_executor::main]
@@ -100,22 +23,12 @@ async fn main(spawner: Spawner) {
 
     // Arduino pins D0 and D1
     // They're connected together with a 1K resistor.
-    #[cfg(feature = "stm32f103c8")]
-    let (tx, rx, usart, tx_dma, rx_dma) = (p.PA9, p.PA10, p.USART1, p.DMA1_CH4, p.DMA1_CH5);
-    #[cfg(feature = "stm32g491re")]
-    let (tx, rx, usart, tx_dma, rx_dma) = (p.PC4, p.PC5, p.USART1, p.DMA1_CH1, p.DMA1_CH2);
-    #[cfg(feature = "stm32g071rb")]
-    let (tx, rx, usart, tx_dma, rx_dma) = (p.PC4, p.PC5, p.USART1, p.DMA1_CH1, p.DMA1_CH2);
-    #[cfg(feature = "stm32f429zi")]
-    let (tx, rx, usart, tx_dma, rx_dma) = (p.PG14, p.PG9, p.USART6, p.DMA2_CH6, p.DMA2_CH1);
-    #[cfg(feature = "stm32wb55rg")]
-    let (tx, rx, usart, tx_dma, rx_dma) = (p.PA2, p.PA3, p.LPUART1, p.DMA1_CH1, p.DMA1_CH2);
-    #[cfg(feature = "stm32h755zi")]
-    let (tx, rx, usart, tx_dma, rx_dma) = (p.PB6, p.PB7, p.USART1, p.DMA1_CH0, p.DMA1_CH1);
-    #[cfg(feature = "stm32u585ai")]
-    let (tx, rx, usart, tx_dma, rx_dma) = (p.PD8, p.PD9, p.USART3, p.GPDMA1_CH0, p.GPDMA1_CH1);
-    #[cfg(feature = "stm32c031c6")]
-    let (tx, rx, usart, tx_dma, rx_dma) = (p.PB6, p.PB7, p.USART1, p.DMA1_CH1, p.DMA1_CH2);
+    let usart = peri!(p, UART);
+    let rx = peri!(p, UART_RX);
+    let tx = peri!(p, UART_TX);
+    let rx_dma = peri!(p, UART_RX_DMA);
+    let tx_dma = peri!(p, UART_TX_DMA);
+    let irq = irqs!(UART);
 
     // To run this test, use the saturating_serial test utility to saturate the serial port
 
@@ -127,7 +40,7 @@ async fn main(spawner: Spawner) {
     config.stop_bits = StopBits::STOP1;
     config.parity = Parity::ParityNone;
 
-    let usart = Uart::new(usart, rx, tx, Irqs, tx_dma, rx_dma, config);
+    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() };
@@ -139,7 +52,7 @@ async fn main(spawner: Spawner) {
 }
 
 #[embassy_executor::task]
-async fn transmit_task(mut tx: UartTx<'static, board::Uart, board::TxDma>) {
+async fn transmit_task(mut tx: UartTx<'static, peris::UART, peris::UART_TX_DMA>) {
     // workaround https://github.com/embassy-rs/embassy/issues/1426
     Timer::after(Duration::from_millis(100) as _).await;
 
@@ -162,7 +75,7 @@ async fn transmit_task(mut tx: UartTx<'static, board::Uart, board::TxDma>) {
 }
 
 #[embassy_executor::task]
-async fn receive_task(mut rx: RingBufferedUartRx<'static, board::Uart, board::RxDma>) {
+async fn receive_task(mut rx: RingBufferedUartRx<'static, peris::UART, peris::UART_RX_DMA>) {
     info!("Ready to receive...");
 
     let mut rng = ChaCha8Rng::seed_from_u64(1337);
diff --git a/tests/stm32/src/common.rs b/tests/stm32/src/common.rs
index ca5cb43ac..9c0b8c39e 100644
--- a/tests/stm32/src/common.rs
+++ b/tests/stm32/src/common.rs
@@ -24,6 +24,131 @@ teleprobe_meta::target!(b"iot-stm32u585ai");
 teleprobe_meta::target!(b"nucleo-stm32h563zi");
 #[cfg(feature = "stm32c031c6")]
 teleprobe_meta::target!(b"nucleo-stm32c031c6");
+#[cfg(feature = "stm32l073rz")]
+teleprobe_meta::target!(b"nucleo-stm32l073rz");
+#[cfg(feature = "stm32l152re")]
+teleprobe_meta::target!(b"nucleo-stm32l152re");
+#[cfg(feature = "stm32l4a6zg")]
+teleprobe_meta::target!(b"nucleo-stm32l4a6zg");
+#[cfg(feature = "stm32l4r5zi")]
+teleprobe_meta::target!(b"nucleo-stm32l4r5zi");
+#[cfg(feature = "stm32l552ze")]
+teleprobe_meta::target!(b"nucleo-stm32l552ze");
+
+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_stm32::bind_interrupts!(struct Irqs $irq_code);
+                    Irqs
+                }};
+            )*
+        }
+
+        #[allow(unused)]
+        #[allow(non_camel_case_types)]
+        pub mod peris {
+            $(
+                pub type $name = embassy_stm32::peripherals::$peri;
+            )*
+        }
+    };
+}
+
+#[cfg(feature = "stm32f103c8")]
+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,
+    @irq UART = {USART1 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART1>;},
+);
+#[cfg(feature = "stm32g491re")]
+define_peris!(
+    UART = USART1, UART_TX = PC4, UART_RX = PC5, 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 = "stm32g071rb")]
+define_peris!(
+    UART = USART1, UART_TX = PC4, UART_RX = PC5, 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 = "stm32f429zi")]
+define_peris!(
+    UART = USART6, UART_TX = PG14, UART_RX = PG9, UART_TX_DMA = DMA2_CH6, UART_RX_DMA = DMA2_CH1,
+    SPI = SPI1, SPI_SCK = PA5, SPI_MOSI = PA7, SPI_MISO = PA6, SPI_TX_DMA = DMA2_CH3, SPI_RX_DMA = DMA2_CH2,
+    @irq UART = {USART6 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART6>;},
+);
+#[cfg(feature = "stm32wb55rg")]
+define_peris!(
+    UART = LPUART1, UART_TX = PA2, UART_RX = PA3, 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 = {LPUART1 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::LPUART1>;},
+);
+#[cfg(feature = "stm32h755zi")]
+define_peris!(
+    UART = USART1, UART_TX = PB6, UART_RX = PB7, UART_TX_DMA = DMA1_CH0, UART_RX_DMA = DMA1_CH1,
+    SPI = SPI1, SPI_SCK = PA5, SPI_MOSI = PB5, SPI_MISO = PA6, SPI_TX_DMA = DMA1_CH0, SPI_RX_DMA = DMA1_CH1,
+    @irq UART = {USART1 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART1>;},
+);
+#[cfg(feature = "stm32u585ai")]
+define_peris!(
+    UART = USART3, UART_TX = PD8, UART_RX = PD9, UART_TX_DMA = GPDMA1_CH0, UART_RX_DMA = GPDMA1_CH1,
+    SPI = SPI1, SPI_SCK = PE13, SPI_MOSI = PE15, SPI_MISO = PE14, SPI_TX_DMA = GPDMA1_CH0, SPI_RX_DMA = GPDMA1_CH1,
+    @irq UART = {USART3 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART3>;},
+);
+#[cfg(feature = "stm32h563zi")]
+define_peris!(
+    UART = LPUART1, UART_TX = PB6, UART_RX = PB7, UART_TX_DMA = GPDMA1_CH0, UART_RX_DMA = GPDMA1_CH1,
+    SPI = SPI4, SPI_SCK = PE12, SPI_MOSI = PE14, SPI_MISO = PE13, SPI_TX_DMA = GPDMA1_CH0, SPI_RX_DMA = GPDMA1_CH1,
+    @irq UART = {LPUART1 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::LPUART1>;},
+);
+#[cfg(feature = "stm32c031c6")]
+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 = "stm32l4a6zg")]
+define_peris!(
+    UART = USART3, UART_TX = PD8, UART_RX = PD9, UART_TX_DMA = DMA1_CH2, UART_RX_DMA = DMA1_CH3,
+    SPI = SPI1, SPI_SCK = PA5, SPI_MOSI = PA7, SPI_MISO = PA6, SPI_TX_DMA = DMA1_CH3, SPI_RX_DMA = DMA1_CH2,
+    @irq UART = {USART3 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART3>;},
+);
+#[cfg(feature = "stm32l4r5zi")]
+define_peris!(
+    UART = USART3, UART_TX = PD8, UART_RX = PD9, 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 = {USART3 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART3>;},
+);
+#[cfg(feature = "stm32l073rz")]
+define_peris!(
+    UART = USART4, UART_TX = PA0, UART_RX = PA1, UART_TX_DMA = DMA1_CH3, UART_RX_DMA = DMA1_CH2,
+    SPI = SPI1, SPI_SCK = PA5, SPI_MOSI = PA7, SPI_MISO = PA6, SPI_TX_DMA = DMA1_CH3, SPI_RX_DMA = DMA1_CH2,
+    @irq UART = {USART4_5 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART4>;},
+);
+#[cfg(feature = "stm32l152re")]
+define_peris!(
+    UART = USART3, UART_TX = PB10, UART_RX = PB11, UART_TX_DMA = DMA1_CH2, UART_RX_DMA = DMA1_CH3,
+    SPI = SPI1, SPI_SCK = PA5, SPI_MOSI = PA7, SPI_MISO = PA6, SPI_TX_DMA = DMA1_CH3, SPI_RX_DMA = DMA1_CH2,
+    @irq UART = {USART3 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART3>;},
+);
+#[cfg(feature = "stm32l552ze")]
+define_peris!(
+    UART = USART3, UART_TX = PD8, UART_RX = PD9, 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 = {USART3 => embassy_stm32::usart::InterruptHandler<embassy_stm32::peripherals::USART3>;},
+);
 
 pub fn config() -> Config {
     #[allow(unused_mut)]
@@ -31,14 +156,86 @@ pub fn config() -> Config {
 
     #[cfg(feature = "stm32h755zi")]
     {
-        config.rcc.sys_ck = Some(Hertz(400_000_000));
-        config.rcc.pll1.q_ck = Some(Hertz(100_000_000));
-        config.rcc.adc_clock_source = embassy_stm32::rcc::AdcClockSource::PerCk;
+        use embassy_stm32::rcc::*;
+        config.rcc.hsi = Some(Hsi::Mhz64);
+        config.rcc.csi = true;
+        config.rcc.pll_src = PllSource::Hsi;
+        config.rcc.pll1 = Some(Pll {
+            prediv: 4,
+            mul: 50,
+            divp: Some(2),
+            divq: Some(8), // SPI1 cksel defaults to pll1_q
+            divr: None,
+        });
+        config.rcc.pll2 = Some(Pll {
+            prediv: 4,
+            mul: 50,
+            divp: Some(8), // 100mhz
+            divq: None,
+            divr: None,
+        });
+        config.rcc.sys = Sysclk::Pll1P; // 400 Mhz
+        config.rcc.ahb_pre = AHBPrescaler::DIV2; // 200 Mhz
+        config.rcc.apb1_pre = APBPrescaler::DIV2; // 100 Mhz
+        config.rcc.apb2_pre = APBPrescaler::DIV2; // 100 Mhz
+        config.rcc.apb3_pre = APBPrescaler::DIV2; // 100 Mhz
+        config.rcc.apb4_pre = APBPrescaler::DIV2; // 100 Mhz
+        config.rcc.voltage_scale = VoltageScale::Scale1;
+        config.rcc.adc_clock_source = AdcClockSource::PLL2_P;
+    }
+
+    #[cfg(any(feature = "stm32l4a6zg", feature = "stm32l4r5zi"))]
+    {
+        use embassy_stm32::rcc::*;
+        config.rcc.mux = ClockSrc::PLL(
+            // 72Mhz clock (16 / 1 * 18 / 4)
+            PLLSource::HSI16,
+            PLLClkDiv::Div4,
+            PLLSrcDiv::Div1,
+            PLLMul::Mul18,
+            Some(PLLClkDiv::Div6), // 48Mhz (16 / 1 * 18 / 6)
+        );
+    }
+
+    #[cfg(any(feature = "stm32l552ze"))]
+    {
+        use embassy_stm32::rcc::*;
+        config.rcc.mux = ClockSrc::PLL(
+            // 110Mhz clock (16 / 4 * 55 / 2)
+            PLLSource::HSI16,
+            PLLClkDiv::Div2,
+            PLLSrcDiv::Div4,
+            PLLMul::Mul55,
+            None,
+        );
     }
 
     #[cfg(feature = "stm32u585ai")]
     {
-        config.rcc.mux = embassy_stm32::rcc::ClockSrc::MSI(embassy_stm32::rcc::MSIRange::Range48mhz);
+        use embassy_stm32::rcc::*;
+        config.rcc.mux = ClockSrc::MSI(MSIRange::Range48mhz);
+    }
+
+    #[cfg(feature = "stm32l073rz")]
+    {
+        use embassy_stm32::rcc::*;
+        config.rcc.mux = ClockSrc::PLL(
+            // 32Mhz clock (16 * 4 / 2)
+            PLLSource::HSI16,
+            PLLMul::Mul4,
+            PLLDiv::Div2,
+        );
+    }
+
+    #[cfg(any(feature = "stm32l152re"))]
+    {
+        use embassy_stm32::rcc::*;
+        config.rcc.mux = ClockSrc::PLL(
+            // 32Mhz clock (16 * 4 / 2)
+            PLLSource::HSI,
+            PLLMul::Mul4,
+            PLLDiv::Div2,
+        );
     }
 
     config