OSDev.org

Code: Select all

EnableA20:

    cli
    pusha

        call    wait_input
        mov     al,0xAD
        out     0x64,al     ; disable keyboard
        call    wait_input

        mov     al,0xD0
        out     0x64,al     ; tell controller to read output port
        call    wait_output

        in      al,0x60
        push    eax     ; get output port data and store it
        call    wait_input

        mov     al,0xD1
        out     0x64,al     ; tell controller to write output port
        call    wait_input

        pop     eax
        or      al,2        ; set bit 1 (enable a20)
        out     0x60,al     ; write out data back to the output port

        call    wait_input
        mov     al,0xAE     ; enable keyboard
        out     0x64,al

        call    wait_input
    popa
        sti
        ret

    ; wait for input buffer to be clear

wait_input:
        in      al,0x64
        test    al,2
        jnz     wait_input
        ret

    ; wait for output buffer to be clear

wait_output:
        in      al,0x64
        test    al,1
        jz      wait_output
        ret

Code: Select all

gdt:
	NULL: equ $-gdt
	dd 0
	dd 0

	CODE: equ $-gdt
	dw 0xFFFF
	dw 0
	db 0
	db 10011010b
	db 11001111b
	db 0

	DATA: equ $-gdt
	dw 0xFFFF
	dw 0
	db 0
	db 10010010b
	db 11001111b
	db 0
gdt_end:
pointer:
	dw gdt_end - gdt - 1
	dd gdt 

install_gdt:
	pusha
	cli
	lgdt [pointer]
	sti
	popa
	ret

Code: Select all

 
org 0x0

bits 16

;set up segment registers base to 0x07C0
stage1:
	mov ax,0x07C0
	mov ds,ax
	mov es,ax
	
	mov ax,0x0	
	mov ss,ax
	mov sp,0xFFFF

;reset disk, so we start at 0x0 of disk.
resetdisk:
	mov ah,0x0
	mov dl,0x80
	int 0x13
	jc resetdisk

;es:bx = 0x50:0x0. This where we load the 2nd stage. Physical -> 0x500
	mov bx,0x0050
	mov es,bx
	mov bx,0x0

;load stage 2 from sector 2. stage 2 is 512 bytes, so load just the 1 sector.
load_stage2:
	mov ah,0x02
	mov al,0x1  ;just the one sector for stage 2, 512 bytes
	mov ch,0x0
	mov cl,0x2  ;stage 2 is on 2nd sector of disk
	mov dh,0x0
	mov dl,0x80
	int 0x13
	jc load_stage2

;print "Loading Stage 2"
	mov si,msg_stage1
print:
	lodsb
	or al,al
	jz here
	mov ah,0x0E	
	int 0x10
	jmp print

;Now do a far jump to 0x50:0x0, which is where stage 2 is loaded.	
here:
	jmp 0x50:0x0

msg_stage1 db "Loading Stage 2",13,10,0

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

Code: Select all

org 0x500

jmp stage2

%include "GDT.inc"
%include "A20.inc"

bits 16

%define KERNEL 0x100000

;set up segment registers
stage2:
	xor ax,ax
	mov ds,ax
	mov es,ax
	mov ax,0x9000
	mov ss,ax
	mov sp,0xFFFF

;print "Loading OS" , as that is what we're doing
	mov si,msg_stage2
print:
	lodsb
	or al,al
	jz do_stuff
	mov ah,0x0E
	int 0x10
	jmp print

;enable A20 and load GDTR.
do_stuff:
	call EnableA20
	call install_gdt

;reset the disk so accesses start from 0x0
resetdisk:
	mov ah,0x0
	mov dl,0x80
	int 0x13
	jc resetdisk

;es:bx = 0x3000:0x0. This is where we load the kernel, at first.
	mov bx,0x3000
	mov es,bx
	mov bx,0x0
	
;load the kernel from sector 3 of harddisk. Kernel is of 512 bytes, so just load
;the one sector
loadkernel:
	mov ah,0x2
	mov al,0x1  ;just the one sector to load
	mov ch,0x0
	mov cl,0x3  ;sector 3, where the kernel binary is located
	mov dh,0x0
	mov dl,0x80
	int 0x13
	jc loadkernel

;shift to protected mode
protected_mode:
	mov eax,cr0
	or al,1
	mov cr0,eax

	jmp CODE:stage2_5  ;reload segment registers

bits 32

stage2_5:
	mov ax,DATA ;the data selector of GDT
	mov ds,ax
	mov es,ax
	mov fs,ax
	mov gs,ax
	mov ss,ax
	mov esp,0x90000
	
;copy kernel loaded at 0x3000:0x0 in real mode, to the 1 MB mark now.
copykernel:
	mov esi,0x30000   ;physical address of where the kernel is loaded
	mov edi,0x100000  ;physical address of where it is to be copied
	mov ecx,0x200     ;the kernel is of size 512 bytes
	cld
	rep movsb

	jmp CODE:KERNEL   ;jump to the kernel.

msg_stage2 db "Loading OS",13,10,0

times 512-($-$$) db 0

Code: Select all

org 0x100000

bits 32

jmp main

%include "stdio.inc"
%include "GDT.inc"

;load segment registers
main:
	mov ax,DATA
	mov ds,ax
	mov es,ax
	mov ss,ax
	mov esp,0x90000


	call ClrScr32  ;clear the screen
	mov ebx,msg_kernel 
	call Puts32   ;print "Kernel Loaded"
	
msg_kernel db "Kernel Loaded",13,10,0

times 512-($-$$) db 0

Code: Select all

   mov ax,0x9000
   mov ss,ax
   mov sp,0xFFFF