amd64: barely boot into kernel code

6 files changed, 338 insertions, 0 deletions

diff --git a/src/kernel/arch/amd64/driver/fsroot.c b/src/kernel/arch/amd64/driver/fsroot.c
new file mode 100644
index 0000000..02a4a21
--- /dev/null
+++ b/src/kernel/arch/amd64/driver/fsroot.c
@@ -0,0 +1,146 @@
+#include <kernel/arch/amd64/ata.h>
+#include <kernel/mem/virt.h>
+#include <kernel/panic.h>
+#include <kernel/proc.h>
+#include <kernel/util.h>
+#include <kernel/arch/amd64/driver/fsroot.h>
+#include <shared/mem.h>
+#include <stdbool.h>
+
+enum {
+	HANDLE_ROOT,
+	HANDLE_VGA,
+	HANDLE_ATA_ROOT,
+	HANDLE_ATA,
+	_SKIP = HANDLE_ATA + 4,
+};
+
+static bool exacteq(struct vfs_request *req, const char *str) {
+	size_t len = strlen(str);
+	assert(req->input.kern);
+	return req->input.len == len && !memcmp(req->input.buf_kern, str, len);
+}
+
+/* truncates the length */
+static void req_preprocess(struct vfs_request *req, size_t max_len) {
+	if (req->offset < 0) {
+		// TODO negative offsets
+		req->offset = 0;
+	}
+
+	if (req->offset >= capped_cast32(max_len)) {
+		req->input.len = 0;
+		req->output.len = 0;
+		req->offset = max_len;
+		return;
+	}
+
+	req->input.len  = min(req->input.len,  max_len - req->offset);
+	req->output.len = min(req->output.len, max_len - req->offset);
+
+	assert(req->input.len + req->offset <= max_len);
+	assert(req->input.len + req->offset <= max_len);
+}
+
+
+static int handle(struct vfs_request *req) {
+	assert(req->caller);
+	int id = (int)req->id;
+	switch (req->type) {
+		case VFSOP_OPEN:
+			if (exacteq(req, "/"))		return HANDLE_ROOT;
+			if (exacteq(req, "/vga"))	return HANDLE_VGA;
+
+			if (exacteq(req, "/ata/"))	return HANDLE_ATA_ROOT;
+			if (exacteq(req, "/ata/0"))
+				return ata_available(0) ? HANDLE_ATA+0 : -1;
+			if (exacteq(req, "/ata/1"))
+				return ata_available(1) ? HANDLE_ATA+1 : -1;
+			if (exacteq(req, "/ata/2"))
+				return ata_available(2) ? HANDLE_ATA+2 : -1;
+			if (exacteq(req, "/ata/3"))
+				return ata_available(3) ? HANDLE_ATA+3 : -1;
+
+			return -1;
+
+		case VFSOP_READ:
+			switch (id) {
+				case HANDLE_ROOT: {
+					// TODO document directory read format
+					const char src[] =
+						"vga\0"
+						"com1\0"
+						"ps2\0"
+						"ata/";
+					req_preprocess(req, sizeof src);
+					virt_cpy_to(req->caller->pages, req->output.buf,
+							src + req->offset, req->output.len);
+					return req->output.len;
+				}
+				case HANDLE_VGA: {
+					char *vga = (void*)0xB8000;
+					req_preprocess(req, 80*25*2);
+					virt_cpy_to(req->caller->pages, req->output.buf,
+							vga + req->offset, req->output.len);
+					return req->output.len;
+				}
+				case HANDLE_ATA_ROOT: {
+					char list[8] = {};
+					size_t len = 0;
+					for (int i = 0; i < 4; i++) {
+						if (ata_available(i)) {
+							list[len] = '0' + i;
+							len += 2;
+						}
+					}
+					req_preprocess(req, len);
+					virt_cpy_to(req->caller->pages, req->output.buf,
+							list + req->offset, req->output.len);
+					return req->output.len;
+				}
+				case HANDLE_ATA:   case HANDLE_ATA+1:
+				case HANDLE_ATA+2: case HANDLE_ATA+3: {
+					if (req->offset < 0) return 0;
+					char buf[512];
+					uint32_t sector = req->offset / 512;
+					size_t len = min(req->output.len, 512 - ((size_t)req->offset & 511));
+					ata_read(id - HANDLE_ATA, sector, buf);
+					virt_cpy_to(req->caller->pages, req->output.buf, buf, len);
+					return len;
+				}
+				default: panic_invalid_state();
+			}
+
+		case VFSOP_WRITE:
+			switch (id) {
+				case HANDLE_VGA: {
+					void *vga = (void*)0xB8000;
+					req_preprocess(req, 80*25*2);
+					virt_cpy_from(req->caller->pages, vga + req->offset,
+							req->input.buf, req->input.len);
+					return req->input.len;
+				}
+				default: return -1;
+			}
+
+		case VFSOP_CLOSE:
+			return 0;
+
+		default: panic_invalid_state();
+	}
+}
+
+static void accept(struct vfs_request *req) {
+	if (req->caller) {
+		vfsreq_finish_short(req, handle(req));
+	} else {
+		vfsreq_finish_short(req, -1);
+	}
+}
+
+static bool is_ready(struct vfs_backend __attribute__((unused)) *self) {
+	return true;
+}
+
+static struct vfs_backend backend = BACKEND_KERN(is_ready, accept);
+void vfs_root_init(void) { vfs_mount_root_register("", &backend); }
diff --git a/src/kernel/arch/amd64/driver/fsroot.h b/src/kernel/arch/amd64/driver/fsroot.h
new file mode 100644
index 0000000..dd72202
--- /dev/null
+++ b/src/kernel/arch/amd64/driver/fsroot.h
@@ -0,0 +1,2 @@
+#pragma once
+void vfs_root_init(void);
diff --git a/src/kernel/arch/amd64/driver/ps2.c b/src/kernel/arch/amd64/driver/ps2.c
new file mode 100644
index 0000000..8a5a078
--- /dev/null
+++ b/src/kernel/arch/amd64/driver/ps2.c
@@ -0,0 +1,61 @@
+#include <kernel/arch/amd64/driver/ps2.h>
+#include <kernel/arch/amd64/interrupts/irq.h>
+#include <kernel/mem/virt.h>
+#include <kernel/panic.h>
+#include <kernel/vfs/request.h>
+#include <shared/container/ring.h>
+#include <shared/mem.h>
+
+#define BACKLOG_CAPACITY 64
+static volatile uint8_t backlog_buf[BACKLOG_CAPACITY];
+static volatile ring_t backlog = {(void*)backlog_buf, BACKLOG_CAPACITY, 0, 0};
+
+static void accept(struct vfs_request *req);
+static bool is_ready(struct vfs_backend *self);
+
+static struct vfs_request *blocked_on = NULL;
+static struct vfs_backend backend = BACKEND_KERN(is_ready, accept);
+void ps2_init(void) { vfs_mount_root_register("/ps2", &backend); }
+
+
+void ps2_recv(uint8_t s) {
+	ring_put1b((void*)&backlog, s);
+	if (blocked_on) {
+		accept(blocked_on);
+		blocked_on = NULL;
+		vfs_backend_tryaccept(&backend);
+	}
+}
+
+static void accept(struct vfs_request *req) {
+	// when you fix something here go also fix it in the COM1 driver
+	static uint8_t buf[32]; // pretty damn stupid
+	int ret;
+	bool valid;
+	switch (req->type) {
+		case VFSOP_OPEN:
+			valid = req->input.len == 0;
+			vfsreq_finish_short(req, valid ? 0 : -1);
+			break;
+		case VFSOP_READ:
+			if (ring_size((void*)&backlog) == 0) {
+				// nothing to read
+				blocked_on = req;
+			} else if (req->caller) {
+				ret = clamp(0, req->output.len, sizeof buf);
+				ret = ring_get((void*)&backlog, buf, ret);
+				virt_cpy_to(req->caller->pages, req->output.buf, buf, ret);
+				vfsreq_finish_short(req, ret);
+			} else {
+				vfsreq_finish_short(req, -1);
+			}
+			break;
+		default:
+			vfsreq_finish_short(req, -1);
+			break;
+	}
+}
+
+static bool is_ready(struct vfs_backend __attribute__((unused)) *self) {
+	return blocked_on == NULL;
+}
diff --git a/src/kernel/arch/amd64/driver/ps2.h b/src/kernel/arch/amd64/driver/ps2.h
new file mode 100644
index 0000000..54e8fb2
--- /dev/null
+++ b/src/kernel/arch/amd64/driver/ps2.h
@@ -0,0 +1,5 @@
+#pragma once
+#include <stdint.h>
+
+void ps2_recv(uint8_t s);
+void ps2_init(void);
diff --git a/src/kernel/arch/amd64/driver/serial.c b/src/kernel/arch/amd64/driver/serial.c
new file mode 100644
index 0000000..6dda657
--- /dev/null
+++ b/src/kernel/arch/amd64/driver/serial.c
@@ -0,0 +1,114 @@
+#include <kernel/arch/amd64/driver/serial.h>
+#include <kernel/arch/amd64/interrupts/irq.h>
+#include <kernel/arch/amd64/port_io.h>
+#include <kernel/mem/virt.h>
+#include <kernel/panic.h>
+#include <shared/container/ring.h>
+#include <shared/mem.h>
+#include <stdint.h>
+
+#define BACKLOG_CAPACITY 64
+static volatile uint8_t backlog_buf[BACKLOG_CAPACITY];
+static volatile ring_t backlog = {(void*)backlog_buf, BACKLOG_CAPACITY, 0, 0};
+
+static const int COM1 = 0x3f8;
+
+static void accept(struct vfs_request *req);
+static bool is_ready(struct vfs_backend *self);
+
+static struct vfs_request *blocked_on = NULL;
+static struct vfs_backend backend = BACKEND_KERN(is_ready, accept);
+void serial_init(void) { vfs_mount_root_register("/com1", &backend); }
+
+
+static void serial_selftest(void) {
+	char b = 0x69;
+	port_out8(COM1 + 4, 0b00011110); // enable loopback mode
+	port_out8(COM1, b);
+	assert(port_in8(COM1) == b);
+}
+
+void serial_preinit(void) {
+	// see https://www.sci.muni.cz/docs/pc/serport.txt
+	// set baud rate divisor
+	port_out8(COM1 + 3, 0b10000000); // enable DLAB
+	port_out8(COM1 + 0, 0x01);       // divisor = 1 (low  byte)
+	port_out8(COM1 + 1, 0x00);       //             (high byte)
+
+	port_out8(COM1 + 3, 0b00000011); // 8 bits, no parity, one stop bit
+	port_out8(COM1 + 1, 0x01);       // enable the Data Ready IRQ
+	port_out8(COM1 + 2, 0b11000111); // enable FIFO with 14-bit trigger level (???)
+
+	serial_selftest();
+
+	port_out8(COM1 + 4, 0b00001111); // enable everything in the MCR
+}
+
+
+void serial_irq(void) {
+	ring_put1b((void*)&backlog, port_in8(COM1));
+	if (blocked_on) {
+		accept(blocked_on);
+		blocked_on = NULL;
+		vfs_backend_tryaccept(&backend);
+	}
+}
+
+
+static void serial_putchar(char c) {
+	while ((port_in8(COM1 + 5) & 0x20) == 0); // wait for THRE
+	port_out8(COM1, c);
+}
+
+void serial_write(const char *buf, size_t len) {
+	for (size_t i = 0; i < len; i++)
+		serial_putchar(buf[i]);
+}
+
+
+static void accept(struct vfs_request *req) {
+	static char buf[32];
+	int ret;
+	bool valid;
+	switch (req->type) {
+		case VFSOP_OPEN:
+			valid = req->input.len == 0;
+			vfsreq_finish_short(req, valid ? 0 : -1);
+			break;
+		case VFSOP_READ:
+			if (ring_size((void*)&backlog) == 0) {
+				/* nothing to read, join queue */
+				assert(!req->postqueue_next);
+				struct vfs_request **slot = &blocked_on;
+				while (*slot)
+					slot = &(*slot)->postqueue_next;
+				*slot = req;
+			} else if (req->caller) {
+				ret = clamp(0, req->output.len, sizeof buf);
+				ret = ring_get((void*)&backlog, buf, ret);
+				virt_cpy_to(req->caller->pages, req->output.buf, buf, ret);
+				vfsreq_finish_short(req, ret);
+			} else {
+				vfsreq_finish_short(req, -1);
+			}
+			break;
+		case VFSOP_WRITE:
+			if (req->caller) {
+				struct virt_iter iter;
+				virt_iter_new(&iter, req->input.buf, req->input.len,
+						req->caller->pages, true, false);
+				while (virt_iter_next(&iter))
+					serial_write(iter.frag, iter.frag_len);
+				ret = iter.prior;
+			} else ret = -1;
+			vfsreq_finish_short(req, ret);
+			break;
+		default:
+			vfsreq_finish_short(req, -1);
+			break;
+	}
+}
+
+static bool is_ready(struct vfs_backend __attribute__((unused)) *self) {
+	return true;
+}
diff --git a/src/kernel/arch/amd64/driver/serial.h b/src/kernel/arch/amd64/driver/serial.h
new file mode 100644
index 0000000..6a4876e
--- /dev/null
+++ b/src/kernel/arch/amd64/driver/serial.h
@@ -0,0 +1,10 @@
+#pragma once
+#include <kernel/vfs/request.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+void serial_preinit(void);
+void serial_irq(void);
+void serial_write(const char *buf, size_t len);
+
+void serial_init(void);