Add basic implementation of FtdiDeviceHandler

examples/ftdi.rs

@@ -0,0 +1,107 @@
+use env_logger;
+use std::any::Any;
+use std::net::*;
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+use usbip::{
+    ftdi::FtdiDeviceHandler, Direction, EndpointAttributes, SetupPacket, UsbDevice, UsbEndpoint,
+    UsbInterface, UsbInterfaceHandler,
+};
+
+const FTDI_VID: u16 = 0x0403;
+const FTDI_PID: u16 = 0x6011;
+
+#[derive(Clone)]
+pub struct PseudoFtdiHandler {
+    tx_buffer: Vec<u8>,
+}
+
+impl PseudoFtdiHandler {
+    pub fn new() -> Self {
+        Self { tx_buffer: vec![] }
+    }
+}
+
+// This implemention does not
+impl UsbInterfaceHandler for PseudoFtdiHandler {
+    fn handle_urb(
+        &mut self,
+        _interface: &UsbInterface,
+        ep: UsbEndpoint,
+        _setup: SetupPacket,
+        req: &[u8],
+    ) -> Result<Vec<u8>, std::io::Error> {
+        // interrupt
+        if ep.attributes == EndpointAttributes::Interrupt as u8 {
+            Ok(vec![])
+        }
+        // bulk
+        else if let Direction::Out = ep.direction() {
+            // write to device/file here...
+            println!("Write endpoint {:02x}: {:?}", ep.address, req);
+            Ok(vec![])
+        } else {
+            // Read from the device.
+            // The first two bytes are device status.
+            // These must always be present, otherwise the ftdi driver on the remote side will
+            // consume these bytes.
+            if self.tx_buffer.len() > 0 {
+                let mut ftdi_packet: Vec<u8> = vec![0x01, 0x00];
+                ftdi_packet.extend(&self.tx_buffer);
+                self.tx_buffer = vec![];
+                println!("Read endpoint {:02x}: {:?}", ep.address, ftdi_packet);
+                Ok(ftdi_packet)
+            } else {
+                Ok(vec![0x01, 0x00])
+            }
+        }
+    }
+
+    fn get_class_specific_descriptor(&self) -> Vec<u8> {
+        vec![]
+    }
+
+    fn as_any(&mut self) -> &mut dyn Any {
+        self
+    }
+}
+
+fn ftdi_device() -> (
+    UsbDevice,
+    Arc<std::sync::Mutex<Box<dyn UsbInterfaceHandler + Send>>>,
+) {
+    let pseudo = Arc::new(Mutex::new(
+        Box::new(PseudoFtdiHandler::new()) as Box<dyn usbip::UsbInterfaceHandler + Send>
+    ));
+    let device_handler = Arc::new(Mutex::new(
+        Box::new(FtdiDeviceHandler::new()) as Box<dyn usbip::UsbDeviceHandler + Send>
+    ));
+    let endpoints = FtdiDeviceHandler::endpoints(4);
+    let mut device = UsbDevice::new(0)
+        .with_interface(255, 255, 255, "", endpoints[0..2].to_vec(), pseudo.clone())
+        .with_interface(255, 255, 255, "", endpoints[2..4].to_vec(), pseudo.clone())
+        .with_interface(255, 255, 255, "", endpoints[4..6].to_vec(), pseudo.clone())
+        .with_interface(255, 255, 255, "", endpoints[6..8].to_vec(), pseudo.clone())
+        .with_device_handler(device_handler);
+
+    device.product_id = FTDI_PID;
+    device.vendor_id = FTDI_VID;
+    (device, pseudo)
+}
+
+#[tokio::main]
+async fn main() {
+    env_logger::init();
+    let (device, handler) = ftdi_device();
+    let server = usbip::UsbIpServer::new_simulated(vec![device]);
+    let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 3240);
+    tokio::spawn(usbip::server(addr, server));
+
+    loop {
+        tokio::time::sleep(Duration::from_secs(1)).await;
+        let mut handler = handler.lock().unwrap();
+        if let Some(ftdi) = handler.as_any().downcast_mut::<PseudoFtdiHandler>() {
+            ftdi.tx_buffer.extend(b"hello\0");
+        }
+    }
+}

src/device.rs

@@ -1,4 +1,28 @@
 use super::*;
+use rusb::Version as rusbVersion;
+
+#[derive(Clone, Default)]
+pub struct Version {
+    pub major: u8,
+    pub minor: u8,
+    pub patch: u8,
+}
+
+impl From<rusbVersion> for Version {
+    fn from(value: rusbVersion) -> Self {
+        Self {
+            major: value.major(),
+            minor: value.minor(),
+            patch: value.sub_minor(),
+        }
+    }
+}
+
+impl Into<rusbVersion> for Version {
+    fn into(self) -> rusbVersion {
+        rusbVersion(self.major, self.minor, self.patch)
+    }
+}
 
 /// Represent a USB device
 #[derive(Clone, Default)]
@@ -10,14 +34,16 @@ pub struct UsbDevice {
     pub speed: u32,
     pub vendor_id: u16,
     pub product_id: u16,
-    pub device_bcd: u16,
+    pub device_bcd: Version,
     pub device_class: u8,
     pub device_subclass: u8,
     pub device_protocol: u8,
     pub configuration_value: u8,
     pub num_configurations: u8,
     pub interfaces: Vec<UsbInterface>,
     pub device_handler: Option<Arc<Mutex<Box<dyn UsbDeviceHandler + Send>>>>,
+    pub usb_version: Version,
+
     pub(crate) ep0_in: UsbEndpoint,
     pub(crate) ep0_out: UsbEndpoint,
     // strings
@@ -130,7 +156,9 @@ impl UsbDevice {
         socket.write_u32(self.speed).await?;
         socket.write_u16(self.vendor_id).await?;
         socket.write_u16(self.product_id).await?;
-        socket.write_u16(self.device_bcd).await?;
+        socket
+            .write_u16((self.device_bcd.major as u16) << 8 | self.device_bcd.minor as u16)
+            .await?;
         socket.write_u8(self.device_class).await?;
         socket.write_u8(self.device_subclass).await?;
         socket.write_u8(self.device_protocol).await?;
@@ -198,18 +226,18 @@ impl UsbDevice {
                                 let mut desc = vec![
                                     0x12,         // bLength
                                     Device as u8, // bDescriptorType: Device
-                                    0x10,
-                                    0x02,                              // bcdUSB: USB 2.1
-                                    self.device_class,                 // bDeviceClass
-                                    self.device_subclass,              // bDeviceSubClass
-                                    self.device_protocol,              // bDeviceProtocol
+                                    self.usb_version.minor as u8,
+                                    self.usb_version.major as u8, // bcdUSB: USB 2.0
+                                    self.device_class,            // bDeviceClass
+                                    self.device_subclass,         // bDeviceSubClass
+                                    self.device_protocol,         // bDeviceProtocol
                                     self.ep0_in.max_packet_size as u8, // bMaxPacketSize0
-                                    self.vendor_id as u8,              // idVendor
+                                    self.vendor_id as u8,         // idVendor
                                     (self.vendor_id >> 8) as u8,
                                     self.product_id as u8, // idProduct
                                     (self.product_id >> 8) as u8,
-                                    self.device_bcd as u8, // bcdDevice
-                                    (self.device_bcd >> 8) as u8,
+                                    self.device_bcd.minor as u8, // bcdDevice
+                                    self.device_bcd.major as u8,
                                     self.string_manufacturer, // iManufacturer
                                     self.string_product,      // iProduct
                                     self.string_serial,       // iSerial
@@ -331,14 +359,14 @@ impl UsbDevice {
                                 let mut desc = vec![
                                     0x0A,                  // bLength
                                     DeviceQualifier as u8, // bDescriptorType: Device Qualifier
-                                    0x10,
-                                    0x02,                              // bcdUSB USB 2.1
-                                    self.device_class,                 // bDeviceClass
-                                    self.device_subclass,              // bDeviceSUbClass
-                                    self.device_protocol,              // bDeviceProtocol
+                                    self.usb_version.minor as u8,
+                                    self.usb_version.major as u8,
+                                    self.device_class,    // bDeviceClass
+                                    self.device_subclass, // bDeviceSUbClass
+                                    self.device_protocol, // bDeviceProtocol
                                     self.ep0_in.max_packet_size as u8, // bMaxPacketSize0
-                                    self.num_configurations,           // bNumConfigurations
-                                    0x00,                              // reserved
+                                    self.num_configurations, // bNumConfigurations
+                                    0x00,                 // reserved
                                 ];
 
                                 // requested len too short: wLength < real length

src/ftdi.rs

@@ -0,0 +1,117 @@
+use crate::{EndpointAttributes, SetupPacket, UsbDeviceHandler, UsbEndpoint};
+use std::any::Any;
+
+const FTDI_DEVICE_REQ_TYPE: u8 = 0xC0;
+const FTDI_SIO_RESET: u8 = 0; /* Reset the port */
+const FTDI_SIO_MODEM_CTRL: u8 = 1; /* Set the modem control register */
+const FTDI_SIO_SET_FLOW_CTRL: u8 = 2; /* Set flow control register */
+const FTDI_SIO_SET_BAUD_RATE: u8 = 3; /* Set baud rate */
+const FTDI_SIO_SET_DATA: u8 = 4; /* Set the data characteristics ofthe port */
+const FTDI_SIO_GET_MODEM_STATUS: u8 = 5; /* Retrieve current value of modem status register */
+const FTDI_SIO_SET_EVENT_CHAR: u8 = 6; /* Set the event character */
+const FTDI_SIO_SET_ERROR_CHAR: u8 = 7; /* Set the error character */
+const FTDI_SIO_SET_LATENCY_TIMER: u8 = 9; /* Set the latency timer */
+const FTDI_SIO_GET_LATENCY_TIMER: u8 = 0x0a; /* Get the latency timer */
+const FTDI_SIO_SET_BITMODE: u8 = 0x0b; /* Set bitbang mode */
+const FTDI_SIO_READ_PINS: u8 = 0x0c; /* Read immediate value of pins */
+const FTDI_SIO_READ_EEPROM: u8 = 0x90; /* Read EEPROM */
+
+const EP_MAX_PACKET_SIZE: u16 = 512;
+
+#[derive(Debug)]
+enum FTDISIORequestTypes {
+    Reset,
+    ModemCtrl,
+    SetFlowCtrl,
+    SetBaudRate,
+    SetData,
+    GetModemStatus,
+    SetEventChar,
+    SetErrorChar,
+    SetLatencyTimer,
+    GetLatencyTimer,
+    SetBitmode,
+    ReadPins,
+    ReadEEPROM,
+    Unknown,
+}
+
+impl From<u8> for FTDISIORequestTypes {
+    fn from(orig: u8) -> Self {
+        match orig {
+            FTDI_SIO_RESET => FTDISIORequestTypes::Reset,
+            FTDI_SIO_MODEM_CTRL => FTDISIORequestTypes::ModemCtrl,
+            FTDI_SIO_SET_FLOW_CTRL => FTDISIORequestTypes::SetFlowCtrl,
+            FTDI_SIO_SET_BAUD_RATE => FTDISIORequestTypes::SetBaudRate,
+            FTDI_SIO_SET_DATA => FTDISIORequestTypes::SetData,
+            FTDI_SIO_GET_MODEM_STATUS => FTDISIORequestTypes::GetModemStatus,
+            FTDI_SIO_SET_EVENT_CHAR => FTDISIORequestTypes::SetEventChar,
+            FTDI_SIO_SET_ERROR_CHAR => FTDISIORequestTypes::SetErrorChar,
+            FTDI_SIO_SET_LATENCY_TIMER => FTDISIORequestTypes::SetLatencyTimer,
+            FTDI_SIO_GET_LATENCY_TIMER => FTDISIORequestTypes::GetLatencyTimer,
+            FTDI_SIO_SET_BITMODE => FTDISIORequestTypes::SetBitmode,
+            FTDI_SIO_READ_PINS => FTDISIORequestTypes::ReadPins,
+            FTDI_SIO_READ_EEPROM => FTDISIORequestTypes::ReadEEPROM,
+            _ => FTDISIORequestTypes::Unknown,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct FtdiDeviceHandler {}
+
+impl FtdiDeviceHandler {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    pub fn endpoints(interface_count: u8) -> Vec<UsbEndpoint> {
+        let mut ret_eps = vec![];
+
+        for i in 0..interface_count {
+            ret_eps.push(UsbEndpoint {
+                /// bEndpointAddress
+                address: 0x81 + (0x2 * i),
+                /// bmAttributes
+                attributes: EndpointAttributes::Bulk as u8,
+                /// wMaxPacketSize
+                max_packet_size: EP_MAX_PACKET_SIZE as u16,
+                /// bInterval
+                interval: 0,
+            });
+
+            ret_eps.push(UsbEndpoint {
+                /// bEndpointAddress
+                address: 0x2 + (0x2 * i),
+                /// bmAttributes
+                attributes: EndpointAttributes::Bulk as u8,
+                /// wMaxPacketSize
+                max_packet_size: EP_MAX_PACKET_SIZE as u16,
+                /// bInterval
+                interval: 0,
+            })
+        }
+        ret_eps
+    }
+}
+
+impl UsbDeviceHandler for FtdiDeviceHandler {
+    fn handle_urb(&mut self, setup: SetupPacket, _: &[u8]) -> Result<Vec<u8>, std::io::Error> {
+        match setup.request_type {
+            FTDI_DEVICE_REQ_TYPE => match setup.request.into() {
+                FTDISIORequestTypes::GetModemStatus => Ok(vec![0x00]),
+                // 1 ms
+                FTDISIORequestTypes::GetLatencyTimer => Ok(vec![0x01]),
+                request => {
+                    println!("Unhandled: {:?}", request);
+                    Ok(vec![])
+                }
+            },
+            _ => Ok(vec![]),
+        }
+    }
+
+    fn as_any(&mut self) -> &mut dyn Any {
+        self
+    }
+}

src/host.rs

@@ -25,7 +25,7 @@ impl UsbInterfaceHandler for UsbHostInterfaceHandler {
             "To host device: ep={:?} setup={:?} req={:?}",
             ep, setup, req
         );
-        let mut buffer = [0u8; 1024];
+        let mut buffer = vec![0u8; ep.max_packet_size as usize];
         let timeout = std::time::Duration::new(1, 0);
         let handle = self.handle.lock().unwrap();
         if ep.attributes == EndpointAttributes::Control as u8 {