boothead.s

boot启动监视代码 boot启动监视代码

	int	0x16
	jnz	getc		! Keypress?
	xor	ax, ax		! No key
	ret
_getchar:
	movb	ah, #0		! Read character from keyboard
	int	0x16
getc:	cmpb	al, #0x3D	! '=' character
	jnz	noeq
	movb	_eqscancode, ah	! Save scancode of '=' key
noeq:	cmpb	al, #0x0D	! Carriage return
	jnz	nocr
	movb	al, #0x0A	! Change to linefeed
nocr:	xorb	ah, ah		! ax = al
	ret

! int putchar(c);
!	Write a character in teletype mode.  The putc and putk synonyms
!	are for the kernel printk function that uses one of them.
!	Newlines are automatically prepended by a carriage return.
!
.define _putchar, _putc, _putk
_putchar:
_putc:
_putk:	mov	bx, sp
	movb	al, 2(bx)	! al = character to be printed
	testb	al, al		! 1.6.* printk prints null characters
	jz	nulch		! that appear as blanks, so don't do it.
	cmpb	al, #0x0A	! al = newline?
	jnz	putc		! No
	cmpb	wdirty, #0	! Yes, erase wheel and do a carriage return
	jz	nodirt
	movb	al, #0x20	! putc(' ');
	call	putc
nodirt:	movb	al, #0x0D	! putc('\r')
	call	putc
	movb	al, #0x0A	! Restore the '\n' and print it
putc:	movb	ah, #14		! 14 = print character in teletype mode
	mov	bx, #0x0001	! Page 0, foreground color
	int	0x10		! Call BIOS VIDEO_IO
	movb	wdirty, #0
nulch:	ret

! |/-\|/-\|/-\|/-\|/-\	(playtime)
wheel:	push	si
	mov	si, gp		! si = gp
	lodsb
	call	putc		! putc(*si++)
	movb	al, #0x08
	call	putc		! putc('\b')
	cmp	si, #glyphs+4
	jne	wmore
	mov	si, #glyphs
wmore:	mov	gp, si		! gp= si == glyphs + 4 ? glyphs : si;
	incb	wdirty
	pop	si
	ret
.data
	.align	2
gp:	.data2	glyphs
glyphs:	.ascii	"|/-\\"
wdirty:	.data1	0
.text

! void reset_video(int color);
!	Reset and clear the screen.
! void set_cursor(column, row);
!	Position the cursor at a specified column & row.
.define _reset_video, _set_cursor
_reset_video:
	mov	bx, sp
	movb	al, #7		! Assume mode 7: 80x24 monochrome
	cmp	2(bx), #0	! Or is color requested?
	jz	clear
	movb	al, #2		! Mode 2: 80x25 color
clear:	xorb	ah, ah		! Reset video
	int	0x10
	xor	dx, dx		! dl = column = 0, dh = row = 0
	jmp	setcur
_set_cursor:
	mov	bx, sp
	movb	dl, 2(bx)	! dl = column
	movb	dh, 4(bx)	! dh = row
setcur:	xorb	bh, bh		! Page 0
	movb	ah, #0x02	! Set cursor position
	int	0x10
	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, like the type of video
! and amount of memory.  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_video	! returns type of display
.define		_get_ext_memsize  ! returns amount of extended memory in K
.define		_get_low_memsize  ! returns amount of low memory in K
.define		_get_processor	! returns processor type (86, 186, 286, 386)

! 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

! u16_t get_ext_memsize(void);
!	Ask the BIOS how much extended memory there is.

_get_ext_memsize:
	call	_get_processor	! Is this an old crate?
	cmp	ax, #186
	jbe	no_ext		! Don't try the next function, it crashed an XT
	movb	ah, #0x88
	clc			! Carry will stay clear if call exists
	int	0x15		! Returns size (in K) in ax for AT's
	jnb	got_ext_memsize
no_ext:	sub	ax, ax		! Error, probably a PC
got_ext_memsize:
	ret

! u16_t get_low_memsize(void);
!	Ask the BIOS how much normal memory there is.

_get_low_memsize:
	int	0x12		! Returns the size (in K) in ax
	ret

! u16_t get_processor(void);
!	Decide processor type among 8088=8086, 80188=80186, 80286, 80386, 80486.
!	Return 86, 186, 286, 386 or 486.
!	Preserves all registers except the flags and the return register ax.

! Method:
!	8088=8086 and 80188=80186 push sp as new sp, 80286 and 80386 as old sp.
!	All but 8088=8086 do shifts mod 32 or 16.
!	386 stores 0 for the upper 8 bits of the GDT pointer in 16 bit mode,
!	while 286 stores 0xFF.
!	486 has an AC flag the 386 doesn't have.

	o32 = 0x66		! 32 bit operand size prefix

_get_processor:
	push	bp
	mov	bp, sp
	push	sp		! see if pushed sp == sp
	pop	ax
	cmp	ax, sp
	jz	new_processor
	mov	cx, #0x0120	! see if shifts are mod 32
	shlb	ch, cl		! zero tells if 86
	mov	ax, #86
	jz	got_processor
	mov	ax, #186
	jmp	got_processor

new_processor:			! see if high bits are set in saved GDT
	sub	sp, #6		! space for GDT ptr
	.data1	0x0F		! Prefix for 286 instruction: sgdt -6(bp)
	add	-6(bp), ax	! save 3 word GDT ptr (This is NOT an add!)
	cmpb	-1(bp), #0	! top byte of GDT ptr is zero only for 386
	mov	ax, #286
	jnz	got_processor

! 386 or 486
	and	sp, #0xFFFC	! Align stack to avoid AC fault (needed?)
	.data1	o32		! About to operate on a 32 bit object
	pushf			! Push eflags
	pop	ax
	pop	dx		! dx:ax = eflags
	mov	bx, ax
	mov	cx, dx		! Save original eflags
	xor	dx, #0x0004	! Flip the AC bit
	push	dx
	push	ax		! Push modified eflags value
	.data1	o32
	popf			! Load modified eflags register
	.data1	o32
	pushf
	pop	ax
	pop	dx		! Get it again
	push	cx
	push	bx
	.data1	o32
	popf			! Restore original eflags register
	xor	dx, cx		! See if AC bit changed
	test	dx, #0x0004
	mov	ax, #386	! 386 if it didn't react to "flipping"
	jz	got_processor
	mov	ax, #486	! 486 if you can modify the AC bit

got_processor:
	mov	sp, bp
	pop	bp
	ret

! void _bootstrap(device, partoff, partseg)
!	Call another bootstrap routine to boot MS-DOS for instance.  (No real
!	need for that anymore, now that you can format floppies under Minix).
!	The bootstrap must have been loaded at BOOTSEG from "device".
.define _bootstrap
_bootstrap:
	mov	bx, sp
	movb	dl, 2(bx)	! Device to boot from
	lds	si, 4(bx)	! ds:si = partition table entry
	xor	ax, ax
	mov	es, ax		! Vector segment
	mov	di, #BUFFER	! es:di = buffer in low core
	mov	cx, #PENTRYSIZE	! cx = size of partition table entry
	rep
	movsb			! Copy the entry to low core
	mov	si, #BUFFER	! es:si = partition table entry
	mov	ds, ax		! Some bootstraps need zero segment registers
	cli
	mov	ss, ax
	mov	sp, #BOOTOFF	! This should do it
	sti
	jmpf	BOOTOFF, 0	! Back to where the BIOS loads the boot code

! To my surprise this code is so fast that floppy drive 0 was still running
! (tries to boot floppy first), when Minix was started after a hard disk boot.
stop_motor:
	mov	dx, #0x03F2	! Motor drive control bits
	movb	al, #0x0C	! Bits 4-7 for floppy 0-3 are off
	outb			! Kill the motors
	ret

! void minix86(koff, kcs, kds, bootparams, paramsize);
!	Call 8086 Minix or 386 Minix with an 8086 startoff.
.define _minix86
_minix86:
	call	stop_motor	! Turn off floppy drives
	mov	bp, sp		! Pointer to arguments
	mov	ax, #0x100	! Newer boot code
	mov	si, 8(bp)
	mov	di, ds		! di:si = boot parameters
	mov	cx, 10(bp)	! # bytes of boot parameters
	push	cx
	push	si		! Kernel may find these on the stack too
	mov	ds, 6(bp)	! Kernel data segment set
	mov	es, 6(bp)	! Set es to kernel data too
	cli			! Disable interrupts
	jmpf	@2(bp)		! Finally out of this mess!

! Minix is called with ax, di and si as expected, but also with segment
! registers and stack compatible with the 386 call.

! void minix386(koff, kcs, kds, bootparams, paramsize);
!	Call 386 Minix with a 386 mode switch.  Code inspired by the Amoeba
!	386 bootstrap by Leendert van Doorn.
.define _minix386
_minix386:
	call	stop_motor	! Turn off floppy drives
	mov	bp, sp		! Pointer to arguments

	mov	di, ds		! Monitor ds
	mov	si, #gdt	! di:si = Global descriptor table
	mov	bx, #gdt_desc
	call	set_base	! Set base of gdt descriptor

	mov	di, 6(bp)	! Kernel ds
	xor	si, si		! di:si = Kernel data segment
	mov	bx, #ds_desc
	call	set_base	! Set base of kernel ds

	mov	di, ss		! Monitor ss
	xor	si, si		! di:si = Monitor stack segment
	mov	bx, #ss_desc
	call	set_base	! Minix starts with the stack of the monitor

	mov	di, 4(bp)	! Kernel cs
	xor	si, si		! di:si = Kernel text segment
	mov	bx, #cs_desc
	call	set_base	! Set base of kernel cs

	xor	ax, ax
	push	ax
	push	10(bp)		! 32 bit size of parameters on stack
	push	ax
	push	8(bp)		! 32 bit address of parameters (ss relative)

! Use the BIOS to kick us into protected mode.  This is the most portable
! way to enable the A20 address line.  A real programmer would use cr0.

	mov	si, #gdt	! es:si = global descriptor table
	xor	bx, bx		! 8259's must be initialized by the kernel
	movb	ah, #0x89	! Protected mode function code
! Fake an interrupt stack frame as if called from the kernel entry point
	cli			! No more interruptions
	pushf			! Flags
	push	4(bp)		! Kernel cs
	push	2(bp)		! Kernel entry point
	mov	ds, bx		! ds = vector segment
	jmpf	@4*0x15		! "int 0x15"

! The "interrupt" will return directly to the Minix kernel in 386 mode.  The
! split is clean:  No 386 code here, and no 8086 code in the kernel.  The
! boot parameters address and size are on the stack.  They may be retrieved
! using the ss descriptor.

set_base:
	! Set the base of descriptor bx to the 8086 address di:si
	mov	2(bx), di	! Base = segment
	mov	cx, #4
seg2abs:
	shl	2(bx), #1
	rclb	4(bx), #1	! Base = segment << 4
	loop	seg2abs
	add	2(bx), si
	adcb	4(bx), #0	! Base = (segment << 4) + offset
	ret

.data
	.align	2
	UNSET	= 0	! Must be computed

! Global descriptor table.
gdt:
null_desc:
	! Null descriptor
	.data2	0x0000, 0x0000
	.data1	0x00, 0x00, 0x00, 0x00
gdt_desc:
	! Descriptor for this descriptor table
	.data2	8*8-1, UNSET
	.data1	UNSET, 0x00, 0x00, 0x00
idt_desc:
	! Interrupt descriptor table descriptor (no interrupts allowed)
	.data2	0x0000, 0x0000
	.data1	0x00, 0x00, 0x00, 0x00
ds_desc:
	! Kernel data segment descriptor (4Gb flat)
	.data2	0xFFFF, UNSET
	.data1	UNSET, 0x92, 0xCF, 0x00
es_desc:
	! Physical memory descriptor (4Gb flat)
	.data2	0xFFFF, 0x0000
	.data1	0x00, 0x92, 0xCF, 0x00
ss_desc:
	! Monitor data segment descriptor (64Kb flat)
	.data2	0xFFFF, UNSET
	.data1	UNSET, 0x92, 0x40, 0x00
cs_desc:
	! Kernel code segment descriptor (4Gb flat)
	.data2	0xFFFF, UNSET
	.data1	UNSET, 0x9A, 0xCF, 0x00
bios_desc:
	! BIOS segment descriptor (scratch for int 0x15)
	.data2	UNSET, UNSET
	.data1	UNSET, UNSET, UNSET, UNSET