329 lines
8.4 KiB
C
329 lines
8.4 KiB
C
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
#include <vcc/cassette.h>
|
|
#include <cmoc.h>
|
|
|
|
typedef unsigned char Byte;
|
|
typedef struct TapeBlock {
|
|
Byte type, size, data[255];
|
|
} TapeBlock;
|
|
|
|
static TapeBlock block;
|
|
static Byte mode, position;
|
|
static int readStatus;
|
|
enum { CLOSED, READING, WRITING };
|
|
|
|
// The ROM's generic leader and block-write vectors take their parameters in
|
|
// BASIC's scratch bytes. Save these and the caller's register/mask state.
|
|
static asm void writeBlock(TapeBlock *p)
|
|
{
|
|
asm {
|
|
ldx 2,s
|
|
pshs cc,dp,y,u
|
|
orcc #$50
|
|
clra
|
|
tfr a,dp
|
|
ldd <$7c
|
|
pshs d
|
|
ldd <$7e
|
|
pshs d
|
|
ldd <$80
|
|
pshs d
|
|
lda <$85
|
|
ldb >$ff20 ; restore DAC and serial outputs after ROM writes
|
|
pshs d
|
|
ldd ,x++
|
|
std <$7c
|
|
stx <$7e
|
|
jsr [$a00c] ; gapped tape, leader at every block
|
|
jsr [$a008] ; ROM generates type, count, data, checksum
|
|
lda >$ff21
|
|
anda #$f7
|
|
sta >$ff21 ; stop motor between blocks
|
|
puls d
|
|
stb >$ff20
|
|
sta <$85
|
|
puls d
|
|
std <$80
|
|
puls d
|
|
std <$7e
|
|
puls d
|
|
std <$7c
|
|
puls cc,dp,y,u
|
|
}
|
|
}
|
|
|
|
// ROM BLKIN waits indefinitely for a transition on a damaged tape. Decode a
|
|
// complete block with bounded edge waits instead. High pulse widths are
|
|
// calibrated against the alternating leader in each gapped block. The fast
|
|
// CAS reader supplies pulse widths in BASIC's normal period scratch byte.
|
|
static asm Byte readBlock(TapeBlock *p, const Byte *wanted)
|
|
{
|
|
asm {
|
|
ldx 2,s
|
|
pshs cc,dp,y,u
|
|
orcc #$50
|
|
clra
|
|
tfr a,dp
|
|
tfr x,y
|
|
leas -12,s
|
|
tfr s,u
|
|
; U frame: saved ROM period, threshold, min, max, bit counter,
|
|
; edge timeout multiplier, sync search budget, block address, wanted name.
|
|
sty 8,u
|
|
ldd 22,u ; second argument above 12 locals, 6 saved registers and PC
|
|
std 10,u
|
|
lda <$83
|
|
sta ,u
|
|
clr <$83
|
|
lda >$ff21
|
|
ora #8
|
|
sta >$ff21
|
|
lbsr tapeRX_width ; discard the initial partial pulse
|
|
lda #255
|
|
sta 2,u
|
|
clr 3,u
|
|
ldb #24
|
|
tapeRX_learn lbsr tapeRX_width
|
|
cmpa 2,u
|
|
bhs tapeRX_max
|
|
sta 2,u
|
|
tapeRX_max cmpa 3,u
|
|
bls tapeRX_next
|
|
sta 3,u
|
|
tapeRX_next decb
|
|
bne tapeRX_learn
|
|
lda 3,u
|
|
suba 2,u
|
|
lsra
|
|
adda 2,u
|
|
sta 1,u
|
|
tapeRX_scan ldy 8,u
|
|
ldd #$ffff
|
|
std 6,u
|
|
clrb
|
|
tapeRX_sync lbsr tapeRX_bit
|
|
rorb ; bits arrive least significant first
|
|
cmpb #$3c
|
|
beq tapeRX_packet
|
|
ldx 6,u
|
|
leax -1,x
|
|
stx 6,u
|
|
bne tapeRX_sync
|
|
lbra tapeRX_error
|
|
tapeRX_packet lbsr tapeRX_byte
|
|
stb ,y+
|
|
lbsr tapeRX_byte
|
|
stb ,y+
|
|
stb 2,u ; remaining payload bytes
|
|
addb -2,y
|
|
stb 3,u ; additive checksum including type and count
|
|
tst 2,u
|
|
beq tapeRX_check
|
|
tapeRX_data lbsr tapeRX_byte
|
|
stb ,y+
|
|
addb 3,u
|
|
stb 3,u
|
|
dec 2,u
|
|
bne tapeRX_data
|
|
tapeRX_check lbsr tapeRX_byte
|
|
cmpb 3,u
|
|
bne tapeRX_error
|
|
; During named lookup keep the motor on through unrelated files.
|
|
; Nongapped program blocks can have only a single short sync leader.
|
|
ldx 10,u
|
|
beq tapeRX_ok
|
|
ldy 8,u
|
|
tst ,y+
|
|
bne tapeRX_scan
|
|
lda ,y+
|
|
cmpa #15
|
|
bne tapeRX_error
|
|
ldb #8
|
|
tapeRX_name lda ,y+
|
|
cmpa ,x+
|
|
bne tapeRX_scan
|
|
decb
|
|
bne tapeRX_name
|
|
tapeRX_ok clrb
|
|
bra tapeRX_finish
|
|
tapeRX_error ldb #1
|
|
tapeRX_finish tfr u,s ; also unwinds any nested edge/byte calls
|
|
lda ,u
|
|
sta <$83
|
|
lda >$ff21
|
|
anda #$f7
|
|
sta >$ff21
|
|
leas 12,s
|
|
puls cc,dp,y,u,pc
|
|
|
|
tapeRX_byte lda #8
|
|
sta 4,u
|
|
tapeRX_bits bsr tapeRX_bit
|
|
rorb
|
|
dec 4,u
|
|
bne tapeRX_bits
|
|
rts
|
|
tapeRX_bit bsr tapeRX_width
|
|
cmpa 1,u ; short high phase represents a one
|
|
rts
|
|
|
|
tapeRX_width lda #3 ; allow the initial motor silence
|
|
sta 5,u
|
|
ldx #0
|
|
tapeRX_rise lda >$ff20
|
|
lsra
|
|
bcs tapeRX_high
|
|
leax -1,x
|
|
bne tapeRX_rise
|
|
dec 5,u
|
|
bne tapeRX_rise
|
|
lbra tapeRX_error
|
|
tapeRX_high ldx #0
|
|
lda #3
|
|
sta 5,u
|
|
tapeRX_fall leax 1,x
|
|
bne tapeRX_sample
|
|
dec 5,u
|
|
lbeq tapeRX_error
|
|
tapeRX_sample lda >$ff20
|
|
lsra
|
|
bcs tapeRX_fall
|
|
lda <$83
|
|
bne tapeRX_measured ; accelerated reader supplied the period
|
|
cmpx #255
|
|
blo tapeRX_short
|
|
lda #255
|
|
rts
|
|
tapeRX_short pshs x
|
|
lda 1,s
|
|
leas 2,s
|
|
tapeRX_measured rts
|
|
}
|
|
}
|
|
|
|
static int fileName(const char *name, Byte *dest)
|
|
{
|
|
// Avoid interfering with a BASIC file or an already active motor.
|
|
if (mode || *(Byte *)0x78 || (*(Byte *)0xff21 & 8)) return VCC_TAPE_BUSY;
|
|
if (!name || !*name) return VCC_TAPE_INVALID;
|
|
memset(dest, ' ', 8);
|
|
for (Byte i = 0; *name; ++i) {
|
|
Byte ch = *name++;
|
|
if (i == 8 || ch < 32 || ch > 126) return VCC_TAPE_INVALID;
|
|
dest[i] = ch;
|
|
}
|
|
return VCC_TAPE_OK;
|
|
}
|
|
|
|
int vcc_tape_open_write(const char *name)
|
|
{
|
|
int status = fileName(name, block.data);
|
|
if (status) return status;
|
|
block.type = 0;
|
|
block.size = 15;
|
|
block.data[8] = 1; // BASIC data file
|
|
block.data[9] = block.data[10] = 255; // ASCII, gapped
|
|
memset(block.data + 11, 0, 4);
|
|
writeBlock(&block);
|
|
mode = WRITING;
|
|
block.type = 1;
|
|
block.size = 0;
|
|
return VCC_TAPE_OK;
|
|
}
|
|
|
|
static void putByte(Byte ch)
|
|
{
|
|
block.data[block.size++] = ch;
|
|
if (block.size == 255) {
|
|
writeBlock(&block);
|
|
block.size = 0;
|
|
}
|
|
}
|
|
|
|
int vcc_tape_write_line(const char *line)
|
|
{
|
|
if (mode != WRITING || !line) return VCC_TAPE_INVALID;
|
|
for (const char *s = line; *s; ++s)
|
|
if ((Byte)*s < 32 || (Byte)*s > 126) return VCC_TAPE_INVALID;
|
|
while (*line) putByte(*line++);
|
|
putByte(13);
|
|
return VCC_TAPE_OK;
|
|
}
|
|
|
|
int vcc_tape_open_read(const char *name)
|
|
{
|
|
Byte wanted[8];
|
|
int status = fileName(name, wanted);
|
|
if (status) return status;
|
|
if (readBlock(&block, wanted)) return VCC_TAPE_IO;
|
|
if (block.data[8] != 1 || !block.data[9] || !block.data[10]) return VCC_TAPE_TYPE;
|
|
mode = READING;
|
|
block.size = position = 0;
|
|
readStatus = VCC_TAPE_OK;
|
|
return VCC_TAPE_OK;
|
|
}
|
|
|
|
int vcc_tape_read_line(char *line, unsigned capacity)
|
|
{
|
|
unsigned used = 0;
|
|
Byte haveText = 0, overflow = 0;
|
|
if (!line || !capacity) return VCC_TAPE_INVALID;
|
|
line[0] = 0;
|
|
if (mode != READING) return VCC_TAPE_INVALID;
|
|
if (readStatus) return readStatus;
|
|
for (;;) {
|
|
while (position == block.size) {
|
|
if (readBlock(&block, 0)) {
|
|
readStatus = VCC_TAPE_IO;
|
|
} else if (block.type == 255 && !block.size) {
|
|
readStatus = VCC_TAPE_EOF;
|
|
// BASIC can suppress its last CR with PRINT #-1,"TEXT";.
|
|
if (haveText) {
|
|
if (overflow) {
|
|
line[0] = 0;
|
|
return VCC_TAPE_LONG;
|
|
}
|
|
line[used] = 0;
|
|
return VCC_TAPE_OK;
|
|
}
|
|
} else if (block.type != 1) {
|
|
readStatus = VCC_TAPE_IO;
|
|
}
|
|
if (readStatus) {
|
|
line[0] = 0;
|
|
return readStatus;
|
|
}
|
|
position = 0;
|
|
}
|
|
Byte ch = block.data[position++];
|
|
if (ch == 13) {
|
|
if (overflow) {
|
|
line[0] = 0;
|
|
return VCC_TAPE_LONG;
|
|
}
|
|
line[used] = 0;
|
|
return VCC_TAPE_OK;
|
|
}
|
|
if (ch < 32 || ch > 126) {
|
|
line[0] = 0;
|
|
return readStatus = VCC_TAPE_IO;
|
|
}
|
|
haveText = 1;
|
|
if (used < capacity - 1) line[used++] = ch;
|
|
else overflow = 1;
|
|
}
|
|
}
|
|
|
|
int vcc_tape_close(void)
|
|
{
|
|
if (!mode) return VCC_TAPE_INVALID;
|
|
if (mode == WRITING) {
|
|
if (block.size) writeBlock(&block);
|
|
block.type = 255;
|
|
block.size = 0;
|
|
writeBlock(&block);
|
|
}
|
|
mode = CLOSED;
|
|
return VCC_TAPE_OK;
|
|
}
|