feat: Move transfer size to generics

ArthurHeymans · ArthurHeymans · commit 6c1d43d138b6 · 2025-12-17T10:19:25.000+01:00
Signed-off-by: Arthur Heymans &lt;arthur@aheymans.xyz&gt;
diff --git a/bluepill-prog/src/main.rs b/bluepill-prog/src/main.rs
@@ -50,6 +50,8 @@ assign_resources! {
     }
 }
 
+const USB_BUFFER_SIZE: usize = 64;
+
 // According to Serial Flasher Protocol Specification - version 1
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
@@ -131,7 +133,7 @@ async fn main(spawner: Spawner) {
     let serprog_class = {
         static STATE: StaticCell<State> = StaticCell::new();
         let state = STATE.init(State::new());
-        CdcAcmClass::new(&mut builder, state, 64)
+        CdcAcmClass::new(&mut builder, state, USB_BUFFER_SIZE.try_into().unwrap())
     };
 
     let usb = builder.build();
@@ -190,7 +192,13 @@ async fn serprog_task(mut class: CdcAcmClass<'static, CustomUsbDriver>, r: SpiRe
 
     loop {
         class.wait_connection().await;
-        let serprog = serprog::Serprog::new(spi, cs, led, class, Some(set_freq_cb));
+        let serprog = serprog::Serprog::<_, _, _, _, _, USB_BUFFER_SIZE>::new(
+            spi,
+            cs,
+            led,
+            class,
+            Some(set_freq_cb),
+        );
         serprog.run_loop().await
     }
 }
diff --git a/picoprog/src/main.rs b/picoprog/src/main.rs
@@ -51,6 +51,7 @@ assign_resources! {
 }
 
 const FLASH_SIZE: usize = 2 * 1024 * 1024;
+const USB_BUFFER_SIZE: usize = 64;
 
 // According to Serial Flasher Protocol Specification - version 1
 
@@ -106,13 +107,13 @@ async fn main(spawner: Spawner) {
     let uart_class = {
         static STATE: StaticCell<State> = StaticCell::new();
         let state = STATE.init(State::new());
-        CdcAcmClass::new(&mut builder, state, 64)
+        CdcAcmClass::new(&mut builder, state, USB_BUFFER_SIZE.try_into().unwrap())
     };
 
     let serprog_class = {
         static STATE: StaticCell<State> = StaticCell::new();
         let state = STATE.init(State::new());
-        CdcAcmClass::new(&mut builder, state, 64)
+        CdcAcmClass::new(&mut builder, state, USB_BUFFER_SIZE.try_into().unwrap())
     };
 
     let usb = builder.build();
@@ -166,7 +167,13 @@ async fn serprog_task(class: CdcAcmClass<'static, CustomUsbDriver>, r: SpiResour
         spi.set_frequency(freq);
     };
 
-    let serprog = serprog::Serprog::new(spi, cs, led, class, Some(set_freq_cb));
+    let serprog = serprog::Serprog::<_, _, _, _, _, USB_BUFFER_SIZE>::new(
+        spi,
+        cs,
+        led,
+        class,
+        Some(set_freq_cb),
+    );
     serprog.run_loop().await
 }
 
diff --git a/serprog/src/lib.rs b/serprog/src/lib.rs
@@ -199,29 +199,29 @@ impl QCmdMapResponse {
     }
 }
 
-pub struct Serprog<SPI, CS, LED, T: Transport, F> {
+pub struct Serprog<SPI, CS, LED, T: Transport<TRANSFER_SIZE>, F, const TRANSFER_SIZE: usize> {
     spi: SPI,
     cs: CS,
     led: LED,
     transport: T,
     freq_callback: Option<F>,
 }
 
-async fn ospiop_usb_task<T: Transport>(
+async fn ospiop_usb_task<T: Transport<TRANSFER_SIZE>, const TRANSFER_SIZE: usize>(
     transport: &mut T,
-    mut sender: Sender<'_, NoopRawMutex, Vec<u8, 64>>,
+    mut sender: Sender<'_, NoopRawMutex, Vec<u8, TRANSFER_SIZE>>,
     sdata_size: usize,
-    mut receiver: Receiver<'_, NoopRawMutex, Vec<u8, 64>>,
+    mut receiver: Receiver<'_, NoopRawMutex, Vec<u8, TRANSFER_SIZE>>,
     rdata_size: usize,
 ) -> Result<(), SerprogError> {
     // First block - already contains header + initial data, send as-is
     let mut data_to_read = sdata_size;
-    let first_block_data_size = data_to_read.min(64 - 6);
+    let first_block_data_size = data_to_read.min(TRANSFER_SIZE - 6);
     sender.send_done();
     data_to_read -= first_block_data_size;
 
     while data_to_read > 0 {
-        let read_size = data_to_read.min(64);
+        let read_size = data_to_read.min(TRANSFER_SIZE);
         let buf = sender.send().await;
         buf.clear();
         buf.resize(read_size, 0).ok();
@@ -250,11 +250,11 @@ async fn ospiop_usb_task<T: Transport>(
     Ok(())
 }
 
-async fn ospiop_spi_task<SPI: SpiBus<u8>, CS: OutputPin>(
+async fn ospiop_spi_task<SPI: SpiBus<u8>, CS: OutputPin, const TRANSFER_SIZE: usize>(
     spi: &mut SPI,
-    mut receiver: Receiver<'_, NoopRawMutex, Vec<u8, 64>>,
+    mut receiver: Receiver<'_, NoopRawMutex, Vec<u8, TRANSFER_SIZE>>,
     sdata_size: usize,
-    mut sender: Sender<'_, NoopRawMutex, Vec<u8, 64>>,
+    mut sender: Sender<'_, NoopRawMutex, Vec<u8, TRANSFER_SIZE>>,
     rdata_size: usize,
     cs: &mut CS,
 ) -> Result<(), SerprogError> {
@@ -271,7 +271,7 @@ async fn ospiop_spi_task<SPI: SpiBus<u8>, CS: OutputPin>(
         let write_slice = if is_first {
             // First buffer: skip the 6-byte header
             is_first = false;
-            let data_len = data_to_write.min(64 - 6);
+            let data_len = data_to_write.min(TRANSFER_SIZE - 6);
             data_to_write -= data_len;
             &buf[6..6 + data_len]
         } else {
@@ -288,7 +288,7 @@ async fn ospiop_spi_task<SPI: SpiBus<u8>, CS: OutputPin>(
     while data_to_read > 0 {
         let buf = sender.send().await;
         buf.clear();
-        let read_size = data_to_read.min(64);
+        let read_size = data_to_read.min(TRANSFER_SIZE);
         buf.resize(read_size, 0).ok();
         spi.read(buf.as_mut_slice())
             .await
@@ -302,12 +302,12 @@ async fn ospiop_spi_task<SPI: SpiBus<u8>, CS: OutputPin>(
     Ok(())
 }
 
-impl<SPI, CS, LED, T, F> Serprog<SPI, CS, LED, T, F>
+impl<SPI, CS, LED, T, F, const TRANSFER_SIZE: usize> Serprog<SPI, CS, LED, T, F, TRANSFER_SIZE>
 where
     SPI: SpiBus<u8>,
     CS: OutputPin,
     LED: OutputPin,
-    T: Transport,
+    T: Transport<TRANSFER_SIZE>,
     F: FnMut(&mut SPI, u32) + Send + Sync,
 {
     pub fn new(spi: SPI, cs: CS, led: LED, transport: T, freq_callback: Option<F>) -> Self {
@@ -320,7 +320,11 @@ where
         }
     }
 
-    pub async fn run_loop(mut self) -> ! {
+    pub async fn run_loop(mut self) -> !
+    where
+        CS::Error: core::fmt::Debug,
+        LED::Error: core::fmt::Debug,
+    {
         let mut buf = [0; 1];
 
         loop {
@@ -439,8 +443,8 @@ where
                 debug!("Received OSpiOp CMD");
 
                 // Read directly into the first channel buffer
-                let mut usb_rx_spi_tx_buf = [const { Vec::<u8, 64>::new() }; 4];
-                usb_rx_spi_tx_buf[0].resize(64, 0).ok();
+                let mut usb_rx_spi_tx_buf = [const { Vec::<u8, TRANSFER_SIZE>::new() }; 4];
+                usb_rx_spi_tx_buf[0].resize(TRANSFER_SIZE, 0).ok();
                 self.transport
                     .read(usb_rx_spi_tx_buf[0].as_mut_slice())
                     .await
@@ -450,25 +454,31 @@ where
                 let op_slen = le_u24_to_u32(&usb_rx_spi_tx_buf[0][0..3]) as usize;
                 let op_rlen = le_u24_to_u32(&usb_rx_spi_tx_buf[0][3..6]) as usize;
 
-                let mut usb_rx_spi_tx_channel: Channel<'_, NoopRawMutex, Vec<u8, 64>> =
+                let mut usb_rx_spi_tx_channel: Channel<'_, NoopRawMutex, Vec<u8, TRANSFER_SIZE>> =
                     Channel::new(&mut usb_rx_spi_tx_buf);
                 let (usb_rx, spi_tx) = usb_rx_spi_tx_channel.split();
 
-                let mut usb_tx_spi_rx_buf = [const { Vec::<u8, 64>::new() }; 8];
-                let mut usb_tx_spi_rx_channel: Channel<'_, NoopRawMutex, Vec<u8, 64>> =
+                let mut usb_tx_spi_rx_buf = [const { Vec::<u8, TRANSFER_SIZE>::new() }; 8];
+                let mut usb_tx_spi_rx_channel: Channel<'_, NoopRawMutex, Vec<u8, TRANSFER_SIZE>> =
                     Channel::new(&mut usb_tx_spi_rx_buf);
                 let (spi_rx, usb_tx) = usb_tx_spi_rx_channel.split();
 
                 let (spi_res, usb_res) = block_on(join(
-                    ospiop_spi_task(
+                    ospiop_spi_task::<_, _, TRANSFER_SIZE>(
                         &mut self.spi,
                         spi_tx,
                         op_slen,
                         spi_rx,
                         op_rlen,
                         &mut self.cs,
                     ),
-                    ospiop_usb_task(&mut self.transport, usb_rx, op_slen, usb_tx, op_rlen),
+                    ospiop_usb_task::<_, TRANSFER_SIZE>(
+                        &mut self.transport,
+                        usb_rx,
+                        op_slen,
+                        usb_tx,
+                        op_rlen,
+                    ),
                 ));
                 if let Err(spi_err) = spi_res {
                     self.transport
diff --git a/serprog/src/transport.rs b/serprog/src/transport.rs
@@ -1,18 +1,20 @@
 use core::future;
 use embassy_usb::class::cdc_acm::CdcAcmClass;
 
-pub trait Transport {
+pub trait Transport<const TRANSFER_SIZE: usize> {
     fn read(&mut self, buf: &mut [u8]) -> impl future::Future<Output = Result<(), ()>>;
     fn write(&mut self, data: &[u8]) -> impl future::Future<Output = Result<(), ()>>;
 }
 
-impl<'d, D: embassy_usb::driver::Driver<'d>> Transport for CdcAcmClass<'d, D> {
+impl<'d, D: embassy_usb::driver::Driver<'d>, const TRANSFER_SIZE: usize> Transport<TRANSFER_SIZE>
+    for CdcAcmClass<'d, D>
+{
     async fn read(&mut self, buf: &mut [u8]) -> Result<(), ()> {
         let packet_size = self.max_packet_size() as usize;
         let buf_len = buf.len();
 
         // Use a buffer large enough for full speed and high speed
-        let mut buffer = [0; 512];
+        let mut buffer = [0; TRANSFER_SIZE];
         let mut size = 0;
         if buf_len < packet_size {
             let bytes_read = self
