rp/pio: PioStateMachine{Instance, => ,Instance}

next step: get rid of the insance trait entirely

6 files changed, 42 insertions, 42 deletions

diff --git a/embassy-rp/src/pio.rs b/embassy-rp/src/pio.rs
index ffd8d53dd..a2e3d3a91 100644
--- a/embassy-rp/src/pio.rs
+++ b/embassy-rp/src/pio.rs
@@ -97,13 +97,13 @@ pub(crate) unsafe fn init() {
 
 /// Future that waits for TX-FIFO to become writable
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct FifoOutFuture<'a, PIO: PioInstance, SM: PioStateMachine + Unpin> {
+pub struct FifoOutFuture<'a, PIO: PioInstance, SM: PioStateMachineInstance + Unpin> {
     sm: &'a mut SM,
     pio: PhantomData<PIO>,
     value: u32,
 }
 
-impl<'a, PIO: PioInstance, SM: PioStateMachine + Unpin> FifoOutFuture<'a, PIO, SM> {
+impl<'a, PIO: PioInstance, SM: PioStateMachineInstance + Unpin> FifoOutFuture<'a, PIO, SM> {
     pub fn new(sm: &'a mut SM, value: u32) -> Self {
         FifoOutFuture {
             sm,
@@ -113,7 +113,7 @@ impl<'a, PIO: PioInstance, SM: PioStateMachine + Unpin> FifoOutFuture<'a, PIO, S
     }
 }
 
-impl<'d, PIO: PioInstance, SM: PioStateMachine + Unpin> Future for FifoOutFuture<'d, PIO, SM> {
+impl<'d, PIO: PioInstance, SM: PioStateMachineInstance + Unpin> Future for FifoOutFuture<'d, PIO, SM> {
     type Output = ();
     fn poll(self: FuturePin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         //debug!("Poll {},{}", PIO::PIO_NO, SM);
@@ -133,7 +133,7 @@ impl<'d, PIO: PioInstance, SM: PioStateMachine + Unpin> Future for FifoOutFuture
     }
 }
 
-impl<'d, PIO: PioInstance, SM: PioStateMachine + Unpin> Drop for FifoOutFuture<'d, PIO, SM> {
+impl<'d, PIO: PioInstance, SM: PioStateMachineInstance + Unpin> Drop for FifoOutFuture<'d, PIO, SM> {
     fn drop(&mut self) {
         unsafe {
             PIO::PIO.irqs(0).inte().write_clear(|m| {
@@ -145,12 +145,12 @@ impl<'d, PIO: PioInstance, SM: PioStateMachine + Unpin> Drop for FifoOutFuture<'
 
 /// Future that waits for RX-FIFO to become readable
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct FifoInFuture<'a, PIO: PioInstance, SM: PioStateMachine> {
+pub struct FifoInFuture<'a, PIO: PioInstance, SM: PioStateMachineInstance> {
     sm: &'a mut SM,
     pio: PhantomData<PIO>,
 }
 
-impl<'a, PIO: PioInstance, SM: PioStateMachine> FifoInFuture<'a, PIO, SM> {
+impl<'a, PIO: PioInstance, SM: PioStateMachineInstance> FifoInFuture<'a, PIO, SM> {
     pub fn new(sm: &'a mut SM) -> Self {
         FifoInFuture {
             sm,
@@ -159,7 +159,7 @@ impl<'a, PIO: PioInstance, SM: PioStateMachine> FifoInFuture<'a, PIO, SM> {
     }
 }
 
-impl<'d, PIO: PioInstance, SM: PioStateMachine> Future for FifoInFuture<'d, PIO, SM> {
+impl<'d, PIO: PioInstance, SM: PioStateMachineInstance> Future for FifoInFuture<'d, PIO, SM> {
     type Output = u32;
     fn poll(mut self: FuturePin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         //debug!("Poll {},{}", PIO::PIO_NO, SM);
@@ -178,7 +178,7 @@ impl<'d, PIO: PioInstance, SM: PioStateMachine> Future for FifoInFuture<'d, PIO,
     }
 }
 
-impl<'d, PIO: PioInstance, SM: PioStateMachine> Drop for FifoInFuture<'d, PIO, SM> {
+impl<'d, PIO: PioInstance, SM: PioStateMachineInstance> Drop for FifoInFuture<'d, PIO, SM> {
     fn drop(&mut self) {
         unsafe {
             PIO::PIO.irqs(0).inte().write_clear(|m| {
@@ -312,11 +312,11 @@ impl<'l, PIO: PioInstance> Pin<'l, PIO> {
     }
 }
 
-pub struct PioStateMachineInstance<'d, PIO: PioInstance, const SM: usize> {
+pub struct PioStateMachine<'d, PIO: PioInstance, const SM: usize> {
     pio: PhantomData<&'d PIO>,
 }
 
-impl<'d, PIO: PioInstance, const SM: usize> Drop for PioStateMachineInstance<'d, PIO, SM> {
+impl<'d, PIO: PioInstance, const SM: usize> Drop for PioStateMachine<'d, PIO, SM> {
     fn drop(&mut self) {
         unsafe {
             PIO::PIO.ctrl().write_clear(|w| w.set_sm_enable(1 << SM));
@@ -325,13 +325,13 @@ impl<'d, PIO: PioInstance, const SM: usize> Drop for PioStateMachineInstance<'d,
     }
 }
 
-impl<'d, PIO: PioInstance, const SM: usize> sealed::PioStateMachine for PioStateMachineInstance<'d, PIO, SM> {
+impl<'d, PIO: PioInstance, const SM: usize> sealed::PioStateMachineInstance for PioStateMachine<'d, PIO, SM> {
     type Pio = PIO;
     const SM: usize = SM;
 }
-impl<'d, PIO: PioInstance, const SM: usize> PioStateMachine for PioStateMachineInstance<'d, PIO, SM> {}
+impl<'d, PIO: PioInstance, const SM: usize> PioStateMachineInstance for PioStateMachine<'d, PIO, SM> {}
 
-pub trait PioStateMachine: sealed::PioStateMachine + Sized + Unpin {
+pub trait PioStateMachineInstance: sealed::PioStateMachineInstance + Sized + Unpin {
     fn restart(&mut self) {
         let mask = 1u8 << Self::SM;
         unsafe {
@@ -892,10 +892,10 @@ impl<'d, PIO: PioInstance> PioCommon<'d, PIO> {
 
 pub struct Pio<'d, PIO: PioInstance> {
     pub common: PioCommon<'d, PIO>,
-    pub sm0: PioStateMachineInstance<'d, PIO, 0>,
-    pub sm1: PioStateMachineInstance<'d, PIO, 1>,
-    pub sm2: PioStateMachineInstance<'d, PIO, 2>,
-    pub sm3: PioStateMachineInstance<'d, PIO, 3>,
+    pub sm0: PioStateMachine<'d, PIO, 0>,
+    pub sm1: PioStateMachine<'d, PIO, 1>,
+    pub sm2: PioStateMachine<'d, PIO, 2>,
+    pub sm3: PioStateMachine<'d, PIO, 3>,
 }
 
 impl<'d, PIO: PioInstance> Pio<'d, PIO> {
@@ -907,10 +907,10 @@ impl<'d, PIO: PioInstance> Pio<'d, PIO> {
                 instructions_used: 0,
                 pio: PhantomData,
             },
-            sm0: PioStateMachineInstance { pio: PhantomData },
-            sm1: PioStateMachineInstance { pio: PhantomData },
-            sm2: PioStateMachineInstance { pio: PhantomData },
-            sm3: PioStateMachineInstance { pio: PhantomData },
+            sm0: PioStateMachine { pio: PhantomData },
+            sm1: PioStateMachine { pio: PhantomData },
+            sm2: PioStateMachine { pio: PhantomData },
+            sm3: PioStateMachine { pio: PhantomData },
         }
     }
 }
@@ -944,7 +944,7 @@ fn on_pio_drop<PIO: PioInstance>() {
 mod sealed {
     use super::*;
 
-    pub trait PioStateMachine {
+    pub trait PioStateMachineInstance {
         type Pio: super::PioInstance;
         const SM: usize;
 
diff --git a/embassy-rp/src/pio_instr_util.rs b/embassy-rp/src/pio_instr_util.rs
index ae26ff1dc..f5e7d7abd 100644
--- a/embassy-rp/src/pio_instr_util.rs
+++ b/embassy-rp/src/pio_instr_util.rs
@@ -1,8 +1,8 @@
 use pio::{InSource, InstructionOperands, JmpCondition, OutDestination, SetDestination};
 
-use crate::pio::PioStateMachine;
+use crate::pio::PioStateMachineInstance;
 
-pub fn set_x<SM: PioStateMachine>(sm: &mut SM, value: u32) {
+pub fn set_x<SM: PioStateMachineInstance>(sm: &mut SM, value: u32) {
     const OUT: u16 = InstructionOperands::OUT {
         destination: OutDestination::X,
         bit_count: 32,
@@ -12,7 +12,7 @@ pub fn set_x<SM: PioStateMachine>(sm: &mut SM, value: u32) {
     sm.exec_instr(OUT);
 }
 
-pub fn get_x<SM: PioStateMachine>(sm: &mut SM) -> u32 {
+pub fn get_x<SM: PioStateMachineInstance>(sm: &mut SM) -> u32 {
     const IN: u16 = InstructionOperands::IN {
         source: InSource::X,
         bit_count: 32,
@@ -22,7 +22,7 @@ pub fn get_x<SM: PioStateMachine>(sm: &mut SM) -> u32 {
     sm.pull_rx()
 }
 
-pub fn set_y<SM: PioStateMachine>(sm: &mut SM, value: u32) {
+pub fn set_y<SM: PioStateMachineInstance>(sm: &mut SM, value: u32) {
     const OUT: u16 = InstructionOperands::OUT {
         destination: OutDestination::Y,
         bit_count: 32,
@@ -32,7 +32,7 @@ pub fn set_y<SM: PioStateMachine>(sm: &mut SM, value: u32) {
     sm.exec_instr(OUT);
 }
 
-pub fn get_y<SM: PioStateMachine>(sm: &mut SM) -> u32 {
+pub fn get_y<SM: PioStateMachineInstance>(sm: &mut SM) -> u32 {
     const IN: u16 = InstructionOperands::IN {
         source: InSource::Y,
         bit_count: 32,
@@ -43,7 +43,7 @@ pub fn get_y<SM: PioStateMachine>(sm: &mut SM) -> u32 {
     sm.pull_rx()
 }
 
-pub fn set_pindir<SM: PioStateMachine>(sm: &mut SM, data: u8) {
+pub fn set_pindir<SM: PioStateMachineInstance>(sm: &mut SM, data: u8) {
     let set: u16 = InstructionOperands::SET {
         destination: SetDestination::PINDIRS,
         data,
@@ -52,7 +52,7 @@ pub fn set_pindir<SM: PioStateMachine>(sm: &mut SM, data: u8) {
     sm.exec_instr(set);
 }
 
-pub fn set_pin<SM: PioStateMachine>(sm: &mut SM, data: u8) {
+pub fn set_pin<SM: PioStateMachineInstance>(sm: &mut SM, data: u8) {
     let set: u16 = InstructionOperands::SET {
         destination: SetDestination::PINS,
         data,
@@ -61,7 +61,7 @@ pub fn set_pin<SM: PioStateMachine>(sm: &mut SM, data: u8) {
     sm.exec_instr(set);
 }
 
-pub fn set_out_pin<SM: PioStateMachine>(sm: &mut SM, data: u32) {
+pub fn set_out_pin<SM: PioStateMachineInstance>(sm: &mut SM, data: u32) {
     const OUT: u16 = InstructionOperands::OUT {
         destination: OutDestination::PINS,
         bit_count: 32,
@@ -70,7 +70,7 @@ pub fn set_out_pin<SM: PioStateMachine>(sm: &mut SM, data: u32) {
     sm.push_tx(data);
     sm.exec_instr(OUT);
 }
-pub fn set_out_pindir<SM: PioStateMachine>(sm: &mut SM, data: u32) {
+pub fn set_out_pindir<SM: PioStateMachineInstance>(sm: &mut SM, data: u32) {
     const OUT: u16 = InstructionOperands::OUT {
         destination: OutDestination::PINDIRS,
         bit_count: 32,
@@ -80,7 +80,7 @@ pub fn set_out_pindir<SM: PioStateMachine>(sm: &mut SM, data: u32) {
     sm.exec_instr(OUT);
 }
 
-pub fn exec_jmp<SM: PioStateMachine>(sm: &mut SM, to_addr: u8) {
+pub fn exec_jmp<SM: PioStateMachineInstance>(sm: &mut SM, to_addr: u8) {
     let jmp: u16 = InstructionOperands::JMP {
         address: to_addr,
         condition: JmpCondition::Always,
diff --git a/examples/rp/src/bin/pio_async.rs b/examples/rp/src/bin/pio_async.rs
index 154cc6b65..8c02f9f16 100644
--- a/examples/rp/src/bin/pio_async.rs
+++ b/examples/rp/src/bin/pio_async.rs
@@ -9,7 +9,7 @@ use embassy_rp::pio_instr_util;
 use embassy_rp::relocate::RelocatedProgram;
 use {defmt_rtt as _, panic_probe as _};
 
-fn setup_pio_task_sm0(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachineInstance<PIO0, 0>, pin: impl PioPin) {
+fn setup_pio_task_sm0(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachine<PIO0, 0>, pin: impl PioPin) {
     // Setup sm0
 
     // Send data serially to pin
@@ -37,7 +37,7 @@ fn setup_pio_task_sm0(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachineInstanc
 }
 
 #[embassy_executor::task]
-async fn pio_task_sm0(mut sm: PioStateMachineInstance<'static, PIO0, 0>) {
+async fn pio_task_sm0(mut sm: PioStateMachine<'static, PIO0, 0>) {
     sm.set_enable(true);
 
     let mut v = 0x0f0caffa;
@@ -48,7 +48,7 @@ async fn pio_task_sm0(mut sm: PioStateMachineInstance<'static, PIO0, 0>) {
     }
 }
 
-fn setup_pio_task_sm1(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachineInstance<PIO0, 1>) {
+fn setup_pio_task_sm1(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachine<PIO0, 1>) {
     // Setupm sm1
 
     // Read 0b10101 repeatedly until ISR is full
@@ -67,7 +67,7 @@ fn setup_pio_task_sm1(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachineInstanc
 }
 
 #[embassy_executor::task]
-async fn pio_task_sm1(mut sm: PioStateMachineInstance<'static, PIO0, 1>) {
+async fn pio_task_sm1(mut sm: PioStateMachine<'static, PIO0, 1>) {
     sm.set_enable(true);
     loop {
         let rx = sm.wait_pull().await;
@@ -75,7 +75,7 @@ async fn pio_task_sm1(mut sm: PioStateMachineInstance<'static, PIO0, 1>) {
     }
 }
 
-fn setup_pio_task_sm2(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachineInstance<PIO0, 2>) {
+fn setup_pio_task_sm2(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachine<PIO0, 2>) {
     // Setup sm2
 
     // Repeatedly trigger IRQ 3
@@ -99,7 +99,7 @@ fn setup_pio_task_sm2(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachineInstanc
 }
 
 #[embassy_executor::task]
-async fn pio_task_sm2(mut sm: PioStateMachineInstance<'static, PIO0, 2>) {
+async fn pio_task_sm2(mut sm: PioStateMachine<'static, PIO0, 2>) {
     sm.set_enable(true);
     loop {
         sm.wait_irq(3).await;
diff --git a/examples/rp/src/bin/pio_dma.rs b/examples/rp/src/bin/pio_dma.rs
index 0f1f6df12..a351e2c7c 100644
--- a/examples/rp/src/bin/pio_dma.rs
+++ b/examples/rp/src/bin/pio_dma.rs
@@ -4,7 +4,7 @@
 use defmt::info;
 use embassy_executor::Spawner;
 use embassy_futures::join::join;
-use embassy_rp::pio::{Pio, PioStateMachine, ShiftDirection};
+use embassy_rp::pio::{Pio, PioStateMachineInstance, ShiftDirection};
 use embassy_rp::relocate::RelocatedProgram;
 use embassy_rp::{pio_instr_util, Peripheral};
 use {defmt_rtt as _, panic_probe as _};
diff --git a/examples/rp/src/bin/pio_hd44780.rs b/examples/rp/src/bin/pio_hd44780.rs
index 6d56bc233..249711a32 100644
--- a/examples/rp/src/bin/pio_hd44780.rs
+++ b/examples/rp/src/bin/pio_hd44780.rs
@@ -64,7 +64,7 @@ async fn main(_spawner: Spawner) {
 
 pub struct HD44780<'l> {
     dma: PeripheralRef<'l, AnyChannel>,
-    sm: PioStateMachineInstance<'l, PIO0, 0>,
+    sm: PioStateMachine<'l, PIO0, 0>,
 
     buf: [u8; 40],
 }
diff --git a/examples/rp/src/bin/ws2812-pio.rs b/examples/rp/src/bin/ws2812-pio.rs
index 8276fad64..c141560e5 100644
--- a/examples/rp/src/bin/ws2812-pio.rs
+++ b/examples/rp/src/bin/ws2812-pio.rs
@@ -13,11 +13,11 @@ use embassy_time::{Duration, Timer};
 use smart_leds::RGB8;
 use {defmt_rtt as _, panic_probe as _};
 pub struct Ws2812<'d, P: PioInstance, const S: usize> {
-    sm: PioStateMachineInstance<'d, P, S>,
+    sm: PioStateMachine<'d, P, S>,
 }
 
 impl<'d, P: PioInstance, const S: usize> Ws2812<'d, P, S> {
-    pub fn new(mut pio: PioCommon<'d, P>, mut sm: PioStateMachineInstance<'d, P, S>, pin: impl PioPin) -> Self {
+    pub fn new(mut pio: PioCommon<'d, P>, mut sm: PioStateMachine<'d, P, S>, pin: impl PioPin) -> Self {
         // Setup sm0
 
         // prepare the PIO program