Adding a skeleton for the memory management code

Moved the PMM away from being object orientated as it is just plain annoying renamed src folder to source Set timeout to 5 seconds in the grub config
2022-08-21 21:18:53 +02:00
parent e70f56a005
commit 0f0fc9f252
70 changed files with 308 additions and 404 deletions
--- a/source/grub.cfg
+++ b/source/grub.cfg
@ -0,0 +1,3 @@
+menuentry "BarinkOS" {
+    multiboot /boot/myos.bin
+}
--- a/source/kernel/Drivers/PCI/pci.cpp
+++ b/source/kernel/Drivers/PCI/pci.cpp
@ -0,0 +1,108 @@
+#include "pci.h"
+
+uint16_t ConfigReadWord (uint8_t bus, uint8_t slot, uint8_t func, uint8_t offset){
+    uint32_t address;
+    uint32_t lbus = (uint32_t) bus;
+    uint32_t lslot = (uint32_t) slot;
+    uint32_t lfunc = (uint32_t) func;
+    uint16_t tmp = 0;
+
+    /* Create configuration address as per Figure 1 */
+    address = (uint32_t) ((lbus << 16) |  (lslot << 11) | (lfunc << 8) | (offset & 0xFC) |((uint32_t) 0x80000000) );
+    /*write out the address */ 
+    outl(CONFIG_ADDRESS, address);
+    /* read in the data */
+    /* (offset & 2 ) * 8 ) = o will choosse the first word of the 32 bits register*/
+    tmp = (uint16_t)((inl(CONFIG_DATA)) >> ((offset & 2) * 8) & 0xFFFF);
+    return (tmp);
+}
+
+uint16_t CheckVendor (uint8_t bus, uint8_t slot) {
+    uint16_t vendor, device;
+    /* 
+        Try and read the first configuration register. Since there ar no
+        vendors that == 0xFFFF, it must be a non-existent device.
+    */
+   if((vendor = ConfigReadWord(bus, slot, 0,0)) != 0xFFFF) {
+       device = ConfigReadWord(bus, slot, 0,2);
+        // Possible read more config values ...
+   } return (vendor);
+}
+
+void checkDevice (uint8_t bus, uint8_t device ) {
+    uint8_t function = 0;
+
+    uint16_t vendorID = CheckVendor(bus, device);
+    if (vendorID == 0xFFFF) {
+        return;
+    }
+
+    checkFunction (bus, device, function );
+    headerType = getHeaderType(bus, device, function );
+    if( (headerType & 0x80) != 0) {
+        /* It is  a multi-function device, so check remaining functions */
+        for (function = 1; function < 8; function++){
+            if (CheckVendor(bus, device)!= 0xFFFF){
+                checkFunction(bus, device, function );
+            } 
+        }
+    }
+
+}
+
+
+void checkFunction (uint8_t bus, uint8_t device, uint8_t function ){
+    uint8_t baseClass;
+    uint8_t subClass;
+    uint8_t secondaryBus;
+
+    baseClass = getBaseClass(bus, device, function);
+    subClass = getSubClass (bus, device, function );
+    if ( (baseClass == 0x06) && (subClass == 0x04)){
+        secondaryBus = getSecondaryBus(bus,device, function);
+        checkBus(secondaryBus);
+    }
+}
+
+
+// Brute-force scan
+void checkAllBuses (){
+    uint16_t bus;
+    uint8_t device;
+
+    for(bus = 0; bus < 256; bus++){
+        for(device = 0; device < 32; device++){
+            checkDevice(bus,device);
+        }
+    }
+}
+
+// Recursive scan
+void checkBus (uint8_t bus){
+    uint8_t device;
+
+    for(device = 0; device < 32; device ++){
+        checkDevice(bus,device);
+    }
+}
+
+void checkAllBuses(){
+    uint8_t function; 
+    uint8_t bus;
+
+    headerType = getHeaderType(0,0,0);
+    if ( (headerType & 0x80) == 0 ){
+        /* Single PCI host controller */
+        checkBus(0);
+    } else{
+        /* Multiple PCI host controllers */
+        for (function = 0; function < 8; function++){
+            if( CheckVendor(0,0) != 0xFFFF) {
+                break;
+            }
+            bus = function;
+            checkBus(bus);
+        }
+    }
+
+}
--- a/source/kernel/Drivers/PCI/pci.h
+++ b/source/kernel/Drivers/PCI/pci.h
@ -0,0 +1,58 @@
+#pragma once
+#include <stdint.h>
+#include "io.h"
+// Configuration Space Access Mechanism #1
+#define CONFIG_ADDRESS 0xCF8 // Configuration adress that is to be accessed
+#define CONFIG_DATA 0xCFC // Will do the actual configuration operation
+
+/*
+CONFIG_ADDRESS 
+
+32 bit register 
+
+bit 31      Enable bit      (Should CONFIG_DATA be translatedc to configuration cycles)      
+bit 30 - 24 Reserved    
+bit 23 - 16 Bus Number      (Choose a specific PCI BUS)
+bit 15 - 11 Device Number   (Selects specific device one the pci bus)
+bit 10 - 8  Function Number (Selects a specific function in a device)
+bit 7 -  0  Register Offset (Offset in the configuration space of 256 Bytes ) NOTE: lowest two bits will always be zero 
+
+*/
+
+
+/* 
+PCI Device structure
+
+Register    offset  bits 31-24  bits 23-16  bits 15-8   bits 7-0
+00          00      Device ID   <----       Vendor  ID  <-------
+01          04      Status      <----       Command     <-------
+02          08      Class code  Sub class   Prog IF     Revision ID
+03          0C      BIST        Header Type Ltncy Timer Cache line Size
+04          10      Base address #0 (BAR0) 
+05          14      Base address #1 (BAR1) 
+06          18      Base address #2 (BAR2) 
+07          1C      Base address #3 (BAR3)
+08          20      Base address #4 (BAR4)
+09          24      Base address #5 (BAR5)
+0A          28      Cardbus CIS Pointer
+0B          2C      Subsystem ID <------   Subsystem Vendor ID  <-------
+0C          30      Expansion ROM base address
+0D          34      Reserved     <-------   Capabilities Pointer <------
+0E          38      Reserved    <-------    <--------   <--------
+0F          3C      Max ltncy   Min Grant   Interrupt PIN   Interrupt Line
+
+*/
+
+
+/*
+The idea for now is to support the minimal things necessary to find ATA supported drives
+ */
+
+
+// Lets write some boiler plate configuration code
+
+uint16_t ConfigReadWord (uint8_t bus, uint8_t slot, uint8_t func, uint8_t offset);
+
+uint16_t CheckVendor (uint8_t bus, uint8_t slot);
+
+void checkDevice (uint8_t bus, uint8_t device );
--- a/source/kernel/Drivers/PIC/pic.cpp
+++ b/source/kernel/Drivers/PIC/pic.cpp
@ -0,0 +1,62 @@
+#include "pic.h"
+
+extern "C" void PIC_sendEOI (unsigned char irq){
+    if(irq >= 8)
+        outb(PIC2_COMMAND, PIC_EOI);
+    outb(PIC1_COMMAND, PIC_EOI);
+}
+
+/* Helper func */
+static uint16_t __pic_get_irq_reg(int ocw3)
+{
+    /* OCW3 to PIC CMD to get the register values.  PIC2 is chained, and
+     * represents IRQs 8-15.  PIC1 is IRQs 0-7, with 2 being the chain */
+    outb(PIC1_COMMAND, ocw3);
+    outb(PIC2_COMMAND, ocw3);
+    return (inb(PIC2_COMMAND) << 8) | inb(PIC1_COMMAND);
+}
+ 
+/* Returns the combined value of the cascaded PICs irq request register */
+uint16_t pic_get_irr(void)
+{
+    return __pic_get_irq_reg(PIC_READ_IRR);
+}
+ 
+/* Returns the combined value of the cascaded PICs in-service register */
+uint16_t pic_get_isr(void)
+{
+    return __pic_get_irq_reg(PIC_READ_ISR);
+}
+
+
+void PIC_remap (int offset1, int offset2 ){
+    unsigned char a1, a2;
+
+    a1 = inb(PIC1_DATA);
+    a2 = inb(PIC2_DATA);
+
+
+    // Start initialization
+
+    outb(PIC1_COMMAND, ICW1_INIT | ICW1_ICW4);
+    io_wait();
+    outb(PIC2_COMMAND, ICW1_INIT | ICW1_ICW4);
+    io_wait();
+    outb(PIC1_DATA, offset1);
+    io_wait();
+    outb(PIC2_DATA, offset2);
+    io_wait();
+    outb(PIC1_DATA, 4);
+    io_wait();
+    outb(PIC2_DATA, 2);
+    io_wait();
+
+    outb(PIC1_DATA, ICW4_8086);
+    io_wait();
+    outb(PIC2_DATA, ICW4_8086);
+    io_wait();
+
+    outb(PIC1_DATA, a1);
+    outb(PIC2_DATA, a2);
+
+}
--- a/source/kernel/Drivers/PIC/pic.h
+++ b/source/kernel/Drivers/PIC/pic.h
@ -0,0 +1,57 @@
+#pragma once 
+#include "../../io.h"
+
+#define PIC1		0x20		/* IO base address for master PIC */
+#define PIC2		0xA0		/* IO base address for slave PIC */
+#define PIC1_COMMAND	PIC1
+#define PIC1_DATA	(PIC1+1)
+#define PIC2_COMMAND	PIC2
+#define PIC2_DATA	(PIC2+1)
+
+
+#define ICW1_ICW4	0x01		/* ICW4 (not) needed */
+#define ICW1_SINGLE	0x02		/* Single (cascade) mode */
+#define ICW1_INTERVAL4	0x04		/* Call address interval 4 (8) */
+#define ICW1_LEVEL	0x08		/* Level triggered (edge) mode */
+#define ICW1_INIT	0x10		/* Initialization - required! */
+ 
+#define ICW4_8086	0x01		/* 8086/88 (MCS-80/85) 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) */
+
+#define PIC_EOI 0x20
+#define PIC_READ_IRR 0x0a    /* OCW3 irq ready next CMD read */
+#define PIC_READ_ISR 0x0b    /* OCW3 irq service next CMD read */
+
+extern "C"{
+
+extern void irq0 ();
+extern void irq1 ();
+extern void irq2 ();
+extern void irq3 ();
+extern void irq4 ();
+extern void irq5 ();
+extern void irq6 ();
+extern void irq7 ();
+extern void irq8 ();
+extern void irq9 ();
+extern void irq10 ();
+extern void irq11 ();
+extern void irq12 ();
+extern void irq13 ();
+extern void irq14 ();
+extern void irq15 ();
+
+void PIC_sendEOI (unsigned char irq);
+
+}
+
+
+//static uint16_t __pic_get_irq_reg(int ocw3);
+uint16_t pic_get_irr(void);
+uint16_t pic_get_isr(void);
+
+
+void PIC_remap (int offset1, int offset2 );
--- a/source/kernel/Drivers/PIT/pit.cpp
+++ b/source/kernel/Drivers/PIT/pit.cpp
@ -0,0 +1,54 @@
+#include "pit.h"
+#include "../../Terminal/kterm.h"
+uint32_t pit_tick = 0;
+
+
+void pit_initialise()
+{
+    asm volatile("CLI");
+
+#ifdef __VERBOSE__
+    printf("Init PIT!\n");
+#endif
+    // clear mask for IRQ 0 
+    uint8_t value = inb(0x21) & ~(1<< 0);
+    outb(0x21, value);
+
+    io_wait();
+
+    const int freq = 500;
+
+    uint32_t divisor = 1193180 / freq;
+
+    outb(PIT_COMMAND, 0x36);
+
+    uint8_t l = (uint8_t) (divisor & 0xFF);
+    uint8_t h = (uint8_t) ( (divisor>>8) & 0xff);
+
+    outb(PIT_DATA_0, l);
+    outb(PIT_DATA_0,h);
+
+
+    asm volatile("STI");
+}
+
+
+void get_pit_count()
+{
+    asm volatile ("CLI");
+
+    outb(PIT_COMMAND, 0);
+    uint16_t count = inb(PIT_DATA_0);
+    count |= inb(PIT_DATA_0) << 8;
+
+    printf("PIT count: 0x%x\n", count); 
+
+    asm volatile("STI");   
+
+}
+
+void set_pit_count()
+{
+
+}
+
--- a/source/kernel/Drivers/PIT/pit.h
+++ b/source/kernel/Drivers/PIT/pit.h
@ -0,0 +1,18 @@
+#pragma once 
+#include <stdint.h>
+#include "../../io.h"
+#define PIT_DATA_0 0x40
+#define PIT_DATA_1 0x41
+#define PIT_DATA_2 0x42
+#define PIT_COMMAND 0x43
+
+
+extern uint32_t pit_tick;
+
+
+void pit_initialise();
+
+
+void get_pit_count();
+
+void set_pit_count();
--- a/source/kernel/Drivers/PS-2/keyboard.cpp
+++ b/source/kernel/Drivers/PS-2/keyboard.cpp
@ -0,0 +1,51 @@
+#include "keyboard.h"
+
+KeyPressInfo keyPress {};
+
+void KeyHandled(){
+    keyPress.ScanCode= 0x00;
+    keyPress.PressedModifiers = 0x00;
+}
+
+
+char getASCIIKey(){
+    char keyPressed;
+    // Wait until a key is pressed  
+    while(keyPress.ScanCode == 0x00) {
+        asm volatile ("NOP");
+    }
+
+    
+    // Translate keycode to ascii 
+    // Probably a lookup table might be handy 
+    // Until 0x37
+     const char* ASCIILookUp =
+      "\01234567890-=\0\0QWERTYUIOP[]\0\0ASDFGHJKL;\'`\0\\ZXCVBNM,./\0"; 
+     
+     uint8_t ASCII_Index = keyPress.ScanCode - 3  ;
+     //printf("ASCII_INDEX: %x\n", ASCII_Index);
+     keyPressed = ASCIILookUp[ASCII_Index];
+
+    KeyHandled();
+
+    return keyPressed;
+}
+
+
+
+uint8_t getKey(){
+    // Wait until a key is pressed 
+    while(keyPress.ScanCode == 0x00){
+        asm volatile ("NOP");
+    }
+    
+    if( keyPress.ScanCode > 0x37){
+        keyPress.ScanCode = 0x00;
+        return 0;
+    }
+
+    uint8_t ScanCode = keyPress.ScanCode;
+   // KeyHandled();
+
+    return  ScanCode ;
+}
--- a/source/kernel/Drivers/PS-2/keyboard.h
+++ b/source/kernel/Drivers/PS-2/keyboard.h
@ -0,0 +1,34 @@
+#pragma once
+#include <stdint.h>
+#include "../../Terminal/kterm.h"
+typedef enum ScanCodeSet{
+    None            =   0,
+    ScanCodeSet1    =   1,
+    ScanCodeSet2    =   2,
+    ScanCodeSet3    =   3,
+};
+
+typedef enum Modifiers{
+    LSHIFT  =   1,
+    RSHIFT  =   2,
+
+    LCTRL   =   3,
+    RCTRL   =   4,
+
+    LALT    =   5,
+    RALT    =   6
+};
+
+struct KeyPressInfo{ 
+    uint8_t PressedModifiers;
+    uint8_t ScanCode;
+};
+
+
+
+extern KeyPressInfo keyPress;
+
+void KeyHandled();
+
+char getASCIIKey();
+uint8_t getKey();
--- a/source/kernel/Drivers/Serial/serial.cpp
+++ b/source/kernel/Drivers/Serial/serial.cpp
@ -0,0 +1,19 @@
+#include "serial.h"
+
+Serial Serial::init() {
+    // No clue what to setup yet!
+
+    return Serial();
+}
+
+void Serial::print(){
+    // Do nothing!
+}
+
+Serial::Serial(){
+    // Do nothing!
+}
+
+Serial::~Serial(){
+    // Do nothing!
+}
--- a/source/kernel/Drivers/Serial/serial.h
+++ b/source/kernel/Drivers/Serial/serial.h
@ -0,0 +1,19 @@
+#pragma once
+
+class Serial {
+
+    public: 
+        static Serial init();
+        
+        void print();
+
+    private: 
+        const int COM1 = 0x3F8;
+        const int COM2 = 0x2F8;
+        const int COM3 = 0x3E8;
+        const int COM4 = 0x2E8;
+
+
+        Serial();
+        ~Serial();
+};
--- a/source/kernel/Drivers/VGA/VBE.h
+++ b/source/kernel/Drivers/VGA/VBE.h
@ -0,0 +1,41 @@
+
+#define VBE_DISPI_IOPORT_INDEX 0x01CE
+#define VBE_DISPI_IOPORT_DATA 0x01CF
+
+/* VBE index values*/
+#define VBE_DISPI_INDEX_ID              0x0
+#define VBE_DISPI_INDEX_XRES            0x1
+#define VBE_DISPI_INDEX_YRES            0x2
+#define VBE_DISPI_INDEX_BPP             0x3
+#define VBE_DISPI_INDEX_ENABLE          0x4
+#define VBE_DISPI_INDEX_BANK            0x5
+#define VBE_DISPI_INDEX_VIRT_WIDTH      0x6
+#define VBE_DISPI_INDEX_VIRT_HEIGHT     0x7
+#define VBE_DISPI_INDEX_X_OFFSET        0x8
+#define VBE_DISPI_INDEX_Y_OFFSET        0x9
+
+/* BGA Version */
+#define VBE_DISPI_ID5   0xB0C5
+#define VBE_DISPI_ID4   0xB0C3 
+#define VBE_DISPI_ID3   0xB0C2
+#define VBE_DISPI_ID2   0xB0C1
+#define VBE_DISPI_ID1   0xB0C0
+
+
+/* BGA BIT DEPTH */
+#define VBE_DISPI_BPP_4 0x04
+#define VBE_DISPI_BPP_8 0x08
+#define VBE_DISPI_BPP_15 0x0F
+#define VBE_DISPI_BPP_16 0x10
+#define VBE_DISPI_BPP_24 0x18
+#define VBE_DISPI_BPP_32 0x20
+
+
+    /*unsigned short BGAReadRegister(unsigned short IndexValue){
+        // outpw(VBE_DISPI_IOPORT_INDEX, IndexValue);
+       // return inpw (VBE_DISPI_IOPORT_DATA);
+    }
+
+    int BGAIsAvailable (){
+        return (BGAReadRegister(VBE_DISPI_INDEX_ID) == VBE_DISPI_ID5);
+    }*/
--- a/source/kernel/Drivers/VGA/colors.h
+++ b/source/kernel/Drivers/VGA/colors.h
@ -0,0 +1,19 @@
+#pragma once 
+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,
+};
--- a/source/kernel/Drivers/cmos/cmos.cpp
+++ b/source/kernel/Drivers/cmos/cmos.cpp
@ -0,0 +1,38 @@
+void ReadFromCMOS(unsigned char array[])
+{
+    unsigned char tvalue, index;
+
+    for (index = 0; index < 128; index++)
+    {
+        asm(
+            "cli\n\t"           // Disable interrupts
+            "mov al, index\n\t" // Move index address
+            // since the 0x80 bit of al is not set, NMI is active 
+            "out 0x70,al\n\t" // Copy address to CMOS register
+            // some kind of real delay here is probably best 
+            "in al,0x71\n\t" // Fetch 1 byte to al
+            "sti\n\t"        // Enable interrupts
+            "mov tvalue,al\n\t");
+
+        array[index] = tvalue;
+    }
+}
+
+void WriteTOCMOS(unsigned char array[])
+{
+   unsigned char index;
+ 
+   for(index = 0; index < 128; index++)
+   {
+      unsigned char tvalue = array[index];
+      
+       asm("cli\n\t"       // Clear interrupts
+         "mov al,index\n\t"    // move index address
+         "out 0x70,al\n\t"     // copy address to CMOS register
+         // some kind of real delay here is probably best 
+         "mov al,tvalue\n\t"   // move value to al
+         "out 0x71,al\n\t"   // write 1 byte to CMOS
+         "sti\n\\t"   );        // Enable interrupts
+      
+   }
+}
--- a/source/kernel/FileSystem/FAT/FAT16.cpp
+++ b/source/kernel/FileSystem/FAT/FAT16.cpp
--- a/source/kernel/FileSystem/FAT/FAT16.h
+++ b/source/kernel/FileSystem/FAT/FAT16.h
@ -0,0 +1,8 @@
+#pragma once
+#include "../../vfs/File.h"
+
+
+class FAT16 : File  {
+public:
+    
+};
--- a/source/kernel/Interrupts/idt/idt.cpp
+++ b/source/kernel/Interrupts/idt/idt.cpp
@ -0,0 +1,395 @@
+#include "idt.h"
+#include "../../Drivers/PIT/pit.h"
+#include "../../Drivers/PS-2/keyboard.h"
+#include "../../cpu.h"
+IDT_entry idt_table[256];
+IDT_ptr idt_ptr;
+
+
+void set_id_entry (uint8_t num , uint32_t base, uint16_t sel,  uint8_t flags){
+    idt_table[num].offset_1 = base & 0xFFFF;
+    idt_table[num].selector = sel;
+    idt_table[num].zero = 0;
+    idt_table[num].type_attr = flags;
+    idt_table[num].offset_2 = (base >> 16) & 0xFFFF;
+
+};
+
+void irs_handler (registers regs) {
+     uint32_t FaultingAddress;
+        //printf("(IRS) Interrupt number: %d \r", regs.int_no);
+        switch (regs.int_no)
+        {
+        case 0:
+            // Divide Error #DE
+            printf("#DE\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp);
+        break;
+        
+        case 1:
+            // Debug Exception #DB
+            printf("#DB\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp);
+        break;
+
+        case 2:
+            // NMI Interrupt 
+            printf("#NMI\n");
+        break;
+        
+        case 3:
+            // Breakpoint Exception #BP
+            printf("#BP\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp);
+        break;
+        
+        case 4:
+            // Overflow Exception #OF
+            printf("#OF\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp);
+        break;
+        
+        case 5:
+            // BOUND Range Exceeded Exception #BR
+            printf("#BR\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp);
+        break;
+        
+        case 6:
+            // Invalid OpCode Exception #UD 
+            printf("#UD\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp);
+        break;
+        
+        case 7:
+            // Device Not Available Exception  #NM
+            printf("#NM\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp);
+        break;
+        
+        case 8:
+            // Double Fault Exception #DF
+            printf("#DF\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp);
+        break;
+
+        case 9:
+            // Coprocessor Segment Overrun
+            printf("Coprocessor Segment overrun!\n");
+        break;
+        
+        case 10:
+            // Invalid TSS Exception #TS
+            printf("#TS\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp);
+        break;
+
+        case 11:
+            // Segment Not Present #NP
+            printf("#NP\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp);
+        break;
+        
+        case 12:
+            // Stack Fault Exception #SS
+            printf("#SS\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp);
+        break;
+        
+        case 13:
+            // General Protection Exception #GP
+            printf("#GP\n");
+
+            printf("Accessing memory caused a general protectuion exception.\n");
+            
+            printf("Fault due to entry at index: %d", (regs.err_code >> 3 & 0xFFF ) );
+
+            if(regs.err_code & 0x3 >> 1 == 0   ){
+                printf("* Index references GDT");
+            }
+            if(regs.err_code & 0x3 >> 1 == 1  ){
+                printf("* Index references IDT");
+            }
+
+            if(regs.err_code & 0x3 >> 1 == 2   ){
+                printf("* Index references LDT");
+            }
+
+            if(regs.err_code & 0x3 >> 1 == 4  ){
+                printf("* Index references IDT");
+            }
+
+            if( regs.err_code & 0x1)
+            {
+                printf("* Originated externally!");
+            }
+
+            __asm__("cli;" "1: hlt;" "jmp 1b;");
+
+        break;
+        
+        case 14:
+            // Page Fault Exception #PF
+            printf("#PF\n");
+
+            FaultingAddress = GetCR2();
+            printf("Accessing the linear address 0x%x resulted in a page fault!\n\n", FaultingAddress);
+        
+            // Error code of 32 bits are on the stack
+            // CR2 register contains the 32-bit linear virtual address that generated the exception
+            // See Intel Software Developers manual Volume 3A Part 1 page 236 for more info
+            #define PF_ERR_PRESENT_BIT 0x1
+            #define PF_ERR_WRITE_BIT 0x2
+            #define PF_ERR_USER_BIT 0x3
+            #define PF_ERR_RESERVERD_WRITE_BIT 0x4
+            #define PF_ERR_INSTRUCTION_FETCH_BIT 0x5
+            #define PF_ERR_PROTECTION_KEY_BIT 0x6
+            #define PF_ERR_SHADOW_STACK_BIT 0x7
+            #define PF_ERR_SOFTWARE_GUARD_EXTENSION_BIT 0xE
+
+            printf("REASON: \n\n");
+
+         
+            if (regs.err_code & PF_ERR_PRESENT_BIT ){
+                printf("* Page protection violation!\n");
+            } else{
+                printf("* Page not-present!\n");
+            }
+
+            if(regs.err_code & PF_ERR_WRITE_BIT){
+                printf("* Write access violation!\n");
+            } else{
+                printf("* Read access violation!\n");
+            }
+
+            if(regs.err_code & PF_ERR_USER_BIT){
+                printf("* Violation from user-space (CPL=3)\n");
+            }
+
+            if(regs.err_code & PF_ERR_INSTRUCTION_FETCH_BIT){
+                printf("* Caused by an instruction fetch. \n");
+            }
+
+            /*
+                Check the error code to figure out what happened here
+            */
+            __asm__("cli;" "1: hlt;" "jmp 1b;");
+
+
+            
+    
+        break;
+        
+        case 16:
+            // x87 FPU Floating-point Error #MF
+            printf("#MF\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp);
+        break;
+        
+        case 17:
+            // Alignment Check Exception #AC
+            printf("#AC\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp); 
+        break;
+        
+        case 18:
+            // Machine-Check Exception #MC
+            printf("#MC\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp); 
+        break;
+        
+        case 19:
+            // SIMD Floating-point Exception #XM
+            printf("#XM\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp); 
+        break;
+        
+        case 20:
+             // Virtualization Exception #VE
+            printf("#VE\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp); 
+        break;
+        
+        case 21:
+             // Control Protection Exception #CP
+            printf("#CP\n");
+            printf("EIP: 0x%x\n", regs.eip);
+            printf("EAX: 0x%x\n", regs.eax);
+            printf("EBP: 0x%x\n", regs.ebp); 
+        break;
+
+        default:
+            // PANIC!!!
+            break;
+        }
+
+      
+        
+}
+
+void irq_handler (registers regs) {
+
+    
+
+    switch (regs.int_no) {
+    case 0:
+            pit_tick++;
+        break;
+    case 1:
+        // Keyboard interrupt !!
+
+        int scan;
+        int i;/*register*/
+
+        // Read scancode 
+        scan = inb(0x60);
+        
+        // Send ack message!
+        i = inb(0x61);
+        outb(0x61, i|0x80);
+        outb(0x61, i);
+
+        // NOTE: check for special scan codes 
+        // e.g. modifiers etc..
+        if( scan < 0x37){
+            //printf("Read from IO: 0x%x\n", scan);
+            keyPress.ScanCode = scan ;
+            //printf( "[From Interrupt] Scancode: %x\n", keyPress.ScanCode);
+
+        }
+
+        
+        break;    
+    case 12:
+        // PS2 Mouse interrupt 
+        printf("Mouse event triggered!");
+        //int event = inb(0x60);
+        break;
+
+    default:
+        printf("Interrupt happened!");
+        printf("Received INT: 0x%x\n", regs.int_no);
+        break;
+    }        
+
+    outb(0x20, 0x20); // send end of interrupt to master
+
+    if ( regs.int_no > 8 && regs.int_no <= 15) {
+        outb(0xA0, 0x20); // send end of interrupt to slave 
+    }
+    
+    
+    if( regs.int_no == 13){
+        printf(" Error code: %d \n", regs.err_code);
+
+    }
+
+}
+
+void init_idt(){
+    // Initialise the IDT pointer
+    idt_ptr.length = sizeof(IDT_entry) * 255;
+    idt_ptr.base = (uint32_t)&idt_table;
+
+#ifdef __VERBOSE__
+    printf("Init IDT\n");
+#endif
+
+    // TODO: Set everything to zero first
+
+    set_id_entry(0,  (uint32_t) irs0 , 0x08, 0x8F);
+    set_id_entry(1,  (uint32_t) irs1 , 0x08, 0x8E);
+    set_id_entry(2,  (uint32_t) irs2 , 0x08, 0x8E);
+    set_id_entry(3,  (uint32_t) irs3 , 0x08, 0x8E);
+    set_id_entry(4,  (uint32_t) irs4 , 0x08, 0x8E);
+    set_id_entry(5,  (uint32_t) irs5 , 0x08, 0x8E);
+    set_id_entry(6,  (uint32_t) irs6 , 0x08, 0x8E);
+    set_id_entry(7,  (uint32_t) irs7 , 0x08, 0x8E);
+    set_id_entry(8,  (uint32_t) irs8 , 0x08, 0x8E);
+    set_id_entry(9,  (uint32_t) irs9 , 0x08, 0x8E);
+    set_id_entry(10, (uint32_t) irs10 , 0x08, 0x8E);
+    set_id_entry(11, (uint32_t) irs11 , 0x08, 0x8E);
+    set_id_entry(12, (uint32_t) irs12 , 0x08, 0x8E);
+    set_id_entry(13, (uint32_t) irs13 , 0x08, 0x8E);
+    set_id_entry(14, (uint32_t) irs14 , 0x08, 0x8E);
+    set_id_entry(15, (uint32_t) irs15 , 0x08, 0x8E);
+    set_id_entry(16, (uint32_t) irs16 , 0x08, 0x8E);
+    set_id_entry(17, (uint32_t) irs17 , 0x08, 0x8E);
+    set_id_entry(18, (uint32_t) irs18 , 0x08, 0x8E);
+    set_id_entry(19, (uint32_t) irs19 , 0x08, 0x8E); 
+    set_id_entry(20, (uint32_t) irs20 , 0x08, 0x8E);
+    set_id_entry(21, (uint32_t) irs21 , 0x08, 0x8E);
+    set_id_entry(22, (uint32_t) irs22 , 0x08, 0x8E);
+    set_id_entry(23, (uint32_t) irs23 , 0x08, 0x8E);
+    set_id_entry(24, (uint32_t) irs24 , 0x08, 0x8E);
+    set_id_entry(25, (uint32_t) irs25 , 0x08, 0x8E);
+    set_id_entry(26, (uint32_t) irs26 , 0x08, 0x8E);
+    set_id_entry(27, (uint32_t) irs27 , 0x08, 0x8E); 
+    set_id_entry(28, (uint32_t) irs28 , 0x08, 0x8E);
+    set_id_entry(29, (uint32_t) irs29 , 0x08, 0x8E);
+    set_id_entry(30, (uint32_t) irs30 , 0x08, 0x8E);
+    set_id_entry(31, (uint32_t) irs31 , 0x08, 0x8E);
+
+
+    //print_serial("Remapping PIC\n");
+    PIC_remap(0x20, 0x28);
+
+    // clear mask for IRQ 12
+    uint8_t value = inb(0x21) & ~(1<< 12);
+    outb(0x21, value);
+
+
+
+    // pic IRQ Table
+    set_id_entry(32, (uint32_t)irq0, 0x08, 0x8E);
+    set_id_entry(33, (uint32_t)irq1, 0x08, 0x8E); // PS2 Keyboard
+    set_id_entry(34, (uint32_t)irq2, 0x08, 0x8E);
+    set_id_entry(35, (uint32_t)irq3, 0x08, 0x8E);
+    set_id_entry(36, (uint32_t)irq4, 0x08, 0x8E);
+    set_id_entry(37, (uint32_t)irq5, 0x08, 0x8E);
+    set_id_entry(38, (uint32_t)irq6, 0x08, 0x8E);
+    set_id_entry(39, (uint32_t)irq7, 0x08, 0x8E);
+    set_id_entry(40, (uint32_t)irq8, 0x08, 0x8E);
+    set_id_entry(41, (uint32_t)irq9, 0x08, 0x8E);
+    set_id_entry(42, (uint32_t)irq10, 0x08, 0x8E);
+    set_id_entry(43, (uint32_t)irq11, 0x08, 0x8E);
+    set_id_entry(44, (uint32_t)irq12, 0x08, 0x8E); // PS2 Mouse
+    set_id_entry(45, (uint32_t)irq13, 0x08, 0x8E);
+    set_id_entry(46, (uint32_t)irq14, 0x08, 0x8E);
+    set_id_entry(47, (uint32_t)irq15, 0x08, 0x8E);
+
+    
+    idt_flush((uint32_t)&idt_ptr);
+}
--- a/source/kernel/Interrupts/idt/idt.h
+++ b/source/kernel/Interrupts/idt/idt.h
@ -0,0 +1,77 @@
+#pragma once
+
+#include "stdint.h"
+#include "stddef.h"
+#include "../../Drivers/VGA/colors.h"
+#include "../../Drivers/PIC/pic.h"
+
+#include "../../Terminal/kterm.h"
+
+
+extern "C" {
+    struct __attribute__((__packed__)) IDT_entry {
+        uint16_t offset_1;
+        uint16_t selector;
+        uint8_t zero;
+        uint8_t type_attr;
+        uint16_t offset_2;
+    };
+
+    struct __attribute__((__packed__)) IDT_ptr {
+        unsigned short length;
+        unsigned long base;
+    };
+
+    struct registers {
+        uint32_t ds;                  // Data segment selector
+        uint32_t edi, esi, ebp, esp, ebx, edx, ecx, eax; // Pushed by pusha.
+        uint32_t int_no, err_code;    // Interrupt number and error code (if applicable)
+        uint32_t eip, cs, eflags, useresp, ss; 
+    };
+
+
+    extern void idt_flush(uint32_t); 
+    void set_id_entry (uint8_t num , uint32_t base, uint16_t sel,  uint8_t flags);
+    void init_idt();
+
+    void irq_handler (registers regs);
+
+    void irs_handler (registers regs);
+
+    extern void irs0 ();
+    extern void irs1 ();
+    extern void irs2 ();
+    extern void irs3 ();
+    extern void irs4 ();
+    extern void irs5 ();
+    extern void irs6 ();
+    extern void irs7 ();
+    extern void irs8 ();
+    extern void irs9 ();
+    extern void irs10 ();
+    extern void irs11 ();
+    extern void irs12 ();
+    extern void irs13 ();
+    extern void irs14 ();
+    extern void irs15 ();
+    extern void irs16 ();
+    extern void irs17 ();
+    extern void irs18 ();
+    extern void irs19 ();
+    extern void irs20 ();
+    extern void irs21 ();
+    extern void irs22 ();
+    extern void irs23 ();
+    extern void irs24 ();
+    extern void irs25 ();
+    extern void irs26 ();
+    extern void irs27 ();
+    extern void irs28 ();
+    extern void irs29 ();
+    extern void irs30 ();
+    extern void irs31 ();
+
+
+
+
+}
--- a/source/kernel/Interrupts/idt/idt.s
+++ b/source/kernel/Interrupts/idt/idt.s
@ -0,0 +1,6 @@
+
+.globl idt_flush
+idt_flush:
+	mov 4(%esp), %eax
+	lidt (%eax)
+	ret
--- a/source/kernel/Interrupts/idt/scancodes/set1.h
+++ b/source/kernel/Interrupts/idt/scancodes/set1.h
@ -0,0 +1,184 @@
+#pragma once 
+
+
+
+
+
+
+// ScanCode set 1 
+int ScanCodeToKeyCode [0xD8];
+
+/* key pressed scancode */ 
+ScanCodeToKeyCode[0x01] = 4017;   // escape pressed
+ScanCodeToKeyCode[0x02] = 4018;   // 1 pressed
+ScanCodeToKeyCode[0x03] = 4019;   // 2 pressed
+ScanCodeToKeyCode[0x04] = 4020;   // 3 pressed
+ScanCodeToKeyCode[0x05] =""   // 4 pressed	
+ScanCodeToKeyCode[0x06] =""   // 5 pressed
+ScanCodeToKeyCode[0x07] =""   // 6 pressed
+ScanCodeToKeyCode[0x08] =""   // 7 pressed
+ScanCodeToKeyCode[0x09] =""   // 8 pressed	
+ScanCodeToKeyCode[0x0A] =""   // 9 pressed	
+ScanCodeToKeyCode[0x0B] =""   // 0 (zero) pressed
+ScanCodeToKeyCode[0x0C] =""   // - pressed
+ScanCodeToKeyCode[0x0D] =""   // = pressed	
+ScanCodeToKeyCode[0x0E] =""   // backspace pressed
+ScanCodeToKeyCode[0x0F] =""   // tab pressed
+ScanCodeToKeyCode[0x10] =""  	// Q pressed
+ScanCodeToKeyCode[0x11] =""   // W pressed	
+ScanCodeToKeyCode[0x12] ="" 	// E pressed
+ScanCodeToKeyCode[0x13] ="" 	// R pressed
+ScanCodeToKeyCode[0x14] ="" 	// T pressed
+ScanCodeToKeyCode[0x15] ="" 	// Y pressed	
+ScanCodeToKeyCode[0x16] ="" 	// U pressed
+ScanCodeToKeyCode[0x17] ="" 	// I pressed
+ScanCodeToKeyCode[0x18] ="" 	// O pressed
+ScanCodeToKeyCode[0x19] ="" 	// P pressed	
+ScanCodeToKeyCode[0x1A] =""   // [ pressed
+ScanCodeToKeyCode[0x1B] =""   // ] pressed
+ScanCodeToKeyCode[0x1C] =""   // enter pressed
+ScanCodeToKeyCode[0x1D] =""   // left control pressed
+ScanCodeToKeyCode[0x1E] ="" 	// A pressed
+ScanCodeToKeyCode[0x1F] ="" 	// S pressed
+ScanCodeToKeyCode[0x20] ="" 	// D pressed
+ScanCodeToKeyCode[0x21] ="" 	// F pressed
+ScanCodeToKeyCode[0x22] ="" 	// G pressed
+ScanCodeToKeyCode[0x23] ="" 	// H pressed
+ScanCodeToKeyCode[0x24] ="" 	// J pressed
+ScanCodeToKeyCode[0x25] ="" 	// K pressed
+ScanCodeToKeyCode[0x26] ="" 	// L pressed
+ScanCodeToKeyCode[0x27] =""   //  ; pressed
+ScanCodeToKeyCode[0x28] =""   // ' (single quote) pressed
+ScanCodeToKeyCode[0x29] =""   // ` (back tick) pressed
+ScanCodeToKeyCode[0x2A] =""   // left shift pressed	
+ScanCodeToKeyCode[0x2B] =""   // \ pressed
+ScanCodeToKeyCode[0x2C] ="" 	// Z pressed
+ScanCodeToKeyCode[0x2D] ="" 	// X pressed
+ScanCodeToKeyCode[0x2E] ="" 	// C pressed	
+ScanCodeToKeyCode[0x2F] ="" 	// V pressed
+ScanCodeToKeyCode[0x30] ="" 	// B pressed
+ScanCodeToKeyCode[0x31] ="" 	// N pressed
+ScanCodeToKeyCode[0x32] ="" 	// M pressed
+ScanCodeToKeyCode[0x33] =""   // , pressed
+ScanCodeToKeyCode[0x34] =""   // . pressed
+ScanCodeToKeyCode[0x35] =""   // / pressed
+ScanCodeToKeyCode[0x36] =""   // right shift pressed
+ScanCodeToKeyCode[0x37] =""   // (keypad) * pressed
+ScanCodeToKeyCode[0x38] =""   // left alt pressed	
+ScanCodeToKeyCode[0x39] =""   // space pressed	
+ScanCodeToKeyCode[0x3A] =""   // CapsLock pressed
+ScanCodeToKeyCode[0x3B] =""   // F1 pressed
+ScanCodeToKeyCode[0x3C] =""   // F2 pressed
+ScanCodeToKeyCode[0x3D] =""   // F3 pressed
+ScanCodeToKeyCode[0x3E] ="" 	// F4 pressed
+ScanCodeToKeyCode[0x3F] ="" 	// F5 pressed
+ScanCodeToKeyCode[0x40] ="" 	// F6 pressed
+ScanCodeToKeyCode[0x41] ="" 	// F7 pressed
+ScanCodeToKeyCode[0x42] ="" 	// F8 pressed
+ScanCodeToKeyCode[0x43] ="" 	// F9 pressed
+ScanCodeToKeyCode[0x44] ="" 	// F10 pressed
+ScanCodeToKeyCode[0x45] ="" 	// NumberLock pressed
+ScanCodeToKeyCode[0x46] ="" 	// ScrollLock pressed
+ScanCodeToKeyCode[0x47] ="" 	// (keypad) 7 pressed
+ScanCodeToKeyCode[0x48] ="" 	// (keypad) 8 pressed
+ScanCodeToKeyCode[0x49] ="" 	// (keypad) 9 pressed
+ScanCodeToKeyCode[0x4A] ="" 	// (keypad) - pressed
+ScanCodeToKeyCode[0x4B] ="" 	// (keypad) 4 pressed
+ScanCodeToKeyCode[0x4C] ="" 	// (keypad) 5 pressed
+ScanCodeToKeyCode[0x4D] ="" 	// (keypad) 6 pressed
+ScanCodeToKeyCode[0x4E] ="" 	// (keypad) + pressed
+ScanCodeToKeyCode[0x4F] ="" 	// (keypad) 1 pressed
+ScanCodeToKeyCode[0x50] ="" 	// (keypad) 2 pressed
+ScanCodeToKeyCode[0x51] ="" 	// (keypad) 3 pressed
+ScanCodeToKeyCode[0x52] ="" 	// (keypad) 0 pressed
+ScanCodeToKeyCode[0x53] ="" 	// (keypad) . pressed
+ScanCodeToKeyCode[0x57] ="" 	// F11 pressed
+ScanCodeToKeyCode[0x58] ="" 	// F12 pressed						
+
+
+/* key released scanCode.""*/
+ScanCodeToKeyCode[0x81] ="" 	// escape released
+ScanCodeToKeyCode[0x82] ="" 	// 1 released
+ScanCodeToKeyCode[0x83] ="" 	// 2 released
+ScanCodeToKeyCode[0x84] ="" 	// 3 released
+ScanCodeToKeyCode[0x85] ="" 	// 4 released
+ScanCodeToKeyCode[0x86] ="" 	// 5 released
+ScanCodeToKeyCode[0x87] ="" 	// 6 released
+ScanCodeToKeyCode[0x88] ="" 	// 7 released
+ScanCodeToKeyCode[0x89] ="" 	// 8 released
+ScanCodeToKeyCode[0x8A] ="" 	// 9 released
+ScanCodeToKeyCode[0x8B] ="" 	// 0 (zero) released
+ScanCodeToKeyCode[0x8C] ="" 	// - released
+ScanCodeToKeyCode[0x8D] ="" 	// = released
+ScanCodeToKeyCode[0x8E] ="" 	// backspace released
+ScanCodeToKeyCode[0x8F] ="" 	// tab released
+ScanCodeToKeyCode[0x90] ="" 	// Q released
+ScanCodeToKeyCode[0x91] ="" 	// W released
+ScanCodeToKeyCode[0x92] ="" 	// E released
+ScanCodeToKeyCode[0x93] ="" 	// R released
+ScanCodeToKeyCode[0x94] ="" 	// T released
+ScanCodeToKeyCode[0x95] ="" 	// Y released	
+ScanCodeToKeyCode[0x96] ="" 	// U released
+ScanCodeToKeyCode[0x97] ="" 	// I released
+ScanCodeToKeyCode[0x98] ="" 	// O released	
+ScanCodeToKeyCode[0x99] ="" 	// P released
+ScanCodeToKeyCode[0x9A] ="" 	// [ released	
+ScanCodeToKeyCode[0x9B] ="" 	// ] released
+ScanCodeToKeyCode[0x9C] ="" 	// enter released
+ScanCodeToKeyCode[0x9D] ="" 	// left control released
+ScanCodeToKeyCode[0x9E] ="" 	// A released
+ScanCodeToKeyCode[0x9F] ="" 	// S released
+ScanCodeToKeyCode[0xA0] ="" 	// D released
+ScanCodeToKeyCode[0xA1] ="" 	// F released
+ScanCodeToKeyCode[0xA2] ="" 	// G released
+ScanCodeToKeyCode[0xA3] ="" 	// H released
+ScanCodeToKeyCode[0xA4] ="" 	// J released
+ScanCodeToKeyCode[0xA5] ="" 	// K released
+ScanCodeToKeyCode[0xA6] ="" 	// L released
+ScanCodeToKeyCode[0xA7] ="" 	//  ; released
+ScanCodeToKeyCode[0xA8] ="" 	// ' (single quote) released
+ScanCodeToKeyCode[0xA9] ="" 	// ` (back tick) released
+ScanCodeToKeyCode[0xAA] ="" 	// left shift released
+ScanCodeToKeyCode[0xAB] ="" 	// \ released
+ScanCodeToKeyCode[0xAC] ="" 	// Z released	
+ScanCodeToKeyCode[0xAD] ="" 	// X released	
+ScanCodeToKeyCode[0xAE] ="" 	// C released	
+ScanCodeToKeyCode[0xAF] ="" 	// V released
+ScanCodeToKeyCode[0xB0] ="" 	// B released	
+ScanCodeToKeyCode[0xB1] ="" 	// N released	
+ScanCodeToKeyCode[0xB2] ="" 	// M released	
+ScanCodeToKeyCode[0xB3] ="" 	// , released
+ScanCodeToKeyCode[0xB4] ="" 	// . released	
+ScanCodeToKeyCode[0xB5] ="" 	// / released	
+ScanCodeToKeyCode[0xB6] ="" 	// right shift released
+ScanCodeToKeyCode[0xB7] ="" 	// (keypad) * released
+ScanCodeToKeyCode[0xB8] ="" 	// left alt released	
+ScanCodeToKeyCode[0xB9] ="" 	// space released	
+ScanCodeToKeyCode[0xBA] ="" 	// CapsLock released	
+ScanCodeToKeyCode[0xBB] ="" 	// F1 released
+ScanCodeToKeyCode[0xBC] ="" 	// F2 released	
+ScanCodeToKeyCode[0xBD] ="" 	// F3 released	
+ScanCodeToKeyCode[0xBE] ="" 	// F4 released	
+ScanCodeToKeyCode[0xBF] ="" 	// F5 released
+ScanCodeToKeyCode[0xC0] ="" 	// F6 released	
+ScanCodeToKeyCode[0xC1] ="" 	// F7 released	
+ScanCodeToKeyCode[0xC2] ="" 	// F8 released	
+ScanCodeToKeyCode[0xC3] ="" 	// F9 released
+ScanCodeToKeyCode[0xC4] ="" 	// F10 released
+ScanCodeToKeyCode[0xC5] ="" 	// NumberLock released
+ScanCodeToKeyCode[0xC6] ="" 	// ScrollLock released
+ScanCodeToKeyCode[0xC7] ="" 	// (keypad) 7 released
+ScanCodeToKeyCode[0xC8] ="" 	// (keypad) 8 released	
+ScanCodeToKeyCode[0xC9] ="" 	// (keypad) 9 released	
+ScanCodeToKeyCode[0xCA] ="" 	// (keypad) - released	
+ScanCodeToKeyCode[0xCB] ="" 	// (keypad) 4 released
+ScanCodeToKeyCode[0xCC] ="" 	// (keypad) 5 released	
+ScanCodeToKeyCode[0xCD] ="" 	// (keypad) 6 released	
+ScanCodeToKeyCode[0xCE] ="" 	// (keypad) + released	
+ScanCodeToKeyCode[0xCF] ="" 	// (keypad) 1 released
+ScanCodeToKeyCode[0xD0] ="" 	// (keypad) 2 released	
+ScanCodeToKeyCode[0xD1] ="" 	// (keypad) 3 released	
+ScanCodeToKeyCode[0xD2] ="" 	// (keypad) 0 released	
+ScanCodeToKeyCode[0xD3] ="" 	// (keypad) . released
+ScanCodeToKeyCode[0xD7] ="" 	// F11 released
+ScanCodeToKeyCode[0xD8] ="" 	// F12 released					
--- a/source/kernel/KernelLauncher/boot.s
+++ b/source/kernel/KernelLauncher/boot.s
@ -0,0 +1,139 @@
+/*
+ * Multiboot 
+ */
+.set ALIGN,    1<<0             /* align loaded modules on page boundaries */
+.set MEMINFO,  1<<1             /* provide memory map */
+.set FLAGS,    ALIGN | MEMINFO  /* this is the Multiboot 'flag' field */
+.set MAGIC,    0x1BADB002       /* 'magic number' lets bootloader find the header */
+.set CHECKSUM, -(MAGIC + FLAGS) /* checksum of above, to prove we are multiboot */
+
+.section .multiboot.data, "aw"
+.align 4
+.long MAGIC
+.long FLAGS
+.long CHECKSUM
+ 
+/*
+*	Allocate initial stack
+*/
+.section .bootstrap_stack, "aw", @nobits
+stack_bottom:
+.skip 16384 # 16 KiB
+stack_top:
+
+/*
+* Preallocate a couple pages to get us bootstrapped 
+* Being carefull to not use any address the bootloader might 
+* be using for its multiboot structures
+*/
+.section .bss, "aw", @nobits
+	.align 4096
+.globl boot_page_directory
+boot_page_directory:
+	.skip 4096
+boot_page_table:
+	.skip 4096
+.globl multiboot_page_table
+multiboot_page_table:
+	.skip 4096
+# More page tables may be required
+
+# Entry point
+.section .multiboot.text, "a"
+.global _start
+.type _start, @function 
+_start:
+	# Get physical address of the boot_page_table
+	movl $(boot_page_table - 0xC0000000), %edi
+	# Map address 0
+	movl $0, %esi
+1:	
+	cmpl $(_kernel_end - 0xC0000000), %esi
+	jge 3f
+
+	# Map physical address as "present and writable"
+	movl %esi, %edx
+	orl $0x003, %edx
+	movl %edx, (%edi)
+
+2: # Size of page is 4096 bytes
+	addl $4096, %esi
+	# Size of entries in boot_page_table is 4 bytes
+	addl $4, %edi 
+	# Loop to the next entry if we haven't finished.
+	loop 1b
+
+3:	# Map VGA video memory to 0xC03FF00 as "present, writable"
+	movl $(0x000B8000 | 0x003), boot_page_table - 0xC0000000 + 1023 * 4
+
+
+	# IMPORTANT NOTE FROM WIKI.OSDEV.ORG/HIGHER_HALF_X86_BARE_BONES
+
+	# The page table is used at both page directory entry 0 (virtually from 0x0
+	# to 0x3FFFFF) (thus identity mapping the kernel) and page directory entry
+	# 768 (virtually from 0xC0000000 to 0xC03FFFFF) (thus mapping it in the
+	# higher half). The kernel is identity mapped because enabling paging does
+	# not change the next instruction, which continues to be physical. The CPU
+	# would instead page fault if there was no identity mapping.\
+	
+	# Map the page table to both virtual addresss 0x00000000 and 0xC0000000
+	movl $(boot_page_table - 0xC0000000 + 0x003), boot_page_directory - 0xC0000000 + 0
+	movl $(boot_page_table - 0xC0000000 + 0x003), boot_page_directory - 0xC0000000 + 768 * 4
+
+	# Set cr3 to the address of the boot_page_directory
+	movl $(boot_page_directory - 0xC0000000), %ecx
+	movl %ecx, %cr3
+
+	# Enable paging and the write-protect bit
+	movl %cr0, %ecx
+	orl $0x80010000, %ecx
+	movl %ecx, %cr0
+
+	# Jump to higher half with an absolute jump
+	lea 4f, %ecx
+	jmp *%ecx
+
+.section .text
+4:
+	# At this point, paging is fully set up and enabled
+isPaging:
+	# Unmap the identity mapping as it is now unnecessary  
+	movl $0, boot_page_directory + 0
+	
+	# Reload cr3 to force tlb flush 
+	movl %cr3, %ecx
+	movl %ecx, %cr3
+
+	/*Setup the stack pointer to point to the beginning of our stack */
+	/* I believe its a high address growing down to lower adress for the stack on x86*/
+	mov $stack_top, %esp
+
+	/*Reset EFLAGS*/
+	pushl $0 
+	popf 
+
+	/* push the pointer to the Multiboot information structure*/
+	pushl %ebx
+
+	/* push the magic value */
+	pushl %eax
+
+	call early_main
+
+
+
+
+
+	cli
+1:	hlt
+	jmp 1b
+
+
+.include "./src/kernel/Memory/GDT/gdt.s"
+.include "./src/kernel/irs_table.s"
+.include "./src/kernel/irq_table.s"
+.include "./src/kernel/Interrupts/idt/idt.s"
+.include "./src/kernel/Memory/paging.s"
+.include "./src/kernel/cpu.s"
+
+
--- a/source/kernel/KernelLauncher/bootcheck.h
+++ b/source/kernel/KernelLauncher/bootcheck.h
@ -0,0 +1,91 @@
+#pragma once 
+#include "../multiboot.h"
+#define CHECK_FLAG(flags, bit) ((flags) & (1 <<(bit)))
+#define __VERBOSE__
+#include "../Terminal/kterm.h"
+
+
+
+void CheckMBT ( multiboot_info_t*  mbt  ){
+      /* Set MBI to the addresss of the multiboot information structure*/
+        multiboot_info_t * mbi = (multiboot_info_t *) mbt;
+
+#ifdef __VERBOSE__
+        /* Print out the flags */
+        printf("flags = 0x%x\n", (unsigned) mbi->flags);
+#endif
+        /* Are mem_* valid? */
+        if ( CHECK_FLAG(mbi->flags,0)){
+                // Do nothing
+        }
+
+        /* is boot device valid ? */
+        if (CHECK_FLAG (mbi->flags, 1))
+        {
+#ifdef __VERBOSE__
+            printf("boot_device = 0x0%x\n", (unsigned) mbi->boot_device);
+#endif
+        }
+
+        /* is the command line passed? */
+        if (CHECK_FLAG ( mbi->flags,2))
+        {
+#ifdef  __VERBOSE__
+            printf("cmdline = %s\n", (char *) (mbi->cmdline + 0xC0000000));
+#endif
+        }
+
+        /* Are mods_* valid? */
+        if(CHECK_FLAG ( mbi->flags, 3)){
+            multiboot_module_t *mod;
+            uint32_t i;
+#ifdef __VERBOSE__
+            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);
+            }
+#endif
+        }
+
+        /* Bits 4 and 5 are mutually exclusive! */
+        if (CHECK_FLAG (mbi->flags, 4) && CHECK_FLAG(mbi->flags, 5))
+        {
+#ifdef __VERBOSE__
+            printf("Both bits 4 and 5 are set.\n");
+#endif 
+            return;
+        }
+
+        /* Is the symbol table of a.out valid? */
+        if (CHECK_FLAG(mbi->flags, 4)){
+            multiboot_aout_symbol_table_t *multiboot_aout_sym = &(mbi->u.aout_sym);
+#ifdef __VERBOSE__
+            printf( "multiboot_aout_symbol_table: tabsize = 0x%0x, strsize = 0x%x, addr = 0x%x\n", 
+            (unsigned) multiboot_aout_sym->tabsize,
+            (unsigned) multiboot_aout_sym->strsize,
+            (unsigned) multiboot_aout_sym->addr);
+#endif
+        }
+
+        /* Is the section header table of ELF valid? */
+        if (CHECK_FLAG(mbi->flags, 5)){
+            multiboot_elf_section_header_table_t *multiboot_elf_sec = &(mbi->u.elf_sec);
+#ifdef __VERBOSE__
+            printf("multiboot_elf_sec: num = %u, size = 0x%x, addr = 0x%x, shnd = 0x%x\n",
+            
+            (unsigned) multiboot_elf_sec->num, (unsigned) multiboot_elf_sec->size,
+            (unsigned) multiboot_elf_sec->addr, (unsigned)  multiboot_elf_sec->shndx);
+#endif
+            
+        }
+
+        /* Draw diagonal blue line */
+        if (CHECK_FLAG (mbt->flags, 12)){
+#ifdef __VERBOSE__
+            printf("Can draw!\n");
+#endif
+        } 
+
+
+}
--- a/source/kernel/KernelLauncher/crti.s
+++ b/source/kernel/KernelLauncher/crti.s
@ -0,0 +1,14 @@
+.section .init
+.global _init
+.type _init, @function
+_init:
+	push %ebp
+	movl %esp, %ebp
+	/* gcc will nicely put the contents of crtbegin.o's .init section here. */
+
+.section .fini
+.global _fini
+.type _fini, @function
+_fini:
+	push %ebp
+	movl %esp, %ebp
--- a/source/kernel/KernelLauncher/crtn.s
+++ b/source/kernel/KernelLauncher/crtn.s
@ -0,0 +1,7 @@
+.section .init
+	popl %ebp
+	ret
+
+.section .fini
+	popl %ebp
+	ret
--- a/source/kernel/KernelLauncher/launcher.cpp
+++ b/source/kernel/KernelLauncher/launcher.cpp
@ -0,0 +1,28 @@
+#include <stdint.h>
+#include <stddef.h>
+
+void put_char(char ch, size_t x, size_t y ){
+    *((uint16_t*)0xb8000+(y * 80 + x)) = ch | ((7 | 0 << 4) << 8);
+}
+
+void write_ln(char* s, size_t length, size_t x , size_t y)
+{
+  // Because read only data is linked at a virtual address we'll need to convert
+  // the string adddres from virtual to phys.
+  s = s - 0xC0000000;
+  size_t column , row;
+  column = x;
+  row = y;
+  for(int i = 0; i < length ; i ++)
+  {
+    
+    put_char(s[i] , column,row );
+    column ++;
+
+  }
+  
+}
+
+extern "C" void testLauncher  () {
+  write_ln("hello", 5 ,0,0);
+}
--- a/source/kernel/Lib/mem.h
+++ b/source/kernel/Lib/mem.h
@ -0,0 +1,8 @@
+inline void* memset (void* ptr, int value, size_t num){
+    for( int i = 0; i < num; i++ )
+    {
+        unsigned char* data  = (unsigned char*)ptr+ i;
+        *data = (unsigned char)value;
+    }
+    return ptr;
+}
--- a/source/kernel/Lib/string.c
+++ b/source/kernel/Lib/string.c
@ -0,0 +1,28 @@
+#include "string.h"
+
+size_t strlen(const char* str) {
+    size_t len = 0;
+    while(str[len]){
+        len++;
+    }
+    return len;
+}
+
+
+
+int strncmp ( const char* str1, const char* str2, size_t num ){
+    for( int i = 0; i < num ; i++){
+        
+        if( str1[i] < str2[i]){
+            return -1;
+        } 
+
+        if( str1[i] > str2[i] ){
+            return 1;
+        }
+
+
+    }
+
+    return 0;
+}
--- a/source/kernel/Lib/string.h
+++ b/source/kernel/Lib/string.h
@ -0,0 +1,6 @@
+#pragma once
+#include <stddef.h>
+size_t strlen(const char* str);
+
+
+int strncmp ( const char* str1, const char* str2, size_t num );
--- a/source/kernel/Memory/GDT/gdt.s
+++ b/source/kernel/Memory/GDT/gdt.s
@ -0,0 +1,19 @@
+.global LoadGlobalDescriptorTable
+
+	LoadGlobalDescriptorTable:
+		lgdt gdtDescriptor
+
+		movw $16, %ax 
+		movw %ax, %ds
+		movw %ax, %es
+		movw %ax, %fs
+		movw %ax, %gs
+		movw %ax, %ss
+		
+		jmp $8,$flush 
+
+		flush: 
+		ret
+		
+	
+
--- a/source/kernel/Memory/GDT/gdtc.cpp
+++ b/source/kernel/Memory/GDT/gdtc.cpp
@ -0,0 +1,58 @@
+#include "gdtc.h"
+#include "../../Terminal/kterm.h"
+
+#define NULL_SEGMENT          0
+#define KERNEL_CODE_SEGMENT   1
+#define KERNEL_DATA_SEGMENT   2
+#define USER_CODE_SEGMENT     3
+#define USER_DATA_SEGMENT     4
+
+SegmentDescriptor GlobalDescriptorTable[5];
+GlobalDescriptorTableDescriptor gdtDescriptor;
+
+void add_descriptor(int which , unsigned long base, unsigned long limit, unsigned char access, unsigned char granularity ){
+   GlobalDescriptorTable[which].base_low = (base & 0xFFFF );
+   GlobalDescriptorTable[which].base_middle = (base >> 6) & 0xFF;
+   GlobalDescriptorTable[which].base_high = (base >> 24) & 0xFF;
+   
+   GlobalDescriptorTable[which].limit_low = (limit & 0xFFFF);
+   GlobalDescriptorTable[which].granularity = ((limit >> 16) & 0x0F);
+
+   GlobalDescriptorTable[which].granularity |= (granularity & 0xF0);
+   GlobalDescriptorTable[which].access = access;
+
+
+}
+
+
+
+
+void initGDT(){
+
+#ifdef __VERBOSE__
+      printf("Init GDT!\n");
+#endif
+      // NULL segment
+      add_descriptor(NULL_SEGMENT, 0,0,0,0);
+
+      // Kernel Code Segment
+      add_descriptor(KERNEL_CODE_SEGMENT, 0, 0xFFFFFFFF, 0x9A, 0xCF);
+
+      // Kernel Data Segment
+      add_descriptor(KERNEL_DATA_SEGMENT, 0, 0xFFFFFFFF, 0x92, 0xCF);      
+
+      // User Code Segment
+      // TODO:
+      
+      // User Data Segement
+      // TODO: 
+      
+      // init Gdt Descriptor
+      gdtDescriptor.limit = ((sizeof(SegmentDescriptor ) * 5 ) - 1);
+      gdtDescriptor.base = (unsigned int) &GlobalDescriptorTable;
+
+
+
+      LoadGlobalDescriptorTable();
+
+}
--- a/source/kernel/Memory/GDT/gdtc.h
+++ b/source/kernel/Memory/GDT/gdtc.h
@ -0,0 +1,27 @@
+#include <stdint.h>
+
+
+struct SegmentDescriptor {
+   unsigned short limit_low;
+   unsigned short base_low;
+   unsigned char base_middle;
+   unsigned char access;
+   unsigned char granularity;
+   unsigned char base_high;
+}__attribute__((packed));
+
+
+struct GlobalDescriptorTableDescriptor{
+   unsigned short limit;
+   unsigned int base;
+}__attribute__((packed));
+
+extern SegmentDescriptor GlobalDescriptorTable[];
+extern GlobalDescriptorTableDescriptor gdtDescriptor;
+
+
+void add_descriptor(int which , unsigned long base, unsigned long limit, unsigned char access, unsigned char granularity );
+
+
+extern "C" void LoadGlobalDescriptorTable();
+void initGDT();
--- a/source/kernel/Memory/KernelHeap.cpp
+++ b/source/kernel/Memory/KernelHeap.cpp
@ -0,0 +1,51 @@
+#include "KernelHeap.h"
+
+// Size of heap meta data is 5 bytes 
+struct heap_block{
+    uint8_t Used;
+    uint32_t Size;
+}
+
+uint32_t heap_size;
+heap_block* start ;
+
+void* malloc(size_t size)
+{
+    printf("Received request for %d bytes of memory", size);
+    heap_block* current = start;
+
+    while(current <  start + heap_size)
+    {
+        if(current->size >= size && current->Used == false )
+        {
+            // We found a spot 
+            // Set the spot to in-use 
+            current->Used = false;
+            // return the free address 
+            // NOTE: added an offset from the initial address to accomodate for 
+            // meta-data.
+            return current + sizeof(heap_block);
+
+        }
+
+        current += current->Size + sizeof(heap_block);
+    }   
+
+    // If we are here we need more memory so we should 
+    // probably ask the VMM for more 
+    // TODO: ask for more memory
+    
+}
+
+void free(void* addr)
+{
+    // clear the free boolean that corresponds to this adddress
+    // This should be fairly simple
+    heap_block* allocatedBlock = addr - sizeof(heap_block);
+    allocate_block->Used = false;
+}
+
+void initHeap()
+{
+    
+}
--- a/source/kernel/Memory/KernelHeap.h
+++ b/source/kernel/Memory/KernelHeap.h
@ -0,0 +1,9 @@
+#pragma once 
+#include <stdint.h>
+
+
+void initHeap();
+
+void* malloc (size_t size );
+void free(void* addr);
+
--- a/source/kernel/Memory/MBIMMap/MBI_MMap.cpp
+++ b/source/kernel/Memory/MBIMMap/MBI_MMap.cpp
@ -0,0 +1,43 @@
+#include "MBI_MMap.h"
+
+
+void mapMultibootMemoryMap( MemoryInfo* memInfo , multiboot_info_t *mbt) {
+
+    printf("mmap_addr = 0x%x, mmap_length = 0x%x\n", (unsigned) mbt->mmap_addr , (unsigned) mbt->mmap_length );
+
+
+    multiboot_memory_map_t *mmap = (multiboot_memory_map_t*) mbt->mmap_addr;
+
+    for (;  (unsigned long) mmap <  mbt->mmap_addr + mbt->mmap_length;  mmap = (multiboot_memory_map_t *) ((unsigned long) mmap + mmap->size + sizeof(mmap->size))){
+
+        if ( mmap->type == MULTIBOOT_MEMORY_AVAILABLE){
+    
+            memInfo->TotalMemory +=  mmap->len;   
+        } else {
+            memInfo->ReservedMemory += mmap->len;
+        }
+        
+        print_Multiboot_memory_Map(mmap);
+            
+    }
+}
+
+
+
+/**
+ * @brief Debug Verbose functions
+ * 
+ * @param mmap 
+ */
+
+void print_Multiboot_memory_Map(multiboot_memory_map_t* mmap) {
+    printf(
+        "size = 0x%x, base_addr = 0x%x%08x, length = 0x%x%08x, type = 0x%x\n",
+        (unsigned) mmap->size,
+        (unsigned) (mmap->addr >> 32),
+        (unsigned) (mmap->addr & 0xffffffff),
+        (unsigned) (mmap->len >> 32),
+        (unsigned) (mmap->len & 0xffffffff),
+        (unsigned) mmap->type
+    );
+}
--- a/source/kernel/Memory/MBIMMap/MBI_MMap.h
+++ b/source/kernel/Memory/MBIMMap/MBI_MMap.h
@ -0,0 +1,16 @@
+#pragma once 
+#include <stddef.h>
+#include "../../multiboot.h"
+#include "../memoryinfo.h"
+
+void initialise_available_regions(uint32_t memoryMapAddr, uint32_t memoryMapLastAddr, uint32_t* memoryBitMap, int* used_blocks);
+
+
+void mapMultibootMemoryMap( MemoryInfo* memInfo , multiboot_info_t *mbt);
+
+/**
+ * @brief Debug Verbose Functions
+ * 
+ * @param mmap 
+ */
+void print_Multiboot_memory_Map(multiboot_memory_map_t* mmap);
--- a/source/kernel/Memory/PhysicalMemoryManager.cpp
+++ b/source/kernel/Memory/PhysicalMemoryManager.cpp
@ -0,0 +1,102 @@
+#include "./PhysicalMemoryManager.h"
+
+PhysicalMemoryManagerInfoBlock* PMMInfoBlock;
+
+
+void initPMM( MemoryInfo* memory) {
+
+    // NOTE: Lets for now puts the Physical  memoryManagerBlock at a random address
+    //      We'll think of a more proper solution a bit later
+    PMMInfoBlock = (PhysicalMemoryManagerInfoBlock*) 0xCC900000;
+
+
+    // calculate the maximum number of blocks
+    PMMInfoBlock->max_blocks = KB_TO_BLOCKS(memory->TotalMemory);
+    PMMInfoBlock->used_blocks = 0;
+    PMMInfoBlock->memoryBitMap = (uint32_t*) 0xCCA00000;
+
+    printf("Maximum Number of blocks: 0x%x, Number of bytes for memMap: 0x%x\n", PMMInfoBlock->max_blocks , (PMMInfoBlock->max_blocks/8));
+
+    //Size of memory map 
+    uint32_t memMap_size = (PMMInfoBlock->max_blocks / 8 ) ; 
+    
+    printf("Memory Map size:  0x%x\n", memMap_size );
+    printf("size of int in bytes: 0x%x \n" , sizeof(int));
+
+    // Set all places in memory as free
+    memset(PMMInfoBlock->memoryBitMap, 0xFF, memMap_size  );
+}
+
+// NOTE: this can only give blocks of 4kb at a time!
+void* allocate_block() {
+    uint8_t blocks_available = PMMInfoBlock->max_blocks - PMMInfoBlock->used_blocks;
+    // Are there any blocks available?
+    if( blocks_available <= 0)
+    {
+        printf("No blocks available. Blocks Delta: 0x%x\n", blocks_available);
+        return 0;
+    }
+
+    // Find 1 free block somewhere
+    int free_block_index = bitmap_first_unset(PMMInfoBlock->memoryBitMap, (PMMInfoBlock->max_blocks /8) /*memMap Size*/ );
+
+
+    
+    if(free_block_index == -1)
+    {
+        printf("Could not find a good block!\n");
+        // Could not find a block
+        return (void*)0xFFFF;
+    }
+
+    if(free_block_index == 0)
+        printf("Somethings wrong!!!\n");
+
+    // Set the block to be used!
+    bitmap_unset(PMMInfoBlock->memoryBitMap, free_block_index);
+    // Increase the used_block count!
+    PMMInfoBlock->used_blocks++;
+    printf("used blocks: 0x%x\n", PMMInfoBlock->used_blocks);
+    // return the pointer to the physical address
+    return (void*) (BLOCK_SIZE * free_block_index);
+}
+
+void free_block(void* p) {
+    // If it is a null pointer we don't need to do anything.
+    if(p==0) {
+        return;
+    }
+    // calculate the index into the bitmap
+    int index  = ((uint32_t) p) / BLOCK_SIZE;
+    
+    // set the block to be free
+    bitmap_set(PMMInfoBlock->memoryBitMap, index);
+    PMMInfoBlock->used_blocks--;
+    printf("used blocks: 0x%x, after free\n", PMMInfoBlock->used_blocks);
+
+}
+
+void allocate_region(uint32_t startAddress, uint32_t size) {
+    // every bit should be 4KiB 
+    // every byte is 8*4KiB = 32KiB
+    
+    int NumberOfBlocksToAllocate = ( size / 1024) / 4  / 8 + 1;
+    int startBlock = (startAddress / 1024) / 4 / 8 ;
+    
+   // printf("NumberOfBlocksToAllocate: 0x%x\n", NumberOfBlocksToAllocate);
+    //printf( "start block: 0x%x\n" , startBlock);
+    for( int i = 0; i < NumberOfBlocksToAllocate; i++)
+    {
+
+        //printf("ALLOCATE BLOCK: 0x%x\n" , startBlock + i );
+        bitmap_unset(PMMInfoBlock->memoryBitMap, startBlock+ i);
+        PMMInfoBlock->used_blocks++;
+    }
+
+
+}
+void deallocate_region(uint32_t  StartAddress , uint32_t size ) {
+    // NOT IMPLEMENTED YET
+}
+
+
--- a/source/kernel/Memory/PhysicalMemoryManager.h
+++ b/source/kernel/Memory/PhysicalMemoryManager.h
@ -0,0 +1,30 @@
+#pragma once
+#include <stddef.h>
+#include "memoryinfo.h"
+
+#include "../Terminal/kterm.h"
+#include "../Lib/mem.h"
+#include "../bitmap.h"
+
+// Asumming 32 bit x86 for now!
+#define BLOCK_SIZE 4092
+#define WORD_SIZE 2 
+#define BLOCKS_PER_WORD 32 
+
+#define KB_TO_BLOCKS(x) (x  / BLOCK_SIZE)
+#define IS_ALIGNED(addr, align) !((addr) & ~((align) - 1))
+#define ALIGN(addr, align) (((addr) & ~((align) - 1 )) + (align))
+
+struct PhysicalMemoryManagerInfoBlock
+{
+    uint32_t* memoryBitMap;
+    size_t pmmap_size;
+    size_t max_blocks;
+    int used_blocks;
+};
+
+void initPMM(MemoryInfo* memory);
+void free_block(void* ptr);
+void* allocate_block();
+void allocate_region(uint32_t, uint32_t);
+void deallocate_region(uint32_t   , uint32_t );
--- a/source/kernel/Memory/VirtualMemoryManager.cpp
+++ b/source/kernel/Memory/VirtualMemoryManager.cpp
@ -0,0 +1,24 @@
+#include "VirtualMemoryManager.h"
+
+extern "C" void loadPageDirectory (uint32_t* addr );
+extern "C" void enablePaging();
+
+void AllocatePage(uint32_t vaddr)
+{
+
+}
+
+void FreePage(uint32_t vaddr )
+{
+
+}
+
+void Map (  uint32_t vaddr, uint32_t paddr)
+{
+
+}
+
+void Unmap(uint32_t vaddr)
+{
+    // NOTE: I will implement lazy unmapping for now 
+}
--- a/source/kernel/Memory/VirtualMemoryManager.h
+++ b/source/kernel/Memory/VirtualMemoryManager.h
@ -0,0 +1,12 @@
+#pragma once 
+#include "PhysicalMemoryManager.h"
+#include "../Terminal/kterm.h"
+#include "../cpu.h"
+
+void AllocatePage(uint32_t v_addr );
+void FreePage(uint32_t v_addr);
+
+void Map(uint32_t p_addr, uint32_t v_addr);
+void Unmap (uint32_t v_addr);
+
+
--- a/source/kernel/Memory/memoryinfo.h
+++ b/source/kernel/Memory/memoryinfo.h
@ -0,0 +1,20 @@
+#pragma once
+#include <stdint.h>
+#include <stddef.h>
+
+struct MemoryArea{
+    void* StartAddress;
+    size_t Size;
+    unsigned int type;
+    MemoryArea* Next;
+
+}__attribute__((packed));
+
+struct MemoryInfo {
+    uint32_t TotalMemory;
+    uint32_t ReservedMemory;
+    MemoryArea* MemoryRegionList;
+}__attribute__((packed));
+
+
+
--- a/source/kernel/Memory/paging.definitions.h
+++ b/source/kernel/Memory/paging.definitions.h
@ -0,0 +1,56 @@
+#pragma once
+#include <stdint.h>
+/*
+    This file contains some handy definitions for different types 
+    that have to do with paging in atleast 32 bit and maybe sometime in the future
+    also 64 bit mode.
+*/
+
+#define MAX_DIRECTORY_ENTRIES 1024
+#define MAX_PAGE_TABLE_ENTRIES 1024
+#define MAX_PAGES 1024
+
+#define PHYSICAL_ADDRESS uint32_t 
+#define VIRTUAL_ADDRESS uint32_t
+
+#define PageDirectoryEntry uint32_t
+#define PageTableEntry uint32_t
+
+
+#define KERNEL_VRT_MEMORY_BEGIN 0xC0000000
+#define KERNEL_VRT_MEMORY_END   0xCFFFFFFF
+#define PAGE_SIZE  4096;
+
+
+// NOTE: FIXME: I am fairly certain these masks are off by one!
+
+#define PD32_PRESENT_MASK                   (0x1 << 0)
+#define PD32_READ_WRITE_MASK                (0x1 << 1)
+#define PD32_SUPERVISOR_MASK                (0x1 << 2)
+#define PD32_WRITE_THROUGH_MASK             (0x1 << 3)
+#define PD32_CACHE_DISABLE_MASK             (0x1 << 4)
+#define PD32_ACCESSED_MASK                  (0x1 << 5)
+#define PD32_AVAILABLE_1_4KB_MASK           (0x1 << 6)
+#define PD32_DISABLE_4MB_MASK               (0x1 << 6)
+#define PD32_PAGE_SIZE_MASK                 (0x1 << 7)
+#define PD32_GLOBAL_4MB_MASK                (0x1 << 8)
+#define PD32_AVAILABLE_2_4MB_MASK           ( 14 << 9)
+#define PD32_AVAILABLE_2_4KB_MASK           ( 15 << 8)
+#define PD32_ADDRESS_4KB_MASK               (0x8FFFF << 12)
+#define PD32_PAGE_ATTRIBUTE_TABLE_4MB_MASK  (0x1 << 12)
+#define PD32_HIGH_HALF_ADDRESS_4MB_MASK     (0x7F<< 13)
+#define PD32_RESERVED_4MB_MASK              (0x1 << 21)
+#define PD32_LOWER_HALF_ADDRESS_4MB_MASK    (0x1FF << 22)
+
+#define PT32_PRESENT_MASK                   (0x1 << 0)
+#define PT32_READ_WRITE_MASK                (0x1 << 1)
+#define PT32_SUPERVISOR_MASK                (0x1 << 2)
+#define PT32_WRITE_THROUGH_MASK             (0x1 << 3)
+#define PT32_CACHE_DISABLE_MASK             (0x1 << 4)
+#define PT32_ACCESSED_MASK                  (0x1 << 5)
+#define PT32_DIRTY_MASK                     (0x1 << 6)
+#define PT32_PAGE_ATTRIBUTE_TABLE_MASK      (0x1 << 7)
+#define PT32_GLOBAL_MASK                    (0x1 << 8)
+#define PT32_AVAILABLE_MASK                 (0x7 << 9)
+#define PT32_CACHE_DISABLE_MASK             (0x7FFFF << 12)
+
--- a/source/kernel/Memory/paging.s
+++ b/source/kernel/Memory/paging.s
@ -0,0 +1,44 @@
+# NOTE: I wish this wasn't AT&T Syntax its horrible
+# REMINDER: INSTRUCTION FROM_REGISTER, TO_REGISTER
+.globl enablePaging
+enablePaging:
+	# Create a new call frame 
+	push %ebp
+	mov %esp, %ebp
+
+	# Set the PG bit of CR0
+	mov %cr0, %eax
+	or $0x80000000, %eax
+	mov %eax, %cr0
+
+	# Restore to the previous call frame 
+	mov %ebp, %esp
+	pop %ebp
+	ret
+
+.globl loadPageDirectory
+loadPageDirectory:
+	push %ebp
+	mov %esp, %ebp
+
+	/* NOTE: We should probably check if paging is already enabled.
+		Changing the CR3 register whilst paging is enabled might 
+		result in unwanted behaviour (in the worst case) or cause a 
+		fault (in the best case).
+	*/
+
+	mov 8(%esp), %eax # Move the first argument in the eax register
+
+	mov %eax, %cr3  # Move the value of eax into the CR3 register
+
+	/*
+		Moving the value of the argument  passed to this function 
+		into the CR3 register will allow the MMU to access the paging 
+		structure we setup in memory once we enable paging
+	*/
+
+	mov %ebp, %esp
+	pop %ebp
+	ret
+
+
--- a/source/kernel/SuperVisorTerminal/superVisorTerminal.cpp
+++ b/source/kernel/SuperVisorTerminal/superVisorTerminal.cpp
@ -0,0 +1,83 @@
+#include "superVisorTerminal.h"
+
+void startSuperVisorTerminal(BootInfo* bootinfo){
+    while (true){
+           
+           printf("SUPERVISOR:>$ " );
+            int characterCount = 0;
+            char command[10] = "";
+         
+            // NOTE: lets just show a kernel prompt                
+            uint8_t ScanCode = getKey();
+            while( ScanCode  != 0x1C )
+            {
+                char character = getASCIIKey();
+                kterm_put(character );
+                // wHAT THE HELL
+
+                if( characterCount  < 10 ){
+                    command[characterCount] = character;  
+                    characterCount++;
+                }
+
+                ScanCode = getKey(); 
+            }
+            printf("\n");
+            KeyHandled();
+         
+
+            if ( strncmp("DATE", command , characterCount ) == 0 )
+            {
+                 read_rtc();
+                 printf("======= Time & Date ==========\n");
+                 printf("   - Date:     %02d-%02d-%02d\n",day, month, year);
+                 printf("   - Time:     %02d:%02d:%02d\n" , hour, minute, second);
+                 printf("   - Ticks:    %09d\n", pit_tick);            
+            }
+            else if( strncmp ("MEMORY" , command , characterCount) == 0 )
+            {
+                // Show memory layout
+                printf("========= Memory ==========\n");
+                printf("Kernel MemoryMap:\n");
+                //printf("kernel: 0x%x - 0x%x\n", &kernel_begin , &kernel_end);         
+                printf("Frames used: 0x%x blocks of 4 KiB\n", 0);  
+                const int bytesInGiB = 1073741824;
+                int64_t bytesLeft = (bootinfo->memory->TotalMemory % bytesInGiB) / bytesInGiB;
+                int64_t effectiveNumberOfGib = bootinfo->memory->TotalMemory / bytesInGiB;
+
+                int64_t GiBs = effectiveNumberOfGib + bytesLeft;  
+
+                printf("Available Memory: %d bytes, %d GiB\n",  bootinfo->memory->TotalMemory, GiBs );
+                printf("Reserved Memory: %d bytes\n",  bootinfo->memory->ReservedMemory);
+
+                //printf("\n\n");
+                //PrintPhysicalMemoryAllocation(  );
+
+
+            }
+            else if(strncmp("TEST", command, characterCount) == 0)
+            {
+                // TEST #DE exception
+               asm volatile ("MOV $4, %AX ;  MOV $0, %BX ; DIV %BX"); // IRS 0
+            }
+            else if (strncmp("VERSION", command , characterCount) == 0)
+            {
+                // Show version information 
+                printf("========= Version ========\n");
+                printf("Kernel v%d\n", 0);
+
+            }
+            else if(strncmp("CLEAR", command, characterCount) == 0)
+            {
+                kterm_init();
+                printf("|===    BarinkOS       ===|\n");
+            }
+            else
+            {
+                printf("Unknown command\n");
+            }
+
+
+            delay(1000);
+        }   
+}
--- a/source/kernel/SuperVisorTerminal/superVisorTerminal.h
+++ b/source/kernel/SuperVisorTerminal/superVisorTerminal.h
@ -0,0 +1,9 @@
+#pragma once 
+#include "../Terminal/kterm.h"
+#include "../time.h"
+#include "../Drivers/PIT/pit.h"
+#include "../Drivers/PS-2/keyboard.h"
+#include "../Memory/PhysicalMemoryManager.h"
+#include "../bootinfo.h"
+
+void startSuperVisorTerminal(BootInfo * );
--- a/source/kernel/Terminal/kterm.cpp
+++ b/source/kernel/Terminal/kterm.cpp
@ -0,0 +1,234 @@
+#include "kterm.h"
+
+static const size_t VGA_WIDTH = 80;
+static const size_t VGA_HEIGHT = 25;
+
+size_t kterm_row;
+size_t kterm_column;
+uint8_t kterm_color;
+uint16_t* kterm_buffer;
+
+
+static inline uint8_t vga_entry_color( enum vga_color fg, enum vga_color bg) {
+    return fg | bg << 4;
+}
+
+static inline uint16_t vga_entry (unsigned char uc, uint8_t color) {
+    return (uint16_t) uc | (uint16_t) color << 8;
+}
+
+void kterm_init () { 
+    kterm_row = 0;
+    kterm_column = 0;
+    kterm_color = vga_entry_color ( VGA_COLOR_LIGHT_GREY , VGA_COLOR_BLACK);
+    kterm_buffer = (uint16_t*) 0xC03FF000;
+    for (size_t y = 0; y < VGA_HEIGHT; y++ ){
+        for( size_t x = 0; x < VGA_WIDTH; x++){
+            const size_t index = y * VGA_WIDTH + x;
+            kterm_buffer[index] = vga_entry(' ', kterm_color);
+
+        }
+    }
+}
+
+
+void kterm_resetcolor(){
+     kterm_color = vga_entry_color ( VGA_COLOR_LIGHT_GREY , VGA_COLOR_BLACK);
+}
+
+void kterm_setcolor(uint8_t color){
+    kterm_color = color;
+}
+
+void kterm_putat (char c, uint8_t color, size_t x, size_t y ) {
+    const size_t index = y * VGA_WIDTH + x;
+
+    kterm_buffer[index] = vga_entry(c, color);
+
+}
+
+void enable_cursor (uint8_t start_cursor , uint8_t end_cursor ){
+    outb(0x3D4, 0x0A);
+    outb(0x3D5, (inb(0x3D5) & 0xC0) | start_cursor);
+
+    outb(0x3D4, 0x0B);
+    outb(0x3D5, (inb(0x3D5) & 0xE0) | end_cursor);
+}
+
+void disable_cursor() 
+{
+        outb(0x3D4, 0x0A);
+        outb(0x3D5, 0x20);
+}
+
+
+void update_cursor(int x, int y){
+    uint16_t pos = y * VGA_WIDTH + x;
+
+    outb(0x3D4, 0x0F);
+    outb(0x3D5, (uint8_t) (pos & 0xFF));
+    outb(0x3D4, 0x0E);
+    outb(0x3D5, (uint8_t) ((pos >> 8) & 0xFF));
+}
+
+uint16_t get_cursor_position(){
+    uint16_t pos = 0;
+    outb(0x3D4, 0x0F);
+    pos |= inb(0x3D5);
+    outb(0x3D4, 0x0E);
+    pos |= ((uint16_t) inb(0x3D5)) << 8;
+    return pos;
+}
+
+int get_cursor_x (uint16_t cursor_pos) {
+    return cursor_pos % VGA_WIDTH;
+}
+
+int get_cursor_y (uint16_t cursor_pos ) {
+    return cursor_pos / VGA_WIDTH;
+}
+
+
+
+/**
+ *  With the help from:
+ * https://whiteheadsoftware.dev/operating-systems-development-for-dummies/
+ **/ 
+void kterm_scrollup(){
+    size_t i ;
+    for(i=0; i < (VGA_WIDTH * VGA_HEIGHT - VGA_WIDTH); i++)
+        kterm_buffer[i] = kterm_buffer[i+VGA_WIDTH];
+
+    for( i=0; i< VGA_WIDTH; i++)
+        kterm_buffer[(VGA_HEIGHT -1) * VGA_WIDTH + i ] = vga_entry(' ', kterm_color); 
+
+}
+
+void kterm_put (char c) {
+    if(++kterm_column == VGA_WIDTH || c == '\n' ) {
+        update_cursor(kterm_column , kterm_row);
+        kterm_column = 0;
+        if(kterm_row == VGA_HEIGHT-1 ) {       
+            kterm_scrollup();
+        } else {
+            kterm_row ++;
+        }
+    }
+    if ( c == '\r'){
+        kterm_column = 0;
+        return;
+    }
+    
+    if(c == '\n') return;
+    kterm_putat ( c, kterm_color, kterm_column, kterm_row);
+    
+
+}
+
+void kterm_write(const char* data, size_t size) {
+    for(size_t i = 0; i < size; i++){
+        kterm_put(data[i]);
+    }
+}   
+
+void kterm_writestring(const char* data ){
+   // AS_KERNEL();
+    kterm_write(data, strlen(data));
+}
+
+
+static void itoa (char *buf, int base, int d) {
+    char *p = buf;
+    char *p1, *p2;
+    unsigned long ud = d;
+    int divisor = 10;
+    if ( base == 'd' && d < 0){
+        *p++ = '-';
+        buf++;
+        ud = -d;
+    } else if (base == 'x'){
+        divisor = 16;
+    }
+
+    do { 
+        int remainder = ud % divisor;
+
+         *p++ = (remainder < 10 ) ? remainder + '0' : remainder + 'a' -10;
+    } while(ud /= divisor);
+
+    /*terminate buf*/
+    *p =0;
+    p1 = buf;
+    p2 = p -1;
+
+    while (p1 < p2)
+    {
+        char tmp = *p1;
+        *p1 = *p2;
+        *p2 = tmp;
+        p1++;
+        p2--;
+
+    }
+
+}
+
+void printf ( const char *format, ...) {
+    
+    char **arg = (char **)&format;
+    int c;
+    char buf[20];
+
+    arg++;
+    
+    while ((c = *format++) != 0){
+        if( c != '%')
+            kterm_put(c);
+        else{
+            char *p, *p2;
+            int pad0 = 0, pad = 0;
+
+            c = *format++;
+            if(c =='0'){
+                pad0 = 1;
+                c = *format++;
+            }
+
+            if ( c >= '0' && c <= '9'){
+                pad = c - '0';
+                c = *format++;
+            }
+
+            switch (c)
+            {
+            case 'd':
+             
+            case 'u':
+            case 'x':
+                itoa(buf, c, *((int *) arg++));
+
+                p = buf;
+                goto string;
+                break;
+            
+            case 's':
+                p = *arg++;
+                if(!p)
+                    p = "(null)";
+                
+                string: 
+                    for (p2 = p; *p2; p2++);
+                    for (; p2 < p + pad; p2++)
+                        kterm_put(pad0 ? '0': ' ');
+                    while (*p)
+                        kterm_put(*p++);
+                    break;
+
+
+            default:
+                kterm_put(*((int *)arg++));
+                break;
+            }
+        }
+    }
+}
--- a/source/kernel/Terminal/kterm.h
+++ b/source/kernel/Terminal/kterm.h
@ -0,0 +1,45 @@
+#pragma once 
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#include "../Drivers/VGA/colors.h"
+#include "../io.h"
+
+extern "C"{
+    #include "../Lib/string.h"
+}
+
+void kterm_init();
+
+/* Kernel terminal - Colour functions*/
+void kterm_resetcolor();
+void kterm_setcolor(uint8_t);
+
+/* Kernel terminal - Printing function */
+void kterm_putat(char, uint8_t, size_t, size_t);
+void kterm_put(char);
+void kterm_write(const char*, size_t);
+void kterm_writestring(const char*);
+void kterm_scrollup();
+
+
+/* Kernel terminal - Cursor functions */
+void enable_cursor (uint8_t start_cursor , uint8_t end_cursor );
+void disable_cursor();
+void update_cursor(int x, int y);
+uint16_t get_cursor_position();
+int get_cursor_x (uint16_t cursor_pos);
+int get_cursor_y (uint16_t cursor_pos);
+
+
+void printf ( const char *format, ...);
+
+//static void itoa (char *buf, int base, int d);
+
+#define KernelTag "[Kernel]: "
+#define AS_KERNEL() (  kterm_setcolor(VGA_COLOR_LIGHT_BLUE),\
+                       kterm_write(KernelTag, 10 ), \
+                       kterm_resetcolor())
+
+
--- a/source/kernel/bitmap.h
+++ b/source/kernel/bitmap.h
@ -0,0 +1,40 @@
+#pragma once 
+#include <stddef.h>
+#include <stdint.h>
+
+
+inline void bitmap_set( uint32_t* map , int index )
+{
+    map[index/32] |= (1 << (index % 32));
+}
+
+inline void bitmap_unset(uint32_t* map , int index)
+{
+    map[index/32] &= ~(1 << (index % 32));
+}
+
+inline uint32_t bitmap_first_unset( uint32_t* map , int map_size)
+{
+    for ( int i = 0 ; i < map_size ; i ++ )
+    {
+        // a bit or more is set within this byte!
+        if( (map[i] & 0xFFFFFFFF) > 0 ){
+
+            // which bit is set? 
+            for(int j = 0 ; j < 32 ; j++){
+                if ( (map[i] & (0x00000001 << j)) > 0)
+                {
+                    printf("Found bit: byte 0x%x , bit 0x%x\n", i , j);
+                    return (i*32)+j;
+                }
+            }
+
+        
+        }
+
+
+    }
+
+    return -1;
+    
+}
--- a/source/kernel/bootinfo.h
+++ b/source/kernel/bootinfo.h
@ -0,0 +1,8 @@
+#pragma once
+#include "Memory/memoryinfo.h"
+
+struct BootInfo{
+    const char* BootStructureID = "BarinkOS";
+    MemoryInfo* memory;
+
+}; 
--- a/source/kernel/cpu.h
+++ b/source/kernel/cpu.h
@ -0,0 +1,74 @@
+#pragma once 
+
+/*
+Based on Intel specifications.
+
+C++ interface for the cpu.s assembly file.
+
+©Nigel Barink - 2022 
+*/
+
+
+/*
+*       EFLAGS FUNCTIONS
+*/
+
+extern "C" uint32_t GetEFLAGS();
+
+
+
+/*
+*       CONTROL_REGISTER_0 FUNCTIONS
+*/
+extern "C" uint32_t GetCR0();
+
+/*
+ struct CR0_Register  {
+        uint8_t PE :1; // Protection Mode Enabled 0
+        uint8_t MP :1; // Monitor co-processor 1
+        uint8_t EM :1; // Emulation 2
+        uint8_t TS :1; // Task switched 3
+        uint8_t ET :1; // Extension Type 4
+        uint8_t NE :1; // Numeric error 5
+        uint16_t Reserved :10; // 6,7,8,9,10,11,12,13,14,15
+        uint8_t WP :1; // Write Protect 16
+        uint8_t Reserved :1; // 17
+        uint8_t AM :1; // Alligment Task 18
+        uint16_t Reserved :10; // 19,20,21,22,23,24,25,26,27,28
+        uint8_t NW :1; // Not-write through 29
+        uint8_t CD :1; // Cache disable 30
+        uint8_t PG :1; // Paging 31
+    };*/
+
+
+
+#define GET_PE_BIT(CONTROL_REGISTER_0) (CONTROL_REGISTER_0&0x1)
+#define GET_MP_BIT(CONTROL_REGISTER_0) (CONTROL_REGISTER_0&0x2)
+#define GET_EM_BIT(CONTROL_REGISTER_0) (CONTROL_REGISTER_0&0x3)
+#define GET_TS_BIT(CONTROL_REGISTER_0) (CONTROL_REGISTER_0&0x4)
+#define GET_ET_BIT(CONTROL_REGISTER_0) (CONTROL_REGISTER_0&0x5)
+#define GET_NE_BIT(CONTROL_REGISTER_0) (CONTROL_REGISTER_0&0x6)
+
+
+#define GET_PG_BIT(CONTROL_REGISTER_0) (CONTROL_REGISTER_0>>31)
+
+/*
+*       CONTROL_REGISTER_4 FUNCTIONS
+*/
+
+extern "C" uint32_t GetCR4();
+
+#define GET_PSE_BIT(CONTROL_REGISTER_4) (CONTROL_REGISTER_4&0x4)
+#define GET_PAE_BIT(CONTROL_REGISTER_4) (CONTROL_REGISTER_4&0x5)
+
+/*
+*       CONTROL_REGISTER_2 FUNCTIONS
+*/
+
+extern "C" uint32_t GetCR2();
+
+/*
+*       CONTROL_REGISTER_3 FUNCTIONS
+*/
+
+extern "C" uint32_t GetCR3();
--- a/source/kernel/cpu.s
+++ b/source/kernel/cpu.s
@ -0,0 +1,63 @@
+# Basic cpu functions 
+.globl GetCR0
+GetCR0:
+	push %ebp # save the base pointer on the stack
+	mov %esp, %ebp  # Set the base pointer to the current stack pointer 
+
+	xor %eax, %eax # Clear EAX to make sure no weird stuff is going on
+	mov %cr0, %eax # Copy the value of the CR0 register into EAX
+
+	mov %ebp, %esp # restore the base pointer 
+	pop %ebp
+	ret
+
+.globl GetCR4
+GetCR4:
+	push %ebp
+	mov %esp, %ebp
+
+	xor %eax, %eax
+	mov %cr4, %eax 
+
+	mov %ebp, %esp 
+	pop %ebp
+	ret
+
+
+
+.globl GetEFLAGS
+GetEFLAGS:
+	push %ebp 
+	mov %esp, %ebp
+
+	xor %eax, %eax 
+	pushfl # Push the EFLAGS register content onto the stack, should be pushfd but GAS apparently doesn't agree
+	mov 4(%esp) , %eax
+
+	mov %ebp, %esp
+	pop %ebp
+	ret
+
+.globl GetCR2
+GetCR2:
+	push %ebp
+	mov %esp, %ebp
+
+	xor %eax, %eax
+	mov %cr2, %eax
+	
+	mov %ebp, %esp
+	pop %ebp
+	ret
+	
+.globl GetCR3
+GetCR3:
+	push %ebp
+	mov %esp, %ebp
+
+	xor %eax, %eax
+	mov %cr3, %eax
+	
+	mov %ebp, %esp
+	pop %ebp
+	ret
--- a/source/kernel/definitions.h
+++ b/source/kernel/definitions.h
@ -0,0 +1,9 @@
+#pragma once 
+/**
+ * Kernel definitions
+ */
+
+#define __DEBUG__ false
+#define KERNEL_VERSION 0
+
+#define ARCHITECTURE "I386"
--- a/source/kernel/io.cpp
+++ b/source/kernel/io.cpp
@ -0,0 +1,72 @@
+#include "io.h"
+
+unsigned char inb_p(unsigned short ){
+        // TODO: implement me!
+        return 0;
+}
+unsigned short inw(unsigned short ){
+// TODO: implement me!
+        return 0;
+}
+unsigned short inw_p(unsigned short ){
+// TODO: implement me!
+        return 0;
+}
+unsigned int inl(unsigned short ){
+// TODO: implement me!
+        return 0;
+}
+unsigned int inl_p(unsigned short ){
+// TODO: implement me!
+        return 0;
+}
+
+
+void b_p(unsigned char , unsigned short ){
+
+}
+void outw(unsigned short , unsigned short ){
+
+}
+void outw_p(unsigned short , unsigned short ){
+
+}
+void outl(unsigned int , unsigned short ){
+
+}
+void outl_p(unsigned int , unsigned short ){
+
+}
+
+void insb(unsigned short , void *,
+        unsigned long ){
+
+        }
+void insw(unsigned short , void *,
+        unsigned long ){
+
+        }
+void insl(unsigned short , void *,
+        unsigned long ){
+
+        }
+void outsb(unsigned short , const void *,
+        unsigned long ){
+
+        }
+void outsw(unsigned short , const void *,
+        unsigned long ){
+
+        }
+void outsl(unsigned short , const void *,
+        unsigned long ){
+
+        }
+
+void io_wait(void)
+{
+    /* TODO: This is probably fragile. */
+    asm volatile ( "jmp 1f\n\t"
+                   "1:jmp 2f\n\t"
+                   "2:" );
+}
--- a/source/kernel/io.h
+++ b/source/kernel/io.h
@ -0,0 +1,44 @@
+#pragma once
+#include <stdint.h>
+
+static inline uint8_t inb(uint16_t port)
+{
+    uint8_t ret;
+    asm volatile ( "inb %1, %0"
+                   : "=a"(ret)
+                   : "Nd"(port) );
+    return ret;
+}
+unsigned char inb_p(unsigned short port);
+unsigned short inw(unsigned short port);
+unsigned short inw_p(unsigned short port);
+unsigned int inl(unsigned short port);
+unsigned int inl_p(unsigned short port);
+
+static inline void outb(uint16_t port, uint8_t val)
+{
+    asm volatile ( "outb %0, %1" : : "a"(val), "Nd"(port) );
+    /* There's an outb %al, $imm8  encoding, for compile-time constant port numbers that fit in 8b.  (N constraint).
+     * Wider immediate constants would be truncated at assemble-time (e.g. "i" constraint).
+     * The  outb  %al, %dx  encoding is the only option for all other cases.
+     * %1 expands to %dx because  port  is a uint16_t.  %w1 could be used if we had the port number a wider C type */
+}
+void outb_p(unsigned char value, unsigned short port);
+void outw(unsigned short value, unsigned short port);
+void outw_p(unsigned short value, unsigned short port);
+void outl(unsigned int value, unsigned short port);
+void outl_p(unsigned int value, unsigned short port);
+
+void insb(unsigned short port, void *addr,
+        unsigned long count);
+void insw(unsigned short port, void *addr,
+        unsigned long count);
+void insl(unsigned short port, void *addr,
+        unsigned long count);
+void outsb(unsigned short port, const void *addr,
+        unsigned long count);
+void outsw(unsigned short port, const void *addr,
+        unsigned long count);
+void outsl(unsigned short port, const void *addr,
+        unsigned long count);
+void io_wait();
--- a/source/kernel/irq_table.s
+++ b/source/kernel/irq_table.s
@ -0,0 +1,138 @@
+.globl irq0
+irq0:
+	cli 
+	push $0
+	push $0
+	jmp irq_common
+
+.globl irq1
+irq1:
+	cli 
+	push $0
+	push $1
+	jmp irq_common
+
+.globl irq2
+irq2:
+	cli 
+	push $0
+	push $2
+	jmp irq_common
+
+.globl irq3
+irq3:
+	cli 
+	push $0
+	push $3
+	jmp irq_common
+
+.globl irq4
+irq4:
+	cli 
+	push $0
+	push $4
+	jmp irq_common
+
+.globl irq5
+irq5:
+	cli 
+	push $0
+	push $5
+	jmp irq_common
+
+.globl irq6
+irq6:
+	cli 
+	push $0
+	push $6
+	jmp irq_common
+
+.globl irq7
+irq7:
+	cli 
+	push $0
+	push $7
+	jmp irq_common
+
+.globl irq8
+irq8:
+	cli 
+	push $0
+	push $8
+	jmp irq_common
+
+.globl irq9
+irq9:
+	cli 
+	push $0
+	push $9
+	jmp irq_common
+
+.globl irq10
+irq10:
+	cli 
+	push $0
+	push $10
+	jmp irq_common
+
+.globl irq11
+irq11:
+	cli 
+	push $0
+	push $11
+	jmp irq_common
+
+
+.globl irq12
+irq12:
+	cli 
+	push $0
+	push $12
+	jmp irq_common
+
+.globl irq13
+irq13:
+	cli 
+	push $0
+	push $13
+	jmp irq_common
+
+.globl irq14
+irq14:
+	cli 
+	push $0
+	push $14
+	jmp irq_common
+
+.globl irq15
+irq15:
+	cli 
+	push $0
+	push $15
+	jmp irq_common
+
+irq_common:
+	pusha
+
+	mov %ds, %ax
+	push %eax
+
+	mov $0x10, %ax
+	mov %ax, %ds
+	mov %ax, %es
+	mov %ax, %fs
+	mov %ax, %gs
+
+	call irq_handler
+
+	pop %eax
+
+	mov %ax, %ds
+	mov %ax, %es
+	mov %ax, %fs
+	mov %ax, %gs
+
+	popa
+	add  $8, %esp  # cleans push error and irs code
+	sti
+	iret # pops 5 things at once: CS, EIP, EFLAGS, SS, and ESP
--- a/source/kernel/irs_table.s
+++ b/source/kernel/irs_table.s
@ -0,0 +1,256 @@
+/*
+* Interupt handlers
+*/
+
+.globl irs0
+irs0:
+	cli 
+	push $0
+	push $0
+	jmp irs_common
+
+.globl irs1
+irs1:
+	cli 
+	push $0
+	push $1
+	jmp irs_common
+
+.globl irs2
+irs2:
+	cli 
+	push $0
+	push $2
+	jmp irs_common
+
+.globl irs3
+irs3:
+	cli 
+	push $0
+	push $3
+	jmp irs_common
+
+.globl irs4
+irs4:
+	cli 
+	push $0
+	push $4
+	jmp irs_common
+
+.globl irs5
+irs5:
+	cli 
+	push $0
+	push $5
+	jmp irs_common
+
+.globl irs6
+irs6:
+	cli 
+	push $0
+	push $6
+	jmp irs_common
+
+.globl irs7
+irs7:
+	cli 
+	push $0
+	push $7
+	jmp irs_common
+
+.globl irs8
+irs8:
+	cli 
+	push $0
+	push $8
+	jmp irs_common
+
+.globl irs9
+irs9:
+	cli 
+	push $0
+	push $9
+	jmp irs_common
+
+.globl irs10
+irs10:
+	cli 
+	push $0
+	push $10
+	jmp irs_common
+
+.globl irs11
+irs11:
+	cli 
+	push $0
+	push $11
+	jmp irs_common
+
+.globl irs12
+irs12:
+	cli 
+	push $0
+	push $12
+	jmp irs_common
+
+.globl irs13
+irs13:
+	cli 
+	push $13
+	jmp irs_common
+
+.globl irs14
+irs14:
+	cli 
+	push $0
+	push $14
+	jmp irs_common
+
+.globl irs15
+irs15:
+	cli 
+	push $0
+	push $15
+	jmp irs_common
+
+.globl irs16
+irs16:
+	cli 
+	push $0
+	push $16
+	jmp irs_common
+
+.globl irs17
+irs17:
+	cli 
+	push $0
+	push $17
+	jmp irs_common
+
+.globl irs18
+irs18:
+	cli 
+	push $0
+	push $18
+	jmp irs_common
+
+.globl irs19
+irs19:
+	cli 
+	push $0
+	push $19
+	jmp irs_common
+
+.globl irs20
+irs20:
+	cli 
+	push $0
+	push $20
+	jmp irs_common
+
+.globl irs21
+irs21:
+	cli 
+	push $0
+	push $21
+	jmp irs_common
+
+.globl irs22
+irs22:
+	cli 
+	push $0
+	push $22
+	jmp irs_common
+
+.globl irs23
+irs23:
+	cli 
+	push $0
+	push $23
+	jmp irs_common
+
+.globl irs24
+irs24:
+	cli 
+	push $0
+	push $24
+	jmp irs_common
+
+.globl irs25
+irs25:
+	cli 
+	push $0
+	push $25
+	jmp irs_common
+
+.globl irs26
+irs26:
+	cli 
+	push $0
+	push $26
+	jmp irs_common
+
+.globl irs27
+irs27:
+	cli 
+	push $0
+	push $27
+	jmp irs_common
+
+.globl irs28
+irs28:
+	cli 
+	push $0
+	push $28
+	jmp irs_common
+
+.globl irs29
+irs29:
+	cli 
+	push $0
+	push $29
+	jmp irs_common
+
+.globl irs30
+irs30:
+	cli 
+	push $0
+	push $30
+	jmp irs_common
+
+.globl irs31
+irs31:
+	cli 
+	push $0
+	push $31
+	jmp irs_common
+
+
+irs_common:
+	pusha 				# Pushes edi,esi,ebp,esp,ebx,edx,ecx,eax
+
+
+	mov %ds, %ax
+	push %eax
+
+	/* load the kernel data segment descriptor*/
+
+	mov $0x10, %ax
+	mov %ax, %ds
+	mov %ax, %es
+	mov %ax, %fs
+	mov %ax, %gs
+
+	call irs_handler
+
+	pop %eax
+
+	mov %ax, %ds
+	mov %ax, %es
+	mov %ax, %fs
+	mov %ax, %gs
+
+	popa
+	add  $8, %esp  # cleans push error and irs code
+	sti
+	iret # pops 5 things at once: CS, EIP, EFLAGS, SS, and ESP
--- a/source/kernel/kernel.cpp
+++ b/source/kernel/kernel.cpp
@ -0,0 +1,159 @@
+#include "kernel.h"
+
+extern "C" void early_main(unsigned long magic, unsigned long addr){
+
+    // Convert MBI address to higher quarter kernel space
+    addr += KERNEL_BASE_ADDR;
+    /** 
+     * Initialize terminal interface 
+     * NOTE: This should be done later on , the magic value should be checked first.
+     */ 
+    initGDT();
+    kterm_init();
+    init_serial();
+    print_serial("Hello Higher half kernel!\n");
+ 
+    init_idt();
+    // Enable interrupts
+    asm volatile("STI");
+
+   
+    printf("DEBUG:\n Magic: 0x%x\n MBT_addr: 0x%x\n", magic, addr);
+    /**
+     * Check Multiboot magic number
+     * NOTE: Printf call should not be a thing this early on ...
+    */ 
+    if (magic != MULTIBOOT_BOOTLOADER_MAGIC){
+        printf("Invalid magic number: 0x%x\n",  magic);
+        return;
+    }
+
+    /**
+     * Show a little banner for cuteness
+     */
+    printf("|===    BarinkOS       ===|\n");
+    /**
+     * Use the address given as an argument as the pointer
+     * to a Multiboot information structure.
+     */
+        multiboot_info_t* mbt = (multiboot_info_t*) (addr );
+
+    /**
+     * Construct our own bootInfo structure
+     */
+        BootInfo bootinfo = {};
+       
+        
+    /*
+        If we got a memory map from our bootloader we 
+        should be parsing it to find out the memory regions available.
+    */
+    if (CHECK_FLAG(mbt->flags, 6))
+    {  
+    
+        /*
+            Setup Physical memory managment
+        */
+        MemoryInfo meminfo = {};
+        bootinfo.memory = &meminfo;
+ 
+        ///mapMultibootMemoryMap(bootinfo.memory , mbt);        
+        printf("Memory size: 0x%x bytes\n", bootinfo.memory->TotalMemory );
+
+       /*
+        PhysicalMemory memAlloc = PhysicalMemory{};
+        memAlloc.setup(bootinfo.memory );
+        */
+
+        // TODO: FIX physical allocator
+        /*
+         Mark already in use sections 
+        */
+        
+        // Mark kernel memory as used
+        printf("Kernel Begin Pointer: 0x%x, Kernel end pointer: 0x%x\n", &kernel_begin , &kernel_end );
+       
+       
+        multiboot_memory_map_t *mmap = (multiboot_memory_map_t*) (mbt->mmap_addr + KERNEL_BASE_ADDR) ;
+
+        for (;  (unsigned long) mmap < mbt->mmap_addr + mbt->mmap_length;  mmap = (multiboot_memory_map_t *) ((unsigned long) mmap + mmap->size + sizeof(mmap->size))){
+
+            if ( mmap->type == MULTIBOOT_MEMORY_AVAILABLE){
+                  
+            } else{
+                printf("allocate region: 0x%x, size : 0x%x bytes\n", (unsigned) mmap->addr,(unsigned) mmap->len  );
+               // memAlloc.allocate_region((unsigned)mmap->addr , (unsigned)mmap->len);
+            }
+          
+            
+        } 
+
+
+       printf("allocate region: 0x%x, size : 0x%x bytes\n", &kernel_begin, &kernel_end - &kernel_begin );
+       //memAlloc.allocate_region(kernel_end, kernel_end - kernel_begin);
+    
+        // test alloc_block
+        /*
+        uint8_t* memory = (uint8_t*) memAlloc.allocate_block();
+        printf("Got a new pointer: 0x%x\n", memory);
+
+        uint8_t* memory2 = (uint8_t*) memAlloc.allocate_block();
+        printf("Got a new pointer: 0x%x\n", memory2);
+
+
+        memAlloc.free_block((void*) memory);
+
+        uint8_t* newBlockPlse = (uint8_t*) memAlloc.allocate_block();
+        */
+
+
+
+        //memAlloc.free_block((void*) memory);
+        //InitializePaging();
+        //IdentityMap();
+        //Enable();
+    } else{
+        printf("memory flag not set!");
+    }
+    
+    CheckMBT( (multiboot_info_t *) addr);
+	asm volatile("mov %cr0, %eax ");
+    asm volatile("or $1, %eax");
+    asm volatile("mov %eax, %cr0");
+    kernel_main(&bootinfo);
+    
+}
+
+void map_multiboot_info_structure(unsigned long addr){
+    // map the multiboot structure into virtual memory 
+    // so we can gather the necessary data from it.
+
+    uint32_t pageDirectoryIndex = (addr )  >> 22;
+    printf("pageDirectoryIndex: %d\n", pageDirectoryIndex);
+
+    uint32_t pageTableIndex = (addr  >> 12)  & 0x1FFF;
+    printf("PagTableIndex: %d\n", pageTableIndex);
+
+
+    printf("boot_page_directory addr: 0x%x\n", &boot_page_directory);
+    printf("boot_page_table addr: 0x%x\n", &multiboot_page_table);
+
+    uint32_t* current_page_directory = &boot_page_directory;
+    uint32_t* needed_page_table = &multiboot_page_table - KERNEL_BASE_ADDR;
+    // set the page tabel reference;
+    current_page_directory[pageDirectoryIndex]  = (uint32_t)&multiboot_page_table - KERNEL_BASE_ADDR + 0x003;
+
+    // set the page reference;
+    needed_page_table[ pageTableIndex ] = addr | 0x003;
+
+
+    // Reload CR3 to force a flush
+    asm("movl %cr3, %ecx;" "movl %ecx, %cr3" );
+}
+
+    
+extern "C" void kernel_main (BootInfo* bootinfo) {
+    pit_initialise();
+
+    startSuperVisorTerminal(bootinfo);
+}   
--- a/source/kernel/kernel.h
+++ b/source/kernel/kernel.h
@ -0,0 +1,46 @@
+#pragma once
+extern "C" 
+{
+   #include "Lib/string.h" 
+}
+
+#include "definitions.h"
+
+#include "Drivers/VGA/VBE.h"
+#include "Terminal/kterm.h"
+
+#include "multiboot.h"
+#include "bootinfo.h"
+
+#include "Memory/PhysicalMemoryManager.h"
+#include "Memory/memoryinfo.h"
+#include "Memory/VirtualMemoryManager.h"
+#include "KernelLauncher/bootcheck.h"
+
+#include "Memory/GDT/gdtc.h"
+#include "Interrupts/idt/idt.h"
+
+#include "Drivers/PIT/pit.h"
+#include "io.h"
+#include "cpu.h"
+#include "serial.h"
+
+#include "time.h"
+#include "SuperVisorTerminal/superVisorTerminal.h"
+
+#define CHECK_FLAG(flag, bit) ( flag & (1 << bit ))
+#define PANIC(message) {return;} 
+
+
+void map_multiboot_info_structure(unsigned long addr);
+
+extern "C" void kernel_main (BootInfo* bootinfo);
+
+extern "C" const void* kernel_begin;
+extern "C" const void* kernel_end;
+
+extern "C" uint32_t boot_page_directory;
+extern "C" uint32_t multiboot_page_table;
+
+
+const uint32_t KERNEL_BASE_ADDR = 0xC0000000;
--- a/source/kernel/linker.ld
+++ b/source/kernel/linker.ld
@ -0,0 +1,46 @@
+ENTRY(_start)
+ 
+/* Tell where the various sections of the object files will be put in the final
+   kernel image. */
+SECTIONS
+{
+	. = 0x00100000;  /* place code at 1MB mark*/
+ 
+	_kernel_start	= .;
+	kernel_begin	= .; /*  For legacy reasons */
+
+
+	.multiboot.data : {
+		*(.multiboot.data)
+	}
+
+	.multiboot.text : {
+		*(multiboot.text)
+		*launcher.o(.text)
+	}
+
+	. += 0xC0000000; /* Addresses in the following code need to be above the 3Gb mark */
+
+
+	.text ALIGN (4K) : AT (ADDR (.text) - 0xC0000000)
+	{
+		*(.text)
+	}
+	.rodata ALIGN (4K) : AT (ADDR (.rodata) - 0xC0000000)
+	{
+		*(.rodata)
+	}
+	.data ALIGN (4K) : AT (ADDR (.data) - 0xC0000000)
+	{
+		*(.data)
+	}
+	.bss ALIGN (4K) : AT (ADDR (.bss) - 0xC0000000)
+	{
+		*(COMMON)
+		*(.bss)
+		*(.bootstrap_stack)
+	}
+	_kernel_end = .;
+	kernel_end = .; /* For legacy reasons */
+}
+
--- a/source/kernel/multiboot.h
+++ b/source/kernel/multiboot.h
@ -0,0 +1,274 @@
+/* multiboot.h - Multiboot header file. */
+/* Copyright (C) 1999,2003,2007,2008,2009,2010  Free Software Foundation, Inc.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to
+ *  deal in the Software without restriction, including without limitation the
+ *  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ *  sell copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL ANY
+ *  DEVELOPER OR DISTRIBUTOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ *  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+ *  IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef MULTIBOOT_HEADER
+#define MULTIBOOT_HEADER 1
+
+/* How many bytes from the start of the file we search for the header. */
+#define MULTIBOOT_SEARCH                        8192
+#define MULTIBOOT_HEADER_ALIGN                  4
+
+/* The magic field should contain this. */
+#define MULTIBOOT_HEADER_MAGIC                  0x1BADB002
+
+/* This should be in %eax. */
+#define MULTIBOOT_BOOTLOADER_MAGIC              0x2BADB002
+
+/* Alignment of multiboot modules. */
+#define MULTIBOOT_MOD_ALIGN                     0x00001000
+
+/* Alignment of the multiboot info structure. */
+#define MULTIBOOT_INFO_ALIGN                    0x00000004
+
+/* Flags set in the ’flags’ member of the multiboot header. */
+
+/* Align all boot modules on i386 page (4KB) boundaries. */
+#define MULTIBOOT_PAGE_ALIGN                    0x00000001
+
+/* Must pass memory information to OS. */
+#define MULTIBOOT_MEMORY_INFO                   0x00000002
+
+/* Must pass video information to OS. */
+#define MULTIBOOT_VIDEO_MODE                    0x00000004
+
+/* This flag indicates the use of the address fields in the header. */
+#define MULTIBOOT_AOUT_KLUDGE                   0x00010000
+
+/* Flags to be set in the ’flags’ member of the multiboot info structure. */
+
+/* is there basic lower/upper memory information? */
+#define MULTIBOOT_INFO_MEMORY                   0x00000001
+/* is there a boot device set? */
+#define MULTIBOOT_INFO_BOOTDEV                  0x00000002
+/* is the command-line defined? */
+#define MULTIBOOT_INFO_CMDLINE                  0x00000004
+/* are there modules to do something with? */
+#define MULTIBOOT_INFO_MODS                     0x00000008
+
+/* These next two are mutually exclusive */
+
+/* is there a symbol table loaded? */
+#define MULTIBOOT_INFO_AOUT_SYMS                0x00000010
+/* is there an ELF section header table? */
+#define MULTIBOOT_INFO_ELF_SHDR                 0X00000020
+
+/* is there a full memory map? */
+#define MULTIBOOT_INFO_MEM_MAP                  0x00000040
+
+/* Is there drive info? */
+#define MULTIBOOT_INFO_DRIVE_INFO               0x00000080
+
+/* Is there a config table? */
+#define MULTIBOOT_INFO_CONFIG_TABLE             0x00000100
+
+/* Is there a boot loader name? */
+#define MULTIBOOT_INFO_BOOT_LOADER_NAME         0x00000200
+
+/* Is there a APM table? */
+#define MULTIBOOT_INFO_APM_TABLE                0x00000400
+
+/* Is there video information? */
+#define MULTIBOOT_INFO_VBE_INFO                 0x00000800
+#define MULTIBOOT_INFO_FRAMEBUFFER_INFO         0x00001000
+
+#ifndef ASM_FILE
+
+typedef unsigned char           multiboot_uint8_t;
+typedef unsigned short          multiboot_uint16_t;
+typedef unsigned int            multiboot_uint32_t;
+typedef unsigned long long      multiboot_uint64_t;
+
+struct multiboot_header
+{
+  /* Must be MULTIBOOT_MAGIC - see above. */
+  multiboot_uint32_t magic;
+
+  /* Feature flags. */
+  multiboot_uint32_t flags;
+
+  /* The above fields plus this one must equal 0 mod 2^32. */
+  multiboot_uint32_t checksum;
+
+  /* These are only valid if MULTIBOOT_AOUT_KLUDGE is set. */
+  multiboot_uint32_t header_addr;
+  multiboot_uint32_t load_addr;
+  multiboot_uint32_t load_end_addr;
+  multiboot_uint32_t bss_end_addr;
+  multiboot_uint32_t entry_addr;
+
+  /* These are only valid if MULTIBOOT_VIDEO_MODE is set. */
+  multiboot_uint32_t mode_type;
+  multiboot_uint32_t width;
+  multiboot_uint32_t height;
+  multiboot_uint32_t depth;
+};
+
+/* The symbol table for a.out. */
+struct multiboot_aout_symbol_table
+{
+  multiboot_uint32_t tabsize;
+  multiboot_uint32_t strsize;
+  multiboot_uint32_t addr;
+  multiboot_uint32_t reserved;
+};
+typedef struct multiboot_aout_symbol_table multiboot_aout_symbol_table_t;
+
+/* The section header table for ELF. */
+struct multiboot_elf_section_header_table
+{
+  multiboot_uint32_t num;
+  multiboot_uint32_t size;
+  multiboot_uint32_t addr;
+  multiboot_uint32_t shndx;
+};
+typedef struct multiboot_elf_section_header_table multiboot_elf_section_header_table_t;
+
+struct multiboot_info
+{
+  /* Multiboot info version number */
+  multiboot_uint32_t flags;
+
+  /* Available memory from BIOS */
+  multiboot_uint32_t mem_lower;
+  multiboot_uint32_t mem_upper;
+
+  /* "root" partition */
+  multiboot_uint32_t boot_device;
+
+  /* Kernel command line */
+  multiboot_uint32_t cmdline;
+
+  /* Boot-Module list */
+  multiboot_uint32_t mods_count;
+  multiboot_uint32_t mods_addr;
+
+  union
+  {
+    multiboot_aout_symbol_table_t aout_sym;
+    multiboot_elf_section_header_table_t elf_sec;
+  } u;
+
+  /* Memory Mapping buffer */
+  multiboot_uint32_t mmap_length;
+  multiboot_uint32_t mmap_addr;
+
+  /* Drive Info buffer */
+  multiboot_uint32_t drives_length;
+  multiboot_uint32_t drives_addr;
+
+  /* ROM configuration table */
+  multiboot_uint32_t config_table;
+
+  /* Boot Loader Name */
+  multiboot_uint32_t boot_loader_name;
+
+  /* APM table */
+  multiboot_uint32_t apm_table;
+
+  /* Video */
+  multiboot_uint32_t vbe_control_info;
+  multiboot_uint32_t vbe_mode_info;
+  multiboot_uint16_t vbe_mode;
+  multiboot_uint16_t vbe_interface_seg;
+  multiboot_uint16_t vbe_interface_off;
+  multiboot_uint16_t vbe_interface_len;
+
+  multiboot_uint64_t framebuffer_addr;
+  multiboot_uint32_t framebuffer_pitch;
+  multiboot_uint32_t framebuffer_width;
+  multiboot_uint32_t framebuffer_height;
+  multiboot_uint8_t framebuffer_bpp;
+#define MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED 0
+#define MULTIBOOT_FRAMEBUFFER_TYPE_RGB     1
+#define MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT     2
+  multiboot_uint8_t framebuffer_type;
+  union
+  {
+    struct
+    {
+      multiboot_uint32_t framebuffer_palette_addr;
+      multiboot_uint16_t framebuffer_palette_num_colors;
+    };
+    struct
+    {
+      multiboot_uint8_t framebuffer_red_field_position;
+      multiboot_uint8_t framebuffer_red_mask_size;
+      multiboot_uint8_t framebuffer_green_field_position;
+      multiboot_uint8_t framebuffer_green_mask_size;
+      multiboot_uint8_t framebuffer_blue_field_position;
+      multiboot_uint8_t framebuffer_blue_mask_size;
+    };
+  };
+};
+typedef struct multiboot_info multiboot_info_t;
+
+struct multiboot_color
+{
+  multiboot_uint8_t red;
+  multiboot_uint8_t green;
+  multiboot_uint8_t blue;
+};
+
+struct multiboot_mmap_entry
+{
+  multiboot_uint32_t size;
+  multiboot_uint64_t addr;
+  multiboot_uint64_t len;
+#define MULTIBOOT_MEMORY_AVAILABLE              1
+#define MULTIBOOT_MEMORY_RESERVED               2
+#define MULTIBOOT_MEMORY_ACPI_RECLAIMABLE       3
+#define MULTIBOOT_MEMORY_NVS                    4
+#define MULTIBOOT_MEMORY_BADRAM                 5
+  multiboot_uint32_t type;
+} __attribute__((packed));
+typedef struct multiboot_mmap_entry multiboot_memory_map_t;
+
+struct multiboot_mod_list
+{
+  /* the memory used goes from bytes ’mod_start’ to ’mod_end-1’ inclusive */
+  multiboot_uint32_t mod_start;
+  multiboot_uint32_t mod_end;
+
+  /* Module command line */
+  multiboot_uint32_t cmdline;
+
+  /* padding to take it to 16 bytes (must be zero) */
+  multiboot_uint32_t pad;
+};
+typedef struct multiboot_mod_list multiboot_module_t;
+
+/* APM BIOS info. */
+struct multiboot_apm_info
+{
+  multiboot_uint16_t version;
+  multiboot_uint16_t cseg;
+  multiboot_uint32_t offset;
+  multiboot_uint16_t cseg_16;
+  multiboot_uint16_t dseg;
+  multiboot_uint16_t flags;
+  multiboot_uint16_t cseg_len;
+  multiboot_uint16_t cseg_16_len;
+  multiboot_uint16_t dseg_len;
+};
+
+#endif /* ! ASM_FILE */
+
+#endif /* ! MULTIBOOT_HEADER */
--- a/source/kernel/serial.h
+++ b/source/kernel/serial.h
@ -0,0 +1,75 @@
+#pragma once
+
+#include "Terminal/kterm.h"
+#include "io.h"
+#define PORT 0x3f8 
+static int init_serial() {
+
+#ifdef __VERBOSE__
+   printf("Init Serial\n");
+#endif
+   
+   outb(PORT + 1, 0x00);    // Disable all interrupts
+   outb(PORT + 3, 0x80);    // Enable DLAB (set baud rate divisor)
+   outb(PORT + 0, 0x03);    // Set divisor to 3 (lo byte) 38400 baud
+   outb(PORT + 1, 0x00);    //                  (hi byte)
+   outb(PORT + 3, 0x03);    // 8 bits, no parity, one stop bit
+   outb(PORT + 2, 0xC7);    // Enable FIFO, clear them, with 14-byte threshold
+   outb(PORT + 4, 0x0B);    // IRQs enabled, RTS/DSR set
+   outb(PORT + 4, 0x1E);    // Set in loopback mode, test the serial chip
+   outb(PORT + 0, 0xAE);    // Test serial chip (send byte 0xAE and check if serial returns same byte)
+ 
+   // Check if serial is faulty (i.e: not same byte as sent)
+   if(inb(PORT + 0) != 0xAE) {
+      return 1;
+   }
+ 
+   // If serial is not faulty set it in normal operation mode
+   // (not-loopback with IRQs enabled and OUT#1 and OUT#2 bits enabled)
+   outb(PORT + 4, 0x0F);
+   return 0;
+}
+
+int is_transmit_empty() {
+   return inb(PORT + 5) & 0x20;
+}
+ 
+void write_serial(char a) {
+   while (is_transmit_empty() == 0);
+ 
+   outb(PORT,a);
+}
+
+int serial_received() {
+   return inb(PORT + 5) & 1;
+}
+ 
+char read_serial() {
+   while (serial_received() == 0);
+ 
+   return inb(PORT);
+}
+
+void print_serial(const char* string ){
+    for(size_t i = 0; i < strlen(string); i ++){
+        write_serial(string[i]);
+    }
+}
+
+void test_serial(){
+        /** Serial test **/
+        kterm_writestring("Writing to COM1 serial port:");
+        init_serial();
+        write_serial('A');
+        write_serial('B');
+        write_serial('C');
+        write_serial('D');
+        write_serial('E');
+
+        char Character_received = read_serial();
+        kterm_writestring("\n");
+        kterm_writestring("received from COM 1: \n");
+        kterm_put(Character_received);
+
+        kterm_writestring("\n");
+}
--- a/source/kernel/time.cpp
+++ b/source/kernel/time.cpp
@ -0,0 +1,111 @@
+#include "time.h"
+
+// Set by ACPI table parsing code if possible
+int century_register = 0x00;     
+unsigned char second;
+unsigned char minute;
+unsigned char hour;
+unsigned char day;
+unsigned char month;
+unsigned int year;
+ 
+
+int get_update_in_progress_flag() {
+      outb(cmos_address, 0x0A);
+      return (inb(cmos_data) & 0x80);
+}
+ 
+unsigned char get_RTC_register(int reg) {
+      outb(cmos_address, reg);
+      return inb(cmos_data);
+}
+ 
+void read_rtc() {
+      unsigned char century;
+      unsigned char last_second;
+      unsigned char last_minute;
+      unsigned char last_hour;
+      unsigned char last_day;
+      unsigned char last_month;
+      unsigned char last_year;
+      unsigned char last_century;
+      unsigned char registerB;
+ 
+      // Note: This uses the "read registers until you get the same values twice in a row" technique
+      //       to avoid getting dodgy/inconsistent values due to RTC updates
+ 
+      while (get_update_in_progress_flag());                // Make sure an update isn't in progress
+      second = get_RTC_register(0x00);
+      minute = get_RTC_register(0x02);
+      hour = get_RTC_register(0x04);
+      day = get_RTC_register(0x07);
+      month = get_RTC_register(0x08);
+      year = get_RTC_register(0x09);
+      if(century_register != 0) {
+            century = get_RTC_register(century_register);
+      } else {
+            century = 21;
+      }
+ 
+      do {
+            last_second = second;
+            last_minute = minute;
+            last_hour = hour;
+            last_day = day;
+            last_month = month;
+            last_year = year;
+            last_century = century;
+ 
+            while (get_update_in_progress_flag());           // Make sure an update isn't in progress
+            second = get_RTC_register(0x00);
+            minute = get_RTC_register(0x02);
+            hour = get_RTC_register(0x04);
+            day = get_RTC_register(0x07);
+            month = get_RTC_register(0x08);
+            year = get_RTC_register(0x09);
+            if(century_register != 0) {
+                  century = get_RTC_register(century_register);
+            }
+      } while( (last_second != second) || (last_minute != minute) || (last_hour != hour) ||
+               (last_day != day) || (last_month != month) || (last_year != year) ||
+               (last_century != century) );
+ 
+      registerB = get_RTC_register(0x0B);
+ 
+      // Convert BCD to binary values if necessary
+ 
+      if (!(registerB & 0x04)) {
+            second = (second & 0x0F) + ((second / 16) * 10);
+            minute = (minute & 0x0F) + ((minute / 16) * 10);
+            hour = ( (hour & 0x0F) + (((hour & 0x70) / 16) * 10) ) | (hour & 0x80);
+            day = (day & 0x0F) + ((day / 16) * 10);
+            month = (month & 0x0F) + ((month / 16) * 10);
+            year = (year & 0x0F) + ((year / 16) * 10);
+            if(century_register != 0) {
+                  century = (century & 0x0F) + ((century / 16) * 10);
+            }
+      }
+ 
+      // Convert 12 hour clock to 24 hour clock if necessary
+ 
+      if (!(registerB & 0x02) && (hour & 0x80)) {
+            hour = ((hour & 0x7F) + 12) % 24;
+      }
+ 
+      // Calculate the full (4-digit) year
+ 
+      if(century_register != 0) {
+            year += century * 100;
+      } else {
+            year += (CURRENT_YEAR / 100) * 100;
+            if(year < CURRENT_YEAR) year += 100;
+      }
+}
+
+
+void delay(int t){
+    volatile int i,j;
+    for(i=0;i<t;i++)
+        for(j=0;j<25000;j++)
+            asm("NOP");
+}
--- a/source/kernel/time.h
+++ b/source/kernel/time.h
@ -0,0 +1,23 @@
+#pragma once 
+#include "io.h"
+#define CURRENT_YEAR        2021
+ 
+                           
+extern int century_register;     
+extern unsigned char second;
+extern unsigned char minute;
+extern unsigned char hour;
+extern unsigned char day;
+extern unsigned char month;
+extern unsigned int year;
+
+ 
+enum {
+      cmos_address = 0x70,
+      cmos_data    = 0x71
+};
+ 
+int get_update_in_progress_flag();
+unsigned char get_RTC_register();
+void read_rtc();
+void delay(int t);
--- a/source/kernel/timer.cpp
+++ b/source/kernel/timer.cpp
@ -0,0 +1,27 @@
+#include "timer.h"
+
+uint32_t tick = 0;
+
+
+static void timer_callback (registers_t regs ){
+    tick ++ ;
+    kterm_writestring ("tick passed!");
+}
+
+void init_timer (uint32_t frequency){
+    // register timer callback
+
+    uint32_t divisor = 1193180 / frequency;
+
+    // Send the commmand byte
+    outb(0x43, 0x36);
+
+    // Divisor has to be sent byt-wise , so will send lower then upper bytes
+    uint8_t low = (uint8_t) (divisor & 0xFF);
+    uint8_t high = (uint8_t) ((divisor >> 8) & 0xFF);
+
+    outb(0x40, low);
+    outb(0x40, high);
+
+
+}
--- a/source/kernel/timer.h
+++ b/source/kernel/timer.h
@ -0,0 +1,6 @@
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+
+void init_timer (uint32_t frequency);