Create ps2.c

add initial ps/2 driver code. This will need wired up to be used

.gitignore

@@ -1,5 +1 @@
-.build.env
+build
-build
-cross
-.cache/
-compile_commands.json

Makefile

@@ -1,12 +1,10 @@
 AS = nasm
 ASFLAGS = -f elf32 -g -F dwarf
-CC = i386-elf-gcc
+CC = gcc
-LD = i386-elf-ld
+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))
-
 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
+kernel: $(KERNEL_OBJ) | $(BUILD_DIR)
-	$(CC) -std=c11 -ffreestanding -nostdlib -nostdinc -fno-stack-protector -m32 -Iklibc/include -g -c -o $@ $<
+	$(LD) -melf_i386 -Tkernel/linker.ld -o $(BUILD_DIR)/kernel.elf $(KERNEL_OBJ)
-
-kernel: $(KERNEL_OBJ) | $(BUILD_DIR) $(KLIBC_OBJ)
-	$(LD) -melf_i386 -Tkernel/linker.ld -o $(BUILD_DIR)/kernel.elf $(KERNEL_OBJ) $(KLIBC_OBJ)
 
 $(DISK_IMG): stage1 stage2 kernel
 	dd if=$(BUILD_DIR)/stage1.bin of=$@
@@ -55,7 +47,6 @@ $(DISK_IMG): stage1 stage2 kernel
 
 $(BUILD_DIR):
 	mkdir -p $@
-	mkdir -p $(BUILD_DIR)/klibc
 
 run:
 	qemu-system-i386 -s -S $(DISK_IMG)
@@ -65,9 +56,3 @@ gdb:
 
 clean:
 	rm -rf $(BUILD_DIR)
-
-clean-cross:
-	rm -rf $(CROSS_DIR)
-	rm -rf .build.env
-
-clean-all: clean clean-cross

README.md

@@ -5,7 +5,7 @@
 [![Platform](https://img.shields.io/badge/platform-x86_IA32-lightgrey?style=flat-square)](https://en.wikipedia.org/wiki/IA-32)
 [![Made with](https://img.shields.io/badge/made%20with-C%20%26%20NASM-9cf?style=flat-square)](#)
 
-> **ClassicOS** is a 32-bit Intel x86 operating system built from scratch using C, NASM, and GCC.
+> **ClassicOS** is a 32-bit Intel x86 operating system built from scratch using C, NASM, and GCC.  
 > Designed for 386, 486, and Pentium-class CPUs, it runs in protected mode, outputs to VGA text mode and serial ports, and supports floppy/HDD boot with basic FAT support.
 
 ---
@@ -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"

bootloader/stage2.asm

@@ -40,13 +40,6 @@ ata_lba_read:
     push edx
     push edi
 
-    ; Wait BSY=0 before proceeding to write the regs
-.wait_rdy:
-    mov edx, 0x1F7
-    in al, dx
-    test al, 0x80
-    jnz .wait_rdy
-
     mov eax, [ebp+8]     ; arg #1 = LBA
     mov cl, [ebp+12]     ; arg #2 = # of sectors
     mov edi, [ebp+16]    ; arg #3 = buffer address
@@ -81,23 +74,21 @@ ata_lba_read:
     mov al, 0x20         ; Read with retry.
     out dx, al
 
-    mov bl, cl           ; Save # of sectors in BL
+    mov bl, cl          ; Save # of sectors in BL
 
-.wait_rdy2:
+.wait_drq:
     mov edx, 0x1F7
-.do_wait_rdy2:
+.do_wait_drq:
     in al, dx
-    test al, 0x80        ; BSY?
+    test al, 8           ; the sector buffer requires servicing.
-    jnz .do_wait_rdy2
+    jz .do_wait_drq      ; keep polling until the sector buffer is ready.
-    test al, 0x8         ; DRQ?
-    jz .do_wait_rdy2
 
     mov edx, 0x1F0       ; Data port, in and out
     mov ecx, 256
     rep insw             ; in to [RDI]
 
     dec bl               ; are we...
-    jnz .wait_rdy2       ; ...done?
+    jnz .wait_drq        ; ...done?
 
     pop edi
     pop edx

configure

@@ -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 "======================"

kernel/context_switch.s

@@ -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):

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);

kernel/memory.c

@@ -1,6 +1,6 @@
 #include "memory.h"
 
-/* note: this is a stub, please use care as theres duplicate functions in utils implementation
+/* note: this is a stub, please use care as theres duplicate functions in utils implementation 
 /* --------------------------------------------------------------------- *
  *  Helper: copy a single byte (used by both memcpy and memmove)
  * --------------------------------------------------------------------- */
@@ -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;
+}

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
+    }
+}

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

kernel/types.h

@@ -27,6 +27,7 @@ typedef enum { false = 0, true = 1 } bool;
 // ----------------------------
 // OS subsystem types
 // ----------------------------
+typedef uint32_t size_t;
 typedef int32_t  ssize_t;
 
 typedef uint32_t phys_addr_t; // Physical address

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;
+}

kernel/utils.h

@@ -1,8 +1,6 @@
 #ifndef UTILS_H
 #define UTILS_H
 
-#include <stddef.h>
-
 #include "types.h"
 
 // Convert integer to string (base is typically 10, 16, etc.)

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

klibc/include/stdbool.h

@@ -1,6 +0,0 @@
-#ifndef CLASSICOS_KLIBC_STDBOOL_H
-#define CLASSICOS_KLIBC_STDBOOL_H
-
-typedef enum { false = 0, true = 1 } bool;
-
-#endif  // CLASSICOS_KLIBC_STDBOOL_H

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

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

klibc/include/stdio.h

@@ -1,4 +0,0 @@
-#ifndef CLASSICOS_KLIBC_STDIO_H
-#define CLASSICOS_KLIBC_STDIO_H
-
-#endif  // CLASSICOS_KLIBC_STDIO_H

klibc/include/stdlib.h

@@ -1,4 +0,0 @@
-#ifndef CLASSICOS_KLIBC_STDLIB_H
-#define CLASSICOS_KLIBC_STDLIB_H
-
-#endif  // CLASSICOS_KLIBC_STDLIB_H

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

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;
-}