327 lines
15 KiB
Zig
327 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 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");
|
|
|
|
if (!device.claim(controller_device_descriptor.id)) {
|
|
_ = logging.write("/system/drivers/ps2-bus: unable to claim controller \n");
|
|
return;
|
|
}
|
|
|
|
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| {
|
|
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 {
|
|
_ = logging.write("/system/drivers/ps2-bus: auxiliary irq_bind failed\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);
|
|
}
|
|
}
|