Create ps2.c

add initial ps/2 driver code. This will need wired up to be used
Create ps2.h
2026-01-19 20:05:20 -08:00 · 2025-12-17 05:50:02 -08:00 · 2025-12-17 05:47:59 -08:00
39 changed files with 586 additions and 976 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -1,24 +0,0 @@
-BasedOnStyle: Google
-IndentWidth: 4
-TabWidth: 4
-UseTab: Never
-ColumnLimit: 80
-
-DerivePointerAlignment: false
-PointerAlignment: Right
-ReferenceAlignment: Right
-
-AlignConsecutiveMacros: Consecutive
-AlignTrailingComments:
-  Kind: Always
-  OverEmptyLines: 0
-
-IncludeBlocks: Regroup
-IncludeCategories:
-  # Std headers
-  - Regex: '<[[:alnum:]_.]+>'
-    Priority: 2
-
-  # Other headers
-  - Regex: '.*'
-    Priority: 1
--- a/.clangd
+++ b/.clangd
@@ -1,6 +0,0 @@
-CompileFlags:
-  CompilationDatabase: build
-
-Diagnostics:
-  UnusedIncludes: Strict
-  MissingIncludes: Strict
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,12 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-[Makefile]
-indent_style = tab
-indent_size = 8
-tab_width = 8
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1 @@
-.build.env
 build
-cross
-.cache/
-compile_commands.json
--- a/37
+++ b/37
@@ -1,12 +1,10 @@
 AS = nasm
 ASFLAGS = -f elf32 -g -F dwarf
-CC = i386-elf-gcc
-LD = i386-elf-ld
+CC = gcc
+LD = ld
 QEMU= qemu-system-i386
-OBJCOPY = i386-elf-objcopy

 BUILD_DIR = build
-CROSS_DIR = cross
 DISK_IMG = $(BUILD_DIR)/disk.img
 STAGE2_SIZE = 2048

@@ -15,37 +13,31 @@ KERNEL_ASM_SRC = $(wildcard kernel/*.asm)
 KERNEL_OBJ = $(patsubst kernel/%.c, $(BUILD_DIR)/%.o, $(KERNEL_C_SRC))
 KERNEL_OBJ += $(patsubst kernel/%.asm, $(BUILD_DIR)/asm_%.o, $(KERNEL_ASM_SRC))

-KLIBC_SRC = $(wildcard klibc/src/*.c)
-KLIBC_OBJ = $(patsubst klibc/src/%.c, $(BUILD_DIR)/klibc/%.o, $(KLIBC_SRC))
-
-.PHONY: all stage1 stage2 kernel compile-commands $(BUILD_DIR)/compile_commands.json run gdb clean clean-cross clean-all
 all: $(DISK_IMG)

+.PHONY: stage1 stage2 kernel run gdb clean
 stage1: $(BUILD_DIR)
 	$(AS) $(ASFLAGS) -o $(BUILD_DIR)/$@.o bootloader/$@.asm
 	$(LD) -Ttext=0x7c00 -melf_i386 -o $(BUILD_DIR)/$@.elf $(BUILD_DIR)/$@.o
-	$(OBJCOPY) -O binary $(BUILD_DIR)/$@.elf $(BUILD_DIR)/$@.bin
+	objcopy -O binary $(BUILD_DIR)/$@.elf $(BUILD_DIR)/$@.bin

 # NOTE: Stage2 final size should be checked against `$(STAGE2_SIZE)` by the build system to avoid an overflow.
 # Alternatively, convey the final stage2 size through other means to stage1.
 stage2: $(BUILD_DIR)
 	$(AS) $(ASFLAGS) -o $(BUILD_DIR)/stage2.o bootloader/stage2.asm
-	$(CC) -std=c11 -ffreestanding -nostdlib -nostdinc -fno-stack-protector -m32 -Iklibc/include -g -c -o $(BUILD_DIR)/stage2_load.o bootloader/stage2_load.c
+	$(CC) -std=c11 -ffreestanding -nostdlib -fno-stack-protector -m32 -g -c -o $(BUILD_DIR)/stage2_load.o bootloader/stage2_load.c
 	$(LD) -Tbootloader/stage2.ld -melf_i386 -o $(BUILD_DIR)/$@.elf $(BUILD_DIR)/stage2.o $(BUILD_DIR)/stage2_load.o
-	$(OBJCOPY) -O binary $(BUILD_DIR)/$@.elf $(BUILD_DIR)/$@.bin
+	objcopy -O binary $(BUILD_DIR)/$@.elf $(BUILD_DIR)/$@.bin
 	truncate -s $(STAGE2_SIZE) $(BUILD_DIR)/$@.bin

 $(BUILD_DIR)/asm_%.o: kernel/%.asm
 	$(AS) $(ASFLAGS) -o $@ $<

 $(BUILD_DIR)/%.o: kernel/%.c
-	$(CC) -std=c11 -ffreestanding -nostdlib -nostdinc -fno-stack-protector -m32 -Iklibc/include -g -c -o $@ $<
+	$(CC) -std=c11 -ffreestanding -nostdlib -fno-stack-protector -m32 -g -c -o $@ $<

-$(BUILD_DIR)/klibc/%.o: klibc/src/%.c
-	$(CC) -std=c11 -ffreestanding -nostdlib -nostdinc -fno-stack-protector -m32 -Iklibc/include -g -c -o $@ $<
-
-kernel: $(KERNEL_OBJ) | $(BUILD_DIR) $(KLIBC_OBJ)
-	$(LD) -melf_i386 -Tkernel/linker.ld -o $(BUILD_DIR)/kernel.elf $(KERNEL_OBJ) $(KLIBC_OBJ)
+kernel: $(KERNEL_OBJ) | $(BUILD_DIR)
+	$(LD) -melf_i386 -Tkernel/linker.ld -o $(BUILD_DIR)/kernel.elf $(KERNEL_OBJ)

 $(DISK_IMG): stage1 stage2 kernel
 	dd if=$(BUILD_DIR)/stage1.bin of=$@
@@ -55,11 +47,6 @@ $(DISK_IMG): stage1 stage2 kernel

 $(BUILD_DIR):
 	mkdir -p $@
-	mkdir -p $(BUILD_DIR)/klibc
-
-compile-commands: $(BUILD_DIR)/compile_commands.json
-$(BUILD_DIR)/compile_commands.json: $(BUILD_DIR)
-	bear --output $@ -- make -B

 run:
 	qemu-system-i386 -s -S $(DISK_IMG)
@@ -69,9 +56,3 @@ gdb:

 clean:
 	rm -rf $(BUILD_DIR)
-
-clean-cross:
-	rm -rf $(CROSS_DIR)
-	rm -rf .build.env
-
-clean-all: clean clean-cross
--- a/README.md
+++ b/README.md
@@ -35,7 +35,6 @@ You’ll need the following tools installed:
 - `qemu-system-i386`

 Optional:
-
 - `gdb`
 - `vncviewer` (TigerVNC or similar)

@@ -43,27 +42,13 @@ Optional:

 ## 🛠️ Building ClassicOS

-Clone repository:
+Clone and build:

-```sh
+```bash
 git clone https://github.com/gbowne1/ClassicOS.git
 cd ClassicOS
-```
-
-Run `configure` script to build a cross-compiler toolchain for `i386-elf`:
-
-```sh
-./configure
-```
-
-Source the `.build.env` file to add the cross-compiler toolchain to your PATH:
-
-```sh
-source .build.env
-```
-
-Build the kernel:
-
-```sh
 make
 ```
+
+build kernel
+for %f in (*.c) do gcc -m32 -O0 -Wall -Wextra -Werror -pedantic -ffreestanding -nostdlib -fno-pic -fno-stack-protector -fno-pie -march=i386 -mtune=i386 -c "%f" -o "%f.o"
--- a/bootloader/stage2.asm
+++ b/bootloader/stage2.asm
@@ -24,3 +24,75 @@ _start:
    call load_kernel

    jmp eax
+
+; ----------------------------------------------------------------------------
+; ATA read sectors (LBA mode) 
+;
+; sysv32 abi signature:
+; void ata_lba_read(uint32_t lba, uint8_t nsect, void *addr);
+; ----------------------------------------------------------------------------
+ata_lba_read:
+    push ebp
+    mov ebp, esp
+
+    push ebx
+    push ecx
+    push edx
+    push edi
+
+    mov eax, [ebp+8]     ; arg #1 = LBA
+    mov cl, [ebp+12]     ; arg #2 = # of sectors
+    mov edi, [ebp+16]    ; arg #3 = buffer address
+    and eax, 0x0FFFFFFF
+
+    mov ebx, eax         ; Save LBA in RBX
+
+    mov edx, 0x01F6      ; Port to send drive and bit 24 - 27 of LBA
+    shr eax, 24          ; Get bit 24 - 27 in al
+    or al, 11100000b     ; Set bit 6 in al for LBA mode
+    out dx, al
+
+    mov edx, 0x01F2      ; Port to send number of sectors
+    mov al, cl           ; Get number of sectors from CL
+    out dx, al
+
+    mov edx, 0x1F3       ; Port to send bit 0 - 7 of LBA
+    mov eax, ebx         ; Get LBA from EBX
+    out dx, al
+
+    mov edx, 0x1F4       ; Port to send bit 8 - 15 of LBA
+    mov eax, ebx         ; Get LBA from EBX
+    shr eax, 8           ; Get bit 8 - 15 in AL
+    out dx, al
+
+    mov edx, 0x1F5       ; Port to send bit 16 - 23 of LBA
+    mov eax, ebx         ; Get LBA from EBX
+    shr eax, 16          ; Get bit 16 - 23 in AL
+    out dx, al
+
+    mov edx, 0x1F7       ; Command port
+    mov al, 0x20         ; Read with retry.
+    out dx, al
+
+    mov bl, cl          ; Save # of sectors in BL
+
+.wait_drq:
+    mov edx, 0x1F7
+.do_wait_drq:
+    in al, dx
+    test al, 8           ; the sector buffer requires servicing.
+    jz .do_wait_drq      ; keep polling until the sector buffer is ready.
+
+    mov edx, 0x1F0       ; Data port, in and out
+    mov ecx, 256
+    rep insw             ; in to [RDI]
+
+    dec bl               ; are we...
+    jnz .wait_drq        ; ...done?
+
+    pop edi
+    pop edx
+    pop ecx
+    pop ebx
+    pop ebp
+    ret
--- a/bootloader/stage2.ld
+++ b/bootloader/stage2.ld
@@ -9,4 +9,6 @@ SECTIONS {
        *(.bss*)
        *(COMMON)
    }
+
+    read_buf = .;
 }
--- a/bootloader/stage2_load.c
+++ b/bootloader/stage2_load.c
@@ -1,39 +1,11 @@
-#include <stddef.h>
 #include <stdint.h>

-// ATA IO Ports
-#define ATA_PRIMARY_DATA            0x1F0
-#define ATA_PRIMARY_ERR_FEATURES    0x1F1
-#define ATA_PRIMARY_SEC_COUNT       0x1F2
-#define ATA_PRIMARY_LBA_LOW         0x1F3
-#define ATA_PRIMARY_LBA_MID         0x1F4
-#define ATA_PRIMARY_LBA_HIGH        0x1F5
-#define ATA_PRIMARY_DRIVE_SEL       0x1F6
-#define ATA_PRIMARY_COMM_STAT       0x1F7
-
-// ATA Commands
-#define ATA_CMD_READ_PIO            0x20
-#define ATA_CMD_WRITE_PIO           0x30
-
 // ELF Ident indexes
-#define EI_NIDENT                   16
+#define EI_NIDENT 16

 // Program header types
-#define PT_NULL                     0
-#define PT_LOAD                     1
-
-// Disk sector size
-#define SECTOR_SIZE                 512
-#define PH_PER_SECTOR               (SECTOR_SIZE / sizeof(Elf32_Phdr))
-
-// Kernel start LBA
-#define KERN_START_SECT             5
-
-// VGA
-// Expects bios initialization for text mode (3), buffer at 0xb8000
-#define VGA_ADDRESS                 0xB8000
-#define VGA_COLS                    80
-#define VGA_ROWS                    25
+#define PT_NULL    0
+#define PT_LOAD    1

 // ELF Header (32-bit)
 typedef struct {
@@ -65,171 +37,82 @@ typedef struct {
    uint32_t p_align;
 } __attribute__((packed)) Elf32_Phdr;

-static inline uint8_t inb(uint16_t port)
-{
-    uint8_t ret;
-    __asm__ volatile ("inb %1, %0"
-                      : "=a"(ret)
-                      : "Nd"(port));
-    return ret;
-}
-
-static inline void outb(uint16_t port, uint8_t val)
-{
-    __asm__ volatile ("outb %0, %1"
-                      :
-                      : "a"(val), "Nd"(port));
-}
-
-static inline uint16_t inw(uint16_t port)
-{
-    uint16_t ret;
-    __asm__ volatile ("inw %1, %0"
-                      : "=a"(ret)
-                      : "Nd"(port));
-    return ret;
-}
-
-static inline void ata_wait_bsy() {
-    while (inb(ATA_PRIMARY_COMM_STAT) & 0x80);
-}
-
-static inline void ata_wait_drq() {
-    while (!(inb(ATA_PRIMARY_COMM_STAT) & 0x08));
-}
-
-static void ata_read_sector(void *addr, uint32_t lba) {
-    ata_wait_bsy();
-
-    outb(ATA_PRIMARY_DRIVE_SEL, 0xE0 | ((lba >> 24) & 0x0F));
-    outb(ATA_PRIMARY_SEC_COUNT, 1);
-    outb(ATA_PRIMARY_LBA_LOW, (uint8_t)lba);
-    outb(ATA_PRIMARY_LBA_MID, (uint8_t)(lba >> 8));
-    outb(ATA_PRIMARY_LBA_HIGH, (uint8_t)(lba >> 16));
-    outb(ATA_PRIMARY_COMM_STAT, ATA_CMD_READ_PIO);
-
-    uint16_t* ptr = (uint16_t*)addr;
-    ata_wait_bsy();
-    ata_wait_drq();
-    for (int i = 0; i < 256; i++) {
-        *ptr++ = inw(ATA_PRIMARY_DATA);
-    }
-}
-
-static void ata_read_sectors(uint8_t *addr, uint32_t offset, uint32_t size)
-{
-    // Reads are offset from the starting sector of the kernel
-    uint32_t lba = KERN_START_SECT + offset / SECTOR_SIZE;
-    uint32_t off = offset % 512;
-    uint8_t data[512];
-
-    while (size > 0) {
-        ata_read_sector(data, lba);
-
-        uint32_t copy = 512 - off;
-        if (copy > size) {
-            copy = size;
-        }
-
-        for (uint32_t i = 0; i < copy; i++) {
-            addr[i] = data[off + i];
-        }
-
-        addr += copy;
-        size -= copy;
-        lba++;
-        off = 0;
-    }
-}
-
-static void on_error(const char *msg)
-{
-    uint16_t *ptr = (uint16_t *)VGA_ADDRESS;
-
-    // Clear
-    uint16_t val = 0x0f00 | (uint8_t)' ';
-    for (size_t i = 0; i < VGA_COLS * VGA_ROWS; i++) {
-        ptr[i] = val;
-    }
-
-    // Print error
-    for (size_t i = 0; msg[i]; i++) {
-        ptr[i] = 0xf00 | (uint8_t)msg[i];
-    }
-
-    // Halt
-    while (1) {
-        __asm__("hlt");
-    }
-}
-
 // Load an ELF executable into memory.
-// NOTE: Only 32-byte program headers are supported.
-// Returns the entry point to the program.
-static void *elf_load(const void *data) {
-    const Elf32_Ehdr *header = (const Elf32_Ehdr*)data;
-
-    if (header->e_phentsize != sizeof(Elf32_Phdr)) {
-        // The bootloader only handles 32-byte program header entries
-        on_error("ERROR: Unsupported program header entry size, halting...");
-    }
-
-    // Buffer for the program headers
-    uint8_t file_buf[SECTOR_SIZE];
-
-    // Current file offset to the next program header
-    uint32_t file_offset = header->e_phoff;
+static int elf_load(const void* data, void (*load_segment)(uint8_t *vaddr, uint32_t src, uint32_t size)) {
+    const Elf32_Ehdr* header = (const Elf32_Ehdr*)data;
+    const Elf32_Phdr* ph = (const Elf32_Phdr*)((uint8_t*)data + header->e_phoff);

    for (int i = 0; i < header->e_phnum; i++) {
-        // Check for sector boundary.
-        // Program headers are read in a sector at a time
-        // 512 / 32 = 16 PH per sector
-        if (i % PH_PER_SECTOR == 0) {
-            uint32_t count = (header->e_phnum - i) * sizeof(Elf32_Phdr);
-            if (count > SECTOR_SIZE) {
-                count = SECTOR_SIZE;
-            }
-
-            // Reads
-            ata_read_sectors(file_buf, file_offset, count);
-            file_offset += count;
-        }
-
-        // PH being processed currently, index mod 16 as headers
-        // are being loaded in sector by sector.
-        const Elf32_Phdr *ph = (const Elf32_Phdr *)file_buf + (i % PH_PER_SECTOR);
-
-        // Discard non-load segments
-        if (ph->p_type != PT_LOAD)
+        if (ph[i].p_type != PT_LOAD)
            continue;

-        // Load in the segment
-        uint32_t offset = ph->p_offset;
-        uint32_t filesz = ph->p_filesz;
-        uint32_t memsz = ph->p_memsz;
-        uint8_t *vaddr = (uint8_t *)ph->p_vaddr;
-        ata_read_sectors(vaddr, offset, filesz);
+        uint32_t offset = ph[i].p_offset;
+        uint32_t vaddr = ph[i].p_vaddr;
+        uint32_t filesz = ph[i].p_filesz;
+        uint32_t memsz = ph[i].p_memsz;
+
+        // Copy data segment
+        //load_segment((uint8_t *)vaddr, offset, filesz);
+        load_segment((uint8_t *)vaddr, offset, filesz);

        // Zero remaining BSS (if any)
        if (memsz > filesz) {
-            uint8_t* bss_start = vaddr + filesz;
+            uint8_t* bss_start = (uint8_t*)(vaddr + filesz);
            for (uint32_t j = 0; j < memsz - filesz; j++) {
                bss_start[j] = 0;
            }
        }
    }

-    // Return the entry point
-    return (void *)header->e_entry;
+    return header->e_entry;
+}
+
+#define KERN_START_SECT 5
+#define MAX(a, b) ((a)>(b) ? (a) : (b))
+
+extern void ata_lba_read(uint32_t lba, uint8_t nsect, void *addr);
+extern uint8_t read_buf[];
+
+static uint32_t
+total_header_size(const Elf32_Ehdr *header) {
+    uint32_t phend = header->e_phoff + header->e_phentsize*header->e_phnum;
+
+    // Align to 512
+    return (phend + 511) & ~511;
+}
+
+static void read_sectors(uint8_t *vaddr, uint32_t offset, uint32_t size) {
+    // # of sectors to read
+    uint32_t rem_nsect = ((size + 511) & ~511) / 512;
+
+    // Current lba address, offset by the first sector already read
+    uint32_t lba = KERN_START_SECT + offset / 512;
+
+    // Max 255 sectors at a time
+    while (rem_nsect) {
+        uint8_t nsect = rem_nsect > 255 ? 255 : rem_nsect;
+        ata_lba_read(lba, nsect, vaddr);
+
+        vaddr += nsect * 512;
+        rem_nsect -= nsect;
+        lba += nsect;
+    }
 }

 void *load_kernel(void) {
-    // ELF header buffer
-    uint8_t header_buf[SECTOR_SIZE];
+    // Read the first sector
+    ata_lba_read(KERN_START_SECT, 1, read_buf);

-    // Read the first sector (contains the ELF header)
-    ata_read_sector(header_buf, KERN_START_SECT);
+    const Elf32_Ehdr* header = (const Elf32_Ehdr*)read_buf;

-    // `elf_load()` returns the entry point
-    return elf_load(header_buf);
+    // Remaining data size, subtract the first 512B already read
+    uint32_t rem = total_header_size(header) - 512;
+
+    // Read the rest if necessary
+    if (rem)
+        read_sectors(read_buf+512, 512, rem);
+
+    elf_load(read_buf, read_sectors);
+
+    return (void *)header->e_entry;
 }
--- a/169
+++ b/169
@@ -1,169 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Configuration
-TARGET="i386-elf"
-BINUTILS_VERSION="2.45"
-GCC_VERSION="15.2.0"
-
-# Paths
-SCRIPT_PATH="$(realpath "${BASH_SOURCE[0]}")"
-SCRIPT_DIR="$(dirname "$SCRIPT_PATH")"
-PREFIX="$SCRIPT_DIR/cross"
-SRC_DIR="$PREFIX/src"
-
-BINUTILS_SRC="$SRC_DIR/binutils-$BINUTILS_VERSION"
-BINUTILS_BUILD="$PREFIX/build-binutils"
-GCC_SRC="$SRC_DIR/gcc-$GCC_VERSION"
-GCC_BUILD="$PREFIX/build-gcc"
-
-# Flags
-DEBUG=0
-HELP=0
-
-# Parse arguments
-for arg in "$@"; do
-  case "$arg" in
-    -h|--help)
-      HELP=1
-      ;;
-    -d|--debug)
-      DEBUG=1
-      ;;
-    *)
-      echo "Unknown option: $arg"
-      echo "Use -h or --help for usage information"
-      exit 1
-      ;;
-  esac
-done
-
-# Show help
-if [[ "$HELP" -eq 1 ]]; then
-  cat << EOF
-Usage: $0 [OPTIONS]
-
-Build a cross-compiler toolchain for $TARGET.
-
-OPTIONS:
-  -h, --help     Show this help message
-  -d, --debug    Enable debug mode (set -x)
-
-This script will:
-  1. Download binutils $BINUTILS_VERSION and GCC $GCC_VERSION
-  2. Build and install them to: $PREFIX
-
-EOF
-  exit 0
-fi
-
-# Enable debug mode
-if [[ "$DEBUG" -eq 1 ]]; then
-  set -x
-fi
-
-# Print configuration
-cat << EOF
-
-=== Build Configuration ===
-Target       : $TARGET
-Prefix       : $PREFIX
-Binutils     : $BINUTILS_VERSION
-GCC          : $GCC_VERSION
-===========================
-
-EOF
-
-# Create directory structure
-echo "Setting up directories..."
-mkdir -p "$SRC_DIR"
-
-# Download sources
-cd "$SRC_DIR"
-
-if [[ ! -d "$BINUTILS_SRC" ]]; then
-  echo "Downloading binutils $BINUTILS_VERSION..."
-  wget "https://ftp.gnu.org/gnu/binutils/binutils-$BINUTILS_VERSION.tar.gz"
-  echo "Extracting binutils..."
-  tar xf "binutils-$BINUTILS_VERSION.tar.gz"
-  rm "binutils-$BINUTILS_VERSION.tar.gz"
-else
-  echo "Binutils source already exists, skipping download"
-fi
-
-if [[ ! -d "$GCC_SRC" ]]; then
-  echo "Downloading GCC $GCC_VERSION..."
-  wget "https://ftp.gnu.org/gnu/gcc/gcc-$GCC_VERSION/gcc-$GCC_VERSION.tar.gz"
-  echo "Extracting GCC..."
-  tar xf "gcc-$GCC_VERSION.tar.gz"
-  rm "gcc-$GCC_VERSION.tar.gz"
-else
-  echo "GCC source already exists, skipping download"
-fi
-
-# Download GCC prerequisites
-if [[ ! -d "$GCC_SRC/gmp" ]]; then
-  echo "Downloading GCC prerequisites..."
-  cd "$GCC_SRC"
-  ./contrib/download_prerequisites
-  cd "$SRC_DIR"
-else
-  echo "GCC prerequisites already downloaded, skipping"
-fi
-
-# Build binutils
-if [[ ! -f "$PREFIX/bin/$TARGET-ld" ]]; then
-  echo "Building binutils..."
-  mkdir -p "$BINUTILS_BUILD"
-  cd "$BINUTILS_BUILD"
-
-  "$BINUTILS_SRC/configure" \
-    --target="$TARGET" \
-    --prefix="$PREFIX" \
-    --with-sysroot \
-    --disable-nls \
-    --disable-werror
-
-  make -j"$(nproc)"
-  make install
-else
-  echo "Binutils already installed, skipping build"
-fi
-
-# Build GCC
-if [[ ! -f "$PREFIX/bin/$TARGET-gcc" ]]; then
-  echo "Building GCC..."
-  mkdir -p "$GCC_BUILD"
-  cd "$GCC_BUILD"
-
-  "$GCC_SRC/configure" \
-    --target="$TARGET" \
-    --prefix="$PREFIX" \
-    --disable-nls \
-    --enable-languages=c \
-    --without-headers
-
-  make all-gcc -j"$(nproc)"
-  make all-target-libgcc -j"$(nproc)"
-  make install-gcc
-  make install-target-libgcc
-else
-  echo "GCC already installed, skipping build"
-fi
-
-cd "$SCRIPT_DIR"
-
-# Generate .build.env file
-cat > .build.env << EOF
-# Generated by configure on $(date)
-# Source this file to add the cross-compiler toolchain to your PATH
-export PATH="$PREFIX/bin:\$PATH"
-EOF
-
-echo ""
-echo "=== Build Complete ==="
-echo "Toolchain installed to: $PREFIX"
-echo ""
-echo "To use the toolchain, run:"
-echo "  source .build.env"
-echo "======================"
--- a/kernel/context_switch.asm
+++ b/kernel/context_switch.asm
@@ -1,4 +1,4 @@
-global ctx_switch
+.global ctx_switch

 ; void ctx_switch(uint32_t **old_sp_ptr, uint32_t *new_sp);
 ; Arguments on stack (cdecl convention):
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -2,106 +2,36 @@
 #include "serial.h"
 #include "terminal.h"
 #include "utils.h"
+#include "print.h"

-void cpuid(uint32_t leaf, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx) {
+void cpuid(uint32_t function, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx) {
    __asm__(
        "cpuid"
        : "=a"(*eax), "=b"(*ebx), "=c"(*ecx), "=d"(*edx)
-        : "a"(leaf)
+        : "a"(function)
    );
 }

-// Helper to print a labeled decimal value
-void print_val(const char* label, uint32_t val) {
-    char buf[12];
-    utoa(val, buf, 10);
-    terminal_write(label);
-    terminal_write(buf);
-    terminal_write(" ");
-}
-
-// Safely check if CPUID is supported by attempting to flip bit 21 of EFLAGS
-int check_cpuid_supported() {
-    uint32_t f1, f2;
-    __asm__ volatile (
-        "pushfl\n\t"
-        "pushfl\n\t"
-        "popl %0\n\t"
-        "movl %0, %1\n\t"
-        "xorl $0x200000, %0\n\t"
-        "pushl %0\n\t"
-        "popfl\n\t"
-        "pushfl\n\t"
-        "popl %0\n\t"
-        "popfl\n\t"
-        : "=&r" (f1), "=&r" (f2));
-    return ((f1 ^ f2) & 0x200000) != 0;
-}
-
 void identify_cpu() {
-    if (!check_cpuid_supported()) {
-        terminal_write("CPUID not supported. Likely a 386 or early 486.\n");
-        return;
-    }
-
    uint32_t eax, ebx, ecx, edx;
    char vendor[13];

-    // Leaf 0: Vendor String & Max Leaf
    cpuid(0, &eax, &ebx, &ecx, &edx);
-    uint32_t max_leaf = eax;
+
    *(uint32_t *)&vendor[0] = ebx;
    *(uint32_t *)&vendor[4] = edx;
    *(uint32_t *)&vendor[8] = ecx;
    vendor[12] = '\0';

-    terminal_write("Vendor: ");
+    terminal_write("CPU Vendor: ");
    terminal_write(vendor);
    terminal_write("\n");

-    // Leaf 1: Family, Model, Stepping
-    if (max_leaf >= 1) {
-        cpuid(1, &eax, &ebx, &ecx, &edx);
+    serial_write("CPU Vendor: ");
+    serial_write(vendor);
+    serial_write("\n");

-        uint32_t stepping = eax & 0xF;
-        uint32_t model = (eax >> 4) & 0xF;
-        uint32_t family = (eax >> 8) & 0xF;
-        uint32_t type = (eax >> 12) & 0x3;
-
-        // Handle Extended Family/Model (Required for Pentium 4 and newer)
-        if (family == 0xF) {
-            family += (eax >> 20) & 0xFF;
-            model += ((eax >> 16) & 0xF) << 4;
-        }
-
-        print_val("Family:", family);
-        print_val("Model:", model);
-        print_val("Step:", stepping);
-        terminal_write("\n");
-    }
-
-    // Leaf 2: Cache Descriptors
-    if (max_leaf >= 2) {
-        cpuid(2, &eax, &ebx, &ecx, &edx);
-        
-        terminal_write("Cache Descriptors: ");
-        // Note: Leaf 2 returns a list of 1-byte descriptors in the registers.
-        // We look for common Intel ones:
-        uint32_t regs[4] = {eax, ebx, ecx, edx};
-        for (int i = 0; i < 4; i++) {
-            if (regs[i] & 0x80000000) continue; // Reserved bit
-            for (int j = 0; j < 4; j++) {
-                uint8_t desc = (regs[i] >> (j * 8)) & 0xFF;
-                if (desc == 0) continue;
-                
-                // Example decoding for specific chips you mentioned:
-                if (desc == 0x06) terminal_write("8KB L1 I-Cache ");
-                if (desc == 0x0A) terminal_write("8KB L1 D-Cache ");
-                if (desc == 0x41) terminal_write("128KB L2 ");
-                if (desc == 0x43) terminal_write("512KB L2 ");
-                if (desc == 0x2C) terminal_write("32KB L1 D-Cache ");
-            }
-        }
-        terminal_write("\n");
-    }
+    terminal_write("CPUID max leaf: ");
+    print_hex(eax, false, false);  // You must implement this (see below)
+    terminal_write("\n");
 }
--- a/kernel/cpu.h
+++ b/kernel/cpu.h
@@ -2,42 +2,8 @@
 #define CPU_H

 #include <stdint.h>
-#include <stdbool.h>

-// Specific Intel Model Definitions for your targets
-#define INTEL_FAM4_486_DX      0x00 // Also 0x01
-#define INTEL_FAM4_486_SX      0x02
-#define INTEL_FAM4_486_DX2     0x03
-#define INTEL_FAM4_486_DX4     0x08
-#define INTEL_FAM5_PENTIUM     0x01 // P5
-#define INTEL_FAM5_PENTIUM_MMX 0x04 // P55C
-#define INTEL_FAM6_PENTIUM_PRO 0x01 // P6
-#define INTEL_FAM6_PENTIUM_II  0x05 // Deschutes
-#define INTEL_FAM6_PENTIUM_III 0x07 // Katmai/Coppermine
-#define INTEL_FAM15_P4_WILLY   0x00 // Willamette
-#define INTEL_FAM15_P4_NORTH   0x02 // Northwood
-#define INTEL_FAM15_P4_PRES    0x03 // Prescott
-
-typedef struct {
-    char vendor[13];
-    uint32_t family;
-    uint32_t model;
-    uint32_t stepping;
-    uint32_t type;
-    uint32_t max_leaf;
-    
-    // Feature flags (optional, but very helpful later)
-    bool has_fpu;
-    bool has_mmx;
-    bool has_sse;
-} cpu_info_t;
-
-// Function Prototypes
-void cpuid(uint32_t leaf, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx);
-bool cpu_check_cpuid_support(void);
+void cpuid(uint32_t function, uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx);
 void identify_cpu(void);

-// Helper to get the current CPU info after identification
-cpu_info_t* cpu_get_info(void);
-
 #endif // CPU_H
--- a/kernel/fat12.c
+++ b/kernel/fat12.c
@@ -15,16 +15,9 @@ static uint8_t g_sector_buffer[FAT12_SECTOR_SIZE];
 static int k_memcmp(const void *s1, const void *s2, uint32_t n) {
    const uint8_t *p1 = (const uint8_t *)s1;
    const uint8_t *p2 = (const uint8_t *)s2;
-
    for (uint32_t i = 0; i < n; i++) {
-        if (p1[i] != p2[i]) {
-            // Correct way to return the difference:
-            // If p1[i] > p2[i], returns positive.
-            // If p1[i] < p2[i], returns negative.
-            return (int)p1[i] - (int)p2[i];
-        }
+        if (p1[i] != p2[i]) return p1[i] - p2[i];
    }
-
    return 0;
 }

@@ -189,8 +182,3 @@ uint32_t fat12_read(file_t *file, uint8_t *buffer, uint32_t bytes_to_read) {

    return total_read;
 }
-
-int disk_read_sector(uint32_t lba, uint8_t *buffer) {
-    // For now, do nothing and return success
-    return 0; 
-}
--- a/kernel/fat12.h
+++ b/kernel/fat12.h
@@ -58,7 +58,7 @@ typedef struct {

 // You must implement this in your disk driver (e.g., floppy.c)
 // Returns 0 on success, non-zero on error.
-int disk_read_sector(uint32_t lba, uint8_t *buffer);
+extern int disk_read_sector(uint32_t lba, uint8_t *buffer);

 void fat12_init();
 file_t fat12_open(const char *filename);
--- a/kernel/irq.h
+++ b/kernel/irq.h
@@ -1,7 +1,7 @@
 #ifndef IRQ_H
 #define IRQ_H

-#include <stdint.h>
+#include "types.h"

 void irq_remap(void);
 void irq_install(void);
--- a/kernel/isr.c
+++ b/kernel/isr.c
@@ -1,4 +1,3 @@
-#include <stdbool.h>
 #include "terminal.h"
 #include "serial.h"
 #include "isr.h"
--- a/kernel/linker.ld
+++ b/kernel/linker.ld
@@ -1,30 +1,18 @@
 ENTRY(kmain)

-PHDRS {
-    text PT_LOAD FLAGS(5);    /* Read + Execute */
-    rodata PT_LOAD FLAGS(4);  /* Read only */
-    data PT_LOAD FLAGS(6);    /* Read + Write */
-}
-
 SECTIONS {
    . = 1M;

    .text : {
        *(.text*)
-    } :text
-
-    .rodata : {
-        *(.rodata*)
-    } :rodata
-
-    .data : {
-        *(.data*)
-    } :data
+    }

+    .rodata : { *(.rodata*) }
+    .data : { *(.data*) }
    .bss : {
        *(.bss*)
        *(COMMON)
-    } :data
+    }

    .stack (NOLOAD) : {
        . = ALIGN(4);
--- a/kernel/memory.c
+++ b/kernel/memory.c
@@ -15,3 +15,124 @@ static inline void byte_copy_backward(uint8_t *dst, const uint8_t *src, size_t n
    while (n--) *--dst = *--src;
 }

+/* --------------------------------------------------------------------- *
+ *  memcpy  –  no overlap allowed (behaviour undefined if overlap)
+ * --------------------------------------------------------------------- */
+void *memcpy(void *restrict dst, const void *restrict src, size_t n)
+{
+    uint8_t *d = (uint8_t *)dst;
+    const uint8_t *s = (const uint8_t *)src;
+
+#if defined(MEMORY_OPTIMIZED)
+    /* Align destination to 4-byte boundary */
+    size_t align = (uintptr_t)d & 3U;
+    if (align) {
+        size_t head = 4 - align;
+        if (head > n) head = n;
+        byte_copy_forward(d, s, head);
+        d += head; s += head; n -= head;
+    }
+
+    /* 32-bit word copy – safe because we already aligned dst */
+    {
+        uint32_t *d32 = (uint32_t *)d;
+        const uint32_t *s32 = (const uint32_t *)s;
+        size_t words = n / 4;
+        while (words--) *d32++ = *s32++;
+        d = (uint8_t *)d32;
+        s = (const uint8_t *)s32;
+        n &= 3;
+    }
+#endif
+
+    byte_copy_forward(d, s, n);
+    return dst;
+}
+
+/* --------------------------------------------------------------------- *
+ *  memmove – handles overlapping regions correctly
+ * --------------------------------------------------------------------- */
+void *memmove(void *dst, const void *src, size_t n)
+{
+    uint8_t *d = (uint8_t *)dst;
+    const uint8_t *s = (const uint8_t *)src;
+
+    if (n == 0 || dst == src)
+        return dst;
+
+    if (d < s) {                     /* copy forward */
+#if defined(MEMORY_OPTIMIZED)
+        /* Same fast path as memcpy when no overlap */
+        size_t align = (uintptr_t)d & 3U;
+        if (align) {
+            size_t head = 4 - align;
+            if (head > n) head = n;
+            byte_copy_forward(d, s, head);
+            d += head; s += head; n -= head;
+        }
+        {
+            uint32_t *d32 = (uint32_t *)d;
+            const uint32_t *s32 = (const uint32_t *)s;
+            size_t words = n / 4;
+            while (words--) *d32++ = *s32++;
+            d = (uint8_t *)d32;
+            s = (const uint8_t *)s32;
+            n &= 3;
+        }
+#endif
+        byte_copy_forward(d, s, n);
+    } else {                         /* copy backward */
+        byte_copy_backward(d, s, n);
+    }
+    return dst;
+}
+
+/* --------------------------------------------------------------------- *
+ *  memcmp  – lexicographical compare
+ * --------------------------------------------------------------------- */
+int memcmp(const void *s1, const void *s2, size_t n)
+{
+    const uint8_t *a = (const uint8_t *)s1;
+    const uint8_t *b = (const uint8_t *)s2;
+
+#if defined(MEMORY_OPTIMIZED)
+    /* Align to 4-byte boundary */
+    size_t align = (uintptr_t)a & 3U;
+    if (align && align == ((uintptr_t)b & 3U)) {
+        size_t head = 4 - align;
+        if (head > n) head = n;
+        while (head--) {
+            int diff = *a++ - *b++;
+            if (diff) return diff;
+        }
+        n -= head;
+    }
+
+    {
+        const uint32_t *a32 = (const uint32_t *)a;
+        const uint32_t *b32 = (const uint32_t *)b;
+        size_t words = n / 4;
+        while (words--) {
+            uint32_t va = *a32++, vb = *b32++;
+            if (va != vb) {
+                /* byte-wise fallback for the differing word */
+                const uint8_t *pa = (const uint8_t *)(a32 - 1);
+                const uint8_t *pb = (const uint8_t *)(b32 - 1);
+                for (int i = 0; i < 4; ++i) {
+                    int diff = pa[i] - pb[i];
+                    if (diff) return diff;
+                }
+            }
+        }
+        a = (const uint8_t *)a32;
+        b = (const uint8_t *)b32;
+        n &= 3;
+    }
+#endif
+
+    while (n--) {
+        int diff = *a++ - *b++;
+        if (diff) return diff;
+    }
+    return 0;
+}
--- a/kernel/paging.c
+++ b/kernel/paging.c
@@ -1,17 +1,21 @@
-#include <stdint.h>
-#include <string.h>
-#include "io.h"
 #include "paging.h"
+#include "io.h"
+#include <stdint.h>
+#include <stddef.h>

 page_directory_entry_t *page_directory = (page_directory_entry_t *)0x200000;
 page_table_entry_t     *page_table     = (page_table_entry_t *)0x201000;
+page_table_entry_t     *heap_page_table = (page_table_entry_t *)0x202000;

 // Helper function to set up the page directory entry
 void set_page_directory(page_directory_entry_t *dir) {
-    // Set first PDE
+    for (int i = 0; i < PAGE_DIRECTORY_SIZE; i++) {
+        dir[i].present = 0;
+    }
    dir[0].present = 1;
    dir[0].rw = 1;
-    dir[0].addr = (uint32_t)page_table >> 12;
+    dir[0].user = 0;
+    dir[0].frame = (uint32_t)page_table >> 12;
 }

 // Helper function to set up the page table entry
@@ -19,8 +23,12 @@ void set_page_table(page_table_entry_t *table) {
    for (int i = 0; i < PAGE_TABLE_SIZE; i++) {
        // Set up page table entries with identity mapping
        table[i].present = 1;
-        table[i].rw = 1;        // Read/Write
-        table[i].addr = i;      // Identity mapping
+        table[i].rw = 1;          // Read/Write
+        table[i].user = 0;        // Kernel mode
+        table[i].write_through = 0;
+        table[i].cache_disabled = 0;
+        table[i].accessed = 0;
+        table[i].frame = i;       // Identity mapping
    }
 }

@@ -39,13 +47,26 @@ void enable_paging() {

 // Initialize paging: set up the page directory and enable paging
 void paging_init() {
-    // Zero out the tables
-    memset(page_directory, 0x00, PAGE_DIRECTORY_SIZE * sizeof *page_directory);
-    memset(page_table, 0x00, PAGE_TABLE_SIZE * sizeof *page_table);
-
    // Set up identity-mapped page directory + table
    set_page_directory(page_directory);
    set_page_table(page_table);

+    // === Set up heap mapping at 0xC0100000 ===
+    for (int i = 0; i < PAGE_TABLE_SIZE; i++) {
+        heap_page_table[i].present = 1;
+        heap_page_table[i].rw = 1;
+        heap_page_table[i].user = 0;
+        heap_page_table[i].write_through = 0;
+        heap_page_table[i].cache_disabled = 0;
+        heap_page_table[i].accessed = 0;
+        heap_page_table[i].frame = (256 + i); // Start physical heap at 1MB (256*4KB = 1MB)
+    }
+
+    // Index 772 = 0xC0100000 / 4MB
+    page_directory[772].present = 1;
+    page_directory[772].rw = 1;
+    page_directory[772].user = 0;
+    page_directory[772].frame = (uint32_t)heap_page_table >> 12;
+
    enable_paging();
 }
--- a/kernel/paging.h
+++ b/kernel/paging.h
@@ -10,31 +10,31 @@

 // Page Directory and Page Table structure
 typedef struct {
-    uint32_t present : 1;           // Present bit (1: page is present in memory)
-    uint32_t rw : 1;                // Read-Write bit (1: page is read-write)
-    uint32_t user : 1;              // User-supervisor bit (1: user mode access)
-    uint32_t write_through : 1;     // Write-through cache
-    uint32_t cache_disabled : 1;    // Cache disabled
-    uint32_t accessed : 1;          // Accessed bit
-    uint32_t dirty : 1;             // Dirty bit
-    uint32_t attribute : 1;         // Page size (0: 4KB, 1: 4MB)
-    uint32_t global : 1;            // Global page (can be used across different processes)
-    uint32_t reserved : 3;          // Unused
-    uint32_t addr : 20;             // Page frame address (physical address)
+    uint32_t present : 1;  // Present bit (1: page is present in memory)
+    uint32_t rw : 1;       // Read-Write bit (1: page is read-write)
+    uint32_t user : 1;     // User-supervisor bit (1: user mode access)
+    uint32_t write_through : 1;  // Write-through cache
+    uint32_t cache_disabled : 1; // Cache disabled
+    uint32_t accessed : 1;        // Accessed bit
+    uint32_t reserved : 1;        // Reserved bit
+    uint32_t page_size : 1;       // Page size (0: 4KB, 1: 4MB)
+    uint32_t global : 1;           // Global page (can be used across different processes)
+    uint32_t available : 3;        // Available bits for the system
+    uint32_t frame : 20;           // Frame address (physical address)
 } __attribute__((packed)) page_table_entry_t;

 // Define page directory entry
 typedef struct {
-    uint32_t present : 1;           // Present bit (1: PTE is present in memory)
-    uint32_t rw : 1;                // Read-Write bit (1: pages are read-write)
-    uint32_t user : 1;              // User-supervisor bit (1: user mode access)
-    uint32_t write_through : 1;     // Write-through cache
-    uint32_t cache_disabled : 1;    // Cache disabled
-    uint32_t accessed : 1;          // Accessed bit
-    uint32_t available : 1;         // Unused
-    uint32_t page_size : 1;         // Page size (0: 4KB, 1: 4MB)
-    uint32_t available_2 : 4;       // Unused
-    uint32_t addr : 20;             // Page table address
+    uint32_t present : 1;
+    uint32_t rw : 1;
+    uint32_t user : 1;
+    uint32_t write_through : 1;
+    uint32_t cache_disabled : 1;
+    uint32_t accessed : 1;
+    uint32_t reserved : 1;
+    uint32_t zero : 5;           // Must be zero for page directory
+    uint32_t reserved_2 : 7;     // Reserved bits
+    uint32_t frame : 20;         // Frame address of the page table
 } __attribute__((packed)) page_directory_entry_t;

 extern page_directory_entry_t *page_directory;
--- a/kernel/print.h
+++ b/kernel/print.h
@@ -1,7 +1,7 @@
 #ifndef PRINT_H
 #define PRINT_H

-#include <stdint.h>
+#include "types.h"

 void print_string(const char *str);
 void my_printf(const char *format, ...);
--- a/kernel/ps2.c
+++ b/kernel/ps2.c
@@ -0,0 +1,117 @@
+#include "ps2.h"
+
+/* --- Low Level I/O Helpers --- */
+static inline void outb(uint16_t port, uint8_t val) {
+    asm volatile ("outb %0, %1" : : "a"(val), "Nd"(port));
+}
+
+static inline uint8_t inb(uint16_t port) {
+    uint8_t ret;
+    asm volatile ("inb %1, %0" : "=a"(ret) : "Nd"(port));
+    return ret;
+}
+
+/* --- Controller Synchronization --- */
+
+// Wait until the controller is ready to receive a byte
+static void ps2_wait_write() {
+    while (inb(PS2_STATUS_REG) & PS2_STATUS_INPUT);
+}
+
+// Wait until the controller has a byte for us to read
+static void ps2_wait_read() {
+    while (!(inb(PS2_STATUS_REG) & PS2_STATUS_OUTPUT));
+}
+
+/* --- Initialization --- */
+
+void ps2_write_device(uint8_t command) {
+    ps2_wait_write();
+    outb(PS2_DATA_PORT, command);
+}
+
+void ps2_write_mouse(uint8_t data) {
+    ps2_wait_write();
+    outb(PS2_COMMAND_REG, PS2_CMD_WRITE_MOUSE); // "Next byte goes to mouse"
+    ps2_wait_write();
+    outb(PS2_DATA_PORT, data);
+}
+
+void ps2_init(void) {
+    // 1. Disable Devices
+    ps2_wait_write();
+    outb(PS2_COMMAND_REG, PS2_CMD_DISABLE_KB);
+    ps2_wait_write();
+    outb(PS2_COMMAND_REG, PS2_CMD_DISABLE_MS);
+
+    // 2. Flush Output Buffer
+    while (inb(PS2_STATUS_REG) & PS2_STATUS_OUTPUT) {
+        inb(PS2_DATA_PORT);
+    }
+
+    // 3. Set Controller Configuration Byte
+    // Bit 0: KB Interrupt, Bit 1: Mouse Interrupt, Bit 6: Translation
+    ps2_wait_write();
+    outb(PS2_COMMAND_REG, PS2_CMD_READ_CONFIG);
+    ps2_wait_read();
+    uint8_t status = inb(PS2_DATA_PORT);
+    status |= (1 << 0) | (1 << 1); // Enable IRQ 1 and IRQ 12
+    
+    ps2_wait_write();
+    outb(PS2_COMMAND_REG, PS2_CMD_WRITE_CONFIG);
+    ps2_wait_write();
+    outb(PS2_DATA_PORT, status);
+
+    // 4. Enable Devices
+    ps2_wait_write();
+    outb(PS2_COMMAND_REG, PS2_CMD_ENABLE_KB);
+    ps2_wait_write();
+    outb(PS2_COMMAND_REG, PS2_CMD_ENABLE_MS);
+
+    // 5. Initialize Mouse (The mouse won't send IRQs until you tell it to)
+    ps2_write_mouse(MOUSE_CMD_SET_DEFAULTS);
+    ps2_wait_read(); inb(PS2_DATA_PORT); // Read ACK (0xFA)
+    
+    ps2_write_mouse(MOUSE_CMD_ENABLE_SCAN);
+    ps2_wait_read(); inb(PS2_DATA_PORT); // Read ACK (0xFA)
+}
+
+/* --- IRQ Handlers --- */
+
+// Called from IRQ 1 (Keyboard)
+void ps2_keyboard_handler(void) {
+    uint8_t scancode = inb(PS2_DATA_PORT);
+    // Process scancode (e.g., put it into a circular buffer)
+}
+
+// Called from IRQ 12 (Mouse)
+static uint8_t mouse_cycle = 0;
+static uint8_t mouse_bytes[3];
+
+void ps2_mouse_handler(void) {
+    uint8_t status = inb(PS2_STATUS_REG);
+    
+    // Ensure this is actually mouse data
+    if (!(status & PS2_STATUS_MOUSE)) return;
+
+    mouse_bytes[mouse_cycle++] = inb(PS2_DATA_PORT);
+
+    if (mouse_cycle == 3) {
+        mouse_cycle = 0;
+        
+        // Byte 0: Flags (Buttons, Signs)
+        // Byte 1: X Delta
+        // Byte 2: Y Delta
+        
+        mouse_state_t state;
+        state.left_button   = (mouse_bytes[0] & 0x01);
+        state.right_button  = (mouse_bytes[0] & 0x02);
+        state.middle_button = (mouse_bytes[0] & 0x04);
+
+        // Handle negative deltas (signed 9-bit logic)
+        state.x_delta = (int8_t)mouse_bytes[1];
+        state.y_delta = (int8_t)mouse_bytes[2];
+
+        // Update your kernel's internal mouse position here
+    }
+}
--- a/kernel/ps2.h
+++ b/kernel/ps2.h
@@ -0,0 +1,45 @@
+#ifndef PS2_H
+#define PS2_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+/* I/O Ports */
+#define PS2_DATA_PORT       0x60
+#define PS2_STATUS_REG      0x64
+#define PS2_COMMAND_REG     0x64
+
+/* Status Register Bits */
+#define PS2_STATUS_OUTPUT   0x01 // 1 = Data ready to be read
+#define PS2_STATUS_INPUT    0x02 // 1 = Controller busy, don't write yet
+#define PS2_STATUS_SYS      0x04 // System flag
+#define PS2_STATUS_CMD_DATA 0x08 // 0 = Data written to 0x60, 1 = Cmd to 0x64
+#define PS2_STATUS_MOUSE    0x20 // 1 = Mouse data, 0 = Keyboard data
+
+/* Controller Commands */
+#define PS2_CMD_READ_CONFIG  0x20
+#define PS2_CMD_WRITE_CONFIG 0x60
+#define PS2_CMD_DISABLE_MS   0xA7
+#define PS2_CMD_ENABLE_MS    0xA8
+#define PS2_CMD_DISABLE_KB   0xAD
+#define PS2_CMD_ENABLE_KB    0xAE
+#define PS2_CMD_WRITE_MOUSE  0xD4
+
+/* Mouse Commands */
+#define MOUSE_CMD_SET_DEFAULTS 0xF6
+#define MOUSE_CMD_ENABLE_SCAN  0xF4
+
+typedef struct {
+    int8_t  x_delta;
+    int8_t  y_delta;
+    bool    left_button;
+    bool    right_button;
+    bool    middle_button;
+} mouse_state_t;
+
+/* Public API */
+void ps2_init(void);
+void ps2_keyboard_handler(void);
+void ps2_mouse_handler(void);
+
+#endif
--- a/kernel/threading.c
+++ b/kernel/threading.c
@@ -1,8 +1,9 @@
-#include <stdbool.h>
-#include <string.h>
 #include "malloc.h"
 #include "print.h"
 #include "threading.h"
+#include "types.h"
+#include "utils.h"
+#include <stdint.h>

 #define MAX_THREADS 16           // Maximum number of threads
 #define THREAD_STACK_SIZE 8192   // Stack size for each thread
--- a/kernel/types.c
+++ b/kernel/types.c
@@ -0,0 +1 @@
+#include "types.h"
--- a/kernel/types.h
+++ b/kernel/types.h
@@ -0,0 +1,62 @@
+#ifndef TYPES_H
+#define TYPES_H
+
+// ----------------------------
+// Fixed-width integer types
+// ----------------------------
+typedef unsigned char      uint8_t;
+typedef signed char        int8_t;
+typedef unsigned short     uint16_t;
+typedef signed short       int16_t;
+typedef unsigned int       uint32_t;
+typedef signed int         int32_t;
+typedef unsigned long long uint64_t;
+typedef signed long long   int64_t;
+
+// ----------------------------
+// Boolean & NULL definitions
+// ----------------------------
+#ifndef __cplusplus
+typedef enum { false = 0, true = 1 } bool;
+#endif
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+// ----------------------------
+// OS subsystem types
+// ----------------------------
+typedef uint32_t size_t;
+typedef int32_t  ssize_t;
+
+typedef uint32_t phys_addr_t; // Physical address
+typedef uint32_t virt_addr_t; // Virtual address
+
+typedef uint32_t pid_t;       // Process ID
+typedef uint32_t tid_t;       // Thread ID
+
+// ----------------------------
+// Bitfield & utility macros
+// ----------------------------
+#define BIT(n) (1U << (n))
+#define BITS(m, n) (((1U << ((n) - (m) + 1)) - 1) << (m))
+
+// Align value to next multiple of alignment
+#define ALIGN_UP(val, align) (((val) + ((align)-1)) & ~((align)-1))
+#define ALIGN_DOWN(val, align) ((val) & ~((align)-1))
+
+// ----------------------------
+// Attributes for structures
+// ----------------------------
+#define PACKED      __attribute__((packed))
+#define ALIGN(x)    __attribute__((aligned(x)))
+
+// ----------------------------
+// Likely/unlikely branch hints
+// (for future optimization use)
+// ----------------------------
+#define likely(x)   __builtin_expect(!!(x), 1)
+#define unlikely(x) __builtin_expect(!!(x), 0)
+
+#endif // TYPES_H
--- a/kernel/utils.c
+++ b/kernel/utils.c
@@ -76,3 +76,10 @@ char* utoa(unsigned int value, char* str, int base) {
    reverse(str, i);
    return str;
 }
+
+void *memset(void *dest, int value, size_t len) {
+    unsigned char *ptr = (unsigned char *)dest;
+    while (len-- > 0)
+        *ptr++ = (unsigned char)value;
+    return dest;
+}
--- a/kernel/utils.h
+++ b/kernel/utils.h
@@ -1,7 +1,7 @@
 #ifndef UTILS_H
 #define UTILS_H

-#include <stddef.h>
+#include "types.h"

 // Convert integer to string (base is typically 10, 16, etc.)
 char* itoa(int value, char* str, int base);
@@ -9,4 +9,6 @@ char* itoa(int value, char* str, int base);
 // Convert unsigned integer to string (base is typically 10, 16, etc.)
 char* utoa(unsigned int value, char* str, int base);

+void *memset(void *dest, int value, size_t len);
+
 #endif // UTILS_H
--- a/kernel/vesa.c
+++ b/kernel/vesa.c
@@ -1,98 +0,0 @@
-#include "vesa.h"
-#include "io.h"
-#include "print.h"
-
-// VESA mode and controller information
-#define VESA_BIOS_INT 0x10
-#define VESA_BIOS_FUNC 0x4F
-
-// Function to call BIOS with specific VESA function
-static bool vesa_bios_call(uint16_t function, uint16_t* eax, uint32_t* ebx, uint32_t* ecx, uint32_t* edx) {
-    // Set up registers for VESA function call
-    __asm__ __volatile__(
-        "movw %1, %%ax\n"           // Move function number into AX
-        "int $0x10\n"                // Call BIOS interrupt 0x10 (VESA)
-        "movw %%ax, %0\n"            // Move return value in AX to the return variable
-        : "=m"(*eax)                 // Output operand (eax)
-        : "m"(function)              // Input operand (function number)
-        : "%eax", "%ebx", "%ecx", "%edx", "memory"
-    );
-    // Check for success (return values vary depending on the function)
-    return *eax == 0x004F;
-}
-
-// Set the VESA video mode
-bool vesa_set_mode(uint16_t mode) {
-    uint16_t eax = VBE_FUNCTION_SET_MODE;
-    uint32_t ebx = mode;
-    uint32_t ecx = 0;
-    uint32_t edx = 0;
-    
-    if (vesa_bios_call(VBE_FUNCTION_SET_MODE, &eax, &ebx, &ecx, &edx)) {
-        return true;
-    }
-    return false;
-}
-
-// Get the VESA mode information
-bool vesa_get_mode_info(uint16_t mode, vbe_mode_info_t* info) {
-    uint16_t eax = VBE_FUNCTION_GET_MODE_INFO;
-    uint32_t ebx = mode;
-    uint32_t ecx = 0;
-    uint32_t edx = 0;
-
-    if (vesa_bios_call(VBE_FUNCTION_GET_MODE_INFO, &eax, &ebx, &ecx, &edx)) {
-        // Copy the information into the provided struct
-        uint32_t base = (uint32_t)info;
-        __asm__ __volatile__(
-            "movw %%bx, %%es:%%di\n"
-            : 
-            : "b" (base)
-            : "%es", "%di", "memory"
-        );
-        return true;
-    }
-    return false;
-}
-
-// Get the VESA controller information
-bool vesa_get_controller_info(vbe_controller_info_t* info) {
-    uint16_t eax = VBE_FUNCTION_GET_CONTROLLER_INFO;
-    uint32_t ebx = 0;
-    uint32_t ecx = 0;
-    uint32_t edx = 0;
-
-    if (vesa_bios_call(VBE_FUNCTION_GET_CONTROLLER_INFO, &eax, &ebx, &ecx, &edx)) {
-        // Copy controller information into the provided struct
-        uint32_t base = (uint32_t)info;
-        __asm__ __volatile__(
-            "movw %%bx, %%es:%%di\n"
-            : 
-            : "b" (base)
-            : "%es", "%di", "memory"
-        );
-        return true;
-    }
-    return false;
-}
-
-// Return pointer to the VESA framebuffer
-void* vesa_get_framebuffer(void) {
-    vbe_mode_info_t mode_info;
-    if (vesa_get_mode_info(0x101, &mode_info)) {
-        return (void*)mode_info.PhysBasePtr;
-    }
-    return NULL;
-}
-
-// Clear the screen with a color
-void vesa_clear_screen(uint32_t color) {
-    uint32_t* framebuffer = (uint32_t*)vesa_get_framebuffer();
-    if (framebuffer) {
-        for (int y = 0; y < 480; y++) { // For 640x480 mode
-            for (int x = 0; x < 640; x++) {
-                framebuffer[y * 640 + x] = color;
-            }
-        }
-    }
-}
--- a/kernel/vesa.h
+++ b/kernel/vesa.h
@@ -1,67 +0,0 @@
-#ifndef VESA_H
-#define VESA_H
-
-#include <stdint.h>
-#include <stdbool.h>
-
-// VESA BIOS Extension 2.0 Function Calls
-#define VBE_FUNCTION_SET_MODE        0x4F02
-#define VBE_FUNCTION_GET_MODE_INFO   0x4F01
-#define VBE_FUNCTION_GET_CONTROLLER_INFO 0x4F00
-#define VBE_FUNCTION_SET_DISPLAY_START 0x4F05
-
-// VESA Mode Information Structure (VBE 2.0)
-typedef struct {
-    uint16_t ModeAttributes;      // Mode attributes
-    uint8_t WinAAttributes;       // Window A attributes
-    uint8_t WinBAttributes;       // Window B attributes
-    uint16_t WinGranularity;      // Window granularity
-    uint16_t WinSize;             // Window size
-    uint16_t WinASegment;         // Window A segment address
-    uint16_t WinBSegment;         // Window B segment address
-    uint32_t WinFuncPtr;          // Function pointer for window
-    uint16_t BytesPerScanLine;    // Bytes per scanline
-    uint16_t XResolution;         // Horizontal resolution in pixels
-    uint16_t YResolution;         // Vertical resolution in pixels
-    uint8_t XCharSize;            // Character cell width
-    uint8_t YCharSize;            // Character cell height
-    uint8_t NumberOfPlanes;       // Number of memory planes
-    uint8_t BitsPerPixel;         // Bits per pixel
-    uint8_t NumberOfBanks;        // Number of banks
-    uint8_t MemoryModel;          // Memory model type
-    uint8_t BankSize;             // Bank size in kB
-    uint8_t NumberOfImagePages;   // Number of image pages
-    uint8_t Reserved0;            // Reserved
-    uint8_t RedMaskSize;          // Red mask size
-    uint8_t RedFieldPosition;     // Red field position
-    uint8_t GreenMaskSize;        // Green mask size
-    uint8_t GreenFieldPosition;   // Green field position
-    uint8_t BlueMaskSize;         // Blue mask size
-    uint8_t BlueFieldPosition;    // Blue field position
-    uint8_t RsvdMaskSize;         // Reserved mask size
-    uint8_t RsvdFieldPosition;    // Reserved field position
-    uint8_t DirectColorModeInfo;  // Direct color mode info
-    uint32_t PhysBasePtr;         // Physical base address of the linear framebuffer
-    uint32_t OffScreenMemOff;     // Offset to off-screen memory
-    uint16_t OffScreenMemSize;    // Size of off-screen memory
-    uint8_t Reserved1[206];       // Reserved
-} __attribute__((packed)) vbe_mode_info_t;
-
-// VESA Controller Information
-typedef struct {
-    uint8_t VESAVersion[2];       // VESA version
-    uint32_t OEMStringPtr;        // Pointer to OEM string
-    uint8_t Capabilities[4];      // Capabilities of the controller
-    uint32_t VideoModePtr;        // Pointer to supported video modes
-    uint16_t TotalMemory;         // Total video memory (in 64KB)
-    uint8_t Reserved[4];          // Reserved
-} __attribute__((packed)) vbe_controller_info_t;
-
-// Function Prototypes
-bool vesa_set_mode(uint16_t mode);
-bool vesa_get_mode_info(uint16_t mode, vbe_mode_info_t* info);
-bool vesa_get_controller_info(vbe_controller_info_t* info);
-void* vesa_get_framebuffer(void);
-void vesa_clear_screen(uint32_t color);
-
-#endif // VESA_H
--- a/klibc/include/stdarg.h
+++ b/klibc/include/stdarg.h
@@ -1,14 +0,0 @@
-#ifndef CLASSICOS_KLIBC_STDARG_H
-#define CLASSICOS_KLIBC_STDARG_H
-
-typedef __builtin_va_list va_list;
-
-#ifndef va_start
-#define va_start(ap, param) __builtin_va_start(ap, param)
-#endif
-
-#define va_end(ap) __builtin_va_end(ap)
-#define va_arg(ap, type) __builtin_va_arg(ap, type)
-#define va_copy(dest, src) __builtin_va_copy(dest, src)
-
-#endif  // CLASSICOS_KLIBC_STDARG_H
--- a/klibc/include/stdbool.h
+++ b/klibc/include/stdbool.h
@@ -1,12 +0,0 @@
-#ifndef CLASSICOS_KLIBC_STDBOOL_H
-#define CLASSICOS_KLIBC_STDBOOL_H
-
-#ifndef __cplusplus
-#define bool _Bool
-#define true 1
-#define false 0
-#endif
-
-#define __bool_true_false_are_defined 1
-
-#endif  // CLASSICOS_KLIBC_STDBOOL_H
--- a/klibc/include/stddef.h
+++ b/klibc/include/stddef.h
@@ -1,10 +0,0 @@
-#ifndef CLASSICOS_KLIBC_STDDEF_H
-#define CLASSICOS_KLIBC_STDDEF_H
-
-typedef __SIZE_TYPE__ size_t;
-typedef __PTRDIFF_TYPE__ ptrdiff_t;
-
-#undef NULL
-#define NULL ((void*)0)
-
-#endif  // CLASSICOS_KLIBC_STDDEF_H
--- a/klibc/include/stdint.h
+++ b/klibc/include/stdint.h
@@ -1,16 +0,0 @@
-#ifndef CLASSICOS_KLIBC_STDINT_H
-#define CLASSICOS_KLIBC_STDINT_H
-
-typedef signed char int8_t;
-typedef short int int16_t;
-typedef int int32_t;
-typedef long long int int64_t;
-
-typedef unsigned char uint8_t;
-typedef unsigned short int uint16_t;
-typedef unsigned int uint32_t;
-typedef unsigned long long int uint64_t;
-
-typedef unsigned int uintptr_t;
-
-#endif  // CLASSICOS_KLIBC_STDINT_H
--- a/klibc/include/stdio.h
+++ b/klibc/include/stdio.h
@@ -1,4 +0,0 @@
-#ifndef CLASSICOS_KLIBC_STDIO_H
-#define CLASSICOS_KLIBC_STDIO_H
-
-#endif  // CLASSICOS_KLIBC_STDIO_H
--- a/klibc/include/stdlib.h
+++ b/klibc/include/stdlib.h
@@ -1,4 +0,0 @@
-#ifndef CLASSICOS_KLIBC_STDLIB_H
-#define CLASSICOS_KLIBC_STDLIB_H
-
-#endif  // CLASSICOS_KLIBC_STDLIB_H
--- a/klibc/include/string.h
+++ b/klibc/include/string.h
@@ -1,14 +0,0 @@
-#ifndef CLASSICOS_KLIBC_STRING_H
-#define CLASSICOS_KLIBC_STRING_H
-
-#include <stddef.h>
-
-extern int memcmp(const void* s1, const void* s2, size_t n);
-extern void* memmove(void* dst, const void* src, size_t n);
-extern void* memcpy(void* dst, const void* src, size_t n);
-extern void* memset(void* dst, int c, size_t n);
-
-extern size_t strlen(const char* s);
-extern int strcmp(const char* s1, const char* s2);
-
-#endif  // CLASSICOS_KLIBC_STRING_H
--- a/klibc/src/string.c
+++ b/klibc/src/string.c
@@ -1,107 +0,0 @@
-#include <string.h>
-
-int memcmp(const void* s1, const void* s2, size_t n) {
-    const unsigned char* c1 = s1;
-    const unsigned char* c2 = s2;
-    int d = 0;
-
-    while (n--) {
-        d = (int)*c1++ - (int)*c2++;
-        if (d) break;
-    }
-
-    return d;
-}
-
-void* memmove(void* dst, const void* src, size_t n) {
-    const char* p = src;
-    char* q = dst;
-#if defined(__i386__) || defined(__x86_64__)
-    if (q < p) {
-        __asm__ volatile("cld; rep; movsb" : "+c"(n), "+S"(p), "+D"(q));
-    } else {
-        p += (n - 1);
-        q += (n - 1);
-        __asm__ volatile("std; rep; movsb; cld" : "+c"(n), "+S"(p), "+D"(q));
-    }
-#else
-    if (q < p) {
-        while (n--) {
-            *q++ = *p++;
-        }
-    } else {
-        p += n;
-        q += n;
-        while (n--) {
-            *--q = *--p;
-        }
-    }
-#endif
-
-    return dst;
-}
-
-void* memcpy(void* dst, const void* src, size_t n) {
-    const char* p = src;
-    char* q = dst;
-#if defined(__i386__)
-    size_t nl = n >> 2;
-    __asm__ volatile("cld ; rep ; movsl ; movl %3,%0 ; rep ; movsb"
-                    : "+c"(nl), "+S"(p), "+D"(q)
-                    : "r"(n & 3));
-#elif defined(__x86_64__)
-    size_t nq = n >> 3;
-    __asm__ volatile("cld ; rep ; movsq ; movl %3,%%ecx ; rep ; movsb"
-                    : "+c"(nq), "+S"(p), "+D"(q)
-                    : "r"((uint32_t)(n & 7)));
-#else
-    while (n--) {
-        *q++ = *p++;
-    }
-#endif
-
-    return dst;
-}
-
-void* memset(void* dst, int c, size_t n) {
-    char* q = dst;
-
-#if defined(__i386__)
-    size_t nl = n >> 2;
-    __asm__ volatile("cld ; rep ; stosl ; movl %3,%0 ; rep ; stosb"
-                    : "+c"(nl), "+D"(q)
-                    : "a"((unsigned char)c * 0x01010101U), "r"(n & 3));
-#elif defined(__x86_64__)
-    size_t nq = n >> 3;
-    __asm__ volatile("cld ; rep ; stosq ; movl %3,%%ecx ; rep ; stosb"
-                    : "+c"(nq), "+D"(q)
-                    : "a"((unsigned char)c * 0x0101010101010101U),
-                      "r"((uint32_t)n & 7));
-#else
-    while (n--) {
-        *q++ = c;
-    }
-#endif
-
-    return dst;
-}
-
-size_t strlen(const char* s) {
-    const char* ss = s;
-    while (*ss) ss++;
-    return ss - s;
-}
-
-int strcmp(const char* s1, const char* s2) {
-    const unsigned char* c1 = (const unsigned char*)s1;
-    const unsigned char* c2 = (const unsigned char*)s2;
-    unsigned char ch;
-    int d = 0;
-
-    while (1) {
-        d = (int)(ch = *c1++) - (int)*c2++;
-        if (d || !ch) break;
-    }
-
-    return d;
-}
Author	SHA1	Message	Date
Gregory Bowne	4e8b13ad77	Create ps2.c add initial ps/2 driver code. This will need wired up to be used	2025-12-17 05:50:02 -08:00
Gregory Bowne	9f8ca3a60c	Create ps2.h	2025-12-17 05:47:59 -08:00