Add a control_buf to UsbDevice

embassy-usb/src/builder.rs

@@ -120,6 +120,7 @@ impl<'a> Config<'a> {
 pub struct UsbDeviceBuilder<'d, D: Driver<'d>> {
     config: Config<'d>,
     interfaces: Vec<(u8, &'d mut dyn ControlHandler), MAX_INTERFACE_COUNT>,
+    control_buf: &'d mut [u8],
 
     bus: D,
     next_interface_number: u8,
@@ -133,12 +134,17 @@ pub struct UsbDeviceBuilder<'d, D: Driver<'d>> {
 
 impl<'d, D: Driver<'d>> UsbDeviceBuilder<'d, D> {
     /// Creates a builder for constructing a new [`UsbDevice`].
+    ///
+    /// `control_buf` is a buffer used for USB control request data. It should be sized
+    /// large enough for the length of the largest control request (in or out)
+    /// anticipated by any class added to the device.
     pub fn new(
         bus: D,
         config: Config<'d>,
         device_descriptor_buf: &'d mut [u8],
         config_descriptor_buf: &'d mut [u8],
         bos_descriptor_buf: &'d mut [u8],
+        control_buf: &'d mut [u8],
     ) -> Self {
         // Magic values specified in USB-IF ECN on IADs.
         if config.composite_with_iads
@@ -170,6 +176,7 @@ impl<'d, D: Driver<'d>> UsbDeviceBuilder<'d, D> {
             bus,
             config,
             interfaces: Vec::new(),
+            control_buf,
             next_interface_number: 0,
             next_string_index: 4,
 
@@ -191,6 +198,7 @@ impl<'d, D: Driver<'d>> UsbDeviceBuilder<'d, D> {
             self.config_descriptor.into_buf(),
             self.bos_descriptor.writer.into_buf(),
             self.interfaces,
+            self.control_buf,
         )
     }
 
@@ -202,6 +210,12 @@ impl<'d, D: Driver<'d>> UsbDeviceBuilder<'d, D> {
         InterfaceNumber::new(number)
     }
 
+    /// Returns the size of the control request data buffer. Can be used by
+    /// classes to validate the buffer is large enough for their needs.
+    pub fn control_buf_len(&self) -> usize {
+        self.control_buf.len()
+    }
+
     /// Allocates a new interface number, with a handler that will be called
     /// for all the control requests directed to it.
     pub fn alloc_interface_with_handler(

embassy-usb/src/control.rs

@@ -164,7 +164,7 @@ pub trait ControlHandler {
     /// # Arguments
     ///
     /// * `req` - The request from the SETUP packet.
-    fn control_in(&mut self, req: Request) -> InResponse<'_> {
+    fn control_in<'a>(&'a mut self, req: Request, buf: &'a mut [u8]) -> InResponse<'a> {
         InResponse::Rejected
     }
 }

embassy-usb/src/lib.rs

@@ -61,6 +61,7 @@ pub struct UsbDevice<'d, D: Driver<'d>> {
     device_descriptor: &'d [u8],
     config_descriptor: &'d [u8],
     bos_descriptor: &'d [u8],
+    control_buf: &'d mut [u8],
 
     device_state: UsbDeviceState,
     remote_wakeup_enabled: bool,
@@ -78,6 +79,7 @@ impl<'d, D: Driver<'d>> UsbDevice<'d, D> {
         config_descriptor: &'d [u8],
         bos_descriptor: &'d [u8],
         interfaces: Vec<(u8, &'d mut dyn ControlHandler), MAX_INTERFACE_COUNT>,
+        control_buf: &'d mut [u8],
     ) -> Self {
         let control = driver
             .alloc_control_pipe(config.max_packet_size_0 as u16)
@@ -94,6 +96,7 @@ impl<'d, D: Driver<'d>> UsbDevice<'d, D> {
             device_descriptor,
             config_descriptor,
             bos_descriptor,
+            control_buf,
             device_state: UsbDeviceState::Default,
             remote_wakeup_enabled: false,
             self_powered: false,
@@ -204,10 +207,9 @@ impl<'d, D: Driver<'d>> UsbDevice<'d, D> {
                 _ => self.control.reject(),
             },
             (RequestType::Class, Recipient::Interface) => {
-                let mut buf = [0; 128];
                 let data = if req.length > 0 {
-                    let size = self.control.data_out(&mut buf).await.unwrap();
-                    &buf[0..size]
+                    let size = self.control.data_out(self.control_buf).await.unwrap();
+                    &self.control_buf[0..size]
                 } else {
                     &[]
                 };
@@ -284,7 +286,7 @@ impl<'d, D: Driver<'d>> UsbDevice<'d, D> {
                     .find(|(i, _)| req.index == *i as _)
                     .map(|(_, h)| h);
                 match handler {
-                    Some(handler) => match handler.control_in(req) {
+                    Some(handler) => match handler.control_in(req, self.control_buf) {
                         InResponse::Accepted(data) => self.control.accept_in(data).await,
                         InResponse::Rejected => self.control.reject(),
                     },