From a78033acc941fc4bcf6188f1d48fd8e012673fff Mon Sep 17 00:00:00 2001 From: EmulatedSeasons <89668582+EmulatedSeasons@users.noreply.github.com> Date: Thu, 15 Jun 2023 22:36:39 -0400 Subject: initial commit --- kernel/arch/i386/boot.asm | 82 +++++++++ kernel/arch/i386/crti.asm | 12 ++ kernel/arch/i386/crtn.asm | 9 + kernel/arch/i386/gdt.asm | 35 ++++ kernel/arch/i386/gdt2.cpp | 51 ++++++ kernel/arch/i386/idt.cpp | 133 +++++++++++++++ kernel/arch/i386/isr.asm | 324 ++++++++++++++++++++++++++++++++++++ kernel/arch/i386/isr_handler.cpp | 21 +++ kernel/arch/i386/linker.ld | 33 ++++ kernel/arch/i386/pic.cpp | 97 +++++++++++ kernel/arch/i386/ps2_controller.cpp | 191 +++++++++++++++++++++ kernel/arch/i386/tmtty.cpp | 76 +++++++++ kernel/arch/i386/vga.h | 35 ++++ 13 files changed, 1099 insertions(+) create mode 100644 kernel/arch/i386/boot.asm create mode 100644 kernel/arch/i386/crti.asm create mode 100644 kernel/arch/i386/crtn.asm create mode 100644 kernel/arch/i386/gdt.asm create mode 100644 kernel/arch/i386/gdt2.cpp create mode 100644 kernel/arch/i386/idt.cpp create mode 100644 kernel/arch/i386/isr.asm create mode 100644 kernel/arch/i386/isr_handler.cpp create mode 100644 kernel/arch/i386/linker.ld create mode 100644 kernel/arch/i386/pic.cpp create mode 100644 kernel/arch/i386/ps2_controller.cpp create mode 100644 kernel/arch/i386/tmtty.cpp create mode 100644 kernel/arch/i386/vga.h (limited to 'kernel/arch') 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 +#include +/* +// 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 +#include + +/* 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 +#include +#include +#include +#include +#include +#include + +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 +#include +#include +#include + +#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 +#include +#include +#include + +#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 +#include +#include +#include +#include + +#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 + +// 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 -- cgit v1.2.3-70-g09d2