init-x.kaba

#----------------------------------------------------------------------------*\
#| Eusebius - Init                                                              |
#| -> A20-Gate aktivieren                                                       |
#| -> GDT laden                                                                 |
#| -> Protected Mode starten (32 bit)                                           |
#| -> Kernel-Image laden und starten                                            |
#|                                                                              |
#| zuletzt geaendert: 2008.09.16 (c) by MichiSoft TM                            |
#\*----------------------------------------------------------------------------


void main()	#-------------------------------------------------------------	# RealMode!!!
	asm{
		bits_16
		
		# Debug
		mov al, 'k'
		mov ah, 0x0e
		mov bx, 0x0000
		int 0x10


		# mehr als 1mb Ram erlauben (Gate 20A... :~~[  )
		mov ax, 0x2401
		int 0x15
		in al, 0x92
		or al, 0x02
		out 0x92, al

		# Speicher-Menge (RAM) feststellen
		mov ax, 0xe801
		int 0x15
		mov [_var_mem_size], bx # #64kb
		shr ax, 0x06
		add [_var_mem_size], ax # #1kb

		# Kernel-Image laden
#		_reset_drive:
			mov dl, 0x00
			mov ah, 0x00
			int 0x13
			or ah, ah
		#jnz _reset_drive
		xor ax, ax
		mov es, ax
		# Ziel des Images
		mov ax, 0x1000
		mov es, ax
		mov bx, 0x0000 # 0x1000:0x0000 = 0x10000 real mode segmentation is ugly
		mov ah, 0x02 # "ReadSector"
		mov al, 0x80 # 128 sectors * 512 bytes = 64k
		mov cx, 0x001d # sector 0x1f, cylinder 0
		mov dx, 0x0080 # head 0x00, disc 0
#		int 0x13
		mov ax, 0x2000
		mov es, ax
		mov bx, 0x0000 # 0x2000:0x0000 = 0x20000 real mode segmentation is ugly
		mov ah, 0x02 # "ReadSector"
		mov al, 0x80 # 128 sectors * 512 bytes = 64k
		mov cx, 0x001f # sector 0x1f, cylinder 0
		mov dx, 0x0280 # head 0x02, disc 0
#		int 0x13
	#	mov al, [0x5008] # Größe: 1Sektor = 512b
	#	mov cx, [0x5004]
	#	mov dx, [0x5006]
	#	int 0x13
		or ah, ah
		#jnz _reset_drive
		
		
		
	
		
		# set destination
		mov   ax, 0x0000 # 0x0030
		mov   [_rsp_dest_hi], ax
		mov   ax, 0xa000 # 0x0000
		mov   [_rsp_dest_lo], ax
		
		# set source
		mov   ax, 0x001c
		mov   [_rsp_lba], ax
		mov   ax, 0x0001
		mov   [_rsp_count], ax
	_read_loop_start:
		
		# if count == 0 break
		mov   ax, [_rsp_count]
		cmp   ax, 0x0000
		jz    _after_read_loop
		
		mov al, 'M'
		mov ah, 0x0e
		mov bx, 0x0000
		int 0x10
		
		jmp   _read_sector
	_after_read:
	
		# count --
		mov   ax, [_rsp_count]
		dec   ax
		mov   [_rsp_count], ax
		
		# lba ++
		mov   ax, [_rsp_lba]
		inc   ax
		mov   [_rsp_lba], ax
		
		# dest ++
		mov   ax, [_rsp_dest_lo]
		add   ax, 0x0200
		mov   [_rsp_dest_lo], ax
		cmp   ax, 0x0000
		jnz   _after_dest
		mov   ax, [_rsp_dest_hi]
		add   ax, 0x0100
		mov   [_rsp_dest_hi], ax
		_after_dest:
		
		jmp    _read_loop_start
	_after_read_loop:
	
		mov al, 'X'
		mov ah, 0x0e
		mov bx, 0x0000
		int 0x10
		
		
		mov al, [0xa012]
		mov ah, 0x0e
		mov bx, 0x0000
		int 0x10
		jmp $


		# Speicher-Segmente laden
		lgdt [_gdtr]

		# Debug
		mov al, '3'
		mov ah, 0x0e
		mov bx, 0x0000
		int 0x10

		# 32bit Protected-Mode aktivieren
		cli
		mov eax, cr0
		or al, 0x01
		mov cr0, eax
		
		# flush cpu prefetch
		jmp _flush
		_flush:

		# die Segment-Register vorbereiten
		mov ax, 0x0010 # Descriptor[2]
		mov ds, ax
		mov es, ax
		mov fs, ax
		mov gs, ax
		mov ss, ax

		# Stack initialisieren
		mov esp, 0x0027fff8

		# in den 32bit ProtectedMode springen
		db 0x66 # weil im 16:32 Format...
		jmp_far [_pmode_ptr] # 0x0008:_pmode

	#-------------------------------------------------------------
	# ProtectedMode!!!
		_pmode:
		bits_32
		
		#jmp $
		
		mov eax, 0x000b8000
		mov [eax], 'M'
		add eax, 0x00000001
		mov [eax], 0x20
		
		# für den Stack nach einem C-Aufruf!
		mov ebp, esp
		
		mov eax, 0x000b8002
		mov [eax], '1'
		add eax, 0x00000001
		mov [eax], 0x20

		# Variablen speichern
		mov eax, [_var_mem_size]
		shl eax, 0x06
		mov [0x00005100], eax
		xor eax, eax

		# -> Kernel starten
		mov eax, 0x00010000
		jmp eax



		# zur Sicherheit....
		jmp $
		
		
		bits_16
		
	_read_sector:
		
		
		
		
		
		# Calculate cylinder, head and sector:
		# Cylinder = (LBA / SectorsPerTrack) / NumHeads
		# Sector   = (LBA mod SectorsPerTrack) + 1
		# Head     = (LBA / SectorsPerTrack) mod NumHeads
 
 		mov ax, [_rsp_lba]
 		
		mov bx, [_drive_sectors]
		xor dx, dx
		div ax, bx
		inc dx
		mov cl, dl

		mov     bx, [_drive_heads]
		xor     dx, dx
		div     ax, bx
		mov     ch, al
		xchg    dl, dh
		
		mov     dl, 0x00 # disc 0
		
		# destination
		mov     ax, [_rsp_dest_hi]
		shl     ax, 0x08 # 0x1200:0x3456 = 0x123456 real mode segmentation is ugly
		mov     es, ax
		mov     bx, [_rsp_dest_lo]
		
		# DEBUG
	
		#mov ax, 0x0000
		#mov es, ax
		#mov bx, 0xa000 # 0x1000:0x0000 = 0x10000 real mode segmentation is ugly
		
		mov ah, 0x02 # "ReadSector"
		mov al, 0x01 # 128 sectors * 512 bytes = 64k
		mov cx, 0x001d # sector 0x1f, cylinder 0
		mov dx, 0x0080 # head 0x00, disc 0
		int 0x13
		jmp _after_read
		jmp _after_read
		
		# read
		mov     ah, 0x02 # "ReadSector"
		mov     al, 0x01 # 1 sector = 512 bytes
		int     0x13
	#	mov cx, 0x001d # sector 0x1f, cylinder 0
	#	mov dx, 0x0080 # head 0x00, disc 0
	#	mov ah, 0x02 # "ReadSector"
	#	mov al, 0x01 # 1 sector = 512 bytes
	#	int 0x13
	
	
	
		jmp _after_read
		
		_rsp_dest_hi:
		dw 0x0000
		_rsp_dest_lo:
		dw 0x0000
		_rsp_lba:
		dw 0x0000
		_rsp_count:
		dw 0x0000
		
		_drive_heads:
		dw 0x0010 # 16
		_drive_sectors:
		dw 0x003f # 63

	#-------------------------------------------------------------
	# Daten
	
		# Variablen
		_var_mem_size:
		dd 0x00000000

		_gdt:
		# [0] 0x00 null descriptor
		dd 0x00000000
		dd 0x00000000
		# [1] 0x08 code descriptor
		dd 0x0000ffff
		dd 0x00cf9a00
		# [2] 0x10 data descriptor
		dd 0x0000ffff
		dd 0x00cf9200

		_gdtr:
		dw 0x0017 # 3 descriptors
		dd _gdt
		
		_pmode_ptr:
		dd _pmode
		dw 0x0008 # Descriptor[1] : ...
	}