eliminate event code duplication

[pcsx_rearmed.git] / libpcsxcore / cdrom.c

diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c
index 28358bf..047172c 100644 (file)
--- a/libpcsxcore/cdrom.c
+++ b/libpcsxcore/cdrom.c
@@ -23,8 +23,10 @@
 
 #include <assert.h>
 #include "cdrom.h"
+#include "misc.h"
 #include "ppf.h"
 #include "psxdma.h"
+#include "psxevents.h"
 #include "arm_features.h"
 
 /* logging */
@@ -65,7 +67,9 @@ static struct {
                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];
@@ -109,7 +113,7 @@ static struct {
        u8 DriveState;
        u8 FastForward;
        u8 FastBackward;
-       u8 unused8;
+       u8 errorRetryhack;
 
        u8 AttenuatorLeftToLeft, AttenuatorLeftToRight;
        u8 AttenuatorRightToRight, AttenuatorRightToLeft;
@@ -239,14 +243,6 @@ static void sec2msf(unsigned int s, u8 *msf) {
        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; \
@@ -256,15 +252,7 @@ static void sec2msf(unsigned int s, u8 *msf) {
        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() { \
@@ -328,7 +316,7 @@ void cdrLidSeekInterrupt(void)
                {
                        memset(cdr.Prev, 0xff, sizeof(cdr.Prev));
                        cdr.DriveState = DRIVESTATE_LID_OPEN;
-                       CDRLID_INT(0x800);
+                       set_event(PSXINT_CDRLID, 0x800);
                }
                break;
 
@@ -344,7 +332,7 @@ void cdrLidSeekInterrupt(void)
                        // 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) {
@@ -358,12 +346,12 @@ void cdrLidSeekInterrupt(void)
                        // 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:
@@ -372,7 +360,7 @@ void cdrLidSeekInterrupt(void)
 
                // 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:
@@ -382,7 +370,7 @@ void cdrLidSeekInterrupt(void)
                }
                else {
                        SetPlaySeekRead(cdr.StatP, STATUS_SEEK);
-                       CDRLID_INT(cdReadTime * 26);
+                       set_event(PSXINT_CDRLID, cdReadTime * 26);
                }
                break;
        }
@@ -524,7 +512,9 @@ static void cdrPlayInterrupt_Autopause()
                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;
@@ -560,6 +550,9 @@ static void cdrPlayInterrupt_Autopause()
                SetResultSize(8);
                setIrq(0x1001);
        }
+
+       if (cdr.ReportDelay)
+               cdr.ReportDelay--;
 }
 
 // LastReadCycles
@@ -570,7 +563,7 @@ static int cdrSeekTime(unsigned char *target)
        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;
+       pausePenalty = (s32)(psxRegs.cycle - cdr.LastReadCycles) > cdReadTime * 8 ? cdReadTime * 25 : 0;
        seekTime += pausePenalty;
 
        seekTime = MIN_VALUE(seekTime, PSXCLK * 2 / 3);
@@ -624,6 +617,20 @@ static void msfiAdd(u8 *msfi, u32 count)
        }
 }
 
+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;
@@ -749,6 +756,8 @@ void cdrInterrupt(void) {
                        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;
                        }
@@ -759,6 +768,7 @@ void cdrInterrupt(void) {
                                memcpy(cdr.SetSector, set_loc, 3);
                                cdr.SetSector[3] = 0;
                                cdr.SetlocPending = 1;
+                               cdr.errorRetryhack = 0;
                        }
                        break;
 
@@ -814,6 +824,8 @@ void cdrInterrupt(void) {
                        cdr.SubqForwardSectors = 1;
                        cdr.TrackChanged = FALSE;
                        cdr.FirstSector = 1;
+                       cdr.ReportDelay = 60;
+                       cdr.sectorsRead = 0;
 
                        if (!Config.Cdda)
                                CDR_play(cdr.SetSectorPlay);
@@ -887,6 +899,12 @@ void cdrInterrupt(void) {
                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
@@ -1109,7 +1127,7 @@ void cdrInterrupt(void) {
                        // 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;
 
@@ -1154,6 +1172,7 @@ void cdrInterrupt(void) {
                        UpdateSubq(cdr.SetSectorPlay);
                        cdr.LocL[0] = LOCL_INVALID;
                        cdr.SubqForwardSectors = 1;
+                       cdr.sectorsRead = 0;
 
                        cycles = (cdr.Mode & MODE_SPEED) ? cdReadTime : cdReadTime * 2;
                        cycles += seekTime;
@@ -1186,7 +1205,7 @@ void cdrInterrupt(void) {
 
        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;
@@ -1276,7 +1295,8 @@ static void cdrUpdateTransferBuf(const u8 *buf)
                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);
 }
@@ -1298,6 +1318,7 @@ 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)
@@ -1433,7 +1454,7 @@ void cdrWrite1(unsigned char rt) {
        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",
@@ -1514,7 +1535,7 @@ void cdrWrite3(unsigned char rt) {
                                        c = 2048 - (psxRegs.cycle - nextCycle);
                                        c = MAX_VALUE(c, 512);
                                }
-                               CDR_INT(c);
+                               set_event(PSXINT_CDR, c);
                        }
                }
                cdr.Stat &= ~rt;
@@ -1604,7 +1625,7 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) {
                        }
                        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) {