Update hardware utilities and USB validation

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

local/recipes/system/redbear-hwutils/source/src/bin/lspci.rs

@@ -2,10 +2,12 @@ use std::fs;
 use std::process;
 
 use redbear_hwutils::{parse_args, parse_pci_location, PciLocation};
+use redox_driver_sys::pci::PciDeviceInfo;
+use redox_driver_sys::quirks::{lookup_pci_quirks, PciQuirkFlags};
 
 const USAGE: &str = "Usage: lspci\nList PCI devices exposed by /scheme/pci.";
 
-#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 struct PciDeviceSummary {
     location: PciLocation,
     vendor_id: u16,
@@ -14,6 +16,9 @@ struct PciDeviceSummary {
     subclass: u8,
     prog_if: u8,
     revision: u8,
+    subvendor_id: u16,
+    subdevice_id: u16,
+    quirk_flags: PciQuirkFlags,
 }
 
 fn main() {
@@ -27,14 +32,118 @@ fn main() {
     }
 }
 
+fn format_quirk_flags(flags: PciQuirkFlags) -> String {
+    let mut names = Vec::new();
+    if flags.contains(PciQuirkFlags::NO_MSI) {
+        names.push("no_msi");
+    }
+    if flags.contains(PciQuirkFlags::NO_MSIX) {
+        names.push("no_msix");
+    }
+    if flags.contains(PciQuirkFlags::FORCE_LEGACY_IRQ) {
+        names.push("force_legacy_irq");
+    }
+    if flags.contains(PciQuirkFlags::NO_PM) {
+        names.push("no_pm");
+    }
+    if flags.contains(PciQuirkFlags::NO_D3COLD) {
+        names.push("no_d3cold");
+    }
+    if flags.contains(PciQuirkFlags::NO_ASPM) {
+        names.push("no_aspm");
+    }
+    if flags.contains(PciQuirkFlags::NEED_IOMMU) {
+        names.push("need_iommu");
+    }
+    if flags.contains(PciQuirkFlags::NO_IOMMU) {
+        names.push("no_iommu");
+    }
+    if flags.contains(PciQuirkFlags::DMA_32BIT_ONLY) {
+        names.push("dma_32bit_only");
+    }
+    if flags.contains(PciQuirkFlags::RESIZE_BAR) {
+        names.push("resize_bar");
+    }
+    if flags.contains(PciQuirkFlags::DISABLE_BAR_SIZING) {
+        names.push("disable_bar_sizing");
+    }
+    if flags.contains(PciQuirkFlags::NEED_FIRMWARE) {
+        names.push("need_firmware");
+    }
+    if flags.contains(PciQuirkFlags::DISABLE_ACCEL) {
+        names.push("disable_accel");
+    }
+    if flags.contains(PciQuirkFlags::FORCE_VRAM_ONLY) {
+        names.push("force_vram_only");
+    }
+    if flags.contains(PciQuirkFlags::NO_USB3) {
+        names.push("no_usb3");
+    }
+    if flags.contains(PciQuirkFlags::RESET_DELAY_MS) {
+        names.push("reset_delay_ms");
+    }
+    if flags.contains(PciQuirkFlags::NO_STRING_FETCH) {
+        names.push("no_string_fetch");
+    }
+    if flags.contains(PciQuirkFlags::BAD_EEPROM) {
+        names.push("bad_eeprom");
+    }
+    if flags.contains(PciQuirkFlags::BUS_MASTER_DELAY) {
+        names.push("bus_master_delay");
+    }
+    if flags.contains(PciQuirkFlags::WRONG_CLASS) {
+        names.push("wrong_class");
+    }
+    if flags.contains(PciQuirkFlags::BROKEN_BRIDGE) {
+        names.push("broken_bridge");
+    }
+    if flags.contains(PciQuirkFlags::NO_RESOURCE_RELOC) {
+        names.push("no_resource_reloc");
+    }
+    names.join(",")
+}
+
+fn lookup_quirks(
+    vendor_id: u16,
+    device_id: u16,
+    revision: u8,
+    class_code: u8,
+    subclass: u8,
+    prog_if: u8,
+    subvendor_id: u16,
+    subdevice_id: u16,
+) -> PciQuirkFlags {
+    let info = PciDeviceInfo {
+        location: redox_driver_sys::pci::PciLocation {
+            segment: 0,
+            bus: 0,
+            device: 0,
+            function: 0,
+        },
+        vendor_id,
+        device_id,
+        subsystem_vendor_id: subvendor_id,
+        subsystem_device_id: subdevice_id,
+        revision,
+        class_code,
+        subclass,
+        prog_if,
+        header_type: 0,
+        irq: None,
+        bars: Vec::new(),
+        capabilities: Vec::new(),
+    };
+    lookup_pci_quirks(&info)
+}
+
 fn run() -> Result<(), String> {
     parse_args("lspci", USAGE, std::env::args())?;
 
     let mut devices = collect_devices()?;
-    devices.sort();
+    devices.sort_by_key(|d| d.location);
 
     for device in devices {
-        println!(
+        print!(
             "{} class {:02x}:{:02x}.{:02x} vendor {:04x} device {:04x} rev {:02x}",
             device.location,
             device.class_code,
@@ -44,6 +153,10 @@ fn run() -> Result<(), String> {
             device.device_id,
             device.revision,
         );
+        if !device.quirk_flags.is_empty() {
+            print!(" quirks: {}", format_quirk_flags(device.quirk_flags));
+        }
+        println!();
     }
 
     Ok(())
@@ -79,14 +192,44 @@ fn collect_devices() -> Result<Vec<PciDeviceSummary>, String> {
             continue;
         }
 
+        let vendor_id = u16::from_le_bytes([config[0x00], config[0x01]]);
+        let device_id = u16::from_le_bytes([config[0x02], config[0x03]]);
+        let revision = config[0x08];
+        let prog_if = config[0x09];
+        let subclass = config[0x0A];
+        let class_code = config[0x0B];
+
+        let (subvendor_id, subdevice_id) = if config.len() >= 0x30 {
+            (
+                u16::from_le_bytes([config[0x2C], config[0x2D]]),
+                u16::from_le_bytes([config[0x2E], config[0x2F]]),
+            )
+        } else {
+            (0xFFFF, 0xFFFF)
+        };
+
+        let quirk_flags = lookup_quirks(
+            vendor_id,
+            device_id,
+            revision,
+            class_code,
+            subclass,
+            prog_if,
+            subvendor_id,
+            subdevice_id,
+        );
+
         devices.push(PciDeviceSummary {
             location,
-            vendor_id: u16::from_le_bytes([config[0x00], config[0x01]]),
-            device_id: u16::from_le_bytes([config[0x02], config[0x03]]),
-            revision: config[0x08],
-            prog_if: config[0x09],
-            subclass: config[0x0A],
-            class_code: config[0x0B],
+            vendor_id,
+            device_id,
+            revision,
+            prog_if,
+            subclass,
+            class_code,
+            subvendor_id,
+            subdevice_id,
+            quirk_flags,
         });
     }