able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/boot/startup/i386/su.asm

1441 lines
33 KiB
NASM
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
;++
;
; Module name
;
; su.asm
;
; Author
;
; Thomas Parslow (tomp) Jan-15-91
;
; Description
;
; Startup module for the 386 NT OS loader.
;
; Exported Procedures
;
; EnableProtectPaging
;
; Notes
; NT386 Boot Loader program. This assembly file is required in
; order to link C modules into a "/TINY" (single segment) memory
; model.
;
;
; This file does the following:
; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; 1) Defines the entry point for the boot loader's startup program
; 2) Computes what values should actually be in the DS and SS registers.
; 3) Provides the int bios functionality
; 4) Provides 386/486 mode (protect/paging) switching code.
;
; The OS/2 bootstrap routine (boot sector) loads the boot loader program at
; real-mode address 2000:0000 with the following register values:
;
; CS = 2000
; IP = 0000
; DS = 07C0
; ES = 1000
; SS = 0000
; SP = 7C00
;
; Build Notes:
; ~~~~~~~~~~~~
; The microsoft C compiler will not produce "tiny" model programs. In the
; tiny model, the entire program consists of only one segment. The small
; model produced by our compilers consists of two segments: DGROUP and _TEXT.
; If you convert a small model program into a tiny model program, DS (which
; should point to DGROUP (bss,const,data) will always be wrong. For this reason
; we need an assembly module to do a simple run-time fixup on SS and DS. To
; guarantee that DS will point to DGROUP no matter where os2ldr is loaded,
; the paragraph (shifted right four bits) offset of DGROUP from _TEXT must
; be added to the value in CS to compute DS and SS.
;
; We get the linker to fixup the offset of the beginning of the dgroup segment
; relative to the beginning of the code segment and it's this value added
; to the value in CS that allows us to build a "tiny" model program in C
; without a lot of munging around in order to get the data reference offsets
; in the code correct.
;
; If the _TEXT:DGROUP fixup appears in other files (which it does), the linker
; will not compute the correct value unless the accumulated data pointer is
; zero when it gets there. Therefore, no data should be placed in the data segment
; until after all instances of _TEXT:DGROUP have been encountered by the linker.
; The linker processes files from right to left on the command line.
;
; A Note About Stacks
; Initially we run on our internal stack (SuStack) which is only 160 bytes deep
; but seems to do the trick. Then we have to have a separate double fault stack.
; This stack can be in the middle of the stack/data segment. It will step on
; the loader image, but that's ok since the fault was either caused by 16bit
; code (which won't be in the loader image) or, it was caused by the 32bit
; loader (which has already been relocated) so we won't be stepping on code
; that may have caused the fault. And finally, we have the "call back" stack
; which starts at the top of the stack/data segment. We use this during
; all call backs since the original loader source is no longer needed and
; this'll give us plenty of stack for bios calls etc.
;
;--
DoubleWord struc
lsw dw ?
msw dw ?
DoubleWord ends
;
; This is the structure used to pass all shared data between the boot sector
; and NTLDR.
;
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 ?
;
; The following byte is NOT part of the BPB but is set by SYS and format
;
BootDriveNumber db ?
BPB ends
SU_CODEMODULE equ 1 ; Identifies this module to "su.inc"
include su.inc
include macro.inc
extrn _BootRecord:word
extrn _puts:near
extrn _MemoryDescriptorList:near
extrn _InsertDescriptor:near
MAXREAD EQU 10000h
MAXSECTORS EQU MAXREAD/0200h
_TEXT segment para use16 public 'CODE'
ASSUME CS: _TEXT, DS: DGROUP, SS: DGROUP
.386p
;
; Run-time fixups for stack and data segment
;
public Start
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 (i.e. HPFS, NTFS, RIPL)
; 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 NTLDR at 2000:0200 (right behind this sector) NTLDR passes us the
; following:
; BX = Starting Cluster Number of NTLDR
; DL = INT 13h drive number we've booted from
; DS:SI -> boot media's BPB
; DS:DI -> argument structure (see above struc definition)
;
;
; 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
; until boundary
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
; boundary reached again
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
if 0
push dx
call PrintDbg
mov dx,ax
call PrintDbg
pop dx
endif
call [di].ReadClusters
jnc ReadOk
;
; error in the read, reset the drive and try again
;
if 0
mov dx, ax
call PrintDbg
endif
mov ax,01h
mov al,ds:[si].BootDriveNumber
int 13h
if 0
mov dx,ax
call PrintDbg
endif
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 $
; 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
PrintDbg proc near
push ax
push bx
push cx
mov cx,4
pd10:
.386
rol dx,4
.8086
mov ah,0eh
mov bx,7
mov al,dl
and al,0fh
add al,'0'
cmp al,'9'
jbe pd15
add al,'A'-('9'+1)
pd15:
int 010h
loop pd10
mov ah,0eh
mov al,' '
mov bx,7
int 010h
pop cx
pop bx
pop ax
ret
PrintDbg 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:
.386p
;
; Compute the paragraph needed for DS
;
if 0
mov ax,0
int 16h
endif
mov bx,offset _TEXT:DGROUP ; first calculate offset to data
shr bx,4 ; must be para aligned
mov ax,cs ; get base of code
add ax,bx ; add paragraph offset to data
mov ss,ax ; ints disabled for next instruct
mov sp,offset DGROUP:SuStack ; (sp) = top of internal stack
;
; Build C stack frame for _SuMain
;
push dx ; pass bootdisk to main (high byte is ignored)
;
; Make DS point to the paragraph address of DGROUP
;
mov ds,ax ; ds now points to beginning of DGROUP
mov es,ax ; es now points to beginning of DGROUP
;
; Compute the physical address of the end of the data segment (which
; will be the beginning of the prepended loader file).
;
movzx edx,ax
shl edx,4
add edx,offset DGROUP:_edata
mov dword ptr _FileStart,edx
;
; Force the upper parts of
; of EBP and ESP to be zero in real mode.
;
xor bp,bp
movzx ebp,bp
movzx esp,sp
mov [saveDS],ds
call _SuMain ; go to C code to do everything else.
;++
; _EnableProtectPaging
;
; Loads 386 protect mode registers.
; Enables 386 protection h/w
; Loads pagings registers
; Enables 386 paging h/w
;
;--
public _EnableProtectPaging
_EnableProtectPaging proc near
;
; Sanitize ES and GS and clean out any junk in the upper 16bits
; of the flags that may have been left by the bios, before we go protected
;
push dword ptr 0
popfd
mov bx,sp
mov dx,[bx+2] ; are we enabling prot/paging for the first time?
xor ax,ax
mov gs,ax
mov es,ax
;
; FS must contain the selector of the PCR when we call the kernel
;
push PCR_Selector
pop fs
;
; Load the gdtr and idtr.
; We disable interrupts here since we can't handle interrups with the
; idt loaded while were in real mode and before we switch to protmode.
cli
lgdt fword ptr [_GDTregister]
lidt fword ptr [_IDTregister]
;
; We have to stamp the segment portion of any real-mode far pointer with
; the corresponding selector values before we go protected.
;
mov si,offset _ScreenStart
mov word ptr [si+2],VideoSelector
mov si,offset _vp
mov word ptr [si+2],VideoSelector
;
; Enable protect and paging mode
;
mov eax,cr0
; If we're enabling protect mode for the first time, don't turn on paging
; because the osloader does all that. However, if we're returning to
; protected mode, the page tables are already setup, therefore we do want
; to turn paging on.
or dx,dx
jz only_prot
or eax,PROT_MODE + ENABLE_PAGING
mov cr0,eax
;
; The following JMP must be DWORD-aligned in order to avoid an obscure i386
; hardware bug. If not, it is possible (albeit unlikely) that the prefetch
; queue can get trashed.
;
ALIGN 4
jmp flush
only_prot:
or eax,PROT_MODE
mov cr0,eax
;
; Flush the prefetch queue
;
ALIGN 4
jmp flush
flush:
;
; Load CS with the SU module's code selector
;
push SuCodeSelector
push offset cs:restart
retf
;
; Now load DS and SS with the SU module's protect mode data selector.
;
restart:
mov ax,SuDataSelector
mov ds,ax
mov ss,ax
;
; Load LDT with zero since it will never be used.
;
xor bx,bx
lldt bx
;
; Load the Task Register and return to the boot SU module.
;
or dx,dx
jnz epp10
mov bx,TSS_Selector
ltr bx
epp10:
ret
_EnableProtectPaging endp
.286p
;** _biosint
;
; Rom bios interrupt dispatcher
;
public _biosint
_biosint proc near
enter 0,0
push di
push si
push ds
push es
; Get pointer to register parameter frame
les di,[bp+4]
; Get requested interrupt number
mov ax,es:[di].intnum
; Check that requested bios interrupt is supported
sub ax,10h ; sub lowest int number supported
jnc short bios1
mov es:[di].intnum,FUNCTION_ERROR
jmp short biosx
bios1:
shl ax,1 ; shift if to make it a word offset
cmp ax,bios_cnt ; offset beyond end of table?
jb short bios2
; Error: requested interrupt not supported
mov es:[di].sax,FUNCTION_ERROR
jmp short biosx
bios2: mov bx,ax
mov ax,word ptr cs:bios_table[bx]
push es ; save seg of address frame
push di ; save stack register frame pointer
push ax ; address of bios int
mov ax,es:[di].sax
mov bx,es:[di].sbx
mov cx,es:[di].scx
mov dx,es:[di].sdx
mov si,es:[di].ssi
mov es,es:[di].ses
ret ; this sends us to the "int #" instruction
; We return here from the jmp instruction following the int
bios_ret:
pop di ; get address of register parameter frame
pop es ; restore segment of parameter frame
bios5: pushf
pop es:[di].sfg
mov es:[di].sax,ax
mov es:[di].sbx,bx
mov es:[di].scx,cx
mov es:[di].sdx,dx
mov es:[di].ssi,si
mov es:[di].ses,es
; Restore original registers and return to caller
biosx:
pop es
pop ds
pop si
pop di
leave
ret
_biosint endp
;** Bios Interrupt Table
;
bios10: int 10h
jmp short bios_ret
bios11: int 11h
jmp short bios_ret
bios12: int 12h
jmp short bios_ret
bios13: int 13h
jmp short bios_ret
bios14: int 14h
jmp short bios_ret
bios15: int 15h
jmp short bios_ret
bios16: int 16h
jmp short bios_ret
bios17: int 17h
jmp short bios_ret
bios18: int 18h
jmp short bios_ret
bios19: int 19h
jmp short bios_ret
bios_table dw bios10,bios11,bios12,bios13,bios14,bios15,bios16,bios17,bios18,bios19
bios_cnt equ $ - bios_table
.386p
;++
;
; _MoveMemory
;
; Routine Description
;
; Moves dwords in memory from source to destination.
;
; Arguments
;
; (TOS+4) = number of bytes to move
; (TOS+8) = linear address of destination
; (TOS+12) = linear address of source
;
; Notes
;
; 1) Valid page table entries must already exist for the
; source and destination memory.
;
; 2) ALL memory in the lower one megabyte is assumed to
; be identity mapped if used.
;
; USES ESI, EDI, ECX, FLAGS
;
;
;--
public _MoveMemory
_MoveMemory proc near
enter 0,0
push ds
push es
;
; Get source, destination, and count arguments from the stack
; Make "count" the number of dwords to move.
;
mov esi,dword ptr [bp+4]
mov edi,dword ptr [bp+8]
mov ecx,dword ptr [bp+12]
shr ecx,2
;
; Load FLAT selectors into DS and ES
;
mov ax,KeDataSelector
mov ds,ax
mov es,ax
;
; Move the block of data.
;
assume es:FLAT, ds:FLAT
;
; move the dwords
;
cld
rep movs dword ptr [edi],dword ptr [esi]
;
; move the remaining tail
;
mov ecx, dword ptr [bp+12]
and ecx, 3
rep movs byte ptr [edi],byte ptr [esi]
assume es:nothing, ds:DGROUP
pop es
pop ds
leave
ret
_MoveMemory endp
;++
;
; _ZeroMemory
;
; Routine Description
;
; Writes zeros into memory at the target address.
;
; Arguments
;
; (TOS+4) = linear address of target
; (TOS+8) = number of bytes to zero
;
; Notes
;
; 1) Valid page table entries must already exist for the
; source and destination memory.
;
; 2) ALL memory in the lower one megabyte is assumed to
; be identity mapped if used.
;
; USES ESI, EDI, ECX, FLAGS
;
;
;--
public _ZeroMemory
_ZeroMemory proc near
enter 0,0
push es
;
; Get source, destination, and count arguments from the stack
; Make "count" the number of dwords to move.
;
mov edi,dword ptr [bp+4]
mov ecx,dword ptr [bp+8]
shr ecx,2
;
; Load FLAT selectors into DS and ES
;
mov ax,KeDataSelector
mov es,ax
xor eax,eax
;
; Zero the the block of data.
;
assume es:FLAT
;
; Zero the dwords
;
cld
rep stos dword ptr [edi]
;
; Zero the remaining bytes
;
mov ecx, dword ptr [bp+8]
and ecx, 3
rep stos byte ptr [edi]
assume es:nothing, ds:DGROUP
pop es
leave
ret
_ZeroMemory endp
;++
;
; Turn Floppy Drive Motor Off
;
;--
public _TurnMotorOff
DriveControlRegister equ 3f2h ; Floppy control register
_TurnMotorOff proc near
mov dx,DriveControlRegister
mov ax,0CH
out dx,al
ret
_TurnMotorOff endp
;
; Note: we do not save and restore the gdt and idt values because they
; cannot change while external services are being used by the OS loader.
; This is because they MUST remain identity mapped until all mode
; switching has ceased.
;
public _RealMode
_RealMode proc near
;
; Switch to real-mode
;
sgdt fword ptr [_GDTregister]
sidt fword ptr [_IDTregister]
push [saveDS] ; push this so we can get to it later
mov ax,SuDataSelector
mov es,ax
mov fs,ax
mov gs,ax
mov eax,cr0
and eax, not (ENABLE_PAGING + PROT_MODE)
mov cr0,eax
;
; flush the pipeline
;
jmp far ptr here
here:
;
; Flush TLB
;
; HACKHACK - We don't know where the page directory is, since it was
; allocated in the osloader. So we don't want to clear out cr3,
; but we DO want to flush the TLB....
;
mov eax,cr3
nop ; Fill - Ensure 13 non-page split
nop ; accesses before CR3 load
nop ; (P6 errata #11 stepping B0)
nop
mov cr3,eax
;
; switch to real mode addressing
;
; N. B. We need to do a far jump rather than a retf, because a retf will not
; reset the access rights to CS properly.
;
db 0EAh ; JMP FAR PTR
dw offset _TEXT:rmode ; 2000:rmode
dw 02000h
rmode:
pop ax
mov ds,ax
mov ss,ax
;
; Stamp video pointers for real-mode use
;
mov si,offset _ScreenStart
mov word ptr [si+2],0b800h
mov si,offset _vp
mov word ptr [si+2],0b800h
;
; re-enable interrups
;
lidt fword ptr [_IDTregisterZero]
;
; Re-enable interrupts
;
sti
ret
_RealMode endp
;** _TransferToLoader - transfer control the the OS loader
;
;
; Arguments:
;
; None
;
; Returns:
;
; Does not return
;
;**
public _TransferToLoader
_TransferToLoader proc near
; generates a double fault for debug purposes
; mov sp,0
; push 0
mov ebx,dword ptr [esp+2] ; get entrypoint arg
xor eax,eax
mov ax,[saveDS]
;
; Setup OS loader's stack. Compute FLAT model esp to id map to
; original stack.
;
mov cx,KeDataSelector
mov ss,cx
mov esp,LOADER_STACK
;
; Load ds and es with kernel's data selectors
;
mov ds,cx
mov es,cx
;
; Setup pointer to file system and boot context records
;
; Make a linear pointer to the Boot Context Record
shl eax,4
xor ecx,ecx
mov cx,offset _BootRecord
add eax,ecx
push eax
push 1010h ; dummy return address.
push 1010h ; dummy return address.
;
; Push 48bit address of loader entry-point
;
db OVERRIDE
push KeCodeSelector
push ebx
;
; Pass control to the OS loader
;
db OVERRIDE
retf
_TransferToLoader endp
;++
; Description:
;
; Gets memory block sizes for memory from zero to one meg and
; from one meg to 64 meg. We do this by calling int 12h
; (get conventional memory size) and int 15h function 88h (get
; extended memory size).
;
; Arguments:
;
; None
;
; Returns:
;
; USHORT - Size of usable memory (in pages)
;
;--
public _IsaConstructMemoryDescriptors
BmlTotal equ [bp-4]
Func88Result equ [bp-6]
_IsaConstructMemoryDescriptors proc near
push bp ; save ebp
mov bp, sp
sub sp, 6
;
; Initialize the MemoryList to start with a zero entry. (end-of-list)
;
les si, dword ptr _MemoryDescriptorList
xor eax,eax
mov es:[si].BlockSize,eax
mov es:[si].BlockBase,eax
;
; Get conventional (below one meg) memory size
;
push es
push si
int 12h
movzx eax,ax
;
; EAX is the number of 1k blocks, which we need to convert to the
; number of bytes.
;
shl eax,10
push eax
shr eax, 12
mov BmlTotal, eax
xor eax,eax
push eax
call _InsertDescriptor
add sp,8
;
; Get extended memory size and fill-in the second descriptor
;
mov ah,88h
int 15h
mov Func88Result,ax
and eax,0ffffh
;
; EAX is the number of 1k blocks, which we need to convert to the
; number of bytes.
;
shl eax,10
push eax
shr eax,12
add BmlTotal, ax
mov eax,0100000h
push eax
call _InsertDescriptor
add sp,8
;
; Try function E801, see if that is supported on this machine
;
mov ax,0E801h
int 15h
jc short Isa50
cmp ax,Func88Result ; Is extended memory same as 88?
je short Isa40 ; Yes, go add the rest
cmp ax, (16-1) * 1024 ; Is extended memory exactly 16MB?
jne short Isa50 ; No, conflict between 88 & E801
Isa40:
;
; Function looks like it worked
;
; AX = extended memory < 16M in 1k blocks
; BX = extended memory > 16M in 64k blocks
;
and ebx,0ffffh
jz short Isa50
shl ebx,16 ; ebx = memory > 16M in bytes (via E801)
add ebx, 16*1024*1024 ; ebx = end of memory in bytes (via E801)
mov ax, Func88Result
and eax,0ffffh
shl eax, 10 ; eax = memory > 1M in bytes (via 88)
add eax, 1*1024*1024 ; eax = end of memory in bytes (via 88)
sub ebx, eax ; ebx = memory above eax
jbe short Isa50 ; if ebx <= eax, done
push ebx
shr ebx,12
add BmlTotal, bx
push eax
call _InsertDescriptor
add sp,8
and eax,0ffffh
Isa50:
pop si
pop es
mov eax, BmlTotal
mov sp, bp
pop bp
ret
_IsaConstructMemoryDescriptors endp
;++
;
; BOOLEAN
; Int15E820 (
; E820Frame *Frame
; );
;
;
; Description:
;
; Gets address range descriptor by calling int 15 function E820h.
;
; Arguments:
;
; Returns:
;
; BOOLEAN - failed or succeed.
;
;--
cmdpFrame equ [bp + 6]
public _Int15E820
_Int15E820 proc near
push ebp
mov bp, sp
mov bp, cmdpFrame ; (bp) = Frame
push es
push edi
push esi
push ebx
push ss
pop es
mov ebx, [bp].Key
mov ecx, [bp].DescSize
lea di, [bp].BaseAddrLow
mov eax, 0E820h
mov edx, 'SMAP' ; (edx) = signature
INT 15h
mov [bp].Key, ebx ; update callers ebx
mov [bp].DescSize, ecx ; update callers size
sbb ecx, ecx ; ecx = -1 if carry, else 0
sub eax, 'SMAP' ; eax = 0 if signature matched
or ecx, eax
mov [bp].ErrorFlag, ecx ; return 0 or non-zero
pop ebx
pop esi
pop edi
pop es
pop ebp
ret
_Int15E820 endp
_TEXT ends
end Start
Reference in a new issue Copy permalink