dennisgunia/Z8C-Homebrew-Computer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fat16 working

Browse Source
This commit is contained in:
Dennis Gunia
2024-01-25 00:12:46 +01:00
parent 507eb3a017
commit 488efa3907
33 changed files with 10561 additions and 6941 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
OperatingSystem/monitor_v2/include/cmd_disk.s
View File

@@ -11,7 +11,7 @@ OP_SELDSK:
jr c,_OP_SELDSK_INVALID
cp 4
jr nc, _OP_SELDSK_INVALID
call 0x8000
call ideif_drv_sel
ret
_OP_SELDSK_INVALID:
@@ -22,5 +22,17 @@ _OP_SELDSK_INVALID:
CALL beep
ret
OP_DIR:
CALL fat_print_directory
ret
OP_CD:
call fat_cd_single
ret
_OP_SELDSK_INVALID_STR:
db 10,13,"Invalid drive letter",10,13,0
db 10,13,"Invalid drive letter",10,13,0
OP_FSEXEC:
call fat_exec
ret

15
OperatingSystem/monitor_v2/include/command.s
View File

@@ -13,6 +13,9 @@ COMMAND_LUT:
db "rst", 0,0x00,0x00 ;soft reset
db "lsdsk", 0,[OP_LSDSK], [OP_LSDSK]>>8 ;list disks
db "seldsk ", 0,[OP_SELDSK], [OP_SELDSK]>>8 ;select disk
db "cd ", 0 , [OP_CD], [OP_CD]>>8 ;Read time
db "ls", 0 , [OP_DIR], [OP_DIR]>>8 ;Read time
db "run ", 0 , [OP_FSEXEC], [OP_FSEXEC]>>8 ;Read time
db "$", 0, [OP_EXEC], [OP_EXEC]>>8 ;jump to addr
db "i", 0, [OP_IO_IN], [OP_IO_IN]>>8 ;Read port
db "o", 0, [OP_IO_OUT], [OP_IO_OUT]>>8 ;Write port
@@ -20,14 +23,14 @@ COMMAND_LUT:
db "?", 0, [OP_DUMP], [OP_DUMP]>>8 ;Print memory
db 0xFF ;End of Table
IN_BUFFER .equ var_buffer
COMMAND:
call print_newLine
ld hl,[var_dir]
call print_str
ld a,'>'
call print_char
xor a ;reset buffer len
ld (var_buffer_len),a
ld (var_buffer_len),a ;set buffer len to 0
COMMAND_READ:
call read_char
jp z, COMMAND_READ ;wait for input
@@ -40,7 +43,7 @@ COMMAND_READ:
push af
; a contains latest char
ld hl,[var_buffer]
ld hl,[var_input]
ld d,0
ld a,(var_buffer_len)
ld e,a
@@ -65,7 +68,7 @@ COMMAND_BACKSPACE:
ld (var_buffer_len),a ;and store it
ld e,a ;load de with decremented value
ld d,0
ld hl,[var_buffer]
ld hl,[var_input]
add hl,de ;hl now contains pointer to last position in buffer
xor a ; store null byte to current location
ld (hl),a
@@ -81,7 +84,7 @@ COMMAND_PROCESS:
;compare
LD HL,[COMMAND_LUT] ;Lookup table
COMMAND_PROCESS_LOOP:
LD DE,[var_buffer] ;Buffer
LD DE,[var_input] ;Buffer
LD A,(HL) ;Load first byte of entry
CP 0xFF
JP Z,COMMAND_PROCESS_NOT_FOUND ;if first byte is 0xFF, End is reached

80
OperatingSystem/monitor_v2/include/console.s
View File

@@ -132,6 +132,24 @@ _read_bcd_invalid
ld a, 0xFF
ret
print_32_hex:
ld a,(ix+3)
call print_a_hex
ld a,(ix+2)
call print_a_hex
ld a,(ix+1)
call print_a_hex
ld a,(ix+0)
call print_a_hex
ret
print_16_hex:
ld a,(ix+1)
call print_a_hex
ld a,(ix+0)
call print_a_hex
ret
;MSG_CRSR_0:
; db 0x1B, "[?25h",0
@@ -154,4 +172,66 @@ A_RTS_ON:
out (CS_SIO_A_C),A
ld a,0EAh ;DTR active, TX 8bit, BREAK off, TX on, RTS active
out (CS_SIO_A_C),A
ret
;------------------------------------------------------------------------------
; PRINTINLINE
;
; String output function
;
; Prints in-line data (bytes immediately following the PRINTINLINE call)
; until a string terminator is encountered (0 - null char).
;------------------------------------------------------------------------------
PRINTINLINE:
EX (SP),HL ; PUSH HL and put RET ADDress into HL
PUSH AF
PUSH BC
nxtILC:
LD A,(HL)
CP 0
JR Z,endPrint
CALL print_char
INC HL
JR nxtILC
endPrint:
INC HL ; Get past "null" terminator
POP BC
POP AF
EX (SP),HL ; PUSH new RET ADDress on stack and restore HL
RET
print_reg:
push af
push de
push bc
push hl
push af
call PRINTINLINE
db 10,13,"A: ",0
pop af
call print_a_hex
call PRINTINLINE
db 10,13,"BC: ",0
ld a,b
call print_a_hex
ld a,c
call print_a_hex
call PRINTINLINE
db 10,13,"DE: ",0
ld a,d
call print_a_hex
ld a,e
call print_a_hex
pop af
call PRINTINLINE
db 10,13,"HL: ",0
ld a,h
call print_a_hex
ld a,l
call print_a_hex
call print_newLine
pop hl
pop bc
pop de
pop af
ret

622
OperatingSystem/monitor_v2/include/fat16.s Normal file
View File

@@ -0,0 +1,622 @@
; 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

366
OperatingSystem/monitor_v2/include/fat16_cmd.s Normal file
View File

@@ -0,0 +1,366 @@
;-------------------------------------
; Print current fat directory of MEM_FAT_CURRDIR
;-------------------------------------
fat_print_directory:
ld hl,MEM_FAT_CURRDIR
ld de,MEM_IDE_POINTER
ldi
ldi
ldi
ldi
LD DE,(MEM_FAT_SECTORS)
LD (MEM_FAT_COUNT1),DE
LD HL,MEM_IDE_POINTER ;read first sector
LD B,1
LD DE, MEM_IDE_BUFFER ;where to store data?
call read_lba_sector
call PRINTINLINE
db 10,13," Filename Cluster Size",10,13,0
LD HL, MEM_IDE_BUFFER ;set buffer start
LD C,16 ;set entries counter
_fat_print_directory_loop: ;loop over each entry (32byte)
LD A,(HL) ; check first byte
PUSH HL ;backup start of entry
POP IX
PUSH HL
;ignore unwanted entries
CP 0x41 ;skip invisible
JP Z, _fat_print_directory_loop_next
CP 0xE5 ;skip deleted
JP Z, _fat_print_directory_loop_next
CP 0x00 ;reached end
JP Z, _fat_print_directory_loop_break
;check file attribute
ld a,(IX+0x0B)
cp 0x10 ;if subdirectors
jp z, _fat_print_directory_dir ;print dir
;else print file
_fat_print_directory_loop_file
;print filename
ld a,' '
call print_char
ld a,' '
call print_char
LD B,8
call print_str_fixed
ld A,'.'
call print_char
LD B,3
call print_str_fixed
call PRINTINLINE
db " 0x",0
;first cluster number
ld a,(ix+0x1B)
call print_a_hex
ld a,(ix+0x1A)
call print_a_hex
call PRINTINLINE
db " 0x",0
ld a,(ix+0x1F)
call print_a_hex
ld a,(ix+0x1E)
call print_a_hex
ld a,(ix+0x1D)
call print_a_hex
ld a,(ix+0x1C)
call print_a_hex
call print_newLine
jr _fat_print_directory_loop_next
_fat_print_directory_dir
ld a,'D'
call print_char
ld a,' '
call print_char
LD B,8
call print_str_fixed
call PRINTINLINE
db " 0x",0
;first cluster number
ld a,(ix+0x1B)
call print_a_hex
ld a,(ix+0x1A)
call print_a_hex
call print_newLine
jr _fat_print_directory_loop_next
_fat_print_directory_loop_next: ; read next entry
DEC C ;next sector after 32 entries
JR Z,_fat_print_directory_loop_next_sector
POP HL ;restore start
LD DE, 32 ;length of entry
ADD HL,DE ;increment
JP _fat_print_directory_loop
_fat_print_directory_loop_next_sector: ; end fo sector. read next sector from disk
POP HL ;clear stack from old hl
LD H,0
LD L,1
call _fat_math_sector_add_16 ;increment sector
LD DE,(MEM_FAT_COUNT1) ; decrement sector count (max FAT length)
DEC DE
LD (MEM_FAT_COUNT1),DE
LD A,D
OR E
RET Z ; if DE is 0, mmax is reached. End here
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
JP _fat_print_directory_loop
_fat_print_directory_loop_break
POP HL
ret
;-------------------------------------
; Changes current fat directory of MEM_FAT_CURRDIR
; input is relativ path
; DE points to path
;-------------------------------------
fat_cd_single:
push de
; check if user wants to go back (input = '..')
ld a,(de)
cp '.'
jr nz, _fat_cd_navigate; if not, skip
inc de ;check next
ld a,(de)
cp '.'
jr nz, _fat_cd_navigate; if not, skip
ld a,(var_dir+79) ;last byte contains depth
or a; Test if 0
jp z, _fat_cd_navigate_error ;cannot go back any more (already at root)
; check if .. exists in directory
ld a,'.' ;prepare filename buffer
ld hl,[MEM_FAT_TMPFNAME]
ld (hl),a
inc hl
ld (hl),a
inc hl
ld a,0x20 ;clear char 3-11
ld b,11
_fat_cd_navigate_goback_fl:
ld (hl),a
inc hl
djnz _fat_cd_navigate_goback_fl ;fill loop end
call fat_openfile_noprepare ;load file table (only 1st sector needed)
or a ;check for error
jp nz, _fat_cd_navigate_error ;entry not found exception
; find end of path
ld hl,[var_dir+3] ;current position
ld bc,76
ld a,0x00 ;termination char
cpir ;find end
jp po,_fat_cd_navigate_inerror ;in case of error, abort
;hl is now at end of string
ld bc,76
ld a,'\' ;seperation char
cpdr ;serach backwards for "/"
jp po,_fat_cd_navigate_inerror ;in case of error, abort
;hl is now at end of string
inc hl
xor a
ld (hl),a ;set termination char
inc hl
ld (hl),a ;set termination char
ld a,(var_dir+79)
dec a
ld (var_dir+79),a ;decrement dir depth counter
pop de
ld hl,[var_dir+2]
ld a,'\'
ld (hl),a ;set first /
ld hl,MEM_FAT_OF0_DATSEC ;setup directory pointer
ld de,MEM_FAT_CURRDIR
ldi
ldi
ldi
ldi
ret
_fat_cd_navigate
pop de ;get pointer to directory namme
push de ;and re-store it for next use
call fat_openfile ;find 'file' in current directory
_fat_cd_navigate_findsec
or a
jp nz, _fat_cd_navigate_error ;entry not found
ld a, (MEM_FAT_OF0_ATTRIBUTE)
cp 0x10
jp nz, _fat_cd_navigate_errfile
ld a,(var_dir+79)
inc a
ld (var_dir+79),a ;increment dir depth counter
ld hl,[var_dir+2] ;load start of path string
ld a,0 ;load termination char
ld bc,76 ;max length of string
cpir ;find end of path string
dec hl
jp po,_fat_cd_navigate_inerror ;in case of error, abort
;HL now has last element, BC has remaining max length
ld a,(var_dir+79) ;last byte contains depth
cp 1 ;if first path, skip /
jr z, _fat_cd_navigate_findsec_skipslash
ld a,'\'
ld (hl),a
inc hl
_fat_cd_navigate_findsec_skipslash
pop de ;get argument from stack
ex de,hl
push de ;store start to stack
;HL now has start of input string, DE has end of current path
ld bc,09 ;maximum length of directory name +1
_fat_cd_navigate_l2: ;copy new subdirectory
ldi ;copy
jp po,_fat_cd_navigate_inerrorS ;in case of error, abort
ld a,(hl) ;check next char
cp '\' ;end at '\'
jr z, _fat_cd_navigate_end ;else next byte
or a ;or and at 0x00
jr z, _fat_cd_navigate_end ;else next byte
jr _fat_cd_navigate_l2
_fat_cd_navigate_end:
xor a
ld (de),a ;set last byte to 0x00 (termination)
ld hl,MEM_FAT_OF0_DATSEC
;setup directory pointer
ld de,MEM_FAT_CURRDIR
ldi
ldi
ldi
ldi
pop de ;stack cleanup
ret
_fat_cd_navigate_error:
ld hl,[_fat_cd_navigate_error_str]
call print_str
pop de
ret
_fat_cd_navigate_inerrorS: ;with path reset
pop de ;restore former path
dec de ;change pointer to remove previous '\' as well
xor a ;clear a to 0x00
ld (de),a ;set last byte to 0x00 (termination)
jr _fat_cd_navigate_inerrore
_fat_cd_navigate_inerror: ;without path reset
pop de
_fat_cd_navigate_inerrore:
ld hl,[_fat_cd_navigate_inputerr_str]
call print_str
ret
_fat_cd_navigate_errfile:
pop de
ld hl,[_fat_cd_navigate_errfile_str]
call print_str
ret
_fat_cd_navigate_error_str:
db 10,13,"No such directory!",10,13,0
_fat_cd_navigate_inputerr_str:
db 10,13,"Invalid input!",10,13,0
_fat_cd_navigate_errfile_str:
db 10,13,"Cannot cd to file!",10,13,0
fat_exec:
push de
;DE has pointer to arguments
call fat_openfile
or a
jp nz, _fat_exec_notfound ;if not found, abort
;call fat_print_dbg
;load header
ld de, MEM_IDE_BUFFER
call fat_readfilesec
;ld hl, MEM_IDE_BUFFER ;print sector
;ld b,0x20
;call dump_pretty
ld a,(MEM_IDE_BUFFER)
cp 0xC3
jp nz, _fat_exec_notexec
call PRINTINLINE
db 10,13,"Loading ",0
ld hl,[var_input+6]
call print_str
call PRINTINLINE
db " to 0x",0
;get start address
ld bc,(MEM_IDE_BUFFER + 10)
ld a,b
call print_a_hex
ld a,c
call print_a_hex
call PRINTINLINE
db " ... ",0
;bc has start addr
ld (MEM_FAT_EXEC_CURR),bc
ld (MEM_FAT_EXEC_START),bc
;get amount of sectors to load
ld hl,(MEM_IDE_BUFFER + 14)
ld l,h
srl l
ld h,0 ;divide by 512
inc hl ;increment because first sector is always loaded
; hl contains sector count
ld (MEM_FAT_EXEC_COUNT), hl
pop de ; restore filename
call fat_openfile ;reset file information
;start reading
_fat_exec_readloop1:
ld de,(MEM_FAT_EXEC_CURR)
call fat_readfilesec
ld hl,(MEM_FAT_EXEC_CURR)
ld de,512
add hl,de
ld (MEM_FAT_EXEC_CURR),hl
ld hl,(MEM_FAT_EXEC_COUNT)
dec hl
ld (MEM_FAT_EXEC_COUNT),hl
ld a,h
or l
jr z, _fat_exec_read_done
jr _fat_exec_readloop1
_fat_exec_read_done:
call PRINTINLINE
db "Load complete!",10,13,0
ld hl,(MEM_FAT_EXEC_START)
jp (hl)
_fat_exec_notfound:
pop de
call PRINTINLINE
db 10,13,"File not found!",10,13,0
ret
_fat_exec_notexec:
pop de
call PRINTINLINE
db 10,13,"File is not an executable!",10,13,0
ret

77
OperatingSystem/monitor_v2/include/fat16_dbg.s Normal file
View File

@@ -0,0 +1,77 @@
fat_print_dbg:
call PRINTINLINE
db 10,13,"PTR.MEM_IDE_POINTER: 0x",0
ld ix,MEM_IDE_POINTER
call print_32_hex
call PRINTINLINE
db " | PTR.MEM_IDE_PARTITION: 0x",0
ld ix,MEM_IDE_PARTITION
call print_32_hex
call PRINTINLINE
db 10,13,"PTR.MEM_FAT_TMPPOINTER: 0x",0
ld ix,MEM_FAT_TMPPOINTER
call print_32_hex
call PRINTINLINE
db " | PTR.MEM_FAT_DATASTART: 0x",0
ld ix,MEM_FAT_DATASTART
call print_32_hex
call PRINTINLINE
db 10,13,"VAL.MEM_FAT_RESERVED: 0x",0
ld ix,MEM_FAT_RESERVED
call print_16_hex
call PRINTINLINE
db " | VAL.MEM_FAT_AMOUNT: 0x",0
ld a,(MEM_FAT_AMOUNT)
call print_a_hex
call PRINTINLINE
db 10,13,"VAL.MEM_FAT_SECTORS: 0x",0
ld ix,MEM_FAT_SECTORS
call print_16_hex
call PRINTINLINE
db " | VAL.MEM_FAT_COUNT1: 0x",0
ld a,(MEM_FAT_COUNT1)
call print_a_hex
call PRINTINLINE
db 10,13,"VAL.MEM_FAT_OF0_CCLUST: 0x",0
ld ix,MEM_FAT_OF0_CCLUST
call print_16_hex
call PRINTINLINE
db " | PTR.MEM_FAT_OF0_FATSEC: 0x",0
ld ix,MEM_FAT_OF0_FATSEC
call print_32_hex
call PRINTINLINE
db 10,13,"VAL.MEM_FAT_OF0_DATSEC: 0x",0
ld ix,MEM_FAT_OF0_DATSEC
call print_32_hex
call PRINTINLINE
db " | PTR.MEM_FAT_OF0_DATREM: 0x",0
ld ix,MEM_FAT_OF0_DATREM
call print_16_hex
call PRINTINLINE
db 10,13,"VAL.MEM_FAT_ROOTSTART: 0x",0
ld ix,MEM_FAT_ROOTSTART
call print_32_hex
call PRINTINLINE
db " | VAL.MEM_FAT_CLUSTERLEN: 0x",0
ld a,(MEM_FAT_CLUSTERLEN)
call print_a_hex
call PRINTINLINE
db 10,13,"VAL.MEM_FAT_FILEREMAIN: 0x",0
ld ix,MEM_FAT_FILEREMAIN
call print_32_hex
call PRINTINLINE
db " | VAL.MEM_FAT_DIRSEC: 0x",0
ld ix,MEM_FAT_DIRSEC
call print_16_hex
call print_newLine
ret

27
OperatingSystem/monitor_v2/include/kdrv_ide8255.s
View File

@@ -130,7 +130,7 @@ ide_regread_8:
; HL contains destination address
;------------------------------------------------------------------------------
ide_readsector_256:
LD C,255 ;Setup counter for 256 words
LD C,0 ;Setup counter for 256 words
ide_readsector_256_waitloop:
LD B, IDE_REG_CMDSTS
@@ -147,32 +147,27 @@ ide_readsector_256_waitloop:
OR IDE_RD ;Set Read bit
OUT (CS_PIA_PC), A ;Write Read to bit controll lines
NOP
NOP
NOP
;NOP
;NOP
IN A,(CS_PIA_PB) ;Load 16-Bit data to buffer
LD (HL), A
INC HL
IN A,(CS_PIA_PA)
LD (HL), A
INC HL
LD A,C
OR A
JP Z,ide_readsector_256_done
DEC C
RET Z
JR ide_readsector_256_waitloop
ide_readsector_256_done:
RET
ide_readsector_512_inv:
LD C,255 ;Setup counter for 256 words
LD C,0 ;Setup counter for 256 words
LD DE, 4096 ;Timeout counter
ide_readsector_512_inv_waitloop:
DEC DE
LD A,D
OR E
JP Z, ide_readsector_timeout
;timeout checked. continue
LD B, IDE_REG_CMDSTS
CALL ide_regread_8
BIT 0,a ;Error Bit set.
@@ -180,15 +175,17 @@ ide_readsector_512_inv_waitloop:
BIT 3,a ;DRQ Bit set. If set, disk has data
JR Z, ide_readsector_512_inv_waitloop ;If not set, wait
LD DE, 2048 ;Timeout counter
LD A, 10010010b ;CommandByte-A, Mode 0, PA IN, PC Out, PB IN
OUT (CS_PIA_CR), A ;Set Data direction to IN
LD A, IDE_REG_DATA ;CS0 and A=0 -> I/O register
OUT (CS_PIA_PC), A ;set register
OR IDE_RD ;Set Read bit
OUT (CS_PIA_PC), A ;Write Read to bit controll lines
;NOP
;NOP
NOP
NOP
NOP
IN A,(CS_PIA_PA) ;Load 16-Bit data to buffer
LD (HL), A
INC HL
@@ -196,10 +193,8 @@ ide_readsector_512_inv_waitloop:
LD (HL), A
INC HL
LD A,C
OR A
JP Z,ide_readsector_256_done
DEC C
RET Z
JR ide_readsector_512_inv_waitloop
ide_readsector_timeout:

62
OperatingSystem/monitor_v2/include/kdrv_ideif.s
View File

@@ -389,6 +389,7 @@ ideif_init_all:
;
; Reads A*512 byte sector into memory
; HL contains pointer to LBA address
; DE contains destination location
; A contains sector count
;------------------------------------------------------------------------------
read_lba_sector:
@@ -416,10 +417,59 @@ read_lba_sector:
LD A,IDE_CMD_READSEC ;send read command
LD B,IDE_REG_CMDSTS
CALL ide_regwrite_8
LD HL,MEM_IDE_BUFFER ;set read/write buffer start address
;LD HL,MEM_IDE_BUFFER ;set read/write buffer start address
EX DE,HL ;transfer destination in DE to HL
call ide_readsector_512_inv ;read 256 words from device
ret
;------------------------------------------------------------------------------
; ideif_drv_sel
;
; Select drive from table
; Prepare variables
;
; A contains drive number
;------------------------------------------------------------------------------
ideif_drv_sel:
ld (MEM_IDE_SELECTED),a
push af
call ideif_get_drv_pointer ;test if drive is marked as available
ld a,(ix+0)
or a
jp nz, _ideif_drv_sel_fail ;if not-> fail
call fat_get_root_table ;else get root table
ld hl,[_ideif_drv_sel_pstr] ;print success message
call print_str
pop af
add 69
ld (var_dir),a ;store drive letter
call print_char
ld a, ':'
ld (var_dir+1),a
ld a, '\'
ld (var_dir+2),a
xor a ;set dir to empty
ld (var_dir+3),a
ld (var_dir+79),a ;set depth counter
ld hl,[_ideif_drv_sel_sstr0]
call print_str
ret
_ideif_drv_sel_fail:
ld hl,[_ideif_drv_sel_pstr]
call print_str
pop af
add 69
call print_char
ld hl,[_ideif_drv_sel_fstr0]
call print_str
xor a ;set dir to empty
ld (var_dir),a
LD DE,0x20
LD BC,0x70
CALL beep
ret
@@ -446,4 +496,12 @@ _ideif_prnt_devtable_sFF:
_ideif_prnt_devtable_master:
db "Master ",0
_ideif_prnt_devtable_slave:
db "Slave ",0
db "Slave ",0
_ideif_drv_sel_pstr:
db 10,13,"Drive ",0
_ideif_drv_sel_fstr0:
db ": not ready",10,13,0
_ideif_drv_sel_sstr0:
db ": selected",10,13,0
_ideif_drv_sel_syn:
db 10,13,"Invalid drive letter",10,13,0