Move PS/2 driver to userspace

io/Cargo.toml

+[package]
+name = "io"
+version = "0.1.0"

io/src/io.rs

+use core::cmp::PartialEq;
+use core::ops::{BitAnd, BitOr, Not};
+
+pub trait Io {
+    type Value: Copy + PartialEq + BitAnd<Output = Self::Value> + BitOr<Output = Self::Value> + Not<Output = Self::Value>;
+
+    fn read(&self) -> Self::Value;
+    fn write(&mut self, value: Self::Value);
+
+    #[inline(always)]
+    fn readf(&self, flags: Self::Value) -> bool  {
+        (self.read() & flags) as Self::Value == flags
+    }
+
+    #[inline(always)]
+    fn writef(&mut self, flags: Self::Value, value: bool) {
+        let tmp: Self::Value = match value {
+            true => self.read() | flags,
+            false => self.read() & !flags,
+        };
+        self.write(tmp);
+    }
+}
+
+pub struct ReadOnly<I: Io> {
+    inner: I
+}
+
+impl<I: Io> ReadOnly<I> {
+    pub const fn new(inner: I) -> ReadOnly<I> {
+        ReadOnly {
+            inner: inner
+        }
+    }
+
+    #[inline(always)]
+    pub fn read(&self) -> I::Value {
+        self.inner.read()
+    }
+
+    #[inline(always)]
+    pub fn readf(&self, flags: I::Value) -> bool {
+        self.inner.readf(flags)
+    }
+}
+
+pub struct WriteOnly<I: Io> {
+    inner: I
+}
+
+impl<I: Io> WriteOnly<I> {
+    pub const fn new(inner: I) -> WriteOnly<I> {
+        WriteOnly {
+            inner: inner
+        }
+    }
+
+    #[inline(always)]
+    pub fn write(&mut self, value: I::Value) {
+        self.inner.write(value)
+    }
+
+    #[inline(always)]
+    pub fn writef(&mut self, flags: I::Value, value: bool) {
+        self.inner.writef(flags, value)
+    }
+}

io/src/lib.rs

+//! I/O functions
+
+#![feature(asm)]
+#![feature(const_fn)]
+#![feature(core_intrinsics)]
+#![no_std]
+
+pub use self::io::*;
+pub use self::mmio::*;
+pub use self::pio::*;
+
+mod io;
+mod mmio;
+mod pio;

io/src/mmio.rs

+use core::intrinsics::{volatile_load, volatile_store};
+use core::mem::uninitialized;
+use core::ops::{BitAnd, BitOr, Not};
+
+use super::io::Io;
+
+#[repr(packed)]
+pub struct Mmio<T> {
+    value: T,
+}
+
+impl<T> Mmio<T> {
+    /// Create a new Mmio without initializing
+    pub fn new() -> Self {
+        Mmio {
+            value: unsafe { uninitialized() }
+        }
+    }
+}
+
+impl<T> Io for Mmio<T> where T: Copy + PartialEq + BitAnd<Output = T> + BitOr<Output = T> + Not<Output = T> {
+    type Value = T;
+
+    fn read(&self) -> T {
+        unsafe { volatile_load(&self.value) }
+    }
+
+    fn write(&mut self, value: T) {
+        unsafe { volatile_store(&mut self.value, value) };
+    }
+}

io/src/pio.rs

+use core::marker::PhantomData;
+
+use super::io::Io;
+
+/// Generic PIO
+#[derive(Copy, Clone)]
+pub struct Pio<T> {
+    port: u16,
+    value: PhantomData<T>,
+}
+
+impl<T> Pio<T> {
+    /// Create a PIO from a given port
+    pub const fn new(port: u16) -> Self {
+        Pio::<T> {
+            port: port,
+            value: PhantomData,
+        }
+    }
+}
+
+/// Read/Write for byte PIO
+impl Io for Pio<u8> {
+    type Value = u8;
+
+    /// Read
+    #[inline(always)]
+    fn read(&self) -> u8 {
+        let value: u8;
+        unsafe {
+            asm!("in $0, $1" : "={al}"(value) : "{dx}"(self.port) : "memory" : "intel", "volatile");
+        }
+        value
+    }
+
+    /// Write
+    #[inline(always)]
+    fn write(&mut self, value: u8) {
+        unsafe {
+            asm!("out $1, $0" : : "{al}"(value), "{dx}"(self.port) : "memory" : "intel", "volatile");
+        }
+    }
+}
+
+/// Read/Write for word PIO
+impl Io for Pio<u16> {
+    type Value = u16;
+
+    /// Read
+    #[inline(always)]
+    fn read(&self) -> u16 {
+        let value: u16;
+        unsafe {
+            asm!("in $0, $1" : "={ax}"(value) : "{dx}"(self.port) : "memory" : "intel", "volatile");
+        }
+        value
+    }
+
+    /// Write
+    #[inline(always)]
+    fn write(&mut self, value: u16) {
+        unsafe {
+            asm!("out $1, $0" : : "{ax}"(value), "{dx}"(self.port) : "memory" : "intel", "volatile");
+        }
+    }
+}
+
+/// Read/Write for doubleword PIO
+impl Io for Pio<u32> {
+    type Value = u32;
+
+    /// Read
+    #[inline(always)]
+    fn read(&self) -> u32 {
+        let value: u32;
+        unsafe {
+            asm!("in $0, $1" : "={eax}"(value) : "{dx}"(self.port) : "memory" : "intel", "volatile");
+        }
+        value
+    }
+
+    /// Write
+    #[inline(always)]
+    fn write(&mut self, value: u32) {
+        unsafe {
+            asm!("out $1, $0" : : "{eax}"(value), "{dx}"(self.port) : "memory" : "intel", "volatile");
+        }
+    }
+}

ps2d/Cargo.toml

@@ -2,5 +2,8 @@
 name = "ps2d"
 version = "0.1.0"
 
-[dependencies.syscall]
-path = "../../syscall/"
+[dependencies]
+bitflags = "*"
+io = { path = "../io/" }
+spin = "*"
+syscall = { path = "../../syscall/" }

ps2d/src/controller.rs

+use io::{Io, Pio, ReadOnly, WriteOnly};
+
+pub unsafe fn init() {
+    Ps2::new().init();
+}
+
+bitflags! {
+    flags StatusFlags: u8 {
+        const OUTPUT_FULL = 1,
+        const INPUT_FULL = 1 << 1,
+        const SYSTEM = 1 << 2,
+        const COMMAND = 1 << 3,
+        // Chipset specific
+        const KEYBOARD_LOCK = 1 << 4,
+        // Chipset specific
+        const SECOND_OUTPUT_FULL = 1 << 5,
+        const TIME_OUT = 1 << 6,
+        const PARITY = 1 << 7
+    }
+}
+
+bitflags! {
+    flags ConfigFlags: u8 {
+        const FIRST_INTERRUPT = 1,
+        const SECOND_INTERRUPT = 1 << 1,
+        const POST_PASSED = 1 << 2,
+        // 1 << 3 should be zero
+        const CONFIG_RESERVED_3 = 1 << 3,
+        const FIRST_DISABLED = 1 << 4,
+        const SECOND_DISABLED = 1 << 5,
+        const FIRST_TRANSLATE = 1 << 6,
+        // 1 << 7 should be zero
+        const CONFIG_RESERVED_7 = 1 << 7,
+    }
+}
+
+#[repr(u8)]
+#[allow(dead_code)]
+enum Command {
+    ReadConfig = 0x20,
+    WriteConfig = 0x60,
+    DisableSecond = 0xA7,
+    EnableSecond = 0xA8,
+    TestSecond = 0xA9,
+    TestController = 0xAA,
+    TestFirst = 0xAB,
+    Diagnostic = 0xAC,
+    DisableFirst = 0xAD,
+    EnableFirst = 0xAE,
+    WriteSecond = 0xD4
+}
+
+#[repr(u8)]
+#[allow(dead_code)]
+enum KeyboardCommand {
+    EnableReporting = 0xF4,
+    SetDefaults = 0xF6,
+    Reset = 0xFF
+}
+
+#[repr(u8)]
+enum KeyboardCommandData {
+    ScancodeSet = 0xF0
+}
+
+#[repr(u8)]
+#[allow(dead_code)]
+enum MouseCommand {
+    GetDeviceId = 0xF2,
+    EnableReporting = 0xF4,
+    SetDefaults = 0xF6,
+    Reset = 0xFF
+}
+
+#[repr(u8)]
+enum MouseCommandData {
+    SetSampleRate = 0xF3,
+}
+
+pub struct Ps2 {
+    data: Pio<u8>,
+    status: ReadOnly<Pio<u8>>,
+    command: WriteOnly<Pio<u8>>
+}
+
+impl Ps2 {
+    pub fn new() -> Self {
+        Ps2 {
+            data: Pio::new(0x60),
+            status: ReadOnly::new(Pio::new(0x64)),
+            command: WriteOnly::new(Pio::new(0x64)),
+        }
+    }
+
+    fn status(&mut self) -> StatusFlags {
+        StatusFlags::from_bits_truncate(self.status.read())
+    }
+
+    fn wait_write(&mut self) {
+        while self.status().contains(INPUT_FULL) {}
+    }
+
+    fn wait_read(&mut self) {
+        while ! self.status().contains(OUTPUT_FULL) {}
+    }
+
+    fn flush_read(&mut self) {
+        while self.status().contains(OUTPUT_FULL) {
+            print!("FLUSH: {:X}\n", self.data.read());
+        }
+    }
+
+    fn command(&mut self, command: Command) {
+        self.wait_write();
+        self.command.write(command as u8);
+    }
+
+    fn read(&mut self) -> u8 {
+        self.wait_read();
+        self.data.read()
+    }
+
+    fn write(&mut self, data: u8) {
+        self.wait_write();
+        self.data.write(data);
+    }
+
+    fn config(&mut self) -> ConfigFlags {
+        self.command(Command::ReadConfig);
+        ConfigFlags::from_bits_truncate(self.read())
+    }
+
+    fn set_config(&mut self, config: ConfigFlags) {
+        self.command(Command::WriteConfig);
+        self.write(config.bits());
+    }
+
+    fn keyboard_command(&mut self, command: KeyboardCommand) -> u8 {
+        self.write(command as u8);
+        self.read()
+    }
+
+    fn keyboard_command_data(&mut self, command: KeyboardCommandData, data: u8) -> u8 {
+        self.write(command as u8);
+        assert_eq!(self.read(), 0xFA);
+        self.write(data as u8);
+        self.read()
+    }
+
+    fn mouse_command(&mut self, command: MouseCommand) -> u8 {
+        self.command(Command::WriteSecond);
+        self.write(command as u8);
+        self.read()
+    }
+
+    fn mouse_command_data(&mut self, command: MouseCommandData, data: u8) -> u8 {
+        self.command(Command::WriteSecond);
+        self.write(command as u8);
+        assert_eq!(self.read(), 0xFA);
+        self.command(Command::WriteSecond);
+        self.write(data as u8);
+        self.read()
+    }
+
+    pub fn init(&mut self) -> bool {
+        // Disable devices
+        self.command(Command::DisableFirst);
+        self.command(Command::DisableSecond);
+
+        // Clear remaining data
+        self.flush_read();
+
+        // Disable clocks, disable interrupts, and disable translate
+        {
+            let mut config = self.config();
+            config.insert(FIRST_DISABLED);
+            config.insert(SECOND_DISABLED);
+            config.remove(FIRST_TRANSLATE);
+            config.remove(FIRST_INTERRUPT);
+            config.remove(SECOND_INTERRUPT);
+            self.set_config(config);
+        }
+
+        // Perform the self test
+        self.command(Command::TestController);
+        assert_eq!(self.read(), 0x55);
+
+        // Enable devices
+        self.command(Command::EnableFirst);
+        self.command(Command::EnableSecond);
+
+        // Reset keyboard
+        assert_eq!(self.keyboard_command(KeyboardCommand::Reset), 0xFA);
+        assert_eq!(self.read(), 0xAA);
+        self.flush_read();
+
+        // Set scancode set to 2
+        assert_eq!(self.keyboard_command_data(KeyboardCommandData::ScancodeSet, 2), 0xFA);
+
+        // Reset mouse and set up scroll
+        // TODO: Check for ack
+        assert_eq!(self.mouse_command(MouseCommand::Reset), 0xFA);
+        assert_eq!(self.read(), 0xAA);
+        assert_eq!(self.read(), 0x00);
+        self.flush_read();
+
+        // Enable extra packet on mouse
+        assert_eq!(self.mouse_command_data(MouseCommandData::SetSampleRate, 200), 0xFA);
+        assert_eq!(self.mouse_command_data(MouseCommandData::SetSampleRate, 100), 0xFA);
+        assert_eq!(self.mouse_command_data(MouseCommandData::SetSampleRate, 80), 0xFA);
+        assert_eq!(self.mouse_command(MouseCommand::GetDeviceId), 0xFA);
+        let mouse_id = self.read();
+        let mouse_extra = mouse_id == 3;
+
+        // Set sample rate to maximum
+        assert_eq!(self.mouse_command_data(MouseCommandData::SetSampleRate, 200), 0xFA);
+
+        // Enable data reporting
+        assert_eq!(self.keyboard_command(KeyboardCommand::EnableReporting), 0xFA);
+        assert_eq!(self.mouse_command(MouseCommand::EnableReporting), 0xFA);
+
+        // Enable clocks and interrupts
+        {
+            let mut config = self.config();
+            config.remove(FIRST_DISABLED);
+            config.remove(SECOND_DISABLED);
+            config.insert(FIRST_TRANSLATE);
+            config.insert(FIRST_INTERRUPT);
+            config.insert(SECOND_INTERRUPT);
+            self.set_config(config);
+        }
+
+        self.flush_read();
+
+        mouse_extra
+    }
+}

ps2d/src/keyboard.rs

+use std::fs::File;
+use std::io::{Read, Write};
+use std::mem;
+use std::thread;
+
+use keymap;
+
+pub fn keyboard() {
+    let mut file = File::open("irq:1").expect("ps2d: failed to open irq:1");
+
+    loop {
+        let mut irqs = [0; 8];
+        if file.read(&mut irqs).expect("ps2d: failed to read irq:1") >= mem::size_of::<usize>() {
+            let data: u8;
+            unsafe {
+                asm!("in al, dx" : "={al}"(data) : "{dx}"(0x60) : : "intel", "volatile");
+            }
+
+            let (scancode, pressed) = if data >= 0x80 {
+                (data - 0x80, false)
+            } else {
+                (data, true)
+            };
+
+            if pressed {
+                print!("{}", keymap::get_char(scancode));
+            }
+
+            file.write(&irqs).expect("ps2d: failed to write irq:1");
+        } else {
+            thread::yield_now();
+        }
+    }
+}

ps2d/src/main.rs

 #![feature(asm)]
 
+#[macro_use]
+extern crate bitflags;
+extern crate io;
 extern crate syscall;
 
-use std::fs::File;
-use std::io::{Read, Write};
-use std::mem;
 use std::thread;
 
 use syscall::iopl;
 
+mod controller;
+mod keyboard;
 mod keymap;
+mod mouse;
 
-fn keyboard() {
-    let mut file = File::open("irq:1").expect("pskbd: failed to open irq:1");
-
-    loop {
-        let mut irqs = [0; 8];
-        if file.read(&mut irqs).expect("pskbd: failed to read irq:1") >= mem::size_of::<usize>() {
-            let data: u8;
-            unsafe {
-                asm!("in al, dx" : "={al}"(data) : "{dx}"(0x60) : : "intel", "volatile");
-            }
-
-            let (scancode, pressed) = if data >= 0x80 {
-                (data - 0x80, false)
-            } else {
-                (data, true)
-            };
-            println!("pskbd: IRQ {}: {:X}: {:X}: {}: {}", unsafe { *(irqs.as_ptr() as *const usize) }, data, scancode, keymap::get_char(scancode), pressed);
-
-            file.write(&irqs).expect("pskbd: failed to write irq:1");
-        } else {
-            thread::yield_now();
-        }
+fn main() {
+    unsafe {
+        iopl(3).expect("ps2d: failed to get I/O permission");
+        asm!("cli" :::: "intel", "volatile");
     }
-}
-
-fn mouse() {
-    let mut file = File::open("irq:12").expect("psmsd: failed to open irq:12");
 
-    loop {
-        let mut irqs = [0; 8];
-        if file.read(&mut irqs).expect("psmsd: failed to read irq:12") >= mem::size_of::<usize>() {
-            let data: u8;
-            unsafe {
-                asm!("in al, dx" : "={al}"(data) : "{dx}"(0x60) : : "intel", "volatile");
-            }
+    let extra_packet = controller::Ps2::new().init();
 
-            println!("psmsd: IRQ {}: {:X}", unsafe { *(irqs.as_ptr() as *const usize) }, data);
-
-            file.write(&irqs).expect("psmsd: failed to write irq:12");
-        } else {
-            thread::yield_now();
-        }
-    }
-}
-
-fn main() {
     thread::spawn(|| {
         unsafe {
-            iopl(3).expect("pskbd: failed to get I/O permission");
+            iopl(3).expect("ps2d: failed to get I/O permission");
             asm!("cli" :::: "intel", "volatile");
         }
 
-        keyboard();
+        keyboard::keyboard();
     });
 
-    thread::spawn(|| {
+    thread::spawn(move || {
         unsafe {
-            iopl(3).expect("psmsd: failed to get I/O permission");
+            iopl(3).expect("ps2d: failed to get I/O permission");
             asm!("cli" :::: "intel", "volatile");
         }
 
-        mouse();
+        mouse::mouse(extra_packet);
     });
 }

ps2d/src/mouse.rs

+use std::fs::File;
+use std::io::{Read, Write};
+use std::mem;
+use std::thread;
+
+bitflags! {
+    flags MousePacketFlags: u8 {
+        const LEFT_BUTTON = 1,
+        const RIGHT_BUTTON = 1 << 1,
+        const MIDDLE_BUTTON = 1 << 2,
+        const ALWAYS_ON = 1 << 3,
+        const X_SIGN = 1 << 4,
+        const Y_SIGN = 1 << 5,
+        const X_OVERFLOW = 1 << 6,
+        const Y_OVERFLOW = 1 << 7
+    }
+}
+
+pub fn mouse(extra_packet: bool) {
+    let mut file = File::open("irq:12").expect("ps2d: failed to open irq:12");
+
+    let mut packets = [0; 4];
+    let mut packet_i = 0;
+    loop {
+        let mut irqs = [0; 8];
+        if file.read(&mut irqs).expect("ps2d: failed to read irq:12") >= mem::size_of::<usize>() {
+            let data: u8;
+            unsafe {
+                asm!("in al, dx" : "={al}"(data) : "{dx}"(0x60) : : "intel", "volatile");
+            }
+
+            packets[packet_i] = data;
+            packet_i += 1;