feat: make USBEndpoint public + add method get_ep_table

revert fix(int): fix bytes for clearing interrupt flags for usbd_serial

src/lib.rs

@@ -14,6 +14,10 @@ pub use types::*;
 
 use types::{DPRAM_SIZE, ENDPOINTS_ALLOC_LAYOUT, ONE_MS_16_MGHZ};
 
+const RESTRICT_RW_FLAG: u8 = !(1 << 5);
+const USBINT_CLEAR: u8 = 1 << 0;
+const UDINT_CLEAR: u8 = !(1 << 7 | 1 << 1);
+
 impl<const L: usize> UsbBus for UsbDevice<L> {
     fn alloc_ep(
         &mut self,
@@ -24,9 +28,9 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
         _interval: u8,
     ) -> UsbResult<EndpointAddress> {
         // Handle first endpoint. //
-        free(|_cs| {
+
         if ep_addr == Some(EndpointAddress::from_parts(0, UsbDirection::In)) {
-                Ok(ep_addr.unwrap())
+            ep_addr.ok_or(UsbError::InvalidState)
         } else {
             let address = match ep_addr {
                 // If current endpoint doesn't allocated, assign ep_addr to variable. //
@@ -40,8 +44,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                         .enumerate()
                         .skip(1)
                         .find(|(index, ep)| {
-                                !ep.is_allocated
+                            !ep.is_allocated && max_packet_size <= ENDPOINTS_ALLOC_LAYOUT[*index]
-                                    && max_packet_size <= ENDPOINTS_ALLOC_LAYOUT[*index]
                         })
                         .ok_or(UsbError::EndpointOverflow)?
                         .0;
@@ -77,7 +80,6 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                 Ok(address)
             }
         }
-        })
     }
 
     fn enable(&mut self) {
@@ -116,7 +118,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
             // Endpoint configuration //
 
             self.allocated_endpoints().for_each(|(i, _ep)| {
-                self.configure_endpoint(cs, i).unwrap();
+                let _ = self.configure_endpoint(cs, i);
             });
 
             // Set high speed and attach the USB. //
@@ -132,17 +134,15 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
     }
 
     fn force_reset(&self) -> UsbResult<()> {
+        let set_detach = |bit| {
             free(|cs| {
-            let usbcon = &self.usb.borrow(cs).usbcon;
+                self.usb.borrow(cs).udcon.modify(|_, w| w.detach().bit(bit));
-            usbcon.modify(|_, w| w.usbe().set_bit());
             });
+        };
 
+        set_detach(true);
         delay_cycles(ONE_MS_16_MGHZ);
-
+        set_detach(false);
-        free(|cs| {
-            let usbcon = &self.usb.borrow(cs).usbcon;
-            usbcon.modify(|_, w| w.usbe().set_bit());
-        });
 
         Ok(())
     }
@@ -162,7 +162,8 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
 
             if usbint.vbusti().bit_is_set() {
                 usb.usbint
-                    .write(|w| unsafe { w.bits(0x01) }.vbusti().clear_bit());
+                    .write(|w| unsafe { w.bits(USBINT_CLEAR) }.vbusti().clear_bit());
+
                 if usb.usbsta.read().vbus().bit_is_set() {
                     return PollResult::Resume;
                 } else {
@@ -184,12 +185,11 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
 
             if udint.sofi().bit_is_set() {
                 usb.udint
-                    .write(|w| unsafe { w.bits(0x7d) }.sofi().clear_bit());
+                    .write(|w| unsafe { w.bits(UDINT_CLEAR) }.sofi().clear_bit());
             }
 
             if usb.usbcon.read().frzclk().bit_is_clear() {
                 let (mut ep_out, mut ep_in_complete, mut ep_setup) = (0u16, 0u16, 0u16);
-                let pending_ins = self.pending_ins.borrow(cs);
 
                 for (ep_index, _ep) in self.allocated_endpoints() {
                     if self.select_endpoint(cs, ep_index).is_err() {
@@ -204,9 +204,8 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                             ep_setup |= 1 << ep_index;
                         }
 
-                        if pending_ins.get() & (1 << ep_index) != 0 && ueintx.txini().bit_is_set() {
+                        if ueintx.txini().bit_is_set() {
                             ep_in_complete |= 1 << ep_index;
-                            pending_ins.set(pending_ins.get() & !(1 << ep_index));
                         }
                     }
                 }
@@ -226,9 +225,8 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
         free(|cs| {
             let usb = self.usb.borrow(cs);
 
-            if let Err(error) = self.select_endpoint(cs, ep_addr.index()) {
+            self.select_endpoint(cs, ep_addr.index())?;
-                Err(error)
+
-            } else {
             let ep = &self.ep_table[ep_addr.index()];
 
             if ep.ep_type == 0 {
@@ -239,6 +237,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                 }
 
                 let buf_size = self.get_size(cs);
+
                 if buf.len() < buf_size {
                     return Err(UsbError::BufferOverflow);
                 }
@@ -248,7 +247,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                 }
 
                 usb.ueintx.write(|w| {
-                        unsafe { w.bits(0xdf) }
+                    unsafe { w.bits(RESTRICT_RW_FLAG) }
                         .rxouti()
                         .clear_bit()
                         .rxstpi()
@@ -260,10 +259,12 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                 if usb.ueintx.read().rxouti().bit_is_clear() {
                     return Err(UsbError::WouldBlock);
                 }
+
                 usb.ueintx
-                        .write(|w| unsafe { w.bits(0xdf) }.rxouti().clear_bit());
+                    .write(|w| unsafe { w.bits(RESTRICT_RW_FLAG) }.rxouti().clear_bit());
 
                 let mut bytes_read = 0;
+
                 for slot in buf {
                     if usb.ueintx.read().rwal().bit_is_clear() {
                         break;
@@ -277,10 +278,10 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                 }
 
                 usb.ueintx
-                        .write(|w| unsafe { w.bits(0xdf) }.fifocon().clear_bit());
+                    .write(|w| unsafe { w.bits(RESTRICT_RW_FLAG) }.fifocon().clear_bit());
+
                 Ok(bytes_read)
             }
-            }
         })
     }
 
@@ -291,13 +292,13 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
             usb.udint.modify(|_, w| w.eorsti().clear_bit());
 
             self.allocated_endpoints().for_each(|(i, _)| {
-                self.configure_endpoint(cs, i).unwrap();
+                let _ = self.configure_endpoint(cs, i);
             });
 
             // Clear resume informations. //
 
             usb.udint.write(|w| {
-                unsafe { w.bits(0x7d) }
+                unsafe { w.bits(UDINT_CLEAR) }
                     .wakeupi()
                     .clear_bit()
                     .suspi()
@@ -325,7 +326,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
             usb.usbcon.modify(|_, w| w.frzclk().clear_bit());
 
             usb.udint.write(|w| {
-                unsafe { w.bits(0x7d) }
+                unsafe { w.bits(UDINT_CLEAR) }
                     .wakeupi()
                     .clear_bit()
                     .suspi()
@@ -369,7 +370,7 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
             let (usb, pll) = (self.usb.borrow(cs), self.pll.borrow(cs));
 
             usb.udint.write(|w| {
-                unsafe { w.bits(0x7d) }
+                unsafe { w.bits(UDINT_CLEAR) }
                     .wakeupi()
                     .clear_bit()
                     .suspi()
@@ -395,14 +396,14 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
         free(|cs| {
             let usb = self.usb.borrow(cs);
 
-            if let Err(error) = self.select_endpoint(cs, ep_addr.index()) {
+            self.select_endpoint(cs, ep_addr.index())?;
-                Err(error)
+
-            } else {
             let ep = &self.ep_table[ep_addr.index()];
 
             // Endpoint type confitions //
 
-                if ep.ep_type == 0 {
+            match ep.ep_type {
+                0 => {
                     if usb.ueintx.read().txini().bit_is_clear() {
                         return Err(UsbError::WouldBlock);
                     }
@@ -416,13 +417,15 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                     }
 
                     usb.ueintx
-                        .write(|w| unsafe { w.bits(0xdf) }.txini().clear_bit());
+                        .write(|w| unsafe { w.bits(RESTRICT_RW_FLAG) }.txini().clear_bit());
-                } else {
+                }
+                _ => {
                     if usb.ueintx.read().txini().bit_is_clear() {
                         return Err(UsbError::WouldBlock);
                     }
+
                     usb.ueintx.write(|w| {
-                        unsafe { w.bits(0xdf) }
+                        unsafe { w.bits(RESTRICT_RW_FLAG) }
                             .txini()
                             .clear_bit()
                             .rxouti()
@@ -438,19 +441,16 @@ impl<const L: usize> UsbBus for UsbDevice<L> {
                     }
 
                     usb.ueintx.write(|w| {
-                        unsafe { w.bits(0xdf) }
+                        unsafe { w.bits(RESTRICT_RW_FLAG) }
                             .rxouti()
                             .clear_bit()
                             .fifocon()
                             .clear_bit()
                     });
                 }
-
+            };
-                let pending_ins = self.pending_ins.borrow(cs);
-                pending_ins.set(pending_ins.get() | 1 << ep_addr.index());
 
             Ok(buf.len())
-            }
         })
     }
 }

src/types/usb_device.rs

@@ -1,5 +1,3 @@
-use core::cell::Cell;
-
 use avr_device::{
     atmega32u4::{PLL, USB_DEVICE},
     interrupt::{CriticalSection, Mutex},
@@ -8,7 +6,7 @@ use usb_device::{bus::UsbBusAllocator, endpoint::EndpointType, UsbDirection, Usb
 
 #[allow(unused)]
 #[derive(Default, Copy, Clone)]
-pub(crate) struct USBEndpoint {
+pub struct USBEndpoint {
     pub(crate) is_allocated: bool,
     pub(crate) size: u8,
     pub(crate) ep_type: u8,
@@ -72,7 +70,6 @@ pub struct UsbDevice<const L: usize> {
     pub(crate) pll: Mutex<PLL>,
     pub(crate) usb: Mutex<USB_DEVICE>,
     pub(crate) ep_table: [USBEndpoint; L],
-    pub(crate) pending_ins: Mutex<Cell<u8>>,
     pub(crate) dpram_already_used: u16,
 }
 
@@ -88,7 +85,6 @@ impl<const L: usize> UsbDevice<L> {
             pll: Mutex::new(pll),
             usb: Mutex::new(usb),
             ep_table: [USBEndpoint::default(); L],
-            pending_ins: Mutex::new(Cell::new(0u8)),
             dpram_already_used: 0,
         })
     }
@@ -136,6 +132,10 @@ impl<const L: usize> UsbDevice<L> {
         Ok(())
     }
 
+    pub fn get_ep_table(&self) -> &[USBEndpoint] {
+        &self.ep_table
+    }
+
     pub(crate) fn configure_endpoint(
         &self,
         cs: CriticalSection<'_>,