Add a framework-ish for USB drivers.

Cargo.toml

@@ -15,4 +15,5 @@ members = [
     "vboxd",
     "vesad",
     "xhcid",
+    "usbscsid",
 ]

usbscsid/.gitignore

@@ -0,0 +1 @@
+/target

usbscsid/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "usbscsid"
+version = "0.1.0"
+authors = ["4lDO2 <4lDO2@protonmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

usbscsid/src/main.rs

@@ -0,0 +1,13 @@
+use std::env;
+
+fn main() {
+    let mut args = env::args().skip(1);
+
+    const USAGE: &'static str = "usbscsid <scheme> <port> <protocol>";
+
+    let scheme = args.next().expect(USAGE);
+    let port = args.next().expect(USAGE);
+    let protocol = args.next().expect(USAGE);
+
+    println!("USB SCSI driver spawned with scheme `{}`, port {}, protocol {}", scheme, port, protocol);
+}

xhcid/Cargo.toml

@@ -6,9 +6,11 @@ edition = "2018"
 [dependencies]
 bitflags = "1"
 plain = "0.2"
+lazy_static = "1.4"
 spin = "0.4"
 redox_event = { git = "https://gitlab.redox-os.org/redox-os/event.git" }
 redox_syscall = { git = "https://gitlab.redox-os.org/4lDO2/syscall.git", branch = "dma-slices" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 smallvec = { version = "1", features = ["serde"] }
+toml = "0.5"

xhcid/drivers.toml

@@ -0,0 +1,5 @@
+[[drivers]]
+name = "SCSI over USB"
+class = 8 # Mass Storage class
+subclass = 6 # SCSI transparent command set
+command = ["usbscsid", "$SCHEME", "$PORT", "$IF_PROTO"]

xhcid/src/main.rs

@@ -44,7 +44,7 @@ fn main() {
 
         let address = unsafe { syscall::physmap(bar, 65536, PHYSMAP_WRITE | PHYSMAP_NO_CACHE).expect("xhcid: failed to map address") };
         {
-            let hci = Arc::new(RefCell::new(Xhci::new(address).expect("xhcid: failed to allocate device")));
+            let hci = Arc::new(RefCell::new(Xhci::new(name, address).expect("xhcid: failed to allocate device")));
 
             hci.borrow_mut().probe().expect("xhcid: failed to probe");
 

xhcid/src/xhci/mod.rs

@@ -1,10 +1,13 @@
-use plain::Plain;
-use std::{mem, slice, sync::atomic, task};
+use std::{mem, slice, process, sync::atomic, task};
 use std::collections::BTreeMap;
+use std::ffi::OsStr;
 use std::pin::Pin;
 use std::sync::{Arc, Mutex, Weak, atomic::AtomicBool};
-use syscall::error::Result;
+
+use serde::Deserialize;
+use syscall::error::{EBADF, EBADMSG, ENOENT, Error, Result};
 use syscall::io::{Dma, Io};
+
 use crate::usb;
 
 mod capability;
@@ -139,6 +142,9 @@ pub struct Xhci {
     // IRQs, but it would make sense in case the hub has both isochronous (which trigger interrupts
     // reapeatedly with some time in between), bulk, control, etc. I might be wrong though...
     irq_state: Arc<IrqState>,
+
+    drivers: BTreeMap<usize, process::Child>,
+    scheme_name: String,
 }
 
 struct PortState {
@@ -167,7 +173,7 @@ impl EndpointState {
 }
 
 impl Xhci {
-    pub fn new(address: usize) -> Result<Xhci> {
+    pub fn new(scheme_name: String, address: usize) -> Result<Xhci> {
         let cap = unsafe { &mut *(address as *mut CapabilityRegs) };
         println!("  - CAP {:X}", address);
 
@@ -238,6 +244,8 @@ impl Xhci {
                 triggered: AtomicBool::new(false),
                 wakers: Mutex::new(Vec::new()),
             }),
+            drivers: BTreeMap::new(),
+            scheme_name,
         };
 
         xhci.init(max_slots);
@@ -380,15 +388,21 @@ impl Xhci {
                 }
 
                 let dev_desc = Self::get_dev_desc_raw(&mut self.ports, &mut self.run, &mut self.cmd, &mut self.dbs, i, slot, &mut ring)?;
-
-                self.port_states.insert(i, PortState {
+                let mut port_state = PortState {
                     slot,
                     input_context: input,
                     dev_desc,
                     endpoint_states: std::iter::once((0, EndpointState::Ready(
                         RingOrStreams::Ring(ring),
                     ))).collect::<BTreeMap<_, _>>(),
-                });
+                };
+
+                match self.spawn_drivers(i, &mut port_state) {
+                    Ok(()) => (),
+                    Err(err) => println!("Failed to spawn driver for port {}: `{}`", i, err),
+                }
+
+                self.port_states.insert(i, port_state);
             }
         }
 
@@ -405,7 +419,7 @@ impl Xhci {
             // FIXME: MSI and MSI-X systems
             self.run.ints[0].iman.writef(1, true);
 
-            // Wake all futures that await the IRQ.
+            // Wake all futures awaiting the IRQ.
             for waker in self.irq_state.wakers.lock().unwrap().drain(..) {
                 waker.wake();
             }
@@ -420,6 +434,51 @@ impl Xhci {
             state: IrqFutureState::Pending(Arc::downgrade(&self.irq_state))
         }
     }
+    fn spawn_drivers(&mut self, port: usize, ps: &mut PortState) -> Result<()> {
+        // TODO: There should probably be a way to select alternate interfaces, and not just the
+        // first one.
+        // TODO: Now that there are some good error crates, I don't think errno.h error codes are
+        // suitable here.
+
+        let ifdesc = &ps.dev_desc.config_descs.first().ok_or(Error::new(EBADF))?.interface_descs.first().ok_or(Error::new(EBADF))?;
+        let drivers_usercfg: &DriversConfig = &DRIVERS_CONFIG;
+
+        if let Some(driver) = drivers_usercfg.drivers.iter().find(|driver| driver.class == ifdesc.class && driver.subclass == ifdesc.sub_class) {
+            println!("Loading driver \"{}\"", driver.name);
+            let (command, args) = driver.command.split_first().ok_or(Error::new(EBADMSG))?;
+
+            let if_proto = ifdesc.protocol;
+
+            let process = process::Command::new(command).args(args.into_iter().map(|arg| arg.replace("$SCHEME", &self.scheme_name).replace("$PORT", &format!("{}", port)).replace("$IF_PROTO", &format!("{}", if_proto))).collect::<Vec<_>>()).stdin(process::Stdio::null()).spawn().or(Err(Error::new(ENOENT)))?;
+            self.drivers.insert(port, process);
+        } else {
+            return Err(Error::new(ENOENT));
+        }
+
+        Ok(())
+    }
+}
+#[derive(Deserialize)]
+struct DriverConfig {
+    name: String,
+    class: u8,
+    subclass: u8,
+    command: Vec<String>,
+}
+#[derive(Deserialize)]
+struct DriversConfig {
+    drivers: Vec<DriverConfig>,
+}
+
+use lazy_static::lazy_static;
+
+lazy_static! {
+    static ref DRIVERS_CONFIG: DriversConfig = {
+        // TODO: Load this at runtime.
+        const TOML: &'static [u8] = include_bytes!("../../drivers.toml");
+
+        toml::from_slice::<DriversConfig>(TOML).expect("Failed to parse internally embedded config file")
+    };
 }
 
 pub(crate) struct IrqFuture { state: IrqFutureState }

xhcid/src/xhci/scheme.rs

@@ -46,7 +46,7 @@ pub enum Handle {
     Port(usize, usize, Vec<u8>), // port, offset, contents
     PortDesc(usize, usize, Vec<u8>), // port, offset, contents
     PortState(usize, usize), // port, offset
-    PortReq(usize),
+    PortReq(usize), // port
     Endpoints(usize, usize, Vec<u8>), // port, offset, contents
     Endpoint(usize, u8, EndpointHandleTy), // port, endpoint, offset, state
     ConfigureEndpoints(usize), // port
@@ -55,7 +55,8 @@ pub enum Handle {
 #[derive(Serialize)]
 struct PortDesc(DevDesc);
 
-// Even though these descriptors are originally intended for JSON, they should suffice..
+// TODO: Even though these descriptors are originally intended for JSON, they should suffice... for
+// now.
 
 #[derive(Clone, Debug, Serialize)]
 pub(crate) struct DevDesc {