boot.s

计算机启动例子代码

; Edit by Heyongli.
;      Assamble by NASM.


; Linux Boot  
;	           boot.s
;
; boot.s is loaded at 0x7c00 by the bios-startup routines, and moves itself
; out of the way to address 0x90000, and jumps there.
;
; It then loads the system at 0x10000, using BIOS interrupts. Thereafter
; it disables all interrupts, moves the system down to 0x0000, changes
; to protected mode, and calls the start of system. System then must
; RE-initialize the protected mode in it's own tables, and enable
; interrupts as needed.
;
; NOTE! currently system is at most 8*65536 bytes long. This should be no
; problem, even in the future. I want to keep it simple. This 512 kB
; kernel size should be enough - in fact more would mean we'd have to move
; not just these start-up routines, but also do something about the cache-
; memory (block IO devices). The area left over in the lower 640 kB is meant
; for these. No other memory is assumed to be "physical", ie all memory
; over 1Mb is demand-paging. All addresses under 1Mb are guaranteed to match
; their physical addresses.
;
; NOTE1 abouve is no longer valid in it's entirety. cache-memory is allocated
; above the 1Mb mark as well as below. Otherwise it is mainly correct.
;
; NOTE 2! The boot disk type must be set at compile-time, by setting
; the following equ. Having the boot-up procedure hunt for the right
; disk type is severe brain-damage.
; The loader has been made as simple as possible (had to, to get it
; in 512 bytes with the code to move to protected mode), and continuos
; read errors will result in a unbreakable loop. Reboot by hand. It
; loads pretty fast by getting whole sectors at a time whenever possible.

; 1.44Mb disks:
  sectors equ 18
; 1.2Mb disks:
; sectors = 15
; 720kB disks:
; sectors = 9

;.globl begtext, begdata, begbss, endtext, enddata, endbss
;.text
;begtext:
;.data
;begdata:
;.bss
;begbss:
;.text

BOOTSEG equ 0x07c0
INITSEG equ 0x9000
SYSSEG  equ 0x1000			; system loaded at 0x10000 (65536).
ENDSEG	equ SYSSEG + 0x3000             ;SYSSIZE, assume System have 0x8000

;entry start
start:
	mov	ax,BOOTSEG
	mov	ds,ax
	mov	ax,INITSEG
	mov	es,ax
	mov	cx,256
	sub	si,si
	sub	di,di
	rep movsw
	
        jmp	INITSEG:go
go:	cli
        mov	ax,cs
	mov	ds,ax
	mov	es,ax
	mov	ss,ax
	mov	sp,0x400		; arbitrary value >>512

        sti
	
        mov	ah,0x03	; read cursor pos
	xor	bh,bh
	int	0x10
	;=========================================================
        ;Loading system.....
	mov	cx,24
	mov	bx,0x0007	; page 0, attribute 7 (normal)
	mov	bp,msg1
	mov	ax,0x1301	; write string, move cursor
	int	0x10

; ok, we've written the message, now
; we want to load the system (at 0x10000)

	mov	ax,SYSSEG
	mov	es,ax		; segment of 0x010000
	call	read_it
     	;call	kill_motor

; if the read went well we get current cursor position ans save it for
; posterity.

	mov	ah,0x03	; read cursor pos
	xor	bh,bh
	int	0x10		; save it in known place, con_init fetches
	mov	[510],dx	; it from 0x90510.
		

	
        ;=========================================================
        ;Loading system.....
	dis_msg:
        mov     ax,cs
        mov     ds,ax
        mov     es,ax
        mov	cx,24
	mov	bx,0x0007	; page 0, attribute 7 (normal)
	mov	bp,msg2
	mov	ax,0x1301	; write string, move cursor
	int	0x10
        jmp     0x1000:0        ; 和 setup 装入位置一致 
        



; This routine loads the system at address 0x10000, making sure
; no 64kB boundaries are crossed. We try to load it as fast as
; possible, loading whole tracks whenever we can.
;
; in:	es - starting address segment (normally 0x1000)
;
; This routine has to be recompiled to fit another drive type,
; just change the "sectors" variable at the start of the file
; (originally 18, for a 1.44Mb drive)
;
sread:	dw 1			; sectors read of current track
head:	dw 0			; current head
track:	dw 0			; current track
read_it:
	mov ax,es
	test ax,0x0fff
die:	jne die			; es must be at 64kB boundary
	xor bx,bx		; bx is starting address within segment
rp_read:
	mov ax,es
	cmp ax,ENDSEG		; have we loaded all yet?
	jb ok1_read
	ret
ok1_read:
	mov ax,sectors
	sub ax,[sread]
	mov cx,ax
	shl cx,9
	add cx,bx
	jnc ok2_read
	je ok2_read
	xor ax,ax
	sub ax,bx
	shr ax,9
ok2_read:
	call read_track
	mov cx,ax
	add ax,[sread]
	cmp ax,sectors
	jne ok3_read
	mov ax,1
	sub ax,[head]
	jne ok4_read
	inc word [track]

ok4_read:
	mov [head],ax
	xor ax,ax
ok3_read:
	mov [sread],ax
	shl cx,9
	add bx,cx
	jnc rp_read
	mov ax,es
	add ax,0x1000
	mov es,ax
	xor bx,bx
	jmp rp_read

read_track:
	push ax
	push bx
	push cx
	push dx
	mov dx,[track]
	mov cx,[sread]
	inc cx
	mov ch,dl
	mov dx,[head]
	mov dh,dl
	mov dl,0
	and dx,0x0100
	mov ah,2
	int 0x13
	jc bad_rt
	pop dx
	pop cx
	pop bx
	pop ax
	ret
bad_rt:	mov ax,0
	mov dx,0
	int 0x13
	pop dx
	pop cx
	pop bx
	pop ax
	jmp read_track

;
;  This procedure turns off the floppy drive motor, so
;  that we enter the kernel in a known state, and
;  don't have to worry about it later.
; 
kill_motor:
	push dx
	mov dx,0x3f2
	mov al,0
	outb
        jmp delay
  delay:
	pop dx
	ret
;--------------------------------------------------
gdt:
	dw	0,0,0,0		; dummy

	dw	0x07FF		; 8Mb - limit=2047 (2048*4096=8Mb)
	dw	0x0000		; base address=0
	dw	0x9A00		; code read/exec
	dw	0x00C0		; granularity=4096, 386

	dw	0x07FF		; 8Mb - limit=2047 (2048*4096=8Mb)
	dw	0x0000		; base address=0
	dw	0x9200		; data read/write
	dw	0x00C0		; granularity=4096, 386

idt_48:
	dw	0			; idt limit=0
	dw	0,0			; idt base=0L

gdt_48:
	dw	0x800		; gdt limit=2048, 256 GDT entries
	dw	gdt,0x9		; gdt base = 0X9xxxx
	
msg1:
	db 13,10
	db "Loading system ..."
	db 13,10,13,10
msg2:
	db 13,10
	db "Jump to 0x10000 ..."
	db 13,10,13,10,13

times (510-($-$$)) db 0
        dw  0x55AA