Refactor k_memcmp and implement disk_read_sector

Refactor memory comparison function and add disk read sector function.

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)
-static uint8_t g_sector_buffer[FAT12_SECTOR_SIZE];
+// Local scratch buffer
+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] = ' ';
-
     int i = 0, j = 0;
-    // Copy Name
-    while (src[i] != '\0' && src[i] != '.' && j < 8) {
-        // Convert to uppercase (simple version)
-        char c = src[i];
-        if (c >= 'a' && c <= 'z') c -= 32; 
-        dest[j++] = c;
-        i++;
+    while (src[i] && src[i] != '.' && j < 8) {
+        char c = src[i++];
+        dest[j++] = (c >= 'a' && c <= 'z') ? c - 32 : c;
     }
-    
-    // Skip extension dot
     if (src[i] == '.') i++;
-
-    // Copy Extension
     j = 8;
-    while (src[i] != '\0' && j < 11) {
-        char c = src[i];
-        if (c >= 'a' && c <= 'z') c -= 32;
-        dest[j++] = c;
-        i++;
+    while (src[i] && j < 11) {
+        char c = src[i++];
+        dest[j++] = (c >= 'a' && c <= 'z') ? c - 32 : c;
     }
 }
 
-// --- 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
-    disk_read_sector(fat_sector, g_sector_buffer);
+    uint8_t bytes[2];
+    floppy_read_sector(fat_sector, sector_buffer);
+    bytes[0] = sector_buffer[ent_offset];
 
-    // Read 16 bits (2 bytes)
-    // Note: If ent_offset == 511, the entry spans two sectors. 
-    // For simplicity in this snippet, we ignore that edge case (rare).
-    // A robust kernel would check if(ent_offset == 511) and read next sector.
-    
-    uint16_t val = *(uint16_t*)&g_sector_buffer[ent_offset];
-
-    if (current_cluster & 1) {
-        return val >> 4;      // Odd: High 12 bits
+    // Boundary Fix: If entry spans two sectors
+    if (ent_offset == 511) {
+        floppy_read_sector(fat_sector + 1, sector_buffer);
+        bytes[1] = sector_buffer[0];
     } 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];
-    to_fat_name(filename, target_name);
+    char fat_name[11];
+    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(entry[j].filename, target_name, 11) == 0) {
-                // Found it!
-                file.start_cluster = entry[j].low_cluster_num;
-                file.size = entry[j].file_size;
-                
-                // Initialize file cursor
+            if (k_memcmp(entries[j].filename, fat_name, 11) == 0) {
+                file.size = entries[j].file_size;
+                file.start_cluster = entries[j].low_cluster_num;
                 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) {
-    if (file->start_cluster == 0) return 0; // File not open
+uint32_t fat12_read(file_t *file, uint8_t *buffer, uint32_t count) {
+    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) {
-        // Check for EOF marker in FAT12 (>= 0xFF8)
-        if (file->current_cluster >= 0xFF8) break;
+    while (total_read < count && file->current_cluster < 0xFF8) {
+        uint32_t lba = data_start_lba + (file->current_cluster - 2) * bpb.sectors_per_cluster;
         
-        // Calculate Physical LBA of current cluster
-        // LBA = DataStart + ((Cluster - 2) * SectorsPerCluster)
-        uint32_t lba = data_start_lba + ((file->current_cluster - 2) * bpb.sectors_per_cluster);
+        // Read each sector in the cluster
+        for (uint8_t s = 0; s < bpb.sectors_per_cluster; s++) {
+            floppy_read_sector(lba + s, sector_buffer);
 
-        // Read the cluster
-        // NOTE: Assumes SectorsPerCluster = 1 (Standard Floppy)
-        disk_read_sector(lba, g_sector_buffer);
+            // Calculate how much of this sector we actually need
+            uint32_t offset_in_sector = file->bytes_read % FAT12_SECTOR_SIZE;
+            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_size = FAT12_SECTOR_SIZE;
+            uint32_t chunk = left_in_sector;
+            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
-        if (chunk_size > bytes_to_read) chunk_size = bytes_to_read;
-        
-        // Check if we are reading past file size
-        if (file->bytes_read + chunk_size > file->size) {
-            chunk_size = file->size - file->bytes_read;
+            // Simple memcpy replacement
+            for (uint32_t i = 0; i < chunk; i++) {
+                buffer[total_read + i] = sector_buffer[offset_in_sector + i];
             }
 
-        // Copy to user buffer
-        for (uint32_t i = 0; i < chunk_size; i++) {
-            buffer[total_read + i] = g_sector_buffer[i];
+            total_read += chunk;
+            file->bytes_read += chunk;
+
+            if (chunk == 0 || file->bytes_read >= file->size || total_read >= count) break;
         }
 
-        total_read += chunk_size;
-        file->bytes_read += chunk_size;
-        bytes_to_read -= chunk_size;
-
-        // If we finished this cluster, move to the next one
-        if (chunk_size == FAT12_SECTOR_SIZE) { // Or strictly logic based on position
+        // If we've finished the cluster, move to next
+        if (file->bytes_read % cluster_size == 0 || file->bytes_read >= file->size) {
+             if (file->bytes_read < file->size) {
                 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
-    uint8_t  sectors_per_cluster; // 1
-    uint16_t reserved_sectors;    // 1 (Boot sector)
-    uint8_t  fat_count;           // 2
-    uint16_t dir_entries_count;   // 224
-    uint16_t total_sectors;       // 2880
-    uint8_t  media_descriptor;    // 0xF0
-    uint16_t sectors_per_fat;     // 9
-    uint16_t sectors_per_track;   // 18
-    uint16_t heads;               // 2
+    uint16_t bytes_per_sector;
+    uint8_t  sectors_per_cluster;
+    uint16_t reserved_sectors;
+    uint8_t  fat_count;
+    uint16_t dir_entries_count;
+    uint16_t total_sectors;
+    uint8_t  media_descriptor;
+    uint16_t sectors_per_fat;
+    uint16_t sectors_per_track;
+    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
-    uint32_t file_size;        // Size in bytes
+    uint16_t low_cluster_num;
+    uint32_t file_size;
 } __attribute__((packed)) fat12_entry_t;
 
-// --- Kernel File Handle ---
-// This is what your kernel uses to track an open file
+/* --- Kernel File Handle --- */
+
 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)
-// Returns 0 on success, non-zero on error.
-extern int disk_read_sector(uint32_t lba, uint8_t *buffer);
-
-void fat12_init();
+void     fat12_init(void);
 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