matos/core/main.c

173 lines
7.1 KiB
C
Raw Normal View History

2019-04-11 22:34:20 +02:00
#include "alloc.h"
2018-07-20 15:41:58 +02:00
#include "exception.h"
#include "gdt.h"
#include "idt.h"
#include "interrupt.h"
#include "io.h"
#include "irq.h"
2018-08-09 22:19:34 +02:00
#include "klibc.h"
2020-04-23 00:49:09 +02:00
#include "kthread.h"
2018-08-06 18:41:45 +02:00
#include "mem.h"
#include "multiboot.h"
2018-11-11 23:04:23 +01:00
#include "paging.h"
2018-07-20 15:41:58 +02:00
#include "pit.h"
2018-11-08 21:11:45 +01:00
#include "serial.h"
2020-04-23 00:49:09 +02:00
#include "stack.h"
#include "stdarg.h"
2018-11-08 22:08:27 +01:00
#ifdef RUN_TEST
#include "test.h"
#endif
2018-11-11 23:04:23 +01:00
#include "types.h"
2018-07-20 15:41:58 +02:00
#include "vga.h"
2018-08-09 22:19:34 +02:00
#define CHECK_FLAG(flags, bit) ((flags) & (1 << (bit)))
2018-07-20 15:41:58 +02:00
void cpuid(int code, uint32_t *a, uint32_t *d)
{
asm volatile("cpuid" : "=a"(*a), "=d"(*d) : "0"(code) : "ebx", "ecx");
}
2020-04-23 00:49:09 +02:00
void idleThread(void *arg){
(void)arg;
2020-04-23 23:40:16 +02:00
int count = 0;
2020-04-23 00:49:09 +02:00
while(1)
2020-04-23 23:40:16 +02:00
printIntDetails(count++, GREEN, BLACK, 0, VGA_HEIGHT - 1);
2020-04-23 00:49:09 +02:00
}
2018-08-09 22:19:34 +02:00
// Multiboot information available here :
// https://www.gnu.org/software/grub/manual/multiboot/multiboot.html#kernel_002ec
// https://www.gnu.org/software/grub/manual/multiboot/html_node/Boot-information-format.html#Boot%20information%20format
void kmain(unsigned long magic, unsigned long addr)
2018-07-20 15:41:58 +02:00
{
2018-08-06 18:41:45 +02:00
unsigned long upper_mem = 0;
2018-11-08 22:08:27 +01:00
VGASetup(BLACK, GREEN);
2018-11-14 18:03:11 +01:00
cursorEnable(14, 15);
2018-11-08 22:08:27 +01:00
printf("Setting up Interruptions\n");
2018-07-20 15:41:58 +02:00
gdtSetup();
idtSetup();
irqSetup();
2018-11-08 22:08:27 +01:00
pitSetup(100);
2018-07-20 15:41:58 +02:00
2019-04-15 23:19:14 +02:00
if (magic == MULTIBOOT_BOOTLOADER_MAGIC) { // Get loaded by Grub with mutliboot version 1
multiboot_info_t *mbi = (multiboot_info_t *)addr;
/* Are mem_* valid? */
2018-08-09 22:19:34 +02:00
if (CHECK_FLAG(mbi->flags, 0)) {
printf("mem_lower = %dKiB mem_upper %dKiB\n", mbi->mem_lower, mbi->mem_upper);
2018-08-06 18:41:45 +02:00
upper_mem = mbi->mem_upper;
}
/* Is boot_device valid? */
2018-08-09 22:19:34 +02:00
if (CHECK_FLAG(mbi->flags, 1)) {
2018-08-06 22:28:45 +02:00
printf("boot_device = %d\n", mbi->boot_device);
}
/* Is the command line passed? */
2018-08-09 22:19:34 +02:00
if (CHECK_FLAG(mbi->flags, 2)) {
2018-08-06 22:28:45 +02:00
printf("cmdline = %s\n", (char *)mbi->cmdline);
}
if (CHECK_FLAG(mbi->flags, 3)) {
multiboot_module_t *mod;
uint32_t i;
printf("mods_count = %d, mods_addr = 0x%x\n", (int)mbi->mods_count,
(int)mbi->mods_addr);
for (i = 0, mod = (multiboot_module_t *)mbi->mods_addr; i < mbi->mods_count;
i++, mod++)
printf(" mod_start = 0x%x, mod_end = 0x%x, cmdline = %s\n",
(unsigned)mod->mod_start, (unsigned)mod->mod_end, (char *)mod->cmdline);
}
if (CHECK_FLAG(mbi->flags, 6)) {
struct multiboot_mmap_entry *mmap = (struct multiboot_mmap_entry *)mbi->mmap_addr;
uint size = mbi->mmap_length / sizeof(struct multiboot_mmap_entry);
2020-04-23 23:38:20 +02:00
pr_devel("mmap buffer at %d size %d %d\n", mbi->mmap_addr, mbi->mmap_length,
sizeof(multiboot_memory_map_t));
for (uint i = 0; i < size; i++) {
2020-04-23 23:38:20 +02:00
printf("base_addr 0x%x 0x%x, length = 0x%x 0x%x, type = 0x%x\n",
(unsigned)(mmap[i].addr >> 32), (unsigned)(mmap[i].addr & 0xffffffff),
(unsigned)(mmap[i].len >> 32), (unsigned)(mmap[i].len & 0xffffffff),
(uint32_t)mmap[i].type);
}
}
}
2018-08-09 22:19:34 +02:00
if (upper_mem == 0) {
2018-08-06 22:28:45 +02:00
printf("Cannot get upper phy mem bound. Using default value 32MB\n");
2018-08-06 18:41:45 +02:00
upper_mem = 32 * 1024;
}
2018-11-08 22:08:27 +01:00
printf("Setting up Pagination\n");
2018-11-11 23:04:23 +01:00
paddr_t lastUserByMem;
memSetup(upper_mem, &lastUserByMem);
2018-11-12 18:06:46 +01:00
#ifdef RUN_TEST
testPhymem();
#endif
2018-11-11 23:04:23 +01:00
pagingSetup(lastUserByMem);
2018-08-06 18:41:45 +02:00
2018-08-06 22:28:45 +02:00
printf("Setting up IRQ handlers\n");
2018-07-20 15:41:58 +02:00
irqSetRoutine(IRQ_KEYBOARD, keyboard_handler);
2018-11-08 22:08:27 +01:00
2018-08-06 22:28:45 +02:00
printf("Enabling HW interrupts\n");
2020-04-23 23:59:57 +02:00
exceptionSetRoutine(EXCEPTION_DOUBLE_FAULT, ACCESS_INTERRUPT(EXCEPTION_DOUBLE_FAULT));
2020-04-24 23:39:56 +02:00
exceptionSetRoutine(EXCEPTION_DIVIDE_ZERO, ACCESS_INTERRUPT(EXCEPTION_DIVIDE_ZERO));
//Used by the DBG
//exceptionSetRoutine(EXCEPTION_DEBUG, ACCESS_INTERRUPT(EXCEPTION_DEBUG));
exceptionSetRoutine(EXCEPTION_NMI, ACCESS_INTERRUPT(EXCEPTION_NMI));
exceptionSetRoutine(EXCEPTION_BREAKPOINT, ACCESS_INTERRUPT(EXCEPTION_BREAKPOINT));
exceptionSetRoutine(EXCEPTION_OVERFLOW, ACCESS_INTERRUPT(EXCEPTION_OVERFLOW));
exceptionSetRoutine(EXCEPTION_BOUND_RANGE_EXCEEDED,
ACCESS_INTERRUPT(EXCEPTION_BOUND_RANGE_EXCEEDED));
exceptionSetRoutine(EXCEPTION_INVALID_OPCODE, ACCESS_INTERRUPT(EXCEPTION_INVALID_OPCODE));
exceptionSetRoutine(EXCEPTION_DEVICE_NOT_AVAILABLE,
ACCESS_INTERRUPT(EXCEPTION_DEVICE_NOT_AVAILABLE));
exceptionSetRoutine(EXCEPTION_COPRO_OVERRUN, ACCESS_INTERRUPT(EXCEPTION_COPRO_OVERRUN));
exceptionSetRoutine(EXCEPTION_INVALID_TSS, ACCESS_INTERRUPT(EXCEPTION_INVALID_TSS));
exceptionSetRoutine(EXCEPTION_SEGMENT_NOT_PRESENT,
ACCESS_INTERRUPT(EXCEPTION_SEGMENT_NOT_PRESENT));
exceptionSetRoutine(EXCEPTION_STACK_SEGMENT_FAULT,
ACCESS_INTERRUPT(EXCEPTION_STACK_SEGMENT_FAULT));
exceptionSetRoutine(EXCEPTION_GENERAL_PROTECTION_FAULT,
ACCESS_INTERRUPT(EXCEPTION_GENERAL_PROTECTION_FAULT));
exceptionSetRoutine(EXCEPTION_PAGE_FAULT, ACCESS_INTERRUPT(EXCEPTION_PAGE_FAULT));
exceptionSetRoutine(EXCEPTION_RESERVED_1, ACCESS_INTERRUPT(EXCEPTION_RESERVED_1));
exceptionSetRoutine(EXCEPTION_X87_FP_EXCEPTION,
ACCESS_INTERRUPT(EXCEPTION_X87_FP_EXCEPTION));
exceptionSetRoutine(EXCEPTION_ALIGNMENT_CHECK,
ACCESS_INTERRUPT(EXCEPTION_ALIGNMENT_CHECK));
exceptionSetRoutine(EXCEPTION_MACHINE_CHECK, ACCESS_INTERRUPT(EXCEPTION_MACHINE_CHECK));
exceptionSetRoutine(EXCEPTION_SIMD_FP, ACCESS_INTERRUPT(EXCEPTION_SIMD_FP));
exceptionSetRoutine(EXCEPTION_VIRTUALIZATION, ACCESS_INTERRUPT(EXCEPTION_VIRTUALIZATION));
exceptionSetRoutine(EXCEPTION_RESERVED_2, ACCESS_INTERRUPT(EXCEPTION_RESERVED_2));
exceptionSetRoutine(EXCEPTION_RESERVED_3, ACCESS_INTERRUPT(EXCEPTION_RESERVED_3));
exceptionSetRoutine(EXCEPTION_RESERVED_4, ACCESS_INTERRUPT(EXCEPTION_RESERVED_4));
exceptionSetRoutine(EXCEPTION_RESERVED_5, ACCESS_INTERRUPT(EXCEPTION_RESERVED_5));
exceptionSetRoutine(EXCEPTION_RESERVED_6, ACCESS_INTERRUPT(EXCEPTION_RESERVED_6));
exceptionSetRoutine(EXCEPTION_RESERVED_7, ACCESS_INTERRUPT(EXCEPTION_RESERVED_7));
exceptionSetRoutine(EXCEPTION_RESERVED_8, ACCESS_INTERRUPT(EXCEPTION_RESERVED_8));
exceptionSetRoutine(EXCEPTION_RESERVED_9, ACCESS_INTERRUPT(EXCEPTION_RESERVED_9));
exceptionSetRoutine(EXCEPTION_RESERVED_10, ACCESS_INTERRUPT(EXCEPTION_RESERVED_10));
exceptionSetRoutine(EXCEPTION_SECURITY, ACCESS_INTERRUPT(EXCEPTION_SECURITY));
exceptionSetRoutine(EXCEPTION_RESERVED_11, ACCESS_INTERRUPT(EXCEPTION_RESERVED_11));
2018-11-13 18:02:47 +01:00
exceptionSetRoutine(EXCEPTION_PAGE_FAULT, pagefault_handler);
2018-07-20 15:41:58 +02:00
// Enabling the HW interrupts
asm volatile("sti\n");
2018-11-08 22:08:27 +01:00
printf("Setting up Serial link (115200)\n");
serialSetup(115200);
allocInit();
2020-04-23 00:49:09 +02:00
kthreadSetup(_stack_bottom, (_stack_top - _stack_bottom + 1));
2020-04-24 00:12:12 +02:00
kthreadCreate("idle", idleThread, NULL);
2020-04-23 00:49:09 +02:00
irqSetRoutine(IRQ_TIMER, pit_handler);
2018-11-08 22:08:27 +01:00
#ifdef RUN_TEST
run_test();
#endif
2020-04-23 23:40:16 +02:00
printf("\nSystem init done\n");
2018-11-08 21:11:45 +01:00
2020-04-23 23:40:16 +02:00
// There is no real caller behind this point
// So finish this by ourself
2020-04-24 00:12:12 +02:00
kthreadExit();
2018-07-20 15:41:58 +02:00
}