kernel.c

#include <stddef.h>
#include <stdint.h>

// Core OS includes
#include "idt.h"
#include "isr.h"
#include "pic.h"
#include "io.h"       // Include for inb/outb if needed directly, or rely on drivers

// Driver/Module includes
#include "keyboard.h"
#include "shell.h"
#include "memory.h"
#include "filesystem.h"

// VGA color constants
enum vga_color {
    VGA_BLACK = 0,
    VGA_BLUE = 1,
    VGA_GREEN = 2,
    VGA_CYAN = 3,
    VGA_RED = 4,
    VGA_MAGENTA = 5,
    VGA_BROWN = 6,
    VGA_LIGHT_GREY = 7,
    VGA_DARK_GREY = 8,
    VGA_LIGHT_BLUE = 9,
    VGA_LIGHT_GREEN = 10,
    VGA_LIGHT_CYAN = 11,
    VGA_LIGHT_RED = 12,
    VGA_LIGHT_MAGENTA = 13,
    VGA_LIGHT_BROWN = 14,
    VGA_WHITE = 15,
};

static uint16_t* const VGA_MEMORY = (uint16_t*)0xB8000;
static const size_t VGA_WIDTH = 80;
static const size_t VGA_HEIGHT = 25;
static size_t terminal_row = 0;
static size_t terminal_column = 0;

// Create a VGA entry from character and color
static inline uint16_t vga_entry(unsigned char c, uint8_t color) {
    return (uint16_t) c | (uint16_t) color << 8;
}

// Initialize the terminal
void terminal_initialize(void) {
    uint8_t color = VGA_LIGHT_GREY | VGA_BLACK << 4;
    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;
            VGA_MEMORY[index] = vga_entry(' ', color);
        }
    }
    terminal_reset_position();
}

// Reset cursor position
void terminal_reset_position() {
    terminal_row = 0;
    terminal_column = 0;
}

// Clear the terminal and reset position
void terminal_clear() {
    terminal_initialize();
    terminal_reset_position();
    const char* welcome = "Welcome to MyOS!\nType 'help' for available commands.\n\n";
    terminal_putstr(welcome);
}

// Put a single character at specified position
void terminal_putchar_at(char c, uint8_t color, size_t x, size_t y) {
    const size_t index = y * VGA_WIDTH + x;
    VGA_MEMORY[index] = vga_entry(c, color);
}

// Add this function before terminal_putchar
void terminal_scroll() {
    uint8_t color = VGA_LIGHT_GREY | VGA_BLACK << 4;
    
    // Move all lines up one position
    for (size_t y = 0; y < VGA_HEIGHT - 1; y++) {
        for (size_t x = 0; x < VGA_WIDTH; x++) {
            size_t current_index = y * VGA_WIDTH + x;
            size_t next_index = (y + 1) * VGA_WIDTH + x;
            VGA_MEMORY[current_index] = VGA_MEMORY[next_index];
        }
    }
    
    // Clear the last line
    for (size_t x = 0; x < VGA_WIDTH; x++) {
        size_t index = (VGA_HEIGHT - 1) * VGA_WIDTH + x;
        VGA_MEMORY[index] = vga_entry(' ', color);
    }
}

// Modify the terminal_putchar function to use scrolling
void terminal_putchar(char c) {
    uint8_t color = VGA_LIGHT_GREY | VGA_BLACK << 4;
    
    // Handle newline character
    if (c == '\n') {
        terminal_column = 0;
        terminal_row++;
        if (terminal_row == VGA_HEIGHT) {
            terminal_scroll();
            terminal_row = VGA_HEIGHT - 1;
        }
        return;
    }
    
    terminal_putchar_at(c, color, terminal_column, terminal_row);
    if (++terminal_column == VGA_WIDTH) {
        terminal_column = 0;
        terminal_row++;
        if (terminal_row == VGA_HEIGHT) {
            terminal_scroll();
            terminal_row = VGA_HEIGHT - 1;
        }
    }
}

// Handle backspace
void terminal_backspace() {
    if (terminal_column > 0) {
        terminal_column--;
        terminal_putchar_at(' ', VGA_LIGHT_GREY | VGA_BLACK << 4, terminal_column, terminal_row);
    }
    else if (terminal_row > 0) {
        terminal_row--;
        terminal_column = VGA_WIDTH - 1;
        terminal_putchar_at(' ', VGA_LIGHT_GREY | VGA_BLACK << 4, terminal_column, terminal_row);
    }
}

void terminal_putstr(const char* str) {
    for (size_t i = 0; str[i] != '\0'; i++) {
        terminal_putchar(str[i]);
    }
}

// Declare the external initialization function from memory.c
extern void initialize_static_memory();

void kernel_main(void) {

    terminal_clear(); // Initialize terminal first for output

    //terminal_putstr("Initializing Memory...\n");
    initialize_static_memory(); // Initialize the memory allocator
    //terminal_putstr("Memory Initialized.\n");

    //terminal_putstr("Initializing Filesystem...\n");
    fs_init(); // Initialize filesystem
    //terminal_putstr("Filesystem Initialized.\n");

    //terminal_putstr("Initializing Interrupts...\n");
    idt_init();           // Set up IDT entries
    pic_remap(0x20, 0x28); // Remap PIC: IRQs 0-7 -> 32-39, IRQs 8-15 -> 40-47
    isr_install_handlers(); // Clear C handler table
    //terminal_putstr("Interrupts Initialized.\n");

    //terminal_putstr("Initializing Keyboard...\n");
    keyboard_init_interrupts(); // Register keyboard IRQ handler
    //terminal_putstr("Keyboard Initialized.\n");

    // --- Enable Interrupts ---
    //terminal_putstr("Enabling Interrupts (STI)...\n");
    asm volatile ("sti");
    //terminal_putstr("Interrupts Enabled.\n");

    //terminal_putstr("Initializing Shell...\n");
    init_shell(); // Display initial prompt
    //terminal_putstr("Shell Initialized. Ready for input.\n");

    

    char buffer[MAX_COMMAND_LENGTH];
    int buffer_pos = 0;

    // Interrupt-driven input loop
    while(1) {
        char c = keyboard_getchar(); // Read from the keyboard buffer (blocks if empty)

        if(c == '\n') {
            terminal_putchar('\n');
            buffer[buffer_pos] = '\0'; // Null-terminate command
            if (buffer_pos > 0) { // Process only if command is not empty
                 shell_process_command(buffer);
            } else {
                 shell_prompt(); // Show prompt again if only Enter was pressed
            }
            buffer_pos = 0; // Reset buffer
        } else if(c == '\b') { // Handle backspace
            if (buffer_pos > 0) {
                terminal_backspace();
                buffer_pos--;
            }
        } else { // Handle regular characters
            if(buffer_pos < MAX_COMMAND_LENGTH - 1) {
                buffer[buffer_pos++] = c;
                terminal_putchar(c); // Echo character
            } else {
                // Optional: Handle command buffer full (e.g., beep)
            }
        }
    }

    // Kernel should not exit
    terminal_putstr("\nKernel Halted Unexpectedly.\n");
    asm volatile ("cli; hlt");
}