feat: devices via caps (BootInfo, init assigns devices, drivers map MMIO/DMA themselves, IRQ-driven input); drop boot device wiring and info pages; headless display fallback

crates/init/src/devices.rs

@@ -0,0 +1,83 @@
+//! Which driver gets which device. Boot gave init a capability to every
+//! board device and a page saying where they are (`types::bootinfo`); init
+//! asks each virtio slot what it is and hands the disk, the GPU and the
+//! keyboard (or, without one, the UART) to their drivers.
+
+use hw_virtio::mmio::{
+    DEVICE_ID_BLOCK, DEVICE_ID_GPU, DEVICE_ID_INPUT, MAGIC, REG_DEVICE_ID, REG_MAGIC,
+};
+use libkos::device::{self, Device};
+use libkos::syscall;
+use types::badge::Badge;
+use types::bootinfo::{BOOT_INFO_VA, BootInfo, KIND_UART_16550, KIND_VIRTIO, NO_SLOT};
+use types::bounded::CapSlot;
+use types::permission::{Permission, PermissionSet};
+
+/// Where init briefly maps a device to ask what it is (top of the window).
+const PROBE_VA: usize = 0x01F0_0000;
+
+pub struct Devices {
+    pub disk: Device,
+    pub gpu: Device,
+    pub input: Device,
+}
+
+fn slot(raw: u64) -> Option<CapSlot> {
+    if raw == NO_SLOT {
+        return None;
+    }
+    CapSlot::new(u8::try_from(raw).ok()?)
+}
+
+/// The virtio device id behind `region`, 0 for an empty slot. Read through
+/// a copy of the capability, mapped only while looking and then dropped,
+/// which unmaps it.
+fn virtio_id(region: CapSlot) -> u32 {
+    let perms = PermissionSet::empty().with(Permission::Read).with(Permission::Write);
+    let Ok(copy) = syscall::mint(region, Badge::NONE, perms) else {
+        return 0;
+    };
+    let id = match device::map_mmio(copy, PROBE_VA) {
+        // SAFETY: PROBE_VA maps the device's registers until the drop below.
+        Ok(()) => unsafe {
+            let reg = |off: usize| core::ptr::read_volatile((PROBE_VA + off) as *const u32);
+            if reg(REG_MAGIC) == MAGIC { reg(REG_DEVICE_ID) } else { 0 }
+        },
+        Err(_) => 0,
+    };
+    syscall::drop_cap(copy);
+    id
+}
+
+/// Sorts the board's devices out.
+pub fn discover() -> Devices {
+    // SAFETY: boot maps the BootInfo page read-only at BOOT_INFO_VA before
+    // init runs; `devices()` checks its magic.
+    let info = unsafe { &*(BOOT_INFO_VA as *const BootInfo) };
+    let mut found = Devices { disk: Device::NONE, gpu: Device::NONE, input: Device::NONE };
+    let mut uart = Device::NONE;
+    for d in info.devices() {
+        let Some(region) = slot(d.region_slot) else {
+            continue;
+        };
+        let dev = Device { mmio: Some(region), irq: slot(d.irq_slot), kind: d.kind as usize };
+        let place = match d.kind {
+            KIND_UART_16550 => &mut uart,
+            KIND_VIRTIO => match virtio_id(region) {
+                DEVICE_ID_BLOCK => &mut found.disk,
+                DEVICE_ID_GPU => &mut found.gpu,
+                DEVICE_ID_INPUT => &mut found.input,
+                _ => continue,
+            },
+            _ => continue,
+        };
+        // The first device of each kind wins.
+        if place.mmio.is_none() {
+            *place = dev;
+        }
+    }
+    if found.input.mmio.is_none() {
+        found.input = uart;
+    }
+    found
+}