initial commit

13 files changed, 1099 insertions, 0 deletions

diff --git a/kernel/arch/i386/boot.asm b/kernel/arch/i386/boot.asm
new file mode 100644
index 0000000..a2dccce
--- /dev/null
+++ b/kernel/arch/i386/boot.asm
@@ -0,0 +1,82 @@
+; multiboot header constants

+MBALIGN equ 1 << 0

+MEMINFO equ 1 << 1

+MBFLAGS equ MBALIGN | MEMINFO

+MAGIC    equ  0x1BADB002

+CHECKSUM equ -(MAGIC+MBFLAGS)

+

+; multiboot header

+section .multiboot

+align 4

+    dd MAGIC

+    dd MBFLAGS

+    dd CHECKSUM

+

+section .data

+%include "arch/i386/gdt.asm"

+

+; defines the stack

+section .bss

+align 16

+stack_bottom:

+resb 16384 ; 16 KiB

+stack_top:

+

+

+section .text

+global _start:function (_start.end - _start)

+_start:

+    cli

+    ; setup stack

+    mov esp, stack_top

+

+    extern _init

+    call _init

+

+    lgdt [gdt_descriptor]

+    jmp 0x08:.gdt_jmp

+

+.gdt_jmp:

+	mov ax, DATA_SEG

+	mov ds, ax

+	mov es, ax

+	mov fs, ax

+	mov gs, ax

+	mov ss, ax

+	jmp .gdt_jmp2

+

+.gdt_jmp2:

+

+    ; setup idt

+    extern idt_setup

+    call idt_setup

+    extern idtr

+    lidt [idtr]

+    

+    ; initialize pic

+    push ebp

+    mov ebp, esp

+    mov ebx, 0x28

+    push ebx

+    mov ebx, 0x20

+    push ebx

+

+    extern pic_remap

+    call pic_remap

+

+    pop ebx

+    pop ebx

+    mov esp, ebp

+    pop ebp

+

+    sti

+

+    ; enter the kernel

+    extern kernel_main

+    call kernel_main

+

+    ; indefinite loop once system exits

+    ;cli

+.hang: hlt

+    jmp .hang

+.end:
\ No newline at end of file
diff --git a/kernel/arch/i386/crti.asm b/kernel/arch/i386/crti.asm
new file mode 100644
index 0000000..51f27d9
--- /dev/null
+++ b/kernel/arch/i386/crti.asm
@@ -0,0 +1,12 @@
+; x86 crti.asm

+section .init

+global _init:function

+_init:

+    push ebp

+    mov ebp, esp

+

+section .fini

+global _fini:function

+_fini:

+    push ebp

+    mov ebp, esp
\ No newline at end of file
diff --git a/kernel/arch/i386/crtn.asm b/kernel/arch/i386/crtn.asm
new file mode 100644
index 0000000..370f4ae
--- /dev/null
+++ b/kernel/arch/i386/crtn.asm
@@ -0,0 +1,9 @@
+; x86 crtn.asm

+

+section .init

+    pop ebp

+    ret

+

+section .fini

+    pop ebp

+    ret
\ No newline at end of file
diff --git a/kernel/arch/i386/gdt.asm b/kernel/arch/i386/gdt.asm
new file mode 100644
index 0000000..e3af8bd
--- /dev/null
+++ b/kernel/arch/i386/gdt.asm
@@ -0,0 +1,35 @@
+; gdt.asm

+; GDT is defined here

+

+gdt_start:

+

+gdt_null: ; Null segment

+	dd 0x0

+	dd 0x0

+

+gdt_kcode: ; Kernel code segment. Kernel has seperate segment from users for ring level

+	; flag and access byte description on osdev wiki

+	dw 0xffff ; low limit

+	dw 0x0 ;low base

+	db 0x0 ; mid base

+	db 10011010b ; order (reversed): ac, rw, dc, ex, s, privl, pr 

+	db 11001111b ; flags then limit. order (reversed): 0, 0, size bit, granularity bit

+	db 0x0 ; high limit

+

+gdt_kdata: ; same as gdt_kcode but for the data segment

+	dw 0xffff ;low limit

+	dw 0x0 ;low base

+	db 0x0 ;mid base

+	db 10010010b ; order: same as code seg. changed for data seg

+	db 11001111b ; same as kcode

+	db 0x0 ; high limit

+

+gdt_end:

+

+gdt_descriptor: ; describes the gdt to the lgdt register

+	dw gdt_end - gdt_start - 1

+

+	dd gdt_start

+

+CODE_SEG equ gdt_kcode - gdt_start

+DATA_SEG equ gdt_kdata - gdt_start
\ No newline at end of file
diff --git a/kernel/arch/i386/gdt2.cpp b/kernel/arch/i386/gdt2.cpp
new file mode 100644
index 0000000..0acdb0e
--- /dev/null
+++ b/kernel/arch/i386/gdt2.cpp
@@ -0,0 +1,51 @@
+#include <stdio.h>

+#include <stdint.h>

+/*

+// structure to be encoded at encodeGdtEntry()

+struct GDT

+{

+    uint32_t base;

+    uint32_t limit;

+    uint8_t access_byte;

+    uint8_t flags;

+};

+

+GDT strnulldesc {0, 0, 0, 0};

+GDT strkernelcode {0, 0xFFFFF, 0x9A, 0xC};

+GDT strkerneldata {0, 0xFFFFF, 0x92, 0xC};

+GDT strusercode {0, 0xFFFFF, 0xFA, 0xC};

+GDT struserdata {0, 0xFFFFF, 0xF2, 0xC};

+

+uint8_t* nulldesc;

+uint8_t* kernelcode;

+uint8_t* kerneldata;

+uint8_t* usercode;

+uint8_t* userdata;

+

+

+void encodeGdtEntry(uint8_t *target, struct GDT source)

+{

+    // Check the limit to make sure that it can be encoded

+    if (source.limit > 0xFFFFF) {printf("GDT cannot encode limits larger than 0xFFFFF\n");}

+ 

+    // Encode the limit

+    target[0] = source.limit & 0xFF;

+    target[1] = (source.limit >> 8) & 0xFF;

+    target[6] = (source.limit >> 16) & 0x0F;

+ 

+    // Encode the base

+    target[2] = source.base & 0xFF;

+    target[3] = (source.base >> 8) & 0xFF;

+    target[4] = (source.base >> 16) & 0xFF;

+    target[7] = (source.base >> 24) & 0xFF;

+ 

+    // Encode the access byte

+    target[5] = source.access_byte;

+ 

+    // Encode the flags

+    target[6] |= (source.flags << 4);

+}

+

+extern "C" void setupGdt() {

+

+} */
\ No newline at end of file
diff --git a/kernel/arch/i386/idt.cpp b/kernel/arch/i386/idt.cpp
new file mode 100644
index 0000000..a8f3ff4
--- /dev/null
+++ b/kernel/arch/i386/idt.cpp
@@ -0,0 +1,133 @@
+#include <stdint.h>

+#include <stddef.h>

+

+/* Function prototypes for the ISR functions. IDT[0] to IDT[31] are reserved for hardware exceptions */

+extern "C" void isr0();

+extern "C" void isr1();

+extern "C" void isr2();

+extern "C" void isr3();

+extern "C" void isr4();

+extern "C" void isr5();

+extern "C" void isr6();

+extern "C" void isr7();

+extern "C" void isr8();

+extern "C" void isr9();

+extern "C" void isr10();

+extern "C" void isr11();

+extern "C" void isr12();

+extern "C" void isr13();

+extern "C" void isr14();

+extern "C" void isr15();

+extern "C" void isr16();

+extern "C" void isr17();

+extern "C" void isr18();

+extern "C" void isr19();

+extern "C" void isr20();

+extern "C" void isr21();

+extern "C" void isr22();

+extern "C" void isr23();

+extern "C" void isr24();

+extern "C" void isr25();

+extern "C" void isr26();

+extern "C" void isr27();

+extern "C" void isr28();

+extern "C" void isr29();

+extern "C" void isr30();

+extern "C" void isr31();

+extern "C" void isr32();

+extern "C" void isr33();

+extern "C" void isr34();

+extern "C" void isr35();

+extern "C" void isr36();

+extern "C" void isr37();

+extern "C" void isr38();

+extern "C" void isr39();

+extern "C" void isr40();

+extern "C" void isr41();

+extern "C" void isr42();

+extern "C" void isr43();

+extern "C" void isr44();

+extern "C" void isr45();

+extern "C" void isr46();

+extern "C" void isr47();

+

+struct idt_entry

+{

+    uint16_t offset_low;

+    uint16_t selector;

+    uint8_t always0;

+    uint8_t type_attributes;

+    uint16_t offset_high;

+}__attribute__((packed));

+

+struct str_idtr {

+    uint16_t limit;

+    uint32_t base;

+}__attribute__((packed));

+

+idt_entry idt[256];

+str_idtr idtr;

+

+void idt_new_entry(int num, uint32_t offset, uint16_t sel, uint8_t type_attribs) {

+    idt[num].offset_low = (offset & 0xFFFF);

+    idt[num].selector = sel;

+    idt[num].always0 = 0;

+    idt[num].type_attributes = type_attribs;

+    idt[num].offset_high = (offset >> 16) & 0xFFFF;

+}

+

+extern "C" void idt_setup() {

+    idtr.limit = (sizeof(struct idt_entry) * 256) - 1;

+    idtr.base = (uint32_t)idt;

+

+    // todo: is there really no other way?

+    idt_new_entry(0, (unsigned)isr0, 0x08, 0x8E);

+	idt_new_entry(1, (unsigned)isr1, 0x08, 0x8E);

+	idt_new_entry(2, (unsigned)isr2, 0x08, 0x8E);

+	idt_new_entry(3, (unsigned)isr3, 0x08, 0x8E);

+	idt_new_entry(4, (unsigned)isr4, 0x08, 0x8E);

+	idt_new_entry(5, (unsigned)isr5, 0x08, 0x8E);

+	idt_new_entry(6, (unsigned)isr6, 0x08, 0x8E);

+	idt_new_entry(7, (unsigned)isr7, 0x08, 0x8E);

+	idt_new_entry(8, (unsigned)isr8, 0x08, 0x8E);

+	idt_new_entry(9, (unsigned)isr9, 0x08, 0x8E);

+	idt_new_entry(10, (unsigned)isr10, 0x08, 0x8E);

+	idt_new_entry(11, (unsigned)isr11, 0x08, 0x8E);

+	idt_new_entry(12, (unsigned)isr12, 0x08, 0x8E);

+	idt_new_entry(13, (unsigned)isr13, 0x08, 0x8E);

+	idt_new_entry(14, (unsigned)isr14, 0x08, 0x8E);

+	idt_new_entry(15, (unsigned)isr15, 0x08, 0x8E);

+	idt_new_entry(16, (unsigned)isr16, 0x08, 0x8E);

+	idt_new_entry(17, (unsigned)isr17, 0x08, 0x8E);

+	idt_new_entry(18, (unsigned)isr18, 0x08, 0x8E);

+	idt_new_entry(19, (unsigned)isr19, 0x08, 0x8E);

+	idt_new_entry(20, (unsigned)isr20, 0x08, 0x8E);

+	idt_new_entry(21, (unsigned)isr21, 0x08, 0x8E);

+	idt_new_entry(22, (unsigned)isr22, 0x08, 0x8E);

+	idt_new_entry(23, (unsigned)isr23, 0x08, 0x8E);

+	idt_new_entry(24, (unsigned)isr24, 0x08, 0x8E);

+	idt_new_entry(25, (unsigned)isr25, 0x08, 0x8E);

+	idt_new_entry(26, (unsigned)isr26, 0x08, 0x8E);

+	idt_new_entry(27, (unsigned)isr27, 0x08, 0x8E);

+	idt_new_entry(28, (unsigned)isr28, 0x08, 0x8E);

+	idt_new_entry(29, (unsigned)isr29, 0x08, 0x8E);

+	idt_new_entry(30, (unsigned)isr30, 0x08, 0x8E);

+	idt_new_entry(31, (unsigned)isr31, 0x08, 0x8E);

+	//PIC entries

+	idt_new_entry(32, (unsigned)isr32, 0x08, 0x8E);

+	idt_new_entry(33, (unsigned)isr33, 0x08, 0x8E);

+	idt_new_entry(34, (unsigned)isr34, 0x08, 0x8E);

+	idt_new_entry(35, (unsigned)isr35, 0x08, 0x8E);

+	idt_new_entry(36, (unsigned)isr36, 0x08, 0x8E);

+	idt_new_entry(37, (unsigned)isr37, 0x08, 0x8E);

+	idt_new_entry(38, (unsigned)isr38, 0x08, 0x8E);

+	idt_new_entry(39, (unsigned)isr39, 0x08, 0x8E);

+	idt_new_entry(40, (unsigned)isr40, 0x08, 0x8E);

+	idt_new_entry(41, (unsigned)isr41, 0x08, 0x8E);

+	idt_new_entry(42, (unsigned)isr42, 0x08, 0x8E);

+	idt_new_entry(43, (unsigned)isr43, 0x08, 0x8E);

+	idt_new_entry(44, (unsigned)isr44, 0x08, 0x8E);

+	idt_new_entry(45, (unsigned)isr45, 0x08, 0x8E);

+	idt_new_entry(46, (unsigned)isr46, 0x08, 0x8E);

+	idt_new_entry(47, (unsigned)isr47, 0x08, 0x8E);

+}
\ No newline at end of file
diff --git a/kernel/arch/i386/isr.asm b/kernel/arch/i386/isr.asm
new file mode 100644
index 0000000..4ccbaf9
--- /dev/null
+++ b/kernel/arch/i386/isr.asm
@@ -0,0 +1,324 @@
+; isr.asm

+; ISR functions are defined here. Most code is done in isr_handlers.cpp

+

+global isr0

+global isr1

+global isr2

+global isr3

+global isr4

+global isr5

+global isr6

+global isr7

+global isr8

+global isr9

+global isr10

+global isr11

+global isr12

+global isr13

+global isr14

+global isr15

+global isr16

+global isr17

+global isr18

+global isr19

+global isr20

+global isr21

+global isr22

+global isr23

+global isr24

+global isr25

+global isr26

+global isr27

+global isr28

+global isr29

+global isr30

+global isr31

+global isr32

+global isr33

+global isr34

+global isr35

+global isr36

+global isr37

+global isr38

+global isr39

+global isr40

+global isr41

+global isr42

+global isr43

+global isr44

+global isr45

+global isr46

+global isr47

+

+section .text

+align 4

+

+isr0:

+	pushad

+    mov ebx, 0

+    call exception_stub

+    hlt

+	popad

+	iret

+

+isr1:

+	pushad

+	popad

+	iret

+

+isr2:

+	pushad

+	popad

+	iret

+

+isr3:

+	pushad

+	popad

+	iret

+

+isr4:

+	pushad

+	popad

+	iret

+

+isr5:

+	pushad

+	popad

+	iret

+

+isr6:

+	pushad

+	mov ebx, 6

+	call exception_stub

+	popad

+	iret

+

+isr7:

+	pushad

+	popad

+	iret

+

+isr8:

+	pushad

+	mov ebx, 8

+	call exception_stub

+	popad

+	iret

+

+isr9:

+	pushad

+	popad

+	iret

+

+isr10:

+	pushad

+	popad

+	iret

+

+isr11:

+	pushad

+	mov ebx, 11

+	call exception_stub

+	popad

+	iret

+

+isr12:

+	pushad

+	popad

+	iret

+

+isr13:

+	pushad

+	mov ebx, 13

+	call exception_stub

+	popad

+	iret

+

+isr14:

+	pushad

+	mov ebx, 14

+	call exception_stub

+	popad

+	iret

+

+isr15:

+	pushad

+	popad

+	iret

+

+isr16:

+	pushad

+	popad

+	iret

+

+isr17:

+	pushad

+	popad

+	iret

+

+isr18:

+	pushad

+	popad

+	iret

+

+isr19:

+	pushad

+	popad

+	iret

+

+isr20:

+	pushad

+	popad

+	iret

+

+isr21:

+	pushad

+	popad

+	iret

+

+isr22:

+	pushad

+	popad

+	iret

+

+isr23:

+	pushad

+	popad

+	iret

+

+isr24:

+	pushad

+	popad

+	iret

+

+isr25:

+	pushad

+	popad

+	iret

+

+isr26:

+	pushad

+	popad

+	iret

+

+isr27:

+	pushad

+	popad

+	iret

+isr28:

+	pushad

+	popad

+	iret

+

+isr29:

+	pushad

+	popad

+	iret

+

+isr30:

+	pushad

+	popad

+	iret

+

+isr31:

+	pushad

+	popad

+	iret

+

+isr32:

+	pushad

+	;extern pit_handler

+	;call pit_handler

+	popad

+	iret

+

+isr33:

+	pushad

+	extern ps2_handler

+	call ps2_handler

+	popad

+	iret

+

+isr34:

+	pushad

+	popad

+	iret

+

+isr35:

+	pushad

+	popad

+	iret

+

+isr36:

+	pushad

+	popad

+	iret

+isr37:

+	pushad

+	popad

+	iret

+

+isr38:

+	pushad

+	popad

+	iret

+

+isr39:

+	pushad

+	popad

+	iret

+

+isr40:

+	pushad

+	xchg bx, bx

+	popad

+	iret

+

+isr41:

+	pushad

+	popad

+	iret

+

+isr42:

+	pushad

+	popad

+	iret

+

+isr43:

+	pushad

+	popad

+	iret

+

+isr44:

+	pushad

+	popad

+	iret

+

+isr45:

+	pushad

+	popad

+	iret

+

+isr46:

+	pushad

+	popad

+	iret

+

+isr47:

+	pushad

+	popad

+	iret

+

+exception_stub:

+	push ebp

+	mov ebp, esp

+

+	push ebx

+    ;cld

+	extern exception_handler

+	call exception_handler

+	pop ebx

+	

+	mov esp, ebp

+	pop ebp

+	ret
\ No newline at end of file
diff --git a/kernel/arch/i386/isr_handler.cpp b/kernel/arch/i386/isr_handler.cpp
new file mode 100644
index 0000000..a2fc23a
--- /dev/null
+++ b/kernel/arch/i386/isr_handler.cpp
@@ -0,0 +1,21 @@
+#include <stdint.h>

+#include <stdio.h>

+#include <stddef.h>

+#include <arch/i386/tmtty.h>

+#include <arch/i386/ps2_controller.h>

+#include <arch/i386/pic.h>

+#include <io.h>

+

+extern "C" void exception_handler(int e) {

+    //unsigned char errorcode[2]{((unsigned char) e) + 48};

+    //terminal_initialize();

+	printf("Exception\n");

+}

+

+extern "C" void ps2_handler() {

+    printf("b");

+    inb(0x60);

+    printf("a");

+

+    pic_send_eoi(1);

+}
\ No newline at end of file
diff --git a/kernel/arch/i386/linker.ld b/kernel/arch/i386/linker.ld
new file mode 100644
index 0000000..24cfa84
--- /dev/null
+++ b/kernel/arch/i386/linker.ld
@@ -0,0 +1,33 @@
+/* Excecution start point symbol */

+ENTRY(_start)

+

+SECTIONS

+{

+    . = 1M;

+

+    /* code. multiboot header comes first */

+    .text BLOCK(4K) : ALIGN(4K)

+    {

+        *(.multiboot)

+        *(.text)

+    }

+

+    /* read only data */

+    .rodata BLOCK(4K) : ALIGN(4K)

+    {

+        *(.rodata)

+    }

+

+    /* read write data (initialized) */

+    .data BLOCK(4K) : ALIGN(4K)

+    {

+        *(.data)

+    }

+

+    /* read write data (uninitialized) and stack */

+    .bss BLOCK(4K) : ALIGN(4K)

+    {

+        *(COMMON)

+        *(.bss)

+    }

+}
\ No newline at end of file
diff --git a/kernel/arch/i386/pic.cpp b/kernel/arch/i386/pic.cpp
new file mode 100644
index 0000000..78cbcf8
--- /dev/null
+++ b/kernel/arch/i386/pic.cpp
@@ -0,0 +1,97 @@
+#include <io.h>

+#include <arch/i386/pic.h>

+#include <stdint.h>

+#include <arch/i386/pic.h>

+

+#define PIC1 0x20

+#define PIC2 0xA0

+#define PIC1_CMD PIC1

+#define PIC1_DATA (PIC1 + 1)

+#define PIC2_CMD PIC2

+#define PIC2_DATA (PIC2 + 1)

+#define PIC_READ_IRR 0x0a    // OCW3 irq ready next CMD read

+#define PIC_READ_ISR 0x0b    // OCW3 irq service next CMD read

+

+#define PIC_EOI 0x20

+

+// pic reinitialization constants

+#define ICW1_ICW4 0x01 // indicates icw4 will be present

+#define ICW1_SINGLE 0x02 // single cascade mode

+#define ICW1_INTERVAL4 0x04 // call address interval 4

+#define ICW1_LEVEL 0x08 // level triggered (edge) mode

+#define ICW1_INIT 0x10 // initialization

+

+#define ICW4_8086 0x01 // 8086 mode

+#define ICW4_AUTO 0x02 // auto (normal) eoi

+#define ICW4_BUF_SLAVE 0x08 // buffered mode/slave

+#define ICW4_BUF_MASTER 0x0C // buffered mode/master

+#define ICW4_SFNM 0x10 // special fully nested (not)

+

+void pic_send_eoi(unsigned char irq) {

+    if (irq >= 8) {

+        outb(PIC2_CMD, PIC_EOI);

+    }

+    outb(PIC1_CMD, PIC_EOI);

+}

+

+// offset 1 is for master, offset 2 is for slave

+void pic_remap(int offset1, int offset2) {

+    unsigned char a1, a2;

+

+    a1 = inb(PIC1_DATA); // save masks

+    a2 = inb(PIC2_DATA);

+

+    outb(PIC1_CMD, ICW1_INIT | ICW1_ICW4); // starts initialization in cascade mode

+    io_wait();

+    outb(PIC2_CMD, ICW1_INIT | ICW1_ICW4);

+    io_wait();

+    outb(PIC1_DATA, offset1); // icw2: master and slave vector offset set

+    io_wait();

+    outb(PIC2_DATA, offset2);

+    io_wait();

+    outb(PIC1_DATA, 4); // tells master pic theres a slave pic at irq2

+    io_wait();

+    outb(PIC2_DATA, 2); // tells slave pic its cascade identity

+    io_wait();

+

+    outb(PIC1_DATA, ICW4_8086);

+    io_wait();

+    outb(PIC2_DATA, ICW4_8086);

+    io_wait();

+

+    outb(PIC1_DATA, a1); // restore masks

+    outb(PIC2_DATA, a2);

+

+    for (char i = 0; i < 15; i++)

+	{

+		irq_set_mask(i);

+	}

+}

+

+void irq_set_mask(unsigned char irq) {

+    uint16_t port;

+    uint8_t value;

+

+    if (irq < 8) {

+        port = PIC1_DATA;

+    } else {

+        port = PIC2_DATA;

+        irq -= 8;

+    }

+    value = inb(port) | (1 << irq);

+    outb(port, value);

+}

+

+void irq_clear_mask(unsigned char irq) {

+    uint16_t port;

+    uint8_t value;

+

+    if (irq < 8) {

+        port = PIC1_DATA;

+    } else {

+        port = PIC2_DATA;

+        irq -= 8;

+    }

+    value = inb(port) & ~(1 << irq);

+    outb(port, value);

+}
\ No newline at end of file
diff --git a/kernel/arch/i386/ps2_controller.cpp b/kernel/arch/i386/ps2_controller.cpp
new file mode 100644
index 0000000..9424233
--- /dev/null
+++ b/kernel/arch/i386/ps2_controller.cpp
@@ -0,0 +1,191 @@
+#include <io.h>

+#include <stdint.h>

+#include <stdio.h>

+#include <arch/i386/ps2_controller.h>

+

+#define PS2_DATA 0x60 // data port

+#define PS2_STATUS 0x64 // status register

+#define PS2_COMMAND 0x64 // command register

+

+// set to true if 2nd ps2 port is available

+bool ps2SecondaryEnabled = false;

+

+void initialize_ps2_controller() {

+    inputbuffer_wait();

+    outb(PS2_COMMAND, 0xAD); // disable devices

+    inputbuffer_wait();

+    outb(PS2_COMMAND, 0xA7);

+    

+    outputbuffer_wait();

+    inb(PS2_DATA); // flush output buffer

+    inb(PS2_DATA);

+    inb(PS2_DATA);

+    inb(PS2_DATA);

+    inb(PS2_DATA);

+    inb(PS2_DATA);

+    inb(PS2_DATA);

+    inb(PS2_DATA);

+    inb(PS2_DATA);

+    inb(PS2_DATA);

+

+    

+    inputbuffer_wait();

+    outb(PS2_COMMAND, 0x20); // set controller configuration byte

+    outputbuffer_wait();

+    uint8_t conconfig = inb(PS2_DATA);

+    conconfig &= 0b00110100;

+    inputbuffer_wait();

+    outb(PS2_COMMAND, 0x60);

+    inputbuffer_wait();

+    outb(PS2_DATA, conconfig);

+

+    inputbuffer_wait();

+    outb(PS2_COMMAND, 0xAA); // performs controller self test

+    outputbuffer_wait();

+    if (inb(PS2_DATA) == 0xFC) {

+        printf("PS/2 controller failed self test\n");

+    }

+    inputbuffer_wait();

+    outb(PS2_COMMAND, 0x60); // in case the controller resets from the test

+    inputbuffer_wait();

+    outb(PS2_DATA, conconfig);

+

+    int portcount = 1;

+    inputbuffer_wait();

+    outb(PS2_COMMAND, 0xA8); // check if ps2 controller is dual channel

+    inputbuffer_wait();

+    outb(PS2_COMMAND, 0x20);

+    outputbuffer_wait();

+    conconfig = inb(PS2_DATA);

+    if ((conconfig & 0b00100000) == 0b00000000) { // checks if bit 5 is cleared

+        ps2SecondaryEnabled = true;

+        //printf("Dual channel PS/2\n");

+        portcount = 2;

+    } else {

+        //printf("Single channel PS/2\n");

+    }

+    

+    inputbuffer_wait();

+    outb(PS2_COMMAND, 0xAB); // tests ps2 ports

+    outputbuffer_wait();

+    if (inb(PS2_DATA) != 0x00) {

+        printf("PS/2 port 1 failed self test\n");

+        --portcount;

+    }

+    if (ps2SecondaryEnabled) {

+        inputbuffer_wait();

+        outb(PS2_COMMAND, 0xA9);

+        outputbuffer_wait();

+        if (inb(PS2_DATA) != 0x00) {

+            printf("PS/2 port 2 failed self test\n");

+            --portcount;

+        }

+    }

+    if (!portcount) {

+        printf("PS/2 initialization failed\n");

+        return;

+    }

+

+    conconfig |= 0b00000011;

+    inputbuffer_wait();

+    outb(PS2_COMMAND, 0xAE); // enable ps2 ports

+    conconfig |= 0b00000001;

+    if (ps2SecondaryEnabled) {

+        inputbuffer_wait();

+        outb(PS2_COMMAND, 0xA8);

+        outb(PS2_COMMAND, 0x60);

+        conconfig |= 0b00000011;

+        outb(PS2_DATA, conconfig);

+    } else {

+        inputbuffer_wait();

+        outb(PS2_COMMAND, 0x60);

+        conconfig |= 0b00000001;

+        outb(PS2_DATA, conconfig);

+    }

+

+    //ps2_dev_send_command(0, 0xFF); // reset devices

+    //inb(PS2_DATA);

+    //io_wait();

+    if (ps2SecondaryEnabled) {

+        //ps2_dev_send_command(1, 0xFF);

+        //inb(PS2_DATA);

+        //io_wait();

+    }

+

+    //printf("PS/2 controller initialized\n");

+}

+

+// waits for input buffer (write) to be filled

+void inputbuffer_wait() {

+    for (int i = 0; i < 15; i++) {

+        uint8_t status_reg = inb(PS2_STATUS);

+        if ((status_reg & 0b00000010)) {

+            return;

+        }

+        io_wait();

+    }

+}

+

+// waits for outbut buffer (read) to be filled

+void outputbuffer_wait() {

+    for (int i = 0; i < 15; i++) {

+        uint8_t status_reg = inb(PS2_STATUS);

+        if ((status_reg & 0b00000001)) {

+            return;

+        }

+        io_wait();

+    }

+}

+

+// checks if inpbut buffer is set

+bool inputbuffer_check() {

+    uint8_t status_reg = inb(PS2_STATUS);

+    if ((status_reg & 0b00000010)) {

+        return true;

+    } else {

+        return false;

+    }

+}

+

+bool outputbuffer_check() {

+    uint8_t status_reg = inb(PS2_STATUS);

+    if ((status_reg & 0b00000001)) {

+        return true;

+    } else {

+        return false;

+    }

+}

+

+/* Sends a command byte to a ps2 device 

+Port numbers start from 0 */

+int ps2_dev_send_command(int port, unsigned char command) {

+    //bool commandRecieved = false;

+    switch (port)

+        {

+        case 0:

+            for (int i = 0; i < 5; i++) {

+                uint8_t status_reg = inb(PS2_STATUS);

+                if ((status_reg & 0b00000010) == 0b00000000) {

+                    outb(PS2_DATA, command);

+                    return 0;

+                }

+                inb(PS2_DATA);

+                io_wait();

+            }

+            return 1; // error returned if timeout expires

+        case 1:

+            outb(PS2_COMMAND, 0xD4);

+            for (int i = 0; i < 5; i++) {

+                uint8_t status_reg = inb(PS2_STATUS);

+                if ((status_reg & 0b00000010) == 0b00000000) {

+                    outb(PS2_DATA, command);

+                    return 0;

+                }

+                inb(PS2_DATA);

+                io_wait();

+            }

+            return 1;

+        default:

+            return 2; // out of port range

+        }

+}
\ No newline at end of file
diff --git a/kernel/arch/i386/tmtty.cpp b/kernel/arch/i386/tmtty.cpp
new file mode 100644
index 0000000..06eb578
--- /dev/null
+++ b/kernel/arch/i386/tmtty.cpp
@@ -0,0 +1,76 @@
+#include <stdbool.h>

+#include <stddef.h>

+#include <stdint.h>

+#include <string.h>

+#include <arch/i386/tmtty.h>

+

+#include "vga.h"

+

+/* Text mode tty */

+

+static const size_t VGA_WIDTH = 80;

+static const size_t VGA_HEIGHT = 25;

+

+size_t terminal_row;

+size_t terminal_column;

+uint8_t terminal_color;

+uint16_t* terminal_buffer;

+

+void terminal_initialize(void) {

+    terminal_row = 0;

+    terminal_column = 0;

+    terminal_color = vga_entry_color(VGA_COLOR_WHITE, VGA_COLOR_BLACK);

+    terminal_buffer = (uint16_t*) 0xB8000;

+    for (size_t y = 0; y < VGA_HEIGHT; y++) {

+        for (size_t x = 0; x < VGA_WIDTH; x++) {

+            const size_t i = y * VGA_WIDTH + x;

+            terminal_buffer[i] = vga_entry(' ', terminal_color);

+        }

+    }

+}

+

+void terminal_clear(void) {

+    terminal_row = 0;

+    terminal_column = 0;

+    for (size_t y = 0; y < VGA_HEIGHT; y++) {

+        for (size_t x = 0; x < VGA_WIDTH; x++) {

+            const size_t i = y * VGA_WIDTH + x;

+            terminal_buffer[i] = vga_entry(' ', terminal_color);

+        }

+    }

+}

+

+void terminal_setcolor(uint8_t color) {

+    terminal_color = color;

+}

+

+void terminal_putentryat(char c, uint8_t color, size_t x, size_t y) {

+    const size_t i = y * VGA_WIDTH + x;

+    terminal_buffer[i] = vga_entry(c, color);

+}

+

+void terminal_putchar(char c) {

+    if (c == '\n') {

+        terminal_column = 0;

+        ++terminal_row;

+        return;

+    }

+    terminal_putentryat(c, terminal_color, terminal_column, terminal_row);

+    

+    if (++terminal_column == VGA_WIDTH) {

+        terminal_column = 0;

+        if (++terminal_row == VGA_HEIGHT) {

+            terminal_row = 0;

+        }

+    }

+}

+

+void terminal_write(const char* data, size_t size) {

+    for (size_t i = 0; i < size; i++) {

+        terminal_putchar(data[i]);

+    }

+}

+

+void terminal_writestring(const char* data) {

+    terminal_write(data, strlen(data));

+}
\ No newline at end of file
diff --git a/kernel/arch/i386/vga.h b/kernel/arch/i386/vga.h
new file mode 100644
index 0000000..5b6b351
--- /dev/null
+++ b/kernel/arch/i386/vga.h
@@ -0,0 +1,35 @@
+#ifndef ARCH_I386_VGA_H

+#define ARCH_I386_VGA_H

+

+#include <stdint.h>

+

+// hardware text mode constants

+enum vga_color {

+    VGA_COLOR_BLACK = 0,

+	VGA_COLOR_BLUE = 1,

+	VGA_COLOR_GREEN = 2,

+	VGA_COLOR_CYAN = 3,

+	VGA_COLOR_RED = 4,

+	VGA_COLOR_MAGENTA = 5,

+	VGA_COLOR_BROWN = 6,

+	VGA_COLOR_LIGHT_GREY = 7,

+	VGA_COLOR_DARK_GREY = 8,

+	VGA_COLOR_LIGHT_BLUE = 9,

+	VGA_COLOR_LIGHT_GREEN = 10,

+	VGA_COLOR_LIGHT_CYAN = 11,

+	VGA_COLOR_LIGHT_RED = 12,

+	VGA_COLOR_LIGHT_MAGENTA = 13,

+	VGA_COLOR_LIGHT_BROWN = 14,

+	VGA_COLOR_WHITE = 15,

+};

+

+static inline uint8_t vga_entry_color(enum vga_color fg, enum vga_color bg) {

+    return fg | bg << 4;

+}

+

+// returns the character/color of a terminal entry

+static inline uint16_t vga_entry(unsigned char uc, uint8_t color) {

+    return (uint16_t) uc | (uint16_t) color << 8;

+}

+

+#endif
\ No newline at end of file