Implement endpoint size with generics

Signed-off-by: Arthur Heymans <[email protected]>

Author: ArthurHeymans

examples/ch32v307/src/bin/usb_hs_serial.rs

@@ -4,7 +4,7 @@
 use panic_halt as _;
 use embassy_executor::Spawner;
 use embassy_futures::join::join;
-use ch32_hal::usb::EndpointDataBuffer;
+use ch32_hal::usb::EndpointDataBuffer512;
 use ch32_hal::usbhs::{Driver};
 use ch32_hal::{self as hal, bind_interrupts, peripherals, Config};
 use ch32_hal::usbhs::{InterruptHandler, WakeupInterruptHandler, Instance};
@@ -27,7 +27,7 @@ async fn main(_spawner: Spawner) {
 
 
     // Create the driver, from the HAL.
-    let mut buffer: [EndpointDataBuffer; 4] = core::array::from_fn(|_| EndpointDataBuffer::default());
+    let mut buffer: [EndpointDataBuffer512; 4] = core::array::from_fn(|_| EndpointDataBuffer512::default());
     let driver = Driver::new(p.USBHS, Irq,  p.PB7, p.PB6, &mut buffer);
 
     // Create embassy-usb Config
@@ -55,7 +55,7 @@ async fn main(_spawner: Spawner) {
     );
 
     // Create classes on the builder.
-    let mut class = CdcAcmClass::new(&mut builder, &mut state, 64);
+    let mut class = CdcAcmClass::new(&mut builder, &mut state, 512);
 
     // Build the builder.
     let mut usb = builder.build();
@@ -87,8 +87,8 @@ impl From<EndpointError> for Disconnected {
     }
 }
 
-async fn echo<'d, T: Instance + 'd, const NR_EP: usize>(class: &mut CdcAcmClass<'d, Driver<'d, T, NR_EP>>) -> Result<(), Disconnected> {
-    let mut buf = [0; 64];
+async fn echo<'d, T: Instance + 'd, const NR_EP: usize, const SIZE: usize>(class: &mut CdcAcmClass<'d, Driver<'d, T, NR_EP, SIZE>>) -> Result<(), Disconnected> {
+    let mut buf = [0; 512];
     loop {
         let n = class.read_packet(&mut buf).await?;
         let data = &buf[..n];

examples/ch32v307/src/bin/usbfs_dfu.rs

@@ -2,7 +2,7 @@
 #![no_main]
 
 use panic_halt as _;
-use ch32_hal::usb::EndpointDataBuffer;
+use ch32_hal::usb::EndpointDataBuffer512;
 use ch32_hal::otg_fs::{self, Driver};
 use ch32_hal::{self as hal, bind_interrupts, peripherals, Config};
 use embassy_executor::Spawner;
@@ -47,7 +47,7 @@ async fn main(spawner: Spawner) -> ! {
     let p = hal::init(cfg);
 
     /* USB DRIVER SECION */
-    let mut buffer: [EndpointDataBuffer; 1] = core::array::from_fn(|_| EndpointDataBuffer::default());
+    let mut buffer: [EndpointDataBuffer512; 1] = core::array::from_fn(|_| EndpointDataBuffer512::default());
     let driver = Driver::new(p.OTG_FS, p.PA12, p.PA11, &mut buffer);
 
     // Create embassy-usb Config

src/otg_fs/endpoint.rs

@@ -10,14 +10,14 @@ use crate::interrupt::typelevel::Interrupt;
 use crate::usb::{Dir, EndpointData, In, Out};
 
 /// USB endpoint.
-pub struct Endpoint<'d, T, D> {
+pub struct Endpoint<'d, T, D, const SIZE: usize> {
     _phantom: PhantomData<&'d (T, D)>,
     info: EndpointInfo,
-    data: EndpointData<'d>,
+    data: EndpointData<'d, SIZE>,
 }
 
-impl<'d, T: Instance, D: Dir> Endpoint<'d, T, D> {
-    pub(crate) fn new(info: EndpointInfo, data: EndpointData<'d>) -> Self {
+impl<'d, T: Instance, D: Dir, const SIZE: usize> Endpoint<'d, T, D, SIZE> {
+    pub(crate) fn new(info: EndpointInfo, data: EndpointData<'d, SIZE>) -> Self {
         T::regs()
             .uep_dma(info.addr.index() as usize)
             .write_value(data.buffer.addr() as u32);
@@ -67,7 +67,7 @@ impl<'d, T: Instance, D: Dir> Endpoint<'d, T, D> {
     }
 }
 
-impl<'d, T: Instance, D: Dir> embassy_usb_driver::Endpoint for Endpoint<'d, T, D> {
+impl<'d, T: Instance, D: Dir, const SIZE: usize> embassy_usb_driver::Endpoint for Endpoint<'d, T, D, SIZE> {
     fn info(&self) -> &EndpointInfo {
         &self.info
     }
@@ -77,7 +77,7 @@ impl<'d, T: Instance, D: Dir> embassy_usb_driver::Endpoint for Endpoint<'d, T, D
     }
 }
 
-impl<'d, T: Instance> embassy_usb_driver::EndpointIn for Endpoint<'d, T, In> {
+impl<'d, T: Instance, const SIZE: usize> embassy_usb_driver::EndpointIn for Endpoint<'d, T, In, SIZE> {
     async fn write(&mut self, buf: &[u8]) -> Result<(), EndpointError> {
         trace!("endpoint {} IN", self.info.addr.index());
         if !self.is_enabled() {
@@ -133,7 +133,7 @@ impl<'d, T: Instance> embassy_usb_driver::EndpointIn for Endpoint<'d, T, In> {
     }
 }
 
-impl<'d, T: Instance> embassy_usb_driver::EndpointOut for Endpoint<'d, T, Out> {
+impl<'d, T: Instance, const SIZE: usize> embassy_usb_driver::EndpointOut for Endpoint<'d, T, Out, SIZE> {
     async fn read(&mut self, buf: &mut [u8]) -> Result<usize, EndpointError> {
         trace!("endpoint {} OUT", self.info.addr.index());
         if !self.is_enabled() {
@@ -192,21 +192,21 @@ impl<'d, T: Instance> embassy_usb_driver::EndpointOut for Endpoint<'d, T, Out> {
     }
 }
 
-pub struct ControlPipe<'d, T> {
-    ep0_buf: EndpointData<'d>,
+pub struct ControlPipe<'d, T, const SIZE: usize> {
+    ep0_buf: EndpointData<'d, SIZE>,
     _phantom: PhantomData<T>,
 }
 
-impl<'d, T: Instance> ControlPipe<'d, T> {
-    pub(crate) fn new(ep0_buf: EndpointData<'d>) -> Self {
+impl<'d, T: Instance, const SIZE: usize> ControlPipe<'d, T, SIZE> {
+    pub(crate) fn new(ep0_buf: EndpointData<'d, SIZE>) -> Self {
         Self {
             ep0_buf,
             _phantom: PhantomData,
         }
     }
 }
 
-impl<'d, T> embassy_usb_driver::ControlPipe for ControlPipe<'d, T>
+impl<'d, T, const SIZE: usize> embassy_usb_driver::ControlPipe for ControlPipe<'d, T, SIZE>
 where
     T: Instance,
 {

src/otg_fs/mod.rs

@@ -101,13 +101,13 @@ impl<T: Instance> interrupt::typelevel::Handler<T::Interrupt> for InterruptHandl
     }
 }
 
-pub struct Driver<'d, T: Instance, const NR_EP: usize> {
+pub struct Driver<'d, T: Instance, const NR_EP: usize, const SIZE: usize> {
     phantom: PhantomData<&'d mut T>,
-    allocator: EndpointBufferAllocator<'d, NR_EP>,
+    allocator: EndpointBufferAllocator<'d, NR_EP, SIZE>,
     allocated: Bitmap<MAX_NR_EP>,
 }
 
-impl<'d, T, const NR_EP: usize> Driver<'d, T, NR_EP>
+impl<'d, T, const NR_EP: usize, const SIZE: usize> Driver<'d, T, NR_EP, SIZE>
 where
     T: Instance,
 {
@@ -116,7 +116,7 @@ where
         // _irq: impl interrupt::typelevel::Binding<T::Interrupt, InterruptHandler<T>> + 'd,
         dp: impl Peripheral<P = impl crate::gpio::Pin> + 'd,
         dm: impl Peripheral<P = impl crate::gpio::Pin> + 'd,
-        ep_buffer: &'d mut [EndpointDataBuffer; NR_EP],
+        ep_buffer: &'d mut [EndpointDataBuffer<SIZE>; NR_EP],
     ) -> Self {
         assert!(ep_buffer.len() > 0);
         let dp = dp.into_ref();
@@ -151,7 +151,7 @@ where
         max_packet_size: u16,
         interval_ms: u8,
         dir: Direction,
-    ) -> Result<Endpoint<'d, T, D>, embassy_usb_driver::EndpointAllocError> {
+    ) -> Result<Endpoint<'d, T, D, SIZE>, embassy_usb_driver::EndpointAllocError> {
         let addr = match ep_addr {
             Some(addr) => {
                 // Use the provided endpoint address
@@ -198,12 +198,14 @@ where
     }
 }
 
-impl<'d, T: Instance, const NR_EP: usize> embassy_usb_driver::Driver<'d> for Driver<'d, T, NR_EP> {
-    type EndpointOut = Endpoint<'d, T, Out>;
+impl<'d, T: Instance, const NR_EP: usize, const SIZE: usize> embassy_usb_driver::Driver<'d>
+    for Driver<'d, T, NR_EP, SIZE>
+{
+    type EndpointOut = Endpoint<'d, T, Out, SIZE>;
 
-    type EndpointIn = Endpoint<'d, T, In>;
+    type EndpointIn = Endpoint<'d, T, In, SIZE>;
 
-    type ControlPipe = ControlPipe<'d, T>;
+    type ControlPipe = ControlPipe<'d, T, SIZE>;
 
     type Bus = Bus<'d, T>;
 

src/usb/mod.rs

@@ -1,19 +1,25 @@
 use embassy_usb_driver::EndpointAllocError;
 
-pub(crate) struct EndpointBufferAllocator<'d, const NR_EP: usize> {
-    ep_buffer: &'d mut [EndpointDataBuffer; NR_EP],
+pub(crate) struct EndpointBufferAllocator<'d, const NR_EP: usize, const SIZE: usize> {
+    ep_buffer: &'d mut [EndpointDataBuffer<SIZE>; NR_EP],
     ep_next: usize,
 }
 
-impl<'d, const NR_EP: usize> EndpointBufferAllocator<'d, NR_EP> {
-    pub fn new(ep_buffer: &'d mut [EndpointDataBuffer; NR_EP]) -> Self {
+/// Compile-time validation for buffer sizes
+const fn validate_buffer_size(size: usize) -> bool {
+    matches!(size, 8 | 16 | 32 | 64 | 512)
+}
+
+impl<'d, const NR_EP: usize, const SIZE: usize> EndpointBufferAllocator<'d, NR_EP, SIZE> {
+    pub fn new(ep_buffer: &'d mut [EndpointDataBuffer<SIZE>; NR_EP]) -> Self {
+        const { assert!(validate_buffer_size(SIZE), "Invalid buffer size") };
         Self { ep_buffer, ep_next: 0 }
     }
 
     pub fn alloc_endpoint(
         &mut self,
         max_packet_size: u16,
-    ) -> Result<EndpointData<'d>, embassy_usb_driver::EndpointAllocError> {
+    ) -> Result<EndpointData<'d, SIZE>, embassy_usb_driver::EndpointAllocError> {
         if self.ep_next >= NR_EP {
             error!("out of endpoint buffers");
             return Err(EndpointAllocError);
@@ -22,37 +28,39 @@ impl<'d, const NR_EP: usize> EndpointBufferAllocator<'d, NR_EP> {
         let ep_buf_idx = self.ep_next;
         self.ep_next += 1;
 
-        // TODO: Fix this, and allow variable buffer sizes
-        assert!(max_packet_size as usize <= ENDPOINT_DATA_BUFFER_SIZE);
+        assert!(
+            max_packet_size as usize <= SIZE,
+            "max_packet_size {} exceeds buffer size {}",
+            max_packet_size,
+            SIZE
+        );
 
         Ok(EndpointData {
             max_packet_size,
-            buffer: unsafe { core::mem::transmute(&self.ep_buffer[ep_buf_idx] as *const EndpointDataBuffer) },
+            buffer: unsafe { core::mem::transmute(&self.ep_buffer[ep_buf_idx] as *const EndpointDataBuffer<SIZE>) },
         })
     }
 }
 
-pub struct EndpointData<'d> {
+pub struct EndpointData<'d, const SIZE: usize> {
     pub max_packet_size: u16,
-    pub buffer: &'d mut EndpointDataBuffer,
+    pub buffer: &'d mut EndpointDataBuffer<SIZE>,
 }
 
-impl<'d> EndpointData<'d> {
+impl<'d, const SIZE: usize> EndpointData<'d, SIZE> {
     pub fn addr(&self) -> usize {
         self.buffer.addr()
     }
 }
 
-// todo generic
-const ENDPOINT_DATA_BUFFER_SIZE: usize = 64;
-
 #[repr(C, align(4))]
-pub struct EndpointDataBuffer {
-    data: [u8; ENDPOINT_DATA_BUFFER_SIZE as usize],
+pub struct EndpointDataBuffer<const SIZE: usize> {
+    data: [u8; SIZE],
 }
 
-impl Default for EndpointDataBuffer {
+impl<const SIZE: usize> Default for EndpointDataBuffer<SIZE> {
     fn default() -> Self {
+        const { assert!(validate_buffer_size(SIZE), "Invalid buffer size") };
         unsafe {
             EndpointDataBuffer {
                 data: core::mem::zeroed(),
@@ -61,7 +69,7 @@ impl Default for EndpointDataBuffer {
     }
 }
 
-impl EndpointDataBuffer {
+impl<const SIZE: usize> EndpointDataBuffer<SIZE> {
     pub(crate) fn read_volatile(&self, buf: &mut [u8]) {
         assert!(buf.len() <= self.data.len());
         let len = buf.len();
@@ -85,6 +93,25 @@ impl EndpointDataBuffer {
     }
 }
 
+// Type aliases for common buffer sizes
+pub type EndpointDataBuffer8 = EndpointDataBuffer<8>;
+pub type EndpointDataBuffer16 = EndpointDataBuffer<16>;
+pub type EndpointDataBuffer32 = EndpointDataBuffer<32>;
+pub type EndpointDataBuffer64 = EndpointDataBuffer<64>;
+pub type EndpointDataBuffer512 = EndpointDataBuffer<512>;
+
+pub type EndpointData8<'d> = EndpointData<'d, 8>;
+pub type EndpointData16<'d> = EndpointData<'d, 16>;
+pub type EndpointData32<'d> = EndpointData<'d, 32>;
+pub type EndpointData64<'d> = EndpointData<'d, 64>;
+pub type EndpointData512<'d> = EndpointData<'d, 512>;
+
+pub type EndpointBufferAllocator8<'d, const NR_EP: usize> = EndpointBufferAllocator<'d, NR_EP, 8>;
+pub type EndpointBufferAllocator16<'d, const NR_EP: usize> = EndpointBufferAllocator<'d, NR_EP, 16>;
+pub type EndpointBufferAllocator32<'d, const NR_EP: usize> = EndpointBufferAllocator<'d, NR_EP, 32>;
+pub type EndpointBufferAllocator64<'d, const NR_EP: usize> = EndpointBufferAllocator<'d, NR_EP, 64>;
+pub type EndpointBufferAllocator512<'d, const NR_EP: usize> = EndpointBufferAllocator<'d, NR_EP, 512>;
+
 /// USB Direction Trait
 pub trait Dir {}
 

src/usbhs/control.rs

@@ -9,21 +9,21 @@ use super::endpoint::Endpoint;
 use super::{Instance, EP_WAKERS};
 use crate::usb::InOut;
 
-pub struct ControlPipe<'d, T: Instance> {
+pub struct ControlPipe<'d, T: Instance, const SIZE: usize> {
     _phantom: PhantomData<&'d mut T>,
-    ep0: Endpoint<'d, T, InOut>,
+    ep0: Endpoint<'d, T, InOut, SIZE>,
 }
 
-impl<'d, T: Instance> ControlPipe<'d, T> {
-    pub(crate) fn new(ep0: Endpoint<'d, T, InOut>) -> Self {
+impl<'d, T: Instance, const SIZE: usize> ControlPipe<'d, T, SIZE> {
+    pub(crate) fn new(ep0: Endpoint<'d, T, InOut, SIZE>) -> Self {
         Self {
             _phantom: PhantomData,
             ep0,
         }
     }
 }
 
-impl<'d, T: Instance> embassy_usb_driver::ControlPipe for ControlPipe<'d, T> {
+impl<'d, T: Instance, const SIZE: usize> embassy_usb_driver::ControlPipe for ControlPipe<'d, T, SIZE> {
     fn max_packet_size(&self) -> usize {
         use embassy_usb_driver::Endpoint;
 

src/usbhs/endpoint.rs

@@ -8,14 +8,14 @@ use embassy_usb_driver::{Direction, EndpointError, EndpointIn, EndpointInfo, End
 use super::{EndpointData, Instance, EP_WAKERS};
 use crate::usb::{Dir, In, Out};
 
-pub struct Endpoint<'d, T: Instance, D: Dir> {
+pub struct Endpoint<'d, T: Instance, D: Dir, const SIZE: usize> {
     _phantom: PhantomData<(&'d mut T, D)>,
     info: EndpointInfo,
-    pub(crate) data: EndpointData<'d>,
+    pub(crate) data: EndpointData<'d, SIZE>,
 }
 
-impl<'d, T: Instance, D: Dir> Endpoint<'d, T, D> {
-    pub(crate) fn new(info: EndpointInfo, data: EndpointData<'d>) -> Self {
+impl<'d, T: Instance, D: Dir, const SIZE: usize> Endpoint<'d, T, D, SIZE> {
+    pub(crate) fn new(info: EndpointInfo, data: EndpointData<'d, SIZE>) -> Self {
         let index = info.addr.index();
         T::dregs().ep_max_len(index).write(|v| v.set_len(info.max_packet_size));
         if info.ep_type != EndpointType::Control {
@@ -152,7 +152,7 @@ impl<'d, T: Instance, D: Dir> Endpoint<'d, T, D> {
     }
 }
 
-impl<'d, T: Instance, D: Dir> embassy_usb_driver::Endpoint for Endpoint<'d, T, D> {
+impl<'d, T: Instance, D: Dir, const SIZE: usize> embassy_usb_driver::Endpoint for Endpoint<'d, T, D, SIZE> {
     fn info(&self) -> &EndpointInfo {
         &self.info
     }
@@ -162,7 +162,7 @@ impl<'d, T: Instance, D: Dir> embassy_usb_driver::Endpoint for Endpoint<'d, T, D
     }
 }
 
-impl<'d, T: Instance> EndpointOut for Endpoint<'d, T, Out> {
+impl<'d, T: Instance, const SIZE: usize> EndpointOut for Endpoint<'d, T, Out, SIZE> {
     async fn read(&mut self, buf: &mut [u8]) -> Result<usize, EndpointError> {
         if !self.is_enabled() {
             error!("read from disabled ep {}", self.info.addr.index());
@@ -184,7 +184,7 @@ impl<'d, T: Instance> EndpointOut for Endpoint<'d, T, Out> {
     }
 }
 
-impl<'d, T: Instance> EndpointIn for Endpoint<'d, T, In> {
+impl<'d, T: Instance, const SIZE: usize> EndpointIn for Endpoint<'d, T, In, SIZE> {
     async fn write(&mut self, buf: &[u8]) -> Result<(), EndpointError> {
         if !self.is_enabled() {
             error!("write to disabled ep {}", self.info.addr.index());