boolean Play, Muted;
int CurTrack;
int Mode, File, Channel;
- int Reset;
- int NoErr;
+ unsigned char LocL[8];
int FirstSector;
xa_decode_t Xa;
// so (PSXCLK / 75) = cdr read time (linuzappz)
#define cdReadTime (PSXCLK / 75)
+#define LOCL_INVALID 0xff
+
enum drive_state {
DRIVESTATE_STANDBY = 0, // pause, play, read
DRIVESTATE_LID_OPEN,
new_dyna_set_event(PSXINT_CDR, eCycle); \
}
-// cdrPlaySeekReadInterrupt
-#define CDRPLAYSEEKREAD_INT(eCycle, isFirst) { \
+// cdrPlayReadInterrupt
+#define CDRPLAYREAD_INT(eCycle, isFirst) { \
u32 e_ = eCycle; \
psxRegs.interrupt |= (1 << PSXINT_CDREAD); \
if (isFirst) \
// (yes it's slow, but you probably don't want to modify it)
void cdrLidSeekInterrupt(void)
{
+ CDR_LOG_I("%u %s cdr.DriveState=%d\n", psxRegs.cycle, __func__, cdr.DriveState);
+
switch (cdr.DriveState) {
default:
case DRIVESTATE_STANDBY:
break;
case DRIVESTATE_PREPARE_CD:
- cdr.StatP |= STATUS_SEEK;
-
- cdr.DriveState = DRIVESTATE_STANDBY;
- CDRLID_INT(cdReadTime * 26);
+ if (cdr.StatP & STATUS_SEEK) {
+ SetPlaySeekRead(cdr.StatP, 0);
+ cdr.DriveState = DRIVESTATE_STANDBY;
+ }
+ else {
+ SetPlaySeekRead(cdr.StatP, STATUS_SEEK);
+ CDRLID_INT(cdReadTime * 26);
+ }
break;
}
}
cdr.subq.Absolute[2] = itob(time[2]);
}
-static void ReadTrack(const u8 *time) {
+static int ReadTrack(const u8 *time) {
unsigned char tmp[3];
struct SubQ *subq;
+ int read_ok;
u16 crc;
tmp[0] = itob(time[0]);
tmp[2] = itob(time[2]);
if (memcmp(cdr.Prev, tmp, 3) == 0)
- return;
+ return 1;
CDR_LOG("ReadTrack *** %02x:%02x:%02x\n", tmp[0], tmp[1], tmp[2]);
- cdr.NoErr = CDR_readTrack(tmp);
- memcpy(cdr.Prev, tmp, 3);
+ read_ok = CDR_readTrack(tmp);
+ if (read_ok)
+ memcpy(cdr.Prev, tmp, 3);
if (CheckSBI(time))
- return;
+ return read_ok;
subq = (struct SubQ *)CDR_getBufferSub();
if (subq != NULL && cdr.CurTrack == 1) {
cdr.subq.Track, cdr.subq.Index,
cdr.subq.Relative[0], cdr.subq.Relative[1], cdr.subq.Relative[2],
cdr.subq.Absolute[0], cdr.subq.Absolute[1], cdr.subq.Absolute[2]);
+
+ return read_ok;
}
static void cdrPlayInterrupt_Autopause()
return seekTime;
}
+static u32 cdrAlignTimingHack(u32 cycles)
+{
+ /*
+ * timing hack for T'ai Fu - Wrath of the Tiger:
+ * The game has a bug where it issues some cdc commands from a low priority
+ * vint handler, however there is a higher priority default bios handler
+ * that acks the vint irq and returns, so game's handler is not reached
+ * (see bios irq handler chains at e004 and the game's irq handling func
+ * at 80036810). For the game to work, vint has to arrive after the bios
+ * vint handler rejects some other irq (of which only cd and rcnt2 are
+ * active), but before the game's handler loop reads I_STAT. The time
+ * window for this is quite small (~1k cycles of so). Apparently this
+ * somehow happens naturally on the real hardware.
+ */
+ u32 vint_rel = rcnts[3].cycleStart + 63000 - psxRegs.cycle;
+ vint_rel += PSXCLK / 60;
+ while ((s32)(vint_rel - cycles) < 0)
+ vint_rel += PSXCLK / 60;
+ return vint_rel;
+}
+
static void cdrUpdateTransferBuf(const u8 *buf);
static void cdrReadInterrupt(void);
static void cdrPrepCdda(s16 *buf, int samples);
static void cdrAttenuate(s16 *buf, int samples, int stereo);
-void cdrPlaySeekReadInterrupt(void)
+void cdrPlayReadInterrupt(void)
{
if (cdr.Reading) {
cdrReadInterrupt();
return;
}
- if (!cdr.Play && (cdr.StatP & STATUS_SEEK)) {
- if (cdr.Stat) {
- CDR_LOG_I("cdrom: seek stat hack\n");
- CDRPLAYSEEKREAD_INT(0x1000, 1);
- return;
- }
- SetResultSize(1);
- cdr.StatP |= STATUS_ROTATING;
- SetPlaySeekRead(cdr.StatP, 0);
- cdr.Result[0] = cdr.StatP;
- cdr.Stat = Complete;
- setIrq(0x1002);
-
- Find_CurTrack(cdr.SetSectorPlay);
- ReadTrack(cdr.SetSectorPlay);
- cdr.TrackChanged = FALSE;
- return;
- }
-
if (!cdr.Play) return;
CDR_LOG( "CDDA - %d:%d:%d\n",
// update for CdlGetlocP/autopause
generate_subq(cdr.SetSectorPlay);
- CDRPLAYSEEKREAD_INT(cdReadTime, 0);
+ CDRPLAYREAD_INT(cdReadTime, 0);
}
#define CMD_PART2 0x100
void cdrInterrupt(void) {
int start_rotating = 0;
int error = 0;
- unsigned int seekTime = 0;
+ u32 cycles, seekTime = 0;
u32 second_resp_time = 0;
+ const void *buf;
u8 ParamC;
u8 set_loc[3];
+ int read_ok;
u16 not_ready = 0;
u16 Cmd;
int i;
}
switch (cdr.DriveState) {
+ case DRIVESTATE_PREPARE_CD:
+ if (Cmd > 2) {
+ // Syphon filter 2 expects commands to work shortly after it sees
+ // STATUS_ROTATING, so give up trying to emulate the startup seq
+ cdr.DriveState = DRIVESTATE_STANDBY;
+ cdr.StatP &= ~STATUS_SEEK;
+ psxRegs.interrupt &= ~(1 << PSXINT_CDRLID);
+ break;
+ }
+ // fallthrough
case DRIVESTATE_LID_OPEN:
case DRIVESTATE_RESCAN_CD:
- case DRIVESTATE_PREPARE_CD:
// no disk or busy with the initial scan, allowed cmds are limited
not_ready = CMD_WHILE_NOT_READY;
break;
// MM must be BCD, SS must be BCD and <0x60, FF must be BCD and <0x75
if (((cdr.Param[0] & 0x0F) > 0x09) || (cdr.Param[0] > 0x99) || ((cdr.Param[1] & 0x0F) > 0x09) || (cdr.Param[1] >= 0x60) || ((cdr.Param[2] & 0x0F) > 0x09) || (cdr.Param[2] >= 0x75))
{
- CDR_LOG("Invalid/out of range seek to %02X:%02X:%02X\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
+ CDR_LOG_I("Invalid/out of range seek to %02X:%02X:%02X\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
error = ERROR_INVALIDARG;
goto set_error;
}
*/
Find_CurTrack(cdr.SetSectorPlay);
ReadTrack(cdr.SetSectorPlay);
+ cdr.LocL[0] = LOCL_INVALID;
cdr.TrackChanged = FALSE;
cdr.FirstSector = 1;
// BIOS player - set flag again
cdr.Play = TRUE;
- CDRPLAYSEEKREAD_INT(cdReadTime + seekTime, 1);
+ CDRPLAYREAD_INT(cdReadTime + seekTime, 1);
start_rotating = 1;
break;
StopReading();
SetPlaySeekRead(cdr.StatP, 0);
cdr.StatP &= ~STATUS_ROTATING;
+ cdr.LocL[0] = LOCL_INVALID;
second_resp_time = 0x800;
if (cdr.DriveState == DRIVESTATE_STANDBY)
StopCdda();
StopReading();
SetPlaySeekRead(cdr.StatP, 0);
+ cdr.LocL[0] = LOCL_INVALID;
cdr.Muted = FALSE;
cdr.Mode = 0x20; /* This fixes This is Football 2, Pooh's Party lockups */
second_resp_time = not_ready ? 70000 : 4100000;
break;
case CdlGetlocL:
+ if (cdr.LocL[0] == LOCL_INVALID) {
+ error = 0x80;
+ goto set_error;
+ }
SetResultSize(8);
- memcpy(cdr.Result, cdr.Transfer, 8);
+ memcpy(cdr.Result, cdr.LocL, 8);
break;
case CdlGetlocP:
case CdlSeekP:
StopCdda();
StopReading();
- SetPlaySeekRead(cdr.StatP, STATUS_SEEK);
+ SetPlaySeekRead(cdr.StatP, STATUS_SEEK | STATUS_ROTATING);
seekTime = cdrSeekTime(cdr.SetSector);
memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
Rockman X5 = 0.5-4x
- fix capcom logo
*/
- CDRPLAYSEEKREAD_INT(cdReadTime + seekTime, 1);
+ second_resp_time = cdReadTime + seekTime;
start_rotating = 1;
break;
+ case CdlSeekL + CMD_PART2:
+ case CdlSeekP + CMD_PART2:
+ SetPlaySeekRead(cdr.StatP, 0);
+ cdr.Result[0] = cdr.StatP;
+ cdr.Stat = Complete;
+
+ Find_CurTrack(cdr.SetSectorPlay);
+ read_ok = ReadTrack(cdr.SetSectorPlay);
+ if (read_ok && (buf = CDR_getBuffer()))
+ memcpy(cdr.LocL, buf, 8);
+ cdr.TrackChanged = FALSE;
+ break;
+
case CdlTest:
case CdlTest + CMD_WHILE_NOT_READY:
switch (cdr.Param[0]) {
case CdlReadToc:
case CdlReadToc + CMD_WHILE_NOT_READY:
+ cdr.LocL[0] = LOCL_INVALID;
second_resp_time = cdReadTime * 180 / 4;
start_rotating = 1;
break;
case CdlReadN:
case CdlReadS:
+ if (cdr.Reading && !cdr.SetlocPending)
+ break;
+
Find_CurTrack(cdr.SetlocPending ? cdr.SetSector : cdr.SetSectorPlay);
if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1)
// Fighting Force 2 - update subq time immediately
// - fixes new game
ReadTrack(cdr.SetSectorPlay);
+ cdr.LocL[0] = LOCL_INVALID;
- CDRPLAYSEEKREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime, 1);
+ cycles = (cdr.Mode & 0x80) ? cdReadTime : cdReadTime * 2;
+ cycles += seekTime;
+ cycles = cdrAlignTimingHack(cycles);
+ CDRPLAYREAD_INT(cycles, 1);
SetPlaySeekRead(cdr.StatP, STATUS_SEEK);
start_rotating = 1;
break;
+
case CdlSync:
default:
- CDR_LOG_I("Invalid command: %02x%s\n",
- Cmd, not_ready ? " (not_ready)" : "");
error = ERROR_INVALIDCMD;
// FALLTHROUGH
set_error:
+ CDR_LOG_I("cdrom: cmd %02x error %02x\n", Cmd, error);
SetResultSize(2);
cdr.Result[0] = cdr.StatP | STATUS_ERROR;
cdr.Result[1] = not_ready ? ERROR_NOTREADY : error;
}
if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) {
- printf("cdr.DriveState %d->%d\n", cdr.DriveState, DRIVESTATE_STANDBY);
cdr.DriveState = DRIVESTATE_STANDBY;
cdr.StatP |= STATUS_ROTATING;
}
static void cdrReadInterrupt(void)
{
u8 *buf = NULL, *hdr;
+ int read_ok;
SetPlaySeekRead(cdr.StatP, STATUS_READ | STATUS_ROTATING);
- ReadTrack(cdr.SetSectorPlay);
- if (cdr.NoErr)
+ read_ok = ReadTrack(cdr.SetSectorPlay);
+ if (read_ok)
buf = CDR_getBuffer();
if (buf == NULL)
- cdr.NoErr = 0;
+ read_ok = 0;
- if (!cdr.NoErr) {
+ if (!read_ok) {
CDR_LOG_I("cdrReadInterrupt() Log: err\n");
- memset(cdr.Transfer, 0, DATA_SIZE);
cdrReadInterruptSetResult(cdr.StatP | STATUS_ERROR);
return;
}
+ memcpy(cdr.LocL, buf, 8);
if (!cdr.Irq1Pending)
cdrUpdateTransferBuf(buf);
ReadTrack(cdr.SetSectorPlay);
}
- CDRPLAYSEEKREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0);
+ CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0);
}
/*
}
unsigned char cdrRead2(void) {
- unsigned char ret = 0;
+ unsigned char ret = cdr.Transfer[0x920];
if (cdr.FifoOffset < cdr.FifoSize)
ret = cdr.Transfer[cdr.FifoOffset++];
switch (chcr & 0x71000000) {
case 0x11000000:
ptr = (u8 *)PSXM(madr);
- if (ptr == NULL) {
+ if (ptr == INVALID_PTR) {
CDR_LOG_I("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n");
break;
}
{
memcpy(ptr, cdr.Transfer + cdr.FifoOffset, size);
cdr.FifoOffset += size;
- psxCpu->Clear(madr, size / 4);
}
- if (size < cdsize)
+ if (size < cdsize) {
CDR_LOG_I("cdrom: dma3 %d/%d\n", size, cdsize);
+ memset(ptr + size, cdr.Transfer[0x920], cdsize - size);
+ }
+ psxCpu->Clear(madr, cdsize / 4);
CDRDMA_INT((cdsize/4) * 24);
cdr.Channel = 1;
cdr.Reg2 = 0x1f;
cdr.Stat = NoIntr;
- cdr.DriveState = DRIVESTATE_STANDBY;
- cdr.StatP = STATUS_ROTATING;
cdr.FifoOffset = DATA_SIZE; // fifo empty
+ if (CdromId[0] == '\0') {
+ cdr.DriveState = DRIVESTATE_STOPPED;
+ cdr.StatP = 0;
+ }
+ else {
+ cdr.DriveState = DRIVESTATE_STANDBY;
+ cdr.StatP = STATUS_ROTATING;
+ }
// BIOS player - default values
cdr.AttenuatorLeftToLeft = 0x80;
if (Mode == 0) {
getCdInfo();
- cdr.FifoOffset = tmp;
+ cdr.FifoOffset = tmp < DATA_SIZE ? tmp : DATA_SIZE;
cdr.FifoSize = (cdr.Mode & 0x20) ? 2340 : 2048 + 12;
// read right sub data
if (!Config.Cdda)
CDR_play(cdr.SetSectorPlay);
if (psxRegs.interrupt & (1 << PSXINT_CDRPLAY_OLD))
- CDRPLAYSEEKREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime, 1);
+ CDRPLAYREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime, 1);
}
if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {