; Bluebottle Boot Manager
;
; Written by A.L. Fischer using Network Assembler syntax for use with
; the Bluebottle assembler PCAAMD64.Mod
; PCAAMD64.Assemble BootManager.Asm ~
; This Boot Manager uses the int 13h extensions for
; accessing blocks in LBA mode in order to break the 8.4GB barrier,
; if that access method is supported by the BIOS and the hard drive,
; and uses the C-H-S disk access mode otherwise.
; In Oberon, what is otherwise named "sector" is called "block",
; in relation with LBA = Logical Block Address
; The 1st block of a volume is named MBR and that of a partition PBR.
; Reference: BIOS Enhanced Disk Drive Specification
; Version 3.0 - Rev 0.9b - June 24, 1999. Phoenix Technologies Ltd.
; http://www.t13.org/project/d1386r0.pdf
; http://web.inter.nl.net/hcc/J.Steunebrink/bioslim.htm
; 2007-04-13 afi Started
; Adaptation from original BootManager.Asm
; 2007-06-24 afi completed first version
; 2007-11-12 afi converted text from Turbo to Network Assembler
; The date of the current version is located at bmdate and displayed
; in the title line of the boot menu at startup.
; --------------------
; Infrastructure and implementation procedure:
;
; 1 - edit this text
; 2 - assemble by executing: PCAAMD64.Assemble BootManager.Asm ~
; to obtain BootManager.Bin
; 3 - Split BootManager.Bin into BootManagerMBR.Bin and BootManagerTail.Bin
; --------------------
; (0) central combined CHS / LBA support.
; All of it must be located in block with LBA=0 (MBR)
; (1) added for warning when a partition has no valid PBR
; (2) added for using 1 or 2 digits depending on the # of partitions
; Up to 12 partitions per volume can be handled
; (3) added for inspecting the graphic controller capabilities
; incorporated to (15) - previously done with enter 'v'
; procedure inspectvbe
; VESA BIOS Extensions 2.0 (VBE)
; http:www.geocities.com/SiliconValley/Park/8933.vesa.html
; (4) added for collecting disk drive information - proc driveinfo
; (5) added for displaying VBE information or not - now part of (15)
; (6) added for providing a better disk error diagnostic
; as soon as the complete BootManager is loaded
; (7) added for scanning PCI bus
; (8) added for presenting a survey of installed drives
; Nowadays justified by the appearance of external mobile drives
; with USB or Firewire interface resulting in an ever changing
; drive configuration
; (9) was diskette support, now removed
; (10) added for indicating which volume is currently explored (underline)
; (11) void
; (12) was diskette support, now removed
; (13) show drive interface: IDE, FDD, CD-ROM, USB when available
; (14) skip non-accessible (USB) drives
; (15) display PC hardware information - enter 'h' - inspectvbe/inspectpci
; (16) GUI text restructured - not marked in code
; (17) diskette support entirely removed. Presence of FDD now ignored.
; In 2007, PCs are very seldomly equipped with a diskette drive.
; All PCs, without exception support external USB devices having
; many thousand times superior storage capacity.
; If no FDD is installed, it should be disabled in the BIOS setup.
; (18) toggle between 25 (default) and 50 lines on screen - enter 'l'
; (20) announce OS start
; (21) display CPU information with cpuid
; (22) switch/swap the current MBR and that of another volume - enter 's'
; (23) add some persistance to the message line
; (24) display partition sizes
; (25) toggle store/do NOT store selected volume and partition - enter 'b'
; Refer to Dual/Multi Booting With Vista - www.multibooters.co.uk/mbr.html
; --------------------
CPU P4
bits 16
; define filler character
filler: equ 'U' ; Unused byte
; BIOS reads the first physical block (MBR) of the boot device and places
; it into memory at location
biosloc: equ 7c00h
; The initial part of the contained program (up to entry01) has the
; duty of freeing the area at biosloc by relocating it to memory
; at location 0000:0600 (newloc below).
; The rest of the program will read and place the PBR
; at the same location biosloc as if it had been read by the BIOS.
newloc: equ 0600h ; address of the area in which
; the MBR will be relocated
MBRreloc: equ 0200h ; (22) address of the area in
; which the MBR is temporarily saved for a possible swapping
CR: equ 13 ; Carriage Return 0ch
LF: equ 10 ; Line Feed 0ah
blocksize: equ 512 ; bytes per block
signID: equ 0aa55h ; signature
bmLBA: equ 1 ; LBA of stage 2
; Changing bmLBA might be required to locate the bulk of the
; IPL bootmanager elsewhere than immediatly after the MBR
; as is suggested here with the value 1.
; The boot manager is split into two parts:
; - the MBR of the volume: stage1 contained in block LBA=0
; - the rest, comprising bmsize blocks, in a free area of the volume
bmsize: equ 12 ; stage2 size in blocks
; the block with LBA= 12 is used to memorize the last user selection
; defaultd and defaultp
lbalen: equ 21 ; length of an lbalist entry
partlen: equ 16 ; length of a partition entry
; offset (in blocks) of the first partition with respect to the volume beginning
;partoffset: equ 2048 ; on a HD formatted with Vista
;partoffset: equ 63 ; on a HD or USB memory stick
;partoffset: equ 32 ; on a CD-ROM
maxretry: equ 5 ; max. number of read/write retries
; --------------------------------------------------------------------
; LBA 0 - MBR - Master Boot Record
org 0
; WARNING: Do not alter dl until call inspectdisk is over
entry: cli ; disable interrupts
; NOTE: No justification yet for the presence of this "cli" but
; in LILO one can read "NT 4 blows up if this is missing".
xor ax, ax ; clear
mov ss, ax ; set stack segment to 0000
mov sp, biosloc ; set stack pointer
sti ; enable interrupts
push ax ;
pop es ; es now 0000
push ax ;
pop ds ; ds now 0000
cld ; clear direction flag
mov si, biosloc + entry01 ; set si
mov di, newloc + entry01 ; relocation address
push ax ; 0000
push di ; newloc + offset entry01
mov cx, blocksize - (entry01-entry) ; set count
rep movsb ; move MBR from 0000:7c00 to 0000:0600
retf ; jump to 0000:newloc + entry01
entry01: call savembr
mov [newloc + currdrive], dl ; note from which drive it all started
call inspectdisk
; read rest of boot manager - bmsize blocks in one operation
mov bp, newloc + baseadd ; lba = 1 for accessing the 2nd block
call readblock ; read all blocks in one go
mov si, biosloc ; set si
mov di, newloc + blocksize ; relocation address
mov cx, bmsize*blocksize ; set count for bmsize blocks
rep movsb ; move from 0000:7c00 to 0000:0800
; The area extending from entry to this point may be used to store data
; as soon as execution passed this point.
; Imperative condition: it must be at least 3*16 bytes long to contain
; 3 partition table entries of an extended partition - see at isext label
; --------------------------------
; At this point, the entire boot manager is loaded into memory (bmloaded).
; An eventual disk operation error can be diagnosed correctly and
; reported on the display console.
mov [newloc + bmloaded], 1 ; (6) set indicator to TRUE
; Collect the information on the installed drives (drive numbers ordered
; by index) for deciding what to tell the user about the environment
; Takes place only once at the very beginning
call cpuinfo
call driveinfo ; (4)
jmp word newmbr
; Jump to the main processing located at the end of this block .
; All the procedures which appear below and up to the label newmbr
; must imperatively be located within the block with LBA=0 because
; they are all needed for getting the remaining blocks LBA=1 to bmsize
; ===== procedure: read a block with the specified LBA number (0)
; NOTE: (0) starts at label readblock. What comes before is used later
; use the LBA directly or convert that value to CHS
; in : bp = point to lba in table entry
; out : dl = drive number ; bx = data buffer address
readplus:
; has the function of tracing the partition types detected - optional
call info ; info about the current entry, set bp
; Up to maxretry attempts, with at each failed attempt a disk reset.
; The registers are conditioned first to launch an extended read and
; if LBA mode is not supported, a standard read in prepared.
; A discriminator is also placed immediately before the int 13h instruction
; to trim the operation code in ah, al.
readblock: mov di, maxretry ; number of tries
readtry:
; set up dap for an extended read/write 13h disk operation
; the Device Address Packet (dap) is constructed on the fly by pushing
; the parts on the stack.
; the structure of the dap is:
;dap db 10h ; dap size (fixed)
; db 0 ; reserved (fixed)
;num dw bmsize ; number of blocks to transfer (fixed)
;boff dw biosloc ; address of transfer buffer - offset
;bseg dw 0 ; address of transfer buffer - segment
;sec0 dd ? ; starting absolute block address
;sec1 dd 0 ; remaining 32 bits of address
; it is easiest to set up the dap first because the values to assign are
; available straight away.
; a volatile dap has the disadvantage that it must be rebuilt for a read retry
mov ax, word [bp] ; dx:ax = lba number of block to read
mov dx, word [bp+2]
; now leave dx:ax untouched until the next test of the lba indicator !
; NOTE: pushd 0 is an "Illegal instruction" for tasm in 16-bit mode
push byte 0 ; remaining 16 bits
push byte 0 ; remaining 16 bits
; NOTE: push dword [bp] ; starting absolute block address
; replaced by the next 2 lines because ax and dx are set already
push dx
push ax
push es ; address of transfer buffer - segment
push biosloc ; address of transfer buffer - offset
push byte bmsize ; read bmsize blocks (fixed)
push byte 10h ; 00h reserved - DAP is 16 bytes long (fixed)
mov si, sp ; give access to the dap ds:si = dap
; test if the drive supports extended int 13h extensions, i.e. LBA mode
; and trim to standard read if lba is not supported
cmp [newloc + lbaindic], 0 ; test the lba indicator
jne short uselba
; convert lba (dx:ax = lba number of block to read) to CHS values
; see http://homepage2.nifty.com/cars/misc/chs2lba.html
mov bx, word [newloc + blocks] ; blocks per track (spt)
div bx ; remainder in dx (lba MOD spt)
inc dx ; correct block number
mov cx, dx ; move it in cx
xor dx, dx ; clear
; dx:ax = quotient of lba DIV spt
mov bx, word [newloc + heads] ; number of heads
div bx ; remainder in dx
; at this point, the register values are:
; ax = cylinder number
; dx = head number
; cx = block number
; place the obtained values in the registers for the upcoming standard read
mov ch, al ; lsb of cylinder number
shl ah, 6 ; 2 msb of cylinder number
or cl, ah ; merge to form cylinder number
mov dh, dl ; head number
mov bx, biosloc ; data buffer offset
mov ax, 0200h + bmsize ; function 02h, read bmsize blocks
jmp short chsmode
uselba: mov ah, 42h ; ready for extended read
chsmode: mov dl, [newloc + currdrive] ; current drive number
int 13h ; call BIOS
mov [newloc + errcode], ah ; (6) stow the error code away
lea sp, [si + 10h] ; load original offset value in sp
jnc short int13ok ; carry flag not set: success, proceed
; failure is signalled by carry and ah value <> :, perform a disk reset
xor ax, ax ; reset disk system
int 13h ; call BIOS
dec di ; does not clear carry
jnz readtry ; retry counter > 0, retry
cmp [newloc + bmloaded], 0 ; (6)
jne near readerr ; (6) display errormsg with error code
mov si, newloc + errormsg
call writestring ; issue msg - call WILAstring not
; allowed yet (not yet in memory)
; when the attempt to read the rest of the boot manager fails, nothing else
; can be attempted except bringing the machine to a grinding halt !!!
hang: jmp short hang ; halt the system !!! endless loop
int13ok: mov di, biosloc + sign ; point to the signature
; For each block read note the signature
mov ax, word [di] ; (1) get it
mov [newloc + mbrsign], ax ; (1) make a note
; Later on if the block is a PBR its validity will be assessed.
good: ret
; messages
errormsg: db 10,'Disk error ' ; must remain in the 1st block
errorgui: db '??',CR,LF,0 ; (6) errcode translated for GUI
currdrive: db 0h ; current drive # as returned by BIOS in dl
lbaindic: db 0 ; lba indicator: 0 = lba not supported
mbrsign: dw 0 ; (1) mbr signature (55AA)
; saved for TUI
; 3 fields storing data obtained by int 13h, funct 08h (get drive parameters)
; heads and blocks are used to convert an LBA value to CHS
cyls: dw 0 ; number of cylinders
heads: dw 0 ; maximum head number
blocks: dw 0 ; maximum block number
chainadd: dd 0 ; lba of chained extended
flag: db 1fh ; flag/mask for testing bits in the BIOS
; ; shift status byte at address 0040h:0017h
mbrinproc: db 0 ; bit 0 = 1 new mbr being processed,
; force interaction
; bit 7 = 1 write LBA 12 lock
; after having swapped mbr
digindic: db 2 ; (2) no. of digits indic. (1 = one, 2 = two)
bmloaded: db 0 ; (6) bit 0 = 1 bootmanager loaded
errcode: db 0 ; (6) disk operation error code
; ===== procedure: write one character at the current cursor location and
; advance the cursor (display operating in text mode)
; on entry: al = character
; mod: none
writechar:
push ax
; push bx
; NOTE: commented because invalid in text mode. Found everywhere though.
; Setting the attribute in text mode is done as shown in proc setred
; mov bx, 7 ; screen attributes: white text on black bg
mov ah, 0eh ;
int 10h ; display character on the screen
; pop bx
pop ax
ret
; ===== procedure: write a zero-terminated string
; must be located in the MBR to be able to report a disk error (message
; labelled "errormsg") while reading the rest of the boot manager (LBA=1 ...)
; in : si = pointer to zero terminated string
; mod: al,si
writestring:
nxtchar: lodsb ; get char of message
cmp al, 0 ; is end of message ?
jz short finish ; yes
call writechar ; display this character
jmp nxtchar ; proceed to next character
finish: ret
; ===== procedure: inspect the properties of the disk/diskette drives
; with the purpose of finding out if LBA is supported and of determining
; the disk geometry for converting an LBA value to a C-H-S equivalent.
; in : dl = drive number (00h is diskette; 80h, 81h, ... is internal or
; external drives, incl. USB flash memory and others)
; On the first call, the drive number is supplied in dl by BIOS
inspectdisk:
; find out if the drive supports extended int 13h extensions
mov [newloc + lbaindic], 0 ; clear lba indicator
cmp dl, 80h ; is it a hard disk ?
jb short params ; no, lba not applicable to diskette
mov bx, 55aah ; condition next BIOS call
mov ah, 41h ; check extension present
int 13h ; call BIOS
jc short params ; carry, LBA not supported
cmp bx, signID ; confirm lba extensions present
jne short params ; no
test cx, 01h ; fixed disk access subset - is LBA ready ?
jz short params ; no
mov [newloc + lbaindic], cl ; save lba level indicator
ret ; omit what follows
; get number of heads and blocks in view of a needed conversion
; from LBA to CHS in the procedure readblock
; the number of cylinders is evaluated for presenting on the display
; dl has still the correct value
params: push es ; save to protect its value
mov ah, 08h ; get disk drive parameters
int 13h ; call BIOS
xor ax, ax ; clear 16 bits
mov al, dh ; max. # of heads (0-based)
inc ax ; effective # of heads
mov[newloc + heads], ax ; save it
mov al, cl ; number of blocks per track (0 .. 63)
and ax, 3fh ; mask cylinder bits
mov [newloc + blocks], ax ; save number of blocks
xchg ch, cl ; 8 MLB of number of cylinders
shr ch, 6 ; 2 MSB of do.
inc cx
mov [newloc + cyls], cx ; save number of cylinders
pop es ; restore es
ret
; ===== procedure: save the MBR just read in a save area (22)
savembr:
mov si, biosloc ;
mov di, MBRreloc ;
mov cx, blocksize ; (22) set count
rep movsb ; (22) save MBR
ret
; code stretch used for testing and now commented out:
tracesec:
; test code: display the beginning of the block just read
; mov cx, 40 ;
; mov si, biosloc
;disnxt: lodsb ; get char of message
; mov bh, al
; call char2hex ; display this character
; loop disnxt ; proceed to next character
; ret
; The code between the labels newmbr and bmdate may be moved
; to a block with LBA > 0 when more space is needed for essential
; processing which must take place in the MBR (LBA = 0).
; Process the partition table entries of a new MBR
newmbr:
call inspectmbr
mov [newloc + digindic], 2 ; assume 2
mov si, newloc + lbaval ; point to lba in first table entry
; process the four partition table entries of the MBR now relocated
next2: mov ebx, [si] ; note base lba of partition
cmp ebx, byte 0 ; is this entry empty ?
je near donext ; yes, skip entry
cmp [newloc + lbaindic], 0
jne short lbaready ; ignore limit
cmp ebx, 16450560 ; 1024 * 255 * 63
; max. lba value accessible with c-h-s addressing
ja near donext ; cannot access > 8.4GB, skip entry
lbaready: mov [newloc + baseadd], ebx ; save lba of extended partition
mov [newloc + chainadd], ebx ; save lba of chained extended
call addlba ; collect in list
push si
call readplus ; read the corresponding block
; either of primary or extended partition
cmp [bp-4], 05h ; is it for a DOS extended partition ?
je short isext ; yes,
cmp byte [bp-4], 0fh ; is it for a WIN extended partition LBA ?
jne near notext ; no, skip
; process 2 first table entries of an extended partition
; 1 - save these 2 entries in the 32 bytes at the beginning of newloc
; 2 - the first one points to a logical drive
; 3 - the second one, can be empty or point to the next extended partition
isext: add word [newloc + lbaslot], byte lbalen ; next lba entry address
jmp short nxtsect ; continue in next block
; Free space
db 'UUUUUUUUUUUUUUUUU' ;17 bytes
; By design, the remaining data in block must imperatively be located here.
; NOTE: fillto was a macro used to force locating some values at the
; specified offset. The macro disppaeared but the offsets are imperative.
; fillto 1a3h ; imperative location !!!
db '*' ; Visible reference point
bmdate: db '13.03.2008 - '
; By design, the remaining data in block must imperatively be located here.
; fillto 1b0h ; imperative location !!!
bbmid: db 'BBM ' ; (12) unique 'BBM ' identifier
baseadd: db bmLBA,0,0,0 ; lba of block where the bulk
; Field also stores the lba of an extended partition during the processing.
; Windows 2000, XP and Vista disk signature!
; When a drive has either of these OSes installed, the four bytes at offset
; 1b8h through 1bbh will/might be overwritten with that disk signature. One
; observes a high tendency for the 1st and 3rd and for the 2nd and 4th bytes
; to be the same, as in the examples: 96 e9 96 e9 or a8 e1 a8 e1
; fillto 1b8h ; imperative location !!!
dsignat: db 66h,0dh,67h,0dh,0,0 ; Vista disk signature
; These four bytes at 1b8h MUST BE TAKEN OVER from the Windows Vista install.
; See: http://www.multibooters.co.uk/mbr.html
; Dual/Multi Booting With Vista
; The partition table in the MBR has four 16-byte entries.
; The data in this area originates from:
; either the MBR of the boot volume
; or the MBR of the volume accessed by selecting another volume
; in the list - when entering 'n' or 'p'. Processing starts at label extract:
; When only the boot manager resides on a volume (thus not partitioned)
; this area should contain all 0's as defined below.
; fillto 1beh ; imperative location !!!
partab: dd 0
partyp: dd 0 ;
lbaval: dd 0 ; 1st lba of partition
dd 0 ; partition size in blocks
dd 0,0,0,0 ;
dd 0,0,0,0 ;
dd 0,0,0,0 ;
sign: dw signID ; MBR signature
; --------------------------------------------------------------------
; LBA 1 - contains the boot manager continuation i.e. stage2
nxtsect:
isext2: mov si, biosloc + partab ; point to first entry in new block
mov di, newloc ; point to free space in relocated MBR
mov cx, 3 * partlen ; was mov cx,32
rep movsb ; move 2 ext. part. entries to save area
mov si, newloc + 8 ; point to first entry lba in extended
mov ebx, [newloc + chainadd] ; retrieve base lba of partition
add [si], ebx ; add relative lba
mov ebx, [si] ; absolute lba
call addlba ; collect in list
call readplus ; read block corresponding to entry 1
call lbatxte ; collect the OS name in the table
mov si, newloc + 24 ; point to 2nd entry lba in extended
cmp dword [si], byte 0 ; is the chain finished ?
jz short donexte ; yes
; At this point the information about the partitions is in the lbalist table
mov ebx, [newloc + baseadd] ; retrieve base LBA of extended
add [si], ebx ; add relative LBA
mov ebx, [si] ; absolute LBA of this chained extended
mov [newloc + chainadd], ebx ; lba of chained extended
call readplus ; read block corresponding to entry 2
jmp isext2
notext: call lbatxt ; collect the OS name in the table
donexte: pop si
donext: add si, byte partlen ; point to next table entry lba
; there are 4 partition table entries terminated with 0aa55h.
cmp word [si - 8], signID ; signature in there is end of table ?
jne word next2 ; no, process next entry
cmp [newloc + flag], 0 ; any bit set in flag (mask)?
je short direct ; no, boot directly
push ds
xor ax, ax
mov ds, ax
mov al, [417h] ; shift status byte in BIOS low address 0040h:0017h
; 7 Insert locked
; 6 Caps Lock locked
; 5 Num Lock locked
; 4 Scroll Lock locked
; 3 Alt key is pressed
; 2 Ctrl key is pressed
; 1 Left Shift is pressed
; 0 Right Shift is pressed
; NOTE: the same information can be collected with int 16h, function ah = 02h
; Same technique for halting the boot process as in the OBL boot loader.
pop ds
test al, [newloc + flag] ; flag mask tests if any bit is set
jnz short interact ; stop boot process for user interaction
; if no flag instructs to cause an interaction, force it if mbrinproc = 1
; i.e. 'p' or 'n' input caused to extract info from another mbr
test [newloc + mbrinproc], 1 ; is flag = 1 ?
jnz short interact ; yes, force interaction
; boot the partition directly, thus without user intervention/interaction
cmp [newloc + defaultd], 0 ; is default <> 0 ? e.g. 80h ?
je short interact ; no, force interaction
; access the correct hard disk
mov cl, [newloc + curindex] ; index of drive currently analyzed
call getdrvno ; set dl = drive number with that index
cmp dl, [newloc + defaultd] ; is current hd also the default ?
je short locatep ; yes, locate the partition to boot
inc cl ; next drive index
jmp word extract2 ; extract the info from the partition table
; without halting the boot process for a user interaction
; access the correct partition
locatep: mov al, dl ;
call announce ; (20) optional, may be commented out
mov bx, newloc + lbadesc
mov ax, [newloc + defaultp]
direct:
nxtos: cmp ax, word [bx]
je near startdirec ; digit pair found, now start os
add bx, byte lbalen ; point to next entry
jmp nxtos
interact: call clearscr
; stow the MBR date in the prompt line
mov cx, 10 ; pdate is 10 bytes long
mov si, newloc + bmdate
mov di, newloc + pdate
rep movsb
call setblue23
call WILAstring ; issue top prompt text line
dw newloc + prompt
call WILAstring
dw newloc + drivelisth
call underline ; (10) indicate selected vol.
; info displayed differs depending on the drive mode, i.e. LBA or CHS
mov cl, [newloc + currdrive] ; current drive number
mov al, cl
call hex ; convert to 2 hex characters
mov [newloc + driveno], ax ; stow away in text
call WILAstring
dw newloc + twolinef
cmp [newloc + lbaindic], 0
jne short notchs
call WILAstring
dw newloc + modechs
mov ax, [newloc + cyls] ; number of cylinders
call int2charv
mov ax, [newloc + heads] ; number of heads
call int2charv
mov ax, [newloc + blocks] ; blocks per track
mov [newloc + intval + 4], 0
call int2charv
mov [newloc + intval + 4], 'x'
call WILAstring
dw newloc + fddtail
jmp word invitlin
notchs: mov si, newloc + modelba
mov ah, [newloc + lbaindic]
or ah, 30h ; convert to decimal character
mov [si + 4], ah ; store in text
call writestring
; Display which kind of MBR is present on this volume
mov si, newloc + BBMBR
test [newloc + uvstate], 80h ; 'Foreign'
jz short setbbm ;
test [newloc + uvstate], 40h ; 'GRUB'
jnz short setgrub ;
test [newloc + uvstate], 20h ; 'LILO'
jnz short setlilo ;
test [newloc + uvstate], 10h ; 'GAG'
jnz short setgag ;
jmp short setforeign
setgag: add si, MBRtxtlen ; position on 'GAG'
setlilo: add si, MBRtxtlen ; position on 'LILO'
setgrub: add si, MBRtxtlen ; position on 'GRUB'
setforeign: add si, MBRtxtlen ; position on 'Foreign'
call writestring
jmp short settail
setbbm: call writestring
settail: call WILAstring
dw newloc + BBMtail
; Display a list of OSs to choose from
; The information is extracted from the table lbadesc creating
; one line of text in lbaline per primary or logical partition
; The extended partition is not published.
nombr: mov bx, newloc + lbadesc
; transfer the text in the entry to a line for display
nxtline: cmp byte [bx + 4], 'x'
jne short nxtline2
mov ax, [bx]
mov [newloc + locked], ax
nxtline2: mov si, bx
mov di, newloc + lbaline
mov cx, 12 ; text length, incl. line number
rep movsb ; transfer text
mov al, byte [bx + 12] ; get partition type
call hex ; convert to 2 hex characters
mov [newloc + lbalinep], ax ; stow away in text
call showsize ; (24)
call hilite
mov si, newloc + lbaline ; 1 line partition info
; if the number of partitions is less than 10 use one digit
mov ax, word [newloc + lbaslot] ; (2)
sub ax, newloc + lbalist ; (2)
cmp ax, 10*lbalen ; (2)
jae short twodigit ; (2)
mov byte [newloc + digindic], 1 ; (2) note only 1 digit
inc si ; (2) start in the 2nd position
twodigit: call writestring
add bx, byte lbalen
cmp bx, word [newloc + lbaslot]
jb nxtline
; Construct the user prompt line: the information displayed will vary
; depending on the number of disk drives detected
invitlin: call WILAstring
dw newloc + selectinit ; prompt initial
call defaultsel
call WILAstring ; finalize user prompting
dw newloc + selectfin ; prompt final
cmp [newloc + maxdrive], 1 ; only 1 disk drive ?
je short finalize ;
; Prompt user to select the next or previous drive.
; In response, the partitions on the selected drive are enumerated.
mov cl, [newloc + curindex]
cmp cl, 1 ; is first drive ?
ja short notfirst ; go wait for new input
mov si, newloc + selectn ; prompt user to select next
jmp short writeit ;
notfirst: cmp cl, [newloc + maxdrive] ; is last drive ?
jb short notlast ;
mov si, newloc + selectp ; prompt user to select
jmp short writeit ;
notlast: mov si, newloc + select ; prompt user to select
writeit: call writestring
call WILAstring ; finalize user prompting
dw newloc + selectdrv ; prompt final
finalize:
input: and byte [newloc + mbrinproc], 0ffh - 1 ; reset
call readchar ; wait for single character input
; User response discriminator for the following cases
; 's' | 'l' | 'b' | 'h'' | 'n' | 'p' | 1-decimal digit | 2-decimal digit
mov cl, [newloc + curindex] ; index of current drive
; CASE 's'
cmp al, 's' ; (22)
je near swapMBR ; (22)
; CASE 'l'
cmp al, 'l' ; (18)
jne short notl ; (18)
test [newloc + uvstate], 04h ; (18)
jnz short set25 ; (18)
or [newloc + uvstate], 04h ; (18) done
jmp short now50 ; (18)
; fill rest of block, and check if size ok
times 2*blocksize - ($-$$) -2 db filler
dw signID ; imperative signature to verify
; BootManager is designed to read volume MBRs and PBRs.
; It must verify that the blocks read have a valid signature.
; The second BootManager block at LBA = 1 is subjected to the same
; validation to make sure that the continuation was correctly loaded.
; --------------------------------------------------------------------
; LBA 2 - contains the boot manager continuation
set25: and [newloc + uvstate], 0ffh - 04h ; (18)
now50: call clearscr ; (18)
test [newloc + uvstate], 2 ; (18)
jnz short inspecti ; (18)
jmp word extract ; (18)
; CASE 'b'
notl:
cmp al, 'b' ; (25)
jne short notb ; (25)
test [newloc + memoriz], 01h ; (25)
jnz short resetb ; (25)
or [newloc + memoriz], 01h ; (25) set indicator
jmp word interact ; (25)
resetb: and [newloc + memoriz], 0ffh - 01h ; (25) clear indicator
jmp word interact ; (25)
; CASE 'h'
notb:
cmp al, 'h' ; (15) request to display HW info ?
jne short noth ; (15) no
call clearscr ; (15)
inspecti: call inspectvbe ; (3)
call inspectpci ; (15)
call WILAstring ; issue top prompt text line
dw newloc + invitretn
call readchar
mov cl, [newloc + curindex] ; index of current drive
jmp short extract ; (5)
; CASE 'n'
noth: cmp al, 'n' ; request to explore next drive ?
jne short notn ; no
notv2: inc cl ; index of next drive to access
cmp cl, [newloc + maxdrive] ; is above last drive ?
ja word input ; yes, go wait for new input
call isaccess ; (14) is that drive marked 'not accessible' ?
je notv2 ; (14) ignore it and proceed to next
jmp short extract ;
; CASE 'p'
notn: cmp al, 'p' ; request to explore previous drive ?
jne notp ; no
notn2: dec cl ; index of previous drive to access
cmp cl, 1 ; is below first drive ?
jb word input ; yes, go wait for new input
call isaccess ; (14) is that drive marked 'not accessible' ?
je notn2 ; (14) ignore it and proceed to next
; extract the MBR of another volume and process it as if it had been
; loaded by the BIOS, that is, originated from the boot volume.
extract: or byte [newloc + mbrinproc], 1
extract2: mov [newloc + curindex], cl; note index of volume to process
call getdrvno
mov [newloc + currdrive], dl ; note the volume to inspect next
; restore the default text in the lbadesc table
call restorelba
call inspectdisk
mov bp, newloc + baseadd ; point to pseudo table entry
mov dword [bp], 0 ; MBR on any volume has LBA=0
call readblock ; read MBR into area at biosloc
call savembr ; what kind of data in MBR
; move the 4 partition table entries to newloc thus replacing the current ones
mov si, biosloc + partab ; si points to partab
mov di, newloc + partab ; relocation address
mov cx, 64 ; set count
rep movsb ; move partition table data
jmp word newmbr ; go process another MBR
; CASE 'digit'
; find the LBA corresponding to the chosen partition number and save in bx
notp:
; call writechar ; TRACE - echo user input
cmp byte [newloc + digindic], 2 ; (2)
je short firstdig ; (2) is first digit
mov dl, '0' ; (2) force '0' as 1st digit
; whereas the user will operate with 1 or 2 digits, the internal processing
; is always dealing with 2 digits
jmp short isalone ; (2) this digit is alone
; find the first digit in the lbadesc table
firstdig: ; (2)
mov bx, newloc + lbadesc
dig1try: cmp al, [bx]
je short digit2 ; digit found, now find digit pair
add bx, byte lbalen ; point to next entry
cmp bx, word [newloc + lbaslot]
jb dig1try
invresp: call WILAstring
dw newloc + invalid
jmp word input ; go wait for new input
; expect 2nd digit
digit2: mov dl, al ; save first digit
call readchar ; wait for single character input
call writechar ; echo user input
; find the 2-digit value in the lbadesc table
isalone: ; (2)
xchg ah, al
mov al, dl
mov bx, newloc + lbadesc
dig2try: cmp ax, word [bx]
jne short nentry ; digit pair not found, next
cmp dword [bx + 3], 'no P' ; 'no PBR'
je invresp
cmp dword [bx + 3], '|no ' ; '|no PBR'
je invresp
jmp short startos ; digit pair found, now start os
nentry: add bx, byte lbalen ; point to next entry
cmp bx, word [newloc + lbaslot]
jb dig2try
dig2ext: jmp invresp ; invalid response
; END CASE
; Start the operating system chosen by its menu number,
; read the partition boot block, place it at the exact location where
; the BIOS would have placed it and jump to it
; i.e. chain load to the Partition Boot Record of the selected partition
; At this point, bx points to the lbadesc entry corresponding to the partition
startos: cmp word [newloc + locked], ax ; is it the locked Extended ?
je dig2ext ; yes, it may not be selected
; Note which drive and which partition are now selected.
; They become the defaults for the next BootManager start.
mov word [newloc + defaultp], ax ; note partition number
mov dl, [newloc + currdrive] ; get current drive number
mov [newloc + defaultd], dl ; note drive number
test [newloc + memoriz], 01h ; (25)
jnz short leavesel ; (25)
mov [newloc + defaultd], 0 ; (25) force de-selection
mov word [newloc + defaultp], '??' ; (25) force de-selection
; Save to drive configuration for the next system restart.
leavesel: mov cx, 8*prevdlen ; (8)
mov si, newloc + drivelist ; (8) source
mov di, newloc + prevdlist ; (8) relocation address
rep movsb ; (8) move
push bx
call writeblock ; record these values
pop bx
; determine which partition table entry corresponds to this LBA and load
; its address in si - Needed by the interface to Damn Small Linux - DSL
startdirec: call setsiDSL
mov ebx, [bx-4] ; point to corresponding lba
mov [newloc + baseadd], ebx
mov bp, newloc + baseadd ;
call readblock ; read partition boot block
; test code: display the first 32 bytes of the block just read, stop and
; wait for a keyboard input
; mov cx, 32 ; 32 bytes
; mov si, biosloc ;
;nxtlba: lodsb ; get char of message
; cmp cx, 0 ; is last entry ?
; jz short read ; yes
; mov bh, al
; call ptyp ; display this character
; dec cx
; jmp nxtlba ; proceed to next character
;read: call readchar ; wait for single character input
; Drive mapping just before transferring control to the PBR loaded at biosloc
; In the case of Bluebottle, Native Oberon and DOS, the drive
; number (80h, 81h ...) is stored in the boot block of the OS partition.
; In order to boot from a drive which is not the first as it was at
; installation time, one needs to insert the correct number before
; the boot block is exploited.
; In pratice, it suffices to modify it on the fly in memory at biosloc.
; Drive mapping for other OSs will eventually be implemented later.
mov dl, [newloc + currdrive] ; get drive number
; and place it in DL as specified in the work assumptions - cfr. BootMan.Text
cmp word [biosloc + 3], 'OB' ; for 'OBERON', map drive ?
; 'OBERON' is found in Oberon partitions of types: 4ch = 76, 4fh and 50h
je short mapdrive ; do map
cmp word [biosloc + 6], 'LI' ; 'SYSLINUX' of DSL "
jne short mapdrive ; if DSL do not map, leave PBR as is
; Such is the case for DSL on a USB flash memory stick
mov si, [newloc + DSLsiVal]
jmp short nomap
; Add whichever OS needs a drive number in its PBR here!
mapdrive: mov byte [biosloc + 24h], dl ; correct drive number on the fly
nomap: xor dh, dh ; zero dh; dl must be passed over
jmp 0:biosloc ; jump to PBR
; On entry to the PBR:
; es = 0
; dl = is the BIOS drive number accessed
; This code is now definitively left !!
; ===== procedure: place the OS name (primary partition) in the next entry
; si : MUST be left untouched! - pointer to lba in partition table entry
lbatxt:
mov di, word [newloc + lbaslot]
add di, byte 7 ; position of text inside slot
osname: push si
; Now that a PBR is being processed, verify that the signature is valid.
cmp word [newloc + mbrsign], signID ; (1) is signature present ?
je short signgood
mov si, newloc + notPBR ; bad signID means not a PBR
jmp short movename
signgood: mov si, biosloc + 3 ; OS name in PBR
; The PBR has a valid signID but when the OS name contains all 0h
; it is the sign of a Linux partition (Ubuntu, Mandriva, DSL, ....)
cmp word [si],0
jne short testLILO
mov si, newloc + linuxtxt ; substitute this to the 0s
jmp short movename
testLILO: cmp dword [si + 3],'LILO'
jne short testOBER
mov si, newloc + LILOMBR ; same shifted left
jmp short movename
testOBER: cmp word [si],'OB'
jne short movename
mov word [si + 6],' '
; move whichever name applies to this partition to output area
movename: mov cx, 8
rep movsb
pop si
add word [newloc + lbaslot], byte lbalen ; next lba entry address
ret
; ===== procedure: write the block with LBA = bmLBA+bmsize-1 to the volume
; thus recording the number of:
; - the selected boot disk (field defaultd) and of
; - the selected partition (fields defaultp)
; which become default values
; No write operation is performed when booting from a FD because:
; 1 - a FDD is considered as a rescue disk, not resident
; 2 - a CD-ROM emulates a FDD and cannot be written on
writeblock:
; simple tracing sequence
; mov cx, 32 ;
; mov si, newloc + blocksize
;nxtlba: lodsb ; get char
; cmp cx, 0 ; is last char ?
; jz short read ; yes
; call char2hex ; display this character
; dec cx
; jmp nxtlba ; proceed to next character
;read:
test byte [newloc + mbrinproc], 80h ; write lock on ?
jnz short donotwrt ; yes, do not write
inc byte [newloc + reason] ; discrimator of situation
cmp byte [newloc + drivenbrs + 1], 80h ; is it a hard disk ?
; if the boot disk drive (first in the list) was a USB-FDD or CD-ROM, then
jb short donotwrt ; DO NOT register the selection
inc byte [newloc + reason] ; discrimator of situation
test [newloc + uvstate], 80h ; is it a foreign MBR ?
jnz short donotwrt ; DO NOT register the selection
mov di, maxretry ; number of tries
tryw: mov ax, 4300h ; ready for extended read
mov si, newloc + dapw ; dap - Device Address Packet (see below)
; test if the drive supports extended int 13h extensions, i.e. LBA mode
; and trim to standard write if lba not supported
cmp [newloc + lbaindic], 0 ; test the lba indicator
jne short uselbaw
mov ax, 0301h ; standard write 03h, 1 block
; place the values in the registers
mov cx, bmLBA + bmsize - 1 ; write block corresponding to LBA 12
mov dh, 0 ; head 0
mov bx, newloc + bmsize * blocksize ; data buffer offset
jmp short uselbaw
; times 3*blocksize - ($-$$) db filler
; --------------------------------------------------------------------
; LBA 3
uselbaw: mov dl, 80h ; boot drive number
int 13h ; call BIOS
jnc short int13okw ; carry flag not set: ok, proceed
; on failure, perform a disk reset
; by experience this event was never observed but who knows !!! it
; will never happen?
mov [newloc + errcode], ah ; (6) stow the error code away
xor ax, ax ; reset disk
int 13h ; call BIOS
dec di ; does not clear carry
jnz tryw ; retry counter > 0, retry
jmp word showerr ; (6) display errormsg with code
; better than the next brutal instruction
; hangw: jmp hangw ; halt the system !!! endless loop
int13okw: call WILAstring
dw newloc + recording
jmp short persist
donotwrt: call WILAstring
dw newloc + ignoring
persist: call persistance ; (23) add msg persistance
ret ;
; ===== procedure: insert size (MB/GB) in text string
; in : bx = pointer to lbadesc for this partition line
; must be left unaltered
showsize:
mov dword [newloc + limit], 999999
mov eax, dword [bx + 13] ; (24) get partition size in blocks
; show volume size
showsizev: mov cx,6 ; (24) max. number of digits to produce
mov si,newloc + sizeunit ; (24) start at least significant digit
shr eax,11 ; (24) partition size in MB
mov word [newloc + sizeMG], 'MB' ; (24) Megabytes
cmp eax, dword [newloc + limit] ; (24) display max. 6 digits
jbe short sizeM ; (24)
shr eax, 10 ; (24) DIV 1024 > size in GB
mov word [newloc + sizeMG], 'GB' ; (24) Gigabytes
sizeM: push bx ; (24)
call convert ; (24)
pop bx ; (24)
ret ; (24)
limit: dd 0
; ===== procedure: place the OS name (logical drive) in the next entry
; in : PBR located at biosloc
lbatxte:
mov di, word [newloc + lbaslot]
mov byte [di + 7], '|'
add di, byte 8 ; position of text inside slot
jmp word osname ; treat as primary partition name
; ===== procedure: collect the information on the number of installed (4)
; drives in a group - either hard disk or floppy disk or both
; Executed only once when the MBR from the boot volume is extracted
driveinfo:
cmp [newloc + maxdrive],0 ; max. drive number determined ?
jne short done ; yes, skip
mov word [newloc + driveslot],newloc + drivelist
; set the table beginning address
mov dl,[newloc + currdrive] ; get current drive
mov al,dl
call hex ; convert to 2 hex characters
mov [newloc + driveinctrl],ax ; stow away in drivelisth
push es ; save to protect its value
call groupinfo
xor [newloc + currdrive],80h ; flip msb to access other group
call groupinfo
xor [newloc + currdrive],80h ; restore original value
pop es ; restore es
done: ret
; ===== procedure: collect the information on the number of installed (4)
; drives in a group - floppy disk or hard disk
; mod: ax, cx, dx, di
groupinfo:
mov dl,[newloc + currdrive] ; get current drive
and dl,80h ; (22) start with first in group
mov [newloc + grouplead],dl ; (22) save group leader
; obtain the number of drives in this goup (returned in dl)
mov ah,08h ; get disk drive parameters
int 13h ; call BIOS
; (9) dl now contains the number of drives around that drive, but even when
; no diskette drive is installed or when it is disabled, BIOS returns dl = 1.
; In that case of non-existent diskette drive, CF = 0 means successful, but
; bx = 0 is used to decide that no diskette drive is present.
; However, booting from CD-ROM also arrives here with dl = 1 and bx = 0 .
; Must thus test if CD-ROM or not -> using value in ax as discriminator.
; When booting from USB_FDD, the BIOS volume id is 00h or 80h depending
; on the BIOS.
cmp [newloc + currdrive],80h ; (9)
jae short hddgrp ; (9) no problem with hdd
cmp [newloc + maxdrive],0 ; (9) first group detected is fdd
; which means that the boot volume is a CD-ROM or a USB-FDD.
jne short exitgrp ; (9) no, forget about fdds
mov word [newloc + fddtype],ax ; note that
mov dl,1 ; (9) consider only one device
; and ignore the remaining fdds if any exists.
hddgrp: add [newloc + maxdrive],dl
xor cx,cx
mov cl,dl ; set repeat counter, dl now free
xor ax,ax ; clear
mov al,[newloc + grouplead] ; (22) group leader
dgroup:
inc word [newloc + drivtaddr]
mov di,[newloc + drivtaddr]
mov byte [di],al ; save drive number in table
push cx ; save repeat counter
; brief report of the drive number and parameters. One report per drive is
; in the drivelist at the address found in driveslot .
push ax ; save drive number
push di
mov di,[newloc + driveslot]
mov byte [di],26 ; single character 'right arrow'
call hex
mov byte [di + 1],al ; most sign. in drive number
xchg ah,al ;
mov byte [di + 2],al ; least sign. in drive number
pop di
call driveparam ; (8)
pop ax ; restore drive number
inc al ; next drive
pop cx ; restore repeat counter
add word [newloc + driveslot],byte 10
loop dgroup
exitgrp: ret
; ===== procedure: collect the information on the installed drives (8)
; interprete the data in the return buffer and its extensions, if any
driveparam:
mov dl,byte [di] ; get current drive number
cmp dl,80h ; is it among the hdds ?
jb isfdd ; no, is floppy drive or cd-rom
; collect more information concerning hdds
mov si,newloc + dpbuffer ; extra-muros buffer
mov word [si],74 ; data size to receive
; see remark under dpbuffer
mov ah,48h ; get drive parameters
int 13h ; call BIOS
jc short int13err ; carry denotes error
; volume geometry information - not used
; mov al,[newloc + infflags]
; call char2hex
; mov ax,[si + 4] ; cylinders
; call int2char4
; mov ax,[si + 8] ; heads
; call int2char4
; mov ax,[si + 12] ; blocks per track
; call int2char4
; mov ax,[si + 24] ; bytes per block
; call int2char4
; TRACE: Take a view of the first dpbuffer encountered and halt!
; Modern PCs do not return device path information,
; only PCI interface path
; mov cx,72 ;
; mov si,newloc + dpbuffer ; extra-muros buffer
;disnxt: lodsb ; get char of buffer
; mov bh,al
; call char2hex ; display in 2 hex
; loop disnxt ; proceed to next character
;hardstop: jmp short hardstop
mov di,[newloc + driveslot]
add di,byte 4
; display the volume size in the matching entry on the next line
mov dword [newloc + limit],999
mov eax,dword [si + 16] ; (8) volume size in blocks
call showsizev ; (8)
; transfer the volume size to the next driveslot
mov cx,5 ; extract only 5 bytes
mov si,newloc + sizethous ; first digit to extract
rep movsb ; move cx bytes
call interfinfo ; (13) collect volume interface information
ret ;
; This error occurs when:
; 1 - BIOS was set up to boot from a USB drive (it chooses the first one)
; 2 - then attempt to obtain the drive parameters of another USB drive.
; That drive is not accessible in that set-up.
int13err: mov di,[newloc + driveslot]
add di,byte 4
mov dword [di],'n.a.' ; mark as 'not accessible'
ret ; exit
isfdd:
; discriminate FDD and CD-ROM by the value returned earlier in ax
; this bit of code appears superfluous: same value returned for real fdd
; or fdd emulating cd-rom
mov di,[newloc + driveslot] ; (13)
; cmp word [newloc + fddtype],0030h ; (13) CD-ROM emulating FDD ?
; jne short notcd ; (13) no, booting from FDD
; mov dword [di + 81],'CD-R' ; (13) 80 char. line + 1
; mov word [di + 85],'OM' ; (13) 80 char. line + 5
; ret ; (13)
notcd: mov dword [di + 83],'FDD ' ; (13) 80 char. line + 3
ret ; (13)
; ===== procedure: underline the drive info line (10)
underline:
; adjust the curindex as is required after swapping MBR
mov si,newloc + drivenbrs + 1 ;
mov al,1
mov cl,[newloc + currdrive] ; get current drive
trynextd: cmp byte [si],cl
je short valindex ; valid index obtained
inc si
inc al
jmp trynextd
valindex: mov [newloc + curindex],al ; correct curindex
mov di,newloc + drivelistul ; destination address
mov al,[newloc + curindex] ; current drive index
addspace: mov cx,10
dec al
jz short markit
mov si,newloc + spaces ; move 10 spaces
rep movsb
jmp short addspace
markit: mov si,newloc + marks ; move 10 marks
rep movsb
mov byte [di],0 ; add a 0-terminator
call WILAstring ; write complete underlining string
dw newloc + drivelistul
ret
; ===== procedure: is current drive accessible ? (14)
; in: cl - drive index (origin is 1)
; out: carry is 1 if drive marked as non-accessible
isaccess:
mov al,cl ; (14) index of drive to scrutinize
cbw ; (14) convert byte to word
mov dx,10 ; (14) drivelist entry length
mul dx ; (14) ax now contains destination location
mov di,ax ; (14) total displacement
add di, newloc + drivelist - 6 ; (14) 10 - 4 = 6
cmp dword [di],'n.a.' ; (14) 10 - 4 = 6
ret ; (14)
; ===== edit the disk operation error code as errorgui in the errormsg
; Extension of the readblock/writeblock procedure (6)
showerr: mov al,[newloc + errcode]
call hex ; convert to 2 hex characters
mov word [newloc + errorgui],ax ; stow away in text
call WILAstring
dw newloc + errormsg
jmp word invitlin
; ===== edit the disk operation error code as errorgui in the errormsg
; Extension of the readblock procedure (6)
readerr: mov al,[newloc + errcode]
call hex ; convert to 2 hex characters
mov word [newloc + errorgui],ax ; stow away in text
call WILAstring
dw newloc + errormsg
cmp dl,80h ; is it a hard disk ?
jae word input ;no,
call WILAstring
dw newloc + fdderror
errinfo: call persistance ; (23) add msg persistance
jmp word interact
driveslot: dw newloc + drivelist ; address of next available slot
fddtype: dw 0 ; type of fdd detected
times 4*blocksize - ($-$$) db filler
; --------------------------------------------------------------------
; LBA 4 - data areas
modelba: db 'LBA ?) - MBR: ',0
modechs: db 'CHS ',0
; One line of text per partition
; number / partition type / partition size
lbaline: db 'ij - '
lbalinep: db 'XY ' ; partition type in hex
db 'thu'
; the following 5 bytes are for displaying volume size
sizethous: db 'th' ; thousand/hundred/
sizeunit: db 'u' ; unit digit is inserted first
sizeMG: db 'mb' ; MB or GB
crlf: db CR,LF,0
dfttext: db 'Extended ',0 ; default text
locked: dw 0 ; OS number which may not be selected
; that is, the extended partition
; area in which partition data for up to 12 partitions is collected:
; each partition is completely identified by a quadruple:
; lbalist / lbadesc / lbapartno / lbasize in no. of blocks
; each entry has lbalen bytes
lbaslot: dw newloc + lbalist ; address of next available slot
lbalist: dd 0 ; lba of first partition block
lbadesc: db '01 Extended ' ; partition description
lbapartno: db 0 ; partition type extracted from partition table
lbasize: dd 0 ; (24) partition size in no. of blocks
dd 0
db '02 Extended '
db 0
dd 0
dd 0
db '03 Extended '
db 0
dd 0
dd 0
db '04 Extended '
db 0
dd 0
dd 0
db '05 Extended '
db 0
dd 0
dd 0
db '06 Extended '
db 0
dd 0
dd 0
db '07 Extended '
db 0
dd 0
dd 0
db '08 Extended '
db 0
dd 0
dd 0
db '09 Extended '
db 0
dd 0
dd 0
db '10 Extended '
db 0
dd 0
dd 0
db '11 Extended '
db 0
dd 0
dd 0
db '12 Extended '
db 0
dd 0
; three lines of up to 8 volumes detected to display in one go
; Each volume is allocated a 10-byte slot with the structure:
; 1 character "right arrow"
; 2 characters drive number 00h, 01h, 80h, 81h, ...
; 1 space
; the drive size in MB or GB, or 'fdd' for a floppy diskette
; or a CD-ROM emulating a floppy
; 2 spaces
drivelisth: db 'BIOS detected volumes / '
driveinctrl: db ' ' ; drive in control by MBR
db ' is boot volume in control',CR,LF ; drive list header
drivelist: db ' '
db ' '
db ' '
db ' '
db ' '
db ' '
db ' '
db ' '
; db CR,LF ; automatic cr+lf because full line
volinterf: db ' ' ; volume interface: ATAPI, ATA, USB
db ' '
db ' '
db ' '
db ' '
db ' '
db ' '
db ' '
; db CR,LF ; automatic cr+lf because full line
db 0
; times 5*blocksize - ($-$$) db filler
; --------------------------------------------------------------------
; LBA 5
maxdrive: db 0 ; max. number of hard disk detected
; 0 denotes that the max. drive number is not yet determined
drivtaddr: dw newloc + drivenbrs ; address in table for groupinfo
drivenbrs: db -1,-2,-2,-2,-2,-2,-2,-2,-2
; table of (max. 8) disk drive numbers
; position with index 0 is empty
curindex: db 1 ; index of drive currently accessed [1 .. 8]
; for underline
; dap for an extended write 13h disk operation defined in proc writeblock
; the structure of the dap is:
dapw: db 10h ; dap size (fixed)
db 0 ; reserved (fixed)
dw 1 ; number of blocks to transfer (fixed)
boffw: dw newloc + bmsize * blocksize ; address of transfer buffer - offset
dw 0 ; address of transfer buffer - segment
dd bmLBA + bmsize - 1 ; starting absolute block address LBA
dd 0 ; remaining 32 bits of address
; work areas and prompt lines
spaces: db ' '
selectn: db ' N(ext)',0
select: db ' N(ext) or'
selectp: db ' P(revious)',0
selectdrv: db ' volume'
marks: db ' ',30,30,30,30,30,30,CR,LF,0 ; (10) marks
selectfin: db ' L (toggle) 25/50 lines',CR,LF
db ' H to display PC HW info',CR,LF
db ' S MBR on selected volume is to take control as boot volume',CR,LF,0
invalid: db ' invalid input, retry',CR,LF,0
; (25) text to appear in green or red
preselr: db ' B (toggle) @ next boot, show this menu',CR,LF,0
preselg: db ' B (toggle) @ next boot, start selected OS [currently v. '
dftdtext: db ' , p. '
dftptext: db ' ]',CR,LF,0
fdderror: db 'Either no floppy drive is present: disable it '
db 'in the BIOS setup,',CR,LF
db ' or no diskette is present: insert one',CR,LF,0
; times 6*blocksize - ($-$$) db filler
; --------------------------------------------------------------------
; LBA 6
twolinef: db CR,LF,'Volume '
driveno: db ' ' ; displayable digit
mode: db '(Mode ',0
grouplead: db 0 ; (22) is 80h OR 00h
wrongdid: db 'Must access 80h',CR,LF,0
BBMtail: db ' - Vol. signature @ 1B8h: '
signb1: db ' '
signb2: db ' '
signb3: db ' '
signb4: db ' ',CR,LF,LF,0
fddtail: db ') Not partitioned.',CR,LF,0
; ===== procedure: inspect the data in the MBR just read
; does not alter registers
inspectmbr:
; determine the kind of boot manager it corresponds to:
; Bluebottle, GRUB, LILO or Foreign
; A Windows MBR has no fixed identifying strign, hence Foreign
; Save that information in uvstate for later use.
and [newloc + uvstate],0ffh - 0f0h ; clear bits 7,6,5,4
cmp dword [MBRreloc + 17h],'GAG ' ; position of GAG
jne short notGAG
or [newloc + uvstate],90h ; set bit 4 = GAG
jmp short MBRok
notGAG: cmp dword [MBRreloc + bbmid],'BBM '
je short MBRok
or [newloc + uvstate],80h ; set bit 7 = foreign
cmp dword [MBRreloc + 017fh],'GRUB' ; position of GRUB
jne short notGRUB
or [newloc + uvstate],40h ; set bit 6 = GRUB
jmp short MBRok
notGRUB: cmp dword [MBRreloc + 06h],'LILO' ; position of LILO
jne short MBRok
or [newloc + uvstate],20h ; set bit 5 = LILO
MBRok:
; reveal the disk signature in the MBR: stow info in signb1 to 4
pusha
mov al,[MBRreloc + dsignat]
call hex
mov word [newloc + signb1],ax
mov al,[MBRreloc + dsignat + 1]
call hex
mov word [newloc + signb2],ax
mov al,[MBRreloc + dsignat + 2]
call hex
mov word [newloc + signb3],ax
mov al,[MBRreloc + dsignat + 3]
call hex
mov word [newloc + signb4],ax
popa
ret
; ===== procedure: set the cursor to the u.l. corner and fill the screen
; with blanks on 25 or 50 lines according to bit 2 in uvstate
; References:
; http://home.earthlink.net/~danrollins/techhelp/0117.HTM and 0124.HTM
clearscr:
push cx
; set cursor at row 0, column 0 (upper left screen corner)
mov ah,2
mov bh,0
xor dx,dx
int 10h ; call BIOS - display characters
; fill the entire screen with blanks
mov cx,4000 ; repeat write char. 80 x 50 times
test [newloc + uvstate],04h ;
jz short go50
mov ax,03h ; set text mode 80 x 25 lines
xor bx,bx
int 10h ; call BIOS
mov cx,2000 ; repeat write char. 80 x 25 times
jmp short blkscr
go50: mov ax,1112h ; set text mode 80 x 50 lines
xor bx,bx
int 10h ; call BIOS
blkscr: mov ax,0920h ; write blank (20h) and attribute
mov bx,0fh ; bright white
int 10h ; call BIOS
pop cx
ret
; ===== procedure: inform of default boot pre-selection (16)
; memorizing the operating system started last
defaultsel:
cmp byte [newloc + drivenbrs + 1],80h ; is it a hard disk ?
; if the boot disk drive (first in the list) was a FD, then nothing memorized
jb short nopresel ; no preselection
mov al,[newloc + defaultd]
call hex ; convert to 2 hex characters
mov [newloc + dftdtext],ax ; stow away in text
mov ax,[newloc + defaultp]
mov [newloc + dftptext],ax ; stow away in text
mov cx,68 ; (25) presel text length
test [newloc + memoriz], 01h ; (25)
jnz short greepresel ; (25)
call setred ; (25)
call WILAstring ; (25)
dw newloc + preselr ; (25)
jmp short nopresel ; (25)
greepresel: call setgreen ; (25)
call WILAstring ; (25)
dw newloc + preselg ; (25)
nopresel: ret
; ===== procedure: set si for DSL (tested with DSL on 62MB USB-HDD)
; Find the address of the partition table entry containing the LBA value
; found in the lbalist
; In bx: pointer to LBA value where the OS starts
setsiDSL:
mov ax,newloc + partab ; point to first entry
; mov ebx,[bx-4] ; point to lba in front of lbadesc
; cmp ebx,[ax + 8] ; lba found in partition table entry
; jne short setsiEND
mov [newloc + DSLsiVal],ax
setsiEND: ret
DSLsiVal: dw 0 ; si value for interface to DSL
; ===== Transfer control from the current Boot Manager to a MBR in
; another volume (retrieve the saved MBR and relocate it in biosloc
; and behave as BIOS would)
swapMBR: mov si,MBRreloc ; (22) copy the memorized MBR
mov di,biosloc ; (22) to the area where BIOS
; (22) would have loaded it normally
mov cx,blocksize ; (22) set count
rep movsb ; (22) copy MBR
; Attempt to pass control to MBR on volume 8xh after booting from 80h.
; Does not work, except with a Bluebottle MBR.
; Otherwise only successful when passing control to a foreign MBR on 80h.
; Was tested with GRUB and Ubuntu installed on a HDD, enumerated as 81h, while
; booting from USB-HDD thus enumerated as 80h.
cmp dword [biosloc + bbmid],'BBM ' ; (22) is this a Bluebottle MBR?
je short bluembr ; (22) this works always
; Pass control to a foreign MBR which must this time be on volume 80h
cmp [newloc + currdrive],80h ; (22)
je short bluembr ; (22) this works
; boot volume does not have drive id as expected by MBR of installed OS
call WILAstring
dw newloc + wrongdid ; wrong drive id
jmp word errinfo
bluembr: call WILAstring ; (22)
dw newloc + swap ; (22)
call persistance ; (23) add msg persistance
or byte [biosloc + mbrinproc],80h ;
; NOTE! > biosloc lock writing defaultd and defaultp
mov dl,[newloc + currdrive] ; (22) get current drive number
jmp 0:biosloc ; (22) activate new MBR
swap: db 'Switch MBR in 4"...',0 ; (22) timed message
recording: db CR,LF,'Recording user selection',CR,LF,0 ; (22) timed message
ignoring: db CR,LF,'Selection not recorded '
reason: db 'A',CR,LF,0 ; (22) timed message
MBRtxtlen: equ 11
BBMBR: db 'Bluebottle',0
FORMBR: db 'Foreign ',0
GRUBMBR: db 'GRUB ',0
LILOMBR: db 'LILO ',0
GAGMBR: db 'GAG ',0
; --------------------------------------------------------------------
; LBA 7
linuxtxt: db 'Linux ' ; PBR with 8 x 0h at offset 3
notPBR: db 'no PBR ' ; PBR with invalid signature
vbeinfo: db CR,LF,LF,'VESA modes: WidthxHeightxDepth',CR,LF,0 ; (3)
dimen: db ' MB'
hyphen: db ' - ',0
; ===== procedure: inspect the graphic controller capabilities (3)
inspectvbe:
call WILAstring
dw newloc + vendebx
call WILAstring
dw newloc + newline
; vesatab at es:di - 1KB scratch segment for receiving the VBE
; controller information block located at the end of this program
mov di,newloc + vesatab
mov ax,4f00h ; return VBE controller information
mov dword [di],'VBE2' ; "VBE2" signature
int 10h ; call BIOS
cmp ax,004fh
jne near endmode
; process the data returned in the buffer
mov cl,[di+4] ; save value before overwriting it
mov byte [di+4],0 ; now zero-terminated string at di
mov si,di ;
call writestring
mov al,[di+5] ; first digit of version number
or al,30h ; convert to decimal character
call writechar
mov al,'.' ; decimal point
call writechar
mov al,cl ; bring back 2nd digit
or al,30h ; convert to decimal character
call writechar
mov al,' ' ; space
call writechar
mov ax,[di + 12h] ;
shr ax,4
call int2char4 ;
call WILAstring
dw newloc + dimen
; trace VBE controller information (19 bytes of code)
; mov cx,0
; push di
;nextsi: mov al,[di]
; inc di
; push cx
; call char2hex
; pop cx
; inc cx
; cmp cx,34h
; jb nextsi
; pop di
; As from VESA 2.0, additional information is returned. Some of it
; is displayed now
mov al,[di+5] ; first digit of version number
cmp al,2 ; is it 2 ?
jb short vesa1 ; no, skip what appeared later
push ds ; save before accessing the other ds
mov si,[di + 16h] ; of vendor string
mov ds,[di + 18h] ; ds of vendor string
call writestring
pop ds ; restore
call WILAstring
dw newloc + hyphen
push ds ; save before accessing the other ds
mov si,[di + 1ah] ; of product
mov ds,[di + 1ch] ; ds of product
call writestring
pop ds ; restore
call WILAstring
dw newloc + crlf
vesa1: push ds ; save before accessing the other ds
mov si,[di + 6h] ; of OEM string
mov ds,[di + 8h] ; ds of OEM
call writestring
pop ds ; restore
call WILAstring
dw newloc + vbeinfo
; extract all modes from the mode list and display their characteristics
; coloring is used to identify the modes suitable for Bluebottle.
hasmodes:
push ds
mov si,[di + 0eh] ; offset of mode list
mov ds,[di + 10h] ; ds of mode list
nxtmode:
mov al,[si] ; get first byte
cmp al,0ffh ; is it an end of list marker ?
je near endmode ; yes
; inspect mode and inform only about VBE mode for which LFB is available
; A color code is used to differentiate the modes of the graphic card:
; green: mode supported by BB
; white: mode not supported
; yellow: 15-bit depth mode not supported, but potentially suitable
; Requires a module modification.
mov ax,4f01h ; return VBE mode information
mov cx,[si] ; for this mode
mov di,newloc + vesatab + blocksize ; another block for storing data
int 10h ; call BIOS
cmp ax,004fh ; is mode supported ?
jne short skipmode ; no
test byte [es:di],80h ; is video mode attribute LFB available
jz short white ; not good for Bluebottle
; test byte [es:di],10h ; is video mode attribute graphic mode
; jz short white ; not good for bluebottle
cmp byte [es:di + 19h],15 ; 15 bits per pixel ? not yet supported
jne short green ; yes, good for Bluebottle
; or byte [newloc + lfbyes],80h ; at least one mode supports LFB
call setyellow4 ; not good for bluebottle
; NOTE: currently, 15-bit modes are not supported but it would be rather easy
; to include them (as green) by modifying Displays.Mod
jmp short white
green: call setgreen4 ; good for Bluebottle
; display the mode (1 blank and 3 hexadecimal characters)
white: mov al,[si + 1]
call hex
xchg ah,al ;
call writechar
mov al,[si]
call hex
call writechar
xchg ah,al ;
call writechar
mov al,' ' ; terminate with a blank
call writechar
; restore the program code data segment from the stack via ax
pop ax
push ds ; save the current ds containing
; the VBE mode information
mov ds,ax
mov ax,[es:di + 12h] ; horizontal resolution in pixels
call int2char4
mov ax,[es:di + 14h] ; vertical resolution in pixels
call int2char4
mov al,[es:di + 19h] ; bits per pixel
aam 0ah
or ax,'00' ; make it zero ASCII-based
xchg al,ah
cmp al,'0' ; is first digit '0' ?
jne short leaveit ; no
mov al,' ' ; suppress leading '0'
leaveit: mov [newloc + here],ax ; stow away in buffer
push si
call WILAstring ; display it
dw newloc + here
pop si
; restore the VBE mode info data segment from the stack via ax
pop ax
push ds ; save the program code data segment
mov ds,ax
skipmode: add si,byte 2 ; position to next mode
jmp word nxtmode ; repeat for next mode
here: db 0,0,' ',0
endmode: pop ds
call WILAstring
dw newloc + initinfo
call readchar ; halt display output
ret
; ===== procedure: convert 1 byte to two hexadecimal characters
; in : al = byte to convert
; out: al = most significant ; ah = least significant
hex:
aam 10h ; ah := al DIV 10h
; al := al MOD 10h
or ax,word '00' ; make it zero ASCII-based
xchg ah,al ; exchange in view of output order
cmp al,'9'
jna short hexl ; <= 9 is alright
add al,7 ; > 9 modified to 'A' .. 'F'
hexl: cmp ah,'9'
jna short hexh ; <= 9 is alright
add ah,7 ; > 9 modified to 'A' .. 'F'
hexh: ret
; ===== procedure: convert an integer to decimal 4-character string
; with 0-terminator, with suppression of leading zeros
; in: ax = 16-bit value
; out: si pointer to most significant character of zero-delimited string
int2char:
push ax ; correction: extend ax to eax
xor eax,eax
pop ax
mov cx,4 ; max. number of digits to produce
mov si,newloc + intval + 3
call convert
ret
intval: db 0,0,0,0,'x',0 ; 4 receiving pos, a 'x' and a delimiter
; ===== procedure: convert a long integer to decimal character string
; with 0-terminator, with suppression of leading zeroes
; in: eax = 32-bit value
; cx = max. number of digits to produce
; si = pointer to unit digit in result string
; further digits are added from right to left
; out: si pointer to most significant character of zero-delimited string
convert:
mov ebx,10 ; conversion base 10
convertdig: xor edx,edx ; extend eax to 64-bit edx:eax
div ebx ; eax <- edx:eax div ebx, edx <- remainder
or dl,'0' ; make it '0'+ ASCII-based
mov [si],dl ; stow away in buffer
dec si ; place right to left in buffer
loop convertdig ; loop on count in cx
; replace leading '0' by ' '
inc si
convert0: cmp [si],'0' ; is this digit '0' ?
jne short convertexit ; no, keep it
mov [si],' ' ; put a ' ' in there
inc si ; address next digit
jmp convert0 ; repeat that
convertexit: ret
; ===== procedure: convert an integer to a variable length string of decimal
; characters terminated with 0, suppressing the leading zeroes,
; and display it
; in: ax = 16-bit value
int2charv:
push si
call int2char
call writestring ; display it
pop si
ret
; ===== procedure: convert an integer to a string of 4 decimal characters
; terminated with 'x' and 0, suppressing the leading zeroes,
; and display it
; in: ax = 16-bit value
int2char4:
push si
call int2char
call WILAstring ; display it
dw newloc + intval ; position at the beginning
pop si
ret
; ===== procedure: convert a binary integer to a 4-hexadecimal ascii string
; not used here, but good to keep
; in: ax = 16-bit value
; di = pointer destination - 1st byte
int2hex4:
pusha
mov bx,10h ; conversion base is hex (15)
mov cx,4 ; number of characters
add di,byte 3
int2hex4n: xor dx,dx ; extend ax to 32-bit dx:ax
div bx ; ax <- dx:ax div bx, dx <- remainder
cmp dl,10 ; is dl < 10 ?
jb short int2hex4d ; yes, is to become a digit
add dl,'A' - 10 ; form a letter A .. F
jmp short int2hex4l ; skip, it is a letter
int2hex4d: or dl,'0' ; form a digit
int2hex4l: mov [di],dl ; stow away in buffer
dec di ; place right to left in buffer
loop int2hex4n ; loop on count in cx
popa
ret
times 8*blocksize - ($-$$) db filler
; --------------------------------------------------------------------
; LBA 8
; ===== procedure: wait until an ASCII character is received from the keyboard
; out : al = character
readchar:
el0: mov ah,0 ; wait for a keyboard event
int 16h ; call BIOS
cmp al,0 ; is a scan code in ah ?
je el0 ; yes, ignore
ret
lfbyes: db 0 ; at least one mode support LFB (T/F)
uvstate: db 4 ; 04h - bit 2 = 25/50 lines
; 10h - bit 4 on = GAG
; 20h - bit 5 on = LILO
; 40h - bit 6 on = GRUB
; 80h - bit 7 off = BBM in MBR / on = foreign
memoriz: db 0 ; (25)
initinfo: db CR,LF,'Set Init= to a green mode val'
db 'ue and Boot=DisplayLinear',CR,LF,LF
invitretn: db 'Press any key to continue',CR,LF,0
; ===== procedure: info about the partition type of the current entry
; in : si = pointer to lba in entry
info:
mov bp,si ; save entry pointer used in readblock
ret ; shortcut the remaining code
; trace code snippet, now deactivated (16 bytes)
mov dh,[si-4] ; partition type
ptyp: mov al,dh
; in : al = byte to display as 2 hexadecimal digits
char2hex: call hex
call writechar
xchg ah,al ;
call writechar
mov al,' '
call writechar
ret
; ===== procedure: add an lba value and partition type to the lbalist
; the address of the next free slot is available in lbaslot
; in : si: partition table entry address
; ebx: LBA value
addlba:
; call readchar ; used to pause between detected partitions
; NOTE: can be used to trace the progress through the partition table entries.
mov cl,[si - 4] ; get partition type
mov edx,[si + 4] ; (24) get partition size in blocks
push si ; save partition table entry address
mov si,word [newloc + lbaslot] ; next free slot address
mov [si],ebx ; save LBA in lbalist
mov byte [si + 16],cl ; save partition type
mov dword [si + 17],edx ; (24) save partition size
pop si
ret
; ===== procedure: restore the default text in the lbadesc table
restorelba:
mov bx,newloc + lbadesc
nxtdft: mov si,newloc + dfttext ;
mov di,bx ;
add di,byte 3
mov cx,10 ; dfttext length
rep movsb ; restore text
add bx, byte lbalen
cmp bx,word [newloc + lbaslot]
jb nxtdft
; finally, reset the lbaslot content to the first slot address
mov word [newloc + lbaslot],newloc + lbalist
mov word [newloc + locked],0 ; none is locked
ret
; ===== procedure: set the color attribute of 11 characters
; light red is used to warn when a partition is not bootable as is the case
; for an extende one or when the PBR has no signature signID
; in : pointer to string to display
hilite:
cmp dword [bx + 3],'no P' ; 'no PBR'
je short setred11
cmp dword [bx + 3],'|no ' ; '|no PBR'
je short setred11
cmp dword [bx + 3],'Exte' ; 'Extended'
jne short hiliteno
setred11: mov cx,11 ; string length
setred: push bx ; user defined string length
mov bx,0ch ; light red
setattrib: mov ax,0920h ; write blank and attribute
int 10h ; call BIOS - display characters
pop bx
hiliteno: ret
; ===== procedure: set the color attribute of 1 character
; mod : ax, cx
setwhite: mov cx,1 ; write 1 character
push bx ; user defined string length
mov bx,07h ; white
jmp short setattrib
; ===== procedure: set the color attribute of 12 characters
; mod : ax, cx
setblue23: mov cx,23
push bx ; user defined string length
mov bx,1fh ; light blue
jmp short setattrib
; ===== procedure: set the color attribute of 4 characters
; mod : ax, cx
setgreen4: mov cx,4
setgreen: push bx ; user defined string length
mov bx,0ah ; light green
jmp short setattrib
; ===== procedure: set the color attribute of 4 characters
; mod : ax, cx
setyellow4: mov cx,4
push bx ; user defined string length
mov bx,0eh ; light yellow
jmp short setattrib
; ===== procedure: inspect the PCI Bus (7)
; References:
; PCI Bus Specifications - Intel
inspectpci:
; PCI1 - Determine if a PCI BIOS is present
mov ax,0b101h ; pci function id / pci bios present
int 1ah ; call BIOS
jc short nopci ; cf = 1 means 'no BIOS present'
cmp edx,'PCI ' ; edx <> 'PCI ' means 'no BIOS present'
jne short nopci ;
or ah,ah
jnz short nopci ; ah <> 0 means 'no BIOS present'
and al,3h ; extract hardware mechanism bits 0,1
or [newloc + hwmech],al ; transform to decimal character
mov al,bh ;
or [newloc + pciversion],al ; transform to decimal character
mov al,bl ;
shr al,4
or [newloc + pciversion + 2],al ; transform to decimal character
mov al,bl ;
and al,0fh
or [newloc + pciversion + 3],al ; transform to decimal character
mov [newloc + lastbus],cl ; save number of last PCI bus
call WILAstring
dw newloc + equtitle
; PCI2 - Explore bus by bus until last bus in the system
xor bx,bx ; 0 in bh & bl
nextbus: push bx
call scanbus ; (15)
pop bx
inc bh
cmp bh,[newloc + lastbus]
jbe nextbus
nopci: ret
; ===== procedure: scan the PCI bus (15)
; Inspired from Bluebottle PCITools.Mod - ReadConfigDword
; bh = bus number - range 0 .. 0ffh
; bl = devfn - range 0 .. 0feh
; dh = ismulti - dl = devfn MOD 8
scanbus:
xor bl,bl ; 0 in devfn
xor dx,dx ; clear
nxtdevfn: cmp bl,0feh ; FOR devfn := 0 TO 0feh DO
jbe short trydevfn
ret
trydevfn: mov dl,bl
and dl,7 ; devfn MOD 8
cmp dl,0 ; IF devfn MOD 8 = 0 THEN
je short okdevfn
test dh,80h ; (dh) ODD(hdrtype DIV 80h)
jz near gonext
okdevfn: mov di,0eh ; hdrtype offset in al
call readpcib
cmp dl,0 ; IF devfn MOD 8 = 0 THEN
jne short skiptest
mov dh,al ; hdrtype in dh (prepare multi)
skiptest: mov di,0 ; vendor offset
call readpciw ; load vendor in ax
cmp ax,0ffffh ; IF vendor = 0ffffh THEN skip
je near gonext
; !!! from here on, bl, bh and dh must be left untouched until gonext: is
; reached and execution returns to trydevfn: and to line (dh) above
; dl is computed at each round
mov [newloc + venid],ax ; save vendor
; fill area with blanks - reset in preparation of collecting new infos
mov si,newloc + devbus ; fill with blanks
mov cx,devend - devbus ; # of blanks
insertb: mov byte [si],' '
inc si
loop insertb
mov di,newloc + manid ; insert vendor in hex there
call int2hex4
mov al,bh ; bus
or al,'0' ; convert to decimal character
mov byte [newloc + devbus],al ; stow away in text
mov al,bl ; device & function
shr al,3 ; device
call hex ; convert to 2 hex characters
mov [newloc + devno],ax ; stow away in text
mov al,bl
and al,7 ; extract function (3 LSB)
or al,'0' ; convert to decimal character
mov [newloc + devfunno],al ; stow away in text
; get the device but do not search it. It cannot be found anyway.
mov di,2 ; offset to device
call readpciw ; load device in ax
mov di,newloc + devid ; insert device in hex there
call int2hex4
mov ax,[newloc + venid] ; retrieve vendor
; get the device class and subclass
mov di,0ah ; offset to class
call readpciw ; load class and subclass in ax
call movedescr
; discriminate the device classes
; CASE '0ch'
; discriminate the various serial bus types 00, 03, 05
serialbus: cmp ah,0ch ; is serial bus controller ?
jne short notserb ;
push ax
mov si,newloc + serialdesc
call movesubd
pop ax
notsmbus: cmp al,03h ; is USB controller ?
je short moreusb
jmp word classdone
moreusb: push dx
; get USB Specification release
mov di,60h ; offset to read USB Spec. release
call readpcib ; read byte
call hex
mov [newloc + devrel],al ; stow away in text
mov byte [newloc + devdot],'.' ; stow away in text
mov [newloc + devrelsub],ah ; stow away in text
; get the device Programming Interface
mov di,09h ; offset to PI
call readpcib ; load PI in ax
; process the base address
mov di,20h ; offset to base address
call readpciw ; read word in ax
and ax,0fffeh ; clear bit 0
mov [newloc + ioadd],ax ; save IOaddr for later
mov dx,[newloc + ioadd] ;
add dx,byte 10h ; USB port 1 register (base + 10h)
mov di,newloc + devport1
call getport
add dx,byte 02h ; USB port 2 register (base + 12h)
mov di,newloc + devport2
call getport
pop dx
jmp classdone
; times 9*blocksize - ($-$$) db filler
; --------------------------------------------------------------------
; LBA 9 - PCI information collection (15)
; CASE '01h'
cmp ah,01h ; is mass storage controller ?
jne short serialbus
mov si,newloc + massdesc
call movesubd
jmp word classdone
; CASE '02h'
notserb: cmp ah,02h ; is network controller ?
jne short displayc
mov si,newloc + netwdesc
call movesubd
jmp classdone
; CASE '03h'
displayc: cmp ah,03h ; is display controller ?
jne short mmedia
mov si,newloc + dispdesc
call movesubd
jmp short classdone
; CASE '04h'
mmedia: cmp ah,04h ; is multimedia ?
jne short bridge
mov si,newloc + mediadesc
call movesubd
jmp short classdone
; CASE '06h'
; discriminate the various bridge
bridge: cmp ah,06h ; is bridge ?
jne short classdone
cmp al,04h ; is PCI bridge ?
jne short notPCIb
mov byte [newloc + ht],1
notPCIb: mov si,newloc + bridgdesc
call movesubd
; ENDCASE
classdone: call WILAstring
dw newloc + devdesc
mov ah,dh ; hdrtype
and ah,7fh ; hdrtype MOD 80h
cmp byte [newloc + ht],ah
jne short gonext
mov di,1ah ; offset to buses + 2
call readpcib ; read byte in ah
cmp ah,0 ;
je short gonext ; yes
mov di,18h ; offset to buses
call readpciw ; read word in ax
cmp ax,0
je short gonext
pusha
mov bh,ah
call scanbus
popa
gonext: inc bl
jmp word nxtdevfn
; ===== procedure: move class description to info line
movedescr: push ax
mov si,newloc + classdesc
movenextr: sub ah,1
cmp ah,0
je short moveendc
add si,word classlen
jmp short movenextr
moveendc: mov di,newloc + devclass
mov cx,word classlen
rep movsb
pop ax
ret
; ===== procedure: move subclass description to info line
movesubd: cmp al,80h
je short move80
movenexts: cmp al,0
je short moveends
add si,word subclasslen
sub al,1
jmp short movenexts
move80: mov si,newloc + subcother
jmp short movevalid
moveends: cmp byte [si],byte 0ffh
jne short movevalid
mov si,newloc + subcinval
movevalid: mov di,newloc + devsubclass
mov cx,word subclasslen
rep movsb
ret
; ===== procedure: read a word
; in: bh,bl
; di = word offset
; out: ax = word read (transfered from cx)
readpciw:
mov ax,0b109h ; read word
readpci: int 1ah ;
mov ax,cx
ret
; ===== procedure: read a byte
; in: bh,bl
; di = byte offset
; out: al = byte read (transfered from cx)
readpcib:
mov ax,0b108h ; read byte
jmp readpci
; ===== procedure: get information on attached device(s)
; in: dx = IO base address
; out: ax = port status/control register contents
getport:
in ax,dx
and ax,0105h ; bit 8 = 1 : suspended, bit 2 = 1 : enabled
cmp ax,0005h ; bit 0 = 1 : device present
je short getportp ; device present
mov byte [di],'_'
jmp short getporta ; device absent
getportp: mov byte [di],'*'
getporta: ret
; ===== procedure: write a string specified by in-line address
; call WILAstring
; dw newloc + fieldname
; Saves one byte per instruction pair (frequently used)
; mov si,newloc + fieldname
; call writestring
WILAstring:
push bp ; save bp (the caller might be using it)
mov bp,sp ; bp now used to access the stack
mov si,[bp + 2] ; get old IP (return address)
mov si,[si] ; get word after call instruction
call writestring
add word [bp + 2], byte 2 ; return addres is 2 bytes further
pop bp ; restore
ret
; ===== procedure: extract the current drive number given its index
; in : cl = drive index
; out : dl = drive number
getdrvno:
mov al,cl
cbw
add ax,newloc + drivenbrs ;
mov si,ax
mov dl,[si]
ret
; ===== procedure: announce start of selected OS
announce: ; (20)
; insert the volume number in a readable form in the msg text
; the partition number is already in the text in readable form
pusha
call hex
mov [newloc + drvcharh],al
xchg ah,al ;
mov [newloc + drvcharl],al
call WILAstring
dw newloc + launchos
popa
ret
; ===== procedure: add some persistance to a text line (23)
; let the message appear for a few seconds, approx. 4"
persistance:
pusha
xor ah,ah ; get tick count
int 1ah ; call BIOS - timer service in dx
mov bx,dx ; save RTC
add bx,byte 70 ; add 70 ticks x 55 ms = 3850 ms
waittim: xor ah,ah ; get tick count
int 1ah ; call BIOS - timer service
cmp dx,bx ; is tick count >= limit saved in cx
jb waittim ; wait time not expired
popa
ret
; ===== procedure: collect as much drive interface information as possible
; depending on how much data was returned by BIOS in dpbuffer
interfinfo:
mov si,newloc + dpbuffer ; extra-muros buffer
cmp word [si],byte 30 ; (13) 30 or less bytes received ?
jbe exitIF ; (13) yes, very little info available
mov di,[newloc + driveslot] ; (13)
add di,word 84 ; (13) destination is next line element
cmp word [newloc + interftype],'AT' ; (13) test ATA or ATAPI
jne short notATA ; (13)
mov dword [di],'IDE '
cmp word [newloc + key],0beddh ; device path info available ?
jne short exitIF ; no interface info
cmp byte [newloc + primary],0 ; (13)
je short isprim ; (13)
mov byte [di + 3],'2' ; (13)
jmp short tstmaster ; (13)
isprim: mov byte [di + 3],'0' ; (13)
tstmaster: cmp byte [newloc + master],0 ; (13)
je short exitIF ; (13)
add byte [di + 3],01h ; (13)
jmp short exitIF ; (13)
notATA: cmp word [newloc + interftype],'US' ; (13) test USB
jne short exitIF ; (13)
mov dword [di],'USB ' ; (13)
exitIF: ret ;
; ===== procedure: display CPU info extracted with CPUID (21)
; Should be applicable to CPUs of:
; Intel Corp. - Vendor ID 8086h
; AMD - Vendor ID 1022h
; Via (formerly UDT/Centaur) - Vendor ID 1106h
; Could be applicable to Transmeta - not tested
; The CPUID instruction is not known by this assembler
; hence machine code is used instead
; Executed only once when the MBR of a volume is executed
CPUID: equ 0a20fh ; machine hard code
cpuinfo:
; References:
; Intel: How to determine whether a processor supports
; hyper-threading
; Detecting Multi-Core Processors
; softwarecommunity.intel.com/Wiki/Processorfeaturedetection/63.htm
; 6/17/2007
; Advanced Micro Devices - CPUID Specification Rev. 2.18 Jan. 2006
; CPUID - Determine if the CPUID instruction is supported
; by checking ability to set/clear ID flag (bit 21) in EFLAGS
; http://www.delphigl.com/forum/viewtopic.php?t=4621
; google: test eflags
pushfd ; EFLAGS on stack
pop eax ; copy EFLAGS to eax
mov ebx,eax ; save a copy
xor eax, 00200000h ; flip ID bit 21 in EFLAGS
push eax ; new value on stack
popfd ; new value in EFLAGS
pushfd ; EFLAGS on stack
pop eax ; copy EFLAGS in eax
cmp eax, ebx ; compare to see if toggled
jnz short cpuidyes ; jmp if value changed
; CPUID not supported, one should check for Cyrix family but don't and
; assume "classic" Intel
mov si,newloc + cpuidno
mov di,newloc + vendebx
mov cx,33
rep movsb
ret
; CPUID - Get vendor string and stow in text
cpuidyes: xor eax,eax ; clear
dw CPUID ; machine code
mov [newloc + vendebx],ebx
mov [newloc + vendecx],ecx
mov [newloc + vendedx],edx
; CPUID - Determine family, model, stepping
mov eax,1
dw CPUID ; machine code
; 4 instructions suppressed - Stepping value not important
; mov ecx,eax ; save
; call hex
; mov [newloc + cpus],ah ; stepping
; mov eax,ecx ; restore
shr eax,4
call hex
mov [newloc + cpuf],al ; family
mov [newloc + cpum],ah ; model
; CPUID - Determine if deterministic cache parameters supported
xor eax,eax ; clear
dw CPUID ; machine code
cmp ax,4 ; supported ?
jl short getHT ; not supported, assume single-core
; CPUID - Read deterministic cache parameters and validate
mov eax,4
mov ecx,0
dw CPUID ; machine code
push eax
and al,1fh ; valid cache parameters read ?
cmp al,00h ; eax[4:0] = 0 indicates invalid
pop eax
je short getBrand
shr eax,14
; add ax,31h ; add 1 and convert to printable digit
; mov [newloc + logipack],al ; logical processors sharing a cache
shr eax,12 ; # of processor cores on this package/die
add ax,31h ; add 1 and convert to printable digit
mov [newloc + phycores],al
; CPUID - Determine hyperthreading when not MCP - Multi-Core
; NOTE: this only to assert that a physical package is capable of hardware HT.
; It does no imply that HT is enabled.
getHT: mov eax,1
dw CPUID ; machine code
shr ebx,16
; If an IA-32 processor does not have HW HT support,
; the value in ebx[23:16] is reserved
; bl = max. number of logical processors in a physical package
; bh = APIC ID
test edx,010000000h ; hyper-threading bit 28
jz short getBrand
mov byte [newloc + HTind],'Y' ; replace 'N' by 'Y'
or bl,30h ; convert to printable digit
mov [newloc + logiprocs],bl ; stow in text
; CODE LIMITATION: max. 8 logical processors
; mov al,bh ; APIC ID
; call hex ; convert to 2 hex characters
; mov [newloc + cpuapic], ax ; stow away in text
; CPUID - Obtain the Processor Brand string if supported
getBrand: mov eax,80000002h
dw CPUID ; machine code
cmp eax,byte 0 ; eax = 0 : no brand string
jz short nobrand
mov di,newloc + brand
call mov16char
mov eax,80000003h
dw CPUID ; machine code
call mov16char
mov eax,80000004h
dw CPUID ; machine code
call mov16char
; CPUID - Determine width
nobrand: mov eax,80000000h
dw CPUID ; machine code
and eax,byte 0fh ;
cmp eax,byte 0 ;
je short not64
mov eax,80000001h
dw CPUID ; machine code
test edx,20000000h ; long mode 64-bit bit 29
jz short not64
mov word [newloc + cpuwidth],'64'
not64: ret
; ===== procedure: move 16 characters from 4 registers
mov16char:
mov [di],eax
mov [di + 4],ebx
mov [di + 8],ecx
mov [di + 12],edx
add di,16
ret
; TUI title line
prompt: db 'Boot Manager '
pdate: db '??/??/???? - ',0 ; transferred from LBA 0
; Information repository for cpuid instructions
; LINE 1
; NOTE the register order: ebx, edx, ecx!!!
vendebx: dd 0
vendedx: dd 0
vendecx: dd 0
brand: times 48 db ' ' ; 3 * 16 char fixed
; The brand string ends with 0h, thus a newline is needed
; LINE 2
newline: db CR,LF
cpuwidth: db '32' ; 32 or 64
db '-bit processor Family 0'
cpuf: db '?'
db 'h Model 0'
cpum: db '?'
; db 'h Stepping 0'
;cpus: db '?'
db 'h Cores: '
phycores: db '1' ; # of cores in a physical package
db ' Logicals: '
logiprocs: db '1'
; max. # of logical processors in a physical package = HW capability of the
; processor as manufactured and does not necessarily equate to the # of
; logical processors enabled by the platform BIOS or operating system.
; db ' LPSh: '
;logipack: db '1' ; # of logical processors sharing a cache
db ' HT: '
HTind: db 'N' ; hyper-threading capable 'Y' / 'N'
; db ' APIC '
;cpuapic: db '**'
db CR,LF,LF,0
cpuidno: db 'not supported, classic Intel/AMD',0 ; to be moved to vendebx
; adapted from PCI SIG Class Code Table - www.pcisig.com
classlen: equ 15 ; 15-character entry
classdesc: db 'Mass Stor. Ctrl'
db 'Network Ctrl'
db 'Display Ctrl'
db 'Multimed Device'
db 'Memory Ctrl'
db 'Bridge Device'
db 'Communic. Ctrl'
db 'Base peripheral'
db 'Input Device'
db 'Docking Station'
db 'Processor '
db 'Serial bus Ctrl'
subclasslen: equ 8 ; 8-character entry
massdesc: db 'SCSI '
db 'IDE '
db 'Floppy '
db 0ffh
netwdesc: db 'Ethernet'
db 0ffh
dispdesc: db 'VGA comp'
db 'XGA '
db 0ffh
mediadesc: db 'Video '
db 'Audio '
db 'Telephon'
db 'Audio '
db 0ffh
bridgdesc: db 'Host/PCI'
db 'PCI/ISA '
db 'PCI/EISA'
db 'PCI/MIC '
db 'PCI/PCI '
db 'PCI/PCMC'
db 'PCI/NuBu'
db 'PCI/Card'
db 0ffh
serialdesc: db 'Firewire'
db 'ACCESS '
db 'SSArchit'
db 'USB '
db '???? '
db 'SMBus '
db 0ffh
subcinval: db ' unknown'
subcother: db ' other'
; References:
; USB in DOS - "http://www.cybertrails.com/~fys/usb.htm"
; UHCI Design Guide - Revision 1.1 - Intel
; "ftp://download.intel.com/design/usb/uhci11d.pdf"
; http://www.beyondlogic.org/usbnutshell/
devindex: db 3fh,3fh
venid: dw 0
ioadd: dw 0
ht: db 0
lastbus: db 0
; PC equipment information title
equtitle: db 'PC equipment - PCI version '
pciversion: db '0.00'
db ' HW mechanism '
hwmech: db '0',CR,LF,LF
db 'Bus Dev Fun Ven. Dev. Class Subclass Rel P1 P2',CR,LF,0
; one line of device description (equivalent to PCITools.Scan)
devdesc: db ' '
devbus: db '?'
db ' '
devno: db '??'
db ' '
devfunno: db '?'
db ' '
manid: db '????'
db ' '
devid: db '????'
db ' '
devclass: times classlen db '?'
db ' '
devsubclass: times subclasslen db '?'
db ' '
devrel: db '?'
devdot: db '.'
devrelsub: db '?'
db ' '
devport1: db '?'
db ' '
devport2: db '?'
devend: db CR,LF,0
times 12*blocksize - ($-$$) db filler
; --------------------------------------------------------------------
; LBA 12 - Data areas holding information for the next system boot
; CAUTION! This area might be occupied by a GRUB boot manager.
; Beware of a programming error in this Boot Manager when
; deciding to record this block by a call writeblock just
; before reading and transferring control to the PBR.
; defaultd & defaultp contain the number of the drive and of the partitition
; selected last.
; When defaultd is zero (no default yet set), the user is prompted
; to enter values which will then become the defaults.
; Otherwise, prompting must be forced by the user.
; message issued when starting immediately the default OS designated
; by defaultd and defaultp
launchos: db 'Starting OS on volume '
drvcharh: db '?'
drvcharl: db '?'
db ' partition '
; Partition number to boot by default without user interaction:
; "01", "02" ..., the same as used by Bluebottle for numbering partitions
defaultp: db '??'
db ' in 4"...',0 ; 4" seconds delay
; Default volume number hosting the partition to boot:
; 80h, 81h ... for hard disks (internal or external)
; value 0 means that no default was set, the boot menu is displayed.
defaultd: db 0
selectinit: db 10,'Enter one of the following:',CR,LF
db ' the number of a partition hosting an OS to start (red = no OS detected)',CR,LF
db ' Set ScrollLock to halt AOS start-up.',CR,LF,0
; drive list save area - 8 x 10 bytes
prevdlen: equ 10
prevdlist: db ' '
db ' '
db ' '
db ' '
db ' '
db ' '
db ' '
db ' '
times 13*blocksize - ($-$$) db filler
; --------------------------------------------------------------------
; Extra-muros buffer (placed in memory after the previous block)
; to contain the drive parameters information (8)
; Experience shows that at most 30 bytes (1eh) are returned by the BIOS call,
; instead of the documented 74 bytes, even when modern hardware is present
; (offset decimal)
dpbuffer: dw 74 ; (0) buffer length / size of returned data
infflags: dw 0 ; (2) information flags
dd 0 ; (4) number of physical cylinders
dd 0 ; (8) number of physical heads
sectptr: dd 0 ; (12) number of physical blocks per track
sectnumb: dd 0,0 ; (16) number of physical blocks quadword
dw 0 ; (24) number of bytes per block
dpteoff: dw 0 ; (26) pointer to DPTE seg:offset
dpteseg: dw 0
key: dw 0 ; (30) key
db 0,0,0,0 ; (32) length of device path information
bus: db 0,0,0,0 ; (36) host bus type (ASCII)
interftype: dd 0,0 ; (40) interface type (ASCII: ATA, ATAPI, SCSI ..)
interfpath: dd 0,0 ; (48) interface path
; (56) device path - 16 bytes
master: db 0ffh ; 0 = master, 1 = slave
primary: db 0ffh,0,0 ; 0 = primary, 1 = secondary channel
dd 0,0,0
db 0,0,0,0 ; (72)
dd 0,0,0,0 ; (76) free space to adjust
dd 0,0,0,0
dd 0,0,0,0
dd 0
drivelistul: dd 0,0,0,0 ; drivelist underline showing current drive
dd 0,0,0,0 ; 1 * 80-position screen line as sequence
dd 0,0,0,0 ; of spaces terminated with marks
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
dd 0,0,0,0
; times 14*blocksize - ($-$$) db filler
; --------------------------------------------------------------------
; Extra-muros buffer (placed in memory after the previous block)
; to contain the VBE Controller Information (3)
; obtained with a int 10h BIOS call, function 4f00h (see inspectvbe)
; 512-byte information block
vesatab: db 'VBE2' ; 00 - VBE2.0 information request
vbevers: dw 0 ; 04
oemptr: dd 0 ; 06 - pointer to OEM info
capab: db 0,0,0,0 ; 0a
modeptr: dd 0 ; 0e
totalmem: dw 0 ; 12
; added for VBE 2.0
software: dw 0 ; 14 - VBE implementation software rev.
vendptr: dd 0 ; 16 - pointer to OEM vendor name
prodptr: dd 0 ; 1a - pointer to OEM product name
revision: dd 0 ; 1e - pointer to OEM product revision
; The buffer at address newloc + vesatab + blocksize is used
; to store VBE mode information (3)
; and disk information
