! Doshead.s - DOS & BIOS support for boot.c Author: Kees J. Bot

!

!

! This file contains the startup and low level support for the secondary

! boot program. It contains functions for disk, tty and keyboard I/O,

! copying memory to arbitrary locations, etc.

!

! This runs under MS-DOS as a .COM file. A .COM file is what Minix calls

! a common I&D executable, except that the first 256 bytes contains DOS

! thingies.

!

.sect .text; .sect .rom; .sect .data; .sect .bss

K_I386 = 0x0001 ! Call Minix in 386 mode

STACK = 16384 ! Number of bytes for the stack

DS_SELECTOR = 3*8 ! Kernel data selector

ES_SELECTOR = 4*8 ! Flat 4 Gb

SS_SELECTOR = 5*8 ! Monitor stack

CS_SELECTOR = 6*8 ! Kernel code

MCS_SELECTOR= 7*8 ! Monitor code

ESC = 0x1B ! Escape character

! Imported variables and functions:

.extern _caddr, _daddr, _runsize, _edata, _end ! Runtime environment

.extern _k_flags ! Special kernel flags

.extern _mem ! Free memory list

.extern _vdisk ! Name of the virtual disk

.sect .text

.use16 ! Tell 386 assembler we're in 16-bit mode

.define _PSP

_PSP:

.space 256 ! Program Segment Prefix

dosboot:

cld ! C compiler wants UP

xor ax, ax ! Zero

mov di, _edata ! Start of bss is at end of data

mov cx, _end ! End of bss (begin of heap)

sub cx, di ! Number of bss bytes

shr cx, 1 ! Number of words

rep stos ! Clear bss

cmp sp, _end+STACK

jb 0f

mov sp, _end+STACK ! "chmem" to 16 kb

0:

! Are we called with the /U option?

movb cl, (_PSP+0x80) ! Argument byte count

xorb ch, ch

mov bx, _PSP+0x81 ! Argument string

0: jcxz notuflag

cmpb (bx), 0x20 ! Whitespace?

ja 1f

inc bx

dec cx

jmp 0b

1: cmp cx, 2 ! '/U' is two bytes

jne notuflag

cmpb (bx), 0x2F ! '/'?

jne notuflag

movb al, 1(bx)

andb al, ~0x20 ! Ignore case

cmpb al, 0x55 ! 'U'?

jne notuflag

jmp keepumb ! Go grab an UMB

notuflag:

! Remember the current video mode for restoration on exit.

movb ah, 0x0F ! Get current video mode

int 0x10

andb al, 0x7F ! Mask off bit 7 (no blanking)

movb (old_vid_mode), al

movb (cur_vid_mode), al

! We require at least MS-DOS 3.0.

mov ax, 0x3000 ! Get DOS version

int 0x21

cmpb al, 3 ! DOS 3.0+ ?

jae dosok

push tellbaddos

call _printf

jmp quit

.sect .rom

tellbaddos: .ascii "MS-DOS 3.0 or better required\n\0"

.sect .text

dosok:

! Find out how much "low" memory there is available, where it starts and

! where it ends.

mov di, _mem ! di = memory list

mov ax, _PSP+0x80 ! From PSP:80 to next PSP is ours

mov dx, ds

call seg2abs

mov (di), ax

mov 2(di), dx ! mem[0].base = ds * 16 + 0x80

xor ax, ax

mov dx, (_PSP+2) ! First in-use segment far above us

call seg2abs

sub ax, (di)

sbb dx, 2(di) ! Minus base gives size

mov 4(di), ax

mov 6(di), dx ! mem[1].size = free low memory size

! Give C code access to the code segment, data segment and the size of this

! process.

xor ax, ax

mov dx, cs

call seg2abs

mov (_caddr+0), ax

mov (_caddr+2), dx

xor ax, ax

mov dx, ds

call seg2abs

mov (_daddr+0), ax

mov (_daddr+2), dx

mov ax, sp

mov dx, ss ! End of stack = end of program

call seg2abs

sub ax, (_caddr+0)

sbb dx, (_caddr+2) ! Minus start of our code

mov (_runsize+0), ax

mov (_runsize+2), dx ! Is our size

! Patch the regular _getprocessor library routine to jump to 'getprocessor',

! that checks if we happen to be in a V8086 straightjacket by returning '86'.

cseg movb (_getprocessor+0), 0xE9

mov ax, getprocessor

sub ax, _getprocessor+3

cseg mov (_getprocessor+1), ax

! Grab the largest chunk of extended memory available.

call _getprocessor

cmp ax, 286 ! Only 286s and above have extended memory

jb no_ext

mov ax, 0x4300 ! XMS driver check

int 0x2F

cmpb al, 0x80 ! XMS driver exists?

je xmsthere

get_ext: ! No driver, so can use all ext memory directly

call _getprocessor

cmp ax, 486 ! Assume 486s were the first to have >64M

jb small_ext ! (It helps to be paranoid when using the BIOS)

big_ext:

mov ax, 0xE801 ! Code for get memory size for >64M

int 0x15 ! ax = mem at 1M per 1K, bx = mem at 16M per 64K

jnc got_ext

small_ext:

movb ah, 0x88 ! Code for get extended memory size

clc ! Carry will stay clear if call exists

int 0x15 ! Returns size (in K) in ax for AT's

jc no_ext

test ax, ax ! An AT with no extended memory?

jz no_ext

xor bx, bx ! bx = mem above 16M per 64K = 0

got_ext:

mov cx, ax ! cx = copy of ext mem at 1M

mov 10(di), 0x0010 ! mem[1].base = 0x00100000 (1M)

mul (c1024)

mov 12(di), ax ! mem[1].size = "ext mem at 1M" * 1024

mov 14(di), dx

test bx, bx

jz no_ext ! No more ext mem above 16M?

cmp cx, 15*1024 ! Chunks adjacent? (precisely 15M at 1M?)

je adj_ext

mov 18(di), 0x0100 ! mem[2].base = 0x01000000 (16M)

mov 22(di), bx ! mem[2].size = "ext mem at 16M" * 64K

jmp no_ext

adj_ext:

add 14(di), bx ! Add ext mem above 16M to mem below 16M

no_ext:

jmp gotxms

xmsthere:

mov ax, 0x4310 ! Get XMS driver address

int 0x2F

mov (xms_driver+0), bx

mov (xms_driver+2), es

push ds

pop es

movb ah, 0x08 ! Query free extended memory

xorb bl, bl

callf (xms_driver)

testb bl, bl

jnz xmserr

push ax ! ax = size of largest block in kb

mul (c1024)

mov 12(di), ax

mov 14(di), dx ! mem[1].size = ax * 1024

pop dx ! dx = size of largest block in kb

movb ah, 0x09 ! Allocate XMS block of size dx

callf (xms_driver)

test ax, ax

jz xmserr

mov (xms_handle), dx ! Save handle

movb ah, 0x0C ! Lock XMS block (handle in dx)

callf (xms_driver)

test ax, ax

jz xmserr

mov 8(di), bx

mov 10(di), dx ! mem[1].base = Address of locked block

gotxms:

! If we're running in a DOS box then they're might be an Upper Memory Block

! we can use. Every little bit helps when in real mode.

mov ax, 20(di)

or ax, 22(di) ! Can we use mem[2]?

jnz gotumb

mov dx, 0xFFFF ! dx = Maximum size, i.e. gimme all

call getumb ! Get UMB, dx = segment, cx = length

test cx, cx ! Did we get a block?

jz gotumb

xor ax, ax ! dx:ax = memory block

call seg2abs

mov 16(di), ax

mov 18(di), dx ! mem[2].base = memory block base

mov dx, cx

xor ax, ax ! dx:ax = length of memory block

call seg2abs

mov 20(di), ax

mov 22(di), dx ! mem[2].size = memory block length

gotumb:

! Set up an INT 24 "critical error" handler that returns "fail". This way

! Minix won't suffer from "(A)bort, (R)etry, (I)nfluence with a large hammer?".

mov (0x007C), 0x03B0 ! movb al, 0x03 (fail code)

movb (0x007E), 0xCF ! iret

movb ah, 0x25 ! Set interrupt vector

mov dx, 0x007C ! ds:dx = ds:0x007C = interrupt handler

int 0x21

! Time to switch to a higher level language (not much higher)

call _boot

! void ..exit(int status)

! Exit the monitor by returning to DOS.

.define _exit, __exit, ___exit ! Make various compilers happy

_exit:

__exit:

___exit:

mov dx, (xms_handle)

cmp dx, -1 ! Is there an ext mem block in use?

je nohandle

movb ah, 0x0D ! Unlock extended memory block

callf (xms_driver)

mov dx, (xms_handle)

movb ah, 0x0A ! Free extended memory block

callf (xms_driver)

nohandle:

call restore_video

pop ax

pop ax ! Return code in al

movb ah, 0x4C ! Terminate with return code

int 0x21

quit: ! exit(1)

movb al, 1

push ax

call _exit

xmserr:

xorb bh, bh

push bx

push tellxmserr

call _printf

jmp quit

.sect .rom

tellxmserr: .ascii "Extended memory problem, error 0x%02x\n\0"

.sect .text

! int getprocessor(void)

! Prefix for the regular _getprocessor call that first checks if we're

! running in a virtual 8086 box.

getprocessor:

push sp ! Is pushed sp equal to sp?

pop ax

cmp ax, sp

jne gettrueproc ! If not then it's a plain 8086 or 80186

.data1 0x0F,0x01,0xE0 ! Use old 286 SMSW instruction to get the MSW

testb al, 0x01 ! Protected mode enabled?

jz gettrueproc ! If not then a 286 or better in real mode

mov ax, 86 ! Forget fancy tricks, say it's an 8086

ret

gettrueproc: ! Get the true processor type

push bp ! _getprocessor prologue that is patched over.

mov bp, sp

jmp _getprocessor+3

! Try to get an Upper Memory Block under MS-DOS 5+. Try to get one up to size

! dx, return segment of UMB found in dx and size in paragraphs in cx.

getumb:

xor cx, cx ! Initially nothing found

mov ax, 0x3000 ! Get DOS version

int 0x21

cmpb al, 5 ! MS-DOS 5.0 or better?

jb retumb

mov ax, 0x544D ! Get UMB kept by BOOT /U

int 0x15 ! Returns dx = segment, cx = size

jc 0f

cmp ax, 0x4D54 ! Carry clear and ax byte swapped?

je retumb

0: mov ax, 0x5802 ! Get UMB link state

int 0x21

xorb ah, ah

push ax ! Save UMB link state

mov ax, 0x5803 ! Set UMB link state

mov bx, 0x0001 ! Add UMBs to DOS memory chain

int 0x21

mov ax, 0x5800 ! Get memory allocation strategy

int 0x21

push ax ! Save allocation strategy

mov ax, 0x5801 ! Set memory allocation strategy

mov bx, 0x0080 ! First fit, try high then low memory

int 0x21

movb ah, 0x48 ! Allocate memory

mov bx, dx ! Number of paragraphs wanted

int 0x21 ! Fails with bx = size of largest

jnc 0f ! Succeeds with ax = allocated block

test bx, bx ! Is there any?

jz no_umb

movb ah, 0x48 ! Allocate memory

int 0x21

jc no_umb ! Did we get some?

0: mov dx, ax ! dx = segment

mov cx, bx ! cx = size

no_umb: mov ax, 0x5801 ! Set memory allocation strategy

pop bx ! bx = saved former strategy

int 0x21

mov ax, 0x5803 ! Set UMB link state

pop bx ! bx = saved former link state

int 0x21

retumb: ret

! 'BOOT /U' instructs this program to grab the biggest available UMB and to

! sit on it until the next invocation of BOOT wants it back. These shenanigans

! are necessary because Windows 95 keeps all UMBs to itself unless you get hold

! of them first.

umb = 0x80 ! UMB base and size

old15 = 0x84 ! Old 15 interrupt vector

new15 = 0x88 ! New 15 interrupt handler

keepumb:

mov ax, 0x544D ! "Keep UMB" handler already present?

int 0x15

jc 0f

cmp ax, 0x4D54

je exitumb ! Already present, so quit

0:

mov si, new15start

mov di, new15

mov cx, new15end

sub cx, si

rep movsb ! Copy handler into place

add di, 15

movb cl, 4

shr di, cl ! di = first segment above handler

mov cx, cs

cmp cx, 0xA000 ! Are we loaded high perchance?

jb nothigh

werehigh:

add cx, di

mov (umb+0), cx ! Use my own memory as the UMB to keep

mov ax, (_PSP+2) ! Up to the next in-use segment

sub ax, dx ! ax = size of my free memory

cmp ax, 0x1000 ! At least 64K?

jb exitumb ! Don't bother if less

mov (umb+2), 0x1000 ! Size of UMB

add di, 0x1000 ! Keep my code plus 64K when TSR

jmp hook15

nothigh:

mov dx, 0x1000

call getumb ! Grab an UMB of at most 64K

cmp cx, 0x1000 ! Did we get 64K?

jb exitumb ! Otherwise don't bother

mov (umb+0), dx

mov (umb+2), cx

hook15:

mov ax, 0x3515 ! Get interrupt vector

int 0x21

mov (old15+0), bx

mov (old15+2), es ! Old 15 interrupt

mov ax, 0x2515 ! Set interrupt vector

mov dx, new15 ! ds:dx = new 15 handler

int 0x21

mov ax, 0x3100 ! Terminate and stay resident

mov dx, di ! dx = di = paragraphs we keep

int 0x21

exitumb:

mov ax, 0x4C00 ! exit(0)

int 0x21

new15start: ! New interrupt 15 handler

pushf

cmp ax, 0x544D ! Is it my call?

je my15

popf

cseg jmpf (old15) ! No, continue with old 15

my15: popf

push bp

mov bp, sp

andb 6(bp), ~0x01 ! clear carry, call will succeed

xchgb al, ah ! ax = 4D54, also means call works

cseg mov dx, (umb+0) ! dx = base of UMB

cseg mov cx, (umb+2) ! cx = size of UMB

pop bp

iret ! return to caller

new15end:

! u32_t mon2abs(void *ptr)

! Address in monitor data to absolute address.

.define _mon2abs

_mon2abs:

mov bx, sp

mov ax, 2(bx) ! ptr

mov dx, ds ! Monitor data segment

!jmp seg2abs

seg2abs: ! Translate dx:ax to the 32 bit address dx-ax

push cx

movb ch, dh

movb cl, 4

shl dx, cl

shrb ch, cl ! ch-dx = dx << 4

add ax, dx

adcb ch, 0 ! ch-ax = ch-dx + ax

movb dl, ch

xorb dh, dh ! dx-ax = ch-ax

pop cx

ret

abs2seg: ! Translate the 32 bit address dx-ax to dx:ax

push cx

movb ch, dl

mov dx, ax ! ch-dx = dx-ax

and ax, 0x000F ! Offset in ax

movb cl, 4

shr dx, cl

shlb ch, cl

orb dh, ch ! dx = ch-dx >> 4

pop cx

ret

! void raw_copy(u32_t dstaddr, u32_t srcaddr, u32_t count)

! Copy count bytes from srcaddr to dstaddr. Don't do overlaps.

! Also handles copying words to or from extended memory.

.define _raw_copy

_raw_copy:

push bp

mov bp, sp

push si

push di ! Save C variable registers

copy:

cmp 14(bp), 0

jnz bigcopy

mov cx, 12(bp)

jcxz copydone ! Count is zero, end copy

cmp cx, 0xFFF0

jb smallcopy

bigcopy:mov cx, 0xFFF0 ! Don't copy more than about 64K at once

smallcopy:

push cx ! Save copying count

mov ax, 4(bp)

mov dx, 6(bp)

cmp dx, 0x0010 ! Copy to extended memory?

jae ext_copy

cmp 10(bp), 0x0010 ! Copy from extended memory?

jae ext_copy

call abs2seg

mov di, ax

mov es, dx ! es:di = dstaddr

mov ax, 8(bp)

mov dx, 10(bp)

call abs2seg

mov si, ax

mov ds, dx ! ds:si = srcaddr

shr cx, 1 ! Words to move

rep movs ! Do the word copy

adc cx, cx ! One more byte?

rep movsb ! Do the byte copy

mov ax, ss ! Restore ds and es from the remaining ss

mov ds, ax

mov es, ax

jmp copyadjust

ext_copy:

mov (x_dst_desc+2), ax

movb (x_dst_desc+4), dl ! Set base of destination segment

mov ax, 8(bp)

mov dx, 10(bp)

mov (x_src_desc+2), ax

movb (x_src_desc+4), dl ! Set base of source segment

mov si, x_gdt ! es:si = global descriptor table

shr cx, 1 ! Words to move

movb ah, 0x87 ! Code for extended memory move

int 0x15

copyadjust:

pop cx ! Restore count

add 4(bp), cx

adc 6(bp), 0 ! srcaddr += copycount

add 8(bp), cx

adc 10(bp), 0 ! dstaddr += copycount

sub 12(bp), cx

sbb 14(bp), 0 ! count -= copycount

jmp copy ! and repeat

copydone:

pop di

pop si ! Restore C variable registers

pop bp

ret

! u16_t get_word(u32_t addr);

! void put_word(u32_t addr, u16_t word);

! Read or write a 16 bits word at an arbitrary location.

.define _get_word, _put_word

_get_word:

mov bx, sp

call gp_getaddr

mov ax, (bx) ! Word to get from addr

jmp gp_ret

_put_word:

mov bx, sp

push 6(bx) ! Word to store at addr

call gp_getaddr

pop (bx) ! Store the word

jmp gp_ret

gp_getaddr:

mov ax, 2(bx)

mov dx, 4(bx)

call abs2seg

mov bx, ax

mov ds, dx ! ds:bx = addr

ret

gp_ret:

push es

pop ds ! Restore ds

ret

! void relocate(void);

! After the program has copied itself to a safer place, it needs to change

! the segment registers. Caddr has already been set to the new location.

.define _relocate

_relocate:

pop bx ! Return address

mov ax, (_caddr+0)

mov dx, (_caddr+2)

call abs2seg

mov cx, dx ! cx = new code segment

mov ax, cs ! Old code segment

sub ax, cx ! ax = -(new - old) = -Moving offset

mov dx, ds

sub dx, ax

mov ds, dx ! ds += (new - old)

mov es, dx

mov ss, dx

xor ax, ax

call seg2abs

mov (_daddr+0), ax

mov (_daddr+2), dx ! New data address

push cx ! New text segment

push bx ! Return offset of this function

retf ! Relocate

! void *brk(void *addr)

! void *sbrk(size_t incr)

! Cannot fail implementations of brk(2) and sbrk(3), so we can use

! malloc(3). They reboot on stack collision instead of returning -1.

.sect .data

.align 2

break: .data2 _end ! A fake heap pointer

.sect .text

.define _brk, __brk, _sbrk, __sbrk

_brk:

__brk: ! __brk is for the standard C compiler

xor ax, ax

jmp sbrk ! break= 0; return sbrk(addr);

_sbrk:

__sbrk:

mov ax, (break) ! ax= current break

sbrk: push ax ! save it as future return value

mov bx, sp ! Stack is now: (retval, retaddr, incr, ...)

add ax, 4(bx) ! ax= break + increment

mov (break), ax ! Set new break

lea dx, -1024(bx) ! sp minus a bit of breathing space

cmp dx, ax ! Compare with the new break

jb heaperr ! Suffocating noises

pop ax ! Return old break (0 for brk)

ret

heaperr:push nomem

call _printf

call quit

.sect .rom

nomem: .ascii "\nOut of memory\n\0"

.sect .text

! int dev_open(void);

! Open file 'vdisk' to use as the Minix virtual disk. Store handle in

! vfd. Returns 0 for success, otherwise the DOS error code.

.define _dev_open

_dev_open:

call _dev_close ! If already open then first close

mov dx, (_vdisk) ! ds:dx = Address of file name

mov ax, 0x3D22 ! Open file read-write & deny write

int 0x21

jnc opok ! Open succeeded?

cmp ax, 5 ! Open failed, "access denied"?

jne opbad

mov ax, 0x3D40 ! Open file read-only

int 0x21

jc opbad

opok: mov (vfd), ax ! File handle to open file

xor ax, ax ! Zero for success

opbad: ret

! int dev_close(void);

! Close the dos virtual disk.

.define _dev_close

_dev_close:

mov bx, -1

cmp (vfd), bx ! Already closed?

je 1f

movb ah, 0x3E ! Close file

xchg bx, (vfd) ! bx = vfd; vfd = -1;

int 0x21

jc 0f

1: xor ax, ax

0: ret

! int dev_boundary(u32_t sector);

! Returns false; files have no visible boundaries.

.define _dev_boundary

_dev_boundary:

xor ax, ax

ret

! int readsectors(u32_t bufaddr, u32_t sector, u8_t count)

! int writesectors(u32_t bufaddr, u32_t sector, u8_t count)

! Read/write several sectors from/to the Minix virtual disk. Count

! must fit in a byte. The external variable vfd is the file handle.

! Returns 0 for success, otherwise the DOS error code.

!

.define _readsectors, _writesectors

_writesectors:

push bp

mov bp, sp

movb 13(bp), 0x40 ! Code for a file write

jmp rwsec

_readsectors:

push bp

mov bp, sp

movb 13(bp), 0x3F ! Code for a file read

rwsec:

cmp (vfd), -1 ! Currently closed?

jne 0f

call _dev_open ! Open file if needed

test ax, ax

jnz rwerr

0: mov dx, 8(bp)

mov bx, 10(bp) ! bx-dx = Sector number

mov cx, 9

mul512: shl dx, 1

rcl bx, 1 ! bx-dx *= 512

loop mul512

mov cx, bx ! cx-dx = Byte position in file

mov bx, (vfd) ! bx = File handle

mov ax, 0x4200 ! Lseek absolute

int 0x21

jb rwerr

mov bx, (vfd) ! bx = File handle

mov ax, 4(bp)

mov dx, 6(bp) ! dx-ax = Address to transfer data to/from

call abs2seg

mov ds, dx

mov dx, ax ! ds:dx = Address to transfer data to/from

xorb cl, cl

movb ch, 12(bp) ! ch = Number of sectors to transfer

shl cx, 1 ! cx = Number of bytes to transfer

push cx ! Save count

movb ah, 13(bp) ! Read or write

int 0x21

pop cx ! Restore count

push es

pop ds ! Restore ds

jb rwerr

cmp ax, cx ! All bytes transferred?

je rwall

mov ax, 0x05 ! The DOS code for "I/O error", but different

jmp rwerr

rwall: call wheel ! Display tricks

xor ax, ax

rwerr: pop bp

ret

! int getch(void);

! Read a character from the keyboard, and check for an expired timer.

! A carriage return is changed into a linefeed for UNIX compatibility.

.define _getch

_getch:

xor ax, ax

xchg ax, (unchar) ! Ungotten character?

test ax, ax

jnz gotch

getch: hlt ! Play dead until interrupted (see pause())

movb ah, 0x01 ! Keyboard status

int 0x16

jnz press ! Keypress?

call _expired ! Timer expired?

test ax, ax

jz getch

mov ax, ESC ! Return ESC

ret

press:

xorb ah, ah ! Read character from keyboard

int 0x16

cmpb al, 0x0D ! Carriage return?

jnz nocr

movb al, 0x0A ! Change to linefeed

nocr: cmpb al, ESC ! Escape typed?

jne noesc

inc (escape) ! Set flag

noesc: xorb ah, ah ! ax = al

gotch: ret

! int ungetch(void);

! Return a character to undo a getch().

.define _ungetch

_ungetch:

mov bx, sp

mov ax, 2(bx)

mov (unchar), ax

ret

! int escape(void);

! True if ESC has been typed.

.define _escape

_escape:

movb ah, 0x01 ! Keyboard status

int 0x16

jz escflg ! Keypress?

cmpb al, ESC ! Escape typed?

jne escflg

xorb ah, ah ! Discard the escape

int 0x16

inc (escape) ! Set flag

escflg: xor ax, ax

xchg ax, (escape) ! Escape typed flag

ret

! int putch(int c);

! Write a character in teletype mode. The putk synonym is

! for the kernel printf function that uses it.

! Newlines are automatically preceded by a carriage return.

!

.define _putch, _putk

_putch:

_putk: mov bx, sp

movb al, 2(bx) ! al = character to be printed

testb al, al ! Kernel printf adds a null char to flush queue

jz nulch

cmpb al, 0x0A ! al = newline?

jnz putc

movb al, 0x20 ! Erase wheel and do a carriage return

call plotc ! plotc(' ');

nodirt: movb al, 0x0D

call putc ! putc('\r')

movb al, 0x0A ! Restore the '\n' and print it

putc: movb ah, 0x0E ! Print character in teletype mode

mov bx, 0x0001 ! Page 0, foreground color

int 0x10 ! Call BIOS VIDEO_IO

nulch: ret

! |/-\|/-\|/-\|/-\|/-\ (playtime)

wheel: mov bx, (gp)

movb al, (bx)

inc bx ! al = *gp++;

cmp bx, glyphs+4

jne 0f

mov bx, glyphs

0: mov (gp), bx ! gp= gp == glyphs + 4 ? glyphs : gp;

!jmp plotc

plotc: movb ah, 0x0A ! 0x0A = write character at cursor

mov bx, 0x0001 ! Page 0, foreground color

mov cx, 0x0001 ! Just one character

int 0x10

ret

.sect .data

.align 2

gp: .data2 glyphs

glyphs: .ascii "|/-\\"

.sect .text

! void pause(void);

! Wait for an interrupt using the HLT instruction. This either saves

! power, or tells an x86 emulator that nothing is happening right now.

.define _pause

_pause:

hlt

ret

! void set_mode(unsigned mode);

! void clear_screen(void);

! Set video mode / clear the screen.

.define _set_mode, _clear_screen

_set_mode:

mov bx, sp

mov ax, 2(bx) ! Video mode

cmp ax, (cur_vid_mode)

je modeok ! Mode already as requested?

mov (cur_vid_mode), ax

_clear_screen:

mov ax, (cur_vid_mode)

andb ah, 0x7F ! Test bits 8-14, clear bit 15 (8x8 flag)

jnz xvesa ! VESA extended mode?

int 0x10 ! Reset video (ah = 0)

jmp mdset

xvesa: mov bx, ax ! bx = extended mode

mov ax, 0x4F02 ! Reset video

int 0x10

mdset: testb (cur_vid_mode+1), 0x80

jz setcur ! 8x8 font requested?

mov ax, 0x1112 ! Load ROM 8 by 8 double-dot patterns

xorb bl, bl ! Load block 0

int 0x10

setcur: xor dx, dx ! dl = column = 0, dh = row = 0

xorb bh, bh ! Page 0

movb ah, 0x02 ! Set cursor position

int 0x10

modeok: ret

restore_video: ! To restore the video mode on exit

movb al, 0x20

call plotc ! Erase wheel

push (old_vid_mode)

call _set_mode

pop ax

ret

! u32_t get_tick(void);

! Return the current value of the clock tick counter. This counter

! increments 18.2 times per second. Poll it to do delays. Does not

! work on the original PC, but works on the PC/XT.

.define _get_tick

_get_tick:

xorb ah, ah ! Code for get tick count

int 0x1A

mov ax, dx

mov dx, cx ! dx:ax = cx:dx = tick count

ret

! Functions used to obtain info about the hardware. Boot uses this information

! itself, but will also pass them on to a pure 386 kernel, because one can't

! make BIOS calls from protected mode. The video type could probably be

! determined by the kernel too by looking at the hardware, but there is a small

! chance on errors that the monitor allows you to correct by setting variables.

.define _get_bus ! returns type of system bus

.define _get_video ! returns type of display

! u16_t get_bus(void)

! Return type of system bus, in order: XT, AT, MCA.

_get_bus:

call gettrueproc

xor dx, dx ! Assume XT

cmp ax, 286 ! An AT has at least a 286

jb got_bus

inc dx ! Assume AT

movb ah, 0xC0 ! Code for get configuration

int 0x15

jc got_bus ! Carry clear and ah = 00 if supported

testb ah, ah

jne got_bus

eseg movb al, 5(bx) ! Load feature byte #1

inc dx ! Assume MCA

testb al, 0x02 ! Test bit 1 - "bus is Micro Channel"

jnz got_bus

dec dx ! Assume AT

testb al, 0x40 ! Test bit 6 - "2nd 8259 installed"

jnz got_bus

dec dx ! It is an XT

got_bus:

push ds

pop es ! Restore es

mov ax, dx ! Return bus code

mov (bus), ax ! Keep bus code, A20 handler likes to know

ret

! u16_t get_video(void)

! Return type of display, in order: MDA, CGA, mono EGA, color EGA,

! mono VGA, color VGA.

_get_video:

mov ax, 0x1A00 ! Function 1A returns display code

int 0x10 ! al = 1A if supported

cmpb al, 0x1A

jnz no_dc ! No display code function supported

mov ax, 2

cmpb bl, 5 ! Is it a monochrome EGA?

jz got_video

inc ax

cmpb bl, 4 ! Is it a color EGA?

jz got_video

inc ax

cmpb bl, 7 ! Is it a monochrome VGA?

jz got_video

inc ax

cmpb bl, 8 ! Is it a color VGA?

jz got_video

no_dc: movb ah, 0x12 ! Get information about the EGA

movb bl, 0x10

int 0x10

cmpb bl, 0x10 ! Did it come back as 0x10? (No EGA)

jz no_ega

mov ax, 2

cmpb bh, 1 ! Is it monochrome?

jz got_video

inc ax

jmp got_video

no_ega: int 0x11 ! Get bit pattern for equipment

and ax, 0x30 ! Isolate color/mono field

sub ax, 0x30

jz got_video ! Is it an MDA?

mov ax, 1 ! No it's CGA

got_video:

ret

! Function to leave the boot monitor and run Minix.

.define _minix

! void minix(u32_t koff, u32_t kcs, u32_t kds,

! char *bootparams, size_t paramsize, u32_t aout);

_minix:

push bp

mov bp, sp ! Pointer to arguments

mov dx, 0x03F2 ! Floppy motor drive control bits

movb al, 0x0C ! Bits 4-7 for floppy 0-3 are off

outb dx ! Kill the motors

push ds

xor ax, ax ! Vector & BIOS data segments

mov ds, ax

andb (0x043F), 0xF0 ! Clear diskette motor status bits of BIOS

pop ds

cli ! No more interruptions

test (_k_flags), K_I386 ! Minix-386?

jnz minix386

! Call Minix in real mode.

minix86:

push 22(bp) ! Address of a.out headers

push 20(bp)

push 18(bp) ! # bytes of boot parameters

push 16(bp) ! Address of boot parameters

mov dx, cs ! Monitor far return address

mov ax, ret86

cmp (_mem+14), 0 ! Any extended memory? (mem[1].size > 0 ?)

jnz 0f

xor dx, dx ! If no ext mem then monitor not preserved

xor ax, ax

0: push dx ! Push monitor far return address or zero

push ax

mov ax, 8(bp)

mov dx, 10(bp)

call abs2seg

push dx ! Kernel code segment

push 4(bp) ! Kernel code offset

mov ax, 12(bp)

mov dx, 14(bp)

call abs2seg

mov ds, dx ! Kernel data segment

mov es, dx ! Set es to kernel data too

retf ! Make a far call to the kernel

! Call 386 Minix in 386 mode.

minix386:

cseg mov (cs_real-2), cs ! Patch CS and DS into the instructions that

cseg mov (ds_real-2), ds ! reload them when switching back to real mode

mov eax, cr0

orb al, 0x01 ! Set PE (protection enable) bit

o32 mov (msw), eax ! Save as protected mode machine status word

mov dx, ds ! Monitor ds

mov ax, p_gdt ! dx:ax = Global descriptor table

call seg2abs

mov (p_gdt_desc+2), ax

movb (p_gdt_desc+4), dl ! Set base of global descriptor table

mov ax, 12(bp)

mov dx, 14(bp) ! Kernel ds (absolute address)

mov (p_ds_desc+2), ax