From 13370c28db244edd24029d6066ac9e448bd419c9 Mon Sep 17 00:00:00 2001 From: alexmoon Date: Tue, 29 Mar 2022 15:09:24 -0400 Subject: [PATCH] Add a control_buf to UsbDevice --- embassy-usb/src/builder.rs | 14 ++++++++++++++ embassy-usb/src/control.rs | 2 +- embassy-usb/src/lib.rs | 10 ++++++---- examples/nrf/src/bin/usb/cdc_acm.rs | 19 ++++++++++--------- examples/nrf/src/bin/usb/main.rs | 2 ++ 5 files changed, 33 insertions(+), 14 deletions(-) diff --git a/embassy-usb/src/builder.rs b/embassy-usb/src/builder.rs index dfd36bdb3..0c118b782 100644 --- a/embassy-usb/src/builder.rs +++ b/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( diff --git a/embassy-usb/src/control.rs b/embassy-usb/src/control.rs index 195b218dc..19c2c6776 100644 --- a/embassy-usb/src/control.rs +++ b/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 } } diff --git a/embassy-usb/src/lib.rs b/embassy-usb/src/lib.rs index 5a82f5cae..a4b7dda30 100644 --- a/embassy-usb/src/lib.rs +++ b/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(), }, diff --git a/examples/nrf/src/bin/usb/cdc_acm.rs b/examples/nrf/src/bin/usb/cdc_acm.rs index 2a78324fe..c28681dc4 100644 --- a/examples/nrf/src/bin/usb/cdc_acm.rs +++ b/examples/nrf/src/bin/usb/cdc_acm.rs @@ -66,7 +66,6 @@ pub struct CdcAcmClass<'d, D: Driver<'d>> { struct Control<'a> { shared: &'a ControlShared, - buf: [u8; 7], } /// Shared data between Control and CdcAcmClass @@ -97,7 +96,7 @@ impl<'a> Control<'a> { } } -impl<'a> ControlHandler for Control<'a> { +impl<'d> ControlHandler for Control<'d> { fn reset(&mut self) { let shared = self.shared(); shared.line_coding.lock(|x| x.set(LineCoding::default())); @@ -139,17 +138,18 @@ impl<'a> ControlHandler for Control<'a> { } } - fn control_in(&mut self, req: Request) -> InResponse<'_> { + fn control_in<'a>(&'a mut self, req: Request, buf: &'a mut [u8]) -> InResponse<'a> { match req.request { // REQ_GET_ENCAPSULATED_COMMAND is not really supported - it will be rejected below. REQ_GET_LINE_CODING if req.length == 7 => { info!("Sending line coding"); let coding = self.shared().line_coding.lock(|x| x.get()); - self.buf[0..4].copy_from_slice(&coding.data_rate.to_le_bytes()); - self.buf[4] = coding.stop_bits as u8; - self.buf[5] = coding.parity_type as u8; - self.buf[6] = coding.data_bits; - InResponse::Accepted(&self.buf) + assert!(buf.len() >= 7); + buf[0..4].copy_from_slice(&coding.data_rate.to_le_bytes()); + buf[4] = coding.stop_bits as u8; + buf[5] = coding.parity_type as u8; + buf[6] = coding.data_bits; + InResponse::Accepted(&buf[0..7]) } _ => InResponse::Rejected, } @@ -166,11 +166,12 @@ impl<'d, D: Driver<'d>> CdcAcmClass<'d, D> { ) -> Self { let control = state.control.write(Control { shared: &state.shared, - buf: [0; 7], }); let control_shared = &state.shared; + assert!(builder.control_buf_len() >= 7); + let comm_if = builder.alloc_interface_with_handler(control); let comm_ep = builder.alloc_interrupt_endpoint_in(8, 255); let data_if = builder.alloc_interface(); diff --git a/examples/nrf/src/bin/usb/main.rs b/examples/nrf/src/bin/usb/main.rs index 398dd07b6..c4b9c0176 100644 --- a/examples/nrf/src/bin/usb/main.rs +++ b/examples/nrf/src/bin/usb/main.rs @@ -47,6 +47,7 @@ async fn main(_spawner: Spawner, p: Peripherals) { let mut device_descriptor = [0; 256]; let mut config_descriptor = [0; 256]; let mut bos_descriptor = [0; 256]; + let mut control_buf = [0; 7]; let mut state = State::new(); @@ -56,6 +57,7 @@ async fn main(_spawner: Spawner, p: Peripherals) { &mut device_descriptor, &mut config_descriptor, &mut bos_descriptor, + &mut control_buf, ); // Create classes on the builder.