fixed and added a lot more stuff like timer and acpi and ahci stub code and a kernel loader as well as worked on pci enumeration

src/boot/boot2.asm

@@ -40,16 +40,58 @@ start:
    call printstr
 
    ; Load the kernel into memory
-   ; ...
+   %include "kernel_loader.asm"
 
-   ; Set up GDT, IDT, IVT
-   ; ...
+   ; Set up IVT (GTD and IDT not used in 16 bit real mode)
+   ; Define interrupt handlers (replace with your actual handler code)
+   div_by_zero_handler:
+	   cli
+	   hlt
+
+   timer_handler:
+	   ; Your timer interrupt handler code
+	   hlt
+	   ret
+
+   ; IVT entries (offset 0 for all handlers since segment 0)
+   times 0x100 dw 0x0000  ; Initialize unused entries
+   dw offset div_by_zero_handler  ; Interrupt 0 (Division by Zero)
+   times 0x7 dw 0x0000          ; Skip unused entries
+   dw offset timer_handler      ; Interrupt 0x8 (Timer)
 
    ; Switch to protected mode
-   ; ...
+   ; Enable Protected Mode
+   switch_to_protected_mode:
+     cli                   ; Disable interrupts
+     mov eax, cr0           ; Get current CR0 value
+     or eax, 0x01           ; Set PE bit (Protected Mode Enable)
+     mov cr0, eax           ; Write modified CR0 value back
 
    ; Set up stack and start executing kernel's code
-   ; ...
+   ; Define GDT structure (replace with your actual GDT definition)
+   gdt_start:             ; Beginning of GDT
+     times 5 dd 0          ; Null descriptor entries (optional)
+   gdt_code:             ; Code segment descriptor
+     dw 0xffff             ; Segment size (limit)
+     dw 0x0000             ; Segment base address (low)
+     db 0x0              ; Segment base address (high)
+     db 10011010b           ; Access rights (present, readable, conforming, executable)
+     db 11001111b           ; Access rights (long mode, 4-granularity, size)
+   gdt_end:               ; End of GDT
+   gdt_descriptor:
+     equ gdt_end - gdt_start ; Size of GDT
+     dw gdt_descriptor      ; Offset of GDT
+     dd gdt_start           ; Base address of GDT
+
+   ; Load the GDT
+   lgdt [gdt_descriptor]   ; Load GDT descriptor into GDTR
+
+   ; Set up Stack (replace with your actual stack segment and address)
+   mov ss, data_segment    ; Set stack segment selector
+   mov esp, 0x100000       ; Set stack pointer (top of stack)
+
+   ; Start Kernel Execution
+   jmp farptr kernel_entry  ; Jump to kernel entry point (replace with actual address)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ; printstr routine, prints the string pointed by si using int 0x10 ;

src/boot/kernel_loader.asm

@@ -0,0 +1,28 @@
+; Define constants (adjust as needed)
+boot_drive equ 0x00   ; Drive to load kernel from (usually 0 for primary)
+kernel_sector equ 1   ; Sector containing the kernel (adjust for your kernel's location)
+kernel_segments equ 4  ; Number of sectors to load (adjust for your kernel size)
+kernel_load_address equ 0x1000 ; Memory address to load the kernel
+
+; ... (Function prototypes and int_13h implementation copied from previous response)
+; Function prototypes for readability
+; (These functions are not strictly necessary in NASM, but improve code organization)
+; Prototype for BIOS disk read interrupt (INT 13h)
+void int_13h(unsigned int ah, unsigned int al, unsigned int dx, unsigned int ch, unsigned int cl, unsigned int bx);
+
+; Function prototype for error handling or printing a message
+void error_handler(const char *message);
+; Main kernel loading code
+mov bx, kernel_load_address  ; Set load address
+
+; Loop to load kernel sectors
+mov cx, 0                     ; Initialize counter
+loop_load:
+    int_13h(0x02, kernel_segments, boot_drive * 256 + kernel_sector, ch, cl, bx)  ; Read sectors
+    add bx, 512 * kernel_segments  ; Update load address
+    inc cx                        ; Increment counter
+    cmp cx, kernel_segments        ; Check if all sectors loaded
+    jne loop_load                  ; Jump back if not finished
+
+; Success - kernel is now loaded into memory
+ret      ; Return to the main bootloader code