|
version 1.2, 2004/08/05 04:53:15
|
version 1.19, 2004/08/18 08:08:13
|
|
Line 3
|
Line 3
|
| #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_2d.h" |
| #include "fdd_d88.h" |
#include "fdd_d88.h" |
| #include "fdd_mtr.h" |
#include "fdd_mtr.h" |
| |
|
| |
|
| 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 const UINT8 fdctype[] = {1,1,1,1,1,1,1,1,2,2,2,2,3,4,3,3}; |
| |
|
| |
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 |
| |
}; |
| |
|
| |
|
| static BYTE fdd_stat(void) { |
// ---- |
| |
|
| FDDFILE fdd; |
void neitem_fdcbusy(UINT id) { |
| |
|
| fdd = fddfile + fdc.drv; |
fdc.s.busy = FALSE; |
| switch(fdd->type) { |
if (fdc.s.bufdir) { |
| case DISKTYPE_NOTREADY: |
// TRACEOUT(("dma ready!")); |
| return(0); |
dmac_sendready(TRUE); |
| |
} |
| |
(void)id; |
| |
} |
| |
|
| case DISKTYPE_BETA: |
static void setbusy(SINT32 clock) { |
| return(fdd_stat_2d()); |
|
| |
|
| case DISKTYPE_D88: |
if (clock > 0) { |
| default: |
fdc.s.busy = TRUE; |
| return(fdd_stat_d88()); |
nevent_set(NEVENT_FDC, clock, neitem_fdcbusy, NEVENT_ABSOLUTE); |
| |
} |
| |
else { |
| |
fdc.s.busy = FALSE; |
| |
nevent_reset(NEVENT_FDC); |
| |
} |
| |
} |
| |
|
| |
#if defined(SUPPORT_MOTORRISEUP) |
| |
static void setmotor(REG8 drvcmd) { |
| |
|
| |
UINT drv; |
| |
SINT32 clock; |
| |
|
| |
drv = drvcmd & 3; |
| |
clock = CPU_CLOCK + CPU_BASECLOCK - CPU_REMCLOCK; |
| |
if (drvcmd & 0x80) { |
| |
if (fdc.s.motorevent[drv] == FDCMOTOR_STOP) { |
| |
fdc.s.motorevent[drv] = FDCMOTOR_STARTING; |
| |
fdc.s.motorclock[drv] = clock; |
| |
} |
| |
else if (fdc.s.motorevent[drv] == FDCMOTOR_STOPING) { |
| |
fdc.s.motorevent[drv] = FDCMOTOR_READY; |
| |
} |
| |
} |
| |
else { |
| |
if ((fdc.s.motorevent[drv] == FDCMOTOR_STARTING) || |
| |
(fdc.s.motorevent[drv] == FDCMOTOR_READY)) { |
| |
fdc.s.motorevent[drv] = FDCMOTOR_STOPING; |
| |
fdc.s.motorclock[drv] = clock; |
| |
} |
| } |
} |
| return(0); |
|
| } |
} |
| |
|
| |
void fdc_callback(void) { |
| |
|
| /*********************************************************************** |
SINT32 clock; |
| ＦＤＣ （Ｘ１から見るＩ／Ｏに相当する関数） |
UINT i; |
| ***********************************************************************/ |
|
| |
|
| static int inc_off(void) { |
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; |
| |
} |
| |
} |
| |
else if (fdc.s.motorevent[i] == FDCMOTOR_STOPING) { |
| |
if ((clock - fdc.s.motorclock[i]) >= (SINT32)pccore.realclock) { |
| |
fdc.s.motorevent[i] = FDCMOTOR_STOP; |
| |
} |
| |
} |
| |
} |
| |
} |
| |
|
| BYTE ret; |
static SINT32 motorwait(REG8 drv) { |
| FDDFILE fdd; |
|
| |
|
| if (!fdc.motor) { |
SINT32 curclock; |
| return(0); |
SINT32 nextclock; |
| |
|
| |
if (fdc.s.motorevent[drv] == FDCMOTOR_STARTING) { |
| |
curclock = CPU_CLOCK + CPU_BASECLOCK - CPU_REMCLOCK; |
| |
curclock -= fdc.s.motorclock[drv]; |
| |
if (curclock < (SINT32)pccore.realclock) { |
| |
nextclock = pccore.realclock - curclock; |
| |
// TRACEOUT(("motor starting busy %d", nextclock)); |
| |
return(nextclock); |
| |
} |
| } |
} |
| if (fdcdummyread) { |
return(0); |
| fdcdummyread--; |
} |
| return(0); |
#endif |
| |
|
| |
|
| |
static REG8 getstat(void) { |
| |
|
| |
FDDFILE fdd; |
| |
REG8 cmd; |
| |
REG8 type; |
| |
REG8 ret; |
| |
|
| |
fdd = fddfile + fdc.s.drv; |
| |
cmd = (REG8)(fdc.s.cmd >> 4); |
| |
type = fdc.s.type; |
| |
if (fdd->type == DISKTYPE_NOTREADY) { |
| |
ret = FDDSTAT_NOTREADY; |
| |
} |
| |
else if (type != 0) { |
| |
ret = fdc.s.stat; |
| } |
} |
| else { |
else { |
| fdd = fddfile + fdc.drv; |
ret = 0; |
| switch(fdd->type) { |
} |
| case DISKTYPE_NOTREADY: |
if ((type == 1) && (fdc.s.c == 0)) { |
| return(0); |
ret |= FDDSTAT_TRACK00; |
| |
} |
| case DISKTYPE_BETA: |
if ((type == 0) || (type == 1) || (type == 4) || |
| ret = fdd_incoff_2d(); |
(cmd == 0x0a) || (cmd == 0x0b) || (cmd == 0x0f)) { |
| break; |
if (fdd->protect) { |
| |
ret |= FDDSTAT_WRITEP; |
| case DISKTYPE_D88: |
|
| default: |
|
| ret = fdd_incoff_d88(); |
|
| break; |
|
| } |
} |
| if (ret) { |
} |
| dma.DMA_REDY = 8; // <- DMA ノ レディシンゴウ ヲ クリア |
if ((type == 1) || (type == 4)) { |
| |
fdc.s.hole++; |
| |
if (fdc.s.hole < 8) { |
| |
ret |= FDDSTAT_INDEX; |
| |
} |
| |
} |
| |
else if (!(ret & 0xf0)) { |
| |
if (FDDMTR_BUSY) { |
| |
ret |= FDDSTAT_BUSY; |
| |
} |
| |
if (fdc.s.bufdir) { |
| |
ret |= FDDSTAT_DRQ | FDDSTAT_BUSY; |
| |
} |
| |
else if (cmd == 0x0f) { |
| |
ret |= FDDSTAT_LOSTDATA; |
| } |
} |
| } |
} |
| return(ret); |
return(ret); |
| } |
} |
| |
|
| void IOOUTCALL fdc_o(UINT port, REG8 value) { |
static void seekcmd(void) { |
| |
|
| REG8 cmd; |
FDDFILE fdd; |
| |
UINT track; |
| |
|
| if ((port & (~7)) != 0x0ff8) { |
fdc.s.crcnum = 0; |
| return; |
fdc.s.creg = fdc.s.c; |
| } |
fdd = fddfile + fdc.s.drv; |
| port &= 0xf; |
track = (fdc.s.c << 1) + fdc.s.h; |
| if (port == 8) { // コマンド |
fdc.s.stat = fdd->seek(fdd, fdc.s.media, track) | FDDSTAT_HEADENG; |
| driveset = 0; |
FDDMTR_MOVE; |
| fdc.cmd = value; |
} |
| cmd = (REG8)(value >> 4); |
|
| fdc.type = fdctype[cmd]; |
static REG8 type2cmd(REG8 sc) { |
| fdc.skip = 2; |
|
| switch(cmd) { |
REG8 dir; |
| case 0x00: // リストア |
UINT track; |
| if (value & 8) { // LAYDOCK |
UINT8 *p; |
| fdc.skip = 0; |
FDDFILE fdd; |
| fdc.busyclock = 20; // ver0.25 (now testing) |
UINT size; |
| fdc.busystart = h_cntbase + h_cnt; |
REG8 stat; |
| } |
SINT32 clock; |
| fdc.motor = 0x80; // モーターOn? |
#if defined(SUPPORT_DISKEXT) |
| fdc.c = 0; |
SINT32 curclock; |
| fdc.treg = 0; |
SINT32 nextclock; |
| FDDMTR_MOVE; |
UINT32 secinfo; |
| fdc.step = 1; |
|
| #if 1 // ver0.25 |
|
| fdc.r = 0; // デゼニワールド |
|
| fdc.rreg = 0; |
|
| #endif |
#endif |
| break; |
|
| |
|
| case 0x01: // シーク |
track = (fdc.s.c << 1) + fdc.s.h; |
| fdc.motor = 0x80; // モーターOn |
if (!(fdc.s.cmd & 0x20)) { |
| fdc.step = (char)((fdc.c<=fdc.data)?1:-1); |
p = fdc.s.buffer; |
| #if 0 // スタクル // ver0.50 |
dir = FDCDIR_IN; |
| fdc.rreg = fdc.r = 0; |
} |
| |
else { |
| |
p = NULL; |
| |
dir = FDCDIR_OUT; |
| |
} |
| |
size = sizeof(fdc.s.buffer); |
| |
fdd = fddfile + fdc.s.drv; |
| |
// TRACEOUT(("read %.2x %d %d", fdc.s.drv, track, sc)); |
| |
stat = fdd->read(fdd, fdc.s.media, track, sc, p, &size); |
| |
if (stat & FDDSTAT_RECNFND) { |
| |
size = 0; |
| |
dir = FDCDIR_NONE; |
| |
} |
| |
else if (dir == FDCDIR_OUT) { |
| |
if (size) { |
| |
ZeroMemory(fdc.s.buffer, size); |
| |
} |
| |
stat = stat & (~FDDSTAT_RECTYPE); |
| |
} |
| |
fdc.s.bufmedia = fdc.s.media; |
| |
fdc.s.bufunit = fdc.s.drv; |
| |
fdc.s.buftrack = track; |
| |
fdc.s.bufsc = sc; |
| |
fdc.s.bufwrite = FALSE; |
| |
fdc.s.bufdir = dir; |
| |
fdc.s.bufmark = fdc.s.cmd & 1; |
| |
fdc.s.bufpos = 0; |
| |
fdc.s.bufsize = size; |
| |
fdc.s.curtime = 0; |
| |
|
| |
clock = 0; |
| |
#if defined(SUPPORT_MOTORRISEUP) |
| |
clock += motorwait(fdc.s.drv); |
| #endif |
#endif |
| fdc.c = fdc.data; |
#if defined(SUPPORT_DISKEXT) |
| fdc.treg = fdc.data; |
secinfo = fdd->sec(fdd, fdc.s.media, track, sc); |
| FDDMTR_MOVE; |
if (secinfo) { |
| break; |
nextclock = LOW16(secinfo); |
| |
nextclock *= fdc.s.loopclock; |
| case 0x02: // ステップ |
nextclock /= LOW16(secinfo >> 16); |
| case 0x03: |
curclock = nevent_getwork(NEVENT_RTC); |
| if (fdc.motor) { |
nextclock -= curclock; |
| fdc.c += fdc.step; |
if (nextclock < 0) { |
| if (cmd & 1) { |
nextclock += fdc.s.loopclock; |
| FDDMTR_MOVE; |
} |
| fdc.treg = fdc.c; |
// TRACEOUT(("wait clock -> %d [%d/%d]", nextclock, |
| } |
// LOW16(secinfo), LOW16(secinfo >> 16))); |
| } |
clock += nextclock; |
| break; |
} |
| |
#endif |
| |
setbusy(max(clock, 500)); |
| |
return(stat); |
| |
} |
| |
|
| case 0x04: // ステップイン |
static REG8 type2flash(void) { |
| case 0x05: |
|
| if (fdc.motor) { |
|
| fdc.step = 1; |
|
| fdc.c++; |
|
| if (cmd & 1) { |
|
| FDDMTR_MOVE; |
|
| fdc.treg = fdc.c; |
|
| } |
|
| } |
|
| break; |
|
| |
|
| case 0x06: // ステップアウト |
FDDFILE fdd; |
| case 0x07: |
|
| if (fdc.motor) { |
|
| fdc.step = -1; |
|
| fdc.c--; |
|
| if (cmd & 1) { |
|
| FDDMTR_MOVE; |
|
| fdc.treg = fdc.c; |
|
| } |
|
| } |
|
| break; |
|
| |
|
| case 0x08: // リードデータ |
fdc.s.bufwrite = FALSE; |
| case 0x09: |
fdd = fddfile + fdc.s.bufunit; |
| case 0x0a: // ライトデータ |
if (fdd->protect) { |
| case 0x0b: |
return(FDDSTAT_WRITEFAULT); |
| fdc.off = 0; |
} |
| fdcdummyread = 2; |
return(fdd->write(fdd, fdc.s.bufmedia, fdc.s.buftrack, |
| if (fdc.motor) { |
fdc.s.bufsc, fdc.s.buffer, fdc.s.bufpos)); |
| if (dma.DMA_ENBL) { |
} |
| dma.DMA_REDY = 0; |
|
| // fdc.skip = 0; // DMAで割り込みを監視する事！ |
|
| } |
|
| } |
|
| break; |
|
| |
|
| case 0xc: // リードアドレス |
static REG8 crccmd(void) { |
| fdc.crc_off = 0; |
|
| fdcdummyread = 2; |
|
| if (fdc.motor) { // ver0.25 |
|
| if (dma.DMA_ENBL) { |
|
| dma.DMA_REDY = 0; |
|
| } |
|
| } |
|
| { |
|
| 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: // フォースインタラプト |
UINT track; |
| fdcdummyread = 0; // 必要ない？ |
FDDFILE fdd; |
| fdc.skip = 0; // 000330 |
REG8 stat; |
| dma.DMA_REDY = 8; // ver0.25 |
|
| break; |
track = (fdc.s.c << 1) + fdc.s.h; |
| |
fdd = fddfile + fdc.s.drv; |
| case 0x0e: // リードトラック |
// TRACEOUT(("fdd->crc %d %d %d", fdc.s.drv, track, fdc.s.crcnum)); |
| readdiag = 0; |
stat = fdd->crc(fdd, fdc.s.media, track, fdc.s.crcnum, fdc.s.buffer); |
| break; |
if (stat & FDDSTAT_RECNFND) { |
| |
fdc.s.crcnum = 0; |
| case 0x0f: // ライトトラック |
stat = fdd->crc(fdd, fdc.s.media, track, 0, fdc.s.buffer); |
| { |
} |
| FDDFILE fdd = fddfile + fdc.drv; |
if (!(stat & FDDSTAT_RECNFND)) { |
| switch(fdd->type) { |
fdc.s.bufdir = FDCDIR_IN; |
| case DISKTYPE_NOTREADY: |
fdc.s.bufsize = 6; |
| case DISKTYPE_BETA: |
fdc.s.rreg = fdc.s.buffer[0]; |
| break; |
fdc.s.crcnum++; |
| |
} |
| case DISKTYPE_D88: |
else { |
| default: |
fdc.s.bufdir = FDCDIR_NONE; |
| if (fdc.motor) { // ver0.25 |
fdc.s.bufsize = 0; |
| init_tao_d88(); |
} |
| if (dma.DMA_ENBL) { |
fdc.s.bufwrite = FALSE; |
| dma.DMA_REDY = 0; |
fdc.s.curtime = 0; |
| } |
return(stat); |
| } |
} |
| break; |
|
| } |
static void bufposinc(void) { |
| |
|
| |
BRESULT r; |
| |
REG8 stat; |
| |
|
| |
if (fdc.s.busy) { |
| |
return; |
| |
} |
| |
fdc.s.bufpos++; |
| |
fdc.s.curtime = 0; |
| |
if (fdc.s.bufpos >= fdc.s.bufsize) { |
| |
r = FALSE; |
| |
if (fdc.s.type == 2) { |
| |
stat = 0; |
| |
if (fdc.s.cmd & 0x10) { |
| |
r = TRUE; |
| |
} |
| |
if ((fdc.s.cmd & 0x20) && (fdc.s.bufwrite)) { |
| |
stat = type2flash(); |
| |
if (stat & (FDDSTAT_RECNFND | FDDSTAT_WRITEFAULT)) { |
| |
r = FALSE; |
| } |
} |
| break; |
fdc.s.stat = stat; |
| |
} |
| |
} |
| |
fdc.s.bufdir = FDCDIR_NONE; |
| |
dmac_sendready(FALSE); |
| |
if (r) { |
| |
fdc.s.rreg = fdc.s.r + 1; |
| |
stat = type2cmd(fdc.s.rreg); |
| |
if (!(stat & FDDSTAT_RECNFND)) { |
| |
fdc.s.r = fdc.s.r + 1; |
| |
fdc.s.stat = stat; |
| |
} |
| } |
} |
| } |
} |
| else { |
} |
| cmd = (REG8)(fdc.cmd >> 4); |
|
| switch(port) { |
void IOOUTCALL fdc_o(UINT port, REG8 value) { |
| case 0x09: // トラック |
|
| fdc.treg = value; |
REG8 cmd; |
| break; |
|
| |
if ((port & (~7)) != 0x0ff8) { |
| case 0x0a: // セクタ |
return; |
| FDDMTR_WAITSEC(value); |
} |
| fdc.r = value; |
TRACEOUT(("fdc %.4x,%.2x [%.4x]", port, value, Z80_PC)); |
| fdc.rreg = value; |
switch(port & 7) { |
| break; |
case 0: // コマンド |
| |
fdc.s.cmd = value; |
| case 0x0b: // データ |
cmd = (REG8)(value >> 4); |
| fdc.data = value; |
fdc.s.type = fdctype[cmd]; |
| if ((cmd == 0x0a) || (cmd == 0x0b)) { |
// TRACEOUT(("fdc cmd: %.2x", value)); |
| FDDFILE fdd = fddfile + fdc.drv; |
if (fdc.s.bufwrite) { |
| switch(fdd->type) { |
fdc.s.stat = type2flash(); |
| case DISKTYPE_NOTREADY: |
} |
| break; |
fdc.s.bufdir = FDCDIR_NONE; |
| |
// リストアコマンドにおいて |
| case DISKTYPE_BETA: |
// マリオは コマンド発行後にbusyを見張る |
| fdd_write_2d(); |
// 逆にソーサリアンとかは busyだとエラーになる… |
| break; |
// 条件は何？ |
| |
setbusy(20); |
| case DISKTYPE_D88: |
switch(cmd) { |
| default: |
case 0x00: // リストア |
| fdd_write_d88(); |
fdc.s.motor = 0x80; // モーターOn? |
| break; |
fdc.s.c = 0; |
| |
fdc.s.step = 1; |
| |
fdc.s.r = 0; // デゼニワールド |
| |
seekcmd(); |
| |
fdc.s.rreg = 0; |
| |
break; |
| |
|
| |
case 0x01: // シーク |
| |
fdc.s.motor = 0x80; // モーターOn |
| |
fdc.s.step = (SINT8)((fdc.s.c<=fdc.s.data)?1:-1); |
| |
fdc.s.c = fdc.s.data; |
| |
seekcmd(); |
| |
break; |
| |
|
| |
case 0x02: // ステップ |
| |
case 0x03: |
| |
if (fdc.s.motor) { |
| |
fdc.s.c += fdc.s.step; |
| |
if (cmd & 1) { |
| |
seekcmd(); |
| |
} |
| } |
} |
| inc_off(); |
break; |
| } |
|
| else if (cmd == 0x0f) { // TRACK WRITE |
case 0x04: // ステップイン |
| FDDFILE fdd = fddfile + fdc.drv; |
case 0x05: |
| switch(fdd->type) { |
if (fdc.s.motor) { |
| case DISKTYPE_NOTREADY: |
fdc.s.step = 1; |
| case DISKTYPE_BETA: |
fdc.s.c++; |
| break; |
if (cmd & 1) { |
| |
seekcmd(); |
| case DISKTYPE_D88: |
} |
| default: |
|
| fdd_wtao_d88(value); |
|
| break; |
|
| } |
} |
| } |
break; |
| break; |
|
| |
case 0x06: // ステップアウト |
| |
case 0x07: |
| |
if (fdc.s.motor) { |
| |
fdc.s.step = -1; |
| |
fdc.s.c--; |
| |
if (cmd & 1) { |
| |
seekcmd(); |
| |
} |
| |
} |
| |
break; |
| |
|
| case 0x0c: // ドライブ・サイド |
case 0x08: // リードデータ |
| driveset = 1; |
case 0x09: |
| FDC_c[fdc.drv] = fdc.c; |
case 0x0a: // ライトデータ |
| fdc.c = FDC_c[value & 0x03]; // XTAL !!! |
case 0x0b: |
| fdc.motor = (UINT8)(value & 0x80); |
fdc.s.stat = type2cmd(fdc.s.r); |
| fdc.drv = (UINT8)(value & 0x03); |
break; |
| fdc.h = (UINT8)((value >> 4) & 1); |
|
| |
case 0xc: // リードアドレス |
| fdc.cmd = 0; // T&E SORCERIAN |
setbusy(200); |
| // fdc.data = 0; // 影の伝説 |
fdc.s.stat = crccmd(); |
| fdc.type = 0; |
break; |
| |
|
| FDDMTR_DRVSET; |
case 0x0d: // フォースインタラプト |
| if (!fdc.motor) { |
setbusy(0); // 必要ない？ |
| fdc.r = 0; // SACOM TELENET |
// fdc.s.skip = 0; // 000330 |
| fdc.rreg = 0; |
fdc.s.stat = 0; |
| #if 0 // XTAL |
dmac_sendready(FALSE); |
| fdc.c = 0; |
break; |
| fdc.step = 1; |
|
| |
case 0x0e: // リードトラック |
| |
setbusy(200); |
| |
ZeroMemory(fdc.s.buffer, 0x1a00); |
| |
fdc.s.bufpos = 0; |
| |
fdc.s.bufsize = 0x1a00; |
| |
fdc.s.bufdir = FDCDIR_IN; |
| |
break; |
| |
|
| |
case 0x0f: // ライトトラック |
| |
break; |
| |
} |
| |
break; |
| |
|
| |
case 1: // トラック |
| |
fdc.s.c = value; |
| |
break; |
| |
|
| |
case 2: // セクタ |
| |
FDDMTR_WAITSEC(value); |
| |
fdc.s.r = value; |
| |
fdc.s.rreg = value; |
| |
break; |
| |
|
| |
case 3: // データ |
| |
fdc.s.data = value; |
| |
if ((fdc.s.motor) && (fdc.s.bufdir == FDCDIR_OUT)) { |
| |
fdc.s.buffer[fdc.s.bufpos] = value; |
| |
fdc.s.bufwrite = TRUE; |
| |
bufposinc(); |
| |
} |
| |
break; |
| |
|
| |
case 4: // ドライブ・サイド |
| |
fdc.s.ctbl[fdc.s.drv] = fdc.s.c; |
| |
fdc.s.c = fdc.s.ctbl[value & 0x03]; |
| |
fdc.s.motor = (UINT8)(value & 0x80); |
| |
fdc.s.drv = (UINT8)(value & 0x03); |
| |
fdc.s.h = (UINT8)((value >> 4) & 1); |
| |
fdc.s.cmd = 0; // T&E SORCERIAN |
| |
fdc.s.type = 0; |
| |
|
| |
FDDMTR_DRVSET; |
| |
if (!fdc.s.motor) { |
| |
fdc.s.r = 0; // SACOM TELENET |
| |
fdc.s.rreg = 0; |
| |
} |
| |
#if defined(SUPPORT_MOTORRISEUP) |
| |
setmotor(value); |
| #endif |
#endif |
| } |
break; |
| break; |
|
| } |
|
| } |
} |
| } |
} |
| |
|
| REG8 IOINPCALL fdc_i(UINT port) { |
REG8 IOINPCALL fdc_i(UINT port) { |
| |
|
| static BYTE timeoutwait; |
REG8 ret; |
| static BYTE last_r; |
|
| static short last_off; |
// TRACEOUT(("fdc inp %.4x", port)); |
| BYTE ans; |
|
| REG8 cmd; |
|
| |
|
| if ((port & (~7)) != 0x0ff8) { |
if ((port & (~7)) != 0x0ff8) { |
| return(0xff); |
return(0xff); |
| } |
} |
| cmd = (REG8)(fdc.cmd >> 4); |
switch(port & 7) { |
| if ((port &= 0xf) != 8) { |
case 0: // ステータス |
| last_r = -1; |
ret = fdc.s.busy; |
| last_off = -1; |
if (ret) { |
| timeoutwait = 4; |
return(ret); |
| } |
|
| switch(port) { |
|
| case 0x8: // ステータス |
|
| ans = 0; |
|
| fdcdummyread = 0; |
|
| if (fdc.skip) { |
|
| fdc.skip--; |
|
| return(0x01); |
|
| } |
|
| if (fdc.busyclock) { // ver0.25 |
|
| if (((h_cntbase + h_cnt) - fdc.busystart) < fdc.busyclock) { |
|
| return(0x01); |
|
| } |
|
| fdc.busyclock = 0; |
|
| } |
|
| { |
|
| FDDFILE fdd = fddfile + fdc.drv; |
|
| if (fdd->type == DISKTYPE_NOTREADY) { |
|
| if (fdc.type == 1 && fdc.c == 0) { // ドライブチェック !!! |
|
| return(0x84); // ←接続されてる時だけ |
|
| } |
|
| return(0x80); |
|
| } |
|
| } |
|
| if (fdc.type == 2) { |
|
| if (last_r == fdc.r && last_off == fdc.off && |
|
| !(--timeoutwait)) { |
|
| inc_off(); |
|
| timeoutwait = 4; |
|
| } |
|
| last_r = fdc.r; |
|
| last_off = fdc.off; |
|
| } // Read Write時のみの変化でいい筈 |
|
| if (!((ans = fdd_stat()) & 2)) { |
|
| dma.DMA_REDY = 8; // <- DMA ノ レディシンゴウ ヲ クリア |
|
| } |
} |
| #if 1 |
#if 1 |
| if (driveset) { // 0xffcを叩いた直後だったら |
if (fdc.s.bufdir) { // YsII |
| ans &= 0xc4; |
fdc.s.curtime++; |
| |
if (fdc.s.curtime >= 8) { |
| |
fdc.s.stat |= 0x04; |
| |
bufposinc(); |
| |
} |
| } |
} |
| #endif |
#endif |
| return(ans); |
ret = getstat(); |
| |
if (!(ret & 0x02)) { |
| |
dmac_sendready(FALSE); |
| |
} |
| |
// TRACEOUT(("ret->%.2x", ret)); |
| |
return(ret); |
| |
|
| case 0x9: // トラック |
case 1: // トラック |
| return(fdc.treg); |
return(fdc.s.creg); |
| |
|
| case 0xa: // セクタ |
case 2: // セクタ |
| return(fdc.rreg); // ver0.25 |
return(fdc.s.rreg); |
| |
|
| case 0xb: // データ |
case 3: // データ |
| if (fdc.motor) { |
if (fdc.s.motor) { |
| if ((cmd == 0x08) || (cmd == 0x09)) { // リード・データ |
if (fdc.s.bufdir == FDCDIR_IN) { |
| FDDFILE fdd; |
fdc.s.data = fdc.s.buffer[fdc.s.bufpos]; |
| fdd = fddfile + fdc.drv; |
// TRACEOUT(("read %.2x - %.2x [%.4x]", fdc.s.bufpos, fdc.s.data, Z80_PC)); |
| switch(fdd->type) { |
bufposinc(); |
| case DISKTYPE_NOTREADY: |
|
| break; |
|
| |
|
| case DISKTYPE_BETA: |
|
| fdd_read_2d(); |
|
| break; |
|
| |
|
| case DISKTYPE_D88: |
|
| default: |
|
| fdd_read_d88(); // WOODY POCO !!! |
|
| break; |
|
| } |
|
| inc_off(); |
|
| } |
|
| else if (cmd == 0x0c) { // リード・アドレス |
|
| if (fdc.crc_off < 6) { // ver0.25 |
|
| fdc.data = fdc.crc_dat[fdc.crc_off]; |
|
| if (fdcdummyread) { // ver0.25 |
|
| fdcdummyread--; |
|
| } |
|
| else { |
|
| fdc.crc_off++; |
|
| } |
|
| } |
|
| } |
|
| else if (cmd == 0x0e) { // ver0.25 |
|
| fdc.data = 0; |
|
| readdiag++; |
|
| } |
} |
| } |
} |
| return(fdc.data); // WOODY POCO !!! |
return(fdc.s.data); |
| |
|
| // case 0xc: // FM |
case 4: // FM |
| // case 0xd: // MFM |
case 5: // MFM |
| // break; |
return(0x00); |
| |
|
| case 0xe: // 1.6M |
case 6: // 1.6M |
| fdc.media = 1; |
fdc.s.media = DISKTYPE_2HD; |
| return(0xff); |
break; |
| |
|
| case 0xf: // 500K/1M |
case 7: // 500K/1M |
| fdc.media = 0; |
fdc.s.media = DISKTYPE_2D; |
| return(0xff); |
break; |
| } |
} |
| return(0); |
return(0xff); |
| } |
} |
| |
|
| |
|
|
Line 423 void fdc_reset(void) {
|
Line 549 void fdc_reset(void) {
|
| |
|
| FDDMTR_INIT; |
FDDMTR_INIT; |
| ZeroMemory(&fdc, sizeof(fdc)); |
ZeroMemory(&fdc, sizeof(fdc)); |
| fdc.step = 1; |
fdc.s.step = 1; |
| ZeroMemory(FDC_c, 4); |
fdc.s.equip = xmilcfg.fddequip; |
| |
fdc.s.loopclock = pccore.realclock / 5; |
| } |
} |
| |
|
![[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