mirror of
https://github.com/reactos/reactos.git
synced 2024-09-18 08:42:34 +00:00
527f2f9057
* Create a branch for some evul shell experiments. svn path=/branches/shell-experiments/; revision=61927
1086 lines
27 KiB
ArmAsm
1086 lines
27 KiB
ArmAsm
/*
|
|
* COPYRIGHT: See COPYING in the top level directory
|
|
* PROJECT: ReactOS Bootsector for ISO file system
|
|
* FILE:
|
|
* PURPOSE:
|
|
* PROGRAMMERS: ?
|
|
*/
|
|
|
|
/* INCLUDES ******************************************************************/
|
|
|
|
#include <asm.inc>
|
|
#include "../freeldr/include/arch/pc/x86common.h"
|
|
|
|
.code16
|
|
|
|
// ****************************************************************************
|
|
//
|
|
// isolinux.asm
|
|
//
|
|
// A program to boot Linux kernels off a CD-ROM using the El Torito
|
|
// boot standard in "no emulation" mode, making the entire filesystem
|
|
// available. It is based on the SYSLINUX boot loader for MS-DOS
|
|
// floppies.
|
|
//
|
|
// Copyright (C) 1994-2001 H. Peter Anvin
|
|
//
|
|
// This program is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,
|
|
// USA; either version 2 of the License, or (at your option) any later
|
|
// version; incorporated herein by reference.
|
|
//
|
|
// ****************************************************************************
|
|
//
|
|
// THIS FILE IS A MODIFIED VERSION OF ISOLINUX.ASM
|
|
// MODIFICATION DONE BY MICHAEL K TER LOUW
|
|
// LAST UPDATED 3-9-2002
|
|
// SEE "COPYING" FOR INFORMATION ABOUT THE LICENSE THAT APPLIES TO THIS RELEASE
|
|
//
|
|
// ****************************************************************************
|
|
//
|
|
// This file is a modified version of ISOLINUX.ASM.
|
|
// Modification done by Eric Kohl
|
|
// Last update 04-25-2002
|
|
//
|
|
// ****************************************************************************
|
|
|
|
//#define DEBUG_MESSAGES /* Uncomment to get debugging messages */
|
|
#ifndef ROS_REGTEST
|
|
#define WAIT_FOR_KEY
|
|
#endif
|
|
|
|
// ****************************************************************************
|
|
// BEGIN THE BIOS/CODE/DATA SEGMENT
|
|
// ****************************************************************************
|
|
serial_base = HEX(0400) // Base addresses for 4 serial ports (4 words)
|
|
BIOS_fbm = HEX(0413) // Free Base Memory (kilobytes) (1 word)
|
|
BIOS_timer = HEX(046C) // Timer ticks (1 word)
|
|
BIOS_magic = HEX(0472) // BIOS reset magic (1 word)
|
|
BIOS_vidrows = HEX(0484) // Number of screen rows (1 byte)
|
|
|
|
// Memory below this point is reserved for the BIOS and the MBR
|
|
trackbuf = HEX(1000) // Track buffer goes here (8192 bytes)
|
|
trackbufsize = 8192 // trackbuf ends at 3000h
|
|
|
|
// struct open_file_t
|
|
file_sector = 0 // Sector pointer (0 = structure free)
|
|
file_left = 4 // Number of sectors left
|
|
|
|
//struct dir_t
|
|
dir_lba = 0 // Directory start (LBA)
|
|
dir_len = 4 // Length in bytes
|
|
dir_clust = 8 // Length in clusters
|
|
|
|
#define dir_t_size 12
|
|
#define open_file_t_size 8
|
|
|
|
MAX_OPEN_LG2 = 2 // log2(Max number of open files)
|
|
MAX_OPEN = 4
|
|
SECTORSIZE_LG2 = 11 // 2048 bytes/sector (El Torito requirement)
|
|
SECTORSIZE = 2048
|
|
retry_count = 6 // How patient are we with the BIOS?
|
|
|
|
/******************************************************************************/
|
|
absolute HEX(5000) // Here we keep our BSS stuff
|
|
|
|
resb DriveNo, 1 // CD-ROM BIOS drive number (BYTE)
|
|
resb DiskError, 1 // Error code for disk I/O (BYTE)
|
|
resb RetryCount, 1 // Used for disk access retries (BYTE)
|
|
resb TimeoutCount, 1 // Timeout counter (BYTE)
|
|
resb ISOFlags, 1 // Flags for ISO directory search (BYTE)
|
|
resb RootDir, dir_t_size // Root directory (dir_t_size BYTES)
|
|
resb CurDir, dir_t_size // Current directory (dir_t_size BYTES)
|
|
resb ISOFileName, 64 // ISO filename canonicalization buffer
|
|
resb ISOFileNameEnd, 1
|
|
|
|
//align open_file_t_size
|
|
absolute HEX(5060)
|
|
resb Files, (MAX_OPEN * open_file_t_size)
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
|
|
start:
|
|
cli // Disable interrupts
|
|
xor ax, ax // ax = segment zero
|
|
mov ss, ax // Initialize stack segment
|
|
mov sp, offset start // Set up stack
|
|
mov ds, ax // Initialize other segment registers
|
|
mov es, ax
|
|
mov fs, ax
|
|
mov gs, ax
|
|
sti // Enable interrupts
|
|
cld // Increment pointers
|
|
|
|
mov cx, 2048 / 4 // Copy the bootsector
|
|
mov si, HEX(7C00) // from 0000:7C00
|
|
mov di, HEX(7000) // to 0000:7000
|
|
rep movsd // copy the program
|
|
|
|
ljmp16 0, relocate // jump into relocated code
|
|
|
|
relocate:
|
|
#ifdef DEBUG_MESSAGES
|
|
// Display the banner and copyright
|
|
mov si, offset isolinux_banner // si points to hello message
|
|
call writestr // display the message
|
|
mov si, offset copyright_str
|
|
call writestr
|
|
#endif
|
|
|
|
// Make sure the keyboard buffer is empty
|
|
call pollchar_and_empty
|
|
|
|
// Check for MBR on harddisk
|
|
pusha
|
|
mov ax, HEX(0201)
|
|
mov dx, HEX(0080)
|
|
mov cx, HEX(0001)
|
|
mov bx, trackbuf
|
|
int HEX(13)
|
|
popa
|
|
jc .boot_cdrom // could not read hdd
|
|
|
|
push ax
|
|
#ifdef ROS_REGTEST // this change is taken from the original isobtrt.asm
|
|
mov ax, word ptr ds:[trackbuf+510]
|
|
#else
|
|
mov ax, word ptr ds:[trackbuf]
|
|
#endif
|
|
cmp ax, 0
|
|
je .boot_cdrom // no boot sector found (hopefully there are no weird bootsectors which begin with 0)
|
|
pop ax
|
|
|
|
#ifdef WAIT_FOR_KEY
|
|
// Display the 'Press key' message and wait for a maximum of 5 seconds
|
|
call crlf
|
|
mov si, offset presskey_msg // si points to 'Press key' message
|
|
call writestr // display the message
|
|
|
|
mov byte ptr ds:[TimeoutCount], 5
|
|
.next_second:
|
|
mov eax, ds:[BIOS_timer] // load current tick counter
|
|
add eax, 19
|
|
|
|
.poll_again:
|
|
call pollchar_and_empty
|
|
jnz .boot_cdrom
|
|
|
|
mov ebx, ds:[BIOS_timer]
|
|
cmp eax, ebx
|
|
jnz .poll_again
|
|
|
|
mov si, offset dot_msg // print '.'
|
|
call writestr
|
|
dec byte ptr ds:[TimeoutCount] // decrement timeout counter
|
|
jz .boot_harddisk
|
|
jmp .next_second
|
|
#endif
|
|
|
|
.boot_harddisk:
|
|
call crlf
|
|
|
|
// Boot first harddisk (drive 0x80)
|
|
mov ax, HEX(0201)
|
|
mov dx, HEX(0080)
|
|
mov cx, HEX(0001)
|
|
mov bx, HEX(7C00)
|
|
int HEX(13)
|
|
jnc .go_hd
|
|
jmp kaboom
|
|
.go_hd:
|
|
mov ax, cs
|
|
mov ds, ax
|
|
mov es, ax
|
|
mov fs, ax
|
|
mov gs, ax
|
|
mov dx, HEX(0080)
|
|
|
|
ljmp16 0, HEX(7C00)
|
|
|
|
.boot_cdrom:
|
|
#ifdef WAIT_FOR_KEY
|
|
call crlf
|
|
call crlf
|
|
#endif
|
|
|
|
// Save and display the boot drive number
|
|
mov byte ptr ds:[DriveNo], dl
|
|
#ifdef DEBUG_MESSAGES
|
|
mov si, offset startup_msg
|
|
call writemsg
|
|
mov al, dl
|
|
call writehex2
|
|
call crlf
|
|
#endif
|
|
|
|
// Now figure out what we're actually doing
|
|
// Note: use passed-in DL value rather than 7Fh because
|
|
// at least some BIOSes will get the wrong value otherwise
|
|
mov ax, HEX(4B01) // Get disk emulation status
|
|
mov dl, byte ptr ds:[DriveNo]
|
|
mov si, offset spec_packet
|
|
int HEX(13)
|
|
jc spec_query_failed // Shouldn't happen (BIOS bug)
|
|
mov dl, byte ptr ds:[DriveNo]
|
|
cmp byte ptr ds:[sp_drive], dl // Should contain the drive number
|
|
jne spec_query_failed
|
|
|
|
#ifdef DEBUG_MESSAGES
|
|
mov si, offset spec_ok_msg
|
|
call writemsg
|
|
mov al, byte ptr ds:[sp_drive]
|
|
call writehex2
|
|
call crlf
|
|
#endif
|
|
|
|
found_drive:
|
|
// Get drive information
|
|
mov ah, HEX(48)
|
|
mov dl, byte ptr ds:[DriveNo]
|
|
mov si, offset drive_params
|
|
int HEX(13)
|
|
jnc params_ok
|
|
|
|
// mov si, nosecsize_msg No use in reporting this
|
|
// call writemsg
|
|
|
|
params_ok:
|
|
// Check for the sector size (should be 2048, but
|
|
// some BIOSes apparently think we're 512-byte media)
|
|
//
|
|
// FIX: We need to check what the proper behaviour
|
|
// is for getlinsec when the BIOS thinks the sector
|
|
// size is 512!!! For that, we need such a BIOS, though...
|
|
#ifdef DEBUG_MESSAGES
|
|
mov si, offset secsize_msg
|
|
call writemsg
|
|
mov ax, word ptr ds:[dp_secsize]
|
|
call writehex4
|
|
call crlf
|
|
#endif
|
|
|
|
|
|
//
|
|
// Clear Files structures
|
|
//
|
|
mov di, Files
|
|
mov cx, (MAX_OPEN*open_file_t_size)/4
|
|
xor eax, eax
|
|
rep stosd
|
|
|
|
//
|
|
// Now, we need to sniff out the actual filesystem data structures.
|
|
// mkisofs gave us a pointer to the primary volume descriptor
|
|
// (which will be at 16 only for a single-session disk!); from the PVD
|
|
// we should be able to find the rest of what we need to know.
|
|
//
|
|
get_fs_structures:
|
|
mov eax, 16 // Primary Volume Descriptor (sector 16)
|
|
mov bx, trackbuf
|
|
call getonesec
|
|
|
|
mov eax, dword ptr ds:[trackbuf+156+2]
|
|
mov dword ptr ds:[RootDir+dir_lba],eax
|
|
mov dword ptr ds:[CurDir+dir_lba],eax
|
|
#ifdef DEBUG_MESSAGES
|
|
mov si, offset rootloc_msg
|
|
call writemsg
|
|
call writehex8
|
|
call crlf
|
|
#endif
|
|
|
|
mov eax, dword ptr ds:[trackbuf+156+10]
|
|
mov dword ptr ds:[RootDir+dir_len],eax
|
|
mov dword ptr ds:[CurDir+dir_len],eax
|
|
#ifdef DEBUG_MESSAGES
|
|
mov si, offset rootlen_msg
|
|
call writemsg
|
|
call writehex8
|
|
call crlf
|
|
#endif
|
|
add eax,SECTORSIZE-1
|
|
shr eax,SECTORSIZE_LG2
|
|
mov dword ptr ds:[RootDir+dir_clust],eax
|
|
mov dword ptr ds:[CurDir+dir_clust],eax
|
|
#ifdef DEBUG_MESSAGES
|
|
mov si, offset rootsect_msg
|
|
call writemsg
|
|
call writehex8
|
|
call crlf
|
|
#endif
|
|
|
|
// Look for the "REACTOS" directory, and if found,
|
|
// make it the current directory instead of the root
|
|
// directory.
|
|
mov di, offset isolinux_dir
|
|
mov al, 2 // Search for a directory
|
|
call searchdir_iso
|
|
jnz .dir_found
|
|
mov si, offset no_dir_msg
|
|
call writemsg
|
|
jmp kaboom
|
|
|
|
.dir_found:
|
|
mov dword ptr ds:[CurDir+dir_len],eax
|
|
mov eax, dword ptr ds:[si+file_left]
|
|
mov dword ptr ds:[CurDir+dir_clust],eax
|
|
xor eax,eax // Free this file pointer entry
|
|
xchg eax,dword ptr ds:[si+file_sector]
|
|
mov dword ptr ds:[CurDir+dir_lba],eax
|
|
|
|
|
|
mov di, offset isolinux_bin // di points to Isolinux filename
|
|
call searchdir // look for the file
|
|
jnz .isolinux_opened // got the file
|
|
mov si, offset no_isolinux_msg // si points to error message
|
|
call writemsg // display the message
|
|
jmp kaboom // fail boot
|
|
|
|
.isolinux_opened:
|
|
mov di, si // save file pointer
|
|
|
|
#ifdef DEBUG_MESSAGES
|
|
mov si, offset filelen_msg
|
|
call writemsg
|
|
call writehex8
|
|
call crlf
|
|
#endif
|
|
|
|
mov ecx, eax // calculate sector count
|
|
shr ecx, 11
|
|
test eax, HEX(7FF)
|
|
jz .full_sector
|
|
inc ecx
|
|
.full_sector:
|
|
|
|
#ifdef DEBUG_MESSAGES
|
|
mov eax, ecx
|
|
mov si, offset filesect_msg
|
|
call writemsg
|
|
call writehex8
|
|
call crlf
|
|
#endif
|
|
|
|
// use high segment, as some bios can fail, when offset is too big
|
|
mov bx, FREELDR_BASE / 16 // es = load segment
|
|
mov es, bx
|
|
xor ebx, ebx // bx = load offset
|
|
mov si, di // restore file pointer
|
|
mov cx, HEX(0FFFF) // load the whole file
|
|
call getfssec // get the whole file
|
|
|
|
#ifdef DEBUG_MESSAGES
|
|
mov si, offset startldr_msg
|
|
call writemsg
|
|
call crlf
|
|
#endif
|
|
|
|
mov dl, byte ptr ds:[DriveNo] // dl = boot drive
|
|
mov dh, 0 // dh = boot partition
|
|
|
|
/* Transfer execution to the bootloader */
|
|
ljmp16 0, FREELDR_BASE
|
|
|
|
//
|
|
// searchdir:
|
|
//
|
|
// Open a file
|
|
//
|
|
// On entry:
|
|
// DS:DI = filename
|
|
// If successful:
|
|
// ZF clear
|
|
// SI = file pointer
|
|
// DX:AX or EAX = file length in bytes
|
|
// If unsuccessful
|
|
// ZF set
|
|
//
|
|
|
|
//
|
|
// searchdir_iso is a special entry point for ISOLINUX only. In addition
|
|
// to the above, searchdir_iso passes a file flag mask in AL. This is useful
|
|
// for searching for directories.
|
|
//
|
|
alloc_failure:
|
|
xor ax,ax // ZF <- 1
|
|
ret
|
|
|
|
searchdir:
|
|
xor al, al
|
|
searchdir_iso:
|
|
mov byte ptr ds:[ISOFlags],al
|
|
call allocate_file // Temporary file structure for directory
|
|
jnz alloc_failure
|
|
push es
|
|
push ds
|
|
pop es // ES = DS
|
|
mov si, offset CurDir
|
|
cmp byte ptr ds:[di], 92 //'\' // If filename begins with slash
|
|
jne .not_rooted
|
|
inc di // Skip leading slash
|
|
mov si, offset RootDir // Reference root directory instead
|
|
.not_rooted:
|
|
mov eax, dword ptr ds:[si+dir_clust]
|
|
mov dword ptr ds:[bx+file_left],eax
|
|
mov eax,dword ptr ds:[si+dir_lba]
|
|
mov dword ptr ds:[bx+file_sector],eax
|
|
mov edx,dword ptr ds:[si+dir_len]
|
|
|
|
.look_for_slash:
|
|
mov ax,di
|
|
.scan:
|
|
mov cl, byte ptr ds:[di]
|
|
inc di
|
|
and cl,cl
|
|
jz .isfile
|
|
cmp cl, 92 // '\'
|
|
jne .scan
|
|
mov byte ptr ds:[di-1], 0 // Terminate at directory name
|
|
mov cl,2 // Search for directory
|
|
xchg cl, byte ptr ds:[ISOFlags]
|
|
push di
|
|
push cx
|
|
push offset .resume // Where to "return" to
|
|
push es
|
|
.isfile:
|
|
xchg ax,di
|
|
|
|
.getsome:
|
|
// Get a chunk of the directory
|
|
mov si,trackbuf
|
|
pushad
|
|
xchg bx,si
|
|
mov cx,1 // load one sector
|
|
call getfssec
|
|
popad
|
|
|
|
.compare:
|
|
movzx eax, byte ptr ds:[si] // Length of directory entry
|
|
cmp al, 33
|
|
jb .next_sector
|
|
mov cl, byte ptr ds:[si+25]
|
|
xor cl, byte ptr ds:[ISOFlags]
|
|
test cl, HEX(8E) // Unwanted file attributes!
|
|
jnz .not_file
|
|
pusha
|
|
movzx cx, byte ptr ds:[si+32] // File identifier length
|
|
add si, 33 // File identifier offset
|
|
call iso_compare_names
|
|
popa
|
|
je .success
|
|
.not_file:
|
|
sub edx, eax // Decrease bytes left
|
|
jbe .failure
|
|
add si, ax // Advance pointer
|
|
|
|
.check_overrun:
|
|
// Did we finish the buffer?
|
|
cmp si, trackbuf+trackbufsize
|
|
jb .compare // No, keep going
|
|
|
|
jmp .getsome // Get some more directory
|
|
|
|
.next_sector:
|
|
// Advance to the beginning of next sector
|
|
lea ax, [si+SECTORSIZE-1]
|
|
and ax, not (SECTORSIZE-1)
|
|
sub ax, si
|
|
jmp .not_file // We still need to do length checks
|
|
|
|
.failure:
|
|
#ifdef DEBUG_MESSAGES
|
|
mov si, offset findfail_msg
|
|
call writemsg
|
|
call crlf
|
|
#endif
|
|
xor eax, eax // ZF = 1
|
|
mov dword ptr ds:[bx+file_sector], eax
|
|
pop es
|
|
ret
|
|
|
|
.success:
|
|
mov eax, dword ptr ds:[si+2] // Location of extent
|
|
mov dword ptr ds:[bx+file_sector], eax
|
|
mov eax, dword ptr ds:[si+10] // Data length
|
|
push eax
|
|
add eax, SECTORSIZE-1
|
|
shr eax, SECTORSIZE_LG2
|
|
mov dword ptr ds:[bx+file_left], eax
|
|
pop eax
|
|
mov edx, eax
|
|
shr edx, 16
|
|
and bx, bx // ZF = 0
|
|
mov si, bx
|
|
pop es
|
|
ret
|
|
|
|
.resume:
|
|
// We get here if we were only doing part of a lookup
|
|
// This relies on the fact that .success returns bx == si
|
|
xchg edx, eax // Directory length in edx
|
|
pop cx // Old ISOFlags
|
|
pop di // Next filename pointer
|
|
|
|
// restore the backslash in the filename
|
|
mov byte ptr ds:[di-1], 92 // '\'
|
|
|
|
mov byte ptr ds:[ISOFlags], cl // Restore the flags
|
|
jz .failure // Did we fail? If so fail for real!
|
|
jmp .look_for_slash // Otherwise, next level
|
|
|
|
//
|
|
// allocate_file: Allocate a file structure
|
|
//
|
|
// If successful:
|
|
// ZF set
|
|
// BX = file pointer
|
|
// In unsuccessful:
|
|
// ZF clear
|
|
//
|
|
allocate_file:
|
|
push cx
|
|
mov bx, Files
|
|
mov cx, MAX_OPEN
|
|
.check:
|
|
cmp dword ptr ds:[bx], 0
|
|
je .found
|
|
add bx, open_file_t_size // ZF = 0
|
|
loop .check
|
|
// ZF = 0 if we fell out of the loop
|
|
.found:
|
|
pop cx
|
|
ret
|
|
|
|
//
|
|
// iso_compare_names:
|
|
// Compare the names DS:SI and DS:DI and report if they are
|
|
// equal from an ISO 9660 perspective. SI is the name from
|
|
// the filesystem; CX indicates its length, and ';' terminates.
|
|
// DI is expected to end with a null.
|
|
//
|
|
// Note: clobbers AX, CX, SI, DI; assumes DS == ES == base segment
|
|
//
|
|
iso_compare_names:
|
|
// First, terminate and canonicalize input filename
|
|
push di
|
|
mov di, offset ISOFileName
|
|
.canon_loop:
|
|
jcxz .canon_end
|
|
lodsb
|
|
dec cx
|
|
cmp al, ';'
|
|
je .canon_end
|
|
and al, al
|
|
je .canon_end
|
|
stosb
|
|
cmp di, offset ISOFileNameEnd-1 // Guard against buffer overrun
|
|
jb .canon_loop
|
|
.canon_end:
|
|
cmp di, ISOFileName
|
|
jbe .canon_done
|
|
cmp byte ptr ds:[di-1], '.' // Remove terminal dots
|
|
jne .canon_done
|
|
dec di
|
|
jmp short .canon_end
|
|
.canon_done:
|
|
mov byte ptr ds:[di], 0 // Null-terminate string
|
|
pop di
|
|
mov si, ISOFileName
|
|
.compare2:
|
|
lodsb
|
|
mov ah, byte ptr ds:[di]
|
|
inc di
|
|
and ax, ax
|
|
jz .success2 // End of string for both
|
|
and al, al // Is either one end of string?
|
|
jz .failure2 // If so, failure
|
|
and ah, ah
|
|
jz .failure2
|
|
or ax, HEX(2020) // Convert to lower case
|
|
cmp al, ah
|
|
je .compare2
|
|
.failure2:
|
|
and ax, ax // ZF = 0 (at least one will be nonzero)
|
|
.success2:
|
|
ret
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// getfssec: Get multiple clusters from a file, given the file pointer.
|
|
//
|
|
// On entry:
|
|
// ES:BX -> Buffer
|
|
// SI -> File pointer
|
|
// CX -> Cluster count; 0FFFFh = until end of file
|
|
// On exit:
|
|
// SI -> File pointer (or 0 on EOF)
|
|
// CF = 1 -> Hit EOF
|
|
//
|
|
getfssec:
|
|
cmp cx, word ptr ds:[si+file_left]
|
|
jna .ok_size
|
|
mov cx, word ptr ds:[si+file_left]
|
|
|
|
.ok_size:
|
|
mov bp, cx
|
|
push cx
|
|
push si
|
|
mov eax, dword ptr ds:[si+file_sector]
|
|
call getlinsec
|
|
xor ecx, ecx
|
|
pop si
|
|
pop cx
|
|
|
|
add dword ptr ds:[si+file_sector], ecx
|
|
sub dword ptr ds:[si+file_left], ecx
|
|
ja .not_eof // CF = 0
|
|
|
|
xor ecx, ecx
|
|
mov dword ptr ds:[si+file_sector], ecx // Mark as unused
|
|
xor si,si
|
|
stc
|
|
|
|
.not_eof:
|
|
ret
|
|
|
|
|
|
// INT 13h, AX=4B01h, DL=<passed in value> failed.
|
|
// Try to scan the entire 80h-FFh from the end.
|
|
spec_query_failed:
|
|
mov si, offset spec_err_msg
|
|
call writemsg
|
|
|
|
mov dl, HEX(0FF)
|
|
.test_loop:
|
|
pusha
|
|
mov ax, HEX(4B01)
|
|
mov si, offset spec_packet
|
|
mov byte ptr ds:[si], 13 // Size of buffer
|
|
int HEX(13)
|
|
popa
|
|
jc .still_broken
|
|
|
|
mov si, offset maybe_msg
|
|
call writemsg
|
|
mov al, dl
|
|
call writehex2
|
|
call crlf
|
|
|
|
cmp byte ptr ds:[sp_drive], dl
|
|
jne .maybe_broken
|
|
|
|
// Okay, good enough...
|
|
mov si, offset alright_msg
|
|
call writemsg
|
|
mov byte ptr ds:[DriveNo], dl
|
|
.found_drive:
|
|
jmp found_drive
|
|
|
|
// Award BIOS 4.51 apparently passes garbage in sp_drive,
|
|
// but if this was the drive number originally passed in
|
|
// DL then consider it "good enough"
|
|
.maybe_broken:
|
|
cmp byte ptr ds:[DriveNo], dl
|
|
je .found_drive
|
|
|
|
.still_broken:
|
|
dec dx
|
|
cmp dl, HEX(80)
|
|
jnb .test_loop
|
|
|
|
fatal_error:
|
|
mov si, offset nothing_msg
|
|
call writemsg
|
|
|
|
.norge:
|
|
jmp .norge
|
|
|
|
|
|
|
|
// Information message (DS:SI) output
|
|
// Prefix with "isolinux: "
|
|
writemsg:
|
|
push ax
|
|
push si
|
|
mov si, offset isolinux_str
|
|
call writestr
|
|
pop si
|
|
call writestr
|
|
pop ax
|
|
ret
|
|
|
|
//
|
|
// crlf: Print a newline
|
|
crlf:
|
|
mov si, offset crlf_msg
|
|
// Fall through
|
|
|
|
//
|
|
// writestr: write a null-terminated string to the console, saving
|
|
// registers on entry.
|
|
//
|
|
writestr:
|
|
pushfd
|
|
pushad
|
|
writestr_top:
|
|
lodsb
|
|
and al, al
|
|
jz writestr_end
|
|
call writechr
|
|
jmp short writestr_top
|
|
writestr_end:
|
|
popad
|
|
popfd
|
|
ret
|
|
|
|
//
|
|
// writehex[248]: Write a hex number in (AL, AX, EAX) to the console
|
|
//
|
|
writehex2:
|
|
pushfd
|
|
pushad
|
|
shl eax, 24
|
|
mov cx, 2
|
|
jmp short writehex_common
|
|
writehex4:
|
|
pushfd
|
|
pushad
|
|
shl eax, 16
|
|
mov cx, 4
|
|
jmp short writehex_common
|
|
writehex8:
|
|
pushfd
|
|
pushad
|
|
mov cx, 8
|
|
writehex_common:
|
|
.loop:
|
|
rol eax, 4
|
|
push eax
|
|
and al, HEX(0F)
|
|
cmp al, 10
|
|
jae .high
|
|
.low:
|
|
add al, '0'
|
|
jmp short .ischar
|
|
.high:
|
|
add al, 'A'-10
|
|
.ischar:
|
|
call writechr
|
|
pop eax
|
|
loop .loop
|
|
popad
|
|
popfd
|
|
ret
|
|
|
|
//
|
|
// writechr: Write a character to the screen. There is a more "sophisticated"
|
|
// version of this in the subsequent code, so we patch the pointer
|
|
// when appropriate.
|
|
writechr:
|
|
pushfd
|
|
pushad
|
|
mov ah, HEX(0E)
|
|
xor bx, bx
|
|
int HEX(10)
|
|
popad
|
|
popfd
|
|
ret
|
|
|
|
//
|
|
// Get one sector. Convenience entry point.
|
|
//
|
|
getonesec:
|
|
mov bp, 1
|
|
// Fall through to getlinsec
|
|
|
|
//
|
|
// Get linear sectors - EBIOS LBA addressing, 2048-byte sectors.
|
|
//
|
|
// Note that we can't always do this as a single request, because at least
|
|
// Phoenix BIOSes has a 127-sector limit. To be on the safe side, stick
|
|
// to 32 sectors (64K) per request.
|
|
//
|
|
// Input:
|
|
// EAX - Linear sector number
|
|
// ES:BX - Target buffer
|
|
// BP - Sector count
|
|
//
|
|
getlinsec:
|
|
push es // save es, we reset it later to 0
|
|
|
|
mov si, offset dapa // Load up the DAPA
|
|
mov word ptr ds:[si+4], bx
|
|
mov bx, es
|
|
mov word ptr ds:[si+6], bx
|
|
xor bx, bx // reset es to 0, some bioses (KVM) require that
|
|
mov es, bx
|
|
mov dword ptr ds:[si+8], eax
|
|
.loop2:
|
|
push bp // Sectors left
|
|
cmp bp, word ptr ds:[MaxTransfer]
|
|
jbe .bp_ok
|
|
mov bp, word ptr ds:[MaxTransfer]
|
|
.bp_ok:
|
|
mov word ptr ds:[si+2], bp
|
|
push si
|
|
mov dl, byte ptr ds:[DriveNo]
|
|
mov ah, HEX(42) // Extended Read
|
|
call xint13
|
|
pop si
|
|
pop bp
|
|
movzx eax,word ptr ds:[si+2] // Sectors we read
|
|
add dword ptr ds:[si+8], eax // Advance sector pointer
|
|
sub bp, ax // Sectors left
|
|
shl ax, SECTORSIZE_LG2-4 // 2048-byte sectors -> segment
|
|
add word ptr ds:[si+6], ax // Advance buffer pointer
|
|
and bp, bp
|
|
jnz .loop2
|
|
mov eax, dword ptr ds:[si+8] // Next sector
|
|
|
|
pop es
|
|
ret
|
|
|
|
// INT 13h with retry
|
|
xint13:
|
|
mov byte ptr ds:[RetryCount], retry_count
|
|
.try:
|
|
pushad
|
|
int HEX(13)
|
|
jc .error
|
|
add sp, 8*4 // Clean up stack
|
|
ret
|
|
.error:
|
|
mov byte ptr ds:[DiskError], ah // Save error code
|
|
popad
|
|
dec byte ptr ds:[RetryCount]
|
|
jz .real_error
|
|
push ax
|
|
mov al, byte ptr ds:[RetryCount]
|
|
mov ah, byte ptr ds:[dapa+2] // Sector transfer count
|
|
cmp al,2 // Only 2 attempts left
|
|
ja .nodanger
|
|
mov ah,1 // Drop transfer size to 1
|
|
jmp short .setsize
|
|
.nodanger:
|
|
cmp al, retry_count-2
|
|
ja .again // First time, just try again
|
|
shr ah,1 // Otherwise, try to reduce
|
|
adc ah,0 // the max transfer size, but not to 0
|
|
.setsize:
|
|
mov byte ptr ds:[MaxTransfer],ah
|
|
mov byte ptr ds:[dapa+2],ah
|
|
.again:
|
|
pop ax
|
|
jmp .try
|
|
|
|
.real_error:
|
|
mov si, offset diskerr_msg
|
|
call writemsg
|
|
mov al, byte ptr ds:[DiskError]
|
|
call writehex2
|
|
mov si, offset ondrive_str
|
|
call writestr
|
|
mov al, dl
|
|
call writehex2
|
|
call crlf
|
|
// Fall through to kaboom
|
|
|
|
//
|
|
// kaboom: write a message and bail out. Wait for a user keypress,
|
|
// then do a hard reboot.
|
|
//
|
|
kaboom:
|
|
mov ax, cs
|
|
mov ds, ax
|
|
mov es, ax
|
|
mov fs, ax
|
|
mov gs, ax
|
|
sti
|
|
mov si, offset err_bootfailed
|
|
call writestr
|
|
xor ax, ax // Wait for keypress
|
|
int HEX(16)
|
|
cli
|
|
mov word ptr ds:[BIOS_magic], 0 // Cold reboot
|
|
ljmp16 HEX(0F000), HEX(0FFF0) // Reset vector address
|
|
|
|
|
|
//
|
|
// pollchar_and_empty: check if we have an input character pending (ZF = 0) and empty the input buffer afterwards
|
|
//
|
|
pollchar_and_empty:
|
|
pushad
|
|
mov ah, 1 // Did the user press a key?
|
|
int HEX(16)
|
|
jz .end // No, then we're done
|
|
mov ah, 0 // Otherwise empty the buffer by reading it
|
|
int HEX(16)
|
|
.end:
|
|
popad
|
|
ret
|
|
|
|
|
|
isolinux_banner:
|
|
.ascii CR, LF, "Loading IsoBoot...", CR, LF, NUL
|
|
copyright_str:
|
|
.ascii " (C) 1994-2002 H. Peter Anvin", CR, LF, NUL
|
|
presskey_msg:
|
|
.ascii "Press any key to boot from CD", NUL
|
|
dot_msg:
|
|
.ascii ".", NUL
|
|
|
|
#ifdef DEBUG_MESSAGES
|
|
startup_msg:
|
|
.ascii "Startup, DL = '", NUL
|
|
spec_ok_msg:
|
|
.ascii "packet OK, drive = ", NUL
|
|
secsize_msg:
|
|
.ascii "size appears to be ", NUL
|
|
rootloc_msg:
|
|
.ascii "Root dir loc: ", NUL
|
|
rootlen_msg:
|
|
.ascii "Root dir len: ", NUL
|
|
rootsect_msg:
|
|
.ascii "Root dir len(sect): ", NUL
|
|
fileloc_msg:
|
|
.ascii "SETUPLDR loc: ", NUL
|
|
filelen_msg:
|
|
.ascii "SETUPLDR len: ", NUL
|
|
filesect_msg:
|
|
.ascii "SETUPLDR len(sect): ", NUL
|
|
findfail_msg:
|
|
.ascii "Failed to find file!", NUL
|
|
startldr_msg:
|
|
.ascii "Starting SETUPLDR.SYS", NUL
|
|
#endif
|
|
|
|
spec_err_msg:
|
|
.ascii "Load spec failed, trying wing ...", CR, LF, NUL
|
|
maybe_msg:
|
|
.ascii "Found smth at drive = ", NUL
|
|
alright_msg:
|
|
.ascii "might be ok, continuing...", CR, LF, NUL
|
|
nothing_msg:
|
|
.ascii "Failed locate CD-ROM; boot failed.", CR, LF, NUL
|
|
|
|
isolinux_str:
|
|
.ascii "IsoBoot: ", NUL
|
|
crlf_msg:
|
|
.ascii CR, LF, NUL
|
|
diskerr_msg:
|
|
.ascii "Disk error ", NUL
|
|
ondrive_str:
|
|
.ascii ", drive ", NUL
|
|
|
|
err_bootfailed:
|
|
.ascii CR, LF, "failed..", NUL
|
|
isolinux_dir:
|
|
.ascii "\\LOADER", NUL
|
|
no_dir_msg:
|
|
.ascii "LOADER dir not found.", CR, LF, NUL
|
|
isolinux_bin:
|
|
.ascii "SETUPLDR.SYS", NUL
|
|
no_isolinux_msg:
|
|
.ascii "SETUPLDR not found.", CR, LF, NUL
|
|
|
|
|
|
//
|
|
// El Torito spec packet
|
|
//
|
|
.align 8
|
|
spec_packet:
|
|
.byte HEX(13) // Size of packet
|
|
sp_media:
|
|
.byte 0 // Media type
|
|
sp_drive:
|
|
.byte 0 // Drive number
|
|
sp_controller:
|
|
.byte 0 // Controller index
|
|
sp_lba:
|
|
.long 0 // LBA for emulated disk image
|
|
sp_devspec:
|
|
.word 0 // IDE/SCSI information
|
|
sp_buffer:
|
|
.word 0 // User-provided buffer
|
|
sp_loadseg:
|
|
.word 0 // Load segment
|
|
sp_sectors:
|
|
.word 0 // Sector count
|
|
sp_chs:
|
|
.byte 0,0,0 // Simulated CHS geometry
|
|
sp_dummy:
|
|
.byte 0 // Scratch, safe to overwrite
|
|
|
|
//
|
|
// EBIOS drive parameter packet
|
|
//
|
|
.align 8
|
|
drive_params:
|
|
.word 30 // Buffer size
|
|
dp_flags:
|
|
.word 0 // Information flags
|
|
dp_cyl:
|
|
.long 0 // Physical cylinders
|
|
dp_head:
|
|
.long 0 // Physical heads
|
|
dp_sec:
|
|
.long 0 // Physical sectors/track
|
|
dp_totalsec:
|
|
.long 0,0 // Total sectors
|
|
dp_secsize:
|
|
.word 0 // Bytes per sector
|
|
dp_dpte:
|
|
.long 0 // Device Parameter Table
|
|
dp_dpi_key:
|
|
.word 0 // 0BEDDh if rest valid
|
|
dp_dpi_len:
|
|
.byte 0 // DPI len
|
|
.byte 0
|
|
.word 0
|
|
dp_bus:
|
|
.byte 0,0,0,0 // Host bus type
|
|
dp_interface:
|
|
.byte 0,0,0,0,0,0,0,0 // Interface type
|
|
db_i_path:
|
|
.long 0,0 // Interface path
|
|
db_d_path:
|
|
.long 0,0 // Device path
|
|
.byte 0
|
|
db_dpi_csum:
|
|
.byte 0 // Checksum for DPI info
|
|
|
|
//
|
|
// EBIOS disk address packet
|
|
//
|
|
.align 8
|
|
dapa:
|
|
.word 16 // Packet size
|
|
.count:
|
|
.word 0 // Block count
|
|
.off:
|
|
.word 0 // Offset of buffer
|
|
.seg:
|
|
.word 0 // Segment of buffer
|
|
.lba:
|
|
.long 0 // LBA (LSW)
|
|
.long 0 // LBA (MSW)
|
|
|
|
.align 4
|
|
MaxTransfer:
|
|
.word 2 //32 // Max sectors per transfer
|
|
|
|
.org 2046 // Pad to file offset 2046
|
|
.word HEX(0aa55) // BootSector signature
|
|
|
|
.endcode16
|
|
|
|
END
|