update

Author: ZR233

test_crates/test_libusb/tests/test.rs

@@ -1,6 +1,7 @@
 #![cfg(test)]
 
-use crab_usb::USBHost;
+use crab_usb::{BaseClass, DeviceInfo, USBHost};
+use log::info;
 
 #[tokio::test]
 async fn test() {
@@ -10,13 +11,34 @@ async fn test() {
         .init();
 
     let mut host = USBHost::new_libusb();
-    let mut ls = host.device_list().await.unwrap();
+    let ls = host.device_list().await.unwrap();
+
+    let mut info: Option<DeviceInfo> = None;
 
     for device in ls {
         println!("Device: {:?}", device.descriptor().await.unwrap());
 
         for iface in device.interface_descriptors() {
             println!("  Interface: {iface:?}",);
+
+            if iface.class == BaseClass::VIDEO {
+                info = Some(device);
+                break;
+            }
         }
     }
+
+    let mut info = info.unwrap();
+
+    let mut device = info.open().await.unwrap();
+    info!("Opened device: {device}");
+
+    let config = device.current_configuration_descriptor().await.unwrap();
+
+    for iface in &config.interfaces {
+        let interface = device
+            .claim_interface(iface.interface_number, 0)
+            .await
+            .unwrap();
+    }
 }

usb-host/src/host/common/mod.rs

@@ -1,6 +1,7 @@
+use alloc::collections::BTreeMap;
 use alloc::{boxed::Box, string::String, vec::Vec};
 use core::{fmt::Display, ptr::NonNull};
-use std::collections::BTreeMap;
+use log::debug;
 
 use usb_if::{
     descriptor::{
@@ -37,7 +38,7 @@ impl USBHost {
         self.raw.init().await
     }
 
-    pub async fn device_list(&self) -> Result<impl Iterator<Item = DeviceInfo>, USBError> {
+    pub async fn device_list(&mut self) -> Result<impl Iterator<Item = DeviceInfo>, USBError> {
         let devices = self.raw.device_list().await?;
         let mut device_infos = Vec::with_capacity(devices.len());
         for device in devices {
@@ -76,7 +77,6 @@ impl DeviceInfo {
 
     pub async fn open(&mut self) -> Result<Device, USBError> {
         let mut device = self.raw.open().await?;
-        device.set_configuration(1).await?; // Default to configuration 1
 
         let manufacturer_string = match self.descriptor.manufacturer_string_index {
             Some(index) => device.string_descriptor(index.get(), 0).await?,
@@ -93,6 +93,14 @@ impl DeviceInfo {
             None => String::new(),
         };
 
+        let mut config_value = device.get_configuration().await?;
+        if config_value == 0 {
+            debug!("Setting configuration 1");
+            device.set_configuration(1).await?; // Reset to configuration 0
+            config_value = 1;
+        }
+        debug!("Current configuration: {config_value}");
+
         Ok(Device {
             descriptor: self.descriptor.clone(),
             configurations: self.configurations.clone(),
@@ -183,6 +191,21 @@ impl Device {
         }
         Err(USBError::NotFound)
     }
+
+    pub async fn current_configuration_descriptor(
+        &mut self,
+    ) -> Result<ConfigurationDescriptor, USBError> {
+        let value = self.raw.get_configuration().await?;
+        if value == 0 {
+            return Err(USBError::NotFound);
+        }
+        for config in &self.configurations {
+            if config.configuration_value == value {
+                return Ok(config.clone());
+            }
+        }
+        Err(USBError::NotFound)
+    }
 }
 
 pub struct Interface {

usb-host/src/host/libusb/device.rs

@@ -2,7 +2,10 @@ use core::{mem::MaybeUninit, num::NonZero};
 
 use futures::FutureExt;
 use libusb1_sys::*;
-use usb_if::descriptor::{ConfigurationDescriptor, DeviceDescriptor, InterfaceDescriptor, InterfaceDescriptors};
+use log::debug;
+use usb_if::descriptor::{
+    ConfigurationDescriptor, DeviceDescriptor, InterfaceDescriptor, InterfaceDescriptors,
+};
 
 pub struct DeviceInfo {
     pub(crate) raw: *mut libusb_device,
@@ -37,9 +40,10 @@ impl usb_if::host::DeviceInfo for DeviceInfo {
         Result<Box<dyn usb_if::host::Device>, usb_if::host::USBError>,
     > {
         async move {
+            let desc = self.descriptor().await?;
+
             let mut handle = std::ptr::null_mut();
             usb!(libusb_open(self.raw, &mut handle))?;
-            let desc = self.descriptor().await?;
             let device = Device::new(handle, desc);
 
             Ok(Box::new(device) as Box<dyn usb_if::host::Device>)
@@ -85,7 +89,72 @@ impl usb_if::host::DeviceInfo for DeviceInfo {
             let mut interfaces = Vec::with_capacity(interface_num);
 
             for iface_num in 0..interface_num {
-                
+                let iface_desc = unsafe { &*desc.interface.add(iface_num) };
+                let alt_setting_num = iface_desc.num_altsetting as usize;
+                let mut alt_settings = Vec::with_capacity(alt_setting_num);
+
+                for alt_idx in 0..alt_setting_num {
+                    let alt_desc = unsafe { &*iface_desc.altsetting.add(alt_idx) };
+                    let endpoint_num = alt_desc.bNumEndpoints as usize;
+                    let mut endpoints = Vec::with_capacity(endpoint_num);
+
+                    for ep_idx in 0..endpoint_num {
+                        let ep_desc = unsafe { &*alt_desc.endpoint.add(ep_idx) };
+                        let direction = if ep_desc.bEndpointAddress & 0x80 != 0 {
+                            usb_if::transfer::Direction::In
+                        } else {
+                            usb_if::transfer::Direction::Out
+                        };
+
+                        let transfer_type = match ep_desc.bmAttributes & 0x03 {
+                            0 => usb_if::descriptor::EndpointType::Control,
+                            1 => usb_if::descriptor::EndpointType::Isochronous,
+                            2 => usb_if::descriptor::EndpointType::Bulk,
+                            3 => usb_if::descriptor::EndpointType::Interrupt,
+                            _ => unreachable!(),
+                        };
+
+                        let packets_per_microframe = match transfer_type {
+                            usb_if::descriptor::EndpointType::Isochronous
+                            | usb_if::descriptor::EndpointType::Interrupt => {
+                                (((ep_desc.wMaxPacketSize >> 11) & 0x03) + 1) as usize
+                            }
+                            _ => 1,
+                        };
+
+                        endpoints.push(usb_if::descriptor::EndpointDescriptor {
+                            address: ep_desc.bEndpointAddress & 0x0F,
+                            max_packet_size: ep_desc.wMaxPacketSize & 0x7FF,
+                            transfer_type,
+                            direction,
+                            packets_per_microframe,
+                            interval: ep_desc.bInterval,
+                        });
+                    }
+
+                    alt_settings.push(InterfaceDescriptor {
+                        interface_number: alt_desc.bInterfaceNumber,
+                        alternate_setting: alt_desc.bAlternateSetting,
+                        class: alt_desc.bInterfaceClass.into(),
+                        subclass: alt_desc.bInterfaceSubClass.into(),
+                        protocol: alt_desc.bInterfaceProtocol,
+                        string_index: NonZero::new(alt_desc.iInterface),
+                        string: None,
+                        num_endpoints: alt_desc.bNumEndpoints,
+                        endpoints,
+                    });
+                }
+
+                interfaces.push(InterfaceDescriptors {
+                    interface_number: unsafe {
+                        if !iface_desc.altsetting.is_null() {
+                            (*iface_desc.altsetting).bInterfaceNumber
+                        } else {
+                            iface_num as u8
+                        }
+                    },
+                    alt_settings,
+                });
             }
 
             let out = ConfigurationDescriptor {
@@ -115,14 +184,6 @@ impl Device {
     pub(crate) fn new(raw: *mut libusb_device_handle, desc: DeviceDescriptor) -> Self {
         Self { raw, desc }
     }
-
-    pub fn raw(&self) -> *mut libusb_device_handle {
-        self.raw
-    }
-
-    pub fn descriptor(&self) -> &DeviceDescriptor {
-        &self.desc
-    }
 }
 
 impl Drop for Device {
@@ -138,13 +199,22 @@ impl usb_if::host::Device for Device {
         &mut self,
         configuration: u8,
     ) -> futures::future::LocalBoxFuture<'_, Result<(), usb_if::host::USBError>> {
-        todo!()
+        async move {
+            usb!(libusb_set_configuration(self.raw, configuration as _))?;
+            Ok(())
+        }
+        .boxed_local()
     }
 
     fn get_configuration(
         &mut self,
     ) -> futures::future::LocalBoxFuture<'_, Result<u8, usb_if::host::USBError>> {
-        todo!()
+        async move {
+            let mut config = 0;
+            usb!(libusb_get_configuration(self.raw, &mut config))?;
+            Ok(config as _)
+        }
+        .boxed_local()
     }
 
     fn claim_interface(
@@ -155,13 +225,35 @@ impl usb_if::host::Device for Device {
         '_,
         Result<Box<dyn usb_if::host::Interface>, usb_if::host::USBError>,
     > {
-        todo!()
+        async move {
+            let res = usb!(libusb_kernel_driver_active(self.raw, interface as _))?;
+
+            if res == 1 {
+                usb!(libusb_detach_kernel_driver(self.raw, interface as _))?;
+                debug!("Kernel driver detached for interface {interface}");
+            }
+
+            usb!(libusb_claim_interface(self.raw, interface as _))?;
+
+            debug!("Interface {interface} claimed successfully");
+            if alternate != 0 {
+                usb!(libusb_set_interface_alt_setting(
+                    self.raw,
+                    interface as _,
+                    alternate as _,
+                ))?;
+                debug!("Interface {interface} set to alternate setting {alternate} successfully");
+            }
+
+            todo!()
+        }
+        .boxed_local()
     }
 
     fn string_descriptor(
         &mut self,
         index: u8,
-        language_id: u16,
+        _language_id: u16,
     ) -> futures::future::LocalBoxFuture<'_, Result<String, usb_if::host::USBError>> {
         async move {
             let mut buf = vec![0u8; 256];

usb-host/src/host/libusb/endpoint.rs

@@ -0,0 +1,5 @@
+use libusb1_sys::*;
+
+pub struct InterfaceImpl {
+    raw: *mut libusb_interface,
+}

usb-host/src/host/libusb/interface.rs

@@ -15,6 +15,8 @@ macro_rules! usb {
 
 mod context;
 mod device;
+mod endpoint;
+mod interface;
 
 #[macro_use]
 pub(crate) mod err;
@@ -59,3 +61,9 @@ impl Libusb {
         }
     }
 }
+
+impl Default for Libusb {
+    fn default() -> Self {
+        Self::new()
+    }
+}

usb-host/src/host/libusb/mod.rs

@@ -43,15 +43,12 @@ pub struct Device {
 }
 
 pub struct DeviceInfo {
-    device_desc: DeviceDescriptor,
     device: Option<Device>,
 }
 
 impl DeviceInfo {
     pub(crate) fn new(device: Device) -> Self {
-        let device_desc = device.desc.clone().unwrap();
         Self {
-            device_desc,
             device: Some(device),
         }
     }
@@ -73,7 +70,7 @@ impl usb_if::host::DeviceInfo for DeviceInfo {
     fn descriptor(
         &self,
     ) -> futures::future::LocalBoxFuture<'_, Result<DeviceDescriptor, USBError>> {
-        async { Ok(self.device_desc.clone()) }.boxed_local()
+        async { Ok(self.device.as_ref().unwrap().desc.clone().unwrap()) }.boxed_local()
     }
 
     fn configuration_descriptor(
@@ -166,12 +163,6 @@ impl usb_if::host::Device for Device {
         .boxed_local()
     }
 
-    // fn configuration_descriptor(
-    //     &mut self,
-    // ) -> futures::future::LocalBoxFuture<'_, Result<Vec<ConfigurationDescriptor>, USBError>> {
-    //     async { Ok(self.config_desc.to_vec()) }.boxed_local()
-    // }
-
     fn string_descriptor(
         &mut self,
         index: u8,
@@ -223,14 +214,13 @@ impl Device {
 
         trace!("Max packet size: {max_packet_size}");
         self.set_ep_packet_size(Dci::CTRL, max_packet_size).await?;
-
-        // let desc = self.descriptor().await?;
-        // for i in 0..desc.num_configurations {
-        //     let config = self.read_configuration_descriptor(i).await?;
-        //     let parsed_config = ConfigurationDescriptor::parse(&config)
-        //         .ok_or(USBError::Other("config descriptor parse err".into()))?;
-        //     self.config_desc.push(parsed_config);
-        // }
+        let desc = self.descriptor().await?;
+        for i in 0..desc.num_configurations {
+            let config = self.read_configuration_descriptor(i).await?;
+            let parsed_config = ConfigurationDescriptor::parse(&config)
+                .ok_or(USBError::Other("config descriptor parse err".into()))?;
+            self.config_desc.push(parsed_config);
+        }
 
         Ok(())
     }

usb-host/src/host/xhci/device.rs

@@ -491,10 +491,7 @@ impl RootHub {
             let ctx = root.dev_list.new_ctx(slot_id, is_64)?;
             let device = Device::new(slot_id, self, ctx, (port_idx + 1).into())?;
             device.ctrl_ep.listen(&mut root);
-            // {
-            //     let ep = device.ctrl_ep.lock();
-            //     root.litsen_transfer(&ep.ring);
-            // }
+
             device
         };
 

usb-host/src/host/xhci/root.rs

@@ -4,6 +4,9 @@
 extern crate alloc;
 
 use core::time::Duration;
+pub use usb_if::descriptor::*;
+pub use usb_if::err::*;
+pub use usb_if::transfer::*;
 
 #[macro_use]
 mod _macros;
@@ -13,7 +16,6 @@ mod host;
 
 pub use futures::future::BoxFuture;
 pub use host::*;
-use usb_if::transfer::wait;
 
 pub trait Kernel {
     fn sleep<'a>(duration: Duration) -> BoxFuture<'a, ()>;