usb: builtin handling of interface alternate settings

The stack reads its own descriptors to figure out which endpoints
are used in which alt settings, and enables/disables them as needed.

The ControlHandler has a callback so it can get notified of alternate
setting changes, which is purely informative (it doesn't have to do anything).

Author: Dirbaio

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

@@ -438,6 +438,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 +485,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 +498,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 +513,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/src/builder.rs

@@ -1,5 +1,7 @@
 use heapless::Vec;
 
+use crate::Interface;
+
 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,7 +181,6 @@ impl<'d, D: Driver<'d>> Builder<'d, D> {
             config,
             interfaces: Vec::new(),
             control_buf,
-            next_interface_number: 0,
             next_string_index: 4,
 
             device_descriptor,
@@ -234,7 +234,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,
@@ -275,13 +275,15 @@ impl<'a, 'd, D: Driver<'d>> FunctionBuilder<'a, 'd, D> {
             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,
+            current_alt_setting: 0,
+            num_alt_settings: 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 {
@@ -318,6 +320,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,

embassy-usb/src/control.rs

@@ -2,7 +2,6 @@ use core::mem;
 
 use crate::descriptor::DescriptorWriter;
 use crate::driver::{self, EndpointError};
-use crate::DEFAULT_ALTERNATE_SETTING;
 
 use super::types::*;
 
@@ -150,6 +149,10 @@ pub trait ControlHandler {
     /// Called after a USB reset after the bus reset sequence is complete.
     fn reset(&mut self) {}
 
+    fn set_alternate_setting(&mut self, alternate_setting: u8) {
+        let _ = alternate_setting;
+    }
+
     /// Called when a control request is received with direction HostToDevice.
     ///
     /// # Arguments
@@ -163,8 +166,8 @@ pub trait ControlHandler {
 
     /// Called when a control request is received with direction DeviceToHost.
     ///
-    /// You should write the response to `resp`, then return `InResponse::Accepted(len)`
-    /// with the length of the response.
+    /// You should write the response somewhere (usually to `buf`, but you may use another buffer
+    /// owned by yourself, or a static buffer), then return `InResponse::Accepted(data)`.
     ///
     /// # Arguments
     ///
@@ -174,23 +177,17 @@ pub trait ControlHandler {
         InResponse::Rejected
     }
 
-    fn set_interface(&mut self, alternate_setting: u16) -> OutResponse {
-        if alternate_setting == u16::from(DEFAULT_ALTERNATE_SETTING) {
-            OutResponse::Accepted
-        } else {
-            OutResponse::Rejected
-        }
-    }
-
-    fn get_interface<'a>(&'a mut self, buf: &'a mut [u8]) -> InResponse<'a> {
-        buf[0] = DEFAULT_ALTERNATE_SETTING;
-        InResponse::Accepted(&buf[0..1])
-    }
-
-    fn get_status<'a>(&'a mut self, buf: &'a mut [u8]) -> InResponse {
-        let status: u16 = 0;
-        buf[0..2].copy_from_slice(&status.to_le_bytes());
-        InResponse::Accepted(&buf[0..2])
+    /// Called when a GET DESCRIPTOR control request is received on the interface.
+    ///
+    /// You should write the response somewhere (usually to `buf`, but you may use another buffer
+    /// owned by yourself, or a static buffer), then return `InResponse::Accepted(data)`.
+    ///
+    /// # Arguments
+    ///
+    /// * `req` - The request from the SETUP packet.
+    fn get_descriptor<'a>(&'a mut self, req: Request, buf: &'a mut [u8]) -> InResponse<'a> {
+        let _ = (req, buf);
+        InResponse::Rejected
     }
 }
 

embassy-usb/src/descriptor.rs

@@ -1,5 +1,5 @@
 use super::builder::Config;
-use super::{types::*, CONFIGURATION_VALUE, DEFAULT_ALTERNATE_SETTING};
+use super::{types::*, CONFIGURATION_VALUE};
 
 /// Standard descriptor types
 #[allow(missing_docs)]
@@ -192,7 +192,7 @@ impl<'a> DescriptorWriter<'a> {
         interface_protocol: u8,
         interface_string: Option<StringIndex>,
     ) {
-        if alternate_setting == DEFAULT_ALTERNATE_SETTING {
+        if alternate_setting == 0 {
             match self.num_interfaces_mark {
                 Some(mark) => self.buf[mark] += 1,
                 None => {