Implemented serial for basic debugging, Added MMU enable to kernel main

Makefile

@@ -2,9 +2,10 @@
 EMULATOR = qemu-system-i386
 AS = ${HOME}/opt/cross/bin/i686-elf-as
 CC = ${HOME}/opt/cross/bin/i686-elf-gcc
-CFLAGS = -std=gnu99 -ffreestanding -O2 -Wall -Wextra
+CPP = ${HOME}/opt/cross/bin/i686-elf-g++ 
+CFLAGS =  -ffreestanding -O2 -Wall -Wextra
 
-OFILES =	$(BUILD_DIR)/boot.o $(BUILD_DIR)/kterm.o $(BUILD_DIR)/kernel.o 
+OFILES =	$(BUILD_DIR)/boot.o $(BUILD_DIR)/kterm.o $(BUILD_DIR)/kernel.o $(BUILD_DIR)/io.o $(BUILD_DIR)/MMU.o
 
 SRC_DIR = src
 BUILD_DIR = build
@@ -23,7 +24,8 @@ all: clean build
 build: build_kernel run 
 
 run:
-	$(EMULATOR) -kernel $(BUILD_DIR)/myos.bin 
+	$(EMULATOR) -kernel $(BUILD_DIR)/myos.bin -serial stdio
+
 build_kernel: $(OBJ_LINK_LIST)
 	
 	$(CC) -T $(SRC_DIR)/kernel/arch/i386/linker.ld -o $(BUILD_DIR)/myos.bin \
@@ -37,10 +39,10 @@ clean:
 	rm -f $(BUILD_DIR)/myos.bin $(INTERNAL_OBJS)
 
 $(BUILD_DIR)/kernel.o:
-	$(CC) -c $(SRC_DIR)/kernel/kernel.c  -o $(BUILD_DIR)/kernel.o $(CFLAGS)
+	$(CPP) -c $(SRC_DIR)/kernel/kernel.cpp -o $(BUILD_DIR)/kernel.o $(CFLAGS) -fno-exceptions -fno-rtti
 
 $(BUILD_DIR)/kterm.o:
-	$(CC) -c $(SRC_DIR)/kernel/arch/i386/tty/kterm.c  -o $(BUILD_DIR)/kterm.o $(CFLAGS)
+	$(CC) -c $(SRC_DIR)/kernel/arch/i386/tty/kterm.c  -o $(BUILD_DIR)/kterm.o $(CFLAGS) -std=gnu99
 
 $(BUILD_DIR)/boot.o:
 	$(AS) $(SRC_DIR)/kernel/arch/i386/boot.s -o $(BUILD_DIR)/boot.o
@@ -50,3 +52,8 @@ $(BUILD_DIR)/crti.o:
 
 $(BUILD_DIR)/crtn.o:
 	$(AS) $(SRC_DIR)/kernel/arch/i386/crtn.s -o $(BUILD_DIR)/crtn.o
+
+$(BUILD_DIR)/io.o:
+		$(CPP) -c $(SRC_DIR)/kernel/io.cpp  -o $(BUILD_DIR)/io.o $(CFLAGS) -fno-exceptions -fno-rtti
+$(BUILD_DIR)/MMU.o:
+	$(CPP) -c $(SRC_DIR)/kernel/MMU.cpp -o $(BUILD_DIR)/MMU.o $(CFLAGS) -fno-exceptions -fno-rtti 

TODO.md

@@ -5,7 +5,7 @@
 <input type="checkbox" checked/> Printing string to the screen \
 <input type="checkbox" /> Printing values/numbers to the screen (a.k.k itoa) \
 <input type="checkbox" /> Extend Multiboot implementation \
-<input type="checkbox" /> Output to serial port \
+<input type="checkbox" checked/> Output to serial port \
 <input type="checkbox" /> Move to protected mode \
 <input type="checkbox" /> Enabel CMOS clock \
 <input type="checkbox" /> Time measurement (PIC &| PIT) \

src/kernel/arch/i386/ports/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!
+}

src/kernel/arch/i386/ports/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();
+};

src/kernel/arch/i386/tty/kterm.c

@@ -88,4 +88,5 @@ void kterm_write(const char* data, size_t size) {
 void kterm_writestring(const char* data ){
     AS_KERNEL();
     kterm_write(data, strlen(data));
-}
+}
+

src/kernel/arch/i386/tty/kterm.h

@@ -3,6 +3,7 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <stdbool.h>
+
 #include "../vga/colors.h"
 
 void kterm_init();

src/kernel/io.cpp

@@ -0,0 +1,59 @@
+#include "io.h"
+
+unsigned char inb_p(unsigned short ){
+
+}
+unsigned short inw(unsigned short ){
+
+}
+unsigned short inw_p(unsigned short ){
+
+}
+unsigned int inl(unsigned short ){
+
+}
+unsigned int inl_p(unsigned short ){
+
+}
+
+
+void outb_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 ){
+
+        }

src/kernel/io.h

@@ -0,0 +1,43 @@
+#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);

src/kernel/kernel.c

@@ -1,27 +0,0 @@
-#include "kernel.h"
-/**
- *      simple delay function 
- **/
-void delay(int t){
-    volatile int i,j;
-    for(i=0;i<t;i++)
-        for(j=0;j<25000;j++)
-            asm("NOP");
-}
-
-void kernel_main (void) {
-    /** initialize terminal interface */ 
-    kterm_init();
-
-    /** Wrtite stuff to the screen to test the terminal**/ 
-    kterm_writestring("Hello world!\n");
-    kterm_writestring("We got newline support!\n");
-
-    for(;;){
-        delay(500);
-        kterm_writestring("We have implemented terminal scrolling!\n");
-    }
-   
-   
-}   
-

src/kernel/kernel.cpp

@@ -0,0 +1,136 @@
+#include "kernel.h"
+/**
+ *      simple delay function 
+ **/
+void delay(int t){
+    volatile int i,j;
+    for(i=0;i<t;i++)
+        for(j=0;j<25000;j++)
+            asm("NOP");
+}
+
+class Test {
+    public:
+         Test();
+        void printMe();
+         ~Test();
+};
+
+
+Test::Test(){
+    kterm_writestring("Create a test object\n");
+};
+
+void Test::printMe(){
+    kterm_writestring("testObject.printMe()\n");
+}
+
+Test::~Test(){
+    kterm_writestring("Destroy testObject! Bye bye\n");
+}
+
+#define PORT 0x3f8 
+static int init_serial() {
+   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 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");
+}
+
+
+extern "C" {
+    void kernel_main (void) {
+        /** initialize terminal interface */ 
+        kterm_init();
+
+        /** Wrtite stuff to the screen to test the terminal**/ 
+        kterm_writestring("Hello world!\n");
+        kterm_writestring("We got newline support!\n");
+
+        /** Test scrolling **/
+        for(int i=0; i < 5; i++){
+            delay(500);
+            kterm_writestring("We have implemented terminal scrolling!\n");
+        }
+    
+
+        /** Test objective cpp **/
+        kterm_writestring("Testing C++ object support\n");
+        auto testObject = Test();
+        testObject.printMe();
+
+        /** Setup the MMU **/
+        kterm_writestring("Starting MMU...\n");
+        auto mmu = MMU();
+        mmu.enable();
+        kterm_writestring("MMU enabled!\n");
+
+        
+
+
+        /** Lets start using the serial port for debugging .. **/
+        // Hopefully once we go into realmode or do something that
+        // cause the screen to go black.. this serial comms part will give
+        // some situational awareness
+        //Serial serialbus = Serial::init();
+
+        test_serial();
+
+    
+    }   
+}

src/kernel/kernel.h

@@ -1,3 +1,7 @@
 #pragma once 
+extern "C" {
 #include "../libc/include/string.h"
 #include "arch/i386/tty/kterm.h"
+}
+#include "MMU.h"
+#include "io.h"