Daniel Samson
767a2a9a7c
The AML interpreter now handles the Notify opcode (0x86, previously unhandled): it resolves the target device, evaluates the code, and records the pair in a bounded per-evaluate queue the caller drains with takeNotifications. A host unit test with hand-encoded AML — a method that issues Notify(DEV_, 0x80) — proves the device and code come back; aml.zig joins the zig build test loop so the interpreter is covered on the host. The acpi service's SCI handler now services general-purpose events too: for each set-and-enabled GPE bit it evaluates the \_GPE._Lxx (level) or _Exx (edge) handler method, drains the Notify queue that produced, and publishes a domain event per notified device — PNP0C0A battery, ACPI0003 AC, PNP0C0D lid, else generic notify — then clears the status bit and acks. The embedded controller's _Qxx queries are out of scope (hardware track). QEMU raises no GPEs on this config, so the QEMU suite is the regression net (the power button still works with GPE servicing in the path); correctness is the unit test. Suite 59/59.
316 lines
15 KiB
Zig
316 lines
15 KiB
Zig
//! The PS/2 Controller is located on the mainboard.
|
|
//! In the early days the controller was a single chip (Intel 8042).
|
|
//! As of today it is part of the Advanced Integrated Peripheral.
|
|
//!
|
|
//! It shows up in the device discovery as:
|
|
//! KBD_ [acpi_device] hid=PNP0303 (PS/2 Keyboard)
|
|
//! - io_port 0x60 len 0x1
|
|
//! - io_port 0x64 len 0x1
|
|
//! - irq 0x1 len 0x1
|
|
//! MOU_ [acpi_device] hid=PNP0F13 (PS/2 Mouse)
|
|
//! - irq 0xc len 0x1
|
|
const std = @import("std");
|
|
const runtime = @import("runtime");
|
|
const acpi_ids = @import("acpi-ids");
|
|
const ps2 = @import("ps2-library.zig");
|
|
const device = runtime.device;
|
|
const ipc = runtime.ipc;
|
|
|
|
/// Format one whole log line and emit it in a single `debug_write`, so output
|
|
/// from the child drivers (which run concurrently) can never interleave with it.
|
|
fn writeLine(comptime fmt: []const u8, arguments: anytype) void {
|
|
var line: [128]u8 = undefined;
|
|
_ = runtime.system.write(std.fmt.bufPrint(&line, fmt, arguments) catch return);
|
|
}
|
|
|
|
/// Ask the device on `port` what it is, then spawn the matching driver from the
|
|
/// initial-ramdisk, handing it the device's HID as argv[1]. The driver is chosen
|
|
/// from what the device reports, not from the port number. Returns the identified
|
|
/// type so the forwarding loop can route that port's bytes to the driver once it
|
|
/// attaches, or null if nothing was spawned.
|
|
fn spawnIdentifiedDriver(controller: ps2.Controller, port: ps2.Port) ?ps2.DeviceType {
|
|
const device_type = controller.identifyDevice(port) orelse {
|
|
writeLine("/system/drivers/ps2-bus: identify timed out on port {s}\n", .{@tagName(port)});
|
|
return null;
|
|
};
|
|
const driver_name = device_type.driverName() orelse {
|
|
writeLine("/system/drivers/ps2-bus: unrecognized device on port {s}\n", .{@tagName(port)});
|
|
return null;
|
|
};
|
|
const hid = device_type.hid() orelse "";
|
|
if (runtime.system.spawnWithArguments(driver_name, &.{hid}) != null) {
|
|
writeLine("/system/drivers/ps2-bus: port {s} is a {s}, spawned {s}\n", .{ @tagName(port), hid, driver_name });
|
|
return device_type;
|
|
}
|
|
writeLine("/system/drivers/ps2-bus: failed to spawn {s}\n", .{driver_name});
|
|
return null;
|
|
}
|
|
|
|
/// Resource index of the controller's IRQ (IRQ1) on the PNP0303 descriptor, found
|
|
/// the way the ports are found in `Controller.init`.
|
|
fn findInterruptResourceIndex(descriptor: device.DeviceDescriptor) ?u64 {
|
|
for (0..descriptor.resource_count) |index| {
|
|
if (descriptor.resources[index].kind == @intFromEnum(device.ResourceKind.irq)) return index;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// Forwarding endpoints of the attached child drivers, indexed by `ps2.Port`.
|
|
/// Written when a child's `AttachRequest` arrives, read on every forwarded byte.
|
|
var port_endpoints = [_]?ipc.Handle{ null, null };
|
|
|
|
/// Which device type each port identified as, so an attaching child (which knows
|
|
/// its type, not its port) can be matched to the right port's byte stream.
|
|
var port_device_types = [_]?ps2.DeviceType{ null, null };
|
|
|
|
/// Handle a child driver's `AttachRequest`: record the endpoint capability it
|
|
/// passed as the forwarding target for the port whose device matches its type.
|
|
/// Writes an `AttachReply` into `out` and returns its length.
|
|
fn handleAttach(message: []const u8, got: ipc.Received, out: []u8) usize {
|
|
const reply = struct {
|
|
fn write(buffer: []u8, status: ps2.AttachStatus) usize {
|
|
const header = ps2.AttachReply{ .status = @intFromEnum(status) };
|
|
@memcpy(buffer[0..@sizeOf(ps2.AttachReply)], std.mem.asBytes(&header));
|
|
return @sizeOf(ps2.AttachReply);
|
|
}
|
|
};
|
|
|
|
if (message.len < @sizeOf(ps2.AttachRequest)) return reply.write(out, .invalid_request);
|
|
const request = std.mem.bytesToValue(ps2.AttachRequest, message[0..@sizeOf(ps2.AttachRequest)]);
|
|
const endpoint = got.cap orelse return reply.write(out, .missing_endpoint);
|
|
|
|
for (&port_device_types, 0..) |maybe_type, port_index| {
|
|
const device_type = maybe_type orelse continue;
|
|
if (@intFromEnum(device_type) != request.device_type) continue;
|
|
port_endpoints[port_index] = endpoint;
|
|
writeLine("/system/drivers/ps2-bus: {s} driver attached\n", .{@tagName(device_type)});
|
|
return reply.write(out, .ok);
|
|
}
|
|
return reply.write(out, .no_such_device);
|
|
}
|
|
|
|
pub fn main() void {
|
|
const buffer = runtime.allocator().alloc(device.DeviceDescriptor, 64) catch {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: out of memory\n");
|
|
return;
|
|
};
|
|
|
|
var has_two_channels = false;
|
|
var maybe_controller: ?ps2.Controller = null;
|
|
var maybe_interrupt_index: ?u64 = null;
|
|
// The 8042's IO ports (0x60/0x64) are enumerated under the keyboard ACPI node
|
|
// (PNP0303), so we init the controller from that descriptor — but which device
|
|
// is on which port is decided later by identify, not by this HID.
|
|
const maybe_controller_device_descriptor = device.findDeviceDescriptorByHid(buffer, acpi_ids.HardwareId.ps2_keyboard.hid());
|
|
if (maybe_controller_device_descriptor) |controller_device_descriptor| {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: found PS/2 controller\n");
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: initializing controller\n");
|
|
|
|
if (!device.claim(controller_device_descriptor.id)) {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: unable to claim controller \n");
|
|
return;
|
|
}
|
|
|
|
const controller = ps2.Controller.init(controller_device_descriptor) orelse {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: controller is missing its IO ports\n");
|
|
return;
|
|
};
|
|
maybe_controller = controller;
|
|
maybe_interrupt_index = findInterruptResourceIndex(controller_device_descriptor);
|
|
|
|
controller.disablePort(.one);
|
|
controller.disablePort(.two);
|
|
controller.flushOutputBuffer();
|
|
|
|
const current = controller.readConfigurationByte() orelse {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: controller configuration timed out\n");
|
|
return;
|
|
};
|
|
|
|
const update = current & ~(ps2.configuration_first_port_interrupt |
|
|
ps2.configuration_second_port_interrupt |
|
|
ps2.configuration_first_port_translation);
|
|
|
|
if (controller.writeConfigurationByte(update) == null) {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: controller configuration timed out\n");
|
|
return;
|
|
}
|
|
|
|
if (controller.performSelfTest()) |reply| {
|
|
if (reply != ps2.response_controller_test_passed) {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: perform controller self test failed\n");
|
|
return;
|
|
}
|
|
} else {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: controller self test timed out\n");
|
|
return;
|
|
}
|
|
|
|
has_two_channels = controller.hasTwoChannels() orelse {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: controller channels timed out\n");
|
|
return;
|
|
};
|
|
|
|
if (has_two_channels) {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: has two channels\n");
|
|
// keep the bus quiet until we have tested the ports and are ready to use them
|
|
controller.disablePort(.two);
|
|
} else {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: has one channel\n");
|
|
}
|
|
|
|
// interface tests: always test port 1, test port 2 only if it exists
|
|
const port_one_works = (controller.testPort(.one) orelse {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: port 1 test timed out\n");
|
|
return;
|
|
}) == ps2.response_port_test_passed;
|
|
|
|
var port_two_works = false;
|
|
if (has_two_channels) {
|
|
port_two_works = (controller.testPort(.two) orelse {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: port 2 test timed out\n");
|
|
return;
|
|
}) == ps2.response_port_test_passed;
|
|
}
|
|
|
|
if (!port_one_works and !port_two_works) {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: no usable ports\n");
|
|
return;
|
|
}
|
|
|
|
// Enable the working ports. Their interrupts stay off until IRQ1 is bound
|
|
// below — reset and identify use polled reads, which must never race the
|
|
// interrupt-driven drain loop for bytes.
|
|
controller.enablePort(.one);
|
|
if (port_two_works) controller.enablePort(.two);
|
|
|
|
// reset each working device; a failing device is logged but does not
|
|
// abort bring-up of the other one
|
|
if (port_one_works) {
|
|
if (controller.resetDevice(.one)) |passed| {
|
|
if (!passed) _ = runtime.system.write("/system/drivers/ps2-bus: port 1 device reset failed\n");
|
|
} else {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: port 1 device reset timed out\n");
|
|
}
|
|
}
|
|
if (port_two_works) {
|
|
if (controller.resetDevice(.two)) |passed| {
|
|
if (!passed) _ = runtime.system.write("/system/drivers/ps2-bus: port 2 device reset failed\n");
|
|
} else {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: port 2 device reset timed out\n");
|
|
}
|
|
}
|
|
|
|
// Identify the device on each working port and hand it off to the driver
|
|
// that matches what it reported — a port is not assumed to be a keyboard
|
|
// or a mouse by its number.
|
|
if (port_one_works) port_device_types[@intFromEnum(ps2.Port.one)] = spawnIdentifiedDriver(controller, .one);
|
|
if (port_two_works) port_device_types[@intFromEnum(ps2.Port.two)] = spawnIdentifiedDriver(controller, .two);
|
|
} else {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: no PS/2 controller found\n");
|
|
return;
|
|
}
|
|
|
|
const controller = maybe_controller.?;
|
|
const interrupt_index = maybe_interrupt_index orelse {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: controller is missing its IRQ\n");
|
|
return;
|
|
};
|
|
|
|
// The endpoint the child drivers attach to and IRQ1 wakes. Registered under a
|
|
// well-known id so the children can find it, the way input subscribers find
|
|
// the input service.
|
|
const endpoint = ipc.createIpcEndpoint() orelse {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: no endpoint\n");
|
|
return;
|
|
};
|
|
if (!ipc.register(.ps2_bus, endpoint)) {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: register failed\n");
|
|
return;
|
|
}
|
|
|
|
// From here on, only the interrupt path reads the data port. Drop anything a
|
|
// device sent between enable-scanning and now, bind the IRQs, and only then
|
|
// let the controller raise them — an interrupt with nobody bound is lost.
|
|
controller.drainOutputBuffer();
|
|
if (!device.irqBind(controller.device_id, interrupt_index, endpoint)) {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: irq_bind failed\n");
|
|
return;
|
|
}
|
|
|
|
// Port 2's interrupt (IRQ12) is enumerated on the auxiliary device's own ACPI
|
|
// node (PNP0F13), not on the controller's — so if port 2 carries a device,
|
|
// claim that node too and route its IRQ to the same endpoint. The IRQ belongs
|
|
// to the *port*, whatever device identify found on it.
|
|
var maybe_auxiliary_interrupt: ?struct { device_id: u64, interrupt_index: u64, gsi: u64 } = null;
|
|
if (port_device_types[@intFromEnum(ps2.Port.two)] != null) {
|
|
if (device.findDeviceDescriptorByHid(buffer, acpi_ids.HardwareId.ps2_mouse.hid())) |descriptor| {
|
|
if (findInterruptResourceIndex(descriptor)) |auxiliary_index| {
|
|
if (device.claim(descriptor.id) and device.irqBind(descriptor.id, auxiliary_index, endpoint)) {
|
|
maybe_auxiliary_interrupt = .{
|
|
.device_id = descriptor.id,
|
|
.interrupt_index = auxiliary_index,
|
|
.gsi = descriptor.resources[auxiliary_index].start,
|
|
};
|
|
} else {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: auxiliary irq_bind failed\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var configuration = controller.readConfigurationByte() orelse {
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: controller configuration timed out\n");
|
|
return;
|
|
};
|
|
if (port_device_types[@intFromEnum(ps2.Port.one)] != null) configuration |= ps2.Port.one.interruptBit();
|
|
if (maybe_auxiliary_interrupt != null) configuration |= ps2.Port.two.interruptBit();
|
|
_ = controller.writeConfigurationByte(configuration);
|
|
|
|
_ = runtime.system.write("/system/drivers/ps2-bus: ok\n");
|
|
|
|
// The forwarding loop: an IRQ1 notification drains the output buffer, routing
|
|
// each byte to the attached driver of the port it came from; a client message
|
|
// is a child driver's AttachRequest.
|
|
var reply_buffer: [@sizeOf(ps2.AttachReply)]u8 = undefined;
|
|
var reply_len: usize = 0;
|
|
var receive: [@sizeOf(ps2.AttachRequest)]u8 = undefined;
|
|
while (true) {
|
|
const got = ipc.replyWait(endpoint, reply_buffer[0..reply_len], &receive, null);
|
|
if (got.isNotification()) {
|
|
reply_len = 0;
|
|
if (got.isMessage() or got.isChildExit()) continue; // nothing sends us these
|
|
while (true) {
|
|
const current_status = ps2.status(controller.device_id, controller.status_index);
|
|
if (current_status & ps2.status_output_buffer_full == 0) break;
|
|
const byte = device.ioRead(controller.device_id, controller.data_index, 0, 1) orelse break;
|
|
const port: ps2.Port = if (current_status & ps2.status_auxiliary_output != 0) .two else .one;
|
|
if (port_endpoints[@intFromEnum(port)]) |child| {
|
|
const forwarded = ps2.ForwardedByte{ .port = @intFromEnum(port), .byte = byte };
|
|
_ = ipc.send(child, std.mem.asBytes(&forwarded));
|
|
}
|
|
// An unattached port's byte is dropped — e.g. a keystroke before
|
|
// the keyboard driver has attached.
|
|
}
|
|
// Re-arm the line that woke us: the notification badge carries the
|
|
// GSI, and IRQ1 and IRQ12 are acked through different device claims.
|
|
if (maybe_auxiliary_interrupt) |auxiliary| {
|
|
if (got.source() == auxiliary.gsi) {
|
|
_ = device.irqAck(auxiliary.device_id, auxiliary.interrupt_index);
|
|
} else {
|
|
_ = device.irqAck(controller.device_id, interrupt_index);
|
|
}
|
|
} else {
|
|
_ = device.irqAck(controller.device_id, interrupt_index);
|
|
}
|
|
continue;
|
|
}
|
|
reply_len = handleAttach(receive[0..got.len], got, &reply_buffer);
|
|
}
|
|
}
|
|
|
|
pub const panic = runtime.panic;
|
|
comptime {
|
|
_ = &runtime.start._start;
|
|
}
|