; ==================================================================
; The Mike Operating System bootloader
; Copyright (C) 2006 - 2013 MikeOS Developers -- see doc/LICENSE.TXT
; Based on a free boot loader by E Dehling. It scans the FAT12
; floppy for KERNEL.BIN, loads it and executes it.
; This must grow no larger than 512 bytes (one sector), with the final
; two bytes being the boot signature (AA55h). Note that in FAT12,
; a cluster is the same as a sector: 512 bytes.
; ==================================================================
; To test this program install qemu (sudo apt-get install qemu-system)
; In this program kernel.bin from http://mikeos.sourceforge.net/ is used

bits 16

jmp short bootloader_start		; Jump past disk description section
nop								; Pad out before disk description

; ------------------------------------------------------------------
; Disk description table, to make it a valid floppy
; Note: some of these values are hard-coded in the source!
; Values are those used by IBM for 1.44 MB, 3.5" diskette

OEMLabel:				db "BOOTDISK"	;Disk label
BytesPerSector:			dw 512			;Bytes per sector
SectorsPerCluster:		db 1			;Sectors per cluster
ReservedForBoot:		dw 1			;Reserved sectors for boot record
NumberOfFats:			db 2			;Number of copies of the FAT
RootDirEntries:			dw 224			;Number of entries in root dir
									;(224 * 32 = 7168 = 14 sectors to read)
LogicalSectors:			dw 2880			;Number of logical sectors
MediumByte:				db 0F0h			;Medium descriptor byte
SectorsPerFat:			dw 9			;Sectors per FAT
SectorsPerTrack:		dw 18			;Sectors per track (36/cylinder)
Sides:					dw 2			;Number of sides/heads
HiddenSectors:			dd 0			;Number of hidden sectors
LargeSectors:			dd 0			;Number of LBA sectors
DriveNo:				dw 0			;Drive No: 0
Signature:				db 41			;Drive signature: 41 for floppy
VolumeID:				dd 00000000h	;Volume ID: any number
VolumeLabel:			db "BOOTDISK   ";Volume Label: any 11 chars
FileSystem:				db "FAT12   "	;File system type: don't change!

; ------------------------------------------------------------------
; Main bootloader code

   mov ax, 07C0h                   ; Set up 4K of stack space above buffer
   add ax, 544                     ; 8k buffer = 512 paragraphs + 32 paragraphs (loader)
   cli                             ; Disable interrupts while changing stack
   mov ss, ax
   mov sp, 4096
   sti                             ; Restore interrupts

   mov ax, 07C0h                   ; Set data segment to where we're loaded
   mov ds, ax

   ; NOTE: A few early BIOSes are reported to improperly set DL

   cmp dl, 0
   je no_change
   mov [bootdev], dl               ; Save boot device number
   mov ah, 8                       ; Get drive parameters
   int 13h
   jc fatal_disk_error
   and cx, 3Fh                     ; Maximum sector number
   mov [SectorsPerTrack], cx       ; Sector numbers start at 1
   movzx dx, dh                    ; Maximum head number
   add dx, 1                       ; Head numbers start at 0 - add 1 for total
   mov [Sides], dx

   mov eax, 0                      ; Needed for some older BIOSes

; First, we need to load the root directory from the disk. Technical details:
; Start of root = ReservedForBoot + NumberOfFats * SectorsPerFat = logical 19
; Number of root = RootDirEntries * 32 bytes/entry / 512 bytes/sector = 14
; Start of user data = (start of root) + (number of root) = logical 33

floppy_ok:                              ; Ready to read first block of data
   mov ax, 19                      ; Root dir starts at logical sector 19
   call l2hts

   mov si, buffer                  ; Set ES:BX to point to our buffer (see end of code)
   mov bx, ds
   mov es, bx
   mov bx, si

   mov ah, 2                       ; Params for int 13h: read floppy sectors
   mov al, 14                      ; And read 14 of them

   pusha                           ; Prepare to enter loop

   popa                            ; In case registers are altered by int 13h

   stc                             ; A few BIOSes do not set properly on error
   int 13h                         ; Read sectors using BIOS

   jnc search_dir                  ; If read went OK, skip ahead
   call reset_floppy               ; Otherwise, reset floppy controller and try again
   jnc read_root_dir               ; Floppy reset OK?

   jmp reboot                      ; If not, fatal double error


   mov ax, ds                      ; Root dir is now in [buffer]
   mov es, ax                      ; Set DI to this info
   mov di, buffer

   mov cx, word [RootDirEntries]   ; Search all (224) entries
   mov ax, 0                       ; Searching at offset 0

   xchg cx, dx                     ; We use CX in the inner loop...

   mov si, kern_filename           ; Start searching for kernel filename
   mov cx, 11
   rep cmpsb
   je found_file_to_load           ; Pointer DI will be at offset 11

   add ax, 32                      ; Bump searched entries by 1 (32 bytes per entry)

   mov di, buffer                  ; Point to next entry
   add di, ax

   xchg dx, cx                     ; Get the original CX back
   loop next_root_entry

   mov si, file_not_found          ; If kernel is not found, bail out
   call print_string
   jmp reboot

found_file_to_load:                     ; Fetch cluster and load FAT into RAM
   mov ax, word [es:di+0Fh]        ; Offset 11 + 15 = 26, contains 1st cluster
   mov word [cluster], ax

   mov ax, 1                       ; Sector 1 = first sector of first FAT
   call l2hts

   mov di, buffer                  ; ES:BX points to our buffer
   mov bx, di

   mov ah, 2                       ; int 13h params: read (FAT) sectors
   mov al, 9                       ; All 9 sectors of 1st FAT

   pusha                           ; Prepare to enter loop

   popa                            ; In case registers are altered by int 13h

   int 13h                         ; Read sectors using the BIOS

   jnc read_fat_ok                 ; If read went OK, skip ahead
   call reset_floppy               ; Otherwise, reset floppy controller and try again
   jnc read_fat                    ; Floppy reset OK?

; ******************************************************************
; ******************************************************************
   mov si, disk_error              ; If not, print error message and reboot
   call print_string
   jmp reboot                      ; Fatal double error


   mov ax, 2000h                   ; Segment where we'll load the kernel
   mov es, ax
   mov bx, 0

   mov ah, 2                       ; int 13h floppy read params
   mov al, 1

   push ax                         ; Save in case we (or int calls) lose it

; Now we must load the FAT from the disk. Here's how we find out where it starts:
; FAT cluster 0 = media descriptor = 0F0h
; FAT cluster 1 = filler cluster = 0FFh
; Cluster start = ((cluster number) - 2) * SectorsPerCluster + (start of user)
;               = (cluster number) + 31

   mov ax, word [cluster]          ; Convert sector to logical
   add ax, 31

   call l2hts                      ; Make appropriate params for int 13h

   mov ax, 2000h                   ; Set buffer past what we've already read
   mov es, ax
   mov bx, word [pointer]

   pop ax                          ; Save in case we (or int calls) lose it
   push ax

   int 13h

   jnc calculate_next_cluster      ; If there's no error...

   call reset_floppy               ; Otherwise, reset floppy and retry
   jmp load_file_sector

   ; In the FAT, cluster values are stored in 12 bits, so we have to
   ; do a bit of maths to work out whether we're dealing with a byte
   ; and 4 bits of the next byte -- or the last 4 bits of one byte
   ; and then the subsequent byte!

   mov ax, [cluster]
   mov dx, 0
   mov bx, 3
   mul bx
   mov bx, 2
   div bx                          ; DX = [cluster] mod 2
   mov si, buffer
   add si, ax                      ; AX = word in FAT for the 12 bit entry
   mov ax, word [ds:si]

   or dx, dx                       ; If DX = 0 [cluster] is even; if DX = 1 then it's odd

   jz even                         ; If [cluster] is even, drop last 4 bits of word
							; with next cluster; if odd, drop first 4 bits

   shr ax, 4                       ; Shift out first 4 bits (they belong to another entry)
   jmp short next_cluster_cont

   and ax, 0FFFh                   ; Mask out final 4 bits

   mov word [cluster], ax          ; Store cluster

   cmp ax, 0FF8h                   ; FF8h = end of file marker in FAT12
   jae end

   add word [pointer], 512         ; Increase buffer pointer 1 sector length
   jmp load_file_sector

end:                                    ; We've got the file to load!
   pop ax                          ; Clean up the stack (AX was pushed earlier)
   mov dl, byte [bootdev]          ; Provide kernel with boot device info

   jmp 2000h:0000h                 ; Jump to entry point of loaded kernel!

; ------------------------------------------------------------------

   mov ax, 0
   int 16h                         ; Wait for keystroke
   mov ax, 0
   int 19h                         ; Reboot the system

print_string:                           ; Output string in SI to screen

   mov ah, 0Eh                     ; int 10h teletype function

   lodsb                           ; Get char from string
   cmp al, 0
   je .done                        ; If char is zero, end of string
   int 10h                         ; Otherwise, print it
   jmp short .repeat


reset_floppy:           ; IN: [bootdev] = boot device; OUT: carry set on error
   push ax
   push dx
   mov ax, 0
   mov dl, byte [bootdev]
   int 13h
   pop dx
   pop ax

l2hts:                  ; Calculate head, track and sector settings for int 13h
			    ; IN: logical sector in AX, OUT: correct registers for int 13h
   push bx
   push ax

   mov bx, ax                      ; Save logical sector

   mov dx, 0                       ; First the sector
   div word [SectorsPerTrack]
   add dl, 01h                     ; Physical sectors start at 1
   mov cl, dl                      ; Sectors belong in CL for int 13h
   mov ax, bx

   mov dx, 0                       ; Now calculate the head
   div word [SectorsPerTrack]
   mov dx, 0
   div word [Sides]
   mov dh, dl                      ; Head/side
   mov ch, al                      ; Track

   pop ax
   pop bx

   mov dl, byte [bootdev]          ; Set correct device


; ------------------------------------------------------------------

   kern_filename   db "KERNEL  BIN"        ;kernel filename

   disk_error      db "Floppy error! Press any key...", 0
   file_not_found  db "KERNEL.BIN not found!", 0

   bootdev         db 0    ; Boot device number
   cluster         dw 0    ; Cluster of the file we want to load
   pointer         dw 0    ; Pointer into Buffer, for loading kernel

; ------------------------------------------------------------------

   times 510-($-$$) db 0   ; Pad remainder of boot sector with zeros
   dw 0AA55h               ; Boot signature (DO NOT CHANGE!)

buffer:                         ; Disk buffer begins (8k after this, stack starts)

; ==================================================================


;name:			kernel.asm
;description:	This is the "kernel" file which will be loaded by the bootloader.
;				For the sake of simplicity it just displays a message on the screen.
;				This "kernel" can on the other hand start memory management routines, loads
;				a command prompt like DOS does or switch to protected mode or long mode for
;				64 bit operations.  To make a long story short: here the main work starts.
;build:			see makefile

	bits 16

	cli							;disable interrupts
	xor		ax,ax
	mov		ss,ax				;set stack segment and pointer
	mov		sp,0xFFFF
	sti							;enable interrupts
	mov		ax,0x2000			;set all segments to match where kernel is loaded
	mov		ds,ax               ;after this, we don't need to bother with
	mov		es,ax               ;segments ever again,as its programs
	mov		fs,ax               ;live entirely in 64K
	mov		gs,ax
	mov		si,welcome

	mov		ah,0x0E				;int 10h teletype function
	lodsb						;get char from string
	and		al,al
	jz		.done				;if char is zero, end of string
	int		0x10				;otherwise, print it
	jmp		.repeat				;and move on to next char
	jmp		.loop
welcome:  db   'Kernel example by Agguro - Version', 10, 13, 0


# Use of makefile
# make :	build bootloader64 and bootloader16.lst
#		    for a quick view you can use
#		    qemu-system-x86_64 -hda bootloader64 -k nl-be -vga std (you can use cirrus instead of std too)
#		    as mentioned on the developers website.
# make clean	: is called with make run to be sure to delete the floppy and iso image otherwise make results in an error
# make again	: to rebuild the program, even if the source isn't changed, can be run after makefile modifications
# make dump	: to create a hexdump of the different builded files
# make images	: build the images
# make run	: (re-)build all files except dumps and simulate with qemu-x86_64 the iso image
# make tar	: make a tar.gz file
# make all	: make programs and images

.PHONY : clean
.PHONY : again
.PHONY : dump
.PHONY : run
.PHONY : images
.PHONY : tar
.PHONY : all


O           = .o
ASM         = .asm
INC         = .inc
LST         = .lst
DUMP        = .dump

OBJS = $(NAME)$(O)
$(NAME).o : $(NAME).asm
	$(AS) -f $(TARGET) -o $(NAME).$(TARGET) $(NAME)$(ASM) -l $(NAME)$(LST)
	nasm -fbin kernel.asm -o kernel.bin

	@rm -rf *$(O) *~ *$(LST) *$(DUMP) $(NAME)
	@rm -rf floppy/
	@rm -rf iso/
	@rm -rf dumps/
	@rm -rf tmp-loop/
	@rm -rf *$(TARGET)

	touch $(NAME)$(ASM)
	@rm -rf dumps/
	mkdir dumps
	make again
	hexdump -C $(NAME).$(TARGET) > dumps/$(NAME)$(DUMP)
	hexdump -C floppy/$(NAME).flp > dumps/$(NAME).flp$(DUMP)
	hexdump -C iso/$(NAME).iso > dumps/$(NAME).iso$(DUMP)

	make again
	rm -rf floppy/
	rm -rf iso/
	rm -rf tmp-loop/
	mkdir floppy
	mkdir iso
	mkdosfs -C floppy/$(NAME).flp 1440
	dd status=noxfer conv=notrunc count=1 if=$(NAME).$(TARGET) of=floppy/$(NAME).flp
	mkdir tmp-loop
	sudo mount -o loop -t vfat floppy/bootloader16.flp tmp-loop
	sudo cp kernel.bin tmp-loop/
	sleep 0.2
	sudo umount tmp-loop
	rm -rf tmp-loop/
	mkisofs -quiet -V 'AGGURO' -input-charset iso8859-1 -o iso/$(NAME).iso -b $(NAME).flp floppy/
	make images
	qemu-system-i386 -cdrom iso/$(NAME).iso -k nl-be -vga std
	make clean
	tar czf ../$(NAME).tar.gz ../$(NAME)/
	make again
	make images
	make dump