WIP - 32bit mode

Author: usbalbin

src/bus.rs

@@ -12,7 +12,7 @@ use crate::registers::UsbRegisters;
 use crate::UsbPeripheral;
 
 /// USB peripheral driver for STM32 microcontrollers.
-pub struct UsbBus<USB> {
+pub struct UsbBus<USB: UsbPeripheral> {
     peripheral: USB,
     regs: Mutex<UsbRegisters<USB>>,
     endpoints: [Endpoint<USB>; NUM_ENDPOINTS],

src/endpoint.rs

@@ -16,7 +16,7 @@ pub const NUM_ENDPOINTS: usize = 8;
 
 /// Arbitrates access to the endpoint-specific registers and packet buffer memory.
 #[derive(Default)]
-pub struct Endpoint<USB> {
+pub struct Endpoint<USB: UsbPeripheral> {
     out_buf: Option<Mutex<EndpointBuffer<USB>>>,
     in_buf: Option<Mutex<EndpointBuffer<USB>>>,
     ep_type: Option<EndpointType>,
@@ -72,8 +72,8 @@ impl<USB: UsbPeripheral> Endpoint<USB> {
         self.out_buf = Some(Mutex::new(buffer));
 
         let descr = self.descr();
-        descr.addr_rx().set(offset);
-        descr.count_rx().set(size_bits);
+        descr.addr_rx().set(offset.into());
+        descr.count_rx().set(size_bits.into());
     }
 
     pub fn is_in_buf_set(&self) -> bool {
@@ -85,8 +85,8 @@ impl<USB: UsbPeripheral> Endpoint<USB> {
         self.in_buf = Some(Mutex::new(buffer));
 
         let descr = self.descr();
-        descr.addr_tx().set(offset);
-        descr.count_tx().set(0);
+        descr.addr_tx().set(offset.into());
+        descr.count_tx().set(0.into());
     }
 
     fn descr(&self) -> BufferDescriptor<USB> {
@@ -151,7 +151,7 @@ impl<USB: UsbPeripheral> Endpoint<USB> {
             };
 
             in_buf.write(buf);
-            self.descr().count_tx().set(buf.len() as u16);
+            self.descr().count_tx().set((buf.len() as u16).into());
 
             self.set_stat_tx(cs, EndpointStatus::Valid);
 
@@ -173,7 +173,7 @@ impl<USB: UsbPeripheral> Endpoint<USB> {
 
             self.clear_ctr_rx(cs);
 
-            let count = (self.descr().count_rx().get() & 0x3ff) as usize;
+            let count = (self.descr().count_rx().get().into() & 0x3ff) as usize;
             if count > buf.len() {
                 return Err(UsbError::BufferOverflow);
             }

src/endpoint_memory.rs

@@ -1,18 +1,18 @@
 use crate::endpoint::NUM_ENDPOINTS;
-use crate::UsbPeripheral;
+use crate::{UsbPeripheral, Word};
 use core::marker::PhantomData;
 use core::slice;
 use usb_device::{Result, UsbError};
 use vcell::VolatileCell;
 
-pub struct EndpointBuffer<USB> {
-    mem: &'static mut [VolatileCell<u16>],
+pub struct EndpointBuffer<USB: UsbPeripheral> {
+    mem: &'static mut [VolatileCell<USB::Word>],
     marker: PhantomData<USB>,
 }
 
 impl<USB: UsbPeripheral> EndpointBuffer<USB> {
     pub fn new(offset_bytes: usize, size_bytes: usize) -> Self {
-        let ep_mem_ptr = USB::EP_MEMORY as *mut VolatileCell<u16>;
+        let ep_mem_ptr = USB::EP_MEMORY as *mut VolatileCell<_>;
 
         let offset_words = offset_bytes >> 1;
         let count_words = size_bytes >> 1;
@@ -36,7 +36,7 @@ impl<USB: UsbPeripheral> EndpointBuffer<USB> {
     }
 
     #[inline(always)]
-    fn read_word(&self, index: usize) -> u16 {
+    fn read_word(&self, index: usize) -> USB::Word {
         if USB::EP_MEMORY_ACCESS_2X16 {
             self.mem[index].get()
         } else {
@@ -45,46 +45,32 @@ impl<USB: UsbPeripheral> EndpointBuffer<USB> {
     }
 
     #[inline(always)]
-    fn write_word(&self, index: usize, value: u16) {
+    fn write_word(&self, index: usize, value: USB::Word) {
         if USB::EP_MEMORY_ACCESS_2X16 {
             self.mem[index].set(value);
         } else {
             self.mem[index * 2].set(value);
         }
     }
 
-    pub fn read(&self, mut buf: &mut [u8]) {
+    pub fn read(&self, buf: &mut [u8]) {
         let mut index = 0;
+        let mut writer = buf.into_iter().peekable();
 
-        while buf.len() >= 2 {
-            let word = self.read_word(index);
-
-            buf[0] = (word & 0xff) as u8;
-            buf[1] = (word >> 8) as u8;
-
+        while writer.peek().is_some() {
+            self.read_word(index).write_to_iter_le(&mut writer);
             index += 1;
-
-            buf = &mut buf[2..];
-        }
-
-        if buf.len() > 0 {
-            buf[0] = (self.read_word(index) & 0xff) as u8;
         }
     }
 
-    pub fn write(&self, mut buf: &[u8]) {
+    pub fn write(&self, buf: &[u8]) {
         let mut index = 0;
+        let mut reader = buf.into_iter().peekable();
 
-        while buf.len() >= 2 {
-            let value: u16 = buf[0] as u16 | ((buf[1] as u16) << 8);
+        while reader.peek().is_some() {
+            let value = Word::from_iter_le(&mut reader);
             self.write_word(index, value);
             index += 1;
-
-            buf = &buf[2..];
-        }
-
-        if buf.len() > 0 {
-            self.write_word(index, buf[0] as u16);
         }
     }
 
@@ -106,36 +92,28 @@ impl<USB: UsbPeripheral> EndpointBuffer<USB> {
 }
 
 #[repr(C)]
-pub struct BufferDescriptor<USB> {
-    ptr: *const VolatileCell<u16>,
+pub struct BufferDescriptor<USB: UsbPeripheral> {
+    ptr: *const VolatileCell<USB::Word>,
     marker: PhantomData<USB>,
 }
 
 impl<USB: UsbPeripheral> BufferDescriptor<USB> {
     #[inline(always)]
-    fn field(&self, index: usize) -> &'static VolatileCell<u16> {
+    fn field(&self, index: usize) -> &'static VolatileCell<USB::Word> {
         let mul = if USB::EP_MEMORY_ACCESS_2X16 { 1 } else { 2 };
         unsafe { &*(self.ptr.add(index * mul)) }
     }
 
     #[inline(always)]
-    pub fn addr_tx(&self) -> &'static VolatileCell<u16> {
-        self.field(0)
-    }
-
-    #[inline(always)]
-    pub fn count_tx(&self) -> &'static VolatileCell<u16> {
-        self.field(1)
-    }
-
-    #[inline(always)]
-    pub fn addr_rx(&self) -> &'static VolatileCell<u16> {
-        self.field(2)
+    pub fn set_tx(&self, address: u16, count: u16) {
+        self.field(0) // addr
+        self.field(1) // count (msb in 32bit)
     }
 
     #[inline(always)]
-    pub fn count_rx(&self) -> &'static VolatileCell<u16> {
-        self.field(3)
+    pub fn get_rx(&self) -> (u16, u16) {
+        self.field(2) // addr
+        self.field(3) // count(msb in 32bit)
     }
 }
 
@@ -170,7 +148,7 @@ impl<USB: UsbPeripheral> EndpointMemoryAllocator<USB> {
         let mul = if USB::EP_MEMORY_ACCESS_2X16 { 1 } else { 2 };
 
         unsafe {
-            let ptr = (USB::EP_MEMORY as *const VolatileCell<u16>).add((index as usize) * 4 * mul);
+            let ptr = (USB::EP_MEMORY as *const VolatileCell<USB::Word>).add((index as usize) * 4 * mul);
             BufferDescriptor {
                 ptr,
                 marker: Default::default(),

src/lib.rs

@@ -35,6 +35,8 @@ pub unsafe trait UsbPeripheral: Send + Sync {
     /// Set to `true` if "2x16 bits/word" access scheme is used, otherwise set to `false`.
     const EP_MEMORY_ACCESS_2X16: bool;
 
+    type Word: Word;
+
     /// Enables USB device on its peripheral bus
     fn enable();
 
@@ -44,3 +46,41 @@ pub unsafe trait UsbPeripheral: Send + Sync {
     /// peripheral initialization.
     fn startup_delay();
 }
+
+pub trait Word: From<u16> + Into<u32> + Copy + Send + 'static
+{
+    fn from_iter_le<'a>(it: &mut impl Iterator<Item = &'a u8>) -> Self;
+    fn write_to_iter_le<'a>(self, it: &mut impl Iterator<Item = &'a mut u8>);
+}
+
+impl Word for u16 {
+    fn from_iter_le<'a>(it: &mut impl Iterator<Item = &'a u8>) -> Self {
+        Self::from_le_bytes([
+            *it.next().unwrap_or(&0),
+            *it.next().unwrap_or(&0),
+        ])
+    }
+
+    fn write_to_iter_le<'a>(self, it: &mut impl Iterator<Item = &'a mut u8>) {
+        for (w, r) in it.zip(self.to_le_bytes()) {
+            *w = r;
+        }
+    }
+}
+
+impl Word for u32 {
+    fn from_iter_le<'a>(it: &mut impl Iterator<Item = &'a u8>) -> Self {
+        Self::from_le_bytes([
+            *it.next().unwrap_or(&0),
+            *it.next().unwrap_or(&0),
+            *it.next().unwrap_or(&0),
+            *it.next().unwrap_or(&0),
+        ])
+    }
+
+    fn write_to_iter_le<'a>(self, it: &mut impl Iterator<Item = &'a mut u8>) {
+        for (w, r) in it.zip(self.to_le_bytes()) {
+            *w = r;
+        }
+    }
+}