Change USB version to 2.1 and add BOS functionality

Author: redpfire

src/class.rs

@@ -1,6 +1,6 @@
 use crate::{Result, UsbError};
 use crate::bus::{UsbBus, StringIndex};
-use crate::descriptor::DescriptorWriter;
+use crate::descriptor::{DescriptorWriter, BosWriter};
 use crate::control;
 use crate::control_pipe::ControlPipe;
 use crate::endpoint::EndpointAddress;
@@ -24,6 +24,15 @@ pub trait UsbClass<B: UsbBus> {
         Ok (())
     }
 
+    /// Called when a GET_DESCRIPTOR request is received for a BOS descriptor.
+    /// When called, the implementation should write its blobs such as capability
+    /// descriptors into `writer`. The BOS descriptor itself will be written by
+    /// [UsbDevice](crate::device::UsbDevice) and shouldn't be written by classes.
+    fn get_bos_descriptors(&self, writer: &mut BosWriter) -> Result<()> {
+        let _ = writer;
+        Ok (())
+    }
+
     /// Gets a class-specific string descriptor.
     ///
     /// Note: All string descriptor requests are passed to all classes in turn, so implementations
@@ -190,4 +199,4 @@ impl<'a, 'p, 'r, B: UsbBus> ControlOut<'a, 'p, 'r, B> {
     pub fn reject(self) -> Result<()> {
         self.pipe.reject()
     }
-}
+}

src/descriptor.rs

@@ -11,6 +11,8 @@ pub mod descriptor_type {
     pub const STRING: u8 = 3;
     pub const INTERFACE: u8 = 4;
     pub const ENDPOINT: u8 = 5;
+    pub const BOS: u8 = 0x0f;
+    pub const CAPABILITY: u8 = 0x10;
 }
 
 /// String descriptor language IDs.
@@ -21,6 +23,16 @@ pub mod lang_id {
     pub const ENGLISH_US: u16 = 0x0409;
 }
 
+/// Standard capability descriptor types
+#[allow(missing_docs)]
+pub mod capability_type {
+    pub const WIRELESS_USB: u8 = 1;
+    pub const USB_2_0_EXTENSION: u8 = 2;
+    pub const SS_USB_DEVICE: u8 = 3;
+    pub const CONTAINER_ID: u8 = 4;
+    pub const PLATFORM: u8 = 5;
+}
+
 /// A writer for USB descriptors.
 pub struct DescriptorWriter<'a> {
     buf: &'a mut [u8],
@@ -29,6 +41,68 @@ pub struct DescriptorWriter<'a> {
     num_endpoints_mark: Option<usize>,
 }
 
+/// A writer for Binary Object Store descriptor.
+pub struct BosWriter<'w, 'a: 'w> {
+    writer: &'w mut DescriptorWriter<'a>,
+    num_caps_mark: Option<usize>,
+}
+
+impl<'w, 'a: 'w> BosWriter<'w, 'a> {
+    pub(crate) fn new(writer: &'w mut DescriptorWriter<'a>) -> Self {
+        Self {
+            writer: writer,
+            num_caps_mark: None,
+        }
+    }
+
+    pub(crate) fn bos(&mut self) -> Result<()> {
+        self.num_caps_mark= Some(self.writer.position + 4);
+        self.writer.write(
+            descriptor_type::BOS,
+            &[
+                0x00, 0x00, // wTotalLength
+                0x00, // bNumDeviceCaps
+            ])
+    }
+    
+    /// Writes capability descriptor to a BOS
+    ///
+    /// # Arguments
+    ///
+    /// * `capability_type` - Type of a capability
+    /// * `data` - Binary data of the descriptor
+    pub fn capability(&mut self, capability_type: u8, data: &[u8]) -> Result<()> {
+        match self.num_caps_mark{
+            Some(mark) => self.writer.buf[mark] += 1,
+            None => return Err(UsbError::InvalidState),
+        }
+
+        let mut start = self.writer.position;
+        let blen = data.len();
+
+        if start + blen + 3 > self.writer.buf.len()
+            || (blen + 3) > 255 {
+            return Err(UsbError::BufferOverflow);
+        }
+
+        self.writer.buf[start] = (blen + 3) as u8;
+        self.writer.buf[start+1] = descriptor_type::CAPABILITY;
+        self.writer.buf[start+2] = capability_type;
+
+        start += 3;
+        self.writer.buf[start..start+blen].copy_from_slice(data);
+        self.writer.position = start + blen;
+
+        Ok(())
+    }
+
+    pub(crate) fn end_bos(&mut self) {
+        self.num_caps_mark= None;
+        let position = self.writer.position as u16;
+        self.writer.buf[2..4].copy_from_slice(&position.to_le_bytes());
+    }
+}
+
 impl DescriptorWriter<'_> {
     pub(crate) fn new(buf: &mut [u8]) -> DescriptorWriter<'_> {
         DescriptorWriter {
@@ -64,11 +138,12 @@ impl DescriptorWriter<'_> {
         Ok(())
     }
 
+
     pub(crate) fn device(&mut self, config: &device::Config) -> Result<()> {
         self.write(
             descriptor_type::DEVICE,
             &[
-                0x00, 0x02, // bcdUSB
+                0x10, 0x02, // bcdUSB 2.1
                 config.device_class, // bDeviceClass
                 config.device_sub_class, // bDeviceSubClass
                 config.device_protocol, // bDeviceProtocol

src/device.rs

@@ -3,7 +3,7 @@ use crate::bus::{UsbBusAllocator, UsbBus, PollResult, StringIndex};
 use crate::class::{UsbClass, ControlIn, ControlOut};
 use crate::control;
 use crate::control_pipe::ControlPipe;
-use crate::descriptor::{DescriptorWriter, descriptor_type, lang_id};
+use crate::descriptor::{DescriptorWriter, BosWriter, descriptor_type, lang_id};
 use crate::endpoint::{EndpointType, EndpointAddress};
 pub use crate::device_builder::{UsbDeviceBuilder, UsbVidPid};
 
@@ -413,6 +413,19 @@ impl<B: UsbBus> UsbDevice<'_, B> {
         }
 
         match dtype {
+            descriptor_type::BOS => accept_writer(xfer, |w| {
+                let mut bw = BosWriter::new(w);
+                bw.bos()?;
+
+                for cls in classes {
+                    cls.get_bos_descriptors(&mut bw)?;
+                }
+
+                bw.end_bos();
+
+                Ok(())
+            }),
+
             descriptor_type::DEVICE => accept_writer(xfer, |w| w.device(config)),
 
             descriptor_type::CONFIGURATION => accept_writer(xfer, |w| {

src/device_builder.rs

@@ -148,4 +148,4 @@ impl<'a, B: UsbBus> UsbDeviceBuilder<'a, B> {
         self.config.max_power = (max_power_ma / 2) as u8;
         self
     }
-}
+}

src/lib.rs

@@ -185,7 +185,7 @@ pub mod prelude {
 pub mod class_prelude {
     pub use crate::UsbError;
     pub use crate::bus::{UsbBus, UsbBusAllocator, InterfaceNumber, StringIndex};
-    pub use crate::descriptor::DescriptorWriter;
+    pub use crate::descriptor::{DescriptorWriter, BosWriter};
     pub use crate::endpoint::{EndpointType, EndpointIn, EndpointOut, EndpointAddress};
     pub use crate::class::{UsbClass, ControlIn, ControlOut};
     pub use crate::control;
@@ -253,4 +253,4 @@ fn _ensure_sync() {
     ensure_sync::<crate::endpoint::EndpointIn<DummyBus>>();
     ensure_sync::<crate::endpoint::EndpointOut<DummyBus>>();
     ensure_sync::<DummyClass<'_, DummyBus>>();
-}
+}