#include <assert.h>
#include "cdrom.h"
+#include "misc.h"
#include "ppf.h"
#include "psxdma.h"
+#include "psxevents.h"
#include "arm_features.h"
/* logging */
#if 0
#define CDR_LOG_I SysPrintf
#else
-#define CDR_LOG_I log_unhandled
+#define CDR_LOG_I(fmt, ...) \
+ log_unhandled("%u cdrom: " fmt, psxRegs.cycle, ##__VA_ARGS__)
#endif
#if 0
#define CDR_LOG_IO SysPrintf
unsigned char Absolute[3];
} subq;
unsigned char TrackChanged;
- unsigned char unused3[3];
+ unsigned char ReportDelay;
+ unsigned char unused3;
+ unsigned short sectorsRead;
unsigned int freeze_ver;
unsigned char Prev[4];
u16 CmdInProgress;
u8 Irq1Pending;
u8 unused5;
- u32 unused6;
+ u32 LastReadSeekCycles;
u8 unused7;
u8 DriveState;
u8 FastForward;
u8 FastBackward;
- u8 unused8;
+ u8 errorRetryhack;
u8 AttenuatorLeftToLeft, AttenuatorLeftToRight;
u8 AttenuatorRightToRight, AttenuatorRightToLeft;
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() { \
if (cdr.Stat)
{
int i;
- SysPrintf("%u cdrom: CDR IRQ=%d cmd %02x stat %02x: ",
- psxRegs.cycle, !!(cdr.Stat & cdr.Reg2), log_cmd, cdr.Stat);
+ CDR_LOG_I("CDR IRQ=%d cmd %02x stat %02x: ",
+ !!(cdr.Stat & cdr.Reg2), log_cmd, cdr.Stat);
for (i = 0; i < cdr.ResultC; i++)
SysPrintf("%02x ", cdr.Result[i]);
SysPrintf("\n");
// (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);
+ CDR_LOG_I("%s cdr.DriveState=%d\n", __func__, cdr.DriveState);
switch (cdr.DriveState) {
default:
{
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;
}
StopCdda();
SetPlaySeekRead(cdr.StatP, 0);
}
- else if (((cdr.Mode & MODE_REPORT) || cdr.FastForward || cdr.FastBackward)) {
+ else if ((cdr.Mode & MODE_REPORT) && !cdr.ReportDelay &&
+ ((cdr.subq.Absolute[2] & 0x0f) == 0 || cdr.FastForward || cdr.FastBackward))
+ {
cdr.Result[0] = cdr.StatP;
cdr.Result[1] = cdr.subq.Track;
cdr.Result[2] = cdr.subq.Index;
SetResultSize(8);
setIrq(0x1001);
}
+
+ if (cdr.ReportDelay)
+ cdr.ReportDelay--;
}
static int cdrSeekTime(unsigned char *target)
{
int diff = msf2sec(cdr.SetSectorPlay) - msf2sec(target);
- int seekTime = abs(diff) * (cdReadTime / 200);
- /*
- * Gameblabla :
- * It was originally set to 1000000 for Driver, however it is not high enough for Worms Pinball
- * and was unreliable for that game.
- * I also tested it against Mednafen and Driver's titlescreen music starts 25 frames later, not immediatly.
- *
- * Obviously, this isn't perfect but right now, it should be a bit better.
- * Games to test this against if you change that setting :
- * - Driver (titlescreen music delay and retry mission)
- * - Worms Pinball (Will either not boot or crash in the memory card screen)
- * - Viewpoint (short pauses if the delay in the ingame music is too long)
- *
- * It seems that 3386880 * 5 is too much for Driver's titlescreen and it starts skipping.
- * However, 1000000 is not enough for Worms Pinball to reliably boot.
- */
- if(seekTime > 3386880 * 2) seekTime = 3386880 * 2;
+ int seekTime = abs(diff) * (cdReadTime / 2000);
+ seekTime = MAX_VALUE(seekTime, 20000);
+
+ // need this stupidly long penalty or else Spyro2 intro desyncs
+ 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);
return seekTime;
}
}
}
+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.LastReadSeekCycles = psxRegs.cycle;
+
if (cdr.Reading) {
cdrReadInterrupt();
return;
int i;
if (cdr.Stat) {
- CDR_LOG_I("%u cdrom: cmd %02x with irqstat %x\n",
- psxRegs.cycle, cdr.CmdInProgress, cdr.Stat);
+ CDR_LOG_I("cmd %02x with irqstat %x\n",
+ cdr.CmdInProgress, cdr.Stat);
return;
}
if (cdr.Irq1Pending) {
// hand out the "newest" sector, according to nocash
cdrUpdateTransferBuf(CDR_getBuffer());
- CDR_LOG_I("cdrom: %x:%02x:%02x loaded on ack\n",
- cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]);
+ CDR_LOG_I("%x:%02x:%02x loaded on ack, cmd=%02x res=%02x\n",
+ cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2],
+ cdr.CmdInProgress, cdr.Irq1Pending);
SetResultSize(1);
cdr.Result[0] = cdr.Irq1Pending;
cdr.Stat = (cdr.Irq1Pending & STATUS_ERROR) ? DiskError : DataReady;
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_I("Invalid/out of range seek to %02X:%02X:%02X\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
+ if (++cdr.errorRetryhack > 100)
+ break;
error = ERROR_INVALIDARG;
goto set_error;
}
memcpy(cdr.SetSector, set_loc, 3);
cdr.SetSector[3] = 0;
cdr.SetlocPending = 1;
+ cdr.errorRetryhack = 0;
}
break;
cdr.SubqForwardSectors = 1;
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
}
else
{
- second_resp_time = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * 1000000);
+ second_resp_time = (((cdr.Mode & MODE_SPEED) ? 1 : 2) * 1097107);
}
SetPlaySeekRead(cdr.StatP, 0);
break;
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;
// FALLTHROUGH
set_error:
- CDR_LOG_I("cdrom: cmd %02x error %02x\n", Cmd, error);
+ CDR_LOG_I("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 (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;
- CDR_LOG_I("%u cdrom: cmd %02x came before %02x finished\n",
- psxRegs.cycle, cdr.Cmd, Cmd);
+ CDR_LOG_I("cmd %02x came before %02x finished\n", cdr.Cmd, Cmd);
}
setIrq(Cmd);
static void cdrReadInterruptSetResult(unsigned char result)
{
if (cdr.Stat) {
- CDR_LOG_I("cdrom: %d:%02d:%02d irq miss, cmd=%02x irqstat=%02x\n",
+ CDR_LOG_I("%d:%02d:%02d irq miss, cmd=%02x irqstat=%02x\n",
cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2],
cdr.CmdInProgress, cdr.Stat);
cdr.Irq1Pending = result;
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("cdrom: FifoOffset(1) %d/%d\n", cdr.FifoOffset, cdr.FifoSize);
+ CDR_LOG("FifoOffset(1) %d/%d\n", cdr.FifoOffset, cdr.FifoSize);
}
static void cdrReadInterrupt(void)
// 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)
}
memcpy(cdr.LocL, buf, 8);
- if (!cdr.Irq1Pending)
+ if (!cdr.Stat && !cdr.Irq1Pending)
cdrUpdateTransferBuf(buf);
if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA
}
#ifdef CDR_LOG_CMD_IRQ
- SysPrintf("%u cdrom: CD1 write: %x (%s)", psxRegs.cycle, rt, CmdName[rt]);
+ CDR_LOG_I("CD1 write: %x (%s)", rt, CmdName[rt]);
if (cdr.ParamC) {
int i;
SysPrintf(" Param[%d] = {", cdr.ParamC);
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("%u cdrom: cmd while busy: %02x, prev %02x, busy %02x\n",
- psxRegs.cycle, rt, cdr.Cmd, cdr.CmdInProgress);
+ CDR_LOG_I("cmd while busy: %02x, prev %02x, busy %02x\n",
+ rt, cdr.Cmd, cdr.CmdInProgress);
if (cdr.CmdInProgress < 0x100) // no pending 2nd response
cdr.CmdInProgress = rt;
}
if (cdr.FifoOffset < cdr.FifoSize)
ret = cdr.Transfer[cdr.FifoOffset++];
else
- CDR_LOG_I("cdrom: read empty fifo (%d)\n", cdr.FifoSize);
+ CDR_LOG_I("read empty fifo (%d)\n", cdr.FifoSize);
CDR_LOG_IO("cdr r2.dat: %02x\n", ret);
return ret;
if (cdr.Stat & rt) {
u32 nextCycle = psxRegs.intCycle[PSXINT_CDR].sCycle
+ psxRegs.intCycle[PSXINT_CDR].cycle;
+ int pending = psxRegs.interrupt & (1 << PSXINT_CDR);
#ifdef CDR_LOG_CMD_IRQ
- SysPrintf("%u cdrom: ack %02x (w=%02x p=%d,%d)\n",
- psxRegs.cycle, cdr.Stat & rt, rt,
- !!(psxRegs.interrupt & (1 << PSXINT_CDR)),
- nextCycle - psxRegs.cycle);
+ CDR_LOG_I("ack %02x (w=%02x p=%d,%x,%x,%d)\n", cdr.Stat & rt, rt,
+ !!pending, cdr.CmdInProgress,
+ cdr.Irq1Pending, nextCycle - psxRegs.cycle);
#endif
// note: Croc, Shadow Tower (more) vs Discworld Noir (<993)
- if (!(psxRegs.interrupt & (1 << PSXINT_CDR)) &&
- (cdr.CmdInProgress || cdr.Irq1Pending))
+ if (!pending && (cdr.CmdInProgress || cdr.Irq1Pending))
{
- s32 c = 2048 - (psxRegs.cycle - nextCycle);
- c = MAX_VALUE(c, 512);
- CDR_INT(c);
+ s32 c = 2048;
+ if (cdr.CmdInProgress) {
+ c = 2048 - (psxRegs.cycle - nextCycle);
+ c = MAX_VALUE(c, 512);
+ }
+ set_event(PSXINT_CDR, c);
}
}
cdr.Stat &= ~rt;
}
void psxDma3(u32 madr, u32 bcr, u32 chcr) {
- u32 cdsize;
+ u32 cdsize, max_words;
int size;
u8 *ptr;
- CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr);
+#if 0
+ CDR_LOG_I("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x", chcr, madr, bcr);
+ if (cdr.FifoOffset == 0) {
+ ptr = cdr.Transfer;
+ SysPrintf(" %02x:%02x:%02x", ptr[0], ptr[1], ptr[2]);
+ }
+ SysPrintf("\n");
+#endif
switch (chcr & 0x71000000) {
case 0x11000000:
- ptr = (u8 *)PSXM(madr);
+ ptr = getDmaRam(madr, &max_words);
if (ptr == INVALID_PTR) {
CDR_LOG_I("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n");
break;
size = DATA_SIZE - cdr.FifoOffset;
if (size > cdsize)
size = cdsize;
+ if (size > max_words * 4)
+ size = max_words * 4;
if (size > 0)
{
memcpy(ptr, cdr.Transfer + cdr.FifoOffset, size);
}
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) {
Find_CurTrack(cdr.SetSectorPlay);
if (!Config.Cdda)
CDR_play(cdr.SetSectorPlay);
- if (psxRegs.interrupt & (1 << PSXINT_CDRPLAY_OLD))
- CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 1);
}
if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {
notaz.gp2x.de / pcsx_rearmed.git / blobdiff