Merge pull request #722 from embassy-rs/usb-altsettings

usb: builtin handling of interface alternate settings

Author: Dirbaio

embassy-nrf/Cargo.toml

@@ -17,6 +17,8 @@ flavors = [
 
 [features]
 
+defmt = ["dep:defmt", "embassy/defmt", "embassy-usb?/defmt"]
+
 # Enable nightly-only features
 nightly = ["embassy/nightly", "embedded-hal-1", "embedded-hal-async", "embassy-usb", "embedded-storage-async"]
 

embassy-nrf/src/usb.rs

@@ -194,16 +194,12 @@ impl<'d, T: Instance> driver::Driver<'d> for Driver<'d, T> {
     fn into_bus(self) -> Self::Bus {
         Bus {
             phantom: PhantomData,
-            alloc_in: self.alloc_in,
-            alloc_out: self.alloc_out,
         }
     }
 }
 
 pub struct Bus<'d, T: Instance> {
     phantom: PhantomData<&'d mut T>,
-    alloc_in: Allocator,
-    alloc_out: Allocator,
 }
 
 impl<'d, T: Instance> driver::Bus for Bus<'d, T> {
@@ -264,7 +260,16 @@ impl<'d, T: Instance> driver::Bus for Bus<'d, T> {
             if regs.events_usbreset.read().bits() != 0 {
                 regs.events_usbreset.reset();
                 regs.intenset.write(|w| w.usbreset().set());
-                self.set_configured(false);
+
+                // Disable all endpoints except EP0
+                regs.epinen.write(|w| unsafe { w.bits(0x01) });
+                regs.epouten.write(|w| unsafe { w.bits(0x01) });
+                READY_ENDPOINTS.store(In::mask(0), Ordering::Release);
+                for i in 1..=7 {
+                    In::waker(i).wake();
+                    Out::waker(i).wake();
+                }
+
                 return Poll::Ready(Event::Reset);
             }
 
@@ -297,57 +302,76 @@ impl<'d, T: Instance> driver::Bus for Bus<'d, T> {
     }
 
     #[inline]
-    fn set_configured(&mut self, configured: bool) {
+    fn set_address(&mut self, _addr: u8) {
+        // Nothing to do, the peripheral handles this.
+    }
+
+    fn endpoint_set_stalled(&mut self, ep_addr: EndpointAddress, stalled: bool) {
+        Driver::<T>::set_stalled(ep_addr, stalled)
+    }
+
+    fn endpoint_is_stalled(&mut self, ep_addr: EndpointAddress) -> bool {
+        Driver::<T>::is_stalled(ep_addr)
+    }
+
+    fn endpoint_set_enabled(&mut self, ep_addr: EndpointAddress, enabled: bool) {
         let regs = T::regs();
 
-        unsafe {
-            if configured {
-                // TODO: Initialize ISO buffers
+        let i = ep_addr.index();
+        let mask = 1 << i;
 
-                regs.epinen.write(|w| w.bits(self.alloc_in.used.into()));
-                regs.epouten.write(|w| w.bits(self.alloc_out.used.into()));
+        debug!("endpoint_set_enabled {:?} {}", ep_addr, enabled);
 
-                for i in 1..8 {
-                    let out_enabled = self.alloc_out.used & (1 << i) != 0;
+        match ep_addr.direction() {
+            UsbDirection::In => {
+                let mut was_enabled = false;
+                regs.epinen.modify(|r, w| {
+                    let mut bits = r.bits();
+                    was_enabled = (bits & mask) != 0;
+                    if enabled {
+                        bits |= mask
+                    } else {
+                        bits &= !mask
+                    }
+                    unsafe { w.bits(bits) }
+                });
 
+                let ready_mask = In::mask(i);
+                if enabled {
+                    if !was_enabled {
+                        READY_ENDPOINTS.fetch_or(ready_mask, Ordering::AcqRel);
+                    }
+                } else {
+                    READY_ENDPOINTS.fetch_and(!ready_mask, Ordering::AcqRel);
+                }
+
+                In::waker(i).wake();
+            }
+            UsbDirection::Out => {
+                regs.epouten.modify(|r, w| {
+                    let mut bits = r.bits();
+                    if enabled {
+                        bits |= mask
+                    } else {
+                        bits &= !mask
+                    }
+                    unsafe { w.bits(bits) }
+                });
+
+                let ready_mask = Out::mask(i);
+                if enabled {
                     // when first enabled, bulk/interrupt OUT endpoints will *not* receive data (the
                     // peripheral will NAK all incoming packets) until we write a zero to the SIZE
                     // register (see figure 203 of the 52840 manual). To avoid that we write a 0 to the
                     // SIZE register
-                    if out_enabled {
-                        regs.size.epout[i].reset();
-                    }
+                    regs.size.epout[i].reset();
+                } else {
+                    READY_ENDPOINTS.fetch_and(!ready_mask, Ordering::AcqRel);
                 }
 
-                // IN endpoints (low bits) default to ready.
-                // OUT endpoints (high bits) default to NOT ready, they become ready when data comes in.
-                READY_ENDPOINTS.store(0x0000FFFF, Ordering::Release);
-            } else {
-                // Disable all endpoints except EP0
-                regs.epinen.write(|w| w.bits(0x01));
-                regs.epouten.write(|w| w.bits(0x01));
-
-                READY_ENDPOINTS.store(In::mask(0), Ordering::Release);
+                Out::waker(i).wake();
             }
         }
-
-        for i in 1..=7 {
-            In::waker(i).wake();
-            Out::waker(i).wake();
-        }
-    }
-
-    #[inline]
-    fn set_device_address(&mut self, _addr: u8) {
-        // Nothing to do, the peripheral handles this.
-    }
-
-    fn set_stalled(&mut self, ep_addr: EndpointAddress, stalled: bool) {
-        Driver::<T>::set_stalled(ep_addr, stalled)
-    }
-
-    fn is_stalled(&mut self, ep_addr: EndpointAddress) -> bool {
-        Driver::<T>::is_stalled(ep_addr)
     }
 
     #[inline]

embassy-usb-hid/src/lib.rs

@@ -112,7 +112,8 @@ fn build<'d, D: Driver<'d>>(
     let len = config.report_descriptor.len();
 
     let mut func = builder.function(USB_CLASS_HID, USB_SUBCLASS_NONE, USB_PROTOCOL_NONE);
-    let mut iface = func.interface(Some(control));
+    let mut iface = func.interface();
+    iface.handler(control);
     let mut alt = iface.alt_setting(USB_CLASS_HID, USB_SUBCLASS_NONE, USB_PROTOCOL_NONE);
 
     // HID descriptor
@@ -438,6 +439,14 @@ impl<'d> ControlHandler for Control<'d> {
         self.out_report_offset.store(0, Ordering::Release);
     }
 
+    fn get_descriptor<'a>(&'a mut self, req: Request, _buf: &'a mut [u8]) -> InResponse<'a> {
+        match (req.value >> 8) as u8 {
+            HID_DESC_DESCTYPE_HID_REPORT => InResponse::Accepted(self.report_descriptor),
+            HID_DESC_DESCTYPE_HID => InResponse::Accepted(&self.hid_descriptor),
+            _ => InResponse::Rejected,
+        }
+    }
+
     fn control_out(&mut self, req: embassy_usb::control::Request, data: &[u8]) -> OutResponse {
         trace!("HID control_out {:?} {=[u8]:x}", req, data);
         if let RequestType::Class = req.request_type {
@@ -477,13 +486,8 @@ impl<'d> ControlHandler for Control<'d> {
 
     fn control_in<'a>(&'a mut self, req: Request, buf: &'a mut [u8]) -> InResponse<'a> {
         trace!("HID control_in {:?}", req);
-        match (req.request_type, req.request) {
-            (RequestType::Standard, Request::GET_DESCRIPTOR) => match (req.value >> 8) as u8 {
-                HID_DESC_DESCTYPE_HID_REPORT => InResponse::Accepted(self.report_descriptor),
-                HID_DESC_DESCTYPE_HID => InResponse::Accepted(&self.hid_descriptor),
-                _ => InResponse::Rejected,
-            },
-            (RequestType::Class, HID_REQ_GET_REPORT) => {
+        match req.request {
+            HID_REQ_GET_REPORT => {
                 let size = match ReportId::try_from(req.value) {
                     Ok(id) => self.request_handler.and_then(|x| x.get_report(id, buf)),
                     Err(_) => None,
@@ -495,7 +499,7 @@ impl<'d> ControlHandler for Control<'d> {
                     InResponse::Rejected
                 }
             }
-            (RequestType::Class, HID_REQ_GET_IDLE) => {
+            HID_REQ_GET_IDLE => {
                 if let Some(handler) = self.request_handler {
                     let id = req.value as u8;
                     let id = (id != 0).then(|| ReportId::In(id));
@@ -510,7 +514,7 @@ impl<'d> ControlHandler for Control<'d> {
                     InResponse::Rejected
                 }
             }
-            (RequestType::Class, HID_REQ_GET_PROTOCOL) => {
+            HID_REQ_GET_PROTOCOL => {
                 // UNSUPPORTED: Boot Protocol
                 buf[0] = 1;
                 InResponse::Accepted(&buf[0..1])

embassy-usb-serial/src/lib.rs

@@ -178,7 +178,8 @@ impl<'d, D: Driver<'d>> CdcAcmClass<'d, D> {
         let mut func = builder.function(USB_CLASS_CDC, CDC_SUBCLASS_ACM, CDC_PROTOCOL_NONE);
 
         // Control interface
-        let mut iface = func.interface(Some(control));
+        let mut iface = func.interface();
+        iface.handler(control);
         let comm_if = iface.interface_number();
         let data_if = u8::from(comm_if) + 1;
         let mut alt = iface.alt_setting(USB_CLASS_CDC, CDC_SUBCLASS_ACM, CDC_PROTOCOL_NONE);
@@ -218,7 +219,7 @@ impl<'d, D: Driver<'d>> CdcAcmClass<'d, D> {
         let comm_ep = alt.endpoint_interrupt_in(8, 255);
 
         // Data interface
-        let mut iface = func.interface(None);
+        let mut iface = func.interface();
         let data_if = iface.interface_number();
         let mut alt = iface.alt_setting(USB_CLASS_CDC_DATA, 0x00, CDC_PROTOCOL_NONE);
         let read_ep = alt.endpoint_bulk_out(max_packet_size);

embassy-usb/src/builder.rs

@@ -1,5 +1,7 @@
 use heapless::Vec;
 
+use crate::{Interface, STRING_INDEX_CUSTOM_START};
+
 use super::control::ControlHandler;
 use super::descriptor::{BosWriter, DescriptorWriter};
 use super::driver::{Driver, Endpoint};
@@ -121,11 +123,10 @@ impl<'a> Config<'a> {
 pub struct Builder<'d, D: Driver<'d>> {
     config: Config<'d>,
     handler: Option<&'d dyn DeviceStateHandler>,
-    interfaces: Vec<(u8, &'d mut dyn ControlHandler), MAX_INTERFACE_COUNT>,
+    interfaces: Vec<Interface<'d>, MAX_INTERFACE_COUNT>,
     control_buf: &'d mut [u8],
 
     driver: D,
-    next_interface_number: u8,
     next_string_index: u8,
 
     device_descriptor: DescriptorWriter<'d>,
@@ -180,8 +181,7 @@ impl<'d, D: Driver<'d>> Builder<'d, D> {
             config,
             interfaces: Vec::new(),
             control_buf,
-            next_interface_number: 0,
-            next_string_index: 4,
+            next_string_index: STRING_INDEX_CUSTOM_START,
 
             device_descriptor,
             config_descriptor,
@@ -212,14 +212,6 @@ impl<'d, D: Driver<'d>> Builder<'d, D> {
         self.control_buf.len()
     }
 
-    /// Allocates a new string index.
-    pub fn alloc_string(&mut self) -> StringIndex {
-        let index = self.next_string_index;
-        self.next_string_index += 1;
-
-        StringIndex::new(index)
-    }
-
     /// Add an USB function.
     ///
     /// If [`Config::composite_with_iads`] is set, this will add an IAD descriptor
@@ -234,7 +226,7 @@ impl<'d, D: Driver<'d>> Builder<'d, D> {
     ) -> FunctionBuilder<'_, 'd, D> {
         let iface_count_index = if self.config.composite_with_iads {
             self.config_descriptor.iad(
-                InterfaceNumber::new(self.next_interface_number),
+                InterfaceNumber::new(self.interfaces.len() as _),
                 0,
                 class,
                 subclass,
@@ -267,21 +259,21 @@ impl<'a, 'd, D: Driver<'d>> FunctionBuilder<'a, 'd, D> {
     /// Add an interface to the function.
     ///
     /// Interface numbers are guaranteed to be allocated consecutively, starting from 0.
-    pub fn interface(
-        &mut self,
-        handler: Option<&'d mut dyn ControlHandler>,
-    ) -> InterfaceBuilder<'_, 'd, D> {
+    pub fn interface(&mut self) -> InterfaceBuilder<'_, 'd, D> {
         if let Some(i) = self.iface_count_index {
             self.builder.config_descriptor.buf[i] += 1;
         }
 
-        let number = self.builder.next_interface_number;
-        self.builder.next_interface_number += 1;
+        let number = self.builder.interfaces.len() as _;
+        let iface = Interface {
+            handler: None,
+            current_alt_setting: 0,
+            num_alt_settings: 0,
+            num_strings: 0,
+        };
 
-        if let Some(handler) = handler {
-            if self.builder.interfaces.push((number, handler)).is_err() {
-                panic!("max interface count reached")
-            }
+        if self.builder.interfaces.push(iface).is_err() {
+            panic!("max interface count reached")
         }
 
         InterfaceBuilder {
@@ -305,6 +297,19 @@ impl<'a, 'd, D: Driver<'d>> InterfaceBuilder<'a, 'd, D> {
         self.interface_number
     }
 
+    pub fn handler(&mut self, handler: &'d mut dyn ControlHandler) {
+        self.builder.interfaces[self.interface_number.0 as usize].handler = Some(handler);
+    }
+
+    /// Allocates a new string index.
+    pub fn string(&mut self) -> StringIndex {
+        let index = self.builder.next_string_index;
+        self.builder.next_string_index += 1;
+        self.builder.interfaces[self.interface_number.0 as usize].num_strings += 1;
+
+        StringIndex::new(index)
+    }
+
     /// Add an alternate setting to the interface and write its descriptor.
     ///
     /// Alternate setting numbers are guaranteed to be allocated consecutively, starting from 0.
@@ -318,6 +323,7 @@ impl<'a, 'd, D: Driver<'d>> InterfaceBuilder<'a, 'd, D> {
     ) -> InterfaceAltBuilder<'_, 'd, D> {
         let number = self.next_alt_setting_number;
         self.next_alt_setting_number += 1;
+        self.builder.interfaces[self.interface_number.0 as usize].num_alt_settings += 1;
 
         self.builder.config_descriptor.interface_alt(
             self.interface_number,