bootloader.asm

; ============================================================
; TinyBootloader v2.0
; 2-Stufen-Bootloader mit LBA/CHS Auto-Erkennung
; und integrierter Mini-Shell
;
; Build:  nasm -f bin -o tinyboot.img bootloader.asm
; Run:    qemu-system-i386 -fda tinyboot.img
; ============================================================
; Speicherbelegung:
;   0x7C00 - 0x7DFF  Stage 1 (512 Byte, von BIOS geladen)
;   0x7E00 - 0x87FF  Stage 2 (2560 Byte, von Stage 1 geladen)
;   0x8800 - 0xFFFF  Stack (abwaerts) + frei
; ============================================================

org 0x7C00

; ============================================================
; STAGE 1 (Sektor 0, 512 Byte)
; ============================================================

entry:
    ; Segmente initialisieren (DS = ES = SS = 0)
    xor ax, ax
    mov ds, ax
    mov es, ax
    mov ss, ax
    mov sp, 0x7C00

    ; Boot-Laufwerk speichern (von BIOS in DL uebergeben)
    mov [boot_drive], dl

    ; Bildschirm loeschen
    call clearscreen

    ; Boot-Meldung ausgeben
    mov si, msg_boot
    call print
    call print_newline

    mov si, msg_loading
    call print

    ; LBA-Unterstuetzung pruefen
    call detect_lba
    jc .use_chs

    ; LBA lesen (INT 13h AH=42h)
    mov si, msg_lba
    call print

    mov si, dap
    mov dl, [boot_drive]
    mov ah, 0x42
    int 0x13
    jnc .done
    jmp .error

.use_chs:
    ; CHS lesen (INT 13h AH=02h) - Fallback fuer Diskette
    mov si, msg_chs
    call print

    mov ah, 0x02
    mov al, 5             ; 5 Sektoren lesen
    mov ch, 0             ; Cylinder 0
    mov cl, 2             ; Start-Sektor 2
    mov dh, 0             ; Head 0
    mov dl, [boot_drive]
    mov bx, 0x7E00        ; Zieladresse
    int 0x13
    jnc .done

.error:
    mov si, msg_error
    call print
.halt:
    cli
    hlt
    jmp .halt

.done:
    mov si, msg_ok
    call print

    ; Boot-Laufwerk an Stage 2 uebergeben
    mov dl, [boot_drive]
    jmp 0x0000:0x7E00

; ============================================================
; FUNKTIONEN (Stage 1)
; ============================================================

; Bildschirm loeschen via BIOS (INT 10h, AH=07h)
clearscreen:
    push ax
    push bx
    push cx
    push dx

    mov ah, 0x07
    mov al, 0x00
    mov bh, 0x07
    mov cx, 0x0000
    mov dx, 0x184F
    int 0x10

    pop dx
    pop cx
    pop bx
    pop ax
    ret

; String ausgeben (SI = Adresse, null-terminiert)
print:
    push ax
    push bx
    push si

    mov ah, 0x0E
    mov bh, 0x00
    mov bl, 0x07

.loop:
    lodsb
    test al, al
    jz .done
    int 0x10
    jmp .loop

.done:
    pop si
    pop bx
    pop ax
    ret

; Zeilenumbruch (CR + LF)
print_newline:
    push ax
    mov al, 0x0D
    int 0x10
    mov al, 0x0A
    int 0x10
    pop ax
    ret

; LBA-Unterstuetzung prüfen (INT 13h AH=41h)
; Ausgabe: CF=0 wenn LBA verfuegbar
detect_lba:
    mov ah, 0x41
    mov bx, 0x55AA
    mov dl, [boot_drive]
    int 0x13
    ret

; ============================================================
; DATEN (Stage 1)
; ============================================================

boot_drive:  db 0

msg_boot:    db "TinyBootloader v2.0", 0
msg_loading: db "Loading Stage 2...", 0
msg_lba:     db " [LBA]", 0
msg_chs:     db " [CHS]", 0
msg_ok:      db " OK", 0x0D, 0x0A, 0
msg_error:   db 0x0D, 0x0A, "Error: Disk read failed!", 0

; Disk Address Packet fuer LBA (INT 13h AH=42h)
dap:
    db 0x10        ; Packetgroesse (16 Byte)
    db 0           ; reserviert
    dw 5           ; Anzahl Sektoren (Stage 2)
    dw 0x7E00      ; Ziel-Offset
    dw 0           ; Ziel-Segment
    dq 1           ; Start-LBA (Sektor 1)

; Padding auf 512 Byte + Boot-Signatur
times 510 - ($ - $$) db 0
dw 0xAA55

; ============================================================
; STAGE 2 (Sektoren 1-5, ~2560 Byte)
; Wird von Stage 1 bei 0x7E00 geladen
; ============================================================

stage2_entry:
    ; Boot-Laufwerk aus DL sichern
    mov [stage2_boot_drive], dl

    ; Erfolgsmeldung
    mov si, msg_stage2
    call stage2_print
    call stage2_print_newline

    ; Info: LBA- oder CHS-Modus?
    mov si, msg_stage2_info
    call stage2_print
    call stage2_print_newline

.shell_loop:
    ; Prompt ausgeben
    mov si, msg_prompt
    call stage2_print

    ; Eingabe lesen
    mov di, input_buffer
    call read_line

    ; Leere Eingabe ignorieren
    mov si, input_buffer
    cmp byte [si], 0
    je .shell_loop

    ; Befehl erkennen
    mov di, cmd_help
    call strcmp
    jc .cmd_help

    mov di, cmd_cls
    call strcmp
    jc .cmd_cls

    mov di, cmd_info
    call strcmp
    jc .cmd_info

    mov di, cmd_hex
    call strcmp
    jc .cmd_hex

    mov di, cmd_hello
    call strcmp
    jc .cmd_hello

    mov di, cmd_reboot
    call strcmp
    jc .cmd_reboot

    ; Unbekannter Befehl
    mov si, msg_unknown
    call stage2_print
    mov si, input_buffer
    call stage2_print
    call stage2_print_newline
    jmp .shell_loop

.cmd_help:
    mov si, msg_help_text
    call stage2_print
    jmp .shell_loop

.cmd_cls:
    call stage2_clearscreen
    jmp .shell_loop

.cmd_info:
    call cmd_info_handler
    jmp .shell_loop

.cmd_hex:
    mov si, msg_hex_out
    call stage2_print
    mov ax, 0x1A3F
    call print_hex
    call stage2_print_newline
    jmp .shell_loop

.cmd_hello:
    mov si, msg_hello
    call stage2_print
    call stage2_print_newline
    jmp .shell_loop

.cmd_reboot:
    mov si, msg_reboot
    call stage2_print
    int 0x19

; ============================================================
; FUNKTIONEN (Stage 2)
; ============================================================

; Bildschirm loeschen
stage2_clearscreen:
    push ax
    push bx
    push cx
    push dx

    mov ah, 0x07
    mov al, 0x00
    mov bh, 0x07
    mov cx, 0x0000
    mov dx, 0x184F
    int 0x10

    pop dx
    pop cx
    pop bx
    pop ax
    ret

; String ausgeben (SI = Adresse)
stage2_print:
    push ax
    push bx
    push si

    mov ah, 0x0E
    mov bh, 0x00
    mov bl, 0x07

.loop:
    lodsb
    test al, al
    jz .done
    int 0x10
    jmp .loop

.done:
    pop si
    pop bx
    pop ax
    ret

; Zeilenumbruch
stage2_print_newline:
    push ax
    mov al, 0x0D
    int 0x10
    mov al, 0x0A
    int 0x10
    pop ax
    ret

; Ein Zeichen ausgeben (AL)
stage2_print_char:
    push ax
    push bx

    mov ah, 0x0E
    mov bh, 0x00
    mov bl, 0x07
    int 0x10

    pop bx
    pop ax
    ret

; Tastatureingabe lesen (bis Enter oder Backspace)
; DI = Zielpuffer, max. 255 Zeichen
; Ausgabe: Puffer mit null-terminiertem String
read_line:
    push ax
    push di
    push cx

    xor cx, cx

.loop:
    mov ah, 0x00
    int 0x16

    cmp al, 0x0D          ; Enter?
    je .done

    cmp al, 0x08          ; Backspace?
    je .backspace

    cmp al, 0x20          ; Steuerzeichen?
    jb .loop
    cmp al, 0x7E
    ja .loop

    cmp cx, 254           ; Puffer voll?
    jae .loop

    stosb
    inc cx
    call stage2_print_char
    jmp .loop

.backspace:
    test cx, cx
    jz .loop

    dec cx
    dec di

    mov al, 0x08
    call stage2_print_char
    mov al, 0x20
    call stage2_print_char
    mov al, 0x08
    call stage2_print_char
    jmp .loop

.done:
    xor al, al
    stosb

    call stage2_print_newline

    pop cx
    pop di
    pop ax
    ret

; Zwei null-terminierte Strings vergleichen (case-insensitive)
; SI = String 1, DI = String 2
; Ausgabe: CF=1 wenn gleich, CF=0 wenn ungleich
strcmp:
    push ax
    push si
    push di

.loop:
    lodsb
    call to_lower
    mov ah, al

    mov al, [di]
    inc di
    call to_lower

    cmp ah, al
    jne .not_equal

    test al, al
    jz .equal

    jmp .loop

.equal:
    stc
    jmp .done

.not_equal:
    clc

.done:
    pop di
    pop si
    pop ax
    ret

; Zeichen in AL in Kleinbuchstaben umwandeln
to_lower:
    cmp al, 'A'
    jb .done
    cmp al, 'Z'
    ja .done
    add al, 0x20
.done:
    ret

; AX als Hex-Zahl ausgeben (z.B. "0x1A3F")
print_hex:
    push ax
    push bx
    push cx
    push dx

    mov cx, 4
    mov bx, ax

    mov al, '0'
    call stage2_print_char
    mov al, 'x'
    call stage2_print_char

.loop:
    rol bx, 4
    mov al, bl
    and al, 0x0F
    cmp al, 10
    jb .digit
    add al, 'A' - 10
    jmp .print

.digit:
    add al, '0'

.print:
    call stage2_print_char
    dec cx
    jnz .loop

    pop dx
    pop cx
    pop bx
    pop ax
    ret

; ============================================================
; BEFEHLS-HANDLER (Stage 2)
; ============================================================

cmd_info_handler:
    push ax
    push bx
    push cx
    push dx

    ; RAM anzeigen
    mov si, msg_info_mem
    call stage2_print

    int 0x12
    call print_hex
    mov si, msg_info_kb
    call stage2_print
    call stage2_print_newline

    ; Boot-Laufwerk anzeigen
    mov si, msg_info_drive
    call stage2_print
    mov al, [stage2_boot_drive]
    xor ah, ah
    call print_hex
    call stage2_print_newline

    ; LBA/CHS
    mov si, msg_info_mode
    call stage2_print
    call stage2_print_newline

    pop dx
    pop cx
    pop bx
    pop ax
    ret

; ============================================================
; DATEN (Stage 2)
; ============================================================

stage2_boot_drive: db 0

msg_stage2:      db "Stage 2 erfolgreich geladen!", 0
msg_stage2_info: db "Gib 'help' fuer eine Befehlsliste ein.", 0
msg_prompt:      db 0x0D, 0x0A, "> ", 0

cmd_help:   db "help", 0
cmd_cls:    db "cls", 0
cmd_info:   db "info", 0
cmd_hex:    db "hex", 0
cmd_hello:  db "hello", 0
cmd_reboot: db "reboot", 0

msg_help_text:
    db "Verfuegbare Befehle:", 0x0D, 0x0A
    db "  help   - Diese Hilfe anzeigen", 0x0D, 0x0A
    db "  cls    - Bildschirm loeschen", 0x0D, 0x0A
    db "  info   - System-Informationen", 0x0D, 0x0A
    db "  hex    - Hexadezimal-Test (0x1A3F)", 0x0D, 0x0A
    db "  hello  - Hallo Welt ausgeben", 0x0D, 0x0A
    db "  reboot - Computer neustarten", 0x0D, 0x0A
    db 0

msg_unknown:     db "Unbekannter Befehl: ", 0
msg_hello:       db "Hallo Welt!", 0
msg_reboot:      db "Reboot...", 0
msg_hex_out:     db "HEX: ", 0
msg_info_mem:    db "RAM:  0x", 0
msg_info_kb:     db " KB", 0
msg_info_drive:  db "Drive: 0x", 0
msg_info_mode:   db "Modus: LBA/CHS Auto", 0

; Eingabe-Puffer (256 Byte)
input_buffer: times 256 db 0

; ============================================================
; DISKETTEN-IMAGE AUF 1.44MB AUFFUELLEN
; ============================================================
; 1.44 MB = 1474560 Bytes
; Stage 1 = Sektor 0 (512 Byte)
; Stage 2 = 5 Sektoren (2560 Byte)
; Rest = Null-Bytes als freier Platz

times 1474560 - ($ - $$) db 0