Daniel Samson
6b3a381626
The 8042 is a single controller described by two ACPI nodes — PNP0303 carries the 0x60/0x64 ports, PNP0F13 is the mouse — so it cannot be split across two processes without them fighting over the same registers. That is why ps2-bus is a singleton, and why it used to find and claim both nodes itself. The manager now gives it every matching node instead. The keyboard node rides the spawn, because it holds the ports and is needed immediately; the mouse node is transferred to the already-running instance. Late arrival is safe here and the ordering is natural rather than lucky: the mouse is not touched until after the controller handshakes and identify. Measured, the handover lands at 0.336 and the driver reaches the mouse at 0.456. Because the count is however many matched, a machine with no PS/2 ports or only one works without a special case — which matters, since the bus is mostly emulated now and machines vary. ps2-bus claims nothing. irq_bind on the mouse node is the proof it holds it: that call is ownership-gated, so a failure means the handover did not land rather than a hardware fault, and the log says so. acpi-ps2 asserts both delegations with the spawned device backreferenced, so the node that rides the spawn must be the one the driver was spawned for. Disabling the second delegation fails it. Two things worth recording. The first discrimination patch was not valid Zig, so nothing ran and a stale binary reported a pass — checked the build before believing it. And with the second delegation disabled, acpi-ps2 fails while input still passes: the mouse works without its IRQ binding, so exactly one case covers that path. Suite 118/118.
333 lines
16 KiB
Zig
333 lines
16 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 device = @import("driver");
|
|
const channel = @import("channel");
|
|
const ipc = @import("ipc");
|
|
const process = @import("process");
|
|
const service = @import("service");
|
|
const memory = @import("memory");
|
|
const logging = @import("logging");
|
|
const acpi_ids = @import("acpi-ids");
|
|
const ps2 = @import("ps2-library.zig");
|
|
|
|
/// 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 {
|
|
std.log.info("identify timed out on port {s}", .{@tagName(port)});
|
|
return null;
|
|
};
|
|
const driver_name = device_type.driverName() orelse {
|
|
std.log.info("unrecognized device on port {s}", .{@tagName(port)});
|
|
return null;
|
|
};
|
|
const hid = device_type.hid() orelse "";
|
|
if (process.spawnWithArguments(driver_name, &.{hid}) != null) {
|
|
std.log.info("port {s} is a {s}, spawned {s}", .{ @tagName(port), hid, driver_name });
|
|
return device_type;
|
|
}
|
|
std.log.info("failed to spawn {s}", .{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.
|
|
/// A child driver's AttachRequest. The endpoint it hands over arrives under the
|
|
/// same ownership rule the service harness states (`ipc.Arrival`): the turn owns
|
|
/// it, and only the path that records it in `port_endpoints` says `take`. Every
|
|
/// refusal here simply returns, and the loop closes what arrived — otherwise a
|
|
/// stranger (this is a named contract, reachable by anyone) spends one of this
|
|
/// driver's thirty-two handle slots per malformed attach.
|
|
fn handleAttach(message: []const u8, out: []u8, arrived: *ipc.Arrival) 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 = arrived.peek() 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;
|
|
// Claimed. A re-attach supersedes the previous driver's endpoint, and the
|
|
// one it displaces is closed: the slot holds exactly one reference.
|
|
if (port_endpoints[port_index]) |previous| {
|
|
if (previous != endpoint) _ = ipc.close(previous);
|
|
}
|
|
port_endpoints[port_index] = arrived.take();
|
|
std.log.info("{s} driver attached", .{@tagName(device_type)});
|
|
return reply.write(out, .ok);
|
|
}
|
|
return reply.write(out, .no_such_device);
|
|
}
|
|
|
|
pub fn main() void {
|
|
const buffer = memory.allocator().alloc(device.DeviceDescriptor, 64) catch {
|
|
_ = logging.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| {
|
|
_ = logging.write("/system/drivers/ps2-bus: found PS/2 controller\n");
|
|
_ = logging.write("/system/drivers/ps2-bus: initializing controller\n");
|
|
|
|
// The controller node arrived with the spawn — the manager holds the hardware
|
|
// and names it in the call that creates this process
|
|
// (docs/os-development/device-authority.md). Nothing to claim.
|
|
|
|
const controller = ps2.Controller.init(controller_device_descriptor) orelse {
|
|
_ = logging.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 {
|
|
_ = logging.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) {
|
|
_ = logging.write("/system/drivers/ps2-bus: controller configuration timed out\n");
|
|
return;
|
|
}
|
|
|
|
if (controller.performSelfTest()) |reply| {
|
|
if (reply != ps2.response_controller_test_passed) {
|
|
_ = logging.write("/system/drivers/ps2-bus: perform controller self test failed\n");
|
|
return;
|
|
}
|
|
} else {
|
|
_ = logging.write("/system/drivers/ps2-bus: controller self test timed out\n");
|
|
return;
|
|
}
|
|
|
|
has_two_channels = controller.hasTwoChannels() orelse {
|
|
_ = logging.write("/system/drivers/ps2-bus: controller channels timed out\n");
|
|
return;
|
|
};
|
|
|
|
if (has_two_channels) {
|
|
_ = logging.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 {
|
|
_ = logging.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 {
|
|
_ = logging.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 {
|
|
_ = logging.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) {
|
|
_ = logging.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) _ = logging.write("/system/drivers/ps2-bus: port 1 device reset failed\n");
|
|
} else {
|
|
_ = logging.write("/system/drivers/ps2-bus: port 1 device reset timed out\n");
|
|
}
|
|
}
|
|
if (port_two_works) {
|
|
if (controller.resetDevice(.two)) |passed| {
|
|
if (!passed) _ = logging.write("/system/drivers/ps2-bus: port 2 device reset failed\n");
|
|
} else {
|
|
_ = logging.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 {
|
|
_ = logging.write("/system/drivers/ps2-bus: no PS/2 controller found\n");
|
|
return;
|
|
}
|
|
|
|
const controller = maybe_controller.?;
|
|
const interrupt_index = maybe_interrupt_index orelse {
|
|
_ = logging.write("/system/drivers/ps2-bus: controller is missing its IRQ\n");
|
|
return;
|
|
};
|
|
|
|
// The endpoint the child drivers attach to and IRQ1 wakes. Bound as the
|
|
// `ps2-bus` contract so the children can find it by name, the way input
|
|
// subscribers find the input service. This driver runs its own loop rather
|
|
// than the service harness, so it binds by hand — same call the harness makes.
|
|
const endpoint = ipc.createIpcEndpoint() orelse {
|
|
_ = logging.write("/system/drivers/ps2-bus: no endpoint\n");
|
|
return;
|
|
};
|
|
if (!channel.bindPatiently("ps2-bus", endpoint)) {
|
|
_ = logging.write("/system/drivers/ps2-bus: could not bind /protocol/ps2-bus\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)) {
|
|
_ = logging.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 (ps2.findMouseDescriptor(buffer)) |descriptor| {
|
|
if (findInterruptResourceIndex(descriptor)) |auxiliary_index| {
|
|
// The mouse node is a *second* device for this one instance — the
|
|
// 8042 is one controller with two ports, so it cannot be split across
|
|
// two processes. It is transferred to us after the spawn, which is
|
|
// safe because we only reach it here, long after the controller
|
|
// handshakes and identify. irq_bind is the proof we hold it: it is
|
|
// gated on ownership, so a failure here means the handover has not
|
|
// landed rather than a hardware problem.
|
|
if (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 {
|
|
_ = logging.write("/system/drivers/ps2-bus: auxiliary irq_bind failed (mouse node not delegated?)\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var configuration = controller.readConfigurationByte() orelse {
|
|
_ = logging.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);
|
|
|
|
_ = logging.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);
|
|
// The turn owns whatever capability arrived and closes it unless
|
|
// `handleAttach` claims it (`ipc.Arrival`) — the kernel installs one
|
|
// whatever the message's length or kind, so this covers the notification
|
|
// path and every refusal below it.
|
|
var arrived: ipc.Arrival = .{ .handle = got.cap };
|
|
defer arrived.release();
|
|
|
|
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], &reply_buffer, &arrived);
|
|
}
|
|
}
|