7 files changed, 188 insertions, 66 deletions

diff --git a/tests/nrf/src/bin/buffered_uart.rs b/tests/nrf/src/bin/buffered_uart.rs
index 89314bfc9..04f32832f 100644
--- a/tests/nrf/src/bin/buffered_uart.rs
+++ b/tests/nrf/src/bin/buffered_uart.rs
@@ -1,19 +1,17 @@
-// required-features: nrf52840
+// 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());
@@ -27,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 peri!(p, UART0),
             &mut p.TIMER0,
             &mut p.PPI_CH0,
             &mut p.PPI_CH1,
             &mut p.PPI_GROUP0,
-            Irqs,
-            &mut p.P1_03,
-            &mut p.P1_02,
+            irqs!(UART0_BUFFERED),
+            &mut peri!(p, PIN_A),
+            &mut peri!(p, PIN_B),
             config.clone(),
             &mut rx_buffer,
             &mut tx_buffer,
@@ -65,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/nrf/src/bin/buffered_uart_full.rs b/tests/nrf/src/bin/buffered_uart_full.rs
index a7d9a3717..09353bbe8 100644
--- a/tests/nrf/src/bin/buffered_uart_full.rs
+++ b/tests/nrf/src/bin/buffered_uart_full.rs
@@ -1,19 +1,17 @@
-// required-features: nrf52840
+// 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());
@@ -21,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,
+        irqs!(UART0_BUFFERED),
+        peri!(p, PIN_A),
+        peri!(p, PIN_B),
         config.clone(),
         &mut rx_buffer,
         &mut tx_buffer,
@@ -42,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/nrf/src/bin/buffered_uart_halves.rs b/tests/nrf/src/bin/buffered_uart_halves.rs
index ae1021f04..bdf5ad726 100644
--- a/tests/nrf/src/bin/buffered_uart_halves.rs
+++ b/tests/nrf/src/bin/buffered_uart_halves.rs
@@ -1,20 +1,17 @@
-// required-features: nrf52840
+// 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());
@@ -29,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(
+            &mut peri!(p, UART1),
+            irqs!(UART1_BUFFERED),
+            &mut peri!(p, PIN_A),
+            config.clone(),
+            &mut tx_buffer,
+        );
 
         let mut rx = BufferedUarteRx::new(
-            &mut p.UARTE0,
+            &mut peri!(p, UART0),
             &mut p.TIMER0,
             &mut p.PPI_CH0,
             &mut p.PPI_CH1,
             &mut p.PPI_GROUP0,
-            Irqs,
-            &mut p.P1_03,
+            irqs!(UART0_BUFFERED),
+            &mut peri!(p, PIN_B),
             config.clone(),
             &mut rx_buffer,
         );
diff --git a/tests/nrf/src/bin/buffered_uart_spam.rs b/tests/nrf/src/bin/buffered_uart_spam.rs
index 906723229..e8fca452e 100644
--- a/tests/nrf/src/bin/buffered_uart_spam.rs
+++ b/tests/nrf/src/bin/buffered_uart_spam.rs
@@ -1,26 +1,23 @@
-// required-features: nrf52840
+// 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());
@@ -28,23 +25,20 @@ 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(&mut peri!(p, PIN_A), 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!");
@@ -55,7 +49,7 @@ 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 = UarteTx::new(peri!(p, UART1), irqs!(UART1), peri!(p, PIN_A), 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 _)) };
diff --git a/tests/nrf/src/bin/uart_halves.rs b/tests/nrf/src/bin/uart_halves.rs
new file mode 100644
index 000000000..f48ea43a1
--- /dev/null
+++ b/tests/nrf/src/bin/uart_halves.rs
@@ -0,0 +1,41 @@
+// 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(&mut peri!(p, UART0), irqs!(UART0), &mut peri!(p, PIN_A), config.clone());
+    let mut rx = UarteRx::new(&mut peri!(p, UART1), irqs!(UART1), &mut peri!(p, PIN_B), 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..70d8b2e33
--- /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(
+        &mut peri!(p, UART0),
+        irqs!(UART0),
+        &mut peri!(p, PIN_A),
+        &mut peri!(p, PIN_B),
+        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/nrf/src/common.rs b/tests/nrf/src/common.rs
index 79336c5de..ff5299b0f 100644
--- a/tests/nrf/src/common.rs
+++ b/tests/nrf/src/common.rs
@@ -50,16 +50,53 @@ macro_rules! define_peris {
 define_peris!(PIN_A = P0_13, PIN_B = P0_14,);
 
 #[cfg(feature = "nrf52832")]
-define_peris!(PIN_A = P0_11, PIN_B = P0_12,);
+define_peris!(
+    PIN_A = P0_11, PIN_B = P0_12,
+    UART0 = UARTE0,
+    @irq UART0 = {UARTE0_UART0 => uarte::InterruptHandler<peripherals::UARTE0>;},
+    @irq UART0_BUFFERED = {UARTE0_UART0 => buffered_uarte::InterruptHandler<peripherals::UARTE0>;},
+);
 
 #[cfg(feature = "nrf52833")]
-define_peris!(PIN_A = P1_01, PIN_B = P1_02,);
+define_peris!(
+    PIN_A = P1_01, PIN_B = P1_02,
+    UART0 = UARTE0,
+    UART1 = UARTE1,
+    @irq UART0 = {UARTE0_UART0 => uarte::InterruptHandler<peripherals::UARTE0>;},
+    @irq UART1 = {UARTE1 => uarte::InterruptHandler<peripherals::UARTE1>;},
+    @irq UART0_BUFFERED = {UARTE0_UART0 => buffered_uarte::InterruptHandler<peripherals::UARTE0>;},
+    @irq UART1_BUFFERED = {UARTE1 => buffered_uarte::InterruptHandler<peripherals::UARTE1>;},
+);
 
 #[cfg(feature = "nrf52840")]
-define_peris!(PIN_A = P1_02, PIN_B = P1_03,);
+define_peris!(
+    PIN_A = P1_02, PIN_B = P1_03,
+    UART0 = UARTE0,
+    UART1 = UARTE1,
+    @irq UART0 = {UARTE0_UART0 => uarte::InterruptHandler<peripherals::UARTE0>;},
+    @irq UART1 = {UARTE1 => uarte::InterruptHandler<peripherals::UARTE1>;},
+    @irq UART0_BUFFERED = {UARTE0_UART0 => buffered_uarte::InterruptHandler<peripherals::UARTE0>;},
+    @irq UART1_BUFFERED = {UARTE1 => buffered_uarte::InterruptHandler<peripherals::UARTE1>;},
+);
 
 #[cfg(feature = "nrf5340")]
-define_peris!(PIN_A = P1_00, PIN_B = P1_01,);
+define_peris!(
+    PIN_A = P1_08, PIN_B = P1_09,
+    UART0 = SERIAL0,
+    UART1 = SERIAL1,
+    @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>;},
+);
 
 #[cfg(feature = "nrf9160")]
-define_peris!(PIN_A = P0_00, PIN_B = P0_01,);
+define_peris!(
+    PIN_A = P0_00, PIN_B = P0_01,
+    UART0 = SERIAL0,
+    UART1 = SERIAL1,
+    @irq UART0 = {UARTE0_SPIM0_SPIS0_TWIM0_TWIS0 => uarte::InterruptHandler<peripherals::SERIAL0>;},
+    @irq UART1 = {UARTE1_SPIM1_SPIS1_TWIM1_TWIS1 => uarte::InterruptHandler<peripherals::SERIAL1>;},
+    @irq UART0_BUFFERED = {UARTE0_SPIM0_SPIS0_TWIM0_TWIS0 => buffered_uarte::InterruptHandler<peripherals::SERIAL0>;},
+    @irq UART1_BUFFERED = {UARTE1_SPIM1_SPIS1_TWIM1_TWIS1 => buffered_uarte::InterruptHandler<peripherals::SERIAL1>;},
+);