;---------------------------------------------------------;
; FAT16 file system
;---------------------------------------------------------;

file_init:
    clr    T14L;0
    stsi    CurrSect0+2, -1;Read MBR to Buff0
    ldiw    A, 0    ;
    ldi    BH, 0    ;
     rcall    file_get_sect0;
    rjne    fsi_err    ;/
    inc    T14L;1
    ldiw    Y, Buff0+0x1C2;Chekc MBR sign (55AA)
    lddw    A, Y+60    ;
    subiw    A, 0xAA55;
    rjne    mmi_err    ;/
    [i]inc    T14L;2
    ld    AL, Y    ;Check if 1st patition is FAT16.
    cpi    AL, 0x06;
    rjne    fsi_err    ;/

;---------------------------------------------------------;
; FAT16 file system
;---------------------------------------------------------;

file_init:
clr T14L;0
stsi CurrSect0+2, -1 ;Read MBR to Buff0
ldiw A, 0 ;
ldi BH, 0 ;
rcall file_get_sect0 ;
rjne fsi_err ;/
inc T14L;1
ldiw Y, Buff0+0x1C2 ;Chekc MBR sign (55AA)
lddw A, Y+60 ;
subiw A, 0xAA55 ;
rjne mmi_err ;/
inc T14L;2
ld AL, Y ;Check if 1st patition is FAT16.
cpi AL, 0x06 ;
rjne fsi_err ;/

inc T14L;3
lddw A, Y+4 ;Read PBR to Buff0
ldd BL, Y+6 ;
movw CL, AL ;
mov BH, BL ;
subiw C, -1 ;
sbci BH, -1 ;
stsw FatBase+0, C ;
sts FatBase+2, BH ;
rcall file_get_sect0 ;
rjne fsi_err ;/
inc T14L;4
ldsw A, Buff0+0x1FE ;Check PBR sign (55AA)
subiw A, 0xAA55 ;
brne fsi_err ;/
inc T14L;5
ldiw Z, fsi_fat16*2 ;Check FAT16 sign
ldiw X, Buff0+0x36 ;
lpm AL, Z+ ;
ld AH, X+ ;
cp AL, AH ;
brne fsi_err ;
cpi AH, ' ' ;
brne PC-5 ;/
inc T14L;6
ldiw Y, Buff0 ;Get FAT16 information
ldd AL, Y+0x0D ;
sts ClstSize, AL ;
ldsw A, FatBase+0 ;
lds BL, FatBase+2 ;
lddw X, Y+0x16 ;
lslw X ;
addw A, X ;
adc BL, _0 ;
stsw DirBase+0, A ;
sts DirBase+2, BL ;
lddw X, Y+0x11 ;
stsw DirNum, X ;
adiw XL, 15 ;
ldi CL, 4 ;
lsrw X ;
dec CL ;
brne PC-3 ;
addw A, X ;
adc BL, _0 ;
stsw DataBase+0, A ;
sts DataBase+2, BL ;/

sez
fsi_err:
ret

fsi_fat16: .db "FAT16 "



;---------------------------------------------------------;
; Open File
;
; Call: Y = Pointer to new file structure (18 bytes)
; A = Pointer to file access buffer (512 bytes)
; Z = Pointer to file name (ASCIZ)
; Ret: eq: Y == NULL : no file
; Y != NULL : successful
; ne: error

file_open:
movw T2L, ZL ;File name
stdw Y+16, A ;File buffer
ldiw D, 0 ;Reset file search

fo_ml:
rcall file_dir_init
movw ZL, T2L ;Pick a segment
rcall file_getseg;
movw T2L, ZL ;/
cpi CL, 1 ;Is file?
brcs fo_fl ;/
brne fo_nf ;Is invalid name?
fo_dl:
rcall file_dir_next;Get next directory entry
brne fo_ret ;/
cpw Z, _0 ;No more file?
breq fo_ret ;/
rcall fo_comp ;Name matched?
brne fo_dl ;/
ldd AL, Z+11;Is not a sub-dir?
sbrs AL, 4 ;
rjmp fo_nf ;/
lddw D, Z+26 ;Follow sub-dir
rjmp fo_ml ;/

fo_fl:
rcall file_dir_next;Get next directory entry
brne fo_ret ;/
cpw Z, _0 ;No more file?
breq fo_nf ;/
rcall fo_comp ;Name matched
brne fo_fl ;/
ldd AL, Z+11;Is not a file?
andi AL, 0b00011000;
brne fo_nf ;/

stdw Y+0, _0 ; File ptr
stdw Y+2, _0 ; /
lddw A, Z+28 ; File size
lddw B, Z+30 ;
stdw Y+4, A ;
stdw Y+6, B ; /
lddw D, Z+26 ; Cluster
stdw Y+14, D ;
stdw Y+12, D ; /
rcall file_clst2sect; Sector
stdw Y+8, A ;
stdw Y+10, B ;//
sez
ret

fo_nf: sez
fo_ret: ldiw Y, 0
ret

fo_comp:
pushw Z
ldiw X, FileName;Compare file name
ldi CL, 11 ;
ld AL, Z+ ;
ld AH, X+ ;
cp AL, AH ;
brne PC+3 ;
dec CL ;
brne PC-5 ;/
popw Z
ret



;---------------------------------------------------------;
; Read a line
;
; Call: Y = Pointer to the file srtucture
; Z = Pointer to read buffer
; Ret: eq:successful
; ne:error or no more data

file_gets:
ldiw C, 1
rcall file_read
brne fg_end
cpi CL, 1
brne fg_end
ld AL, Z
cpi AL, 10
breq fg_end
cpi AL, ' '
brcs file_gets
adiw ZL, 1
rjmp file_gets
fg_end:
st Z, _0
ret



;---------------------------------------------------------;
; Read File (Byte Oriented)
;
; Call: Y = Pointer to the file srtucture
; Z = Pointer to read buffer
; C = Number of bytes to read
; Ret: eq:successful, C = Number of bytes read
; ne:error, C = Number of bytes read

file_read:
pushw Z
lddw T0, Y+0 ;T2:T0 = File ptr
lddw T2, Y+2 ;/
lddw A, Y+4 ;B:A = File size
lddw B, Y+6 ;/
subw A, T0 ;B:A -= T2:T0
sbcw B, T2 ;/
cpw A, C ;if(B:A < C) C = B:A
cpcw B, _0 ;
brcc PC+2 ;
movw CL, AL ;/
movw T4L, CL ;T4 = C
clrw C ;C = 0
lddw B, Y+16 ;B = File buffer
movw XL, T0L ;X = File ptr & 511 + B
andi XH, high(511);
addw X, B ;/
cpw X, B
breq PC+2
addi BH, high(512);B += 512
fsr_lp1:
cpw C, T4 ;if(T4 >= C) return
brcc fsr_ret ;/
cpw X, B ;if(X >=
brcs fsr_s1 ;/
lddw A, Y+8 ;Fill buffer
ldd BL, Y+10;
lddw X, Y+16 ;
rcall mmc_read_sect;
brne fsr_ret ;/
rcall file_next_sect;Get next sector number
lddw X, Y+16 ;X = File buffer
movw BL, XL ;B = X + 512
addi BH, high(512);/
fsr_s1: ld AL, X+ ;*Z++ = *X++
st Z+, AL ;/
addiw C, 1 ;C++
adcw T0, _0 ;T2:T0++
adcw T2, _0 ;/
rjmp fsr_lp1
fsr_err:
clz
fsr_ret:
stdw Y+0, T0
stdw Y+2, T2
popw Z
ret



;---------------------------------------------------------;
; Read File (Non-Bufferd, Block Oriented)
;
; Call: Y = Pointer to the file srtucture
; Z = Pointer to read buffer
; C = Number of bytes to read (must be multiple of 512)
; Ret: eq:successful, C = Number of bytes read
; ne:error, C = Number of bytes read

file_read_block:
pushw Z
lddw T0, Y+0 ;T2:T0 = File ptr
lddw T2, Y+2 ;/
movw AL, CL ;Check count varidity
andi AH, high(511);
or AL, AH ;
brne fsb_err ;/
lddw A, Y+4 ;B:A = File size
lddw B, Y+6 ;/
subw A, T0 ;B:A -= T2:T0
sbcw B, T2 ;/
brcs fsb_nd ;No more data?
breq fsb_nd ;/
cpw A, C ;if(B:A < C) C = B:A
cpcw B, _0 ;
brcc PC+2 ;
movw CL, AL ;/
movw T4L, CL ;T4 = C
clrw C ;C = 0
fsb_lp1:
cpw C, T4 ;if(T4 >= C) return
brcc fsb_ret ;/
lddw A, Y+8 ;Load block
ldd BL, Y+10;
movw XL, ZL ;
rcall mmc_read_sect;
brne fsb_err ;/
rcall file_next_sect;Get next sector number
ldi AH, high(512);
add CH, AH ;C += 512
add ZH, AH ;Z += 512
add T0H, AH ;T2:T0 += 512
adcw T2, _0 ;/
rjmp fsb_lp1
fsb_ret:
movw CL, T4L
sez
fsb_err:
stdw Y+0, T0
stdw Y+2, T2
popw Z
ret
fsb_nd:
subw C, C
popw Z
ret



;---------------------------------------------------------;
; Seek File Pointer
;
; Call: Y = Pointer to file structure
; B:A = File Pointer
; Ret: eq: successful
; ne: error

file_seek_block:
clr AL
andi AH, ~high(511)

file_seek:
lddw T0, Y+4 ;Check if size <= fp
lddw T2, Y+6 ;
cpw A, T0 ;
cpcw B, T2 ;
brcc fs_ret ;/
movw T0L, AL ;T2:T0 = File pointer
movw T2L, BL ;/
stdw Y+0, T0 ;File Pointer
stdw Y+2, T2 ;/
lddw D, Y+14 ;Cluseter
stdw Y+12, D ;/
rcall file_clst2sect;Sector
stdw Y+8, A ;
stdw Y+10, B ;/

ldiw C, 512 ;Seek sector unit
fs_lp1: cpw T0, C ;
cpcw T2, _0 ;
brcs fs_s1 ;
rcall file_next_sect;
subw T0, C ;
sbcw T2, _0 ;
rjmp fs_lp1 ;/
fs_s1:
cpw T0, _0 ;Fill buffer if needed
breq fs_ret ;
lddw A, Y+8 ;
ldd BL, Y+10;
lddw X, Y+16 ;
rcall mmc_read_sect;
brne PC+3 ;
rcall file_next_sect;/
sez
fs_ret:
ret


;---------------------------------------------------------;
; Create file name in directory entry
;
;Call: Z = Pointer to file name
;Ret: CL = 0:File, 1:Dir, 2:Invalid
; Z = Next segment
; X = Broken

file_getseg:
ldiw X, FileName;Fill output buffer
ldi CH, 11 ;
ldi CL, ' ' ;
st X+, CL ;
dec CH ;
brne PC-2 ;
sbiw XL, 11 ;/
fcv_lp:
rcall fcv_getc
cpi CL, 3
brcc PC+2
ret
cpi CH, 11 ;Buffer full?
brcc fcv_lp ;/
cpi CL, '.' ;Is a dot?
breq PC+4 ;/
st X+, CL ;Store a char
inc CH ;
rjmp fcv_lp ;/
cpi CH, 0 ;Move to extension
brne PC+3 ;
ldi CL, 2 ;
ret ;
cpi CH, 8 ;
brcc fcv_lp ;
adiw XL, 1 ;
inc CH ;
rjmp PC-4 ;/

fcv_getc:
ld CL, Z+ ;Get a char
rcall caps ;/
cpi CL, 0x7F
brcc fcv_err
cpi CL, '|'
breq fcv_err
brcc fcv_ret
cpi CL, '\'
breq fcv_err
cpi CL, '@'
brcc fcv_ret
cpi CL, ':'
brcc fcv_err
cpi CL, '0'
brcc fcv_ret
cpi CL, '/'
breq fcv_dir
cpi CL, '-'
brcc fcv_ret
cpi CL, '*'
brcc fcv_err
cpi CL, '!'
brcc fcv_ret
cpi CL, ' '
brcs fcv_file
fcv_err:ldi CL, 2
fcv_ret:ret
fcv_dir:ldi CL, 1
ret
fcv_file:ldi CL, 0
ret


;---------------------------------------------------------;
; Initialize Directory Search
;
; Call: D: <2:Root, >=2:Sub(cluster#)

file_dir_init:
ldiw A, -1
stsw DirIndex, A
stsw DirClst, D
ldsw A, DirBase+0
lds BL, DirBase+2
ldi BH, 0
cpw D, _0
breq PC+2
rcall file_clst2sect
stsw DirSect+0, A
stsw DirSect+2, B
ret


;---------------------------------------------------------;
; Get Next Directory Entry
;
; Ret: Z != NULL: successrul, Z=Pointer to the directory entry
; Z == NULL: no more entry

file_dir_next:
pushw T2
ldsw T2, DirIndex
fnd_next:
sec ;T2++
adcw T2, _0 ;/
cpw T2, _0 ;First search?
breq fnd_cmp ;/
mov AL, T2L ;Sector changed?
andi AL, 15 ;
brne fnd_cmp ;/
ldsw A, DirSect+0;Next sector
ldsw B, DirSect+2;
sec ;
adcw A, _0 ;
adc BL, _0 ;/
ldsw D, DirClst;Is root dir?
subiw D, 2 ;
brcs fnd_st ;/
inc BH ;Cluster not changed?
lds DL, ClstSize;
cp BH, DL ;
brcs fnd_st ;/
ldsw D, DirClst;Goto next cluster (sub-dir)
rcall file_next_clust;
brne fnd_ret ;
stsw DirClst, D;
rcall file_clst2sect;/
fnd_st: stsw DirSect+0, A
stsw DirSect+2, B
fnd_cmp:
ldsw A, DirClst;Is end of sub-dir?
movw BL, AL ;
subiw A, 0xFFF0;
brcc fnd_nofile;/
subiw B, 2 ;Is sub-dir?
brcc PC+8 ;/
ldsw A, DirNum;End of root-dir?
cpw T2, A ;
brcc fnd_nofile;/

ldsw A, DirSect+0;Get directory sector
lds BL, DirSect+2;
rcall file_get_sect0;
brne fnd_ret ;/
ldi AL, 32 ;Z = ((T2 & 15) << 5) + Buff0
mov AH, T2L ;
andi AH, 15 ;
mul AL, AH ;
movw ZL, T0L ;
addiw Z, Buff0;/
ldd AL, Z+0 ;Is empty entry?
cpi AL, 0xE5;
rjeq fnd_next;/
cpi AL, 0 ;Is end of dir?
breq fnd_nofile;/
sez
rjmp fnd_ret
fnd_nofile:
subw Z, Z
fnd_ret:
stsw DirIndex, T2
popw T2
ret


;---------------------------------------------------------;
; Get Next Sector
;
; Call: Y = File structure
; Ret: BL:A(!=-1) = next sector
; BL:A = -1: error

file_next_sect:
lddw A, Y+8 ;BL:A = CurrSect
lddw B, Y+10 ;BH = CurrSectInClust
subiw A, -1 ;BL:A++
sbci BL, -1 ;/
inc BH ;BH++
lds DL, ClstSize;if(BH < ClstSize) goto fsr_s1
cp BH, DL ;
brcs fsn_ret ;/
lddw D, Y+12 ;Get next cluster
rcall file_next_clust;/
brne fsn_err ;/
stdw Y+12, D ;Current cluster = D
rcall file_clst2sect;BL:A = sector#
fsn_ret:
stdw Y+8, A
stdw Y+10, B
ret
fsn_err:
ldiw A, 0xFFFF
ldiw B, 0x00FF
rjmp fsn_ret



;---------------------------------------------------------;
; Cluster --> Next cluster
;
; Call: D = Cluster
; Ret: EQ: D = Next cluster
; NE: error

file_next_clust:
ldsw A, FatBase+0;BL:A = (Current cluster / 256) + FatBase
lds BL, FatBase+2;
add AL, DH ;
adc AH, _0 ;
adc BL, _0 ;/
push DL ;Read FAT
rcall file_get_sect0;
pop XL ;
brne fnc_err ;
clr XH ;D = Buff0[(Current cluster & 255) << 1]
lslw X ;
addiw X, Buff0;
ldw D, X+ ;/
sez
fnc_err:
ret



;---------------------------------------------------------;
; Cluster --> Sector
;
; Call: D = Cluster#
; Ret: EQ: valid, BL:A=Sector#, BH=0
; NE: invalid, BL:A=-1, BH=0
; Broken: X, D, T0

file_clst2sect:
ldiw A, 0xFFF0;Check if the cluster number is valid
cpw D, A ;
brcc flc_ivd ;
subiw D, 2 ;
brcs flc_ivd ;/
movw XL, T0L ;BL:A = (D - 2) * ClstSize
lds BH, ClstSize;
mul DL, BH ;
movw AL, T0L ;
mul DH, BH ;
add AH, T0L ;
ldi BL, 0 ;
adc BL, T0H ;
movw T0L, XL ;/
ldsw X, DataBase+0;BL:A += DataBase
lds BH, DataBase+2;
addw A, X ;
adc BL, BH ;/
clr BH ;BH = 0
ret
flc_ivd:
ldiw A, 0xFFFF
ldiw B, 0x00FF
clz
ret



;---------------------------------------------------------;
; Read a sector into Buff0

file_get_sect0:
lds DL, CurrSect0+0
cp DL, AL
lds DL, CurrSect0+1
cpc DL, AH
lds DL, CurrSect0+2
cpc DL, BL
breq PC+14
stsw CurrSect0+0, A
sts CurrSect0+2, BL
ldiw X, Buff0
rcall mmc_read_sect
breq PC+4
stsi CurrSect0+2, -1
ret




;-----------------------------------------------------------;
; MMC Control
;-----------------------------------------------------------;


mmc_init:
ldi CL, 20 ;Dummy clock
ldi DL, 0xFF ;
rcall mmc_xmitbyte ;
dec CL ;
brne PC-3 ;/

clr T14L;0
ldi CL, CMD0 ;Send CMD0
ldiw B, 0 ;
ldiw A, 0 ;
rcall mmc_xmit_cmd ;
andi AL, 0b01111110 ;Check error
brne mmi_err ;/

inc T14L;1
ldi CL, CMD1 ;Send CMD1
rcall mmc_xmit_cmd ;
breq PC+3 ;Check if card is ready
andi AL, 0b01111110 ;Check error
breq PC-4 ;/

inc T14L;2
ldiw Y, Buff0 ;Read CSD, CID and OCR
movw XL, YL ;
rcall mmc_read_info ;
brne mmi_err ;/
inc T14L;3
ldd AL, Y+5 ;Check block size (512)
andi AL, 0x0F ;
cpi AL, 9 ;/

mmi_err:
sbi PORTA, MCCS ;CS=H
ret



mmc_read_sect:
pushw C
mov BH, BL ;B:A *= 512;
mov BL, AH ;
mov AH, AL ;
clr AL ;
lsl AH ;
rolw B ;/
ldi CL, CMD17 ;Send CMD17
rcall mmc_xmit_cmd ;
brne PC+6 ;/
rcall mmc_wait_data ;Wait for data token
brne PC+4 ;/
ldi CL, 0 ;Read sector
rcall mmc_rcvblock ;/
sez
popw C
sbi PORTA, MCCS ;CS=H
ret



mmc_read_info:
ldi CL, CMD9 ;Send CMD9 (Read CSD)
rcall mmc_xmit_cmd ;
brne mri_err ;/
rcall mmc_wait_data ;Wait for data token
brne mri_err ;/
ldi CL, 16/2 ;Read CSD and show
rcall mmc_rcvblock ;/

ldi CL, CMD10 ;Send CMD10 (Read CID)
rcall mmc_xmit_cmd ;
brne mri_err ;/
rcall mmc_wait_data ;Wait for data token
brne mri_err ;/
ldi CL, 16/2 ;Read CID and show
rcall mmc_rcvblock ;/

ldi CL, CMD58 ;Send CMD58 (Read OCR)
rcall mmc_xmit_cmd ;
brne mri_err ;/
ldi CL, 4 ;Read OCR
rcall mmc_rcvbyte ;
st X+, AL ;
dec CL ;
brne PC-3 ;/
mri_err:
sbi PORTA, MCCS ;CS=H
ret



mmc_xmit_cmd:
ldi DL, 0xFF ;Dummy clock
rcall mmc_xmitbyte ;/
cbi PORTA, MCCS ;CS=L
mov DL, CL ;Cmd
rcall mmc_xmitbyte ;/
mov DL, BH ;Arg
rcall mmc_xmitbyte ;
mov DL, BL ;
rcall mmc_xmitbyte ;
mov DL, AH ;
rcall mmc_xmitbyte ;
mov DL, AL ;
rcall mmc_xmitbyte ;/
ldi DL, 0x95 ;Crc
rcall mmc_xmitbyte ;/
ldi AH, 200
rcall mmc_rcvbyte ;Receive a byte
subi AH, 1 ;Timeout (375us) occured?
brcs PC+4 ;/
sbrc AL, 7 ;Is valid response?
rjmp PC-4 ;/
tst AL ;Check error status
ret



mmc_xmitbyte:; 5.5us
in DH, PORTA
ldi EL, 8
cbr DH, (1<<MCDI)+(1<<MCCK)
lsl DL
brcc PC+2
sbr DH, (1<<MCDI)
out PORTA, DH;DI=data, CK=L
sbr DH, (1<<MCCK)
out PORTA, DH;CK=H
dec EL
brne PC-8
ret



mmc_wait_data:
pushw X
ldiw X, 5333
rcall mmc_rcvbyte ;Receive a byte
sbiw XL, 1 ;Timeout (10ms) occured?
brcs PC+4 ;/
cpi AL, 0xFF ;Any token is detected?
breq PC-4 ;/
cpi AL, 0xFE ;Valid data taken ?
popw X
ret



mmc_rcvbyte:; 1.875us
in DH, PORTA
sbr DH, (1<<MCDI);DI=H
mov DL, DH
cbr DH, (1<<MCCK);CK=L
mmc_rcvbyte2:; 1.625us
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
rjmp PC+1
in AL, PINC
ret



mmc_rcvblock:; words * 2.69us + 4.1us
in DH, PORTA
sbr DH, (1<<MCDI);DI=H
mov DL, DH
cbr DH, (1<<MCCK);CK=L
mr_lp1:
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
rjmp PC+1
in AL, PINC
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
out PORTA, DH
out PORTA, DL
st X+, AL
in AL, PINC
st X+, AL
dec CL
brne mr_lp1
;mmc_rcvcrc2:
rcall mmc_rcvbyte2 ;Purge CRC
rcall mmc_rcvbyte2 ;/
sbi PORTA, MCCS ;CS=H
ret

;----------------------------------------------------------------------------;
; Laser Display Controller ©ChaN, 2006
;----------------------------------------------------------------------------;

.include "m64def.inc"
.include "avr.inc"
.include "ldp.inc"

;----------------------------------------------------------;
; SRAM Area

.dseg
.org RAMTOP100
Buff0: .byte 512 ;File system working buffer
Buff1: .byte 512 ;File buffer1
.byte 512 ;File buffer2


FatBase: .byte 3 ; FAT start sector
DirBase: .byte 3 ; Directory start sector
DataBase: .byte 3 ; Data start sector
DirNum: .byte 2 ; Number of root directory entry
ClstSize: .byte 1 ; Cluster size (sectors)

CurrSect0: .byte 3 ; Current sector in Buff0
DirIndex: .byte 2 ; Directory index (file_dir_)
DirClst: .byte 2 ; Directory cluster number (0:Null, 1:Root, >1:clst#)
DirSect: .byte 3 ; Current sector
DirInClst: .byte 1 ; Current sector in currrent cluster

FileName: .byte 11 ; File name buffer for file_open



; File control structure 1
File1: .byte 18 ; 0[4]: File ptr
File2: .byte 18 ; 4[4]: File size
; 8[3]: Current sector
; 11[1]: Current sector in currrent cluster
; 12[2]: Current cluster
; 14[2]: Start cluster
; 16[2]: Ptr to file buffer


LineBuf: .byte 40 ;Command Input buffer
DumpAdr: .byte 3
RxBuff: .byte 2+32 ;Serial Receiving Buffer

KeyCmd: .byte 3 ;Key input buffer
Lcdp: .byte 1 ;LCD cursor position

VectFifo: .byte 2+1 ;Vector FIFO buffer {RPtr, Count}

Index: .byte 2 ;Current, Items
ListPtr: .byte 2 ;
List: .byte 2000 ;File List


;----------------------------------------------------------;
; Program Code

.cseg
; Interrupt Vectors (ATmega64)
jmp reset ; Reset
jmp 0 ; Extrenal INT0
jmp 0 ; External INT1
jmp 0 ; External INT2
jmp 0 ; External INT3
jmp 0 ; External INT4
jmp 0 ; External INT5
jmp 0 ; External INT6
jmp 0 ; External INT7
jmp 0 ; TC2 COMP
jmp 0 ; TC2 OVF
jmp 0 ; TC1 CAPT
jmp isr_tc1_coma ; TC1 COMPA
jmp 0 ; TC1 COMPB
jmp 0 ; TC1 OVF
jmp isr_tc0_com ; TC0 COMP
jmp 0 ; TC0 OVF
jmp 0 ; SPI,STC
jmp isr_usart0_rx ; USART0 RX
jmp 0 ; USART0 UDRE
jmp 0 ; USART0 TX
jmp 0 ; ADC
jmp 0 ; EE READY
jmp 0 ; ANALOG COMP
jmp 0 ; TC1 COMPC
jmp 0 ; TC3 CAPT
jmp 0 ; TC3 COMPA
jmp 0 ; TC3 COMPB
jmp 0 ; TC3 COMPC
jmp 0 ; TC3 OVF
jmp 0 ; USART1 RX
jmp 0 ; USART1 UDRE
jmp 0 ; USART1 TX
jmp 0 ; TWI
jmp 0 ; SPM READY


.include "LDP_MMC.ASM" ; MMC control and FAT16 file system
.include "LDP_MON.ASM" ; Monitor
.include "LDP_UI.ASM" ; Key, Serial, LCD


;----------------------------------------------------------;
; Initailize peripherals and work area

reset:
clr _0 ;Zero reg.
ldiw Z, RAMEND ;SP
outw SP, Z ;/
ldiw X, 4096-1 ;Clear RAM
st -Z, _0 ;
sbiw XL, 1 ;
brne PC-2 ;/

outi PORTA, 0b01111111 ;Port A
outi DDRA, 0b01110000 ;

outi PORTB, 0b11111001 ;Port B
outi DDRB, 0b00000111 ;

outi PORTD, 0b11000000 ;Port D
outi DDRD, 0b00111111 ;

outi PORTE, 0b11111111 ;Port E
outi DDRE, 0b00110010 ;

stsi PORTF, 0b11111111 ;Port F
stsi PORTG, 0b11111 ;Port G

ldi AL, SYSCLK/16/BPS-1 ;Start USART0
out UBRR0L, AL ;
outi UCSR0B, 0b10011000 ;/

outi SPCR, 0b01011000 ;Enable SPI
outi SPSR, 0b00000001 ;/

outi OCR0, 156-1 ;Timer0: 100Hz interval
outi TCCR0, 0b00001111 ;/

outi TIMSK, 0b00010010 ;Enable timer interrupts

sei

rcall lcd_init ;Initialize LCD

ldi AL, 13 ;200ms
ldiw X, 0 ;
sbiw XL, 1 ;
brne PC-1 ;
dec AL ;
brne PC-5 ;/

rcall pps_stop ;Initialize DAC

rcall mmc_init ;Initialize MMC
breq PC+4 ;
ldiw Z, die_mmcerr*2 ; "MMC Err #"
rjmp die ;/

rcall file_init ;Initialize file system
breq PC+4 ;
ldiw Z, die_fserr*2 ; "FS Errr #"
rjmp die ;/


;----------------------------------------------------------;
; Main

main_index:
ldiw D, 0
rcall file_dir_init ;Initialize directory index
rcall clr_index
mi_l1:
rcall file_dir_next ;Get next file
rjne mi_err ;/
cpw Z, _0 ;No more?
breq mi_l2 ;/
rcall chk_index ;Check if *.txt
brne mi_l1 ;/
rcall add_index ;Add it to index list
brne mi_l1 ;/
mi_l2:
rcall disp_item
mi_l3:
rcall chk_online
rcall get_key_nw
breq mi_l3
sbrc AL, K_NEXT
rcall idx_next
sbrc AL, K_PREV
rcall idx_prev
sbrc AL, K_SET
rjmp main_list
sbrc AL, K_CLR
rjmp main_index
rjmp mi_l2


main_list:
rcall get_item
ldiw Y, File1
ldiw A, Buff1
rcall file_open
cpw Y, _0
rjeq mi_err
rcall clr_index
ml_l1:
ldiw Z, LineBuf ;Get next line
rcall file_gets ;
brne ml_l2 ;/
lds AL, LineBuf ;Check if valid line
cpi AL, '0' ;
brcs ml_l1 ;/
rcall add_index ;Add it to index list
brne ml_l1 ;/
ml_l2:
rcall disp_item_file
ml_l3:
rcall get_key_nw
breq ml_l3
sbrc AL, K_NEXT
rcall idx_next
sbrc AL, K_PREV
rcall idx_prev
sbrc AL, K_CLR
rjmp main_index
sbrs AL, K_SET
rjmp ml_l2
ml_l4:
rcall get_item
ldiw Y, File1
ldiw A, Buff1
rcall file_open
cpw Y, _0
breq ml_l3
rcall play
sbrc AL, K_NEXT
rjmp pi_next
sbrc AL, K_PREV
rjmp pi_prev
rjmp ml_l3
pi_next: rcall idx_next
rcall disp_item_file
rjmp ml_l4
pi_prev: rcall idx_prev
rcall disp_item_file
rjmp ml_l4


disp_item_file:
rcall lcd_clear
ldsw A, Index
cp AL, AH
brcc di_noitem
inc AL
rcall lcd_prin_val
ldi AL, ':'
rcall lcd_wr_chr
rcall get_item
ldiw Y, File1
ldiw A, Buff1
rcall file_open
brne dif_nofile
cpw Y, _0
breq dif_nofile
ldiw Z, LineBuf
ldiw C, 32
rcall file_read
brne dif_ivd
cpi CL, 32
brne dif_ivd
ldiw Z, LineBuf
lddw A, Z+0
cpi AL, 'V'
brne dif_ivd
cpi AH, 'D'
brne dif_ivd
adiw ZL, 16
std Z+14, _0
rcall lcd_mprin
ret
dif_nofile:
ldiw Z, id_nofile*2
rjmp lcd_fprin
dif_ivd:
ldiw Z, id_invalid*2
rjmp lcd_fprin


disp_item:
rcall lcd_clear
ldsw A, Index
cp AL, AH
brcc di_noitem
inc AL
rcall lcd_prin_val
ldi AL, ':'
rcall lcd_wr_chr
rcall get_item
rcall lcd_mprin
ret
di_noitem:
ldiw Z, id_noitem*2
rjmp lcd_fprin


idx_next:
ldsw B, Index
inc BL
cp BL, BH
brcc PC+3
sts Index, BL
ret

idx_prev:
lds BL, Index
subi BL, 1
brcs PC+3
sts Index, BL
ret

get_item:
lds DL, Index
ldiw Z, List
subi DL, 1
brcc PC+2
ret
ld AL, Z+
cpi AL, 0
brne PC-2
rjmp PC-6


add_index:
ldiw Z, LineBuf
ldsw X, ListPtr
ldiw C, ListPtr+2000
cpw X, C
breq PC+10
ld AL, Z+
st X+, AL
cpi AL, 0
brne PC-6
lds AL, Index+1
inc AL
sts Index+1, AL
stsw ListPtr, X
ret


clr_index:
stsw Index, _0
ldiw A, List
stsw ListPtr, A
ret


chk_index:
ldd AL, Z+8 ;*.TXT
cpi AL, 'T' ;
brne ci_ret ;
ldd AL, Z+9 ;
cpi AL, 'X' ;
brne ci_ret ;
ldd AL, Z+10 ;
cpi AL, 'T' ;
brne ci_ret ;/
ldiw X, LineBuf
ldi CL, 0
ld AL, Z+
inc CL
cpi AL, ' '+1
brcs PC+2
st X+, AL
cpi CL, 8
brne PC+3
ldi AL, '.'
st X+, AL
cpi CL, 11
brne PC-10
st X+, _0
ci_ret: ret


mi_err:
clr T14L
ldiw Z, die_ioerr*2
rjmp die


id_noitem:
.db "<no item>",0
id_nofile:
.db "<no file>",0
id_invalid:
.db "<invalid>",0


;----------------------------------------------------------;
; Play a vector file

play:
ldiw Z, Buff1 ;Get file header
ldiw C, 512 ;
rcall file_read_block ;
rjne play_break ;/
ldiw A, 32 ;Check if the file is a valid frame data
cpw C, A ;
rjcs play_break ;
lddw A, Z+0 ;
cpi AL, 'V' ;
ldi AL, 'D' ;
cpc AH, AL ;
rjne play_break ;/
sts VectFifo+2, _0 ;Start vector interruput
lddw A, Z+4 ;
rcall pps_start ;/
play_l1:
ldiw A, 0 ;Seek to top of vector data
ldiw B, 0 ;
rcall file_seek ;
brne play_break ;/
lds AL, VectFifo+2 ;Wait for FIFO empty
cpi AL, 0 ;
brne PC-3 ;/
ldiw Z, Buff1 ;Load first data block (with 32 byte header)
ldiw C, 512 ;
rcall file_read_block ;
brne play_break ;/
lsrw C ;Initialize FIFO
lsrw C ;
subi CL, 32/4 ;
ldiw A, Buff1+32 ;
stsw VectFifo+0, A ;
sts VectFifo+2, CL ;/
play_l2:
rcall chk_rcvr ;Check if any data or key is received
brne play_break ;
rcall get_key_nw ;
brne play_exit ;/
lds AL, VectFifo+2 ;Wait for data size in FIFO < 128 pts
cpi AL, 512/4 ;
brcc play_l2 ;/
addi ZH, high(512) ;WritePtr++
cpi ZH, high(Buff1+512*2) ;
brcs PC+2 ;
subi ZH, high(512*2) ;/
ldiw C, 512 ;Load next data block
rcall file_read_block ;
brne play_break ;/
lsrw C ;Number of sample ++
lsrw C ;
cli ;
lds AL, VectFifo+2 ;
add AL, CL ;
sts VectFifo+2, AL ;
sei ;/
cpi CL, 512/4 ;End of block?
breq play_l2 ;/
rjmp play_l1 ;Is end of block

play_break:
rcall receive
clr AL
play_exit:
push AL
rcall pps_stop
pop AL
ret



;----------------------------------------------------------;
; Point output driver

pps_start:
cpi AL, 250 ;Clip A between 250-30000
cpc AH, _0 ;
brcs PC+2 ;
ldi AL, 250 ;
ldiw B, 30000 ;
cpw A, B ;
brcs PC+2 ;
movw AL, BL ;/
ldi BL, byte1(SYSCLK) ;CL:B = SYSCLK
ldi BH, byte2(SYSCLK) ;
ldi CL, byte3(SYSCLK) ;/
clrw T0 ;CL:B /= A
ldi CH, 24 ;
lslw B ;
rol CL ;
rolw T0 ;
cpw T0, A ;
brcs PC+4 ;
subw T0, A ;
inc BL ;
dec CH ;
brne PC-12 ;/
outw TCNT1, _0
outw OCR1A, B
outi TCCR1B, 0b00001001
cbi PORTE, OUTEN
ret


pps_stop:
out TCCR1B, _0 ;Stop PPS
ldiw A, 2048
ldiw B, 2048
rcall set_vector
ret


; Vector output interrupt

isr_tc1_coma:
push AL
in AL, SREG
pushw A
pushw B
pushw X

lds AL, VectFifo+2 ;Check if vector data is available
subi AL, 1 ;
brcc PC+3 ;
sbi PORTE, LDMOD ; Stop laser if under-flow occured
rjmp vo_ret ; /
sts VectFifo+2, AL ;/

ldsw X, VectFifo+0 ;X = Read ptr
ldw B, X+ ;Get vector
ldw A, X+ ;
rcall set_vector ;/
ldiw A, Buff1+512*2 ;Next read ptr
cpw X, A ;
brcs PC+2 ;
subi XH, high(512*2) ;/
stsw VectFifo+0, X ;Restore read ptr

vo_ret: popw X
popw B
popw A
out SREG, AL
pop AL
reti


;----------------------------------------------------------;
; Vector output functions
;
; Call: A = vector Y (0..4095)
; B = vector X (0..4095), BH.7 = Mod

set_vector:
andi AH, 0b00001111 ; Send Y value into buffer
ori AH, 0b00010000
cbi PORTB, DACS
rcall send_spi
mov AH, AL
rcall send_spi
sbi PORTB, DACS

mov AH, BH ; Send X value and latch both channels
andi AH, 0b00001111
ori AH, 0b10000000
cbi PORTB, DACS
rcall send_spi
mov AH, BL
rcall send_spi
sbi PORTB, DACS

sbrc BH, 7 ;Set modulation
cbi PORTE, LDMOD ;
sbrs BH, 7 ;
sbi PORTE, LDMOD ;/

ret

send_spi:
out SPDR, AH
ldi AH, 12/3
dec AH
brne PC-1
ret

;---------------------------------------------------------------;
; Space, CRLF

crlf:
ldi AL, 13
rcall xmit
ldi AL, 10
rjmp xmit

space:
ldi AL,' '


;---------------------------------------------------------------;
; UART control driver

xmit: ; Transmit AL
sbis UCSR0A, UDRE0
rjmp PC-1
out UDR0, AL
ret

chk_rcvr:
ldsw A, RxBuff
cp AL, AH
ret



receive:; Receive a char into AL. (ZR=no data)
ldiw Y, RxBuff
cli
ldd AH, Y+0
ldd AL, Y+1
cp AH, AL
breq PC+9
mov AL, AH
inc AL
andi AL, 31
std Y+0, AL
add YL, AH
adc YH, _0
ldd AL, Y+2
clz
sei
ret


isr_usart0_rx:
push AL
in AL, SREG
push BL
pushw A
pushw Y
in BL, UDR0
ldiw Y, RxBuff
ldd AL, Y+0
ldd AH, Y+1
inc AH
andi AH, 31
cp AH, AL
breq PC+7
std Y+1, AH
dec AH
andi AH, 31
add YL, AH
adc YH, _0
std Y+2, BL
popw Y
popw A
pop BL
out SREG, AL
pop AL
reti



;----------------------------------------------------------;
; Key driver


get_key:
lds AL, KeyCmd
andi AL, K_MASK
breq get_key
get_key_nw:
lds AL, KeyCmd
andi AL, K_MASK
breq PC+8
sts KeyCmd, _0
lds AH, KeyCmd+1
andi AH, K_MASK
swap AH
or AL, AH
ret


isr_tc0_com:
push T0L
in T0L, SREG
sei
pushw A

in AL, PINF
com AL
andi AL, K_MASK
lds AH, KeyCmd+2
sts KeyCmd+2, AL
cp AL, AH
brne isc_0e
lds AH, KeyCmd+1
sts KeyCmd+1, AL
eor AH, AL
and AH, AL
breq isc_0e
sts KeyCmd+0, AH

isc_0e:
popw A
out SREG, T0L
pop T0L
reti



;-------------------------------------------------------;
; Die with dieing message
;
;Call: Z = Pointer to the message
; T14L = Error code (0..9)

die:
rcall lcd_fprin_clr
mov AL, T14L
rcall lcd_prin_val
rjmp PC


die_mmcerr: .db "MMC Err ", 0
die_fserr: .db "FS Err ", 0
die_ioerr: .db "IO Err ", 0



;----------------------------------------------------------;
; LCD control
;
; Data:PD[3..0], RS:PD4, E:PD5
;

.equ LCDRS = PD4
.equ LCDEN = PD5


lcd_init:
rcall delay_5ms
rcall delay_5ms
rcall delay_5ms
cbi PORTD, LCDRS ; RS=0
ldi AL, 0b00110000
rcall lcd_wr_n
rcall delay_5ms
ldi AL, 0b00110000
rcall lcd_wr_n
rcall delay_5ms
ldi AL, 0b00110000
rcall lcd_wr_n
rcall delay_5ms
ldi AL, 0b00100000
rcall lcd_wr_n
ldi AL, 0b00101000 ;DL=0, N=1, F=0
rcall lcd_wr_cmd
ldi AL, 0b00001100 ;D=1, C=0, B=0
rcall lcd_wr_cmd
ldi AL, 0b00000110 ;I/D=1, S=0
rcall lcd_wr_cmd
rjmp lcd_clear



lcd_prin_val:
clr CH
inc CH
ldi CL, 8
clr AH
lslw A
cpi AH, 10
brcs PC+3
subi AH, 10
inc AL
dec CL
brne PC-7
addi AH, '0'
push AH
cpi AL, 0
brne PC-14
pop AL
rcall lcd_wr_chr
dec CH
brne PC-3
ret



lcd_mprin_clr:
rcall lcd_clear
lcd_mprin:
ld AL, Z+
tst AL
brne PC+2
ret
rcall lcd_wr_chr
rjmp lcd_mprin


lcd_fprin_clr:
rcall lcd_clear
lcd_fprin:
lpm AL, Z+ ;Get a char
tst AL ;Zero?
brne PC+2 ;/
ret
rcall lcd_wr_chr ;
rjmp lcd_fprin ;/


lcd_clear:
stsi Lcdp, 8
ldi AL, 0x01
rcall lcd_wr_cmd
rjmp delay_5ms


lcd_wr_chr:
sbi PORTD, LCDRS
rcall lcd_delay
rcall lcd_wr_n
rcall lcd_wr_n
lds AL, Lcdp
dec AL
sts Lcdp, AL
breq PC+2
ret
ldi AL, 0xC0
lcd_wr_cmd:
cbi PORTD, LCDRS
rcall lcd_delay
rcall lcd_wr_n
lcd_wr_n:
swap AL
push AL
andi AL, 0b00001111
in AH, PORTD
andi AH, 0b11110000
or AH, AL
out PORTD, AH
pop AL
sbi PORTD, LCDEN
rjmp PC+1
cbi PORTD, LCDEN
ret

lcd_delay:
ldi AH, 848/4 ;Delay 53us
dec AH ;
nop ;
brne PC-2 ;/
ret

delay_5ms: ;Delay 5ms
ldiw X, 80000/4
sbiw XL, 1
brne PC-1
ret