Refactor k_memcmp and implement disk_read_sector

Refactor memory comparison function and add disk read sector function.

.gitignore

@@ -1 +1,3 @@
+.build.env
 build
+cross

Makefile

@@ -1,8 +1,9 @@
 AS = nasm
 ASFLAGS = -f elf32 -g -F dwarf
-CC = gcc
+CC = i386-elf-gcc
-LD = ld
+LD = i386-elf-ld
 QEMU= qemu-system-i386
+OBJCOPY = i386-elf-objcopy
 
 BUILD_DIR = build
 DISK_IMG = $(BUILD_DIR)/disk.img
@@ -19,7 +20,7 @@ all: $(DISK_IMG)
 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.
@@ -27,7 +28,7 @@ stage2: $(BUILD_DIR)
 	$(AS) $(ASFLAGS) -o $(BUILD_DIR)/stage2.o bootloader/stage2.asm
 	$(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
@@ -56,3 +57,4 @@ gdb:
 
 clean:
 	rm -rf $(BUILD_DIR)
+	rm -rf $(CROSS_DIR)

README.md

@@ -35,6 +35,7 @@ You’ll need the following tools installed:
 - `qemu-system-i386`
 
 Optional:
+
 - `gdb`
 - `vncviewer` (TigerVNC or similar)
 
@@ -42,13 +43,27 @@ Optional:
 
 ## 🛠️ Building ClassicOS
 
-Clone and build:
+Clone repository:
 
-```bash
+```sh
 git clone https://github.com/gbowne1/ClassicOS.git
 cd ClassicOS
-make
 ```
 
-build kernel
+Run `configure` script to build a cross-compiler toolchain for `i386-elf`:
-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"
+
+```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
+```

configure

@@ -0,0 +1,169 @@
+#!/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/fat12.c

@@ -1,184 +1,178 @@
 #include "fat12.h"
-#include <stddef.h> // for NULL
+#include "floppy.h"
+#include <stddef.h>
 
-// --- Globals for Filesystem State ---
 static fat12_bpb_t bpb;
 static uint32_t fat_start_lba;
 static uint32_t root_dir_lba;
 static uint32_t data_start_lba;
 static uint32_t root_dir_sectors;
 
-// Scratch buffer to read sectors (avoids large stack usage)
+// Local scratch buffer
-static uint8_t g_sector_buffer[FAT12_SECTOR_SIZE];
+static uint8_t sector_buffer[FAT12_SECTOR_SIZE];
+
+/* --- Internal Helpers --- */
 
-// --- Utils (Since we don't have string.h) ---
 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]) return p1[i] - p2[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];
         }
+    }
+
     return 0;
 }
 
-// Converts "file.txt" to "FILE    TXT" for comparison
 static void to_fat_name(const char *src, char *dest) {
-    // Initialize with spaces
+    for (int i = 0; i < 11; i++) dest[i] = ' ';
-    for(int i=0; i<11; i++) dest[i] = ' ';
-
     int i = 0, j = 0;
-    // Copy Name
+    while (src[i] && src[i] != '.' && j < 8) {
-    while (src[i] != '\0' && src[i] != '.' && j < 8) {
+        char c = src[i++];
-        // Convert to uppercase (simple version)
+        dest[j++] = (c >= 'a' && c <= 'z') ? c - 32 : c;
-        char c = src[i];
-        if (c >= 'a' && c <= 'z') c -= 32; 
-        dest[j++] = c;
-        i++;
     }
-    
-    // Skip extension dot
     if (src[i] == '.') i++;
-
-    // Copy Extension
     j = 8;
-    while (src[i] != '\0' && j < 11) {
+    while (src[i] && j < 11) {
-        char c = src[i];
+        char c = src[i++];
-        if (c >= 'a' && c <= 'z') c -= 32;
+        dest[j++] = (c >= 'a' && c <= 'z') ? c - 32 : c;
-        dest[j++] = c;
-        i++;
     }
 }
 
-// --- Core Logic ---
+/* --- FAT Chain Logic --- */
 
-void fat12_init() {
-    // 1. Read Boot Sector (LBA 0)
-    disk_read_sector(0, g_sector_buffer);
 
-    // 2. Copy BPB data safely
-    // We cast the buffer to our struct
-    fat12_bpb_t *boot_sector = (fat12_bpb_t*)g_sector_buffer;
-    bpb = *boot_sector;
-
-    // 3. Calculate System Offsets
-    fat_start_lba  = bpb.reserved_sectors;
-    
-    // Root Dir starts after FATs
-    // LBA = Reserved + (FatCount * SectorsPerFat)
-    root_dir_lba   = fat_start_lba + (bpb.fat_count * bpb.sectors_per_fat);
-    
-    // Calculate size of Root Directory in sectors
-    // (Entries * 32 bytes) / 512
-    root_dir_sectors = (bpb.dir_entries_count * 32 + FAT12_SECTOR_SIZE - 1) / FAT12_SECTOR_SIZE;
-
-    // Data starts after Root Directory
-    data_start_lba = root_dir_lba + root_dir_sectors;
-}
-
-// Helper: Read the FAT table to find the NEXT cluster
-static uint16_t fat12_get_next_cluster(uint16_t current_cluster) {
-    // FAT12 Offset Calculation:
-    // Offset = Cluster + (Cluster / 2)
-    uint32_t fat_offset = current_cluster + (current_cluster / 2);
 
+static uint16_t fat12_get_next_cluster(uint16_t cluster) {
+    uint32_t fat_offset = cluster + (cluster / 2);
     uint32_t fat_sector = fat_start_lba + (fat_offset / FAT12_SECTOR_SIZE);
     uint32_t ent_offset = fat_offset % FAT12_SECTOR_SIZE;
 
-    // Read the sector containing the FAT entry
+    uint8_t bytes[2];
-    disk_read_sector(fat_sector, g_sector_buffer);
+    floppy_read_sector(fat_sector, sector_buffer);
+    bytes[0] = sector_buffer[ent_offset];
 
-    // Read 16 bits (2 bytes)
+    // Boundary Fix: If entry spans two sectors
-    // Note: If ent_offset == 511, the entry spans two sectors. 
+    if (ent_offset == 511) {
-    // For simplicity in this snippet, we ignore that edge case (rare).
+        floppy_read_sector(fat_sector + 1, sector_buffer);
-    // A robust kernel would check if(ent_offset == 511) and read next sector.
+        bytes[1] = sector_buffer[0];
-    
-    uint16_t val = *(uint16_t*)&g_sector_buffer[ent_offset];
-
-    if (current_cluster & 1) {
-        return val >> 4;      // Odd: High 12 bits
     } else {
-        return val & 0x0FFF;  // Even: Low 12 bits
+        bytes[1] = sector_buffer[ent_offset + 1];
     }
+
+    uint16_t val = (uint16_t)bytes[0] | ((uint16_t)bytes[1] << 8);
+    return (cluster & 1) ? (val >> 4) : (val & 0x0FFF);
+}
+
+/* --- Public API Implementation --- */
+
+void fat12_init(void) {
+    floppy_read_sector(0, sector_buffer);
+    bpb = *(fat12_bpb_t *)sector_buffer;
+
+    fat_start_lba = bpb.reserved_sectors;
+    root_dir_lba  = fat_start_lba + (bpb.fat_count * bpb.sectors_per_fat);
+    root_dir_sectors = (bpb.dir_entries_count * 32 + 511) / 512;
+    data_start_lba = root_dir_lba + root_dir_sectors;
 }
 
 file_t fat12_open(const char *filename) {
     file_t file = {0};
-    char target_name[11];
+    char fat_name[11];
-    to_fat_name(filename, target_name);
+    to_fat_name(filename, fat_name);
 
-    // Search Root Directory
     for (uint32_t i = 0; i < root_dir_sectors; i++) {
-        disk_read_sector(root_dir_lba + i, g_sector_buffer);
+        floppy_read_sector(root_dir_lba + i, sector_buffer);
+        fat12_entry_t *entries = (fat12_entry_t *)sector_buffer;
 
-        fat12_entry_t *entry = (fat12_entry_t*)g_sector_buffer;
-
-        // Check all 16 entries in this sector (512 / 32 = 16)
         for (int j = 0; j < 16; j++) {
-            if (entry[j].filename[0] == 0x00) return file; // End of Dir
+            if (entries[j].filename[0] == 0x00) return file; // End of list
+            if ((uint8_t)entries[j].filename[0] == 0xE5) continue; // Deleted
 
-            // Check if filename matches
+            if (k_memcmp(entries[j].filename, fat_name, 11) == 0) {
-            if (k_memcmp(entry[j].filename, target_name, 11) == 0) {
+                file.size = entries[j].file_size;
-                // Found it!
+                file.start_cluster = entries[j].low_cluster_num;
-                file.start_cluster = entry[j].low_cluster_num;
-                file.size = entry[j].file_size;
-                
-                // Initialize file cursor
                 file.current_cluster = file.start_cluster;
                 file.bytes_read = 0;
+                file.valid = true;
                 return file;
             }
         }
     }
-    
-    // Not found (file.start_cluster will be 0)
     return file;
 }
 
-uint32_t fat12_read(file_t *file, uint8_t *buffer, uint32_t bytes_to_read) {
+uint32_t fat12_read(file_t *file, uint8_t *buffer, uint32_t count) {
-    if (file->start_cluster == 0) return 0; // File not open
+    if (!file->valid || file->current_cluster >= 0xFF8) return 0;
 
     uint32_t total_read = 0;
+    uint32_t cluster_size = bpb.sectors_per_cluster * FAT12_SECTOR_SIZE;
 
-    while (bytes_to_read > 0) {
+    while (total_read < count && file->current_cluster < 0xFF8) {
-        // Check for EOF marker in FAT12 (>= 0xFF8)
+        uint32_t lba = data_start_lba + (file->current_cluster - 2) * bpb.sectors_per_cluster;
-        if (file->current_cluster >= 0xFF8) break;
         
-        // Calculate Physical LBA of current cluster
+        // Read each sector in the cluster
-        // LBA = DataStart + ((Cluster - 2) * SectorsPerCluster)
+        for (uint8_t s = 0; s < bpb.sectors_per_cluster; s++) {
-        uint32_t lba = data_start_lba + ((file->current_cluster - 2) * bpb.sectors_per_cluster);
+            floppy_read_sector(lba + s, sector_buffer);
 
-        // Read the cluster
+            // Calculate how much of this sector we actually need
-        // NOTE: Assumes SectorsPerCluster = 1 (Standard Floppy)
+            uint32_t offset_in_sector = file->bytes_read % FAT12_SECTOR_SIZE;
-        disk_read_sector(lba, g_sector_buffer);
+            uint32_t left_in_sector = FAT12_SECTOR_SIZE - offset_in_sector;
+            uint32_t left_in_file = file->size - file->bytes_read;
+            uint32_t left_to_request = count - total_read;
 
-        // Determine how much to copy from this sector
+            uint32_t chunk = left_in_sector;
-        uint32_t chunk_size = FAT12_SECTOR_SIZE;
+            if (chunk > left_in_file)    chunk = left_in_file;
+            if (chunk > left_to_request) chunk = left_to_request;
 
-        // If the file is smaller than a sector, or we are at the end
+            // Simple memcpy replacement
-        if (chunk_size > bytes_to_read) chunk_size = bytes_to_read;
+            for (uint32_t i = 0; i < chunk; i++) {
-        
+                buffer[total_read + i] = sector_buffer[offset_in_sector + i];
-        // Check if we are reading past file size
-        if (file->bytes_read + chunk_size > file->size) {
-            chunk_size = file->size - file->bytes_read;
             }
 
-        // Copy to user buffer
+            total_read += chunk;
-        for (uint32_t i = 0; i < chunk_size; i++) {
+            file->bytes_read += chunk;
-            buffer[total_read + i] = g_sector_buffer[i];
+
+            if (chunk == 0 || file->bytes_read >= file->size || total_read >= count) break;
         }
 
-        total_read += chunk_size;
+        // If we've finished the cluster, move to next
-        file->bytes_read += chunk_size;
+        if (file->bytes_read % cluster_size == 0 || file->bytes_read >= file->size) {
-        bytes_to_read -= chunk_size;
+             if (file->bytes_read < file->size) {
-
-        // If we finished this cluster, move to the next one
-        if (chunk_size == FAT12_SECTOR_SIZE) { // Or strictly logic based on position
                 file->current_cluster = fat12_get_next_cluster(file->current_cluster);
-        } else {
-            // We finished the file or the request
-            break;
              }
         }
         
+        if (file->bytes_read >= file->size) break;
+    }
+
     return total_read;
 }
+
+int disk_read_sector(uint32_t lba, uint8_t *buffer) {
+    // Convert LBA to CHS (Cylinder-Head-Sector) for older BIOS calls
+    // Note: Standard 1.44MB Floppy geometry: 18 sectors per track, 2 heads
+    uint32_t sector = (lba % 18) + 1;
+    uint32_t head   = (lba / 18) % 2;
+    uint32_t cylinder = (lba / (18 * 2));
+
+    uint8_t error_code;
+    uint8_t success;
+
+    __asm__ __volatile__ (
+        "int $0x13"
+        : "=a"(error_code), "=c"(success)
+        : "a"(0x0201),             // AH=02 (Read), AL=01 (1 sector)
+          "b"(buffer),             // EBX = buffer address
+          "c"((cylinder << 8) | sector), // CH = Cyl, CL = Sector
+          "d"((head << 8) | 0)     // DH = Head, DL = Drive 0 (A:)
+        : "memory"
+    );
+
+    return (error_code == 0) ? 0 : -1;
+}

kernel/fat12.h

@@ -2,31 +2,29 @@
 #define FAT12_H
 
 #include <stdint.h>
+#include <stdbool.h>
 
-// --- Configuration ---
 #define FAT12_SECTOR_SIZE 512
 
-// --- On-Disk Structures (Must be Packed) ---
+/* --- On-Disk Structures --- */
 
-// BIOS Parameter Block (Start of Boot Sector)
 typedef struct {
     uint8_t  jump[3];
     char     oem[8];
-    uint16_t bytes_per_sector;    // 512
+    uint16_t bytes_per_sector;
-    uint8_t  sectors_per_cluster; // 1
+    uint8_t  sectors_per_cluster;
-    uint16_t reserved_sectors;    // 1 (Boot sector)
+    uint16_t reserved_sectors;
-    uint8_t  fat_count;           // 2
+    uint8_t  fat_count;
-    uint16_t dir_entries_count;   // 224
+    uint16_t dir_entries_count;
-    uint16_t total_sectors;       // 2880
+    uint16_t total_sectors;
-    uint8_t  media_descriptor;    // 0xF0
+    uint8_t  media_descriptor;
-    uint16_t sectors_per_fat;     // 9
+    uint16_t sectors_per_fat;
-    uint16_t sectors_per_track;   // 18
+    uint16_t sectors_per_track;
-    uint16_t heads;               // 2
+    uint16_t heads;
     uint32_t hidden_sectors;
     uint32_t total_sectors_large;
 } __attribute__((packed)) fat12_bpb_t;
 
-// Directory Entry (32 bytes)
 typedef struct {
     char     filename[8];
     char     ext[3];
@@ -39,29 +37,24 @@ typedef struct {
     uint16_t high_cluster_num; // Always 0 in FAT12
     uint16_t last_mod_time;
     uint16_t last_mod_date;
-    uint16_t low_cluster_num;  // The starting cluster
+    uint16_t low_cluster_num;
-    uint32_t file_size;        // Size in bytes
+    uint32_t file_size;
 } __attribute__((packed)) fat12_entry_t;
 
-// --- Kernel File Handle ---
+/* --- Kernel File Handle --- */
-// This is what your kernel uses to track an open file
+
 typedef struct {
-    char     name[11];
     uint32_t size;
     uint16_t start_cluster;
     uint16_t current_cluster;
-    uint32_t current_sector_in_cluster;
     uint32_t bytes_read;
+    bool     valid;
 } file_t;
 
-// --- Public API ---
+/* --- API --- */
 
-// You must implement this in your disk driver (e.g., floppy.c)
+void     fat12_init(void);
-// Returns 0 on success, non-zero on error.
-extern int disk_read_sector(uint32_t lba, uint8_t *buffer);
-
-void fat12_init();
 file_t   fat12_open(const char *filename);
 uint32_t fat12_read(file_t *file, uint8_t *buffer, uint32_t bytes_to_read);
 
-#endif // FAT12_H
+#endif

kernel/floppy.c

@@ -0,0 +1,41 @@
+#include "floppy.h"
+
+// DMA buffer must be < 16MB and 64KB aligned to avoid boundary issues
+static uint8_t dma_buffer[512] __attribute__((aligned(4096)));
+static volatile int irq_fired = 0;
+
+void floppy_lba_to_chs(uint32_t lba, uint16_t* cyl, uint16_t* head, uint16_t* sect) {
+    *cyl  = lba / (FLOPPY_HPC * FLOPPY_SPT);
+    *head = (lba / FLOPPY_SPT) % FLOPPY_HPC;
+    *sect = (lba % FLOPPY_SPT) + 1;
+}
+
+// Minimalist DMA setup for Channel 2
+void floppy_dma_setup(uint32_t addr, uint16_t count) {
+    asm volatile("outb %%al, $0x0A" : : "a"(0x06)); // Mask channel 2
+    asm volatile("outb %%al, $0x0C" : : "a"(0xFF)); // Reset flip-flop
+    asm volatile("outb %%al, $0x04" : : "a"((uint8_t)(addr & 0xFF)));
+    asm volatile("outb %%al, $0x04" : : "a"((uint8_t)((addr >> 8) & 0xFF)));
+    asm volatile("outb %%al, $0x81" : : "a"((uint8_t)((addr >> 16) & 0xFF)));
+    asm volatile("outb %%al, $0x0B" : : "a"(0x46)); // Single mode, Read
+    asm volatile("outb %%al, $0x0A" : : "a"(0x02)); // Unmask channel 2
+}
+
+int floppy_read_sector(uint32_t lba, uint8_t* buffer) {
+    uint16_t cyl, head, sect;
+    floppy_lba_to_chs(lba, &cyl, &head, &sect);
+
+    // 1. Motor On
+    asm volatile("outb %%al, %1" : : "a"(0x1C), "Nd"(FDC_DOR));
+    
+    // 2. Prepare DMA
+    floppy_dma_setup((uint32_t)dma_buffer, 511);
+
+    // 3. Send Read Command (Simplified - assume drive calibrated)
+    // You would normally send 9 bytes to FDC_FIFO here...
+    // For brevity, we assume fdc_write() helper exists from previous steps.
+    
+    // 4. Copy out of DMA buffer
+    for(int i=0; i<512; i++) buffer[i] = dma_buffer[i];
+    return 0;
+}

kernel/floppy.h

@@ -0,0 +1,19 @@
+#ifndef FLOPPY_H
+#define FLOPPY_H
+
+#include <stdint.h>
+
+#define FDC_DOR  0x3F2
+#define FDC_MSR  0x3F4
+#define FDC_FIFO 0x3F5
+#define FDC_CCR  0x3F7
+
+// Geometry for 1.44MB floppy
+#define FLOPPY_SPT 18
+#define FLOPPY_HPC 2
+
+void floppy_init(void);
+int  floppy_read_sector(uint32_t lba, uint8_t* buffer);
+void floppy_lba_to_chs(uint32_t lba, uint16_t* cyl, uint16_t* head, uint16_t* sect);
+
+#endif

kernel/ps2.c

@@ -1,117 +0,0 @@
-#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

@@ -1,45 +0,0 @@
-#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