Fix a couple of problems with FreeLDR portability.
[reactos.git] / reactos / boot / freeldr / bootsect / fat.asm
1 ; FAT.ASM
2 ; FAT12/16 Boot Sector
3 ; Copyright (c) 1998, 2001, 2002 Brian Palmer
4
5
6
7 ; This is a FAT12/16 file system boot sector
8 ; that searches the entire root directory
9 ; for the file freeldr.sys and loads it into
10 ; memory.
11 ;
12 ; The stack is set to 0000:7BF2 so that the first
13 ; WORD pushed will be placed at 0000:7BF0
14 ;
15 ; The DWORD at 0000:7BFC or BP-04h is the logical
16 ; sector number of the start of the data area.
17 ;
18 ; The DWORD at 0000:7BF8 or BP-08h is the total
19 ; sector count of the boot drive as reported by
20 ; the computers bios.
21 ;
22 ; The WORD at 0000:7BF6 or BP-0ah is the offset
23 ; of the ReadSectors function in the boot sector.
24 ;
25 ; The WORD at 0000:7BF4 or BP-0ch is the offset
26 ; of the ReadCluster function in the boot sector.
27 ;
28 ; The WORD at 0000:7BF2 or BP-0eh is the offset
29 ; of the PutChars function in the boot sector.
30 ;
31 ; When it locates freeldr.sys on the disk it will
32 ; load the first sector of the file to 0000:8000
33 ; With the help of this sector we should be able
34 ; to load the entire file off the disk, no matter
35 ; how fragmented it is.
36 ;
37 ; We load the entire FAT table into memory at
38 ; 7000:0000. This improves the speed of floppy disk
39 ; boots dramatically.
40
41
42 BootSectorStackTop equ 0x7bf2
43 DataAreaStartHigh equ 0x2
44 DataAreaStartLow equ 0x4
45 BiosCHSDriveSizeHigh equ 0x6
46 BiosCHSDriveSizeLow equ 0x8
47 BiosCHSDriveSize equ 0x8
48 ReadSectorsOffset equ 0xa
49 ReadClusterOffset equ 0xc
50 PutCharsOffset equ 0xe
51
52
53 org 7c00h
54
55 segment .text
56
57 bits 16
58
59 start:
60 jmp short main
61 nop
62
63 OEMName db 'FrLdr1.0'
64 BytesPerSector dw 512
65 SectsPerCluster db 1
66 ReservedSectors dw 1
67 NumberOfFats db 2
68 MaxRootEntries dw 224
69 TotalSectors dw 2880
70 MediaDescriptor db 0f0h
71 SectorsPerFat dw 9
72 SectorsPerTrack dw 18
73 NumberOfHeads dw 2
74 HiddenSectors dd 0
75 TotalSectorsBig dd 0
76 BootDrive db 0xff
77 Reserved db 0
78 ExtendSig db 29h
79 SerialNumber dd 00000000h
80 VolumeLabel db 'NO NAME '
81 FileSystem db 'FAT12 '
82
83 main:
84 xor ax,ax
85 mov ss,ax
86 mov bp,7c00h
87 mov sp,BootSectorStackTop ; Setup a stack
88 mov ds,ax ; Make DS correct
89 mov es,ax ; Make ES correct
90
91
92 cmp BYTE [BYTE bp+BootDrive],BYTE 0xff ; If they have specified a boot drive then use it
93 jne GetDriveParameters
94
95 mov [BYTE bp+BootDrive],dl ; Save the boot drive
96
97
98 GetDriveParameters:
99 mov ah,08h
100 mov dl,[BYTE bp+BootDrive] ; Get boot drive in dl
101 int 13h ; Request drive parameters from the bios
102 jnc CalcDriveSize ; If the call succeeded then calculate the drive size
103
104 ; If we get here then the call to the BIOS failed
105 ; so just set CHS equal to the maximum addressable
106 ; size
107 mov cx,0ffffh
108 mov dh,cl
109
110 CalcDriveSize:
111 ; Now that we have the drive geometry
112 ; lets calculate the drive size
113 mov bl,ch ; Put the low 8-bits of the cylinder count into BL
114 mov bh,cl ; Put the high 2-bits in BH
115 shr bh,6 ; Shift them into position, now BX contains the cylinder count
116 and cl,3fh ; Mask off cylinder bits from sector count
117 ; CL now contains sectors per track and DH contains head count
118 movzx eax,dh ; Move the heads into EAX
119 movzx ebx,bx ; Move the cylinders into EBX
120 movzx ecx,cl ; Move the sectors per track into ECX
121 inc eax ; Make it one based because the bios returns it zero based
122 inc ebx ; Make the cylinder count one based also
123 mul ecx ; Multiply heads with the sectors per track, result in edx:eax
124 mul ebx ; Multiply the cylinders with (heads * sectors) [stored in edx:eax already]
125
126 ; We now have the total number of sectors as reported
127 ; by the bios in eax, so store it in our variable
128 mov [BYTE bp-BiosCHSDriveSize],eax
129
130
131 ; Now we must find our way to the first sector of the root directory
132 xor ax,ax
133 xor cx,cx
134 mov al,[BYTE bp+NumberOfFats] ; Number of fats
135 mul WORD [BYTE bp+SectorsPerFat] ; Times sectors per fat
136 add ax,WORD [BYTE bp+HiddenSectors]
137 adc dx,WORD [BYTE bp+HiddenSectors+2] ; Add the number of hidden sectors
138 add ax,WORD [BYTE bp+ReservedSectors] ; Add the number of reserved sectors
139 adc dx,cx ; Add carry bit
140 mov WORD [BYTE bp-DataAreaStartLow],ax ; Save the starting sector of the root directory
141 mov WORD [BYTE bp-DataAreaStartHigh],dx ; Save it in the first 4 bytes before the boot sector
142 mov si,WORD [BYTE bp+MaxRootEntries] ; Get number of root dir entries in SI
143 pusha ; Save 32-bit logical start sector of root dir
144 ; DX:AX now has the number of the starting sector of the root directory
145
146 ; Now calculate the size of the root directory
147 xor dx,dx
148 mov ax,0020h ; Size of dir entry
149 mul si ; Times the number of entries
150 mov bx,[BYTE bp+BytesPerSector]
151 add ax,bx
152 dec ax
153 div bx ; Divided by the size of a sector
154 ; AX now has the number of root directory sectors
155
156 add [BYTE bp-DataAreaStartLow],ax ; Add the number of sectors of the root directory to our other value
157 adc [BYTE bp-DataAreaStartHigh],cx ; Now the first 4 bytes before the boot sector contain the starting sector of the data area
158 popa ; Restore root dir logical sector start to DX:AX
159
160 LoadRootDirSector:
161 mov bx,7e0h ; We will load the root directory sector
162 mov es,bx ; Right after the boot sector in memory
163 xor bx,bx ; We will load it to [0000:7e00h]
164 xor cx,cx ; Zero out CX
165 inc cx ; Now increment it to 1, we are reading one sector
166 xor di,di ; Zero out di
167 push es ; Save ES because it will get incremented by 20h
168 call ReadSectors ; Read the first sector of the root directory
169 pop es ; Restore ES (ES:DI = 07E0:0000)
170
171 SearchRootDirSector:
172 cmp [es:di],ch ; If the first byte of the directory entry is zero then we have
173 jz ErrBoot ; reached the end of the directory and FREELDR.SYS is not here so reboot
174 pusha ; Save all registers
175 mov cl,0xb ; Put 11 in cl (length of filename in directory entry)
176 mov si,filename ; Put offset of filename string in DS:SI
177 repe cmpsb ; Compare this directory entry against 'FREELDR SYS'
178 popa ; Restore all the registers
179 jz FoundFreeLoader ; If we found it then jump
180 dec si ; SI holds MaxRootEntries, subtract one
181 jz ErrBoot ; If we are out of root dir entries then reboot
182 add di,BYTE +0x20 ; Increment DI by the size of a directory entry
183 cmp di,0200h ; Compare DI to 512 (DI has offset to next dir entry, make sure we haven't gone over one sector)
184 jc SearchRootDirSector ; If DI is less than 512 loop again
185 jmp short LoadRootDirSector ; Didn't find FREELDR.SYS in this directory sector, try again
186
187 FoundFreeLoader:
188 ; We found freeldr.sys on the disk
189 ; so we need to load the first 512
190 ; bytes of it to 0000:8000
191 ; ES:DI has dir entry (ES:DI == 07E0:XXXX)
192 mov ax,WORD [es:di+1ah] ; Get start cluster
193 push ax ; Save start cluster
194 push WORD 800h ; Put 800h on the stack and load it
195 pop es ; Into ES so that we load the cluster at 0000:8000
196 call ReadCluster ; Read the cluster
197 pop ax ; Restore start cluster of FreeLoader
198
199 ; Save the addresses of needed functions so
200 ; the helper code will know where to call them.
201 mov WORD [BYTE bp-ReadSectorsOffset],ReadSectors ; Save the address of ReadSectors
202 mov WORD [BYTE bp-ReadClusterOffset],ReadCluster ; Save the address of ReadCluster
203 mov WORD [BYTE bp-PutCharsOffset],PutChars ; Save the address of PutChars
204
205 ; Now AX has start cluster of FreeLoader and we
206 ; have loaded the helper code in the first 512 bytes
207 ; of FreeLoader to 0000:8000. Now transfer control
208 ; to the helper code. Skip the first three bytes
209 ; because they contain a jump instruction to skip
210 ; over the helper code in the FreeLoader image.
211 ;jmp 0000:8003h
212 jmp 8003h
213
214
215
216
217 ; Displays an error message
218 ; And reboots
219 ErrBoot:
220 mov si,msgFreeLdr ; FreeLdr not found message
221 call PutChars ; Display it
222
223 Reboot:
224 mov si,msgAnyKey ; Press any key message
225 call PutChars ; Display it
226 xor ax,ax
227 int 16h ; Wait for a keypress
228 int 19h ; Reboot
229
230 PutChars:
231 lodsb
232 or al,al
233 jz short Done
234 mov ah,0eh
235 mov bx,07h
236 int 10h
237 jmp short PutChars
238 Done:
239 retn
240
241 ; Displays a bad boot message
242 ; And reboots
243 BadBoot:
244 mov si,msgDiskError ; Bad boot disk message
245 call PutChars ; Display it
246
247 jmp short Reboot
248
249
250 ; Reads cluster number in AX into [ES:0000]
251 ReadCluster:
252 ; StartSector = ((Cluster - 2) * SectorsPerCluster) + ReservedSectors + HiddenSectors;
253 dec ax ; Adjust start cluster by 2
254 dec ax ; Because the data area starts on cluster 2
255 xor ch,ch
256 mov cl,BYTE [BYTE bp+SectsPerCluster]
257 mul cx ; Times sectors per cluster
258 add ax,[BYTE bp-DataAreaStartLow] ; Add start of data area
259 adc dx,[BYTE bp-DataAreaStartHigh] ; Now we have DX:AX with the logical start sector of OSLOADER.SYS
260 xor bx,bx ; We will load it to [ES:0000], ES loaded before function call
261 ;mov cl,BYTE [BYTE bp+SectsPerCluster]; Sectors per cluster still in CX
262 ;call ReadSectors
263 ;ret
264
265
266
267 ; Reads logical sectors into [ES:BX]
268 ; DX:AX has logical sector number to read
269 ; CX has number of sectors to read
270 ReadSectors:
271
272 ; We can't just check if the start sector is
273 ; in the BIOS CHS range. We have to check if
274 ; the start sector + length is in that range.
275 pusha
276 dec cx
277 add ax,cx
278 adc dx,byte 0
279
280 cmp dx,WORD [BYTE bp-BiosCHSDriveSizeHigh] ; Check if they are reading a sector within CHS range
281 ja ReadSectorsLBA ; No - go to the LBA routine
282 jb ReadSectorsCHS ; Yes - go to the old CHS routine
283 cmp ax,WORD [BYTE bp-BiosCHSDriveSizeLow] ; Check if they are reading a sector within CHS range
284 jbe ReadSectorsCHS ; Yes - go to the old CHS routine
285
286 ReadSectorsLBA:
287 popa
288 ReadSectorsLBALoop:
289 pusha ; Save logical sector number & sector count
290
291 o32 push byte 0
292 push dx ; Put 64-bit logical
293 push ax ; block address on stack
294 push es ; Put transfer segment on stack
295 push bx ; Put transfer offset on stack
296 push byte 1 ; Set transfer count to 1 sector
297 push byte 0x10 ; Set size of packet to 10h
298 mov si,sp ; Setup disk address packet on stack
299
300 ; We are so totally out of space here that I am forced to
301 ; comment out this very beautifully written piece of code
302 ; It would have been nice to have had this check...
303 ;CheckInt13hExtensions: ; Now make sure this computer supports extended reads
304 ; mov ah,0x41 ; AH = 41h
305 ; mov bx,0x55aa ; BX = 55AAh
306 ; mov dl,[BYTE bp+BootDrive] ; DL = drive (80h-FFh)
307 ; int 13h ; IBM/MS INT 13 Extensions - INSTALLATION CHECK
308 ; jc PrintDiskError ; CF set on error (extensions not supported)
309 ; cmp bx,0xaa55 ; BX = AA55h if installed
310 ; jne PrintDiskError
311 ; test cl,1 ; CX = API subset support bitmap
312 ; jz PrintDiskError ; Bit 0, extended disk access functions (AH=42h-44h,47h,48h) supported
313
314
315 ; Good, we're here so the computer supports LBA disk access
316 ; So finish the extended read
317 mov dl,[BYTE bp+BootDrive] ; Drive number
318 mov ah,42h ; Int 13h, AH = 42h - Extended Read
319 int 13h ; Call BIOS
320 jc BadBoot ; If the read failed then abort
321
322 add sp,byte 0x10 ; Remove disk address packet from stack
323
324 popa ; Restore sector count & logical sector number
325
326 inc ax ; Increment Sector to Read
327 adc dx,byte 0
328
329 push bx
330 mov bx,es
331 add bx,byte 20h ; Increment read buffer for next sector
332 mov es,bx
333 pop bx
334
335 loop ReadSectorsLBALoop ; Read next sector
336
337 ret
338
339
340 ; Reads logical sectors into [ES:BX]
341 ; DX:AX has logical sector number to read
342 ; CX has number of sectors to read
343 ; CarryFlag set on error
344 ReadSectorsCHS:
345 popa
346 ReadSectorsCHSLoop:
347 pusha
348 xchg ax,cx
349 xchg ax,dx
350 xor dx,dx
351 div WORD [BYTE bp+SectorsPerTrack]
352 xchg ax,cx
353 div WORD [BYTE bp+SectorsPerTrack] ; Divide logical by SectorsPerTrack
354 inc dx ; Sectors numbering starts at 1 not 0
355 xchg cx,dx
356 div WORD [BYTE bp+NumberOfHeads] ; Number of heads
357 mov dh,dl ; Head to DH, drive to DL
358 mov dl,[BYTE bp+BootDrive] ; Drive number
359 mov ch,al ; Cylinder in CX
360 ror ah,2 ; Low 8 bits of cylinder in CH, high 2 bits
361 ; in CL shifted to bits 6 & 7
362 or cl,ah ; Or with sector number
363 mov ax,0201h
364 int 13h ; DISK - READ SECTORS INTO MEMORY
365 ; AL = number of sectors to read, CH = track, CL = sector
366 ; DH = head, DL = drive, ES:BX -> buffer to fill
367 ; Return: CF set on error, AH = status (see AH=01h), AL = number of sectors read
368
369 jc BadBoot
370
371 popa
372 inc ax ;Increment Sector to Read
373 jnz NoCarryCHS
374 inc dx
375
376
377 NoCarryCHS:
378 push bx
379 mov bx,es
380 add bx,byte 20h
381 mov es,bx
382 pop bx
383 ; Increment read buffer for next sector
384 loop ReadSectorsCHSLoop ; Read next sector
385
386 ret
387
388
389 msgDiskError db 'Disk error',0dh,0ah,0
390 msgFreeLdr db 'freeldr.sys not found',0dh,0ah,0
391 ; Sorry, need the space...
392 ;msgAnyKey db 'Press any key to restart',0dh,0ah,0
393 msgAnyKey db 'Press any key',0dh,0ah,0
394 filename db 'FREELDR SYS'
395
396 times 509-($-$$) db 0 ; Pad to 509 bytes
397
398 BootPartition:
399 db 0
400
401 BootSignature:
402 dw 0aa55h ; BootSector signature