Remove Peripheral trait, rename PeripheralRef->Peri.

8 files changed, 74 insertions, 68 deletions

diff --git a/tests/stm32/src/bin/can.rs b/tests/stm32/src/bin/can.rs
index 85a5f8d83..778d88a7b 100644
--- a/tests/stm32/src/bin/can.rs
+++ b/tests/stm32/src/bin/can.rs
@@ -43,7 +43,7 @@ async fn main(_spawner: Spawner) {
     // To synchronise to the bus the RX input needs to see a high level.
     // Use `mem::forget()` to release the borrow on the pin but keep the
     // pull-up resistor enabled.
-    let rx_pin = Input::new(&mut rx, Pull::Up);
+    let rx_pin = Input::new(rx.reborrow(), Pull::Up);
     core::mem::forget(rx_pin);
 
     let mut can = embassy_stm32::can::Can::new(can, rx, tx, Irqs);
diff --git a/tests/stm32/src/bin/cordic.rs b/tests/stm32/src/bin/cordic.rs
index 879ad56b6..e86eea58b 100644
--- a/tests/stm32/src/bin/cordic.rs
+++ b/tests/stm32/src/bin/cordic.rs
@@ -82,8 +82,8 @@ async fn main(_spawner: Spawner) {
     let cnt1 = defmt::unwrap!(
         cordic
             .async_calc_32bit(
-                &mut write_dma,
-                &mut read_dma,
+                write_dma.reborrow(),
+                read_dma.reborrow(),
                 &input_q1_31[2..],
                 &mut output_q1_31[cnt0..],
                 true,
diff --git a/tests/stm32/src/bin/gpio.rs b/tests/stm32/src/bin/gpio.rs
index 4a2584b4e..40b03201c 100644
--- a/tests/stm32/src/bin/gpio.rs
+++ b/tests/stm32/src/bin/gpio.rs
@@ -20,10 +20,10 @@ async fn main(_spawner: Spawner) {
 
     // Test initial output
     {
-        let b = Input::new(&mut b, Pull::None);
+        let b = Input::new(b.reborrow(), Pull::None);
 
         {
-            let a = Output::new(&mut a, Level::Low, Speed::Low);
+            let a = Output::new(a.reborrow(), Level::Low, Speed::Low);
             delay();
             assert!(b.is_low());
             assert!(!b.is_high());
@@ -31,7 +31,7 @@ async fn main(_spawner: Spawner) {
             assert!(!a.is_set_high());
         }
         {
-            let mut a = Output::new(&mut a, Level::High, Speed::Low);
+            let mut a = Output::new(a.reborrow(), Level::High, Speed::Low);
             delay();
             assert!(!b.is_low());
             assert!(b.is_high());
@@ -68,10 +68,10 @@ async fn main(_spawner: Spawner) {
 
     // Test input no pull
     {
-        let b = Input::new(&mut b, Pull::None);
+        let b = Input::new(b.reborrow(), Pull::None);
         // no pull, the status is undefined
 
-        let mut a = Output::new(&mut a, Level::Low, Speed::Low);
+        let mut a = Output::new(a.reborrow(), Level::Low, Speed::Low);
         delay();
         assert!(b.is_low());
         a.set_high();
@@ -81,11 +81,11 @@ async fn main(_spawner: Spawner) {
 
     // Test input pulldown
     {
-        let b = Input::new(&mut b, Pull::Down);
+        let b = Input::new(b.reborrow(), Pull::Down);
         delay();
         assert!(b.is_low());
 
-        let mut a = Output::new(&mut a, Level::Low, Speed::Low);
+        let mut a = Output::new(a.reborrow(), Level::Low, Speed::Low);
         delay();
         assert!(b.is_low());
         a.set_high();
@@ -95,11 +95,11 @@ async fn main(_spawner: Spawner) {
 
     // Test input pullup
     {
-        let b = Input::new(&mut b, Pull::Up);
+        let b = Input::new(b.reborrow(), Pull::Up);
         delay();
         assert!(b.is_high());
 
-        let mut a = Output::new(&mut a, Level::Low, Speed::Low);
+        let mut a = Output::new(a.reborrow(), Level::Low, Speed::Low);
         delay();
         assert!(b.is_low());
         a.set_high();
@@ -109,10 +109,10 @@ async fn main(_spawner: Spawner) {
 
     // Test output open drain
     {
-        let b = Input::new(&mut b, Pull::Down);
+        let b = Input::new(b.reborrow(), Pull::Down);
         // no pull, the status is undefined
 
-        let mut a = OutputOpenDrain::new(&mut a, Level::Low, Speed::Low);
+        let mut a = OutputOpenDrain::new(a.reborrow(), Level::Low, Speed::Low);
         delay();
         assert!(b.is_low());
         a.set_high(); // High-Z output
@@ -124,12 +124,12 @@ async fn main(_spawner: Spawner) {
     // Test initial output
     {
         //Flex pin configured as input
-        let mut b = Flex::new(&mut b);
+        let mut b = Flex::new(b.reborrow());
         b.set_as_input(Pull::None);
 
         {
             //Flex pin configured as output
-            let mut a = Flex::new(&mut a); //Flex pin configured as output
+            let mut a = Flex::new(a.reborrow()); //Flex pin configured as output
             a.set_low(); // Pin state must be set before configuring the pin, thus we avoid unknown state
             a.set_as_output(Speed::Low);
             delay();
@@ -137,7 +137,7 @@ async fn main(_spawner: Spawner) {
         }
         {
             //Flex pin configured as output
-            let mut a = Flex::new(&mut a);
+            let mut a = Flex::new(a.reborrow());
             a.set_high();
             a.set_as_output(Speed::Low);
 
@@ -148,10 +148,10 @@ async fn main(_spawner: Spawner) {
 
     // Test input no pull
     {
-        let mut b = Flex::new(&mut b);
+        let mut b = Flex::new(b.reborrow());
         b.set_as_input(Pull::None); // no pull, the status is undefined
 
-        let mut a = Flex::new(&mut a);
+        let mut a = Flex::new(a.reborrow());
         a.set_low();
         a.set_as_output(Speed::Low);
 
@@ -164,12 +164,12 @@ async fn main(_spawner: Spawner) {
 
     // Test input pulldown
     {
-        let mut b = Flex::new(&mut b);
+        let mut b = Flex::new(b.reborrow());
         b.set_as_input(Pull::Down);
         delay();
         assert!(b.is_low());
 
-        let mut a = Flex::new(&mut a);
+        let mut a = Flex::new(a.reborrow());
         a.set_low();
         a.set_as_output(Speed::Low);
         delay();
@@ -181,12 +181,12 @@ async fn main(_spawner: Spawner) {
 
     // Test input pullup
     {
-        let mut b = Flex::new(&mut b);
+        let mut b = Flex::new(b.reborrow());
         b.set_as_input(Pull::Up);
         delay();
         assert!(b.is_high());
 
-        let mut a = Flex::new(&mut a);
+        let mut a = Flex::new(a.reborrow());
         a.set_high();
         a.set_as_output(Speed::Low);
         delay();
@@ -198,10 +198,10 @@ async fn main(_spawner: Spawner) {
 
     // Test output open drain
     {
-        let mut b = Flex::new(&mut b);
+        let mut b = Flex::new(b.reborrow());
         b.set_as_input(Pull::Down);
 
-        let mut a = Flex::new(&mut a);
+        let mut a = Flex::new(a.reborrow());
         a.set_low();
         a.set_as_input_output(Speed::Low);
         delay();
diff --git a/tests/stm32/src/bin/sdmmc.rs b/tests/stm32/src/bin/sdmmc.rs
index a6bc117c0..07f17b569 100644
--- a/tests/stm32/src/bin/sdmmc.rs
+++ b/tests/stm32/src/bin/sdmmc.rs
@@ -40,15 +40,15 @@ async fn main(_spawner: Spawner) {
     // ======== Try 4bit. ==============
     info!("initializing in 4-bit mode...");
     let mut s = Sdmmc::new_4bit(
-        &mut sdmmc,
+        sdmmc.reborrow(),
         Irqs,
-        &mut dma,
-        &mut clk,
-        &mut cmd,
-        &mut d0,
-        &mut d1,
-        &mut d2,
-        &mut d3,
+        dma.reborrow(),
+        clk.reborrow(),
+        cmd.reborrow(),
+        d0.reborrow(),
+        d1.reborrow(),
+        d2.reborrow(),
+        d3.reborrow(),
         Default::default(),
     );
 
@@ -89,12 +89,12 @@ async fn main(_spawner: Spawner) {
     // ======== Try 1bit. ==============
     info!("initializing in 1-bit mode...");
     let mut s = Sdmmc::new_1bit(
-        &mut sdmmc,
+        sdmmc.reborrow(),
         Irqs,
-        &mut dma,
-        &mut clk,
-        &mut cmd,
-        &mut d0,
+        dma.reborrow(),
+        clk.reborrow(),
+        cmd.reborrow(),
+        d0.reborrow(),
         Default::default(),
     );
 
diff --git a/tests/stm32/src/bin/spi.rs b/tests/stm32/src/bin/spi.rs
index 9712a8c5a..e8310866a 100644
--- a/tests/stm32/src/bin/spi.rs
+++ b/tests/stm32/src/bin/spi.rs
@@ -25,10 +25,10 @@ async fn main(_spawner: Spawner) {
     spi_config.frequency = Hertz(1_000_000);
 
     let mut spi = Spi::new_blocking(
-        &mut spi_peri,
-        &mut sck,  // Arduino D13
-        &mut mosi, // Arduino D11
-        &mut miso, // Arduino D12
+        spi_peri.reborrow(),
+        sck.reborrow(),  // Arduino D13
+        mosi.reborrow(), // Arduino D11
+        miso.reborrow(), // Arduino D12
         spi_config,
     );
 
@@ -43,20 +43,20 @@ async fn main(_spawner: Spawner) {
     defmt::assert!(!embassy_stm32::pac::RCC.apb2enr().read().spi1en());
 
     // test rx-only configuration
-    let mut spi = Spi::new_blocking_rxonly(&mut spi_peri, &mut sck, &mut miso, spi_config);
-    let mut mosi_out = Output::new(&mut mosi, Level::Low, Speed::VeryHigh);
+    let mut spi = Spi::new_blocking_rxonly(spi_peri.reborrow(), sck.reborrow(), miso.reborrow(), spi_config);
+    let mut mosi_out = Output::new(mosi.reborrow(), Level::Low, Speed::VeryHigh);
 
     test_rx::<u8>(&mut spi, &mut mosi_out);
     test_rx::<u16>(&mut spi, &mut mosi_out);
     drop(spi);
     drop(mosi_out);
 
-    let mut spi = Spi::new_blocking_txonly(&mut spi_peri, &mut sck, &mut mosi, spi_config);
+    let mut spi = Spi::new_blocking_txonly(spi_peri.reborrow(), sck.reborrow(), mosi.reborrow(), spi_config);
     test_tx::<u8>(&mut spi);
     test_tx::<u16>(&mut spi);
     drop(spi);
 
-    let mut spi = Spi::new_blocking_txonly_nosck(&mut spi_peri, &mut mosi, spi_config);
+    let mut spi = Spi::new_blocking_txonly_nosck(spi_peri.reborrow(), mosi.reborrow(), spi_config);
     test_tx::<u8>(&mut spi);
     test_tx::<u16>(&mut spi);
     drop(spi);
diff --git a/tests/stm32/src/bin/spi_dma.rs b/tests/stm32/src/bin/spi_dma.rs
index 307409a16..b4fdb8faa 100644
--- a/tests/stm32/src/bin/spi_dma.rs
+++ b/tests/stm32/src/bin/spi_dma.rs
@@ -27,12 +27,12 @@ async fn main(_spawner: Spawner) {
     spi_config.frequency = Hertz(1_000_000);
 
     let mut spi = Spi::new(
-        &mut spi_peri,
-        &mut sck,  // Arduino D13
-        &mut mosi, // Arduino D11
-        &mut miso, // Arduino D12
-        &mut tx_dma,
-        &mut rx_dma,
+        spi_peri.reborrow(),
+        sck.reborrow(),  // Arduino D13
+        mosi.reborrow(), // Arduino D11
+        miso.reborrow(), // Arduino D12
+        tx_dma.reborrow(),
+        rx_dma.reborrow(),
         spi_config,
     );
 
@@ -42,28 +42,34 @@ async fn main(_spawner: Spawner) {
 
     // test rx-only configuration
     let mut spi = Spi::new_rxonly(
-        &mut spi_peri,
-        &mut sck,
-        &mut miso,
+        spi_peri.reborrow(),
+        sck.reborrow(),
+        miso.reborrow(),
         // SPIv1/f1 requires txdma even if rxonly.
         #[cfg(not(feature = "spi-v345"))]
-        &mut tx_dma,
-        &mut rx_dma,
+        tx_dma.reborrow(),
+        rx_dma.reborrow(),
         spi_config,
     );
-    let mut mosi_out = Output::new(&mut mosi, Level::Low, Speed::VeryHigh);
+    let mut mosi_out = Output::new(mosi.reborrow(), Level::Low, Speed::VeryHigh);
 
     test_rx::<u8>(&mut spi, &mut mosi_out).await;
     test_rx::<u16>(&mut spi, &mut mosi_out).await;
     drop(spi);
     drop(mosi_out);
 
-    let mut spi = Spi::new_txonly(&mut spi_peri, &mut sck, &mut mosi, &mut tx_dma, spi_config);
+    let mut spi = Spi::new_txonly(
+        spi_peri.reborrow(),
+        sck.reborrow(),
+        mosi.reborrow(),
+        tx_dma.reborrow(),
+        spi_config,
+    );
     test_tx::<u8>(&mut spi).await;
     test_tx::<u16>(&mut spi).await;
     drop(spi);
 
-    let mut spi = Spi::new_txonly_nosck(&mut spi_peri, &mut mosi, &mut tx_dma, spi_config);
+    let mut spi = Spi::new_txonly_nosck(spi_peri.reborrow(), mosi.reborrow(), tx_dma.reborrow(), spi_config);
     test_tx::<u8>(&mut spi).await;
     test_tx::<u16>(&mut spi).await;
     drop(spi);
diff --git a/tests/stm32/src/bin/ucpd.rs b/tests/stm32/src/bin/ucpd.rs
index bd7b35d6b..97aefe1a0 100644
--- a/tests/stm32/src/bin/ucpd.rs
+++ b/tests/stm32/src/bin/ucpd.rs
@@ -9,7 +9,7 @@ use defmt::{assert, assert_eq};
 use embassy_executor::Spawner;
 use embassy_futures::join::join;
 use embassy_stm32::ucpd::{self, CcPhy, CcPull, CcSel, CcVState, RxError, Ucpd};
-use embassy_stm32::{bind_interrupts, peripherals};
+use embassy_stm32::{bind_interrupts, peripherals, Peri};
 use embassy_time::Timer;
 
 bind_interrupts!(struct Irqs {
@@ -28,8 +28,8 @@ async fn wait_for_vstate<T: ucpd::Instance>(cc_phy: &mut CcPhy<'_, T>, vstate: C
 
 async fn source(
     mut ucpd: Ucpd<'static, peripherals::UCPD1>,
-    rx_dma: peripherals::DMA1_CH1,
-    tx_dma: peripherals::DMA1_CH2,
+    rx_dma: Peri<'static, peripherals::DMA1_CH1>,
+    tx_dma: Peri<'static, peripherals::DMA1_CH2>,
 ) {
     debug!("source: setting default current pull-up");
     ucpd.cc_phy().set_pull(CcPull::SourceDefaultUsb);
@@ -65,8 +65,8 @@ async fn source(
 
 async fn sink(
     mut ucpd: Ucpd<'static, peripherals::UCPD2>,
-    rx_dma: peripherals::DMA1_CH3,
-    tx_dma: peripherals::DMA1_CH4,
+    rx_dma: Peri<'static, peripherals::DMA1_CH3>,
+    tx_dma: Peri<'static, peripherals::DMA1_CH4>,
 ) {
     debug!("sink: setting pull down");
     ucpd.cc_phy().set_pull(CcPull::Sink);
diff --git a/tests/stm32/src/bin/usart.rs b/tests/stm32/src/bin/usart.rs
index 2f601ad0e..129c7b692 100644
--- a/tests/stm32/src/bin/usart.rs
+++ b/tests/stm32/src/bin/usart.rs
@@ -22,7 +22,7 @@ async fn main(_spawner: Spawner) {
 
     {
         let config = Config::default();
-        let mut usart = Uart::new_blocking(&mut usart, &mut rx, &mut tx, config).unwrap();
+        let mut usart = Uart::new_blocking(usart.reborrow(), rx.reborrow(), tx.reborrow(), config).unwrap();
 
         // We can't send too many bytes, they have to fit in the FIFO.
         // This is because we aren't sending+receiving at the same time.
@@ -45,7 +45,7 @@ async fn main(_spawner: Spawner) {
     // Test error handling with with an overflow error
     {
         let config = Config::default();
-        let mut usart = Uart::new_blocking(&mut usart, &mut rx, &mut tx, config).unwrap();
+        let mut usart = Uart::new_blocking(usart.reborrow(), rx.reborrow(), tx.reborrow(), config).unwrap();
 
         // Send enough bytes to fill the RX FIFOs off all USART versions.
         let data = [0; 64];
@@ -75,7 +75,7 @@ async fn main(_spawner: Spawner) {
 
         let mut config = Config::default();
         config.baudrate = baudrate;
-        let mut usart = match Uart::new_blocking(&mut usart, &mut rx, &mut tx, config) {
+        let mut usart = match Uart::new_blocking(usart.reborrow(), rx.reborrow(), tx.reborrow(), config) {
             Ok(x) => x,
             Err(ConfigError::BaudrateTooHigh) => {
                 info!("baudrate too high");