652 lines
16 KiB
NASM
652 lines
16 KiB
NASM
|
;++
|
||
|
|
;
|
||
|
|
;Copyright (c) 1995 Microsoft Corporation
|
||
|
|
;
|
||
|
|
;Module Name:
|
||
|
|
;
|
||
|
|
; bioschk.asm
|
||
|
|
;
|
||
|
|
;Abstract:
|
||
|
|
;
|
||
|
|
; The code in this "image" is responsible for checking if is appropriate
|
||
|
|
; for us to start setupldr.bin. We consider this appropriate when we pass
|
||
|
|
; BIOS checkings. Setupldr.bin is binary appended at the end of this image.
|
||
|
|
;
|
||
|
|
;Author:
|
||
|
|
;
|
||
|
|
; Calin Negreanu (calinn) 16-Dec-1999
|
||
|
|
;
|
||
|
|
;Environment:
|
||
|
|
;
|
||
|
|
; Real mode
|
||
|
|
;
|
||
|
|
; Case 1:
|
||
|
|
; Complete image has been loaded at 2000:0000 by the boot code
|
||
|
|
; DL = INT 13h drive number we've booted from
|
||
|
|
;
|
||
|
|
; Case 2:
|
||
|
|
; First 512 bytes of this image has been loaded at 2000:000 by the boot code
|
||
|
|
; BX = Starting Cluster Number of this image
|
||
|
|
; DL = INT 13h drive number we've booted from
|
||
|
|
; DS:SI -> boot media's BPB
|
||
|
|
; DS:DI -> argument structure
|
||
|
|
;
|
||
|
|
;Revision History:
|
||
|
|
;
|
||
|
|
;--
|
||
|
|
page ,132
|
||
|
|
title boot - BIOS check
|
||
|
|
name bioschk
|
||
|
|
|
||
|
|
.8086
|
||
|
|
|
||
|
|
CODE SEGMENT
|
||
|
|
ASSUME CS:CODE,DS:CODE,SS:NOTHING,ES:NOTHING
|
||
|
|
|
||
|
|
ORG 0000H
|
||
|
|
|
||
|
|
_BiosChk label byte
|
||
|
|
|
||
|
|
BiosChkDestSeg EQU 1000h
|
||
|
|
SetupLdrDestSeg EQU 2000h
|
||
|
|
MaxCodeSize EQU 0800h ;number of paragraphs (32k)
|
||
|
|
MaxSetupLdrSize EQU 4000h ;number of paragraphs (256k)
|
||
|
|
|
||
|
|
StackSeg EQU 1000h ;stack goes from here
|
||
|
|
|
||
|
|
MAXREAD EQU 10000h
|
||
|
|
MAXSECTORS EQU MAXREAD/0200h
|
||
|
|
|
||
|
|
DoubleWord struc
|
||
|
|
lsw dw ?
|
||
|
|
msw dw ?
|
||
|
|
DoubleWord ends
|
||
|
|
|
||
|
|
SHARED struc
|
||
|
|
ReadClusters dd ? ; function pointer
|
||
|
|
ReadSectors dd ? ; function pointer
|
||
|
|
SectorBase dd ? ; starting sector for
|
||
|
|
; ReadSectors callback
|
||
|
|
SHARED ends
|
||
|
|
|
||
|
|
BPB struc
|
||
|
|
BytesPerSector dw ?
|
||
|
|
SectorsPerCluster db ?
|
||
|
|
ReservedSectors dw ?
|
||
|
|
Fats db ?
|
||
|
|
DirectoryEntries dw ?
|
||
|
|
Sectors dw ?
|
||
|
|
Media db ?
|
||
|
|
FatSectors dw ?
|
||
|
|
SectorsPerTrack dw ?
|
||
|
|
Heads dw ?
|
||
|
|
HiddenSectors dd ?
|
||
|
|
SectorsLong dd ?
|
||
|
|
BootDriveNumber db ?
|
||
|
|
BPB ends
|
||
|
|
|
||
|
|
JMPFAR MACRO DestOfs,DestSeg
|
||
|
|
db 0eah
|
||
|
|
dw OFFSET DestOfs
|
||
|
|
dw DestSeg
|
||
|
|
endm
|
||
|
|
|
||
|
|
START:
|
||
|
|
;
|
||
|
|
; The FAT boot sector only reads in the first 512 bytes of NTLDR. This is
|
||
|
|
; the module that contains those 512 bytes, so we are now responsible for
|
||
|
|
; loading the rest of the file. Other filesystems will load the whole file,
|
||
|
|
; so the default entrypoint branches around the FAT-specific code.
|
||
|
|
;
|
||
|
|
jmp RealStart
|
||
|
|
|
||
|
|
FatBegin:
|
||
|
|
.386
|
||
|
|
;
|
||
|
|
; If we're here, we've booted off a FAT system and we must load the rest
|
||
|
|
; of the binary image at 2000:0200 (right behind this sector). The boot
|
||
|
|
; sector passes us the following:
|
||
|
|
; BX = Starting Cluster Number of this image
|
||
|
|
; DL = INT 13h drive number we've booted from
|
||
|
|
; DS:SI -> boot media's BPB
|
||
|
|
; DS:DI -> argument structure
|
||
|
|
;
|
||
|
|
|
||
|
|
;
|
||
|
|
; Save away the boot drive and the starting cluster number
|
||
|
|
;
|
||
|
|
push dx
|
||
|
|
push bx
|
||
|
|
;
|
||
|
|
; Blast the FAT into memory at 6000:0000 - 8000:0000
|
||
|
|
;
|
||
|
|
|
||
|
|
.386
|
||
|
|
push 06000h
|
||
|
|
.8086
|
||
|
|
pop es
|
||
|
|
xor bx,bx ; (es:bx) = 6000:0000
|
||
|
|
mov cx,ds:[si].ReservedSectors
|
||
|
|
mov ds:[di].SectorBase.msw,0
|
||
|
|
mov ds:[di].SectorBase.lsw,cx ; set up Sector Base
|
||
|
|
|
||
|
|
mov ax,ds:[si].FatSectors ; (al) = # Sectors to read
|
||
|
|
cmp ax,080h
|
||
|
|
jbe FatLt64k
|
||
|
|
|
||
|
|
; The FAT is > 64k, so we read the first 64k chunk, then the rest.
|
||
|
|
; (A 16-bit FAT can't be bigger than 128k)
|
||
|
|
|
||
|
|
push cx
|
||
|
|
mov ax,080h ; (al) = # of sectors to read
|
||
|
|
call ds:[di].ReadSectors
|
||
|
|
pop cx ; (cx) = previous SectorBase
|
||
|
|
.386
|
||
|
|
push 07000h
|
||
|
|
.8086
|
||
|
|
pop es
|
||
|
|
xor bx,bx ; (es:bx) = 7000:0000
|
||
|
|
mov ax,ds:[si].FatSectors
|
||
|
|
sub ax,080h ; (ax) = # Sectors left to read
|
||
|
|
add cx,080h ; (cx) = SectorBase for next read
|
||
|
|
mov ds:[di].SectorBase.lsw,cx
|
||
|
|
adc ds:[di].SectorBase.msw,0 ; set up SectorBase
|
||
|
|
|
||
|
|
;
|
||
|
|
; (al) = # of sectors to read
|
||
|
|
;
|
||
|
|
FatLt64k:
|
||
|
|
call ds:[di].ReadSectors
|
||
|
|
|
||
|
|
;
|
||
|
|
; FAT is in memory, now we restore our starting cluster number
|
||
|
|
;
|
||
|
|
pop dx ; (dx) = starting cluster number
|
||
|
|
xor bx,bx
|
||
|
|
|
||
|
|
;
|
||
|
|
; set up FS and GS for reading the FAT
|
||
|
|
;
|
||
|
|
.386
|
||
|
|
mov ax,6000h
|
||
|
|
mov fs,ax
|
||
|
|
mov ax,7000h
|
||
|
|
mov gs,ax
|
||
|
|
.8086
|
||
|
|
|
||
|
|
;
|
||
|
|
; set up ES for reading in the rest of us
|
||
|
|
;
|
||
|
|
push cs
|
||
|
|
pop es
|
||
|
|
mov ah,MAXSECTORS ; (ah) = number of sectors we can read
|
||
|
|
|
||
|
|
FatLoop:
|
||
|
|
;
|
||
|
|
; (dx) = next cluster to load
|
||
|
|
;
|
||
|
|
push dx
|
||
|
|
mov al,ds:[si].SectorsPerCluster ; (al) = number of contiguous sectors
|
||
|
|
; found
|
||
|
|
sub ah,ds:[si].SectorsPerCluster ; can read before 64k
|
||
|
|
|
||
|
|
;
|
||
|
|
; Check to see if we've reached the end of the file
|
||
|
|
;
|
||
|
|
cmp dx,0ffffh
|
||
|
|
jne Fat10
|
||
|
|
|
||
|
|
;
|
||
|
|
; The entire file has been loaded. Throw away the saved next cluster,
|
||
|
|
; restore the boot drive, and let NTLDR do its thing.
|
||
|
|
;
|
||
|
|
pop dx
|
||
|
|
pop dx
|
||
|
|
jmp RealStart
|
||
|
|
|
||
|
|
Fat10:
|
||
|
|
mov cx,dx
|
||
|
|
;
|
||
|
|
; (dx) = (cx) = last contiguous cluster
|
||
|
|
; (al) = # of contiguous clusters found
|
||
|
|
;
|
||
|
|
|
||
|
|
call NextFatEntry
|
||
|
|
;
|
||
|
|
; (dx) = cluster following last contiguous cluster
|
||
|
|
|
||
|
|
;
|
||
|
|
; Check to see if the next cluster is contiguous. If not, go load the
|
||
|
|
; contiguous block we've found.
|
||
|
|
;
|
||
|
|
inc cx
|
||
|
|
cmp dx,cx
|
||
|
|
|
||
|
|
jne LncLoad
|
||
|
|
|
||
|
|
;
|
||
|
|
; Check to see if we've reached the 64k boundary. If so, go load the
|
||
|
|
; contiguous block so far. If not, increment the number of contiguous
|
||
|
|
; sectors and loop again.
|
||
|
|
;
|
||
|
|
cmp ah,0
|
||
|
|
jne Lnc20
|
||
|
|
mov ah,MAXSECTORS ; (ah) = number of sectors until
|
||
|
|
jmp short LncLoad
|
||
|
|
|
||
|
|
Lnc20:
|
||
|
|
add al,ds:[si].SectorsPerCluster
|
||
|
|
sub ah,ds:[si].SectorsPerCluster
|
||
|
|
jmp short Fat10
|
||
|
|
|
||
|
|
|
||
|
|
LncLoad:
|
||
|
|
;
|
||
|
|
; (TOS) = first cluster to load
|
||
|
|
; (dx) = first cluster of next group to load
|
||
|
|
; (al) = number of contiguous sectors
|
||
|
|
;
|
||
|
|
pop cx
|
||
|
|
push dx
|
||
|
|
mov dx,cx
|
||
|
|
mov cx,10 ; (cx) = retry count
|
||
|
|
|
||
|
|
;
|
||
|
|
; N.B.
|
||
|
|
; This assumes that we will never have more than 255 contiguous clusters.
|
||
|
|
; Since that would get broken up into chunks that don't cross the 64k
|
||
|
|
; boundary, this is ok.
|
||
|
|
;
|
||
|
|
; (dx) = first cluster to load
|
||
|
|
; (al) = number of contiguous sectors
|
||
|
|
; (TOS) = first cluster of next group to load
|
||
|
|
; (es:bx) = address where clusters should be loaded
|
||
|
|
;
|
||
|
|
FatRetry:
|
||
|
|
push bx
|
||
|
|
push ax
|
||
|
|
push dx
|
||
|
|
push cx
|
||
|
|
call [di].ReadClusters
|
||
|
|
jnc ReadOk
|
||
|
|
;
|
||
|
|
; error in the read, reset the drive and try again
|
||
|
|
;
|
||
|
|
mov ax,01h
|
||
|
|
mov al,ds:[si].BootDriveNumber
|
||
|
|
int 13h
|
||
|
|
xor ax,ax
|
||
|
|
mov al,ds:[si].BootDriveNumber
|
||
|
|
int 13h
|
||
|
|
|
||
|
|
;
|
||
|
|
; pause for a while
|
||
|
|
;
|
||
|
|
xor ax,ax
|
||
|
|
FatPause:
|
||
|
|
dec ax
|
||
|
|
jnz FatPause
|
||
|
|
|
||
|
|
pop cx
|
||
|
|
pop dx
|
||
|
|
pop ax
|
||
|
|
pop bx
|
||
|
|
|
||
|
|
dec cx
|
||
|
|
jnz FatRetry
|
||
|
|
|
||
|
|
;
|
||
|
|
; we have re-tried ten times, it still doesn't work, so punt.
|
||
|
|
;
|
||
|
|
push cs
|
||
|
|
pop ds
|
||
|
|
mov si,offset FAT_ERROR
|
||
|
|
FatErrPrint:
|
||
|
|
lodsb
|
||
|
|
or al,al
|
||
|
|
jz FatErrDone
|
||
|
|
mov ah,14 ; write teletype
|
||
|
|
mov bx,7 ; attribute
|
||
|
|
int 10h ; print it
|
||
|
|
jmp FatErrPrint
|
||
|
|
|
||
|
|
FatErrDone:
|
||
|
|
jmp $
|
||
|
|
; BUGBUG this should be replaced by a mechanism to get a pointer
|
||
|
|
; passed to us in the param block. since the boot sector msg itself
|
||
|
|
; is properly localized but this one isn't.
|
||
|
|
FAT_ERROR db 13,10,"Disk I/O error",0dh,0ah,0
|
||
|
|
|
||
|
|
|
||
|
|
ReadOk:
|
||
|
|
pop cx
|
||
|
|
pop dx
|
||
|
|
pop ax
|
||
|
|
pop bx
|
||
|
|
pop dx ; (dx) = first cluster of next group
|
||
|
|
; to load.
|
||
|
|
|
||
|
|
.386
|
||
|
|
;
|
||
|
|
; Convert # of sectors into # of bytes.
|
||
|
|
;
|
||
|
|
mov cl,al
|
||
|
|
xor ch,ch
|
||
|
|
shl cx,9
|
||
|
|
.8086
|
||
|
|
add bx,cx
|
||
|
|
jz FatLoopDone
|
||
|
|
jmp FatLoop
|
||
|
|
|
||
|
|
FatLoopDone:
|
||
|
|
;
|
||
|
|
; (bx) = 0
|
||
|
|
; This means we've just ended on a 64k boundary, so we have to
|
||
|
|
; increment ES to continue reading the file. We are guaranteed to
|
||
|
|
; always end on a 64k boundary and never cross it, because we
|
||
|
|
; will reduce the number of contiguous clusters to read
|
||
|
|
; to ensure that the last cluster read will end on the 64k boundary.
|
||
|
|
; Since we start reading at 0, and ClusterSize will always be a power
|
||
|
|
; of two, a cluster will never cross a 64k boundary.
|
||
|
|
;
|
||
|
|
mov ax,es
|
||
|
|
add ax,01000h
|
||
|
|
mov es,ax
|
||
|
|
mov ah,MAXSECTORS
|
||
|
|
jmp FatLoop
|
||
|
|
|
||
|
|
;++
|
||
|
|
;
|
||
|
|
; NextFatEntry - This procedure returns the next cluster in the FAT chain.
|
||
|
|
; It will deal with both 12-bit and 16-bit FATs. It assumes
|
||
|
|
; that the entire FAT has been loaded into memory.
|
||
|
|
;
|
||
|
|
; Arguments:
|
||
|
|
; (dx) = current cluster number
|
||
|
|
; (fs:0) = start of FAT in memory
|
||
|
|
; (gs:0) = start of second 64k of FAT in memory
|
||
|
|
;
|
||
|
|
; Returns:
|
||
|
|
; (dx) = next cluster number in FAT chain
|
||
|
|
; (dx) = 0ffffh if there are no more clusters in the chain
|
||
|
|
;
|
||
|
|
;--
|
||
|
|
NextFatEntry proc near
|
||
|
|
push bx
|
||
|
|
|
||
|
|
;
|
||
|
|
; Check to see if this is a 12-bit or 16-bit FAT. The biggest FAT we can
|
||
|
|
; have for a 12-bit FAT is 4080 clusters. This is 6120 bytes, or just under
|
||
|
|
; 12 sectors.
|
||
|
|
;
|
||
|
|
; A 16-bit FAT that's 12 sectors long would only hold 3072 clusters. Thus,
|
||
|
|
; we compare the number of FAT sectors to 12. If it's greater than 12, we
|
||
|
|
; have a 16-bit FAT. If it's less than or equal to 12, we have a 12-bit FAT.
|
||
|
|
;
|
||
|
|
call IsFat12
|
||
|
|
jnc Next16Fat
|
||
|
|
|
||
|
|
Next12Fat:
|
||
|
|
mov bx,dx ; (fs:bx) => temporary index
|
||
|
|
shr dx,1 ; (dx) = offset/2
|
||
|
|
; (CY) = 1 need to shift
|
||
|
|
pushf ; = 0 don't need to shift
|
||
|
|
add bx,dx ; (fs:bx) => next cluster number
|
||
|
|
.386
|
||
|
|
mov dx,fs:[bx] ; (dx) = next cluster number
|
||
|
|
.8086
|
||
|
|
popf
|
||
|
|
jc shift ; carry flag tells us whether to
|
||
|
|
and dx,0fffh ; mask
|
||
|
|
jmp short N12Tail
|
||
|
|
shift:
|
||
|
|
.386
|
||
|
|
shr dx,4 ; or shift
|
||
|
|
.8086
|
||
|
|
|
||
|
|
N12Tail:
|
||
|
|
;
|
||
|
|
; Check for end of file
|
||
|
|
;
|
||
|
|
cmp dx,0ff8h ; If we're at the end of the file,
|
||
|
|
jb NfeDone ; convert to canonical EOF.
|
||
|
|
mov dx,0ffffh
|
||
|
|
jmp short NfeDone
|
||
|
|
|
||
|
|
Next16Fat:
|
||
|
|
add dx,dx ; (dx) = offset
|
||
|
|
jc N16high
|
||
|
|
|
||
|
|
mov bx,dx ; (fs:bx) => next cluster number
|
||
|
|
.386
|
||
|
|
mov dx,fs:[bx] ; (dx) = next cluster number
|
||
|
|
.8086
|
||
|
|
jmp short N16Tail
|
||
|
|
|
||
|
|
N16high:
|
||
|
|
mov bx,dx
|
||
|
|
.386
|
||
|
|
mov dx,gs:[bx]
|
||
|
|
.8086
|
||
|
|
|
||
|
|
N16Tail:
|
||
|
|
cmp dx,0fff8h
|
||
|
|
jb NfeDone
|
||
|
|
mov dx,0ffffh ; If we're at the end of the file
|
||
|
|
; convert to canonical EOF.
|
||
|
|
|
||
|
|
NfeDone:
|
||
|
|
pop bx
|
||
|
|
ret
|
||
|
|
NextFatEntry endp
|
||
|
|
|
||
|
|
;++
|
||
|
|
;
|
||
|
|
; IsFat12 - This function determines whether the BPB describes a 12-bit
|
||
|
|
; or 16-bit FAT.
|
||
|
|
;
|
||
|
|
; Arguments - ds:si supplies pointer to BPB
|
||
|
|
;
|
||
|
|
; Returns
|
||
|
|
; CY set - 12-bit FAT
|
||
|
|
; CY clear - 16-bit FAT
|
||
|
|
;
|
||
|
|
;--
|
||
|
|
IsFat12 proc near
|
||
|
|
|
||
|
|
.386
|
||
|
|
push eax
|
||
|
|
push ebx
|
||
|
|
push ecx
|
||
|
|
push edx
|
||
|
|
|
||
|
|
movzx ecx, ds:[si].Sectors
|
||
|
|
or cx,cx
|
||
|
|
jnz if10
|
||
|
|
mov ecx, ds:[si].SectorsLong
|
||
|
|
if10:
|
||
|
|
;
|
||
|
|
; (ecx) = number of sectors
|
||
|
|
;
|
||
|
|
movzx ebx, byte ptr ds:[si].Fats
|
||
|
|
movzx eax, word ptr ds:[si].FatSectors
|
||
|
|
mul ebx
|
||
|
|
sub ecx,eax
|
||
|
|
|
||
|
|
;
|
||
|
|
; (ecx) = (#sectors)-(sectors in FATs)
|
||
|
|
;
|
||
|
|
movzx eax, word ptr ds:[si].DirectoryEntries
|
||
|
|
shl eax, 5
|
||
|
|
;
|
||
|
|
; (eax) = #bytes in root dir
|
||
|
|
;
|
||
|
|
mov edx,eax
|
||
|
|
and edx,0ffff0000h
|
||
|
|
div word ptr ds:[si].BytesPerSector
|
||
|
|
sub ecx,eax
|
||
|
|
|
||
|
|
;
|
||
|
|
; (ecx) = (#sectors) - (sectors in fat) - (sectors in root dir)
|
||
|
|
;
|
||
|
|
movzx eax, word ptr ds:[si].ReservedSectors
|
||
|
|
sub ecx, eax
|
||
|
|
mov eax, ecx
|
||
|
|
movzx ecx, byte ptr ds:[si].SectorsPerCluster
|
||
|
|
xor edx,edx
|
||
|
|
div ecx
|
||
|
|
|
||
|
|
cmp eax, 4087
|
||
|
|
jae if20
|
||
|
|
stc
|
||
|
|
jmp short if30
|
||
|
|
if20:
|
||
|
|
clc
|
||
|
|
if30:
|
||
|
|
pop edx
|
||
|
|
pop ecx
|
||
|
|
pop ebx
|
||
|
|
pop eax
|
||
|
|
ret
|
||
|
|
.8086
|
||
|
|
IsFat12 endp
|
||
|
|
|
||
|
|
|
||
|
|
Free EQU 512-($-Start)
|
||
|
|
if Free lt 0
|
||
|
|
%out FATAL PROBLEM: FAT-specific startup code is greater than
|
||
|
|
%out 512 bytes. Fix it!
|
||
|
|
.err
|
||
|
|
endif
|
||
|
|
|
||
|
|
RealStart:
|
||
|
|
|
||
|
|
;
|
||
|
|
; we are completely done with the boot sector, we can party on it's memory as we like.
|
||
|
|
; set up the stack
|
||
|
|
;
|
||
|
|
mov ax,StackSeg
|
||
|
|
mov ss,ax
|
||
|
|
xor sp,sp
|
||
|
|
|
||
|
|
mov ax,cs
|
||
|
|
mov ds,ax
|
||
|
|
mov es,ax
|
||
|
|
|
||
|
|
;
|
||
|
|
; save setupldr data
|
||
|
|
;
|
||
|
|
mov Preserve, dl
|
||
|
|
|
||
|
|
; move ourselves from 2000:0000 to 1000:0000, one paragraph at a time.
|
||
|
|
|
||
|
|
mov ax, BiosChkDestSeg
|
||
|
|
mov es, ax
|
||
|
|
mov dx, MaxCodeSize
|
||
|
|
cld
|
||
|
|
Again1:
|
||
|
|
xor di, di
|
||
|
|
xor si, si
|
||
|
|
mov cx, 10h
|
||
|
|
rep movsb
|
||
|
|
mov ax, ds
|
||
|
|
inc ax
|
||
|
|
mov ds, ax
|
||
|
|
mov ax, es
|
||
|
|
inc ax
|
||
|
|
mov es, ax
|
||
|
|
dec dx
|
||
|
|
jnz Again1
|
||
|
|
mov ax, BiosChkDestSeg
|
||
|
|
mov ds, ax
|
||
|
|
mov es, ax
|
||
|
|
JMPFAR Continue1, BiosChkDestSeg
|
||
|
|
|
||
|
|
Continue1:
|
||
|
|
|
||
|
|
; insert your BIOS check code here
|
||
|
|
; for now we will just display a message and wait for the user to press a key
|
||
|
|
mov si,OFFSET MsgPressKey
|
||
|
|
call PrintMsg
|
||
|
|
QueueEmpty:
|
||
|
|
mov ah, 01h
|
||
|
|
int 16h
|
||
|
|
jz QueueEmpty
|
||
|
|
|
||
|
|
; instead of a real BIOS check we will check if the user holds down CTRL.
|
||
|
|
; If yes, we will behave like BIOS check failed
|
||
|
|
|
||
|
|
; mov ah,02h
|
||
|
|
; int 16h
|
||
|
|
; and al,00000100b
|
||
|
|
; jz MoveSetupLdr
|
||
|
|
|
||
|
|
; at this point, the BIOS check failed. You can add whatever code you want here
|
||
|
|
; to give a message or to make the computer crash. If you don't do anything, the
|
||
|
|
; code will jump to 2000:0000 so an infinite loop is going to happen.
|
||
|
|
; jmp Continue2
|
||
|
|
|
||
|
|
MoveSetupLdr:
|
||
|
|
; move Setupldr code from 2000+MaxCodeSize:0000 to 2000:0000, one paragraph at a time.
|
||
|
|
|
||
|
|
push ds
|
||
|
|
push es
|
||
|
|
mov ax, SetupLdrDestSeg
|
||
|
|
mov es, ax
|
||
|
|
add ax, MaxCodeSize
|
||
|
|
mov ds, ax
|
||
|
|
mov dx, MaxSetupLdrSize
|
||
|
|
cld
|
||
|
|
Again2:
|
||
|
|
xor di, di
|
||
|
|
xor si, si
|
||
|
|
mov cx, 10h
|
||
|
|
rep movsb
|
||
|
|
mov ax, ds
|
||
|
|
inc ax
|
||
|
|
mov ds, ax
|
||
|
|
mov ax, es
|
||
|
|
inc ax
|
||
|
|
mov es, ax
|
||
|
|
dec dx
|
||
|
|
jnz Again2
|
||
|
|
pop es
|
||
|
|
pop ds
|
||
|
|
|
||
|
|
Continue2:
|
||
|
|
mov dl, Preserve
|
||
|
|
JMPFAR 0,SetupLdrDestSeg
|
||
|
|
|
||
|
|
;
|
||
|
|
;EXPECTS DS:SI - MESSAGE ADDR
|
||
|
|
;
|
||
|
|
PrintMsg proc near
|
||
|
|
push ax
|
||
|
|
push bx
|
||
|
|
PrintMsgLoop:
|
||
|
|
lodsb
|
||
|
|
cmp al,0
|
||
|
|
je PrintMsgEnd
|
||
|
|
mov ah,0eh
|
||
|
|
mov bx,0007h
|
||
|
|
int 10h
|
||
|
|
jmp PrintMsgLoop
|
||
|
|
PrintMsgEnd:
|
||
|
|
pop bx
|
||
|
|
pop ax
|
||
|
|
ret
|
||
|
|
PrintMsg endp
|
||
|
|
|
||
|
|
Preserve db ?
|
||
|
|
MsgPressKey db 0dh, 0ah, "Press any key to continue..."
|
||
|
|
db 0
|
||
|
|
|
||
|
|
.errnz ($-_BiosChk) GT (MaxCodeSize*16 - 2) ;FATAL: BiosChk code is too large
|
||
|
|
|
||
|
|
org MaxCodeSize*16 - 2
|
||
|
|
db 55h,0aah
|
||
|
|
|
||
|
|
|
||
|
|
CODE ENDS
|
||
|
|
END START
|