Even more I/O - started new PS/2 driver

4 files changed, 274 insertions, 57 deletions

diff --git a/kernel/drivers/fb.c b/kernel/drivers/fb.c
index 7f05014..1d266f7 100644
--- a/kernel/drivers/fb.c
+++ b/kernel/drivers/fb.c
@@ -6,7 +6,6 @@
 #include <errno.h>
 #include <fb.h>
 #include <fs.h>
-#include <ioctl.h>
 #include <mem.h>
 #include <mm.h>
 #include <str.h>
@@ -33,7 +32,7 @@ static res fb_ioctl(u32 request, void *arg1, void *arg2, void *arg3, struct vfs_
 	UNUSED(dev);
 
 	switch (request) {
-	case IO_FB_GET: {
+	case 0: {
 		if (!info)
 			return -ENOENT;
 
diff --git a/kernel/drivers/keyboard.c b/kernel/drivers/ps2/keyboard.c
index 6b4b0fa..9a19b5c 100644
--- a/kernel/drivers/keyboard.c
+++ b/kernel/drivers/ps2/keyboard.c
@@ -5,10 +5,10 @@
 #include <errno.h>
 #include <fs.h>
 #include <interrupts.h>
-#include <keyboard.h>
 #include <mem.h>
 #include <print.h>
 #include <proc.h>
+#include <ps2.h>
 #include <stack.h>
 #include <str.h>
 #include <sys.h>
@@ -22,7 +22,7 @@ static int merged = 0;
 static void keyboard_handler(struct regs *r)
 {
 	UNUSED(r);
-	int scancode = inb(0x60);
+	u8 scancode = ps2_read_data();
 
 	// TODO: Support more than two-byte scancodes
 	if (scancode == 0xe0) {
@@ -46,19 +46,6 @@ static void keyboard_handler(struct regs *r)
 	merged = 0;
 }
 
-/*static void keyboard_acknowledge(void)
-{
-	while (inb(0x60) != 0xfa)
-		;
-}
-
-static void keyboard_rate(void)
-{
-	outb(0x60, 0xF3);
-	keyboard_acknowledge();
-	outb(0x60, 0x0); // Rate{00000} Delay{00} 0
-}*/
-
 static res keyboard_read(void *buf, u32 offset, u32 count, struct vfs_dev *dev)
 {
 	UNUSED(dev);
@@ -76,12 +63,12 @@ static res keyboard_ready(void)
 	return !stack_empty(queue);
 }
 
-CLEAR void keyboard_reset(void)
+CLEAR void ps2_keyboard_reset(void)
 {
 	stack_clear(queue);
 }
 
-CLEAR void keyboard_install(void)
+CLEAR void ps2_keyboard_install(void)
 {
 	//keyboard_rate(); TODO: Fix keyboard rate?
 	irq_install_handler(1, keyboard_handler);
diff --git a/kernel/drivers/mouse.c b/kernel/drivers/ps2/mouse.c
index 3a78bc8..9b3fa2e 100644
--- a/kernel/drivers/mouse.c
+++ b/kernel/drivers/ps2/mouse.c
@@ -6,9 +6,9 @@
 #include <fs.h>
 #include <interrupts.h>
 #include <mem.h>
-#include <mouse.h>
 #include <print.h>
 #include <proc.h>
+#include <ps2.h>
 #include <stack.h>
 #include <str.h>
 #include <sys.h>
@@ -24,18 +24,18 @@ static void mouse_handler(struct regs *r)
 	UNUSED(r);
 	switch (mouse_cycle) {
 	case 0:
-		mouse_byte[0] = (char)inb(0x60);
+		mouse_byte[0] = ps2_read_data();
 		if (((mouse_byte[0] >> 3) & 1) == 1)
 			mouse_cycle++;
 		else
 			mouse_cycle = 0;
 		break;
 	case 1:
-		mouse_byte[1] = (char)inb(0x60);
+		mouse_byte[1] = ps2_read_data();
 		mouse_cycle++;
 		break;
 	case 2:
-		mouse_byte[2] = (char)inb(0x60);
+		mouse_byte[2] = ps2_read_data();
 
 		event = malloc(sizeof(*event));
 		event->magic = MOUSE_MAGIC;
@@ -52,34 +52,36 @@ static void mouse_handler(struct regs *r)
 	}
 }
 
-CLEAR static void mouse_serial_wait(u8 a_type)
+#define MOUSE_WAIT_OUT 0
+#define MOUSE_WAIT_IN 1
+CLEAR static void mouse_serial_wait(u8 in)
 {
 	u32 time_out = 100000;
-	if (a_type == 0) {
+	if (in) {
 		while (time_out--)
-			if ((inb(0x64) & 1) == 1)
+			if (ps2_read_status().in_full)
 				return;
 		return;
 	} else {
 		while (time_out--)
-			if ((inb(0x64) & 2) == 0)
+			if (ps2_read_status().out_full)
 				return;
 		return;
 	}
 }
 
-CLEAR static void mouse_serial_write(u8 a_write)
+CLEAR static void mouse_serial_write(u8 data)
 {
-	mouse_serial_wait(1);
-	outb(0x64, 0xD4);
-	mouse_serial_wait(1);
-	outb(0x60, a_write);
+	mouse_serial_wait(MOUSE_WAIT_IN);
+	ps2_write_command(0xd4);
+	mouse_serial_wait(MOUSE_WAIT_IN);
+	ps2_write_data(data);
 }
 
 CLEAR static u8 mouse_serial_read(void)
 {
-	mouse_serial_wait(0);
-	return inb(0x60);
+	mouse_serial_wait(MOUSE_WAIT_OUT);
+	return ps2_read_data();
 }
 
 static res mouse_ready(void)
@@ -99,45 +101,45 @@ static res mouse_read(void *buf, u32 offset, u32 count, struct vfs_dev *dev)
 	return MIN(count, sizeof(*e));
 }
 
-CLEAR void mouse_install(void)
+CLEAR void ps2_mouse_install(void)
 {
 	u8 status;
 
 	// Enable auxiliary mouse device
-	mouse_serial_wait(1);
-	outb(0x64, 0xA8);
+	mouse_serial_wait(MOUSE_WAIT_IN);
+	ps2_write_command(0xa8);
 
 	// Enable interrupts
-	mouse_serial_wait(1);
-	outb(0x64, 0x20);
-	mouse_serial_wait(0);
-	status = (u8)(inb(0x60) | 3);
-	mouse_serial_wait(1);
-	outb(0x64, 0x60);
-	mouse_serial_wait(1);
-	outb(0x60, status);
+	mouse_serial_wait(MOUSE_WAIT_IN);
+	ps2_write_command(0x20);
+	mouse_serial_wait(MOUSE_WAIT_OUT);
+	status = ps2_read_data() | 3;
+	mouse_serial_wait(MOUSE_WAIT_IN);
+	ps2_write_command(0x60);
+	mouse_serial_wait(MOUSE_WAIT_IN);
+	ps2_write_data(status);
 
 	// Use default settings
-	mouse_serial_write(0xF6);
+	mouse_serial_write(0xf6);
 	mouse_serial_read();
 
 	// Enable mousewheel
-	mouse_serial_write(0xF2);
+	mouse_serial_write(0xf2);
 	mouse_serial_read();
 	mouse_serial_read();
-	mouse_serial_write(0xF3);
+	mouse_serial_write(0xf3);
 	mouse_serial_read();
 	mouse_serial_write(200);
 	mouse_serial_read();
-	mouse_serial_write(0xF3);
+	mouse_serial_write(0xf3);
 	mouse_serial_read();
 	mouse_serial_write(100);
 	mouse_serial_read();
-	mouse_serial_write(0xF3);
+	mouse_serial_write(0xf3);
 	mouse_serial_read();
 	mouse_serial_write(80);
 	mouse_serial_read();
-	mouse_serial_write(0xF2);
+	mouse_serial_write(0xf2);
 	mouse_serial_read();
 	status = (u8)mouse_serial_read();
 	if (status == 3) {
@@ -145,22 +147,22 @@ CLEAR void mouse_install(void)
 	/* printf("Scrollwheel support!\n"); */
 
 	// Activate 4th and 5th mouse buttons
-	mouse_serial_write(0xF2);
+	mouse_serial_write(0xf2);
 	mouse_serial_read();
 	mouse_serial_read();
-	mouse_serial_write(0xF3);
+	mouse_serial_write(0xf3);
 	mouse_serial_read();
 	mouse_serial_write(200);
 	mouse_serial_read();
-	mouse_serial_write(0xF3);
+	mouse_serial_write(0xf3);
 	mouse_serial_read();
 	mouse_serial_write(200);
 	mouse_serial_read();
-	mouse_serial_write(0xF3);
+	mouse_serial_write(0xf3);
 	mouse_serial_read();
 	mouse_serial_write(80);
 	mouse_serial_read();
-	mouse_serial_write(0xF2);
+	mouse_serial_write(0xf2);
 	mouse_serial_read();
 	status = (u8)mouse_serial_read();
 	if (status == 4) {
@@ -178,7 +180,7 @@ CLEAR void mouse_install(void)
 	mouse_serial_read(); */
 
 	// Enable mouse
-	mouse_serial_write(0xF4);
+	mouse_serial_write(0xf4);
 	mouse_serial_read();
 
 	// Setup the mouse handler
diff --git a/kernel/drivers/ps2/ps2.c b/kernel/drivers/ps2/ps2.c
new file mode 100644
index 0000000..1c73855
--- /dev/null
+++ b/kernel/drivers/ps2/ps2.c
@@ -0,0 +1,229 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+#include <assert.h>
+#include <cpu.h>
+#include <def.h>
+#include <print.h>
+#include <ps2.h>
+
+#define PS2_TIMEOUT 100000
+
+struct ps2_status ps2_read_status(void)
+{
+	u8 byte = inb(0x64);
+	return *(struct ps2_status *)&byte;
+}
+
+static u8 ps2_wait_readable(void)
+{
+	u32 time_out = PS2_TIMEOUT;
+	while (time_out--)
+		if (ps2_read_status().in_full)
+			return 1;
+	/* print("PS/2 readable timeout\n"); */
+	return 0;
+}
+
+static u8 ps2_wait_writable(void)
+{
+	u32 time_out = PS2_TIMEOUT;
+	while (time_out--)
+		if (!ps2_read_status().out_full)
+			return 1;
+	/* print("PS/2 writable timeout\n"); */
+	return 0;
+}
+
+u8 ps2_read_data(void)
+{
+	if (ps2_wait_readable()) {
+		return inb(0x60);
+	} else {
+		return 0;
+	}
+}
+
+u8 ps2_write_data(u8 byte)
+{
+	if (ps2_wait_writable()) {
+		outb(0x60, byte);
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+u8 ps2_write_command(u8 byte)
+{
+	if (ps2_wait_writable()) {
+		outb(0x64, byte);
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+CLEAR static struct ps2_config ps2_read_config(void)
+{
+	assert(ps2_write_command(0x20));
+	u8 config = ps2_read_data();
+	return *(struct ps2_config *)&config;
+}
+
+CLEAR static u8 ps2_write_config(struct ps2_config config)
+{
+	// Select first byte
+	if (!ps2_write_command(0x60))
+		return 0;
+
+	return ps2_write_data(*(u8 *)&config);
+}
+
+#define PS2_TYPE_STANDARD_MOUSE 0x0000
+#define PS2_TYPE_WHEEL_MOUSE 0x0003
+#define PS2_TYPE_BUTTON_MOUSE 0x0004
+#define PS2_TYPE_TRANSLATION_KEYBOARD1 0xab41
+#define PS2_TYPE_TRANSLATION_KEYBOARD2 0xabc1
+#define PS2_TYPE_STANDARD_KEYBOARD 0xab83
+
+PROTECTED static struct {
+	u8 detected : 1;
+	struct {
+		u8 exists : 1;
+		u16 type;
+	} first;
+	struct {
+		u8 exists : 1;
+		u16 type;
+	} second;
+} info = { 0 };
+
+CLEAR static u8 ps2_write_device(u8 device, u8 data)
+{
+	u8 resp = PS2_RESEND;
+	for (u8 i = 0; resp == PS2_RESEND && i < 3; i++) {
+		if (device == 1)
+			ps2_write_command(0xd4);
+		ps2_write_data(data);
+		resp = ps2_read_data();
+	}
+
+	if (resp != PS2_ACK)
+		return 0;
+
+	return 1;
+}
+
+CLEAR static u8 ps2_device_keyboard(u16 type)
+{
+	return type == PS2_TYPE_TRANSLATION_KEYBOARD1 || type == PS2_TYPE_TRANSLATION_KEYBOARD2 ||
+	       type == PS2_TYPE_STANDARD_KEYBOARD;
+}
+
+CLEAR static u8 ps2_device_mouse(u16 type)
+{
+	return type == PS2_TYPE_STANDARD_MOUSE || type == PS2_TYPE_WHEEL_MOUSE ||
+	       type == PS2_TYPE_BUTTON_MOUSE;
+}
+
+CLEAR u8 ps2_keyboard_support(void)
+{
+	if (!info.detected)
+		return 0;
+
+	// Find, reset and self-test
+	if ((info.first.exists && ps2_device_keyboard(info.first.type) &&
+	     ps2_write_device(0, 0xff)) ||
+	    (info.second.exists && ps2_device_keyboard(info.second.type) &&
+	     ps2_write_device(1, 0xff)))
+		return ps2_read_data() == 0xaa;
+
+	return 0;
+}
+
+CLEAR u8 ps2_mouse_support(void)
+{
+	if (!info.detected)
+		return 0;
+
+	// Find, reset and self-test
+	if ((info.first.exists && ps2_device_mouse(info.first.type) && ps2_write_device(0, 0xff)) ||
+	    (info.second.exists && ps2_device_mouse(info.second.type) && ps2_write_device(1, 0xff)))
+		return ps2_read_data() == 0xaa;
+
+	return 0;
+}
+
+CLEAR void ps2_detect(void)
+{
+	// TODO: Read ACPI 8042 flag in FADT to verify PS/2 support
+
+	// Disable PS/2 ports
+	ps2_write_command(0xad);
+	ps2_write_command(0xa7);
+
+	// Get config and disable IRQs
+	struct ps2_config config = ps2_read_config();
+	assert(!config.zero1 && !config.zero2);
+	config.first_int = 0;
+	config.second_int = 0;
+	ps2_write_config(config);
+
+	// Test PS/2 controller
+	ps2_write_command(0xaa);
+	if (ps2_read_data() != 0x55)
+		return;
+	ps2_write_config(config);
+
+	// Test first PS/2 port
+	ps2_write_command(0xab);
+	if (ps2_read_data() == 0x0) {
+		// Enable first port
+		ps2_write_command(0xae);
+		config.first_int = 1;
+		config.first_clock_disabled = 0;
+		info.first.exists = 1;
+	}
+
+	// Test and enable second PS/2 port if available
+	if (config.second_clock_disabled) {
+		ps2_write_command(0xa9);
+		if (ps2_read_data() == 0x0) {
+			// Enable second port
+			ps2_write_command(0xa8);
+			config.second_int = 1;
+			config.second_clock_disabled = 0;
+			info.second.exists = 1;
+		}
+	}
+
+	ps2_write_config(config);
+
+	// Detect device type of first port
+	if (info.first.exists) {
+		if (!ps2_write_device(0, 0xf5))
+			return;
+
+		if (!ps2_write_device(0, 0xf2))
+			return;
+
+		u8 first = ps2_read_data();
+		u8 second = ps2_read_data();
+		info.first.type = (first << 8) | second;
+	}
+
+	// Detect device type of second port
+	if (info.second.exists) {
+		if (!ps2_write_device(1, 0xf5))
+			return;
+
+		if (!ps2_write_device(1, 0xf2))
+			return;
+
+		u8 first = ps2_read_data();
+		u8 second = ps2_read_data(); // This shall timeout if it's a mouse
+		info.second.type = (first << 8) | second;
+	}
+
+	info.detected = 1;
+}