;This bootsector was created by ME239 and is protected under the GNU license agreement.
;This article was intended for educational purposes and was optimized for readability and size.
;The numbers used for the sectors and number of sectors is written in an emperical way to save on
;space, but full equations are given in the comments
; THIS MUST BE COMPILED WITH FASM!
org 0 ; we start everything at zero
jmp start        ; the jump must be 3 bytes before the BPB. A jump is 2 bytes so we add a NOP, or 1 byte
nop              ; This is just the BPB
OEM  db 'SAMPLEBT' ; the name of our disk
BytesPerSecot dw 512
SectorsPerCluster db 1
ReservedSectors dw 1
NumberofFATs db 2
RootEntries dw 224
TotalSectors dw 2880
Media db 0xf8 ; what are we? A floppy, HD, etc.
SectorsPerFAT dw 9
SectorsPerTrack dw 18
HeadsPerCylinder dw 2
dd 0 ; These are hidden sectors, but we won't use them
dd 0
DriveNumber db 0      ;here is the start of the extended BPB (for DOs and windwos)
Unused db 0
Bootsig db 29h
Serial dd 0x1a2a3a
VolumeLabel db 'SAMPLEBOOT '
FileSystem db 'FAT12   '
start:
        cli     ; let's disable interrupts while we configure the stack and segments
        mov     ax, 0x07c0 ; look at an explanation of segmented memory (at the bottom)_
        mov     es, ax  ; let's set all the registers to the new segment
        mov     ds, ax
        mov     gs, ax
        mov     fs, ax
        xor     ax, ax
        mov     ss, ax ; stack segment is now 0
        mov     sp, 0ffffh ; but the stack pointer is at 0xffff giving us a 65,535 byte stack
        sti     ; we're done here, let's re-enable interrupts
        mov     ax, 19 ; Root directory starts at 19 (look at FAT12 map for help)\
        mov     cx, 14 ; Root directory size (224 entries * 32 bytes per entry all divided by 512(sectors per byte)
        mov     bx, 200h ; we want to read the root directory to the end of the bootloader (200h = 512 decimal)
        call    readsectors ; put the sectors into RAM
        mov     di, 0x200 ; set the data index to 200h
        mov     cx, 224 ; max number of root entries so we don't read over the limit
findfile: ; let's find our kernel!
        push    cx ; save cx
        mov     cx, 11 ; each entry in FAT12 has an 11 byte name
        mov     si, filen ; the name of our kernel
        push    di ; save the data index
        repe    cmpsb ; let's compare
        pop     di ; restore DI
        je      filefound ; was it equal? If so, then we found our file
        pop     cx ; restore CX
        add     di, 32 ; let's search the next entry
        loop    findfile ; loop this only 224. If the file isn't found, then fail
        int     18h ; file wasn't found, let's bail!
filefound: ; we've found our kernel! Now let's load it!
        pop     cx ; let's restore CX to keep the stack intact
        mov     dx, word[di+1ah] ; each FAT12 entry contains the first cluster 26 bytes after the beginning of the entry (0x1a = 26 decimal)
        mov     word[cluster], dx ; let's save this for later
        mov     ax, 1 ; there is one reserved sector on our disk, the bootloader. So that means the FAT table is right after it!
        mov     cx, 9 ; there are to FAT tables. Each are 9 sectors and identical stored only as backups to eachother. So let's just load the first one
        mov     bx, 0x200 ; let's overwrite the root directory since we already have the first cluster
        call    readsectors ; let's read the FAT table into RAM
        mov     ax, 0x60 ; this is our new segment where we want to load the kernel
        mov     es, ax ; let's put that into the ES register
        xor     bx, bx ; zero out BX so the kernel will be loaded to 0060:0000 (ES:BX)
        push    bx ; save BX for the loop
clusterloop:
        mov     ax, word[cluster] ; put the cluster number in AX
        sub     ax, 2 ; the conversion for cluster to LBA (or Logical Sector) is simply (cluster number - 2)* the number of sectors per cluster (we're a floppy so we only have one sector per cluster)
        add     ax, 33 ; the data portion starts at 33. (1 reserved sector + 2 FAT tables * 9 sectors each)+((224 root entries * 32 bytes per entry)/512 bytes per sector) = 33
        mov     cx, 1 ; we only have one sector per cluster, so we only read one sector
        pop     bx
        call    readsectors
        push    bx ; save BX so it doesn't get destroyed
        mov     ax, word[cluster] ; load AX with the cluster number
        mov     dx, ax
        mov     cx, ax ; let's do the same with DX and CX
        shr     dx, 1 ; divide DX by two
        add     cx, dx ; add DX back to CX so we now have 3/2 of the original cluster
        mov     bx, 0x200 ; move the FAT table into BX
        add     bx, cx ; BX = the new cluster number
        mov     dx, word[bx] ; put the new cluster number in DX
        test    ax, 1 ; tests the last cluster number to see if it is odd or even (all odd numbers have bit 1 enable, hence the test 1)
        jnz     odd_cluster ; the cluster was odd, so let's take care of it
        and     dx, 0fffh ; let's take the low 12 bits of the new cluster (12 bits, get it? FAT12, 12 bits per cluster number!)
        jmp     done ; let's jump over the odd_cluster routine
odd_cluster:
        shr     dx, 4 ; let's take the high twelve bytes excluding the low 4
done:
        mov     word[cluster], dx ; let's save our new cluster
        cmp     dx, 0ff0h ; the number 0ff0h (or 4080 decimal) marks the end of a cluster chain, meaning we have finished reading the file!
        jb      clusterloop ; was it below 0xff0? If so let's keep reading
        mov     ax, es ; COM files are loaded at offset 0x100, so let's fix the memory (look at the bottom of the article for a better explanation)
        sub     ax, 10h
        mov     es, ax
        mov     ds, ax
        mov     ss, ax
        xor     sp, sp
        push    es
        push    100h
        retf    ; we've loaded our kernel, so let's execute it!
readsectors: ; our loop for reading the disk into RAM
        mov     di, 5 ; let's give it only 5 tries before quitting
sectloop:
        push    ax ; let's save our registers!
        push    bx
        push    cx
        push    dx
        call    lbachs ; we can't use logical sectors, so we must convert is to Cylinder, Head, and Sector
        mov     ah, 02h ; BIOS disk read funtion
        mov     al, 1 ; read only one sector
        mov     dl, 0 ; we're a floppy, so we are the first disk
        mov     dh, [head]
        mov     cl, [sector]
        mov     ch, [track]
        int     13h ; read it!
        jnc     success ; was there an error? If not, jump to the next routine
        xor     ax, ax ; BIOS disk reset function
        int     13h
        pop     dx ; restore the registers
        pop     cx
        pop     bx
        pop     ax
        dec     di ; decrement DI
        jnz     sectloop ; keep going until we reach five
        int     18h ; let's bail
success:
        pop     dx ; restore our registers
        pop     cx
        pop     bx
        pop     ax
        inc     ax ; let's read the next sector
        add     bx, 512 ; there 512 bytes per sector, so let's update BX (our buffer)
        loop    readsectors ; remember, CX = number of sectors to read
        ret ; we read everything without a problem, so let's return
lbachs: ; Sector = LBA MOD SectorsPerTrack (1
        ; Head = (LBA/SectorsPerTrack) MOD HeadsPerCylinder (2)
        ; Track(/Cylinder) = (LBA/SectorsPerTracl) / HeadsPerCylinder (2)
        pusha ; shortcut to save all registers
        xor   dx, dx ; since this is fixed point math, all remainders of divisions are stored in DX, so let's zero DX
        mov   cx, 18 ; SectorsPerTrack
        div   cx ; divide AX (LBA) by the
        inc   dl ; in reality the number of the first sector is 0, but BIOS funtion only accepts 1 as the first sector
        mov   byte[sector], dl ; save our sector
        mov   cx, 2 ; HeadsPerCylinder
        xor   dx, dx ; let's zero out DX again
        div   cx
        mov   byte[head], dl ; let's save the rest
        mov   byte[track], al
        popa ; restore our registers
        ret ; return
cluster dw  0 ; variable for our current cluster
sector  db  0 ; variables for CHS
head    db  0
track   db  0
filen   db  'KERNEL  COM' ; 11 byte file name, CAPITALIZED! 8 bytes for the file name, 3 bytes for the extension
times 510-($-$$) db 0 ; fill in the remaining space with zero
dw 0xaa55 ; legacy boot signature
;*****************NOTES************************
;Here is a quick lesson in how segmented memory works.
;The layout goes like this SEGMENT:OFFSET. Basically, each segment is a place in memory and the offset is a more detailed spot.
;Now you may have realized that I used segment 7c0h rather than 7c00h. Now here is why, each segment is 0x10 (or 16 decimal) times as large as a single offset;
;therefore, the same location can be accessed at both 07c0:0000 or 0000:7c00. Now this also brings us to the explanation for the COM file execution. I subtracted
;0x10 from the segment, so this equal to setting the offset to 0x100. Then all the segments were set to the new segment along with the stack.
;
;Now here is map of how the FAT12 system is laid out
;|----------------------------------------------------------------------|
;|BootSector| FAT table 1| FAT table 2 | Root Directory| Data Region    |
;|512 bytes | 4,608 bytes| 4,608 bytes |  7,168 bytes  | 1,457,664 bytes|
;|1 sector  | 9 sectors  | 9 sectors   |  14 sectors   |  2,847 sectors |
;|______________________________________________________________________|
;
;Here is an explanation of what clusters are.
;A cluster is simply the number (-2) of sectors after the Root Directory the data is located at.
;So it is really just a sector number. So then you ask, "If it's only one sector, then why don't they just call it a sector?".
;The answer to that question is that other larger FAT systems (FAT16, FAT32) use clusters that can larger than 1 sector at a time;
;therefore, we call it a cluster just because it is universal.
;
;Now here is a breif explantion of how the FAT12 table works.
;In the FAT12 system, the FAT table is comprised of numbers containing the next cluster
;in a file's chain. That's simple enough, now it's interpretting those numbers where it
;becomes confusing. The first cluster available on a disk is 2. So let's say our directory
;entry says it's first cluster is 2. OK, let's go read our table. To retrieve the number of our next cluster,
;we get 3/2 of our current cluster. So let's get 3/2 of 2 and now we have 3. Now we get the word at that offset
;in the FAT table. Good, now we are close to having the next sector! All that's left is to test and see if is was odd (since 3/2 of an odd number is a fraction).
;To do that we use the TEST instruction. Testing AX (assuming that AX contains the last cluster) with 1 tests bit 1 to see if it is enabled. If bit 1 is enabled,
;the number is odd otherwise it is even. To adjust the cluster if it is odd, we take the high 12 bits of the word. To do this we shift the new cluster over 4 places
;(1111111111110000b becomes 0000111111111111b). The instruction SHR means shift right, so shifting right four times is equivalent to dividing by 16 (2^4, this unrelated, but
;interesting). OK, so what if it's even? Then we take the low 12 bits. To do this we use the AND instruction as a filter. In the code I use 0xfff to filter it (0xfff =
; 000011111111111b). So now that we have the correct cluster, we repeat the previous steps with the new cluster until you reach 0ff0h, which means the end of a file's
;cluster chain.