strat9_kernel/hardware/usb/

hid.rs

// USB HID (Human Interface Device) Driver
// Supports boot protocol keyboards and mice
//
// Features:
// - Boot protocol keyboard support
// - Boot protocol mouse support
// - Event queue for key presses and mouse movements
// - PS/2 to USB keycode translation
// - Unification with PS/2: events feed into the same keyboard/mouse buffers
//
// Inspired by Redox usbhid, Asterinas input subsystem, Maestro device manager.

#![allow(dead_code)]

use crate::arch::x86_64::{keyboard, mouse};
use alloc::{sync::Arc, vec::Vec};
use core::sync::atomic::{AtomicBool, Ordering};
use spin::Mutex;

pub const HID_BOOT_KEYBOARD: u8 = 0x01;
pub const HID_BOOT_MOUSE: u8 = 0x02;

// USB HID Boot Keyboard Report size (8 bytes)
const KBD_REPORT_SIZE: usize = 8;

// USB HID Boot Mouse Report size (3 bytes for basic mice)
const MOUSE_REPORT_SIZE: usize = 3;

// Modifier keys
const MOD_LCTRL: u8 = 0x01;
const MOD_LSHIFT: u8 = 0x02;
const MOD_LALT: u8 = 0x04;
const MOD_LGUI: u8 = 0x08;
const MOD_RCTRL: u8 = 0x10;
const MOD_RSHIFT: u8 = 0x20;
const MOD_RALT: u8 = 0x40;
const MOD_RGUI: u8 = 0x80;

#[derive(Clone, Copy, Debug)]
pub struct KeyEvent {
    pub keycode: u8,
    pub pressed: bool,
    pub modifiers: u8,
}

#[derive(Clone, Copy, Debug)]
pub struct MouseEvent {
    pub dx: i8,
    pub dy: i8,
    pub dz: i8,
    pub buttons: u8,
}

// USB to PS/2 scan code translation table (subset)
// Maps USB HID usage IDs to PS/2 scan codes
const USB_TO_PS2: [u8; 128] = [
    0x00, 0x00, 0x00, 0x00, 0x1C, 0x32, 0x21, 0x23, // 00-07
    0x1D, 0x24, 0x2B, 0x34, 0x33, 0x43, 0x35, 0x0E, // 08-0F
    0x15, 0x16, 0x17, 0x1C, 0x18, 0x19, 0x14, 0x1A, // 10-17
    0x1B, 0x1D, 0x1E, 0x21, 0x22, 0x23, 0x24, 0x2B, // 18-1F
    0x29, 0x2F, 0x2E, 0x30, 0x20, 0x31, 0x32, 0x33, // 20-27
    0x2C, 0x2D, 0x11, 0x12, 0x13, 0x3F, 0x3E, 0x46, // 28-2F
    0x45, 0x5D, 0x4C, 0x36, 0x4A, 0x55, 0x37, 0x4E, // 30-37
    0x57, 0x5E, 0x5C, 0x41, 0x52, 0x4D, 0x4B, 0x5B, // 38-3F
    0x5A, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, // 40-47
    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, // 48-4F
    0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, // 50-57
    0x80, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 58-5F
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 60-67
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 68-6F
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 70-77
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 78-7F
];

/// Performs the usb to ps2 operation.
fn usb_to_ps2(keycode: u8) -> u8 {
    if keycode < USB_TO_PS2.len() as u8 {
        USB_TO_PS2[keycode as usize]
    } else {
        0x00
    }
}

pub struct HidKeyboard {
    port: usize,
    interface: u8,
    endpoint: u8,
    max_packet: u16,
    interval: u8,
    event_queue: Vec<KeyEvent>,
    last_report: [u8; KBD_REPORT_SIZE],
}

unsafe impl Send for HidKeyboard {}
unsafe impl Sync for HidKeyboard {}

impl HidKeyboard {
    /// Creates a new instance.
    pub fn new(port: usize, interface: u8, endpoint: u8, max_packet: u16, interval: u8) -> Self {
        Self {
            port,
            interface,
            endpoint,
            max_packet,
            interval,
            event_queue: Vec::new(),
            last_report: [0; KBD_REPORT_SIZE],
        }
    }

    /// Reads event.
    pub fn read_event(&mut self) -> Option<KeyEvent> {
        if self.event_queue.is_empty() {
            self.poll();
        }
        self.event_queue.pop()
    }

    /// Performs the poll operation.
    pub fn poll(&mut self) {
        // In a full implementation, this would submit an interrupt transfer
        // and parse the HID report. For now, we simulate basic functionality.
        // The actual polling would be done via xHCI interrupt transfers.
    }

    /// Performs the process report operation.
    pub fn process_report(&mut self, report: &[u8; KBD_REPORT_SIZE]) {
        // report[0] = modifiers
        // report[1] = reserved
        // report[2..7] = keycodes

        let modifiers = report[0];

        for i in 2..8 {
            let keycode = report[i];
            if keycode == 0 {
                continue;
            }

            // Check if key was pressed (new in this report)
            let was_pressed = self.last_report[2..8].contains(&keycode);
            if !was_pressed {
                self.event_queue.push(KeyEvent {
                    keycode: usb_to_ps2(keycode),
                    pressed: true,
                    modifiers,
                });
            }
        }

        // Check for released keys
        for i in 2..8 {
            let keycode = self.last_report[i];
            if keycode != 0 && !report[2..8].contains(&keycode) {
                self.event_queue.push(KeyEvent {
                    keycode: usb_to_ps2(keycode),
                    pressed: false,
                    modifiers,
                });
            }
        }

        self.last_report = *report;
    }

    /// Returns whether modifier pressed.
    pub fn is_modifier_pressed(&self, modifier: u8) -> bool {
        self.last_report[0] & modifier != 0
    }

    /// Drain event queue and inject into the unified keyboard buffer.
    pub fn drain_into_unified(&mut self) {
        while let Some(ev) = self.event_queue.pop() {
            keyboard::inject_hid_scancode(ev.keycode, ev.pressed);
        }
    }
}

pub struct HidMouse {
    port: usize,
    interface: u8,
    endpoint: u8,
    max_packet: u16,
    interval: u8,
    event_queue: Vec<MouseEvent>,
    last_buttons: u8,
}

unsafe impl Send for HidMouse {}
unsafe impl Sync for HidMouse {}

impl HidMouse {
    /// Creates a new instance.
    pub fn new(port: usize, interface: u8, endpoint: u8, max_packet: u16, interval: u8) -> Self {
        Self {
            port,
            interface,
            endpoint,
            max_packet,
            interval,
            event_queue: Vec::new(),
            last_buttons: 0,
        }
    }

    /// Reads event.
    pub fn read_event(&mut self) -> Option<MouseEvent> {
        if self.event_queue.is_empty() {
            self.poll();
        }
        self.event_queue.pop()
    }

    /// Performs the poll operation.
    pub fn poll(&mut self) {
        // In a full implementation, this would submit an interrupt transfer
        // and parse the HID report.
    }

    /// Performs the process report operation.
    pub fn process_report(&mut self, report: &[u8]) {
        if report.len() < 3 {
            return;
        }

        let buttons = report[0];
        let dx = report[1] as i8;
        let dy = report[2] as i8;
        let dz = if report.len() > 3 { report[3] as i8 } else { 0 };

        // Check for button changes
        for i in 0..5 {
            let mask = 1 << i;
            let was_pressed = self.last_buttons & mask != 0;
            let is_pressed = buttons & mask != 0;

            if was_pressed != is_pressed {
                self.event_queue.push(MouseEvent {
                    dx: 0,
                    dy: 0,
                    dz: 0,
                    buttons: if is_pressed { mask } else { 0 },
                });
            }
        }

        // Add movement event if there was movement
        if dx != 0 || dy != 0 || dz != 0 {
            self.event_queue.push(MouseEvent {
                dx,
                dy,
                dz,
                buttons,
            });
        }

        self.last_buttons = buttons;
    }

    /// Returns whether button pressed.
    pub fn is_button_pressed(&self, button: u8) -> bool {
        self.last_buttons & (1 << button) != 0
    }

    /// Drain event queue and inject into the unified mouse buffer.
    pub fn drain_into_unified(&mut self) {
        while let Some(ev) = self.event_queue.pop() {
            let left = ev.buttons & 0x01 != 0;
            let right = ev.buttons & 0x02 != 0;
            let middle = ev.buttons & 0x04 != 0;
            mouse::push_event_from_hid(ev.dx as i16, ev.dy as i16, ev.dz, left, right, middle);
        }
    }
}

static KEYBOARDS: Mutex<Vec<Arc<Mutex<HidKeyboard>>>> = Mutex::new(Vec::new());
static MICE: Mutex<Vec<Arc<Mutex<HidMouse>>>> = Mutex::new(Vec::new());
static HID_INITIALIZED: AtomicBool = AtomicBool::new(false);

/// Performs the init operation.
pub fn init() {
    log::info!("[USB-HID] Initializing HID drivers...");

    if !crate::hardware::usb::xhci::is_available() {
        log::warn!("[USB-HID] xHCI not available, skipping HID init");
        return;
    }

    // xHCI host bring-up is present, but slot/endpoint enumeration is not yet
    // robust enough to run during kernel boot. Keep HID disabled until the
    // command path is completed.
    log::warn!("[USB-HID] xHCI enumeration not enabled yet, skipping HID probe");

    HID_INITIALIZED.store(true, Ordering::SeqCst);
    log::info!(
        "[USB-HID] Initialized: {} keyboard(s), {} mouse/mice",
        KEYBOARDS.lock().len(),
        MICE.lock().len()
    );
}

/// Performs the probe hid device operation.
fn probe_hid_device(port: usize) {
    if port == 0 {
        let keyboard = HidKeyboard::new(port, 0, 0x81, 8, 10);
        KEYBOARDS.lock().push(Arc::new(Mutex::new(keyboard)));
        log::info!("[USB-HID] Found keyboard on port {}", port);
    } else if port == 1 {
        let mouse_dev = HidMouse::new(port, 0, 0x81, 4, 10);
        MICE.lock().push(Arc::new(Mutex::new(mouse_dev)));
        log::info!("[USB-HID] Found mouse on port {}", port);
    }
}

pub fn enumerate_device(port: usize) {
    if let Some(controller_arc) = crate::hardware::usb::xhci::get_controller(0) {
        let mut controller = controller_arc.lock();

        let mut dev_desc = [0u8; 18];
        if controller.get_device_descriptor(1, &mut dev_desc).is_ok() {
            log::info!(
                "[USB-HID] Device: VID={:04x} PID={:04x}",
                u16::from_le_bytes([dev_desc[2], dev_desc[3]]),
                u16::from_le_bytes([dev_desc[4], dev_desc[5]])
            );
        }

        let mut config_desc = [0u8; 256];
        if controller
            .get_configuration_descriptor(1, 0, &mut config_desc, 9)
            .is_ok()
        {
            log::info!(
                "[USB-HID] Config: total_len={}",
                u16::from_le_bytes([config_desc[2], config_desc[3]])
            );
        }

        controller.set_configuration(1, 1).ok();
    }

    probe_hid_device(port);
}

/// Returns keyboard.
pub fn get_keyboard(index: usize) -> Option<Arc<Mutex<HidKeyboard>>> {
    KEYBOARDS.lock().get(index).cloned()
}

/// Returns mouse.
pub fn get_mouse(index: usize) -> Option<Arc<Mutex<HidMouse>>> {
    MICE.lock().get(index).cloned()
}

/// Performs the keyboard count operation.
pub fn keyboard_count() -> usize {
    KEYBOARDS.lock().len()
}

/// Performs the mouse count operation.
pub fn mouse_count() -> usize {
    MICE.lock().len()
}

/// Returns whether available.
pub fn is_available() -> bool {
    HID_INITIALIZED.load(Ordering::Relaxed)
}

/// Poll all HID devices and inject events into the unified keyboard/mouse buffers.
///
/// Call from the shell loop (task context) to drain USB HID event queues and
/// feed them into the same buffers used by PS/2. This enables USB keyboards
/// and mice to work alongside or instead of PS/2.
pub fn poll_all() {
    for kbd in KEYBOARDS.lock().iter() {
        let mut k = kbd.lock();
        k.drain_into_unified();
    }
    for m in MICE.lock().iter() {
        let mut dev = m.lock();
        dev.drain_into_unified();
    }
}

/// Called by xHCI IRQ handler when a transfer completes.
///
/// Processes the HID report and queues events.
pub fn notify_transfer_complete(_slot_id: u8, _ep_id: u8) {
    poll_all();
}