Launch commands for each device found if specified

drivers/pcid/Cargo.toml

@@ -2,5 +2,12 @@
 name = "pcid"
 version = "0.1.0"
 
+[dependencies]
+rustc-serialize = { git = "https://github.com/redox-os/rustc-serialize.git" }
+toml = "*"
+
 [dependencies.syscall]
 path = "../../syscall/"
+
+[replace]
+"rustc-serialize:0.3.19" = { git = "https://github.com/redox-os/rustc-serialize.git" }

drivers/pcid/src/config.rs

@@ -0,0 +1,14 @@
+#[derive(Debug, Default, RustcDecodable)]
+pub struct Config {
+    pub drivers: Vec<DriverConfig>
+}
+
+#[derive(Debug, Default, RustcDecodable)]
+pub struct DriverConfig {
+    pub name: Option<String>,
+    pub class: Option<u8>,
+    pub subclass: Option<u8>,
+    pub vendor: Option<u16>,
+    pub device: Option<u16>,
+    pub command: Option<Vec<String>>
+}

drivers/pcid/src/main.rs

@@ -1,15 +1,40 @@
 #![feature(asm)]
 
+extern crate rustc_serialize;
 extern crate syscall;
+extern crate toml;
 
+use std::env;
+use std::fs::File;
+use std::io::Read;
+use std::process::Command;
 use std::thread;
 use syscall::iopl;
 
+use config::Config;
 use pci::{Pci, PciBar, PciClass};
 
+mod config;
 mod pci;
 
-fn enumerate_pci() {
+fn main() {
+    thread::spawn(|| {
+        let mut config = Config::default();
+
+        let mut args = env::args().skip(1);
+        if let Some(config_path) = args.next() {
+            if let Ok(mut config_file) = File::open(&config_path) {
+                let mut config_data = String::new();
+                if let Ok(_) = config_file.read_to_string(&mut config_data) {
+                    config = toml::decode_str(&config_data).unwrap_or(Config::default());
+                }
+            }
+        }
+
+        println!("{:?}", config);
+
+        unsafe { iopl(3).unwrap() };
+
         println!("PCI BS/DV/FN VEND:DEVI CL.SC.IN.RV");
 
         let pci = Pci::new();
@@ -64,16 +89,56 @@ fn enumerate_pci() {
                         }
 
                         print!("\n");
+
+                        for driver in config.drivers.iter() {
+                            if let Some(class) = driver.class {
+                                if class != header.class { continue; }
                             }
+
+                            if let Some(subclass) = driver.subclass {
+                                if subclass != header.subclass { continue; }
                             }
+
+                            if let Some(vendor) = driver.vendor {
+                                if vendor != header.vendor_id { continue; }
                             }
+
+                            if let Some(device) = driver.device {
+                                if device != header.device_id { continue; }
+                            }
+
+                            if let Some(ref args) = driver.command {
+                                let mut args = args.iter();
+                                if let Some(program) = args.next() {
+                                    let mut command = Command::new(program);
+                                    for arg in args {
+                                        let bar_arg = |i| -> String {
+                                            match PciBar::from(header.bars[i]) {
+                                                PciBar::None => String::new(),
+                                                PciBar::Memory(address) => format!("{:>08X}", address),
+                                                PciBar::Port(address) => format!("{:>04X}", address)
+                                            }
+                                        };
+                                        let arg = match arg.as_str() {
+                                            "$0" => bar_arg(0),
+                                            "$1" => bar_arg(1),
+                                            "$2" => bar_arg(2),
+                                            "$3" => bar_arg(3),
+                                            "$4" => bar_arg(4),
+                                            "$5" => bar_arg(5),
+                                            _ => arg.clone()
+                                        };
+                                        command.arg(&arg);
+                                    }
+                                    println!("{:?}", command);
                                 }
                             }
 
-fn main() {
-    thread::spawn(||{
-        unsafe { iopl(3).unwrap() };
-
-        enumerate_pci();
+                            println!("Driver: {:?}", driver);
+                        }
+                    }
+                }
+            }
+        }
     });
 }

initfs/etc/init.rc

@@ -1,5 +1,5 @@
 initfs:bin/vesad
 initfs:bin/ps2d
-#initfs:bin/pcid
-initfs:bin/example
-#initfs:bin/login display: initfs:bin/ion
+initfs:bin/pcid initfs:etc/pcid.toml
+#initfs:bin/example
+initfs:bin/login display: initfs:bin/ion

initfs/etc/pcid.toml

@@ -0,0 +1,5 @@
+[[drivers]]
+name = "AHCI storage"
+class = 1
+subclass = 6
+command = ["ahcid", "$5"]