#include <assert.h>
#include "cdrom.h"
+#include "misc.h"
#include "ppf.h"
#include "psxdma.h"
+#include "psxevents.h"
#include "arm_features.h"
/* logging */
} subq;
unsigned char TrackChanged;
unsigned char ReportDelay;
- unsigned char unused3[2];
+ unsigned char unused3;
+ unsigned short sectorsRead;
unsigned int freeze_ver;
unsigned char Prev[4];
u16 CmdInProgress;
u8 Irq1Pending;
u8 unused5;
- u32 LastReadCycles;
+ u32 LastReadSeekCycles;
u8 unused7;
msf[2] = s;
}
-// cdrInterrupt
-#define CDR_INT(eCycle) { \
- psxRegs.interrupt |= (1 << PSXINT_CDR); \
- psxRegs.intCycle[PSXINT_CDR].cycle = eCycle; \
- psxRegs.intCycle[PSXINT_CDR].sCycle = psxRegs.cycle; \
- new_dyna_set_event(PSXINT_CDR, eCycle); \
-}
-
// cdrPlayReadInterrupt
#define CDRPLAYREAD_INT(eCycle, isFirst) { \
u32 e_ = eCycle; \
else \
psxRegs.intCycle[PSXINT_CDREAD].sCycle += psxRegs.intCycle[PSXINT_CDREAD].cycle; \
psxRegs.intCycle[PSXINT_CDREAD].cycle = e_; \
- new_dyna_set_event_abs(PSXINT_CDREAD, psxRegs.intCycle[PSXINT_CDREAD].sCycle + e_); \
-}
-
-// cdrLidSeekInterrupt
-#define CDRLID_INT(eCycle) { \
- psxRegs.interrupt |= (1 << PSXINT_CDRLID); \
- psxRegs.intCycle[PSXINT_CDRLID].cycle = eCycle; \
- psxRegs.intCycle[PSXINT_CDRLID].sCycle = psxRegs.cycle; \
- new_dyna_set_event(PSXINT_CDRLID, eCycle); \
+ set_event_raw_abs(PSXINT_CDREAD, psxRegs.intCycle[PSXINT_CDREAD].sCycle + e_); \
}
#define StopReading() { \
{
memset(cdr.Prev, 0xff, sizeof(cdr.Prev));
cdr.DriveState = DRIVESTATE_LID_OPEN;
- CDRLID_INT(0x800);
+ set_event(PSXINT_CDRLID, 0x800);
}
break;
// only sometimes does that
// (not done when lots of commands are sent?)
- CDRLID_INT(cdReadTime * 30);
+ set_event(PSXINT_CDRLID, cdReadTime * 30);
break;
}
else if (cdr.StatP & STATUS_ROTATING) {
// and is only cleared by CdlNop
cdr.DriveState = DRIVESTATE_RESCAN_CD;
- CDRLID_INT(cdReadTime * 105);
+ set_event(PSXINT_CDRLID, cdReadTime * 105);
break;
}
// recheck for close
- CDRLID_INT(cdReadTime * 3);
+ set_event(PSXINT_CDRLID, cdReadTime * 3);
break;
case DRIVESTATE_RESCAN_CD:
// this is very long on real hardware, over 6 seconds
// make it a bit faster here...
- CDRLID_INT(cdReadTime * 150);
+ set_event(PSXINT_CDRLID, cdReadTime * 150);
break;
case DRIVESTATE_PREPARE_CD:
}
else {
SetPlaySeekRead(cdr.StatP, STATUS_SEEK);
- CDRLID_INT(cdReadTime * 26);
+ set_event(PSXINT_CDRLID, cdReadTime * 26);
}
break;
}
static void UpdateSubq(const u8 *time)
{
const struct SubQ *subq;
+ int s = MSF2SECT(time[0], time[1], time[2]);
u16 crc;
- if (CheckSBI(time))
+ if (CheckSBI(s))
return;
- subq = (struct SubQ *)CDR_getBufferSub(MSF2SECT(time[0], time[1], time[2]));
+ subq = (struct SubQ *)CDR_getBufferSub(s);
if (subq != NULL && cdr.CurTrack == 1) {
crc = calcCrc((u8 *)subq + 12, 10);
if (crc == (((u16)subq->CRC[0] << 8) | subq->CRC[1])) {
cdr.ReportDelay--;
}
-// LastReadCycles
static int cdrSeekTime(unsigned char *target)
{
int diff = msf2sec(cdr.SetSectorPlay) - msf2sec(target);
- int pausePenalty, seekTime = abs(diff) * (cdReadTime / 2000);
+ int seekTime = abs(diff) * (cdReadTime / 2000);
seekTime = MAX_VALUE(seekTime, 20000);
// need this stupidly long penalty or else Spyro2 intro desyncs
- pausePenalty = (s32)(psxRegs.cycle - cdr.LastReadCycles) > cdReadTime * 4 ? cdReadTime * 25 : 0;
- seekTime += pausePenalty;
+ if ((s32)(psxRegs.cycle - cdr.LastReadSeekCycles) > cdReadTime * 8)
+ seekTime += cdReadTime * 25;
seekTime = MIN_VALUE(seekTime, PSXCLK * 2 / 3);
CDR_LOG("seek: %.2f %.2f\n", (float)seekTime / PSXCLK, (float)seekTime / cdReadTime);
}
}
+static void msfiSub(u8 *msfi, u32 count)
+{
+ assert(count < 75);
+ msfi[2] -= count;
+ if ((s8)msfi[2] < 0) {
+ msfi[2] += 75;
+ msfi[1]--;
+ if ((s8)msfi[1] < 0) {
+ msfi[1] = 60;
+ msfi[0]--;
+ }
+ }
+}
+
void cdrPlayReadInterrupt(void)
{
- cdr.LastReadCycles = psxRegs.cycle;
+ cdr.LastReadSeekCycles = psxRegs.cycle;
if (cdr.Reading) {
cdrReadInterrupt();
cdr.TrackChanged = FALSE;
cdr.FirstSector = 1;
cdr.ReportDelay = 60;
+ cdr.sectorsRead = 0;
if (!Config.Cdda)
CDR_play(cdr.SetSectorPlay);
case CdlPause:
StopCdda();
StopReading();
+
+ // how the drive maintains the position while paused is quite
+ // complicated, this is the minimum to make "Bedlam" happy
+ msfiSub(cdr.SetSectorPlay, MIN_VALUE(cdr.sectorsRead, 4));
+ cdr.sectorsRead = 0;
+
/*
Gundam Battle Assault 2: much slower (*)
- Fixes boot, gameplay
memcpy(cdr.LocL, buf, 8);
UpdateSubq(cdr.SetSectorPlay);
cdr.TrackChanged = FALSE;
+ cdr.LastReadSeekCycles = psxRegs.cycle;
break;
case CdlTest:
// yes, it really sets STATUS_SHELLOPEN
cdr.StatP |= STATUS_SHELLOPEN;
cdr.DriveState = DRIVESTATE_RESCAN_CD;
- CDRLID_INT(20480);
+ set_event(PSXINT_CDRLID, 20480);
start_rotating = 1;
break;
UpdateSubq(cdr.SetSectorPlay);
cdr.LocL[0] = LOCL_INVALID;
cdr.SubqForwardSectors = 1;
+ cdr.sectorsRead = 0;
cycles = (cdr.Mode & MODE_SPEED) ? cdReadTime : cdReadTime * 2;
cycles += seekTime;
if (second_resp_time) {
cdr.CmdInProgress = Cmd | 0x100;
- CDR_INT(second_resp_time);
+ set_event(PSXINT_CDR, second_resp_time);
}
else if (cdr.Cmd && cdr.Cmd != (Cmd & 0xff)) {
cdr.CmdInProgress = cdr.Cmd;
return;
memcpy(cdr.Transfer, buf, DATA_SIZE);
CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]);
- CDR_LOG("cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]);
+ CDR_LOG("cdr.Transfer %02x:%02x:%02x\n",
+ cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]);
if (cdr.FifoOffset < 2048 + 12)
CDR_LOG("FifoOffset(1) %d/%d\n", cdr.FifoOffset, cdr.FifoSize);
}
// note: CdlGetlocL should work as soon as STATUS_READ is indicated
SetPlaySeekRead(cdr.StatP, STATUS_READ | STATUS_ROTATING);
+ cdr.sectorsRead++;
read_ok = ReadTrack(cdr.SetSectorPlay);
if (read_ok)
if (!cdr.CmdInProgress) {
cdr.CmdInProgress = rt;
// should be something like 12k + controller delays
- CDR_INT(5000);
+ set_event(PSXINT_CDR, 5000);
}
else {
CDR_LOG_I("cmd while busy: %02x, prev %02x, busy %02x\n",
c = 2048 - (psxRegs.cycle - nextCycle);
c = MAX_VALUE(c, 512);
}
- CDR_INT(c);
+ set_event(PSXINT_CDR, c);
}
}
cdr.Stat &= ~rt;
}
psxCpu->Clear(madr, cdsize / 4);
- CDRDMA_INT((cdsize/4) * 24);
+ set_event(PSXINT_CDRDMA, (cdsize / 4) * 24);
HW_DMA3_CHCR &= SWAPu32(~0x10000000);
if (chcr & 0x100) {