Use a single thread for ps/2 driver

crates/event/src/lib.rs

@@ -1,5 +1,3 @@
-#![feature(question_mark)]
-
 extern crate syscall;
 
 use std::collections::BTreeMap;

drivers/ps2d/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 
 [dependencies]
 bitflags = "*"
+event = { path = "../../crates/event/" }
 io = { path = "../../crates/io/" }
 orbclient = "0.1"
 syscall = { path = "../../syscall/" }

drivers/ps2d/src/keyboard.rs

@@ -1,44 +0,0 @@
-use std::fs::File;
-use std::io::{Read, Write};
-use std::mem;
-
-use orbclient::KeyEvent;
-
-use keymap;
-
-pub fn keyboard() {
-    let mut file = File::open("irq:1").expect("ps2d: failed to open irq:1");
-    let mut input = File::open("display:input").expect("ps2d: failed to open display:input");
-
-    let mut lshift = false;
-    let mut rshift = false;
-    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");
-            }
-
-            file.write(&irqs).expect("ps2d: failed to write irq:1");
-
-            let (scancode, pressed) = if data >= 0x80 {
-                (data - 0x80, false)
-            } else {
-                (data, true)
-            };
-
-            if scancode == 0x2A {
-                lshift = pressed;
-            } else if scancode == 0x36 {
-                rshift = pressed;
-            }
-
-            input.write(&KeyEvent {
-                character: keymap::get_char(scancode, lshift || rshift),
-                scancode: scancode,
-                pressed: pressed
-            }.to_event()).expect("ps2d: failed to write key event");
-        }
-    }
-}

drivers/ps2d/src/main.rs

@@ -2,42 +2,154 @@
 
 #[macro_use]
 extern crate bitflags;
+extern crate event;
 extern crate io;
 extern crate orbclient;
 extern crate syscall;
 
-use std::thread;
+use std::fs::File;
+use std::io::{Read, Write, Result};
+use std::os::unix::io::AsRawFd;
+use std::{mem, thread};
 
+use event::EventQueue;
+use orbclient::{KeyEvent, MouseEvent};
 use syscall::iopl;
 
 mod controller;
-mod keyboard;
 mod keymap;
-mod mouse;
+
+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
+    }
+}
 
 fn main() {
-    unsafe {
-        iopl(3).expect("ps2d: failed to get I/O permission");
-        asm!("cli" :::: "intel", "volatile");
-    }
-
-    let extra_packet = controller::Ps2::new().init();
-
     thread::spawn(|| {
         unsafe {
             iopl(3).expect("ps2d: failed to get I/O permission");
             asm!("cli" :::: "intel", "volatile");
         }
 
-        keyboard::keyboard();
+        let extra_packet = controller::Ps2::new().init();
-    });
 
-    thread::spawn(move || {
+        let mut input = File::open("display:input").expect("ps2d: failed to open display:input");
-        unsafe {
+
-            iopl(3).expect("ps2d: failed to get I/O permission");
+        let mut event_queue = EventQueue::<(bool, u8)>::new().expect("ps2d: failed to create event queue");
-            asm!("cli" :::: "intel", "volatile");
+
+        let mut key_irq = File::open("irq:1").expect("ps2d: failed to open irq:1");
+
+        event_queue.add(key_irq.as_raw_fd(), move |_count: usize| -> Result<Option<(bool, u8)>> {
+            let mut irq = [0; 8];
+            if key_irq.read(&mut irq)? >= mem::size_of::<usize>() {
+                let data: u8;
+                unsafe {
+                    asm!("in al, dx" : "={al}"(data) : "{dx}"(0x60) : : "intel", "volatile");
+                }
+
+                key_irq.write(&irq)?;
+
+                Ok(Some((true, data)))
+            } else {
+                Ok(None)
+            }
+        }).expect("ps2d: failed to poll irq:1");
+
+        let mut mouse_irq = File::open("irq:12").expect("ps2d: failed to open irq:12");
+
+        event_queue.add(mouse_irq.as_raw_fd(), move |_count: usize| -> Result<Option<(bool, u8)>> {
+            let mut irq = [0; 8];
+            if mouse_irq.read(&mut irq)? >= mem::size_of::<usize>() {
+                let data: u8;
+                unsafe {
+                    asm!("in al, dx" : "={al}"(data) : "{dx}"(0x60) : : "intel", "volatile");
+                }
+
+                mouse_irq.write(&irq)?;
+
+                Ok(Some((false, data)))
+            } else {
+                Ok(None)
+            }
+        }).expect("ps2d: failed to poll irq:12");
+
+        let mut lshift = false;
+        let mut rshift = false;
+        let mut packets = [0; 4];
+        let mut packet_i = 0;
+
+        loop {
+            let (keyboard, data) = event_queue.run().expect("ps2d: failed to handle events");
+
+            if keyboard {
+                let (scancode, pressed) = if data >= 0x80 {
+                    (data - 0x80, false)
+                } else {
+                    (data, true)
+                };
+
+                if scancode == 0x2A {
+                    lshift = pressed;
+                } else if scancode == 0x36 {
+                    rshift = pressed;
+                }
+
+                input.write(&KeyEvent {
+                    character: keymap::get_char(scancode, lshift || rshift),
+                    scancode: scancode,
+                    pressed: pressed
+                }.to_event()).expect("ps2d: failed to write key event");
+            } else {
+                packets[packet_i] = data;
+                packet_i += 1;
+
+                let flags = MousePacketFlags::from_bits_truncate(packets[0]);
+                if ! flags.contains(ALWAYS_ON) {
+                    println!("MOUSE MISALIGN {:X}", packets[0]);
+
+                    packets = [0; 4];
+                    packet_i = 0;
+                } else if packet_i >= packets.len() || (!extra_packet && packet_i >= 3) {
+                    if ! flags.contains(X_OVERFLOW) && ! flags.contains(Y_OVERFLOW) {
+                        let mut dx = packets[1] as i32;
+                        if flags.contains(X_SIGN) {
+                            dx -= 0x100;
+                        }
+
+                        let mut dy = -(packets[2] as i32);
+                        if flags.contains(Y_SIGN) {
+                            dy += 0x100;
+                        }
+
+                        let _extra = if extra_packet {
+                            packets[3]
+                        } else {
+                            0
+                        };
+
+                        input.write(&MouseEvent {
+                            x: dx,
+                            y: dy,
+                            left_button: flags.contains(LEFT_BUTTON),
+                            middle_button: flags.contains(MIDDLE_BUTTON),
+                            right_button: flags.contains(RIGHT_BUTTON)
+                        }.to_event()).expect("ps2d: failed to write mouse event");
+                    } else {
+                        println!("ps2d: overflow {:X} {:X} {:X} {:X}", packets[0], packets[1], packets[2], packets[3]);
+                    }
+
+                    packets = [0; 4];
+                    packet_i = 0;
+                }
+            }
         }
-
-        mouse::mouse(extra_packet);
     });
 }

drivers/ps2d/src/mouse.rs

@@ -1,79 +0,0 @@
-use std::fs::File;
-use std::io::{Read, Write};
-use std::mem;
-
-use orbclient::MouseEvent;
-
-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 input = File::open("display:input").expect("ps2d: failed to open display:input");
-
-    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");
-            }
-
-            file.write(&irqs).expect("ps2d: failed to write irq:12");
-
-            packets[packet_i] = data;
-            packet_i += 1;
-
-            let flags = MousePacketFlags::from_bits_truncate(packets[0]);
-            if ! flags.contains(ALWAYS_ON) {
-                println!("MOUSE MISALIGN {:X}", packets[0]);
-
-                packets = [0; 4];
-                packet_i = 0;
-            } else if packet_i >= packets.len() || (!extra_packet && packet_i >= 3) {
-                if ! flags.contains(X_OVERFLOW) && ! flags.contains(Y_OVERFLOW) {
-                    let mut dx = packets[1] as i32;
-                    if flags.contains(X_SIGN) {
-                        dx -= 0x100;
-                    }
-
-                    let mut dy = -(packets[2] as i32);
-                    if flags.contains(Y_SIGN) {
-                        dy += 0x100;
-                    }
-
-                    let _extra = if extra_packet {
-                        packets[3]
-                    } else {
-                        0
-                    };
-
-                    input.write(&MouseEvent {
-                        x: dx,
-                        y: dy,
-                        left_button: flags.contains(LEFT_BUTTON),
-                        middle_button: flags.contains(MIDDLE_BUTTON),
-                        right_button: flags.contains(RIGHT_BUTTON)
-                    }.to_event()).expect("ps2d: failed to write mouse event");
-                } else {
-                    println!("ps2d: overflow {:X} {:X} {:X} {:X}", packets[0], packets[1], packets[2], packets[3]);
-                }
-
-                packets = [0; 4];
-                packet_i = 0;
-            }
-        }
-    }
-}