kolibrios/programs/hd_load/usb_boot/mtldr.asm

; KolibriOS bootloader
; this code has been written by diamond in 2005,2006,2007 specially for KolibriOS

; this code is loaded by our bootsector to 0000:8000
	format	binary
	use16

out_string = 0x7DAB
read_cluster = 0x7D15
relative_read = 0x7D22
next_cluster = 0x7D65

	org	0x8000
start:
; cs=ds=0, es undefined, ss=0, sp=7C00
	movzx	esp, sp
	push	1000h
	pop	es
; say hi to user
	mov	si, start_msg
	call	out_string
; parse image name
	mov	eax, [7C2Ch]	; root_cluster
	and	eax, 0xFFFFFFF
	mov	[cur_obj], root_string
.parsedir:
	push	ax
	mov	si, [imgnameofs]
	push	si
@@:
	lodsb
	cmp	al, 0
	jz	@f
	cmp	al, '\'
	jnz	@b
	dec     si
	mov     [missing_slash], si
	inc     si
@@:
	xchg	ax, [esp+2]
	mov	byte [si-1], 0
	mov	[imgnameofs], si
	call	fat32_parse_dir
	call    restore_slash
	pop	cx
	test	cl, cl
	jz	.end
	test	byte [es:di+0Bh], 10h
	mov	si, notdir_string
	jz	find_error_si
	jmp	.parsedir
.end:
	test	byte [es:di+0Bh], 10h
	mov	si, directory_string
	jnz	find_error_si
; parse FAT chunk
; runlist at 5000:0000
	mov	di, 4
	push	5000h
	pop	es
	mov	dword [es:di-4], 1
	stosd
.parsefat:
	call	next_cluster
	jnc	.done
	mov	ecx, [es:di-8]
	add	ecx, [es:di-4]
	cmp	eax, ecx
	jz	.contc
	mov	dword [es:di], 1
	scasd
	stosd
	jmp	.parsefat
.contc:
	inc	dword [es:di-8]
	jmp	.parsefat
.done:
	xor	eax, eax
	stosd
read_img_file:
	xor	si, si
	push	es
	pop	fs
; yes! Now read file to 0x100000
	xor	edi, edi
; read buffer to 1000:0000 and move it to extended memory
	push	1000h
	pop	es
	xor	bx, bx
.img_read_block:
	lods dword [fs:si]		; eax=length
	xchg	eax, ecx
	jecxz	.img_read_done
	lods dword [fs:si]		; eax=disk cluster
.img_read_cluster:
	pushad
; read part of file
	movzx	esi, byte [7C0Dh]
	mul	esi
	add	eax, [7A04h]
	push	ax
	mov	ax, 0x200
	div	si
	cmp	cx, ax
	jb	@f
	mov	cx, ax
@@:
	pop	ax
	add	[esp+1Ch], ecx
	sub	[esp+18h], cx
	imul	cx, si
	push	cx
	call	relative_read
	pop	cx
; move it to extended memory
	mov	byte [sou_addr+2], 1
.move_loop:
	push	cx
	cmp	cx, 80h
	jbe	@f
	mov	cx, 80h
@@:
	mov	ah, 87h
	xchg	cl, ch
	mov	si, movedesc
	push	cx es
	push	ds
	pop	es
	int	15h
	pop	es cx
	test    ah, ah
	mov	si, exmem_string
	jnz	find_error_si
	add	[dest_addr], ecx
	add	[dest_addr], ecx
	inc	byte [sou_addr+2]
	mov	al, ch
	mov	ah, cl
	pop	cx
	sub	cx, ax
	jnz	.move_loop
	popad
	test	cx, cx
	jnz	.img_read_cluster
	jmp	.img_read_block
.img_read_done:
; kolibri.img loaded; now load kernel.mnt
load_kernel:
	push	ds
	pop	es
	mov	[cur_obj], kernel_mnt_name
; read boot sector
	xor	eax, eax
	mov	bx, 500h
	mov	cx, 1
	call	read_img
; init vars
	mov	ax, [50Eh]	; reserved_sect
	add	ax, [51Ch]	; hidden
	mov	word [fat_start], ax
	xchg	ax, bx
	movzx	ax, byte [510h]		; num_fats
	mul	word [516h]		; fat_length
	add	ax, bx
; read root dir
	mov	bx, 700h
	mov	cx, [511h]	; dir_entries
	add	cx, 0Fh
	shr	cx, 4
	call	read_img
	add	ax, cx
	mov	[img_data_start], ax
	shl	cx, 9
	mov	di, bx
	add	bx, cx
	mov	byte [bx], 0
.scan_loop:
	cmp	byte [di], 0
	mov	si, notfound_string
	jz	find_error_si
	mov	si, kernel_mnt_name
	call	fat_compare_name
	jz	.found
	and	di, not 1Fh
	add	di, 20h
	jmp	.scan_loop
.found:
	and	di, not 1Fh
	mov	si, directory_string
	test	byte [di+0Bh], 10h
	jnz	find_error_si
; found, now load it to 1000h:0000h
	mov	ax, [di+1Ah]
; first cluster of kernel.mnt in ax
; translate it to sector on disk in kolibri.img
	push	ax
	dec	ax
	dec	ax
	movzx	cx, byte [50Dh]
	mul	cx
	add	ax, [img_data_start]
; now ax is sector in kolibri.img
	mov	[kernel_mnt_in_img], ax
	movzx	cx, byte [7C0Dh]
	div	cx
; now ax is cluster in kolibri.img and
; dx is offset from the beginning of cluster
	movzx	eax, ax
	push	5000h
	pop	ds
	xor	si, si
	mov	si, 1
.scani:
	sub	eax, [si]
	jb	.scanidone
; sanity check
	cmp	dword [si], 0
	push	data_error_msg
	jz	find_error_sp
	pop	cx
; next chunk
	add	si, 8
	jmp	.scani
.scanidone:
	add	eax, [si]	; undo last subtract
	add	eax, [si+4]	; get cluster
	push	0
	pop	ds
	movzx	ecx, byte [7C0Dh]
	push	dx
	mul	ecx		; get sector
	pop	dx
	movzx	edx, dx
	add	eax, edx
	add	eax, [7A04h]
	mov	[kernel_mnt_1st], eax
	pop	ax
	push	1000h
	pop	es
.read_loop:
	push	ax
	xor	bx, bx
	call	img_read_cluster
	shl	cx, 9-4
	mov	ax, es
	add	ax, cx
	mov	es, ax
	pop	ax
	call	img_next_cluster
	jc	.read_loop
	mov	ax, 'KL'
	mov	si, loader_block
	jmp	1000h:0000h

img_next_cluster:
	mov	bx, 700h
	push	ax
	shr	ax, 1
	add	ax, [esp]
	mov	dx, ax
	shr	ax, 9
	add	ax, word [fat_start]
	mov	cx, 2
	push	es
	push	ds
	pop	es
	call	read_img
	pop	es
	and	dx, 1FFh
	add	bx, dx
	mov	ax, [bx]
	pop	cx
	test	cx, 1
	jz	.1
	shr	ax, 4
.1:
	and	ax, 0FFFh
	mov	si, bad_cluster_string
	cmp	ax, 0FF7h
	jz	find_error_si
	ret
img_read_cluster:
	dec	ax
	dec	ax
	movzx	cx, byte [50Dh]	; sects_per_clust
	mul	cx
	add	ax, [img_data_start]
	movzx	eax, ax
;	call	read_img
;	ret
read_img:
; in: ax = sector, es:bx->buffer, cx=length in sectors
	pushad
	movzx	ebx, bx
	mov	si, movedesc
	shl	eax, 9
	add	eax, 93100000h
	mov	dword [si+sou_addr-movedesc], eax
	mov	eax, 9300000h
	mov	ax, es
	shl	eax, 4
	add	eax, ebx
	mov	[si+dest_addr-movedesc], eax
	mov	ah, 87h
	shl	cx, 8	; mul 200h/2
	push	es
	push	0
	pop	es
	int	15h
	pop	es
	cmp	ah, 0
	mov	si, exmem_string
	jnz	find_error_si
	popad
	ret

movedesc:
	times 16 db 0
; source
	dw	0xFFFF		; segment length
sou_addr dw	0000h		; linear address
	db	1		; linear address
	db	93h		; access rights
	dw	0
; destination
	dw	0xFFFF		; segment length
dest_addr dd	93100000h	; high byte contains access rights
				; three low bytes contains linear address (updated when reading)
	dw	0
	times 32 db 0

find_error_si:
	push	si
find_error_sp:
	mov	si, error_msg
	call	out_string
	mov	si, [cur_obj]
	call	out_string
	mov	si, colon
	call	out_string
	pop	si
	call	out_string
	mov     si, newline
	call    out_string
	jmp	$

file_not_found:
	mov	si, [esp+2]
	mov	[cur_obj], si
	push	notfound_string
	jmp	find_error_sp

restore_slash:
	mov     si, [missing_slash]
	test    si, si
	jz      @f
	and     [missing_slash], 0
	mov     byte [si], '\'
@@:     ret

	include 'fat32.inc'

if 0
write1st:
; callback from kernel.mnt
; write first sector of kernel.mnt from 1000:0000 back to disk
	push	cs
	pop	ds
	push	cs
	pop	es
; sanity check
	mov	bx, 500h
	mov	si, bx
	mov	cx, 1
	push	cx
	mov	eax, [kernel_mnt_1st]
	push	eax
	call	relative_read
	push	1000h
	pop	es
	xor	di, di
	mov	cx, 8
	repz	cmpsw
	mov	si, data_error_msg
	jnz	find_error_si
; ok, now write back to disk
	or	byte [read.patch1+2], 1
	or	byte [read.patch2+2], 1
	xor	bx, bx
	pop	eax
	pop	cx
	call	relative_read
	and	byte [read.patch1+1], not 1
	and	byte [read.patch2+2], not 2
; and to image in memory (probably this may be done by kernel.mnt itself?)
	mov	dword [sou_addr], 93010000h
	movzx	eax, [kernel_mnt_in_img]
	shl	eax, 9
	add	eax, 93100000h
	mov	dword [dest_addr], eax
	mov	si, movedesc
	push	ds
	pop	es
	mov	ah, 87h
	mov	cx, 100h
	int	15h
	cmp	ah, 0
	mov	si, exmem_string
	jnz	find_error_si
	retf
else
write1st = 0
end if

loader_block:
	db	1	; version
	dw	1	; flags - image is loaded
	dw	write1st	; offset
	dw	0		; segment

imgnameofs dw kolibri_img_name

; -----------------------------------------------
; ------------------ Settings -------------------
; -----------------------------------------------

; must be in lowercase, see ntfs_parse_dir.scan, fat32_parse_dir.scan
kernel_mnt_name 	db	'kernel.mnt',0
kolibri_img_name 	db	'kolibri.img',0

missing_slash   dw      0

start_msg	db	2,' KolibriOS bootloader, FAT32 flash version'
newline		db	13,10,0
error_msg	db	'Error'
colon		db	': ',0
root_string	db	'\',0
nodata_string	db	'$DATA '
notfound_string db	'not found',0
directory_string db	'is a directory',0
notdir_string	db	'not a directory',0
exmem_string	db	'extended memory error',0
bad_cluster_string db	'bad cluster',0
data_error_msg db	'data error',0

        align 2

; uninitialized data follows
cur_obj 		dw	?
img_data_start		dw	?
kernel_mnt_in_img	dw	?
fat_start		dw	?
kernel_mnt_1st		dd	?