; Copyright 2022 Mattia Giambirtone & Contributors
;
; Licensed under the Apache License, Version 2.0 (the "License");
; you may not use this file except in compliance with the License.
; You may obtain a copy of the License at
;
; http://www.apache.org/licenses/LICENSE-2.0
;
; Unless required by applicable law or agreed to in writing, software
; distributed under the License is distributed on an "AS IS" BASIS,
; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
; See the License for the specific language governing permissions and
; limitations under the License.

; Welcome to TSBL: The Simple Bootloader

[org 0x7c00]    ; Address where the code expects to be loaded in. The BIOS always loads us here
[bits 16]       ; All x86 CPUs start in 16 bit (aka "real") mode, so we tell nasm to emit 16-bit code

; Code copied from the limine bootloader

jmp skip_bpb ; Workaround for some BIOSes that require this stub
nop

; Some BIOSes will do a funny and decide to overwrite bytes of code in
; the section where a FAT BPB would be, potentially overwriting
; bootsector code.
; Avoid that by filling the BPB area with dummy values.
; Some of the values have to be set to certain values in order
; to boot on even quirkier machines.
; Source: https://github.com/freebsd/freebsd-src/blob/82a21151cf1d7a3e9e95b9edbbf74ac10f386d6a/stand/i386/boot2/boot1.S

bpb:
    times 3-($-$$) db 0
    bpb_oem_id:            db "TSBL  "
    bpb_sector_size:       dw 512
    bpb_sects_per_cluster: db 0
    bpb_reserved_sects:    dw 0
    bpb_fat_count:         db 0
    bpb_root_dir_entries:  dw 0
    bpb_sector_count:      dw 0
    bpb_media_type:        db 0
    bpb_sects_per_fat:     dw 0
    bpb_sects_per_track:   dw 18
    bpb_heads_count:       dw 2
    bpb_hidden_sects:      dd 0
    bpb_sector_count_big:  dd 0
    bpb_drive_num:         db 0
    bpb_reserved:          db 0
    bpb_signature:         db 0
    bpb_volume_id:         dd 0
    bpb_volume_label:      db "TSBL     "
    bpb_filesystem_type:   times 8 db 0


kernel_offset: equ 0x1000   ; Address in memory where kernel will be loaded
reserved_sectors: equ 4     ; How many disk sectors we reserve for our second stage


skip_bpb:
    cli 
    cld
    ; This isn't needed inside the qemu emulator, but
    ; real hardware is unlikely to start up with the
    ; segment registers zeroed, so we do it here
    xor si, si
    mov ds, si
    mov ss, si
    mov es, si 


    ; We save the value of the current boot drive
    mov [boot_drive], dl

    ; Now we setup the stack by setting the
    ; base pointer to a location that's far
    ; enough from where the code for the BIOS
    ; is located
    mov sp, 0x7c00
    mov bp, sp
    sti
    call bios_cls
    mov si, loading_stage2_msg
    call bios_println
    mov bx, stage2
    mov cl, 2
    mov dh, reserved_sectors
    mov dl, [boot_drive]
    call load_disk
    jmp stage2


; Variables needed in the boot
; sector
boot_drive: db 0
loading_stage2_msg: db "TSBL -  INFO: Stage 1 loaded, loading stage 2", 0

; We include just the bare minimum needed to load the
; second stage of our bootloader
%include "src/boot/util/disk.s"
%include "src/boot/util/io.s"

; Padding and magic number
times 510 - ($ - $$) db 0
dw 0xaa55

[bits 16]

stage2:
    ; Here we're no longer limited by the size of the
    ; boot sector, so we can perform the more complex
    ; part of the boot process
    mov si, stage2_loaded_msg
    call bios_println
    call load_kernel
    call switch_to_protected_mode


load_kernel:
    ; Loads the kernel into memory
    mov bx, kernel_offset
    mov cl, reserved_sectors + 1
    mov dh, 4
    mov dl, [boot_drive]
    call load_disk
    mov si, kernel_loaded_msg
    call bios_println
    ret


[bits 32]
BEGIN_32BIT: ; After the switch we will get here
    call enableA20
    call kernel_offset
    cli
    hlt
    jmp $


; Now we include the necessary files to switch to
; 32-bit (aka protected) mode
%include "src/boot/gdt.s"
%include "src/boot/switch32.s"
%include "src/boot/util/enablea20.s"


; Here we define our variables used in the second stage
kernel_loaded_msg: db "TSBL -  INFO: Kernel loaded, switching to protected mode", 0
stage2_loaded_msg: db "TSBL -  INFO: Stage 2 loaded, loading kernel", 0


times (512 * reserved_sectors) - ($ - $$) db 0  ; Pads the section to exactly reserved_sectors