rp/pio: configure state machines with Config struct

the many individual sets aren't very efficient, and almost no checks
were done to ensure that the configuration written to the hardware was
actually valid. this adresses both of these.

5 files changed, 83 insertions, 64 deletions

diff --git a/examples/rp/Cargo.toml b/examples/rp/Cargo.toml
index 57f6f5c67..d2829df99 100644
--- a/examples/rp/Cargo.toml
+++ b/examples/rp/Cargo.toml
@@ -22,6 +22,8 @@ lorawan = { version = "0.7.3", default-features = false, features = ["default-cr
 
 defmt = "0.3"
 defmt-rtt = "0.4"
+fixed = "1.23.1"
+fixed-macro = "1.2"
 
 #cortex-m = { version = "0.7.6", features = ["critical-section-single-core"] }
 cortex-m = { version = "0.7.6", features = ["inline-asm"] }
diff --git a/examples/rp/src/bin/pio_async.rs b/examples/rp/src/bin/pio_async.rs
index 9f47c2316..12484e882 100644
--- a/examples/rp/src/bin/pio_async.rs
+++ b/examples/rp/src/bin/pio_async.rs
@@ -2,10 +2,13 @@
 #![no_main]
 #![feature(type_alias_impl_trait)]
 use defmt::info;
+use embassy_embedded_hal::SetConfig;
 use embassy_executor::Spawner;
 use embassy_rp::peripherals::PIO0;
-use embassy_rp::pio::{Common, Irq, Pio, PioPin, ShiftDirection, StateMachine};
+use embassy_rp::pio::{Common, Config, Irq, Pio, PioPin, ShiftDirection, StateMachine};
 use embassy_rp::relocate::RelocatedProgram;
+use fixed::traits::ToFixed;
+use fixed_macro::types::U56F8;
 use {defmt_rtt as _, panic_probe as _};
 
 fn setup_pio_task_sm0<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a, PIO0, 0>, pin: impl PioPin) {
@@ -21,15 +24,14 @@ fn setup_pio_task_sm0<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a,
     );
 
     let relocated = RelocatedProgram::new(&prg.program);
-    sm.use_program(&pio.load_program(&relocated), &[]);
+    let mut cfg = Config::default();
+    cfg.use_program(&pio.load_program(&relocated), &[]);
     let out_pin = pio.make_pio_pin(pin);
-    let pio_pins = [&out_pin];
-    sm.set_out_pins(&pio_pins);
-    sm.set_clkdiv((125e6 / 20.0 / 2e2 * 256.0) as u32);
-    sm.set_set_range(0, 1);
-
-    sm.set_autopull(true);
-    sm.set_out_shift_dir(ShiftDirection::Left);
+    cfg.set_out_pins(&[&out_pin]);
+    cfg.set_set_pins(&[&out_pin]);
+    cfg.clock_divider = (U56F8!(125_000_000) / 20 / 200).to_fixed();
+    cfg.shift_out.auto_fill = true;
+    sm.set_config(&cfg);
 }
 
 #[embassy_executor::task]
@@ -51,11 +53,12 @@ fn setup_pio_task_sm1<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a,
     let prg = pio_proc::pio_asm!(".origin 8", "set x, 0x15", ".wrap_target", "in x, 5 [31]", ".wrap",);
 
     let relocated = RelocatedProgram::new(&prg.program);
-    sm.use_program(&pio.load_program(&relocated), &[]);
-    sm.set_clkdiv((125e6 / 2e3 * 256.0) as u32);
-    sm.set_set_range(0, 0);
-    sm.set_autopush(true);
-    sm.set_in_shift_dir(ShiftDirection::Right);
+    let mut cfg = Config::default();
+    cfg.use_program(&pio.load_program(&relocated), &[]);
+    cfg.clock_divider = (U56F8!(125_000_000) / 2000).to_fixed();
+    cfg.shift_in.auto_fill = true;
+    cfg.shift_in.direction = ShiftDirection::Right;
+    sm.set_config(&cfg);
 }
 
 #[embassy_executor::task]
@@ -81,8 +84,10 @@ fn setup_pio_task_sm2<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a,
         ".wrap",
     );
     let relocated = RelocatedProgram::new(&prg.program);
-    sm.use_program(&pio.load_program(&relocated), &[]);
-    sm.set_clkdiv((125e6 / 2e3 * 256.0) as u32);
+    let mut cfg = Config::default();
+    cfg.use_program(&pio.load_program(&relocated), &[]);
+    cfg.clock_divider = (U56F8!(125_000_000) / 2000).to_fixed();
+    sm.set_config(&cfg);
 }
 
 #[embassy_executor::task]
diff --git a/examples/rp/src/bin/pio_dma.rs b/examples/rp/src/bin/pio_dma.rs
index 1c4e127c7..7f85288bf 100644
--- a/examples/rp/src/bin/pio_dma.rs
+++ b/examples/rp/src/bin/pio_dma.rs
@@ -2,11 +2,14 @@
 #![no_main]
 #![feature(type_alias_impl_trait)]
 use defmt::info;
+use embassy_embedded_hal::SetConfig;
 use embassy_executor::Spawner;
 use embassy_futures::join::join;
-use embassy_rp::pio::{Pio, ShiftDirection};
+use embassy_rp::pio::{Config, Pio, ShiftConfig, ShiftDirection};
 use embassy_rp::relocate::RelocatedProgram;
 use embassy_rp::Peripheral;
+use fixed::traits::ToFixed;
+use fixed_macro::types::U56F8;
 use {defmt_rtt as _, panic_probe as _};
 
 fn swap_nibbles(v: u32) -> u32 {
@@ -38,15 +41,21 @@ async fn main(_spawner: Spawner) {
     );
 
     let relocated = RelocatedProgram::new(&prg.program);
-    sm.use_program(&common.load_program(&relocated), &[]);
-    sm.set_clkdiv((125e6 / 10e3 * 256.0) as u32);
-    sm.set_autopull(true);
-    sm.set_autopush(true);
-    sm.set_pull_threshold(32);
-    sm.set_push_threshold(32);
-    sm.set_out_shift_dir(ShiftDirection::Right);
-    sm.set_in_shift_dir(ShiftDirection::Left);
+    let mut cfg = Config::default();
+    cfg.use_program(&common.load_program(&relocated), &[]);
+    cfg.clock_divider = (U56F8!(125_000_000) / U56F8!(10_000)).to_fixed();
+    cfg.shift_in = ShiftConfig {
+        auto_fill: true,
+        threshold: 32,
+        direction: ShiftDirection::Left,
+    };
+    cfg.shift_out = ShiftConfig {
+        auto_fill: true,
+        threshold: 32,
+        direction: ShiftDirection::Right,
+    };
 
+    sm.set_config(&cfg);
     sm.set_enable(true);
 
     let mut dma_out_ref = p.DMA_CH0.into_ref();
diff --git a/examples/rp/src/bin/pio_hd44780.rs b/examples/rp/src/bin/pio_hd44780.rs
index 40dee1c4d..61c5565d3 100644
--- a/examples/rp/src/bin/pio_hd44780.rs
+++ b/examples/rp/src/bin/pio_hd44780.rs
@@ -4,11 +4,12 @@
 
 use core::fmt::Write;
 
+use embassy_embedded_hal::SetConfig;
 use embassy_executor::Spawner;
 use embassy_rp::dma::{AnyChannel, Channel};
 use embassy_rp::peripherals::PIO0;
-use embassy_rp::pio::{Direction, FifoJoin, Pio, PioPin, ShiftDirection, StateMachine};
-use embassy_rp::pwm::{Config, Pwm};
+use embassy_rp::pio::{Config, Direction, FifoJoin, Pio, PioPin, ShiftConfig, ShiftDirection, StateMachine};
+use embassy_rp::pwm::{self, Pwm};
 use embassy_rp::relocate::RelocatedProgram;
 use embassy_rp::{into_ref, Peripheral, PeripheralRef};
 use embassy_time::{Duration, Instant, Timer};
@@ -29,7 +30,7 @@ async fn main(_spawner: Spawner) {
     let p = embassy_rp::init(Default::default());
 
     let _pwm = Pwm::new_output_b(p.PWM_CH7, p.PIN_15, {
-        let mut c = Config::default();
+        let mut c = pwm::Config::default();
         c.divider = 125.into();
         c.top = 100;
         c.compare_b = 50;
@@ -83,7 +84,6 @@ impl<'l> HD44780<'l> {
     ) -> HD44780<'l> {
         into_ref!(dma);
 
-        let db7pin = db7.pin();
         let Pio {
             mut common,
             mut irq0,
@@ -118,13 +118,17 @@ impl<'l> HD44780<'l> {
         sm0.set_pin_dirs(Direction::Out, &[&rs, &rw, &e, &db4, &db5, &db6, &db7]);
 
         let relocated = RelocatedProgram::new(&prg.program);
-        sm0.use_program(&common.load_program(&relocated), &[&e]);
-        sm0.set_clkdiv(125 * 256);
-        sm0.set_out_pins(&[&db4, &db5, &db6, &db7]);
-        sm0.set_out_shift_dir(ShiftDirection::Left);
-        sm0.set_fifo_join(FifoJoin::TxOnly);
-        sm0.set_autopull(true);
-        sm0.set_pull_threshold(32);
+        let mut cfg = Config::default();
+        cfg.use_program(&common.load_program(&relocated), &[&e]);
+        cfg.clock_divider = 125u8.into();
+        cfg.set_out_pins(&[&db4, &db5, &db6, &db7]);
+        cfg.shift_out = ShiftConfig {
+            auto_fill: true,
+            direction: ShiftDirection::Left,
+            threshold: 32,
+        };
+        cfg.fifo_join = FifoJoin::TxOnly;
+        sm0.set_config(&cfg);
 
         sm0.set_enable(true);
         // init to 8 bit thrice
@@ -188,13 +192,15 @@ impl<'l> HD44780<'l> {
         );
 
         let relocated = RelocatedProgram::new(&prg.program);
-        sm0.use_program(&common.load_program(&relocated), &[&e]);
-        sm0.set_clkdiv(8 * 256); // ~64ns/insn
-        sm0.set_jmp_pin(db7pin);
-        sm0.set_set_pins(&[&rs, &rw]);
-        sm0.set_out_pins(&[&db4, &db5, &db6, &db7]);
-        sm0.set_out_shift_dir(ShiftDirection::Left);
-        sm0.set_fifo_join(FifoJoin::TxOnly);
+        let mut cfg = Config::default();
+        cfg.use_program(&common.load_program(&relocated), &[&e]);
+        cfg.clock_divider = 8u8.into(); // ~64ns/insn
+        cfg.set_jmp_pin(&db7);
+        cfg.set_set_pins(&[&rs, &rw]);
+        cfg.set_out_pins(&[&db4, &db5, &db6, &db7]);
+        cfg.shift_out.direction = ShiftDirection::Left;
+        cfg.fifo_join = FifoJoin::TxOnly;
+        sm0.set_config(&cfg);
 
         sm0.set_enable(true);
 
diff --git a/examples/rp/src/bin/ws2812-pio.rs b/examples/rp/src/bin/ws2812-pio.rs
index 889970541..d7c4742d8 100644
--- a/examples/rp/src/bin/ws2812-pio.rs
+++ b/examples/rp/src/bin/ws2812-pio.rs
@@ -3,10 +3,12 @@
 #![feature(type_alias_impl_trait)]
 
 use defmt::*;
+use embassy_embedded_hal::SetConfig;
 use embassy_executor::Spawner;
-use embassy_rp::pio::{Common, FifoJoin, Instance, Pio, PioPin, ShiftDirection, StateMachine};
+use embassy_rp::pio::{Common, Config, FifoJoin, Instance, Pio, PioPin, ShiftConfig, ShiftDirection, StateMachine};
 use embassy_rp::relocate::RelocatedProgram;
 use embassy_time::{Duration, Timer};
+use fixed_macro::fixed;
 use smart_leds::RGB8;
 use {defmt_rtt as _, panic_probe as _};
 pub struct Ws2812<'d, P: Instance, const S: usize> {
@@ -43,35 +45,30 @@ impl<'d, P: Instance, const S: usize> Ws2812<'d, P, S> {
         a.bind(&mut wrap_source);
 
         let prg = a.assemble_with_wrap(wrap_source, wrap_target);
+        let mut cfg = Config::default();
 
         // Pin config
         let out_pin = pio.make_pio_pin(pin);
 
         let relocated = RelocatedProgram::new(&prg);
-        sm.use_program(&pio.load_program(&relocated), &[&out_pin]);
+        cfg.use_program(&pio.load_program(&relocated), &[&out_pin]);
 
-        // Clock config
+        // Clock config, measured in kHz to avoid overflows
         // TODO CLOCK_FREQ should come from embassy_rp
-        const CLOCK_FREQ: u32 = 125_000_000;
-        const WS2812_FREQ: u32 = 800_000;
-
-        let bit_freq = WS2812_FREQ * CYCLES_PER_BIT;
-        let mut int = CLOCK_FREQ / bit_freq;
-        let rem = CLOCK_FREQ - (int * bit_freq);
-        let frac = (rem * 256) / bit_freq;
-        // 65536.0 is represented as 0 in the pio's clock divider
-        if int == 65536 {
-            int = 0;
-        }
-
-        sm.set_clkdiv((int << 8) | frac);
+        let clock_freq = fixed!(125_000: U24F8);
+        let ws2812_freq = fixed!(800: U24F8);
+        let bit_freq = ws2812_freq * CYCLES_PER_BIT;
+        cfg.clock_divider = clock_freq / bit_freq;
 
         // FIFO config
-        sm.set_autopull(true);
-        sm.set_fifo_join(FifoJoin::TxOnly);
-        sm.set_pull_threshold(24);
-        sm.set_out_shift_dir(ShiftDirection::Left);
-
+        cfg.fifo_join = FifoJoin::TxOnly;
+        cfg.shift_out = ShiftConfig {
+            auto_fill: true,
+            threshold: 24,
+            direction: ShiftDirection::Left,
+        };
+
+        sm.set_config(&cfg);
         sm.set_enable(true);
 
         Self { sm }