added diagnostic markers

Author: PythonPlumber

src/ai/ai_model.c

@@ -785,9 +785,18 @@ int ai_matmul_q16_16(const q16_16_t* a, const q16_16_t* b, q16_16_t* c, uint32_t
 }
 
 void ai_model_init(void) {
+    serial_write_string("DEBUG: ai_model_init starting...\n");
     uint32_t phys_start = (uint32_t)&_ai_model_start;
     uint32_t phys_end = (uint32_t)&_ai_model_end;
+    
+    serial_write_string("DEBUG: AI Model range: ");
+    serial_write_hex32(phys_start);
+    serial_write_string(" - ");
+    serial_write_hex32(phys_end);
+    serial_write_string("\n");
+
     if (phys_end <= phys_start) {
+        serial_write_string("DEBUG: AI Model not found (size 0)\n");
         ai_mapped_base = 0;
         ai_mapped_size = 0;
         return;
@@ -797,20 +806,30 @@ void ai_model_init(void) {
     uint32_t offset = phys_start - aligned_phys;
     uint32_t total = offset + size;
     uint32_t page_count = (total + 0x3FFFFF) >> 22;
+    
+    serial_write_string("DEBUG: Mapping AI Model pages: ");
+    serial_write_hex32(page_count);
+    serial_write_string("\n");
+
     for (uint32_t i = 0; i < page_count; ++i) {
+        if ((i % 10) == 0) serial_write_string(".");
         map_page_4mb(AI_MODEL_VIRT_BASE + (i << 22), aligned_phys + (i << 22), 0x3);
     }
+    serial_write_string("\nDEBUG: AI Model pages mapped\n");
+
     ai_mapped_base = (uint8_t*)(AI_MODEL_VIRT_BASE + offset);
     ai_mapped_size = size;
 
+    serial_write_string("DEBUG: Reading GGUF header...\n");
     gguf_header_t header;
     if (gguf_read_header(ai_mapped_base, &header)) {
-        serial_write("GGUF OK\n");
+        serial_write_string("DEBUG: GGUF OK\n");
         diag_log(DIAG_INFO, "gguf header ok");
     } else {
-        serial_write("GGUF BAD\n");
+        serial_write_string("DEBUG: GGUF BAD\n");
         diag_log(DIAG_ERROR, "gguf header invalid");
     }
+    serial_write_string("DEBUG: ai_model_init finished\n");
 }
 
 static int contains_word(const char* text, const char* word) {

src/arch/gdt.asm

@@ -13,3 +13,7 @@ gdt_flush:
     jmp 0x08:flush_cs
 flush_cs:
     ret
+
+; Simple macro for serial debug in assembly if needed, 
+; but let's just use the segment load as proof of success.
+

src/arch/pit.c

@@ -2,7 +2,9 @@
 #include "ports.h"
 
 void pit_init(uint32_t frequency) {
+    if (frequency == 0) frequency = 1;
     uint32_t divisor = 1193180 / frequency;
+    if (divisor == 0) divisor = 1;
     outb(0x43, 0x36);
     outb(0x40, (uint8_t)(divisor & 0xFF));
     outb(0x40, (uint8_t)((divisor >> 8) & 0xFF));

src/boot.asm

@@ -11,8 +11,32 @@ global _start
 extern kernel_main
 
 _start:
-    ; Setup stack and call kernel_main
-    mov esp, stack_top
+    ; Setup stack
+     mov esp, stack_top
+
+     ; Direct VGA test: '@' at top-left
+     mov word [0xB8000], 0x0E40 ; '@' yellow on black
+ 
+     ; Serial debug '!' to show we started
+    mov dx, 0x3F8 + 5 ; LSR
+.wait_serial:
+    in al, dx
+    test al, 0x20
+    jz .wait_serial
+    mov dx, 0x3F8
+    mov al, '!'
+    out dx, al
+    
+    ; Serial debug 'A' to show we are about to call kernel_main
+    mov dx, 0x3F8 + 5 ; LSR
+.wait_serial_A:
+    in al, dx
+    test al, 0x20
+    jz .wait_serial_A
+    mov dx, 0x3F8
+    mov al, 'A'
+    out dx, al
+
     push ebx                  ; Pointer to Multiboot info
     push eax                  ; Multiboot magic number
     call kernel_main

src/cpu/isr.c

@@ -186,6 +186,11 @@ static registers_t* exception_handler(registers_t* regs) {
 }
 
 static registers_t* irq0_handler(registers_t* regs) {
+    static uint32_t ticks = 0;
+    ticks++;
+    if (ticks % 100 == 0) {
+        serial_write_string("T"); // T for Tick
+    }
     timer_handler();
     kswapd_tick();
     process_t* previous = 0;
@@ -220,6 +225,9 @@ void isr_init(void) {
 }
 
 registers_t* isr_handler(registers_t* regs) {
+    serial_write_string("DEBUG: ISR ");
+    serial_write_hex32(regs->int_no);
+    serial_write_string("\n");
     if (interrupt_handlers[regs->int_no]) {
         return interrupt_handlers[regs->int_no](regs);
     }
@@ -228,6 +236,7 @@ registers_t* isr_handler(registers_t* regs) {
 
 registers_t* irq_handler(registers_t* regs) {
     uint32_t int_no = regs->int_no;
+    // serial_write_string("I"); // Too noisy? Let's use it for now
     if (interrupt_handlers[int_no]) {
         regs = interrupt_handlers[int_no](regs);
     }

src/drivers/vga.c

@@ -109,17 +109,26 @@ static void vga_write_at(const char* text, uint8_t color, uint8_t x, uint8_t y)
 }
 
 static void wait_ticks(uint64_t ticks) {
+    if (ticks == 0) return;
     uint32_t eflags;
     asm volatile("pushf; pop %0" : "=r"(eflags));
     if (!(eflags & 0x200)) {
         // Interrupts are disabled, use a smaller busy loop to avoid hangs
-        for (uint64_t i = 0; i < ticks * 100000; ++i) {
-            asm volatile("nop");
+        // 1 tick @ 100Hz is 10ms. 1000000 NOPs is roughly a few ms on modern CPUs.
+        for (uint64_t i = 0; i < ticks * 1000000; ++i) {
+            asm volatile("pause"); // Use pause for better power/sync
         }
         return;
     }
     uint64_t start = timer_get_ticks();
-    while ((timer_get_ticks() - start) < ticks) { }
+    uint64_t timeout = 0;
+    while ((timer_get_ticks() - start) < ticks) { 
+        asm volatile("pause");
+        if (++timeout > 10000000) { // Safety break if timer never increments
+             serial_write_string("WARNING: wait_ticks safety break triggered!\n");
+             break;
+        }
+    }
 }
 
 static void typewriter_vga(const char* text, uint8_t color, uint8_t x, uint8_t y) {