luxos/SysBoot/stage2/fat12.inc

;*******************************************************
;
;	Fat12.inc
;		FAT12 filesystem for 3-1/2 floppies
;
;	OS Development Series
;*******************************************************

%ifndef __FAT12_INC_67343546FDCC56AAB872_INCLUDED__
%define __FAT12_INC_67343546FDCC56AAB872_INCLUDED__

bits	16

%include "Floppy16.inc"					; the erm.. floppy driver

%define ROOT_OFFSET 0x2e00
%define FAT_SEG 0x2c0
%define ROOT_SEG 0x2e0

;*******************************************
; LoadRoot ()
;	- Load Root Directory Table to 0x7e00
;*******************************************

LoadRoot:

	pusha							; store registers
	push	es

     ; compute size of root directory and store in "cx"
     
	xor     cx, cx						; clear registers
 	xor     dx, dx
	mov     ax, 32					; 32 byte directory entry
	mul     WORD [bpbRootEntries]				; total size of directory
	div     WORD [bpbBytesPerSector]			; sectors used by directory
	xchg    ax, cx						; move into AX

     ; compute location of root directory and store in "ax"
     
	mov     al, BYTE [bpbNumberOfFATs]			; number of FATs
	mul     WORD [bpbSectorsPerFAT]				; sectors used by FATs
	add     ax, WORD [bpbReservedSectors]
	mov     WORD [datasector], ax				; base of root directory
	add     WORD [datasector], cx

     ; read root directory into 0x7e00
 
 	push	word ROOT_SEG
	pop		es
	mov     bx, 0								; copy root dir
	call    ReadSectors							; read in directory table
	pop		es
	popa										; restore registers and return
	ret

;*******************************************
; LoadFAT ()
;	- Loads FAT table to 0x7c00
;
;	Parm/ ES:DI => Root Directory Table
;*******************************************

LoadFAT:

	pusha							; store registers
	push	es

     ; compute size of FAT and store in "cx"
     
	xor     ax, ax
	mov     al, BYTE [bpbNumberOfFATs]			; number of FATs
	mul     WORD [bpbSectorsPerFAT]				; sectors used by FATs
	mov     cx, ax

     ; compute location of FAT and store in "ax"

	mov     ax, WORD [bpbReservedSectors]

     ; read FAT into memory (Overwrite our bootloader at 0x7c00)

	push	word FAT_SEG
	pop		es
	xor		bx, bx
	call    ReadSectors
	pop		es
	popa							; restore registers and return
	ret
	
;*******************************************
; FindFile ()
;	- Search for filename in root table
;
; parm/ DS:SI => File name
; ret/ AX => File index number in directory table. -1 if error
;*******************************************

FindFile:

	push	cx						; store registers
	push	dx
	push	bx
	mov	bx, si						; copy filename for later

     ; browse root directory for binary image

	mov     cx, WORD [bpbRootEntries]			; load loop counter
	mov     di, ROOT_OFFSET						; locate first root entry at 1 MB mark
	cld							; clear direction flag

.LOOP:
	push    cx
	mov     cx, 11					; eleven character name. Image name is in SI
	mov	si, bx						; image name is in BX
 	push    di
     rep  cmpsb							; test for entry match
	pop     di
	je      .Found
	pop     cx
	add     di, 32					; queue next directory entry
	loop    .LOOP

.NotFound:
	pop	bx						; restore registers and return
	pop	dx
	pop	cx
	mov	ax, -1						; set error code
	ret

.Found:
	pop	ax						; return value into AX contains entry of file
	pop	bx						; restore registers and return
	pop	dx
	pop	cx
	ret

;*******************************************
; LoadFile ()
;	- Load file
; parm/ ES:SI => File to load
; parm/ EBX:BP => Buffer to load file to
; ret/ AX => -1 on error, 0 on success
;*******************************************

LoadFile:

	xor		ecx, ecx					; size of file in sectors
	push	ecx

.FIND_FILE:

	push	bx						; BX=>BP points to buffer to write to; store it for later
	push	bp
	call	FindFile				; find our file. ES:SI contains our filename
	cmp		ax, -1
	jne		.LOAD_IMAGE_PRE
	pop		bp
	pop		bx
	pop		ecx
	mov		ax, -1
	ret

.LOAD_IMAGE_PRE:

	sub		edi, ROOT_OFFSET
	sub		eax, ROOT_OFFSET

	; get starting cluster

	push	word ROOT_SEG				;root segment loc
	pop		es
	mov		dx, WORD [es:di + 0x001A]	; DI points to file entry in root directory table. Refrence the table...
	mov		WORD [cluster], dx			; file's first cluster
	pop		bx							; get location to write to so we dont screw up the stack
	pop		es
	push    bx							; store location for later again
	push	es
	call	LoadFAT

.LOAD_IMAGE:

	; load the cluster

	mov		ax, WORD [cluster]		; cluster to read
	pop		es						; bx:bp=es:bx
	pop		bx
	call	ClusterLBA
	xor		cx, cx
	mov     cl, BYTE [bpbSectorsPerCluster]

	call	ReadSectors

	pop		ecx
	inc		ecx
	push	ecx

	push	bx
	push	es

	mov		ax, FAT_SEG						;start reading from fat
	mov		es, ax
	xor		bx, bx

	; get next cluster

	mov     ax, WORD [cluster]				; identify current cluster
	mov     cx, ax							; copy current cluster
	mov     dx, ax							; copy current cluster
	shr     dx, 0x0001						; divide by two
	add     cx, dx							; sum for (3/2)

	mov		bx, 0							;location of fat in memory
	add		bx, cx
	mov		dx, WORD [es:bx]
	test	ax, 0x0001						; test for odd or even cluster
	jnz		.ODD_CLUSTER

.EVEN_CLUSTER:

	and		dx, 0000111111111111b	; take low 12 bits
	jmp		.DONE

.ODD_CLUSTER:

	shr		dx, 0x0004				; take high 12 bits

.DONE:

	mov		WORD [cluster], dx
	cmp		dx, 0x0ff0				; test for end of file marker
	jb		.LOAD_IMAGE

.SUCCESS:
	pop		es
	pop		bx
	pop		ecx
	xor		ax, ax
	ret

%endif		;__FAT12_INC_67343546FDCC56AAB872_INCLUDED__