|
version 1.2, 2004/08/05 04:53:15
|
version 1.24, 2009/03/23 15:02:25
|
|
Line 1
|
Line 1
|
| #include "compiler.h" |
#include "compiler.h" |
| #include "dosio.h" |
|
| #include "z80core.h" |
#include "z80core.h" |
| #include "pccore.h" |
#include "pccore.h" |
| #include "iocore.h" |
#include "iocore.h" |
| |
#include "nevent.h" |
| #include "fddfile.h" |
#include "fddfile.h" |
| #include "fdd_2d.h" |
|
| #include "fdd_d88.h" |
|
| #include "fdd_mtr.h" |
#include "fdd_mtr.h" |
| |
|
| |
enum { |
| |
FDCCTYPE_CMD1 = 0x01, |
| |
FDCCTYPE_CMD2 = 0x02, |
| |
FDCCTYPE_CMD3 = 0x04, |
| |
FDCCTYPE_CMD4 = 0x08, |
| |
|
| |
FDCCTYPE_RO = 0x10, |
| |
FDCCTYPE_DATA = 0x80 |
| |
}; |
| |
|
| |
|
| |
static const UINT8 fdctype[] = { |
| |
FDCCTYPE_CMD1, |
| |
FDCCTYPE_CMD1, |
| |
FDCCTYPE_CMD1, |
| |
FDCCTYPE_CMD1, |
| |
FDCCTYPE_CMD1, |
| |
FDCCTYPE_CMD1, |
| |
FDCCTYPE_CMD1, |
| |
FDCCTYPE_CMD1, |
| |
FDCCTYPE_CMD2 + FDCCTYPE_RO, |
| |
FDCCTYPE_CMD2 + FDCCTYPE_RO, |
| |
FDCCTYPE_CMD2, |
| |
FDCCTYPE_CMD2, |
| |
FDCCTYPE_CMD3 + FDCCTYPE_RO, |
| |
FDCCTYPE_CMD4, |
| |
FDCCTYPE_CMD3 + FDCCTYPE_RO, |
| |
FDCCTYPE_CMD3}; |
| |
|
| |
|
| |
/* write track */ |
| |
|
| |
#if !defined(CONST_DISKIMAGE) |
| |
enum { |
| |
TAO_MODE_GAP = 0x4e, |
| |
TAO_MODE_SYNC = 0x00, |
| |
TAO_MODE_AM = 0xf5, |
| |
TAO_MODE_IM = 0xf6, |
| |
TAO_MODE_ID = 0xfe, |
| |
TAO_MODE_DATA = 0xfb, |
| |
TAO_ENDOFDATA = 0xf7, |
| |
|
| |
TAO_CMD_GAP = 0x4e, |
| |
TAO_CMD_SYNC = 0x00, |
| |
TAO_CMD_IM_IN = 0xf6, |
| |
TAO_CMD_IM = 0xfc, |
| |
TAO_CMD_AM_IN = 0xf5, |
| |
TAO_CMD_IAM = 0xfe, |
| |
TAO_CMD_DAM = 0xfb, |
| |
TAO_CMD_DDAM = 0xf8, |
| |
TAO_CMD_CRC = 0xf7 |
| |
}; |
| |
|
| BYTE FDC_c[4]; |
|
| BYTE driveset = 0; |
|
| BYTE fdcdummyread = 0; |
|
| WORD readdiag = 0; |
|
| |
|
| static const UINT8 fdctype[] = {1,1,1,1,1,1,1,1,2,2,2,2,3,4,3,3}; |
static REG8 wrtrkstart(FDC *f) { |
| |
|
| |
FDDFILE fdd; |
| |
|
| static BYTE fdd_stat(void) { |
fdd = fddfile + f->s.drv; |
| |
if ((fdd->type == DISKTYPE_NOTREADY) || (fdd->protect)) { |
| |
return(0); |
| |
} |
| |
f->s.bufdir = FDCDIR_TAO; |
| |
f->s.bufpos = 0; |
| |
f->s.bufmedia = f->s.media; |
| |
f->s.bufunit = f->s.drv; |
| |
f->s.buftrack = (f->s.c << 1) + f->s.h; |
| |
|
| |
f->s.wt_mode = TAO_ENDOFDATA; |
| |
f->s.wt_sectors = 0; |
| |
f->s.wt_ptr = 0; |
| |
f->s.wt_datpos = 0; |
| |
f->s.wt_datsize = 0; |
| |
ZeroMemory(f->s.buffer, sizeof(f->s.buffer)); |
| |
|
| FDDFILE fdd; |
return(0); |
| |
} |
| |
|
| |
static void wrtrkdata(FDC *f, REG8 data) { |
| |
|
| |
TAOSEC *t; |
| |
REG8 n; |
| |
UINT datsize; |
| |
FDDFILE fdd; |
| |
|
| |
switch(f->s.wt_mode) { |
| |
case TAO_ENDOFDATA: |
| |
if (data == TAO_MODE_GAP) { |
| |
f->s.wt_mode = TAO_MODE_GAP; |
| |
f->s.wt_ptr = 0; |
| |
} |
| |
break; |
| |
|
| fdd = fddfile + fdc.drv; |
case TAO_MODE_GAP: |
| switch(fdd->type) { |
if (data == TAO_MODE_GAP) { |
| case DISKTYPE_NOTREADY: |
f->s.wt_ptr++; |
| return(0); |
if (f->s.wt_ptr >= 256) { |
| |
goto wtd_done; |
| |
} |
| |
} |
| |
else if (data == TAO_CMD_SYNC) { |
| |
f->s.wt_mode = TAO_MODE_SYNC; |
| |
} |
| |
else if (data == 0xf4) { |
| |
goto wtd_done; |
| |
} |
| |
else { |
| |
goto wtd_err; |
| |
} |
| |
break; |
| |
|
| case DISKTYPE_BETA: |
case TAO_MODE_SYNC: |
| return(fdd_stat_2d()); |
if (data == TAO_CMD_AM_IN) { |
| |
f->s.wt_mode = TAO_MODE_AM; |
| |
} |
| |
else if (data == TAO_CMD_IM_IN) { |
| |
f->s.wt_mode = TAO_MODE_IM; |
| |
} |
| |
else if (data) { |
| |
goto wtd_err; |
| |
} |
| |
break; |
| |
|
| |
case TAO_MODE_IM: |
| |
if (data == TAO_CMD_IM) { |
| |
f->s.wt_mode = TAO_ENDOFDATA; |
| |
} |
| |
else if (data != TAO_CMD_IM_IN) { |
| |
goto wtd_err; |
| |
} |
| |
break; |
| |
|
| |
case TAO_MODE_AM: |
| |
if (data == TAO_CMD_IAM) { |
| |
f->s.wt_mode = TAO_MODE_ID; |
| |
f->s.wt_ptr = 0; |
| |
} |
| |
else if ((data == TAO_CMD_DAM) || (data == TAO_CMD_DDAM)) { |
| |
f->s.wt_mode = TAO_MODE_DATA; |
| |
f->s.wt_ptr = 0; |
| |
if (f->s.wt_datsize) { |
| |
t = (TAOSEC *)(f->s.buffer + f->s.wt_datpos); |
| |
t[-1].flag = (UINT8)(data == TAO_CMD_DDAM); |
| |
} |
| |
} |
| |
break; |
| |
|
| |
case TAO_MODE_ID: |
| |
if ((f->s.wt_ptr == 0) && (data == TAO_CMD_IAM)) { |
| |
break; |
| |
} |
| |
else if (f->s.wt_ptr < 4) { |
| |
f->s.buffer[f->s.bufpos + f->s.wt_ptr] = data; |
| |
f->s.wt_ptr++; |
| |
} |
| |
else if (data == TAO_CMD_CRC) { |
| |
f->s.wt_mode = TAO_ENDOFDATA; |
| |
n = f->s.buffer[f->s.bufpos + 3]; |
| |
if (n > 3) { |
| |
n = 3; |
| |
} |
| |
datsize = 128 << n; |
| |
if ((f->s.bufpos + (sizeof(TAOSEC) * 2) + datsize) |
| |
<= sizeof(f->s.buffer)) { |
| |
t = (TAOSEC *)(f->s.buffer + f->s.bufpos); |
| |
STOREINTELWORD(t->size, datsize); |
| |
f->s.wt_datpos = f->s.bufpos + sizeof(TAOSEC); |
| |
f->s.wt_datsize = datsize; |
| |
f->s.bufpos = f->s.wt_datpos + datsize; |
| |
f->s.wt_sectors += 1; |
| |
} |
| |
else { |
| |
goto wtd_err; |
| |
} |
| |
} |
| |
break; |
| |
|
| case DISKTYPE_D88: |
case TAO_MODE_DATA: /* DATA WRITE */ |
| default: |
if ((f->s.wt_ptr == 0) && |
| return(fdd_stat_d88()); |
((data == TAO_CMD_DAM) || (data == TAO_CMD_DDAM))) { |
| |
break; |
| |
} |
| |
else if (f->s.wt_ptr < f->s.wt_datsize) { |
| |
f->s.buffer[f->s.wt_datpos + f->s.wt_ptr] = data; |
| |
f->s.wt_ptr++; |
| |
} |
| |
else if (data == TAO_CMD_CRC) { |
| |
f->s.wt_mode = TAO_ENDOFDATA; |
| |
f->s.wt_datsize = 0; |
| |
} |
| |
break; |
| } |
} |
| return(0); |
return; |
| |
|
| |
wtd_done: |
| |
fdd = fddfile + f->s.bufunit; |
| |
TRACEOUT(("write! %d %dbytes", f->s.wt_sectors, f->s.bufpos)); |
| |
f->s.stat = (*fdd->wrtrk)(fdd, f->s.bufmedia, f->s.buftrack, |
| |
f->s.wt_sectors, f->s.buffer, f->s.bufpos); |
| |
f->s.bufdir = FDCDIR_NONE; |
| |
dmac_sendready(FALSE); |
| |
return; |
| |
|
| |
wtd_err: |
| |
f->s.stat = FDDSTAT_LOSTDATA; |
| |
f->s.bufdir = FDCDIR_NONE; |
| |
dmac_sendready(FALSE); |
| } |
} |
| |
#endif |
| |
|
| |
|
| /*********************************************************************** |
/* ---- */ |
| ＦＤＣ （Ｘ１から見るＩ／Ｏに相当する関数） |
|
| ***********************************************************************/ |
|
| |
|
| static int inc_off(void) { |
void neitem_fdcbusy(UINT id) { |
| |
|
| BYTE ret; |
fdc.s.busy = 0; |
| FDDFILE fdd; |
if (fdc.s.bufdir) { |
| |
/* TRACEOUT(("dma ready!")); */ |
| |
dmac_sendready(TRUE); |
| |
} |
| |
(void)id; |
| |
} |
| |
|
| if (!fdc.motor) { |
static void setbusy(FDC *f, SINT32 clock) { |
| return(0); |
|
| |
if (clock > 0) { |
| |
f->s.busy = FDDSTAT_BUSY; |
| |
nevent_set(NEVENT_FDC, clock, neitem_fdcbusy, NEVENT_ABSOLUTE); |
| } |
} |
| if (fdcdummyread) { |
else { |
| fdcdummyread--; |
f->s.busy = 0; |
| return(0); |
nevent_reset(NEVENT_FDC); |
| |
} |
| |
} |
| |
|
| |
#if defined(SUPPORT_MOTORRISEUP) |
| |
static void setmotor(FDC *f, REG8 drvcmd) { |
| |
|
| |
UINT drv; |
| |
SINT32 clock; |
| |
|
| |
drv = drvcmd & 3; |
| |
clock = CPU_CLOCK + CPU_BASECLOCK - CPU_REMCLOCK; |
| |
if (drvcmd & 0x80) { |
| |
if (f->s.motorevent[drv] == FDCMOTOR_STOP) { |
| |
f->s.motorevent[drv] = FDCMOTOR_STARTING; |
| |
f->s.motorclock[drv] = clock; |
| |
} |
| |
else if (f->s.motorevent[drv] == FDCMOTOR_STOPING) { |
| |
f->s.motorevent[drv] = FDCMOTOR_READY; |
| |
} |
| } |
} |
| else { |
else { |
| fdd = fddfile + fdc.drv; |
if ((f->s.motorevent[drv] == FDCMOTOR_STARTING) || |
| switch(fdd->type) { |
(f->s.motorevent[drv] == FDCMOTOR_READY)) { |
| case DISKTYPE_NOTREADY: |
f->s.motorevent[drv] = FDCMOTOR_STOPING; |
| return(0); |
f->s.motorclock[drv] = clock; |
| |
} |
| |
} |
| |
} |
| |
|
| case DISKTYPE_BETA: |
void fdc_callback(void) { |
| ret = fdd_incoff_2d(); |
|
| break; |
|
| |
|
| case DISKTYPE_D88: |
SINT32 clock; |
| default: |
UINT i; |
| ret = fdd_incoff_d88(); |
|
| break; |
clock = CPU_CLOCK + CPU_BASECLOCK - CPU_REMCLOCK; |
| |
for (i=0; i<4; i++) { |
| |
if (fdc.s.motorevent[i] == FDCMOTOR_STARTING) { |
| |
if ((clock - fdc.s.motorclock[i]) >= (SINT32)pccore.realclock) { |
| |
fdc.s.motorevent[i] = FDCMOTOR_READY; |
| |
} |
| } |
} |
| if (ret) { |
else if (fdc.s.motorevent[i] == FDCMOTOR_STOPING) { |
| dma.DMA_REDY = 8; // <- DMA ノ レディシンゴウ ヲ クリア |
if ((clock - fdc.s.motorclock[i]) >= (SINT32)pccore.realclock) { |
| |
fdc.s.motorevent[i] = FDCMOTOR_STOP; |
| |
} |
| } |
} |
| } |
} |
| return(ret); |
|
| } |
} |
| |
|
| void IOOUTCALL fdc_o(UINT port, REG8 value) { |
static SINT32 motorwait(const FDC *f) { |
| |
|
| REG8 cmd; |
SINT32 curclock; |
| |
SINT32 nextclock; |
| |
|
| if ((port & (~7)) != 0x0ff8) { |
if (f->s.motorevent[f->s.drv] == FDCMOTOR_STARTING) { |
| return; |
curclock = CPU_CLOCK + CPU_BASECLOCK - CPU_REMCLOCK; |
| |
curclock -= f->s.motorclock[f->s.drv]; |
| |
if (curclock < (SINT32)pccore.realclock) { |
| |
nextclock = pccore.realclock - curclock; |
| |
/* TRACEOUT(("motor starting busy %d", nextclock)); */ |
| |
return(nextclock); |
| |
} |
| } |
} |
| port &= 0xf; |
return(0); |
| if (port == 8) { // コマンド |
} |
| driveset = 0; |
|
| fdc.cmd = value; |
|
| cmd = (REG8)(value >> 4); |
|
| fdc.type = fdctype[cmd]; |
|
| fdc.skip = 2; |
|
| switch(cmd) { |
|
| case 0x00: // リストア |
|
| if (value & 8) { // LAYDOCK |
|
| fdc.skip = 0; |
|
| fdc.busyclock = 20; // ver0.25 (now testing) |
|
| fdc.busystart = h_cntbase + h_cnt; |
|
| } |
|
| fdc.motor = 0x80; // モーターOn? |
|
| fdc.c = 0; |
|
| fdc.treg = 0; |
|
| FDDMTR_MOVE; |
|
| fdc.step = 1; |
|
| #if 1 // ver0.25 |
|
| fdc.r = 0; // デゼニワールド |
|
| fdc.rreg = 0; |
|
| #endif |
#endif |
| break; |
|
| |
|
| case 0x01: // シーク |
|
| fdc.motor = 0x80; // モーターOn |
|
| fdc.step = (char)((fdc.c<=fdc.data)?1:-1); |
|
| #if 0 // スタクル // ver0.50 |
|
| fdc.rreg = fdc.r = 0; |
|
| #endif |
|
| fdc.c = fdc.data; |
|
| fdc.treg = fdc.data; |
|
| FDDMTR_MOVE; |
|
| break; |
|
| |
|
| case 0x02: // ステップ |
static REG8 getstat(FDC *f) { |
| case 0x03: |
|
| if (fdc.motor) { |
|
| fdc.c += fdc.step; |
|
| if (cmd & 1) { |
|
| FDDMTR_MOVE; |
|
| fdc.treg = fdc.c; |
|
| } |
|
| } |
|
| break; |
|
| |
|
| case 0x04: // ステップイン |
FDDFILE fdd; |
| case 0x05: |
REG8 ctype; |
| if (fdc.motor) { |
REG8 ret; |
| fdc.step = 1; |
|
| fdc.c++; |
fdd = fddfile + f->s.drv; |
| if (cmd & 1) { |
ctype = f->s.ctype; |
| FDDMTR_MOVE; |
if (fdd->type == DISKTYPE_NOTREADY) { |
| fdc.treg = fdc.c; |
ret = FDDSTAT_NOTREADY; |
| } |
} |
| } |
else { |
| break; |
ret = f->s.stat; |
| |
} |
| |
if ((ctype & FDCCTYPE_CMD1) && (f->s.c == 0)) { |
| |
ret |= FDDSTAT_TRACK00; |
| |
} |
| |
if (!(ctype & FDCCTYPE_RO)) { |
| |
if (fdd->protect) { |
| |
ret |= FDDSTAT_WRITEP; |
| |
} |
| |
} |
| |
if (ctype & (FDCCTYPE_CMD1 | FDCCTYPE_CMD4)) { |
| |
f->s.hole++; |
| |
if (f->s.hole < 8) { |
| |
ret |= FDDSTAT_INDEX; |
| |
} |
| |
} |
| |
else if (!(ret & 0xf0)) { |
| |
if (fddmtr_isbusy()) { |
| |
ret |= FDDSTAT_BUSY; |
| |
} |
| |
if (f->s.bufdir) { |
| |
ret |= FDDSTAT_DRQ | FDDSTAT_BUSY; |
| |
} |
| |
} |
| |
return(ret); |
| |
} |
| |
|
| case 0x06: // ステップアウト |
static void seekcmd(FDC *f) { |
| case 0x07: |
|
| if (fdc.motor) { |
|
| fdc.step = -1; |
|
| fdc.c--; |
|
| if (cmd & 1) { |
|
| FDDMTR_MOVE; |
|
| fdc.treg = fdc.c; |
|
| } |
|
| } |
|
| break; |
|
| |
|
| case 0x08: // リードデータ |
FDDFILE fdd; |
| case 0x09: |
UINT track; |
| case 0x0a: // ライトデータ |
|
| case 0x0b: |
|
| fdc.off = 0; |
|
| fdcdummyread = 2; |
|
| if (fdc.motor) { |
|
| if (dma.DMA_ENBL) { |
|
| dma.DMA_REDY = 0; |
|
| // fdc.skip = 0; // DMAで割り込みを監視する事！ |
|
| } |
|
| } |
|
| break; |
|
| |
|
| case 0xc: // リードアドレス |
f->s.crcnum = 0; |
| fdc.crc_off = 0; |
f->s.creg = f->s.c; |
| fdcdummyread = 2; |
fdd = fddfile + f->s.drv; |
| if (fdc.motor) { // ver0.25 |
track = (f->s.c << 1) + f->s.h; |
| if (dma.DMA_ENBL) { |
f->s.stat = fdd->seek(fdd, f->s.media, track) | FDDSTAT_HEADENG; |
| dma.DMA_REDY = 0; |
fddmtr_motormove(); |
| } |
} |
| } |
|
| { |
|
| FDDFILE fdd = fddfile + fdc.drv; |
|
| switch(fdd->type) { |
|
| case DISKTYPE_NOTREADY: |
|
| break; |
|
| |
|
| case DISKTYPE_BETA: |
|
| fdd_crc_2d(); |
|
| break; |
|
| |
|
| case DISKTYPE_D88: |
|
| default: |
|
| fdd_crc_d88(); |
|
| break; |
|
| } |
|
| } |
|
| break; |
|
| |
|
| case 0x0d: // フォースインタラプト |
static REG8 type2cmd(FDC *f, REG8 sc) { |
| fdcdummyread = 0; // 必要ない？ |
|
| fdc.skip = 0; // 000330 |
|
| dma.DMA_REDY = 8; // ver0.25 |
|
| break; |
|
| |
|
| case 0x0e: // リードトラック |
REG8 dir; |
| readdiag = 0; |
UINT track; |
| break; |
UINT8 *p; |
| |
FDDFILE fdd; |
| |
UINT size; |
| |
REG8 stat; |
| |
SINT32 clock; |
| |
#if defined(SUPPORT_DISKEXT) |
| |
SINT32 curclock; |
| |
SINT32 nextclock; |
| |
UINT32 secinfo; |
| |
#endif |
| |
|
| case 0x0f: // ライトトラック |
track = (f->s.c << 1) + f->s.h; |
| { |
fdd = fddfile + f->s.drv; |
| FDDFILE fdd = fddfile + fdc.drv; |
#if !defined(CONST_DISKIMAGE) |
| switch(fdd->type) { |
if (!(f->s.cmd & 0x20)) { |
| case DISKTYPE_NOTREADY: |
p = f->s.buffer; |
| case DISKTYPE_BETA: |
dir = FDCDIR_IN; |
| break; |
} |
| |
else { |
| case DISKTYPE_D88: |
p = NULL; |
| default: |
dir = FDCDIR_OUT; |
| if (fdc.motor) { // ver0.25 |
} |
| init_tao_d88(); |
size = sizeof(f->s.buffer); |
| if (dma.DMA_ENBL) { |
stat = fdd->read(fdd, f->s.media, track, sc, p, &size); |
| dma.DMA_REDY = 0; |
if (stat & FDDSTAT_RECNFND) { |
| } |
size = 0; |
| } |
dir = FDCDIR_NONE; |
| break; |
} |
| } |
else if (dir == FDCDIR_OUT) { |
| } |
if (size) { |
| break; |
ZeroMemory(f->s.buffer, size); |
| |
} |
| |
stat = stat & (~FDDSTAT_RECTYPE); |
| |
} |
| |
#else |
| |
size = 0; |
| |
dir = FDCDIR_NONE; |
| |
if (!(f->s.cmd & 0x20)) { |
| |
stat = fdd->readp(fdd, f->s.media, track, sc, (void **)&p, &size); |
| |
if (!(stat & FDDSTAT_RECNFND)) { |
| |
f->e.buffer = p; |
| |
dir = FDCDIR_IN; |
| } |
} |
| } |
} |
| else { |
else { |
| cmd = (REG8)(fdc.cmd >> 4); |
stat = FDDSTAT_RECNFND | FDDSTAT_WRITEFAULT; |
| switch(port) { |
} |
| case 0x09: // トラック |
#endif |
| fdc.treg = value; |
f->s.bufmedia = f->s.media; |
| break; |
f->s.bufunit = f->s.drv; |
| |
f->s.buftrack = track; |
| |
f->s.bufsc = sc; |
| |
f->s.bufwrite = FALSE; |
| |
f->s.bufdir = dir; |
| |
f->s.bufmark = f->s.cmd & 1; |
| |
f->s.bufpos = 0; |
| |
f->s.bufsize = size; |
| |
f->s.curtime = 0; |
| |
|
| |
clock = 0; |
| |
#if defined(SUPPORT_MOTORRISEUP) |
| |
clock += motorwait(f); |
| |
#endif |
| |
#if defined(SUPPORT_DISKEXT) |
| |
secinfo = fdd->sec(fdd, f->s.media, track, sc); |
| |
if (secinfo) { |
| |
nextclock = LOW16(secinfo); |
| |
nextclock *= f->s.loopclock; |
| |
nextclock /= LOW16(secinfo >> 16); |
| |
curclock = nevent_getwork(NEVENT_RTC); |
| |
nextclock -= curclock; |
| |
if (nextclock < 0) { |
| |
nextclock += f->s.loopclock; |
| |
} |
| |
/* TRACEOUT(("wait clock -> %d [%d/%d]", nextclock, |
| |
LOW16(secinfo), LOW16(secinfo >> 16))); */ |
| |
clock += nextclock; |
| |
} |
| |
#endif |
| |
setbusy(f, max(clock, 500)); |
| |
return(stat); |
| |
} |
| |
|
| case 0x0a: // セクタ |
static REG8 type2flash(FDC *f) { |
| FDDMTR_WAITSEC(value); |
|
| fdc.r = value; |
|
| fdc.rreg = value; |
|
| break; |
|
| |
|
| case 0x0b: // データ |
#if !defined(CONST_DISKIMAGE) |
| fdc.data = value; |
FDDFILE fdd; |
| if ((cmd == 0x0a) || (cmd == 0x0b)) { |
|
| FDDFILE fdd = fddfile + fdc.drv; |
|
| switch(fdd->type) { |
|
| case DISKTYPE_NOTREADY: |
|
| break; |
|
| |
|
| case DISKTYPE_BETA: |
|
| fdd_write_2d(); |
|
| break; |
|
| |
|
| case DISKTYPE_D88: |
|
| default: |
|
| fdd_write_d88(); |
|
| break; |
|
| } |
|
| inc_off(); |
|
| } |
|
| else if (cmd == 0x0f) { // TRACK WRITE |
|
| FDDFILE fdd = fddfile + fdc.drv; |
|
| switch(fdd->type) { |
|
| case DISKTYPE_NOTREADY: |
|
| case DISKTYPE_BETA: |
|
| break; |
|
| |
|
| case DISKTYPE_D88: |
|
| default: |
|
| fdd_wtao_d88(value); |
|
| break; |
|
| } |
|
| } |
|
| break; |
|
| |
|
| case 0x0c: // ドライブ・サイド |
f->s.bufwrite = FALSE; |
| driveset = 1; |
fdd = fddfile + f->s.bufunit; |
| FDC_c[fdc.drv] = fdc.c; |
if (fdd->protect) { |
| fdc.c = FDC_c[value & 0x03]; // XTAL !!! |
return(FDDSTAT_WRITEFAULT); |
| fdc.motor = (UINT8)(value & 0x80); |
} |
| fdc.drv = (UINT8)(value & 0x03); |
return(fdd->write(fdd, f->s.bufmedia, f->s.buftrack, |
| fdc.h = (UINT8)((value >> 4) & 1); |
f->s.bufsc, f->s.buffer, f->s.bufpos)); |
| |
#else |
| fdc.cmd = 0; // T&E SORCERIAN |
(void)f; |
| // fdc.data = 0; // 影の伝説 |
return(FDDSTAT_RECNFND | FDDSTAT_WRITEFAULT); |
| fdc.type = 0; |
|
| |
|
| FDDMTR_DRVSET; |
|
| if (!fdc.motor) { |
|
| fdc.r = 0; // SACOM TELENET |
|
| fdc.rreg = 0; |
|
| #if 0 // XTAL |
|
| fdc.c = 0; |
|
| fdc.step = 1; |
|
| #endif |
#endif |
| } |
} |
| break; |
|
| |
static REG8 crccmd(FDC *f) { |
| |
|
| |
UINT8 *crcbuf; |
| |
UINT track; |
| |
FDDFILE fdd; |
| |
REG8 stat; |
| |
|
| |
#if !defined(CONST_DISKIMAGE) |
| |
crcbuf = f->s.buffer; |
| |
#else |
| |
crcbuf = f->s.crcbuf; |
| |
f->e.buffer = crcbuf; |
| |
#endif |
| |
|
| |
track = (f->s.c << 1) + f->s.h; |
| |
fdd = fddfile + f->s.drv; |
| |
/* TRACEOUT(("fdd->crc %d %d %d", f->s.drv, track, f->s.crcnum)); */ |
| |
stat = fdd->crc(fdd, f->s.media, track, f->s.crcnum, crcbuf); |
| |
if (stat & FDDSTAT_RECNFND) { |
| |
f->s.crcnum = 0; |
| |
stat = fdd->crc(fdd, f->s.media, track, 0, crcbuf); |
| |
} |
| |
if (!(stat & FDDSTAT_RECNFND)) { |
| |
f->s.bufdir = FDCDIR_IN; |
| |
f->s.bufsize = 6; |
| |
f->s.rreg = crcbuf[0]; |
| |
f->s.crcnum++; |
| |
} |
| |
else { |
| |
f->s.bufdir = FDCDIR_NONE; |
| |
f->s.bufsize = 0; |
| |
} |
| |
f->s.bufwrite = FALSE; |
| |
f->s.curtime = 0; |
| |
return(stat); |
| |
} |
| |
|
| |
static void fdcenddata(FDC *f) { |
| |
|
| |
BRESULT r; |
| |
REG8 stat; |
| |
|
| |
r = FALSE; |
| |
if (f->s.ctype & FDCCTYPE_CMD2) { |
| |
stat = 0; |
| |
if (f->s.cmd & 0x10) { |
| |
r = TRUE; |
| |
} |
| |
if ((f->s.cmd & 0x20) && (f->s.bufwrite)) { |
| |
stat = type2flash(f); |
| |
if (stat & (FDDSTAT_RECNFND | FDDSTAT_WRITEFAULT)) { |
| |
r = FALSE; |
| |
} |
| |
f->s.stat = stat; |
| |
} |
| |
} |
| |
f->s.bufdir = FDCDIR_NONE; |
| |
dmac_sendready(FALSE); |
| |
if (r) { |
| |
f->s.rreg = f->s.r + 1; |
| |
stat = type2cmd(f, f->s.rreg); |
| |
if (!(stat & FDDSTAT_RECNFND)) { |
| |
f->s.r = f->s.r + 1; |
| |
f->s.stat = stat; |
| } |
} |
| } |
} |
| } |
} |
| |
|
| REG8 IOINPCALL fdc_i(UINT port) { |
|
| |
|
| static BYTE timeoutwait; |
|
| static BYTE last_r; |
/* IO-Sub */ |
| static short last_off; |
|
| BYTE ans; |
static void IOOUTCALL fdc_o0ff8(FDC *f, REG8 value) { |
| REG8 cmd; |
|
| |
REG8 cmd; |
| if ((port & (~7)) != 0x0ff8) { |
|
| return(0xff); |
/* コマンド */ |
| } |
if (f->s.bufwrite) { |
| cmd = (REG8)(fdc.cmd >> 4); |
f->s.stat = type2flash(f); |
| if ((port &= 0xf) != 8) { |
} |
| last_r = -1; |
if (f->s.bufdir != FDCDIR_NONE) { |
| last_off = -1; |
f->s.bufdir = FDCDIR_NONE; |
| timeoutwait = 4; |
dmac_sendready(FALSE); |
| } |
} |
| switch(port) { |
|
| case 0x8: // ステータス |
f->s.cmd = value; |
| ans = 0; |
cmd = (REG8)(value >> 4); |
| fdcdummyread = 0; |
f->s.ctype = fdctype[cmd]; |
| if (fdc.skip) { |
/* TRACEOUT(("fdc cmd: %.2x", value)); */ |
| fdc.skip--; |
/* リストアコマンドにおいて |
| return(0x01); |
* マリオは コマンド発行後にbusyを見張る |
| } |
* 逆にソーサリアンとかは busyだとエラーになる… |
| if (fdc.busyclock) { // ver0.25 |
* 条件は何？ |
| if (((h_cntbase + h_cnt) - fdc.busystart) < fdc.busyclock) { |
*/ |
| return(0x01); |
setbusy(f, 20); |
| |
switch(cmd) { |
| |
case 0x00: /* リストア */ |
| |
f->s.motor = 0x80; /* モーターOn? */ |
| |
f->s.c = 0; |
| |
f->s.step = 1; |
| |
f->s.r = 0; /* デゼニワールド */ |
| |
seekcmd(f); |
| |
f->s.rreg = 0; |
| |
break; |
| |
|
| |
case 0x01: /* シーク */ |
| |
f->s.motor = 0x80; /* モーターOn */ |
| |
f->s.step = (SINT8)((f->s.c<=f->s.data)?1:-1); |
| |
f->s.c = f->s.data; |
| |
seekcmd(f); |
| |
break; |
| |
|
| |
case 0x02: /* ステップ */ |
| |
case 0x03: |
| |
case 0x04: /* ステップイン */ |
| |
case 0x05: |
| |
case 0x06: /* ステップアウト */ |
| |
case 0x07: |
| |
f->s.stat = FDDSTAT_HEADENG; |
| |
if (f->s.motor) { |
| |
if (cmd & 0x04) { |
| |
f->s.step = (cmd & 0x02)?-1:1; |
| |
} |
| |
f->s.c += f->s.step; |
| |
if (cmd & 1) { |
| |
seekcmd(f); |
| } |
} |
| fdc.busyclock = 0; |
|
| } |
} |
| { |
break; |
| FDDFILE fdd = fddfile + fdc.drv; |
|
| if (fdd->type == DISKTYPE_NOTREADY) { |
case 0x08: /* リードデータ */ |
| if (fdc.type == 1 && fdc.c == 0) { // ドライブチェック !!! |
case 0x09: |
| return(0x84); // ←接続されてる時だけ |
case 0x0a: /* ライトデータ */ |
| |
case 0x0b: |
| |
f->s.stat = type2cmd(f, f->s.r); |
| |
break; |
| |
|
| |
case 0xc: /* リードアドレス */ |
| |
setbusy(f, 200); |
| |
f->s.stat = crccmd(f); |
| |
break; |
| |
|
| |
case 0x0d: /* フォースインタラプト */ |
| |
setbusy(f, 0); /* 必要ない？ */ |
| |
/* f->s.skip = 0; */ /* 000330 */ |
| |
f->s.stat = 0; |
| |
dmac_sendready(FALSE); |
| |
break; |
| |
|
| |
case 0x0e: /* リードトラック */ |
| |
#if !defined(CONST_DISKIMAGE) |
| |
setbusy(f, 200); |
| |
ZeroMemory(f->s.buffer, 0x1a00); |
| |
f->s.bufpos = 0; |
| |
f->s.bufsize = 0x1a00; |
| |
f->s.bufdir = FDCDIR_IN; |
| |
f->s.stat = 0; |
| |
#else |
| |
f->s.stat = FDDSTAT_SEEKERR; |
| |
#endif |
| |
break; |
| |
|
| |
case 0x0f: /* ライトトラック */ |
| |
#if !defined(CONST_DISKIMAGE) |
| |
setbusy(f, 200); |
| |
f->s.stat = wrtrkstart(f); |
| |
#else |
| |
f->s.stat = FDDSTAT_LOSTDATA; |
| |
#endif |
| |
break; |
| |
} |
| |
} |
| |
|
| |
static void IOOUTCALL fdc_o0ff9(FDC *f, REG8 value) { |
| |
|
| |
/* トラック */ |
| |
f->s.creg = value; |
| |
} |
| |
|
| |
static void IOOUTCALL fdc_o0ffa(FDC *f, REG8 value) { |
| |
|
| |
/* セクタ */ |
| |
fddmtr_waitsec(value); |
| |
f->s.r = value; |
| |
f->s.rreg = value; |
| |
} |
| |
|
| |
static void IOOUTCALL fdc_o0ffb(FDC *f, REG8 value) { |
| |
|
| |
/* データ */ |
| |
f->s.data = value; |
| |
#if !defined(CONST_DISKIMAGE) |
| |
if (f->s.motor) { |
| |
if (f->s.bufdir == FDCDIR_OUT) { |
| |
f->s.bufwrite = TRUE; |
| |
f->s.curtime = 0; |
| |
f->s.buffer[f->s.bufpos] = value; |
| |
if (!f->s.busy) { |
| |
f->s.bufpos++; |
| |
if (f->s.bufpos >= f->s.bufsize) { |
| |
fdcenddata(f); |
| } |
} |
| return(0x80); |
|
| } |
} |
| } |
} |
| if (fdc.type == 2) { |
else if (f->s.bufdir == FDCDIR_TAO) { |
| if (last_r == fdc.r && last_off == fdc.off && |
wrtrkdata(f, value); |
| !(--timeoutwait)) { |
} |
| inc_off(); |
} |
| timeoutwait = 4; |
#endif |
| } |
} |
| last_r = fdc.r; |
|
| last_off = fdc.off; |
static void IOOUTCALL fdc_o0ffc(FDC *f, REG8 value) { |
| } // Read Write時のみの変化でいい筈 |
|
| if (!((ans = fdd_stat()) & 2)) { |
/* ドライブ・サイド */ |
| dma.DMA_REDY = 8; // <- DMA ノ レディシンゴウ ヲ クリア |
f->s.ctbl[f->s.drv] = f->s.c; |
| } |
f->s.c = f->s.ctbl[value & 0x03]; |
| |
f->s.motor = (UINT8)(value & 0x80); |
| |
f->s.drv = (UINT8)(value & 0x03); |
| |
f->s.h = (UINT8)((value >> 4) & 1); |
| |
f->s.cmd = 0; /* T&E SORCERIAN */ |
| |
f->s.ctype = 0; |
| |
f->s.stat = 0; |
| |
|
| |
fddmtr_drvset(); |
| |
if (!f->s.motor) { |
| |
f->s.r = 0; /* SACOM TELENET */ |
| |
f->s.rreg = 0; |
| |
} |
| |
#if defined(SUPPORT_MOTORRISEUP) |
| |
setmotor(f, value); |
| |
#endif |
| |
} |
| |
|
| |
static void IOOUTCALL fdc_o0(FDC *f, REG8 value) { |
| |
} |
| |
|
| |
static REG8 IOINPCALL fdc_i0ff8(FDC *f) { |
| |
|
| |
REG8 ret; |
| |
|
| |
/* ステータス */ |
| |
ret = f->s.busy; |
| |
if (ret) { |
| |
return(ret); |
| |
} |
| #if 1 |
#if 1 |
| if (driveset) { // 0xffcを叩いた直後だったら |
if (f->s.bufdir >= FDCDIR_IN) { /* YsII */ |
| ans &= 0xc4; |
f->s.curtime++; |
| |
if (f->s.curtime >= 8) { |
| |
f->s.curtime = 0; |
| |
f->s.stat |= FDDSTAT_LOSTDATA; |
| |
f->s.bufpos++; |
| |
if (f->s.bufpos >= f->s.bufsize) { |
| |
fdcenddata(f); |
| } |
} |
| |
} |
| |
} |
| #endif |
#endif |
| return(ans); |
ret = getstat(f); |
| |
#if 1 |
| |
if (!(ret & 0x02)) { |
| |
dmac_sendready(FALSE); |
| |
} |
| |
#endif |
| |
/* TRACEOUT(("ret->%.2x", ret)); */ |
| |
return(ret); |
| |
} |
| |
|
| case 0x9: // トラック |
static REG8 IOINPCALL fdc_i0ff9(FDC *f) { |
| return(fdc.treg); |
|
| |
|
| case 0xa: // セクタ |
/* トラック */ |
| return(fdc.rreg); // ver0.25 |
TRACEOUT(("fdc inp %.4x,%.2x", 0x0ff9, f->s.creg)); |
| |
return(f->s.creg); |
| case 0xb: // データ |
} |
| if (fdc.motor) { |
|
| if ((cmd == 0x08) || (cmd == 0x09)) { // リード・データ |
static REG8 IOINPCALL fdc_i0ffa(FDC *f) { |
| FDDFILE fdd; |
|
| fdd = fddfile + fdc.drv; |
/* セクタ */ |
| switch(fdd->type) { |
TRACEOUT(("fdc inp %.4x,%.2x", 0x0ffa, f->s.rreg)); |
| case DISKTYPE_NOTREADY: |
return(f->s.rreg); |
| break; |
} |
| |
|
| case DISKTYPE_BETA: |
static REG8 IOINPCALL fdc_i0ffb(FDC *f) { |
| fdd_read_2d(); |
|
| break; |
/* データ */ |
| |
if (f->s.motor) { |
| case DISKTYPE_D88: |
if (f->s.bufdir == FDCDIR_IN) { |
| default: |
f->s.curtime = 0; |
| fdd_read_d88(); // WOODY POCO !!! |
#if !defined(CONST_DISKIMAGE) |
| break; |
f->s.data = f->s.buffer[f->s.bufpos]; |
| } |
#else |
| inc_off(); |
f->s.data = f->e.buffer[f->s.bufpos]; |
| } |
#endif |
| else if (cmd == 0x0c) { // リード・アドレス |
if (!f->s.busy) { |
| if (fdc.crc_off < 6) { // ver0.25 |
f->s.bufpos++; |
| fdc.data = fdc.crc_dat[fdc.crc_off]; |
if (f->s.bufpos >= f->s.bufsize) { |
| if (fdcdummyread) { // ver0.25 |
fdcenddata(f); |
| fdcdummyread--; |
|
| } |
|
| else { |
|
| fdc.crc_off++; |
|
| } |
|
| } |
|
| } |
|
| else if (cmd == 0x0e) { // ver0.25 |
|
| fdc.data = 0; |
|
| readdiag++; |
|
| } |
} |
| } |
} |
| return(fdc.data); // WOODY POCO !!! |
/* TRACEOUT(("read %.2x - %.2x [%.4x]", f->s.bufpos, f->s.data, Z80_PC)); */ |
| |
} |
| |
} |
| |
return(f->s.data); |
| |
} |
| |
|
| |
static REG8 IOINPCALL fdc_i0ffc(FDC *f) { |
| |
|
| |
/* FM */ |
| |
return(0x00); |
| |
} |
| |
|
| |
static REG8 IOINPCALL fdc_i0ffd(FDC *f) { |
| |
|
| |
/* MFM */ |
| |
return(0x00); |
| |
} |
| |
|
| |
static REG8 IOINPCALL fdc_i0ffe(FDC *f) { |
| |
|
| |
/* 1.6M */ |
| |
f->s.media = DISKTYPE_2HD; |
| |
return(0xff); |
| |
} |
| |
|
| // case 0xc: // FM |
static REG8 IOINPCALL fdc_i0fff(FDC *f) { |
| // case 0xd: // MFM |
|
| // break; |
/* 500K/1M */ |
| |
f->s.media = DISKTYPE_2D; |
| case 0xe: // 1.6M |
return(0xff); |
| fdc.media = 1; |
} |
| return(0xff); |
|
| |
|
| case 0xf: // 500K/1M |
/* IO */ |
| fdc.media = 0; |
|
| return(0xff); |
typedef void (IOINPCALL * FNFDCOUT)(FDC *f, REG8 value); |
| |
static const FNFDCOUT s_fnOut[] = |
| |
{ |
| |
fdc_o0ff8, fdc_o0ff9, fdc_o0ffa, fdc_o0ffb, |
| |
fdc_o0ffc, fdc_o0, fdc_o0, fdc_o0, |
| |
}; |
| |
|
| |
typedef REG8 (IOINPCALL * FNFDCINP)(FDC *f); |
| |
static const FNFDCINP s_fnInp[] = |
| |
{ |
| |
fdc_i0ff8, fdc_i0ff9, fdc_i0ffa, fdc_i0ffb, |
| |
fdc_i0ffc, fdc_i0ffd, fdc_i0ffe, fdc_i0fff, |
| |
}; |
| |
|
| |
void IOINPCALL fdc_o(UINT port, REG8 value) |
| |
{ |
| |
if ((port & (~7)) != 0x0ff8) |
| |
{ |
| |
return; |
| } |
} |
| return(0); |
|
| |
/* TRACEOUT(("fdc out %.4x,%.2x", port, value)); */ |
| |
(s_fnOut[port & 7])(&fdc, value); |
| |
} |
| |
|
| |
REG8 IOINPCALL fdc_i(UINT uPort) |
| |
{ |
| |
if ((uPort & (~7)) != 0x0ff8) |
| |
{ |
| |
return 0xff; |
| |
} |
| |
|
| |
/* TRACEOUT(("fdc inp %.4x", port)); */ |
| |
return (s_fnInp[uPort & 7])(&fdc); |
| } |
} |
| |
|
| |
|
| // ---- |
/* reset */ |
| |
|
| void fdc_reset(void) { |
void fdc_reset(void) { |
| |
|
| FDDMTR_INIT; |
fddmtr_initialize(); |
| ZeroMemory(&fdc, sizeof(fdc)); |
ZeroMemory(&fdc, sizeof(fdc)); |
| fdc.step = 1; |
fdc.s.step = 1; |
| ZeroMemory(FDC_c, 4); |
fdc.s.equip = xmilcfg.fddequip; |
| |
#if defined(FIX_Z80A) |
| |
fdc.s.loopclock = 2000000 * 2 / 5; |
| |
#else |
| |
fdc.s.loopclock = pccore.realclock / 5; |
| |
#endif |
| } |
} |
| |
|
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to fdc.c CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [RetroPC.NET] / xmil / io