Oberon/A2/BootManager.Asm

< Oberon‎ | A2
; 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