Daniel Samson
ea470afe84
Every supervised driver owes the device manager a hello at startup, and the retry-lookup-call-check for it had been copied into five drivers: usb.helloManager (misfiled in the USB client) plus hand-rolled twins in display, virtio-gpu, pci-bus, and usb-xhci-bus. Extract it once as a runtime client, runtime.device_manager.hello(role, device_id) ?Handle — returns the manager endpoint (bus drivers keep it to report children through), null when there is no manager or it refused the handshake, and logs the outcome itself so each call site is one line. Also correct two roles while collapsing their calls: virtio-gpu and the display driver each claim one PCI function and report no children, so they are Role.device, not Role.bus. The manager ignores role today, so this is cosmetic, but it matches the protocol's own definition (bus = reports children via child_added). Behavior-preserving otherwise: pci-bus and usb-xhci-bus move their hello logging from raw serial writes to std.log, which the kernel renders with the same "<path>: " prefix, so driver-restart still matches "usb-xhci-bus: hello acknowledged". zig build clean; 8 QEMU cases pass (driver-restart, pci-scan, usb-hid, usb-storage, virtio-gpu, display-reattach, device-list, device-manager).
60 lines
2.3 KiB
Zig
60 lines
2.3 KiB
Zig
//! /system/drivers/display - the generic display engine driver.
|
|
//! This driver is a non official driver for GPU vendors like Intel, NVIDIA, AMD. It provides basic
|
|
//! display engine features to the display engine protocol used by the display server, compositor
|
|
//! and graphical user interface libraries like Zooeee.
|
|
//!
|
|
//! This driver is acts like BUS driver, in that it detects the GPU, its capabilities and loads
|
|
//! sub-drivers for each device detected. Similar The device manager
|
|
//! finds display adaptor e.g. over the PCI/ACPI, and passes the buck on to this driver to handle.
|
|
//!
|
|
//! The display driver provides the low level part of identifying the device and launching the
|
|
//! generic device driver for a GPU vendor.
|
|
//!
|
|
//! It takes over the framebuffer feature that was setup during system boot.
|
|
const std = @import("std");
|
|
const runtime = @import("runtime");
|
|
const mmio = @import("mmio");
|
|
const device = runtime.device;
|
|
const dma = runtime.dma;
|
|
const shared_memory = runtime.shared_memory;
|
|
const system = runtime.system;
|
|
const ipc = runtime.ipc;
|
|
const display_protocol = runtime.display_protocol;
|
|
const scanout_protocol = runtime.scanout_protocol;
|
|
var device_id: u64 = 0;
|
|
|
|
fn initialise(endpoint: ipc.Handle) bool {
|
|
_ = endpoint;
|
|
// Hello the device manager (role: device — we claim one GPU's PCI function
|
|
// and serve its display engine; we report no children). Best-effort: without a
|
|
// manager the driver still runs standalone; when present, the manager marks us
|
|
// up before the hello deadline and restarts us if we die.
|
|
_ = runtime.device_manager.hello(.device, device_id);
|
|
return true;
|
|
}
|
|
|
|
fn onMessage(message: []const u8, reply: []u8, sender: u32, capability: ?ipc.Handle) usize {
|
|
_ = sender;
|
|
_ = capability;
|
|
_ = reply;
|
|
|
|
if (message.len < scanout_protocol.request_size) return 0;
|
|
return 0;
|
|
}
|
|
|
|
pub fn main(init: runtime.process.Init) void {
|
|
const argument = init.arguments.get(1) orelse {
|
|
_ = system.write("display: missing device id (argv[1])\n");
|
|
return;
|
|
};
|
|
device_id = std.fmt.parseInt(u64, argument, 10) catch {
|
|
std.log.info("malformed device id '{s}'", .{argument});
|
|
return;
|
|
};
|
|
runtime.service.run(256, .{
|
|
.service = .scanout,
|
|
.init = initialise,
|
|
.on_message = onMessage,
|
|
});
|
|
}
|