Beginning:                   ;calculations are based on this label
         file "filename"
    

; IDE PC Bootloader for 386+
;Features:
;- Disable all interrupts (NMI too)
;- Enable the (fast) A20 gate
;- Go into flat 32 bit protected mode
;- Loads n sectors from IDE hard drive
;  following the MBR and jumps to it.
;- Can work from any bootable medium,
;  even network!
;- BIOS independent
;
;TODO list
;-Support for PACKET atapi interface
;-Raw, small and efficient ethernet access
;-Suggestions?

;Have Fun!
macro align value { times (value-1)-($+value-1) mod value nop}

use16
org 7C00h
Beginning:
    file "header.bak"       ;optional, for FAT12 filesystems
        jmp 0:$+5
        cli                 ;Disable interrupts
        cld                 ;Clear direction flag
        in AL,070h          ;Turn NMI off
        or AL,080h
        out 070h,AL

        mov al,0Ch          ;floppy motor off
        mov dx,03F2h        ;(optional)
        out dx,al
        out 0e1h,al

        in AL,092h          ;
        or AL,2             ; Enable the fast A20 gate
        out 80h, AL         ; 1ms Delay
        out 092h,AL         ;

        lgdt [CS:GDT]       ;Loads GDT
        mov EAX,CR0         ;
        or AX,1             ; Set protected mode bit
        mov CR0,EAX         ;
        jmp 8:Protected     ;Flush pipeline

        align 8             ;Faster, optional
GDT:                        ;Flat, minimal GDT Table
        dw (8*3)-1          ; No need for the blank descriptor,
        dd GDT              ; here it holds the special
        dw 0000h            ; six bytes GDT pointer.
        dw 0FFFFh,0000h,9A00h,00CFh ;code
        dw 0FFFFh,0000h,9200h,00CFh ;data

use32
Protected:                  ;Now in 32 bit protected mode
        mov EAX, 10h        ;Data descriptor pointer
        mov DS, EAX         ;
        mov ES, EAX         ; Initialize crucial descriptors
        mov SS, EAX         ;
        mov ESP, 7C00h      ;Initialize the Return Stack

        xor EDI, EDI
        mov EAX,3           ; Load N sectors after MBR (0=256 sectors)
        call HD_Read        ; at [EDI]

        xor EDX, EDX        ;Test display routine
        mov EDI, 0B8000h
@@:     mov EAX, dword [EDX*4]
        inc EDX
        call ShowDword
        cmp EDX, 128
        jnz @b
@@:     in al, 64h
        test al,1
        jz @b
@@:     in al,60h
kb:     in al,64h           ;make sure buffer is empty
        test al,1
        jnz @b
        test al,2
        jnz kb
        mov al,0FEh         ;before sending reboot
        out 64h,al
        jmp $

IDE_Idle:
        mov DX, 1F7h
        in al,dx            ;Read Status register
        test al,80h         ; Busy bit
        jnz IDE_Idle        ; must be zero
        test al, 8h         ; Wait until DRQ bit
        jz IDE_Idle         ; is ready
        sub EDX,7h          ;1F0h: data port
        ret

HD_Read:
        mov bl, al          ;BL: loop sector counter
        mov dx, 1f2h        ;Sector count register
        out dx,al
        mov eax,0E0000000h  ;28 bits LBA address
        inc edx             ;1F3h LBA Low (0:7)
        out dx,al
        shr EAX, 8
        inc EDX             ;1F4h LBA Mid (8:15)
        out dx, al
        shr EAX, 8
        inc EDX             ;1F5h LBA High (16:23)
        out dx, al
        shr EAX, 8
        inc EDX             ;1F6h LBA & DEV, LBA (24:27)
        out dx, al
        inc EDX             ;1F7h Command register
        mov al,20h          ;"READ SECTOR(S)" command
        out dx,al
IDE_PIO_In:
        call IDE_Idle
        mov ecx,256         ;512 bytes
        rep insw            ;16 bit wide bus
        dec bl
        jnz IDE_PIO_In
        ret

ShowDword:                  ;Display routine
        mov CL, 8           ;nibble count
NextNibble:
        rol EAX, 4          ;most significant nibble first
        push EAX
        and EAX, 0Fh
        cmp AL, 0Ah
        jl @f
        add EAX, 7          ;offset to letters
@@:     add EAX, 0F30h      ;white on black attribute
        stosw
        pop EAX
        dec CL
        jnz NextNibble
        ret

        SpaceLeft = 510-($-Beginning)

        times SpaceLeft db 0h
        dw 0AA55h           ;Boot sector magic number

;===================================================================
;Number to string conversion directives from FASM manual
; * Used to get free space, as the code will always compile to 512 bytes.
d1 = '0'+ SpaceLeft shr 8 and 0Fh
d2 = '0'+ SpaceLeft shr 4 and 0Fh
d3 = '0'+ SpaceLeft and 0Fh
if d1>'9'
d1 = d1 + 7
end if
if d2>'9'
d2 = d2 + 7
end if
if d3>'9'
d3 = d3 + 7
end if

display 'Space left in MBR image: ',d1,d2,d3,'h',13,10
;===================================================================  
    

waitrdy: 
        in  al,dx           ;Read Status register 
        and al,8 
        jz waitrdy 
        mov cx, 256         ;\ 
        mov dx,1f0h         ; Sector fetch loop 
        rep insw            ; Respect 0 = 256 sectors 
        dec bl              ; 
        jnz waitrdy         ;/    

Does this work on multiple sectors? I can see how it'd work on one sector, but DX would not be vaild on second loop. I have not tried the code, but will in the future - thank you.

use16

org 7C00h

Beginning:
        cli                            ; Disable interrupts
        cld                            ; Clear direction flag

        in      al, 070h               ; Turn NMI off
        or      al, 080h
        out     070h, al

        in      al, 092h               ;\
        or      al, 2                  ; Enable the A20 through FastA20
        out     080h, al               ; 1ms Delay
        out     092h, al               ;/

        lgdt    [CS:GDT]               ; Fetch GDT

        mov     eax, cr0               ;\
        inc     ax                     ; Set protected mode bit 0
        mov     cr0, eax               ;/

        mov     ax, 10h                ; Data descriptor

        mov     dx, 1F2h               ; sector count

        jmp     8:Protected            ; Flush pipeline

        align 8

GDT:    dw 8*3 - 1                     ; flat memory GDT
        dd GDT
        dw 0000h
        dw 0FFFFh,0000h,9A00h,00CFh    ; code
        dw 0FFFFh,0000h,9200h,00CFh    ; data

use32

Protected:      ; Now in 32 bit protected mode
;        mov     ds, eax                 ;\
        mov     es, eax                 ; Initialize crucial descriptors
;        mov     ss, eax                 ;/
;        mov     esp, 7C00h              ; Initialize the Return Stack

        mov     al, 1                   ; sectors to read
        xor     edi, edi                ; destination address

        ; Loads N sectors after MBR (0=256 sectors)

        mov     bl, al                  ; BL act as sector counter
        out     dx, al

        mov     eax, 0A0000002h         ; Base address in physical CHS format
        inc     edx
        out     dx, eax

        mov     dl, 0F7h                ;\Write to Command Register
        mov     al, 020h                ; Read and Retry
        out     dx, al                  ;/
waitrdy:
        in      al, dx                  ; Read Status register
        and     eax, 8
        jz      waitrdy

        imul    ecx, eax, 256/8         ;\
        mov     dl, 0F0h                ; Sector fetch loop
;CS: override, what syntax?
        rep insw                        ;/Respect 0 = 256 sectors

        mov     dl, 0F7h                ; Write to Command Register
        dec     bl
        jnz     waitrdy

        jmp     0                      ; Jump to it, in pmode with no interrupts

        SpaceLeft = 510-($-Beginning)

        times SpaceLeft db 0

        dw 0AA55h                      ; Boot sector magic number    

I don't know if this is an error in FASM, or if both instructions are valid and different; but FASM adds a size override prefix byte to "mov ds, ax" and doesn't if the instruction is "mov ds, eax" - the latter should work and save some bytes.

Also, there is only one instruction using the ES: selector - should be able to use an override on that as well, but I haven't figured out the syntax. I don't know if assuming CS=0 on entry is a good idea.

The lgdt [CS:GDT] is the same size as my 3 instructions sequence. I don't really know for sure which is faster; the former is truly more elegant though.

IMO, it's best to set the descriptors one and for all and never touch them back after. I also like the feature that one can reuse the 32 bit code to read the HD later on.

;Written in FASM 1.48
;Test: put bytes from keyboard on screen
;
;*Posted to write on HD's second sector
; to test the IDE bootloader
;
;PC Memory map at boot time (from OSD)
;000000-0003FF interrupt vector table
;000400-0004FF BIOS data area
;000500-007BFF FREE CONVENTIONAL MEMORY
;007C00-007DFF boot sector
;007E00-09FBFF FREE CONVENTIONAL MEMORY
;09FC00-09FFFF extended BDA (variable length)
;0A0000-0FFFFF video memory and BIOS ROMs
;100000-10FFEF high memory area (HMA)
;10FFF0-       FREE EXTENDED MEMORY

org 0
use32
Start:
        mov EDI, 0B8000h
Testing:
        cmp EDI, 0B8000h+(80*25*2)
        jge Start
        xor EAX, EAX
        call KBRead
        call ShowChar
        jmp Testing

KBRead:
        in AL, 64h
        test AL, 1
        jz KBRead
        in AL, 60h
        ret

ShowChar:
        push EAX
        shr EAX, 4
        call ShowHex
        pop EAX

ShowHex:
        and EAX, 0000000Fh
        cmp EAX, 0Ah
        jl @f
        add EAX, 07h   ;letter
@@:     add EAX, 0F30h ;number
        stosw
        ret 

    

_ReadSectors:
;-T
      MOV  EDI,10000h
      MOV  AL,1
      MOV  CL,2
;-T
      MOV  BL,AL             ;counter for loop
      MOV  EDX,RegSectorCnt
      OUT  DX,AL             ;set num of sectors to transfer

      MOV  AL,CL             ;LBA address, starting sector?
      INC  EDX               ;hard disk sector number
      OUT  DX,AL             ;is this right?

      MOV  DL,RegCmdStatus   ;write command register
      MOV  AL,ReadSectors
      OUT  DX,AL             ;read specified number of sectors

_Wait:
      IN   AL,DX             ;read status register
      AND  AL,00001000b      
      JZ   _Wait             ;seek complete?

      MOV  ECX,512/2
      MOV  EDX,RegData
      REP  INSW              ;this errors in bochs
      
      MOV  EDX,RegCmdStatus  ;read status register
      DEC  BL
      JNZ  _Wait
      RET