usb: Implement SOF handling hooks in the USB stack

Author: dragonmux

embassy-nrf/src/usb/mod.rs

@@ -160,7 +160,7 @@ impl<'d, V: VbusDetect + 'd> driver::Driver<'d> for Driver<'d, V> {
         ))
     }
 
-    fn start(self, control_max_packet_size: u16) -> (Self::Bus, Self::ControlPipe) {
+    fn start(self, control_max_packet_size: u16, _enable_sof_interrupts: bool) -> (Self::Bus, Self::ControlPipe) {
         (
             Bus {
                 regs: self.regs,

embassy-rp/src/usb.rs

@@ -330,7 +330,7 @@ impl<'d, T: Instance> driver::Driver<'d> for Driver<'d, T> {
         self.alloc_endpoint(ep_type, ep_addr, max_packet_size, interval_ms)
     }
 
-    fn start(self, control_max_packet_size: u16) -> (Self::Bus, Self::ControlPipe) {
+    fn start(self, control_max_packet_size: u16, _enable_sof_interrupts: bool) -> (Self::Bus, Self::ControlPipe) {
         let regs = T::regs();
         regs.inte().write(|w| {
             w.set_bus_reset(true);

embassy-stm32/src/usb/otg.rs

@@ -250,8 +250,8 @@ impl<'d, T: Instance> embassy_usb_driver::Driver<'d> for Driver<'d, T> {
             .alloc_endpoint_out(ep_type, ep_addr, max_packet_size, interval_ms)
     }
 
-    fn start(self, control_max_packet_size: u16) -> (Self::Bus, Self::ControlPipe) {
-        let (bus, cp) = self.inner.start(control_max_packet_size);
+    fn start(self, control_max_packet_size: u16, enable_sof_interrupts: bool) -> (Self::Bus, Self::ControlPipe) {
+        let (bus, cp) = self.inner.start(control_max_packet_size, enable_sof_interrupts);
 
         (
             Bus {

embassy-stm32/src/usb/usb.rs

@@ -514,7 +514,7 @@ impl<'d, T: Instance> driver::Driver<'d> for Driver<'d, T> {
         self.alloc_endpoint(ep_type, ep_addr, max_packet_size, interval_ms)
     }
 
-    fn start(mut self, control_max_packet_size: u16) -> (Self::Bus, Self::ControlPipe) {
+    fn start(mut self, control_max_packet_size: u16, _enable_sof_interrupts: bool) -> (Self::Bus, Self::ControlPipe) {
         let ep_out = self
             .alloc_endpoint(EndpointType::Control, None, control_max_packet_size, 0)
             .unwrap();

embassy-usb-driver/src/lib.rs

@@ -168,7 +168,7 @@ pub trait Driver<'a> {
     ///
     /// This consumes the `Driver` instance, so it's no longer possible to allocate more
     /// endpoints.
-    fn start(self, control_max_packet_size: u16) -> (Self::Bus, Self::ControlPipe);
+    fn start(self, control_max_packet_size: u16, enable_sof_interrupts: bool) -> (Self::Bus, Self::ControlPipe);
 }
 
 /// USB bus trait.
@@ -402,6 +402,9 @@ pub enum Event {
 
     /// The USB power has been removed. Not supported by all devices.
     PowerRemoved,
+
+    /// A Start of Frame token has been received
+    SOF,
 }
 
 /// Allocating an endpoint failed.

embassy-usb-synopsys-otg/src/lib.rs

@@ -479,7 +479,7 @@ impl<'d, const MAX_EP_COUNT: usize> embassy_usb_driver::Driver<'d> for Driver<'d
         self.alloc_endpoint(ep_type, ep_addr, max_packet_size, interval_ms)
     }
 
-    fn start(mut self, control_max_packet_size: u16) -> (Self::Bus, Self::ControlPipe) {
+    fn start(mut self, control_max_packet_size: u16, _enable_sof_interrupts: bool) -> (Self::Bus, Self::ControlPipe) {
         let ep_out = self
             .alloc_endpoint(EndpointType::Control, None, control_max_packet_size, 0)
             .unwrap();

embassy-usb/src/builder.rs

@@ -117,6 +117,18 @@ pub struct Config<'a> {
     /// Default: 100mA
     /// Max: 500mA
     pub max_power: u16,
+
+    /// Whether to enable SOF interrupts
+    ///
+    /// Start of Frame can be a useful event on the bus, happening either every
+    /// 1ms for USB LS and FS, or every 125µs for USB HS. This can be used as a
+    /// free extra timer in a lot of cases, and as a way to process events at
+    /// the end of the frame if things needed deferring. However, this can be
+    /// a significant amount of interrupt traffic, so only enable this if you
+    /// really need this style of handling.
+    ///
+    /// Default: `false`
+    pub enable_sof_interrupts: bool,
 }
 
 impl<'a> Config<'a> {
@@ -138,6 +150,7 @@ impl<'a> Config<'a> {
             supports_remote_wakeup: false,
             composite_with_iads: true,
             max_power: 100,
+            enable_sof_interrupts: false,
         }
     }
 }

embassy-usb/src/lib.rs

@@ -111,6 +111,9 @@ pub trait Handler {
         let _ = alternate_setting;
     }
 
+    /// Called when a SOF token is processed.
+    fn sof(&mut self) {}
+
     /// Called when a control request is received with direction HostToDevice.
     ///
     /// # Arguments
@@ -225,7 +228,7 @@ impl<'d, D: Driver<'d>> UsbDevice<'d, D> {
     ) -> UsbDevice<'d, D> {
         // Start the USB bus.
         // This prevent further allocation by consuming the driver.
-        let (bus, control) = driver.start(config.max_packet_size_0 as u16);
+        let (bus, control) = driver.start(config.max_packet_size_0 as u16, config.enable_sof_interrupts);
         let device_descriptor = descriptor::device_descriptor(&config);
         let device_qualifier_descriptor = descriptor::device_qualifier_descriptor(&config);
 
@@ -495,6 +498,12 @@ impl<'d, D: Driver<'d>> Inner<'d, D> {
                     h.enabled(false);
                 }
             }
+            Event::SOF => {
+                trace!("usb: start of frame");
+                for h in &mut self.handlers {
+                    h.sof();
+                }
+            }
         }
     }