reactos/boot/freeldr/bootsect/faty.S

590 lines
17 KiB
ArmAsm
Raw Normal View History

/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Bootsector
* FILE: boot/freeldr/bootsect/faty.S
* PURPOSE: Combined FAT12, FAT16 and FAT32 boot sector
* PROGRAMMERS: Brian Palmer
* Timo Kreuzer
*/
#define DISKREADBUFFER HEX(8E000)
/*
* Layout of a FAT volume:
*
* |---------------------------------------------------------
* | * BootSector |
* | * FS Information Sector (FAT32 only) | ReservedSectors
* | * ... more reserved sectors ... |
* |--------------------------------------------------------
* | * FAT 1 | NumberOfFats
* | * FAT 2 | *
* | * [more FATs] | SectorsPerFat
* |---------------------------------------------------------
* | * Root Directory (FAT12/FAT16 only) | MaxRootEntries / 16
* |---------------------------------------------------------
* | * File data |
* | .... |
* |----------------------------------------
*/
/* INCLUDES ******************************************************************/
#include <asm.inc>
#include <freeldr/include/arch/pc/x86common.h>
#define ADDRESS_FOR_DIRENTRIES HEX(10000)
SizeOfDataArea = 32
/* Put the stack below the data area */
BootSectorStackTop = (HEX(7c00) - SizeOfDataArea)
/* Data area offsets for uninitialized data */
DataAreaStart = BootSectorStackTop + 0 /* dword */
#ifndef FAT32
RootDirStartSector = BootSectorStackTop + 4 /* dword */
#endif
BiosCHSDriveSize = BootSectorStackTop + 8 /* dword */
LBASectorsRead = BootSectorStackTop + 12 /* dword */
ReadSectorsOffset = BootSectorStackTop + 16 /* word */
ReadClusterOffset = BootSectorStackTop + 18 /* word */
PutCharsOffset = BootSectorStackTop + 20 /* word */
/* Macro for bp relative memory access to reduce code size */
#define BP_REL(x) ss:[bp + x - BootSectorStackTop]
/* The code starts at 0x7c00 */
// org 7c00h
.code16
/******************************************************************************
* BIOS Parameter Block (BPB) *
******************************************************************************/
/* We have 3 bytes at the entry point to jump over the data area */
start:
jmp short main // FIXME: When compiling FAT32, assembler will complain
// that the label is too far... Need investigation!
nop
/* Here starts the BIOS Parameter Block (BPB) data.
The real data will be copied during install */
OEMName:
.ascii "FrLdr1.0"
BytesPerSector:
.word 512
SectorsPerCluster:
.byte 0
ReservedSectors:
.word 32
NumberOfFats:
.byte 2
MaxRootEntries:
.word 0 // Always zero for FAT32 volumes
TotalSectors:
.word 0 // Always zero for FAT32 volumes
MediaDescriptor:
.byte HEX(0f8)
SectorsPerFat:
.word 0 // Always zero for FAT32 volumes
SectorsPerTrack:
.word 0
NumberOfHeads:
.word 0
HiddenSectors:
.long 0
TotalSectorsBig:
.long 0
/* Extra data for FAT32 volumes */
#ifdef FAT32
SectorsPerFatBig:
.long 0
ExtendedFlags:
.word 0
FSVersion:
.word 0
RootDirStartCluster:
.long 0
FSInfoSector:
.word 0
BackupBootSector:
.word 6
Reserved1:
.space 12, 0
#endif // FAT32
BootDrive:
.byte 0
Reserved:
.byte 0
ExtendSig:
.byte HEX(29)
SerialNumber:
.long 0
VolumeLabel:
.ascii "NO NAME "
FileSystem:
.ascii "FATxx "
/******************************************************************************
* String data *
******************************************************************************/
filename:
.ascii "FREELDR SYS"
msgBootFailure:
.ascii "Load failed!", CR, LF, NUL
msgAnyKey:
.ascii "Press any key to reboot...", NUL
/******************************************************************************
* Main code entry *
* Input: DL = Boot drive *
******************************************************************************/
main:
/* First setup the segment registers */
xor ax, ax
mov ds, ax
mov ss, ax
/* Load the stack pointer */
mov sp, BootSectorStackTop
/* Load bp for relative memory access, which saves us some bytes of code
size, when used with 32 bit instructions */
mov bp, sp
/* Load the boot drive from the BPB into al */
mov al, byte ptr ds:[BootDrive]
/* Check if it's valid */
cmp al, HEX(0ff)
je .SaveBootDrive
/* Copy it into dl */
mov dl, al
.SaveBootDrive:
/* Save the bootdrive in the BPB */
mov byte ptr ds:[BootDrive], dl
/******************************************************************************
* Get drive parameters *
******************************************************************************/
/* Call INT 13 to get the drive parameters:
AH = 08h
DL = drive (bit 7 set for hard disk)
ES:DI = 0000h:0000h to guard against BIOS bugs */
xor di, di
mov ah, 8
int HEX(13)
/* Return from INT 13h/08h:
CF set on error -> AH = status (07h)
CF clear if successful -> AH = 00h
AL = 00h on at least some BIOSes
BL = drive type (AT/PS2 floppies only)
CH = low eight bits of maximum cylinder number
CL = bits 0:5 maximum sector number, bits 7:8 high two bits of maximum cylinder number
DH = maximum head number
DL = number of drives
ES:DI -> drive parameter table (floppies only) */
/* Check for failure */
jc BootFailure
/******************************************************************************
* Calculate drive size *
******************************************************************************/
movzx ebx, ch // Put the low 8-bits of the cylinder count into EBX
mov bh, cl // Put the high 2-bits in BH
shr bh, 6 // Shift them into position, now BX contains the cylinder count
and cl, HEX(3f) // Mask off cylinder bits from sector count
movzx ecx, cl // Move the sectors per track into ECX
movzx eax, dh // Move the heads into EAX
inc eax // Make it one based because the bios returns it zero based
inc ebx // Make the cylinder count one based also
mul ecx // Multiply heads with the sectors per track, result in edx:eax
mul ebx // Multiply the cylinders with (heads * sectors) [stored in edx:eax already]
// We now have the total number of sectors as reported
// by the bios in eax, so store it in our variable
mov dword ptr BP_REL(BiosCHSDriveSize), eax
/******************************************************************************
* Load the FAT *
******************************************************************************/
/* Load the number of first sector of the FAT into eax */
movzx eax, word ptr BP_REL(ReservedSectors)
add eax, dword ptr BP_REL(HiddenSectors)
/* Load sector count into ecx */
#ifdef FAT32
mov ecx, dword ptr BP_REL(SectorsPerFatBig)
#else
movzx ecx, word ptr BP_REL(SectorsPerFat)
#endif
/* Save FAT sector and size for later use */
pushad
/* Point ES:DI to the memory that is later the disk read buffer for freeldr.
This way we cannot overwrite our FAT with freeldr data */
mov bx, DISKREADBUFFER / 16
mov es,bx
xor di, di
/* Read the sectors */
call ReadSectors
/* Restore FAT sector and size */
popad
/******************************************************************************
* Get root directory / data area start *
******************************************************************************/
/* Copy reserved + hidden sectors to EBX */
mov ebx, eax
/* Calculate (NumberOfFats * SectorsPerFat) */
movzx eax, byte ptr BP_REL(NumberOfFats)
mul ecx
/* Add reserved sectors and hidden sectors */
add eax, ebx
#ifndef FAT32
/* Save the starting sector of the root directory */
mov dword ptr BP_REL(RootDirStartSector), eax
/* Calculate number of sectors for the root dir:
sectors = MaxRootEntries * 32 / 512 (rounded up!) */
movzx ebx, word ptr BP_REL(MaxRootEntries)
add ebx, 15
shr ebx, 4
/* Add the root dir start sector and save it as DataAreaStart */
add ebx, eax
mov dword ptr BP_REL(DataAreaStart), ebx
#else
mov dword ptr BP_REL(DataAreaStart), eax
/* On FAT32 volumes the root dir start cluster is stored in the BPB */
mov eax, dword ptr BP_REL(RootDirStartCluster)
#endif
/******************************************************************************
* Search the root directory for freeldr *
******************************************************************************/
.SearchForFreeldr:
/* Load ES with the segment where we put the dir entries */
mov bx, ADDRESS_FOR_DIRENTRIES / 16
mov es, bx
/* Set the address offset to 0 */
xor di, di
#ifdef FAT32
/* Read the dir cluster. This loads the next cluster into EAX */
call ReadCluster
/* Calculate the numer of dir entries in this cluster:
dx = SectorsPerCluster * 512 / 32 */
movzx dx, byte ptr ds:[SectorsPerCluster]
shl dx, 4
#else
/* Set the number of sectors to read to 1 */
xor cx, cx
inc cx
/* Read the sector, but preserve ES */
push es
call ReadSectors
pop es
/* Set entry count to entries per sector */
mov dx, (512 / 32)
#endif
/* Load the start offset of the dir entries into ebx */
xor bx, bx
.CheckDirEntry:
/* Load the address of the name into di */
mov di, bx
/* If the first byte of the entry is 0 then we have reached the end */
cmp byte ptr es:[di], ch
jz BootFailure
/* Compare with freeldr file name */
mov si, offset filename
mov cx, 11
repe cmpsb
/* Check if we found the file */
jz .FoundFreeLoader
/* File didn't match, go to next entry */
add bx, 32
/* Decrement entry count and check if we reached the end */
dec dx
jnz .CheckDirEntry
#ifdef FAT32
/* Check to see if this was the last cluster in the chain */
cmp eax, HEX(0ffffff8)
jnb BootFailure
#endif
/* Repeat the search process with the next sector / cluster.
eax is already incremented in ReadSectors / ReadCluster */
jmp .SearchForFreeldr
/******************************************************************************
* Load freeldr *
******************************************************************************/
.FoundFreeLoader:
/* Load the cluster number of freeldr into eax */
#ifdef FAT32
#error unsupported
#else
movzx eax, word ptr es:[bx + HEX(1A)]
#endif
/* Load es:di with the freeldr start address */
mov dx, FREELDR_BASE / 16
mov es, dx
xor di, di
.LoadNextCluster:
/* Load the cluster to the current address. EAX is adjusted to the next
cluster and ES is adjusted for the next read */
call ReadCluster
/* Check if this is the last cluster in the chain */
#if defined(FAT32)
cmp eax, HEX(0ffffff8)
#elif defined(FAT12)
cmp ax, HEX(0ff8)
#else
cmp ax, HEX(0fff8)
#endif
jb .LoadNextCluster
/* Load boot drive into DL, boot partition into DH */
mov dl, byte ptr ds:[BootDrive]
mov dh, byte ptr ds:[BootPartition]
/* Now the complete freeldr imag is loaded.
Jump to the realmode entry point. */
ljmp16 0, FREELDR_BASE
BootFailure:
mov si, offset msgBootFailure
call PutChars
Reboot:
/* Output "Press any key to reboot" message */
mov si, offset msgAnyKey
call PutChars
/* Wait for a keypress */
xor ax, ax
int HEX(16)
/* Reboot */
int HEX(19)
/******************************************************************************
* PROCEDURE ReadCluster *
* Input: EAX = Cluster number, ES:DI = Target *
* Modifies: EAX (next cluster number), BX, DX (undefined) *
******************************************************************************/
ReadCluster:
pushad
// StartSector = ((Cluster - 2) * SectorsPerCluster) + SectorsForFat + ReservedSectors + HiddenSectors
// StartSector = ((Cluster - 2) * SectorsPerCluster) + DataAreaStart
/* Substract 2 */
dec eax
dec eax
/* Multiply with SectorsPerCluster */
movzx ecx, byte ptr BP_REL(SectorsPerCluster)
mul ecx
/* Add DataAreaStart */
add eax, dword ptr BP_REL(DataAreaStart)
/* Call ReadSectors. EAX = SectorNumber, ECX = SectorsPerCluster */
call ReadSectors
/* Restore the cluster number */
popad
/* Save ES */
push es
#if defined(FAT32)
#error FAT32 not implemented
#elif defined(FAT12)
#error FAT12 not implemented
#else
/* DX:AX = AX * 2 (since FAT16 entries are 2 bytes) */
mov bx, 2
mul bx
/* Shift DX, so that it is the segment offset: DX = DX * (64K / 16) */
shl dx, 12
/* Put segment address of FAT into ES */
add dx, DISKREADBUFFER / 16
mov es, dx
/* Put the FAT entry offset into EBX for indirect mov */
mov bx, ax
/* Put the content of the FAT entry into AX */
mov ax, es:[bx]
#endif
/* Restore ES and return */
pop es
ret
/******************************************************************************
* PROCEDURE ReadSectors *
* Input: EAX = Sector start number, ECX = number of sectors, ES:DI = Target *
* Modifies: EAX (incremented by sector count), CX = 0, ES (incremented), *
* EBX undefined *
******************************************************************************/
ReadSectors:
/* We could possibly also implement CHS, but it's currently unimplemented */
//jmp $
ReadSectorsLBA:
/* Copy number of sectors to ebx */
movzx ebx, cx
/* Since the LBA calls only support 0x7F sectors at a time,
we will limit ourselves to 64 */
cmp bx, 64
jbe .ReadSectorsLBA2
mov bx, 64
.ReadSectorsLBA2:
/* Save logical sector number & sector count */
pushad
/* Setup the disk address packet on the stack */
.byte HEX(66) // size overwrite prefix for next push
push 0 // Put 64-bit logical block address (high part) on stack
push eax // Put 64-bit logical block address (low part) on stack
push es // Put transfer segment on stack
push di // Put transfer offset on stack
push bx // Set transfer count (for this round)
push 16 // Set size of packet to 16
/* Point si to the disk address packet on stack */
mov si, sp
/* Set the drive number */
mov dl, byte ptr ds:[BootDrive]
//jmp $
/* Call INT 13h, AH = 42h - Extended Read
Input: ...
Modifies: ... */
mov ah, HEX(42)
int HEX(13)
//jmp $
/* Check for failure */
jc BootFailure
/* Remove disk address packet from stack */
add sp, 16
/* Adjust ES to point to the next sector */
shl bx, 5
mov ax, es
add ax, bx
mov es, ax
/* Restore sector count & logical sector number */
popad
/* Adjust the sector number to the next sector we need to read
by adding the number of sectors that we read */
add eax, ebx
/* Adjust remaining sectors */
sub cx, bx
jnz ReadSectorsLBA
/* return */
ret
/******************************************************************************
* PROCEDURE PutChars *
* Input: ESI = Points to string to be printed *
* Modifies: AL, AH, SI *
******************************************************************************/
PutChars2:
mov ah, HEX(0e)
mov bx, 7
int HEX(10)
PutChars:
lodsb
or al, al
jnz short PutChars2
ret
/******************************************************************************
* Padding and boot sector signature *
******************************************************************************/
/* Pad to 509 bytes */
.org 509
BootPartition:
.byte 0
BootSignature:
.word HEX(0aa55) // BootSector signature
.endcode16
END