From a1867f0d742f597a25384e4a33209beeec7ec676 Mon Sep 17 00:00:00 2001
From: i509VCB <git@i509.me>
Date: Sun, 6 Jul 2025 17:35:19 -0500
Subject: mspm0: add buffered uart driver

And tests for G3507.
---
 tests/mspm0/Cargo.toml               |   3 +
 tests/mspm0/src/bin/uart_buffered.rs | 115 +++++++++++++++++++++++++++++++++++
 2 files changed, 118 insertions(+)
 create mode 100644 tests/mspm0/src/bin/uart_buffered.rs

(limited to 'tests')

diff --git a/tests/mspm0/Cargo.toml b/tests/mspm0/Cargo.toml
index 2d5b8cd52..5ba3e586b 100644
--- a/tests/mspm0/Cargo.toml
+++ b/tests/mspm0/Cargo.toml
@@ -13,6 +13,7 @@ teleprobe-meta = "1.1"
 
 embassy-sync = { version = "0.7.0", path = "../../embassy-sync", features = [ "defmt" ] }
 embassy-executor = { version = "0.7.0", path = "../../embassy-executor", features = [ "arch-cortex-m", "executor-thread", "defmt" ] }
+embassy-futures = { version = "0.1.0", path = "../../embassy-futures" }
 embassy-time = { version = "0.4.0", path = "../../embassy-time", features = [ "defmt" ] }
 embassy-mspm0 = { version = "0.1.0", path = "../../embassy-mspm0", features = [ "rt", "defmt", "unstable-pac", "time-driver-any" ]  }
 embassy-embedded-hal = { version = "0.3.1", path = "../../embassy-embedded-hal/"}
@@ -24,6 +25,8 @@ cortex-m = { version = "0.7.6", features = [ "inline-asm", "critical-section-sin
 cortex-m-rt = "0.7.0"
 embedded-hal = { package = "embedded-hal", version = "1.0" }
 embedded-hal-async = { version = "1.0" }
+embedded-io = { version = "0.6.1", features = ["defmt-03"] }
+embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 static_cell = "2"
 portable-atomic = { version = "1.5", features = ["critical-section"] }
diff --git a/tests/mspm0/src/bin/uart_buffered.rs b/tests/mspm0/src/bin/uart_buffered.rs
new file mode 100644
index 000000000..135ac1287
--- /dev/null
+++ b/tests/mspm0/src/bin/uart_buffered.rs
@@ -0,0 +1,115 @@
+#![no_std]
+#![no_main]
+
+#[cfg(feature = "mspm0g3507")]
+teleprobe_meta::target!(b"lp-mspm0g3507");
+
+use defmt::{assert_eq, unwrap, *};
+use embassy_executor::Spawner;
+use embassy_mspm0::uart::{BufferedInterruptHandler, BufferedUart, Config};
+use embassy_mspm0::{bind_interrupts, peripherals};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    UART1 => BufferedInterruptHandler<peripherals::UART1>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_mspm0::init(Default::default());
+    info!("Hello World!");
+
+    // TODO: Allow creating a looped-back UART (so pins are not needed).
+    // Do not select default UART since the virtual COM port is attached to UART0.
+    #[cfg(any(feature = "mspm0g3507"))]
+    let (mut tx, mut rx, mut uart) = (p.PA8, p.PA9, p.UART1);
+
+    {
+        use embedded_io_async::{Read, Write};
+
+        let mut config = Config::default();
+        config.loop_back_enable = true;
+        config.fifo_enable = false;
+
+        let tx_buf = &mut [0u8; 16];
+        let rx_buf = &mut [0u8; 16];
+        let mut uart = unwrap!(BufferedUart::new(
+            uart.reborrow(),
+            tx.reborrow(),
+            rx.reborrow(),
+            Irqs,
+            tx_buf,
+            rx_buf,
+            config
+        ));
+
+        let mut buf = [0; 16];
+        for (j, b) in buf.iter_mut().enumerate() {
+            *b = j as u8;
+        }
+
+        unwrap!(uart.write_all(&buf).await);
+        unwrap!(uart.flush().await);
+
+        unwrap!(uart.read_exact(&mut buf).await);
+        for (j, b) in buf.iter().enumerate() {
+            assert_eq!(*b, j as u8);
+        }
+
+        // Buffer is unclogged, should be able to write again.
+        unwrap!(uart.write_all(&buf).await);
+        unwrap!(uart.flush().await);
+
+        unwrap!(uart.read_exact(&mut buf).await);
+        for (j, b) in buf.iter().enumerate() {
+            assert_eq!(*b, j as u8);
+        }
+    }
+
+    info!("Blocking buffered");
+    {
+        use embedded_io::{Read, Write};
+
+        let mut config = Config::default();
+        config.loop_back_enable = true;
+        config.fifo_enable = false;
+
+        let tx_buf = &mut [0u8; 16];
+        let rx_buf = &mut [0u8; 16];
+        let mut uart = unwrap!(BufferedUart::new(
+            uart.reborrow(),
+            tx.reborrow(),
+            rx.reborrow(),
+            Irqs,
+            tx_buf,
+            rx_buf,
+            config
+        ));
+
+        let mut buf = [0; 16];
+
+        for (j, b) in buf.iter_mut().enumerate() {
+            *b = j as u8;
+        }
+
+        unwrap!(uart.write_all(&buf));
+        unwrap!(uart.blocking_flush());
+        unwrap!(uart.read_exact(&mut buf));
+
+        for (j, b) in buf.iter().enumerate() {
+            assert_eq!(*b, j as u8);
+        }
+
+        // Buffer is unclogged, should be able to write again.
+        unwrap!(uart.write_all(&buf));
+        unwrap!(uart.blocking_flush());
+        unwrap!(uart.read_exact(&mut buf));
+
+        for (j, b) in buf.iter().enumerate() {
+            assert_eq!(*b, j as u8, "at {}", j);
+        }
+    }
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
-- 
cgit