622 lines
15 KiB
ArmAsm
622 lines
15 KiB
ArmAsm
; VARS
|
|
|
|
phase MEM_IDE_FSBUFFER
|
|
MEM_FAT_RESERVED: ; Reserved sectors (2byte)
|
|
defs 2
|
|
MEM_FAT_AMOUNT: ; Amount of FATs (1byte)
|
|
defs 1
|
|
MEM_FAT_SECTORS: ; Length of FAT (2byte)
|
|
defs 2
|
|
MEM_FAT_CLUSTERLEN: ; Length of Cluster (1byte)
|
|
defs 1
|
|
MEM_FAT_COUNT1: ; Counter Var for reading FAT (2byte)
|
|
defs 1
|
|
MEM_FAT_TMPPOINTER: ; Temporary working pointer
|
|
defs 4
|
|
MEM_FAT_DATASTART: ; Start of data area
|
|
defs 4
|
|
MEM_FAT_ROOTSTART: ; Start of Root directory
|
|
defs 4
|
|
MEM_FAT_FILEREMAIN: ; Remaining sectors in file
|
|
defs 4
|
|
MEM_FAT_DIRSEC: ; Sectors per directory
|
|
defs 2
|
|
MEM_FAT_TMPFNAME: ; Temporary filename
|
|
defs 16
|
|
MEM_FAT_CURDIR: ; Current Directory
|
|
defs 80
|
|
MEM_FAT_OF0_ATTRIBUTE: ;Current file attribute
|
|
defw 0
|
|
MEM_FAT_OF0_CCLUST: ;Current cluster of file
|
|
defw 0
|
|
MEM_FAT_OF0_FATSEC: ;Current sector in FAT
|
|
defs 4
|
|
MEM_FAT_OF0_DATSEC: ;Current sector in Data
|
|
defs 4
|
|
MEM_FAT_OF0_DATREM: ;Remaining bytes in Data
|
|
defs 4
|
|
MEM_FAT_CURRDIR: ;Current directory
|
|
defs 4
|
|
MEM_FAT_EXEC_CURR:
|
|
defw 0
|
|
MEM_FAT_EXEC_COUNT:
|
|
defw 0
|
|
MEM_FAT_EXEC_START:
|
|
defw 0
|
|
|
|
dephase
|
|
|
|
;-------------------------------------
|
|
; Get FAT Root-Table position
|
|
;-------------------------------------
|
|
fat_get_root_table:
|
|
call fat_reset_pointer ;reset fat pointer
|
|
|
|
; Load first sector on active partition
|
|
LD HL, MEM_IDE_POINTER ; pointer to LBA address
|
|
LD A,1 ;read 1 sector
|
|
LD DE, MEM_IDE_BUFFER ;where to store data?
|
|
call read_lba_sector
|
|
|
|
; check for valid Boot sector
|
|
ld a,(MEM_IDE_BUFFER)
|
|
cp 0xEB ;first byte should be 0xEB
|
|
jp nz, _fat_get_root_table_invalid
|
|
|
|
; Read and store FS Properties
|
|
LD IX,MEM_IDE_BUFFER
|
|
LD A,(IX+0x0D)
|
|
LD (MEM_FAT_CLUSTERLEN),A
|
|
LD A,(IX+0x0E)
|
|
LD (MEM_FAT_RESERVED),A
|
|
LD A,(IX+0x0F)
|
|
LD (MEM_FAT_RESERVED+1),A
|
|
LD A,(IX+0x10)
|
|
LD (MEM_FAT_AMOUNT),A
|
|
LD A,(IX+0x16)
|
|
LD (MEM_FAT_SECTORS),A
|
|
LD A,(IX+0x17)
|
|
LD (MEM_FAT_SECTORS+1),A
|
|
|
|
;Get Data Start Sector
|
|
;calculate fat length
|
|
ld bc,(MEM_FAT_SECTORS)
|
|
ld a,(MEM_FAT_AMOUNT) ;add fat to cluster number
|
|
ld d,0
|
|
ld e,a
|
|
call _fat_math_mul32
|
|
; BCHL contains result -> store to PTR.MEM_FAT_ROOTSTART
|
|
ld (MEM_FAT_ROOTSTART+0),hl
|
|
ld (MEM_FAT_ROOTSTART+2),bc
|
|
|
|
;add offset (reserved sectors)
|
|
ld hl,(MEM_IDE_BUFFER +0x0E) ; load sectors into hl
|
|
ld (MEM_FAT_TMPPOINTER), hl
|
|
xor a
|
|
ld (MEM_FAT_TMPPOINTER+2),a
|
|
ld (MEM_FAT_TMPPOINTER+3),a
|
|
|
|
ld bc,[MEM_FAT_ROOTSTART]
|
|
ld de,[MEM_FAT_TMPPOINTER]
|
|
call _fat_math_add32 ;MEM_FAT_ROOTSTART now contains the first sector
|
|
;of the Root directory
|
|
|
|
;add offset (partition location)
|
|
call ideif_get_drv_pointer
|
|
inc ix
|
|
inc ix
|
|
push ix
|
|
pop de ;copy poiter to hl
|
|
ld bc,[MEM_FAT_ROOTSTART]
|
|
call _fat_math_add32 ;MEM_FAT_OF0_DATSEC now contains the first sector
|
|
;of the cluster
|
|
;copy value from MEM_FAT_ROOTSTART to MEM_IDE_POINTER
|
|
ld hl,MEM_FAT_ROOTSTART
|
|
ld de,MEM_IDE_POINTER
|
|
ldi
|
|
ldi
|
|
ldi
|
|
ldi
|
|
|
|
;copy value from MEM_FAT_ROOTSTART to MEM_IDE_POINTER
|
|
ld hl,MEM_FAT_ROOTSTART
|
|
ld de,MEM_FAT_DATASTART
|
|
ldi
|
|
ldi
|
|
ldi
|
|
ldi
|
|
|
|
ld hl,MEM_FAT_ROOTSTART
|
|
ld de,MEM_FAT_CURRDIR
|
|
ldi
|
|
ldi
|
|
ldi
|
|
ldi
|
|
|
|
;add offset to data area
|
|
;multiply cluster by length of cluster
|
|
|
|
;calculate sectors for root dir
|
|
ld hl,(MEM_IDE_BUFFER+0x11) ;load Maximum root directory entries
|
|
ld a,h
|
|
ld l,a
|
|
xor a ;set a 0, clear carry flag
|
|
ld h,a ;shift right by 8 bit = /512
|
|
|
|
;last step: multiply by 16
|
|
ex de,hl
|
|
ld bc,16
|
|
call _fat_math_mul32
|
|
; BCHL contains result -> store to PTR.MEM_FAT_TMPPOINTER
|
|
ld (MEM_FAT_TMPPOINTER+0),hl
|
|
ld (MEM_FAT_TMPPOINTER+2),bc
|
|
|
|
ld (MEM_FAT_DIRSEC),hl
|
|
; add offset to MEM_FAT_DATASTART
|
|
ld de,[MEM_FAT_TMPPOINTER]
|
|
ld bc,[MEM_FAT_DATASTART]
|
|
call _fat_math_add32 ;MEM_FAT_DATASTART now contains the correct sector
|
|
;at teh beginnig of the data area
|
|
|
|
|
|
;done all FS vars populated
|
|
|
|
;navigate to root directory
|
|
ld a,'\'
|
|
ld(MEM_FAT_CURDIR),a
|
|
xor a
|
|
ld(MEM_FAT_CURDIR+1),a
|
|
|
|
ret
|
|
|
|
_fat_get_root_table_invalid:
|
|
call PRINTINLINE
|
|
db 10,13,"Cannot find boot sector.",10,13,0
|
|
call ideif_get_drv_pointer
|
|
ld (ix+0),0x02
|
|
ret
|
|
|
|
;-------------------------------------
|
|
; fat_getfatsec
|
|
;
|
|
; gets sector in FAT table for the cluster stored in MEM_FAT_OF0_CCLUST
|
|
;
|
|
; store result in MEM_FAT_OF0_FATSEC
|
|
; stores next cluster in MEM_FAT_OF0_CCLUST
|
|
;-------------------------------------
|
|
fat_getfatsec:
|
|
ld HL,(MEM_FAT_OF0_CCLUST) ;load cluster
|
|
ld a,h ;if not 0x0000
|
|
or l
|
|
jp nz, _fat_getfatsec_notroot
|
|
;if 0x0000, goto root directory
|
|
ld hl,MEM_FAT_ROOTSTART
|
|
ld de,MEM_FAT_OF0_DATSEC
|
|
ldi ;quick and dirty hack to go back to root directory
|
|
ldi
|
|
ldi
|
|
ldi
|
|
ret
|
|
|
|
_fat_getfatsec_notroot:
|
|
ld HL,(MEM_FAT_OF0_CCLUST) ;load cluster
|
|
;each sector contains 256 clusters
|
|
;first 8bits are not needed (/256)
|
|
ld a,h ;divide by 256
|
|
ld l,a
|
|
xor a
|
|
ld h,a
|
|
|
|
ld bc,(MEM_FAT_RESERVED) ;add reserved sectors
|
|
add hl,bc
|
|
ld(MEM_FAT_OF0_FATSEC+0),hl;store sector
|
|
xor a
|
|
ld(MEM_FAT_OF0_FATSEC+2),a
|
|
ld(MEM_FAT_OF0_FATSEC+3),a
|
|
|
|
call ideif_get_drv_pointer
|
|
inc ix
|
|
inc ix
|
|
push ix
|
|
pop de ;copy poiter to hl
|
|
ld bc,[MEM_FAT_OF0_FATSEC]
|
|
call _fat_math_add32 ;MEM_FAT_OF0_FATSEC now contains the correct sector
|
|
;in the FAT
|
|
|
|
;read FAT sector
|
|
ld hl,MEM_FAT_OF0_FATSEC ;read next sector
|
|
ld b,1
|
|
LD DE, MEM_IDE_BUFFER ;where to store data?
|
|
call read_lba_sector
|
|
|
|
;calculate data sector
|
|
;multiply cluster by length of cluster
|
|
xor a ;clear carry
|
|
ld a,(MEM_FAT_CLUSTERLEN)
|
|
ld b,0
|
|
ld c,a
|
|
ld de,(MEM_FAT_OF0_CCLUST) ;load cluster number
|
|
dec de ; sub 2 becaus fat starts at 3
|
|
dec de
|
|
call _fat_math_mul32
|
|
; BCHL contains result -> store to PTR.MEM_FAT_OF0_DATSEC
|
|
ld (MEM_FAT_OF0_DATSEC+0),hl
|
|
ld (MEM_FAT_OF0_DATSEC+2),bc
|
|
|
|
; add start of data region to addr
|
|
ld bc,[MEM_FAT_OF0_DATSEC]
|
|
ld de,[MEM_FAT_DATASTART]
|
|
call _fat_math_add32 ;MEM_FAT_OF0_FATSEC now contains the correct sector
|
|
;in the FAT
|
|
;MEM_FAT_OF0_DATSEC now has the first sector of the selected cluster
|
|
|
|
;reset MEM_FAT_OF0_DATREM to default cluster length
|
|
ld a,(MEM_FAT_CLUSTERLEN)
|
|
ld l,a
|
|
ld h,0
|
|
ld (MEM_FAT_OF0_DATREM), hl
|
|
|
|
;get next cluster
|
|
;calculate offset address
|
|
ld a,(MEM_FAT_OF0_CCLUST)
|
|
RLA ;shift to left (x2)
|
|
ld l, a
|
|
ld a,0
|
|
RLA ;shift in carry flag
|
|
ld h,a
|
|
ld de,MEM_IDE_BUFFER
|
|
add hl,de
|
|
;copy pointer (hl to de)
|
|
ld de,MEM_FAT_OF0_CCLUST
|
|
ldi ;copy byte for next cluster from FAT
|
|
ldi
|
|
ret
|
|
;store data
|
|
|
|
;-------------------------------------
|
|
; fat_readfilesec
|
|
;
|
|
; reads single sector of file
|
|
; must run fat_readfilesec before to initialize
|
|
; if a ix 0x00, success
|
|
; if a is 0xFF, end reached
|
|
;
|
|
; DE contains destination address
|
|
;-------------------------------------
|
|
fat_readfilesec:
|
|
;call fat_print_dbg
|
|
ld hl,[MEM_FAT_OF0_DATSEC]
|
|
ld b,1
|
|
;LD DE, MEM_IDE_BUFFER ;where to store data?
|
|
call read_lba_sector ;read sectore
|
|
ld hl,[MEM_FAT_OF0_DATSEC] ;increment pointer to next sector
|
|
call _fat_increment_32 ;***
|
|
ld hl,(MEM_FAT_OF0_DATREM) ;reduce counter
|
|
xor a
|
|
ld de,1
|
|
sbc hl,de ;decrement counter
|
|
ld (MEM_FAT_OF0_DATREM),hl ;store decremented counter
|
|
ret nz ;when not zero, exit function
|
|
;if zero:
|
|
ld a, 0xFF ;preload error code
|
|
ld hl,(MEM_FAT_OF0_CCLUST) ;check next chunk
|
|
ld de,0xFFFF ;end mark
|
|
sbc hl,de ;if Z match
|
|
ret z ;If 0xFFFF, end is reched. Return
|
|
;if next cluster available:
|
|
xor a
|
|
call fat_getfatsec ; read next cluster information
|
|
ret
|
|
|
|
|
|
;-------------------------------------
|
|
; fat_openfile
|
|
; search for entry in current directory
|
|
;
|
|
; DE pointer to file name
|
|
; sets:
|
|
; - MEM_FAT_OF0_CCLUST
|
|
; - MEM_FAT_OF0_ATTRIBUTE
|
|
; - MEM_FAT_FILEREMAIN
|
|
; if a is 0x00, success
|
|
; if a is 0xFF, end reached
|
|
;-------------------------------------
|
|
fat_openfile:
|
|
PUSH DE
|
|
;MEM_FAT_TMPFNAME now has valid text to compare
|
|
LD HL,[MEM_FAT_TMPFNAME]
|
|
call format_filename_fat16
|
|
POP DE
|
|
fat_openfile_noprepare:
|
|
PUSH DE
|
|
;prepare pointer
|
|
ld hl,MEM_FAT_CURRDIR
|
|
ld de,MEM_IDE_POINTER
|
|
ldi
|
|
ldi
|
|
ldi
|
|
ldi
|
|
|
|
LD A,(MEM_FAT_DIRSEC) ;init counter for FAT sectors
|
|
LD (MEM_FAT_COUNT1),A
|
|
|
|
LD HL,MEM_IDE_POINTER ;read first sector
|
|
LD B,1
|
|
LD DE, MEM_IDE_BUFFER ;where to store data?
|
|
call read_lba_sector
|
|
|
|
LD HL, MEM_IDE_BUFFER ;set buffer start
|
|
LD C,16 ;set entries counter
|
|
|
|
_fat_lfs_loop:
|
|
LD DE,[MEM_FAT_TMPFNAME]
|
|
CALL compare_filename
|
|
JR C, _fat_lfs_loop_compare_match ;on match
|
|
|
|
; prepare next entry
|
|
DEC C ;next sector after 16 entries
|
|
JR Z,_fat_lfs_loop_compare_next_sector
|
|
LD DE, 32 ;length of entry
|
|
ADD HL,DE ;increment
|
|
JP _fat_lfs_loop
|
|
|
|
_fat_lfs_loop_compare_next_sector:
|
|
ld hl,[MEM_IDE_POINTER]
|
|
call _fat_increment_32 ;increment sector
|
|
|
|
LD A,(MEM_FAT_COUNT1) ; decrement sector count (max FAT length)
|
|
DEC A
|
|
LD (MEM_FAT_COUNT1),A
|
|
JP Z, _fat_lfs_loop_compare_end ; if DE is 0, mmax is reached. End here
|
|
;call print_a_hex
|
|
|
|
LD HL,MEM_IDE_POINTER ;read next sector
|
|
LD B,1
|
|
LD DE, MEM_IDE_BUFFER ;where to store data?
|
|
call read_lba_sector
|
|
|
|
LD HL, MEM_IDE_BUFFER ;set buffer start
|
|
LD C,16 ;set entries counter
|
|
|
|
ld a,(HL)
|
|
or a
|
|
jp z, _fat_lfs_loop_compare_end ;skip empty sectors
|
|
|
|
JP _fat_lfs_loop
|
|
|
|
_fat_lfs_loop_compare_end:
|
|
POP DE
|
|
ld a,0xFF
|
|
RET
|
|
|
|
_fat_lfs_loop_compare_match:
|
|
; get entry
|
|
POP DE
|
|
|
|
; HL points to Start of Table item
|
|
PUSH HL
|
|
POP IX
|
|
; get important information
|
|
ld a,(ix+0x1B) ;first cluster number
|
|
ld (MEM_FAT_OF0_CCLUST+1),a
|
|
ld a,(ix+0x1A)
|
|
ld (MEM_FAT_OF0_CCLUST+0),a
|
|
ld a,(ix+0x0B)
|
|
ld (MEM_FAT_OF0_ATTRIBUTE+0),a
|
|
|
|
xor a ;clear carry ;set MEM_FAT_OF0_DATREM to remaining sectors
|
|
ld a,(ix+0x1F) ;cluste length shift by 256
|
|
rra
|
|
ld (MEM_FAT_FILEREMAIN+2),a
|
|
ld a,(ix+0x1E)
|
|
rra
|
|
ld (MEM_FAT_FILEREMAIN+1),a
|
|
ld a,(ix+0x1D)
|
|
rra
|
|
ld (MEM_FAT_FILEREMAIN+0),a
|
|
ld a,0
|
|
ld (MEM_FAT_FILEREMAIN+3),a
|
|
call fat_getfatsec ;get sector information
|
|
|
|
xor a
|
|
RET
|
|
|
|
|
|
;=================== UTIL Functions ===========================
|
|
; 32 Bit addition to pointer
|
|
; HL has value
|
|
;deprecated!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
_fat_math_sector_add_16:
|
|
ld (MEM_FAT_TMPPOINTER), hl
|
|
xor a
|
|
ld (MEM_FAT_TMPPOINTER+2),a
|
|
ld (MEM_FAT_TMPPOINTER+3),a
|
|
|
|
ld de,[MEM_FAT_TMPPOINTER]
|
|
ld bc,[MEM_IDE_POINTER]
|
|
call _fat_math_add32
|
|
ret
|
|
;deprecated!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
|
;hl contains pointer
|
|
_fat_increment_32
|
|
ld a,(HL) ; byte 0
|
|
add 1
|
|
ld (hl),a
|
|
inc hl
|
|
ld a,(HL) ; byte 1
|
|
adc 0
|
|
ld (hl),a
|
|
inc hl
|
|
ld a,(HL) ; byte 2
|
|
adc 0
|
|
ld (hl),a
|
|
inc hl
|
|
ld a,(HL) ; byte 3
|
|
adc 0
|
|
ld (hl),a
|
|
ret
|
|
;bc contains pointer to a (also result)
|
|
;de contains pointer to b
|
|
_fat_math_add32
|
|
push hl
|
|
push bc
|
|
push de
|
|
ld a,(de) ; load lower 16bit for B int from (DE) to HL
|
|
ld l,a
|
|
inc de
|
|
ld a,(de)
|
|
ld h,a
|
|
inc de
|
|
; HL, DE dirty
|
|
ld a,(bc) ; load lower 16bit for A int from (BC) to DE
|
|
ld e,a
|
|
inc bc
|
|
ld a,(bc)
|
|
ld d,a
|
|
; HL now contains A, DE now contains D
|
|
add hl,de ;add lower bytes, store carry
|
|
pop de ;restore pointers
|
|
pop bc ;both now cointain first byte of long-value
|
|
ld a,l ;store lower result in (bc)
|
|
ld (bc),a
|
|
inc bc
|
|
ld a,h
|
|
ld (bc),a
|
|
inc bc
|
|
inc de ;also increment de to next byte
|
|
inc de
|
|
; DE and HL now start at the upper byte
|
|
push bc
|
|
push de
|
|
ld a,(de) ; load upper 16bit for B
|
|
ld l,a
|
|
inc de
|
|
ld a,(de)
|
|
ld h,a
|
|
inc de
|
|
ld a,(bc) ; load upper 16bit for A
|
|
ld e,a
|
|
inc bc
|
|
ld a,(bc)
|
|
ld d,a
|
|
adc hl,de ;add upper bytes, store carry
|
|
pop de
|
|
pop bc
|
|
ld a,l ;store lower result in (bc)
|
|
ld(bc),a
|
|
inc bc
|
|
ld a,h
|
|
ld(bc),a
|
|
pop hl
|
|
ret
|
|
|
|
|
|
; Multiply 16-bit values (with 32-bit result)
|
|
; Operands BC, DE
|
|
; Result -> BCHL
|
|
_fat_math_mul32:
|
|
ld a,c
|
|
ld c,b
|
|
ld hl,0
|
|
ld b,16
|
|
_fat_math_mul32_l:
|
|
add hl,hl
|
|
rla
|
|
rl c
|
|
jr nc,_fat_math_mul32_noadd
|
|
add hl,de
|
|
adc a,0
|
|
jp nc,_fat_math_mul32_noadd
|
|
inc c
|
|
_fat_math_mul32_noadd:
|
|
djnz _fat_math_mul32_l
|
|
ld b,c
|
|
ld c,a
|
|
ret
|
|
|
|
; reset LBA pointer to first sector in selected partition
|
|
fat_reset_pointer:
|
|
call ideif_get_drv_pointer
|
|
inc ix
|
|
inc ix
|
|
push ix
|
|
pop hl ;copy poiter to hl
|
|
ld de, MEM_IDE_POINTER
|
|
jr fat_copy_lba_pointer
|
|
|
|
; resets LBA pointer (4-byte) to partition start
|
|
; HL = from here
|
|
; DE = to this destimation
|
|
fat_copy_lba_pointer:
|
|
PUSH BC
|
|
LD B,0
|
|
LD C,4
|
|
LDIR
|
|
POP BC
|
|
ret
|
|
|
|
; compares filenames
|
|
; HL points to name1
|
|
; DE points to name2
|
|
; Carry is set if match
|
|
; Destroys DE, AF
|
|
compare_filename:
|
|
PUSH HL
|
|
push BC
|
|
LD B, 11 ;Counter
|
|
_compare_filename_loop:
|
|
LD A,(DE)
|
|
LD C,A
|
|
LD A,(HL)
|
|
INC HL
|
|
INC DE
|
|
XOR C ;check if identical (should return 0)
|
|
JR NZ, _compare_filename_nomatch
|
|
djnz _compare_filename_loop ;if not last, continue
|
|
POP BC
|
|
POP HL
|
|
SCF
|
|
RET
|
|
_compare_filename_nomatch:
|
|
POP BC
|
|
POP HL
|
|
XOR A ; clear carry flag
|
|
RET
|
|
|
|
; formats filename to 8+3 format
|
|
; DE points to source filename to string
|
|
; HL points to destination
|
|
format_filename_fat16:
|
|
LD B, 11 ;counter
|
|
PUSH HL
|
|
LD A, ' '
|
|
_format_filename_fat16_clean:
|
|
LD (HL),A
|
|
INC HL
|
|
DJNZ _format_filename_fat16_clean
|
|
POP HL ; continue with copy
|
|
LD B, 13
|
|
_format_filename_fat16_loop:
|
|
LD A, (DE) ; load byte
|
|
OR A
|
|
RET Z ;exit on 0byte
|
|
DEC B ;reduce counter
|
|
RET Z ;exit after 12 bytes 8+.+3
|
|
CP '.' ; check if dot
|
|
JR NZ, _format_filename_fat16_loop_copy ; if not continue as usual
|
|
INC DE ;else skip char
|
|
_format_filename_fat16_loop_skip_8:
|
|
LD A,B
|
|
CP 5
|
|
JR C, _format_filename_fat16_loop
|
|
INC HL
|
|
DEC B
|
|
JR _format_filename_fat16_loop_skip_8
|
|
|
|
_format_filename_fat16_loop_copy:
|
|
LD A, (DE) ; load byte
|
|
LD (HL), A ; copy byte
|
|
INC HL
|
|
INC DE
|
|
JP _format_filename_fat16_loop |