X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=libpcsxcore%2Fcdrom.c;h=047172ce6842c940c18c60002b84e839f05f6670;hb=9a0a61d27586bfb93aa443cc59d9588d2b9cf992;hp=07b13649c49c04888de27058480c3277a36e9f10;hpb=e9b207f1b9c79001aaa75abfc4cec353f006a57d;p=pcsx_rearmed.git diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c index 07b13649..047172ce 100644 --- a/libpcsxcore/cdrom.c +++ b/libpcsxcore/cdrom.c @@ -21,9 +21,12 @@ * Handles all CD-ROM registers and functions. */ +#include #include "cdrom.h" +#include "misc.h" #include "ppf.h" #include "psxdma.h" +#include "psxevents.h" #include "arm_features.h" /* logging */ @@ -35,7 +38,8 @@ #if 0 #define CDR_LOG_I SysPrintf #else -#define CDR_LOG_I(...) +#define CDR_LOG_I(fmt, ...) \ + log_unhandled("%u cdrom: " fmt, psxRegs.cycle, ##__VA_ARGS__) #endif #if 0 #define CDR_LOG_IO SysPrintf @@ -45,10 +49,11 @@ //#define CDR_LOG_CMD_IRQ static struct { - unsigned char OCUP; - unsigned char Reg1Mode; + // unused members maintain savesate compatibility + unsigned char unused0; + unsigned char unused1; unsigned char Reg2; - unsigned char CmdProcess; + unsigned char unused2; unsigned char Ctrl; unsigned char Stat; @@ -62,7 +67,9 @@ static struct { unsigned char Absolute[3]; } subq; unsigned char TrackChanged; - unsigned char pad1[3]; + unsigned char ReportDelay; + unsigned char unused3; + unsigned short sectorsRead; unsigned int freeze_ver; unsigned char Prev[4]; @@ -75,7 +82,7 @@ static struct { unsigned char ResultP; unsigned char ResultReady; unsigned char Cmd; - unsigned char Readed; + unsigned char SubqForwardSectors; unsigned char SetlocPending; u32 Reading; @@ -88,31 +95,31 @@ static struct { boolean Play, Muted; int CurTrack; int Mode, File, Channel; - int Reset; - int NoErr; + unsigned char LocL[8]; int FirstSector; xa_decode_t Xa; - int Init; + u16 FifoOffset; + u16 FifoSize; - u16 Irq; - u8 IrqRepeated; - u32 eCycle; + u16 CmdInProgress; + u8 Irq1Pending; + u8 unused5; + u32 LastReadCycles; - u8 pad2; + u8 unused7; u8 DriveState; u8 FastForward; u8 FastBackward; - u8 pad; + u8 errorRetryhack; u8 AttenuatorLeftToLeft, AttenuatorLeftToRight; u8 AttenuatorRightToRight, AttenuatorRightToLeft; u8 AttenuatorLeftToLeftT, AttenuatorLeftToRightT; u8 AttenuatorRightToRightT, AttenuatorRightToLeftT; } cdr; -static unsigned char *pTransfer; static s16 read_buf[CD_FRAMESIZE_RAW/2]; /* CD-ROM magic numbers */ @@ -206,6 +213,9 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 }; // so (PSXCLK / 75) = cdr read time (linuzappz) #define cdReadTime (PSXCLK / 75) +#define LOCL_INVALID 0xff +#define SUBQ_FORWARD_SECTORS 2u + enum drive_state { DRIVESTATE_STANDBY = 0, // pause, play, read DRIVESTATE_LID_OPEN, @@ -233,28 +243,16 @@ 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); \ -} - -// cdrPlaySeekReadInterrupt -#define CDRPLAYSEEKREAD_INT(eCycle) { \ +// cdrPlayReadInterrupt +#define CDRPLAYREAD_INT(eCycle, isFirst) { \ + u32 e_ = eCycle; \ psxRegs.interrupt |= (1 << PSXINT_CDREAD); \ - psxRegs.intCycle[PSXINT_CDREAD].cycle = eCycle; \ - psxRegs.intCycle[PSXINT_CDREAD].sCycle = psxRegs.cycle; \ - new_dyna_set_event(PSXINT_CDREAD, eCycle); \ -} - -// 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); \ + if (isFirst) \ + psxRegs.intCycle[PSXINT_CDREAD].sCycle = psxRegs.cycle; \ + else \ + psxRegs.intCycle[PSXINT_CDREAD].sCycle += psxRegs.intCycle[PSXINT_CDREAD].cycle; \ + psxRegs.intCycle[PSXINT_CDREAD].cycle = e_; \ + set_event_raw_abs(PSXINT_CDREAD, psxRegs.intCycle[PSXINT_CDREAD].sCycle + e_); \ } #define StopReading() { \ @@ -286,9 +284,10 @@ static void setIrq(int log_cmd) psxHu32ref(0x1070) |= SWAP32((u32)0x4); #ifdef CDR_LOG_CMD_IRQ + if (cdr.Stat) { int i; - SysPrintf("CDR IRQ=%d cmd %02x stat %02x: ", + 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]); @@ -301,6 +300,8 @@ static void setIrq(int log_cmd) // (yes it's slow, but you probably don't want to modify it) void cdrLidSeekInterrupt(void) { + CDR_LOG_I("%s cdr.DriveState=%d\n", __func__, cdr.DriveState); + switch (cdr.DriveState) { default: case DRIVESTATE_STANDBY: @@ -313,8 +314,9 @@ void cdrLidSeekInterrupt(void) if (stat.Status & STATUS_SHELLOPEN) { + memset(cdr.Prev, 0xff, sizeof(cdr.Prev)); cdr.DriveState = DRIVESTATE_LID_OPEN; - CDRLID_INT(0x800); + set_event(PSXINT_CDRLID, 0x800); } break; @@ -330,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) { @@ -344,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: @@ -358,14 +360,18 @@ 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: - 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); + set_event(PSXINT_CDRLID, cdReadTime * 26); + } break; } } @@ -433,27 +439,35 @@ static void generate_subq(const u8 *time) 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; - u16 crc; + int read_ok; tmp[0] = itob(time[0]); tmp[1] = itob(time[1]); 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); + return read_ok; +} + +static void UpdateSubq(const u8 *time) +{ + const struct SubQ *subq; + u16 crc; if (CheckSBI(time)) return; - subq = (struct SubQ *)CDR_getBufferSub(); + subq = (struct SubQ *)CDR_getBufferSub(MSF2SECT(time[0], time[1], time[2])); if (subq != NULL && cdr.CurTrack == 1) { crc = calcCrc((u8 *)subq + 12, 10); if (crc == (((u16)subq->CRC[0] << 8) | subq->CRC[1])) { @@ -463,8 +477,8 @@ static void ReadTrack(const u8 *time) { memcpy(cdr.subq.Absolute, subq->AbsoluteAddress, 3); } else { - CDR_LOG_I("subq bad crc @%02x:%02x:%02x\n", - tmp[0], tmp[1], tmp[2]); + CDR_LOG_I("subq bad crc @%02d:%02d:%02d\n", + time[0], time[1], time[2]); } } else { @@ -477,23 +491,6 @@ static void ReadTrack(const u8 *time) { cdr.subq.Absolute[0], cdr.subq.Absolute[1], cdr.subq.Absolute[2]); } -static void AddIrqQueue(unsigned short irq, unsigned long ecycle) { - if (cdr.Irq != 0) { - if (irq == cdr.Irq || irq + 0x100 == cdr.Irq) { - cdr.IrqRepeated = 1; - CDR_INT(ecycle); - return; - } - - CDR_LOG_I("cdr: override cmd %02x -> %02x\n", cdr.Irq, irq); - } - - cdr.Irq = irq; - cdr.eCycle = ecycle; - - CDR_INT(ecycle); -} - static void cdrPlayInterrupt_Autopause() { u32 abs_lev_max = 0; @@ -510,12 +507,14 @@ static void cdrPlayInterrupt_Autopause() //cdr.ResultReady = 1; //cdr.Stat = DataReady; cdr.Stat = DataEnd; - setIrq(0x200); + setIrq(0x1000); // 0x1000 just for logging purposes 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; @@ -549,60 +548,95 @@ static void cdrPlayInterrupt_Autopause() cdr.Stat = DataReady; SetResultSize(8); - setIrq(0x201); + setIrq(0x1001); } + + if (cdr.ReportDelay) + cdr.ReportDelay--; } +// LastReadCycles static int cdrSeekTime(unsigned char *target) { - int seekTime = abs(msf2sec(cdr.SetSectorPlay) - msf2sec(target)) * (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 diff = msf2sec(cdr.SetSectorPlay) - msf2sec(target); + int pausePenalty, 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 * 8 ? cdReadTime * 25 : 0; + seekTime += pausePenalty; + + seekTime = MIN_VALUE(seekTime, PSXCLK * 2 / 3); CDR_LOG("seek: %.2f %.2f\n", (float)seekTime / PSXCLK, (float)seekTime / cdReadTime); 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. + * + * Note: always enforcing this breaks other games like Crash PAL version + * (inputs get dropped because bios handler doesn't see interrupts). + */ + u32 vint_rel; + if (psxRegs.cycle - rcnts[3].cycleStart > 250000) + return cycles; + 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) +static void msfiAdd(u8 *msfi, u32 count) { - if (cdr.Reading) { - cdrReadInterrupt(); - return; + assert(count < 75); + msfi[2] += count; + if (msfi[2] >= 75) { + msfi[2] -= 75; + msfi[1]++; + if (msfi[1] == 60) { + msfi[1] = 0; + msfi[0]++; + } } +} - if (!cdr.Play && (cdr.StatP & STATUS_SEEK)) { - if (cdr.Stat) { - CDR_LOG_I("cdrom: seek stat hack\n"); - CDRPLAYSEEKREAD_INT(0x1000); - return; - } - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - SetPlaySeekRead(cdr.StatP, 0); - cdr.Result[0] = cdr.StatP; - if (cdr.Irq == 0) { - cdr.Stat = Complete; - setIrq(0x202); +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; - Find_CurTrack(cdr.SetSectorPlay); - ReadTrack(cdr.SetSectorPlay); - cdr.TrackChanged = FALSE; + if (cdr.Reading) { + cdrReadInterrupt(); return; } @@ -621,79 +655,109 @@ void cdrPlaySeekReadInterrupt(void) CDR_readCDDA(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], (u8 *)read_buf); } - if (!cdr.Irq && !cdr.Stat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT))) + if (!cdr.Stat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT))) cdrPlayInterrupt_Autopause(); - if (CDR_readCDDA && !cdr.Muted && !Config.Cdda) { + if (!cdr.Muted && !Config.Cdda) { + cdrPrepCdda(read_buf, CD_FRAMESIZE_RAW / 4); cdrAttenuate(read_buf, CD_FRAMESIZE_RAW / 4, 1); - if (SPU_playCDDAchannel) - SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW); - } - - cdr.SetSectorPlay[2]++; - if (cdr.SetSectorPlay[2] == 75) { - cdr.SetSectorPlay[2] = 0; - cdr.SetSectorPlay[1]++; - if (cdr.SetSectorPlay[1] == 60) { - cdr.SetSectorPlay[1] = 0; - cdr.SetSectorPlay[0]++; - } + SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW, psxRegs.cycle, cdr.FirstSector); + cdr.FirstSector = 0; } - CDRPLAYSEEKREAD_INT(cdReadTime); + msfiAdd(cdr.SetSectorPlay, 1); // update for CdlGetlocP/autopause generate_subq(cdr.SetSectorPlay); + + CDRPLAYREAD_INT(cdReadTime, 0); } +#define CMD_PART2 0x100 +#define CMD_WHILE_NOT_READY 0x200 + void cdrInterrupt(void) { - u16 Irq = cdr.Irq; - int no_busy_error = 0; int start_rotating = 0; int error = 0; - int delay; - 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; - // Reschedule IRQ if (cdr.Stat) { - CDR_LOG_I("cdrom: stat hack: %02x %x\n", cdr.Irq, cdr.Stat); - CDR_INT(0x1000); + 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("%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; + cdr.Irq1Pending = 0; + setIrq(0x1003); return; } - - cdr.Ctrl &= ~0x80; // default response SetResultSize(1); cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; - if (cdr.IrqRepeated) { - cdr.IrqRepeated = 0; - if (cdr.eCycle > psxRegs.cycle) { - CDR_INT(cdr.eCycle); - goto finish; - } + Cmd = cdr.CmdInProgress; + cdr.CmdInProgress = 0; + ParamC = cdr.ParamC; + + if (Cmd < 0x100) { + cdr.Ctrl &= ~0x80; + cdr.ParamC = 0; + cdr.Cmd = 0; } - cdr.Irq = 0; + 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: + // no disk or busy with the initial scan, allowed cmds are limited + not_ready = CMD_WHILE_NOT_READY; + break; + } - switch (Irq) { + switch (Cmd | not_ready) { case CdlNop: + case CdlNop + CMD_WHILE_NOT_READY: if (cdr.DriveState != DRIVESTATE_LID_OPEN) cdr.StatP &= ~STATUS_SHELLOPEN; - no_busy_error = 1; break; case CdlSetloc: + case CdlSetloc + CMD_WHILE_NOT_READY: CDR_LOG("CDROM setloc command (%02X, %02X, %02X)\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]); // 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]); + if (++cdr.errorRetryhack > 100) + break; error = ERROR_INVALIDARG; goto set_error; } @@ -704,6 +768,7 @@ void cdrInterrupt(void) { memcpy(cdr.SetSector, set_loc, 3); cdr.SetSector[3] = 0; cdr.SetlocPending = 1; + cdr.errorRetryhack = 0; } break; @@ -718,7 +783,7 @@ void cdrInterrupt(void) { // BIOS CD Player // - Pause player, hit Track 01/02/../xx (Setloc issued!!) - if (cdr.ParamC != 0 && cdr.Param[0] != 0) { + if (ParamC != 0 && cdr.Param[0] != 0) { int track = btoi( cdr.Param[0] ); if (track <= cdr.ResultTN[1]) @@ -754,8 +819,13 @@ void cdrInterrupt(void) { - plays tracks without retry play */ Find_CurTrack(cdr.SetSectorPlay); - ReadTrack(cdr.SetSectorPlay); + generate_subq(cdr.SetSectorPlay); + cdr.LocL[0] = LOCL_INVALID; + cdr.SubqForwardSectors = 1; cdr.TrackChanged = FALSE; + cdr.FirstSector = 1; + cdr.ReportDelay = 60; + cdr.sectorsRead = 0; if (!Config.Cdda) CDR_play(cdr.SetSectorPlay); @@ -765,7 +835,7 @@ void cdrInterrupt(void) { // BIOS player - set flag again cdr.Play = TRUE; - CDRPLAYSEEKREAD_INT(cdReadTime + seekTime); + CDRPLAYREAD_INT(cdReadTime + seekTime, 1); start_rotating = 1; break; @@ -791,11 +861,11 @@ void cdrInterrupt(void) { error = ERROR_INVALIDARG; goto set_error; } - AddIrqQueue(CdlStandby + 0x100, cdReadTime * 125 / 2); + second_resp_time = cdReadTime * 125 / 2; start_rotating = 1; break; - case CdlStandby + 0x100: + case CdlStandby + CMD_PART2: cdr.Stat = Complete; break; @@ -813,22 +883,28 @@ void cdrInterrupt(void) { StopReading(); SetPlaySeekRead(cdr.StatP, 0); cdr.StatP &= ~STATUS_ROTATING; + cdr.LocL[0] = LOCL_INVALID; - delay = 0x800; + second_resp_time = 0x800; if (cdr.DriveState == DRIVESTATE_STANDBY) - delay = cdReadTime * 30 / 2; + second_resp_time = cdReadTime * 30 / 2; cdr.DriveState = DRIVESTATE_STOPPED; - AddIrqQueue(CdlStop + 0x100, delay); break; - case CdlStop + 0x100: + case CdlStop + CMD_PART2: cdr.Stat = Complete; break; 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 @@ -846,33 +922,33 @@ void cdrInterrupt(void) { * */ if (!(cdr.StatP & (STATUS_PLAY | STATUS_READ))) { - delay = 7000; + second_resp_time = 7000; } else { - delay = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * (1000000)); + second_resp_time = (((cdr.Mode & MODE_SPEED) ? 1 : 2) * 1097107); } - AddIrqQueue(CdlPause + 0x100, delay); SetPlaySeekRead(cdr.StatP, 0); - cdr.Ctrl |= 0x80; break; - case CdlPause + 0x100: + case CdlPause + CMD_PART2: cdr.Stat = Complete; break; case CdlReset: + case CdlReset + CMD_WHILE_NOT_READY: 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 */ - AddIrqQueue(CdlReset + 0x100, 4100000); - no_busy_error = 1; + cdr.Mode = MODE_SIZE_2340; /* This fixes This is Football 2, Pooh's Party lockups */ + second_resp_time = not_ready ? 70000 : 4100000; start_rotating = 1; break; - case CdlReset + 0x100: + case CdlReset + CMD_PART2: + case CdlReset + CMD_PART2 + CMD_WHILE_NOT_READY: cdr.Stat = Complete; break; @@ -890,22 +966,28 @@ void cdrInterrupt(void) { break; case CdlSetmode: - no_busy_error = 1; + case CdlSetmode + CMD_WHILE_NOT_READY: + CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]); + cdr.Mode = cdr.Param[0]; break; case CdlGetparam: + case CdlGetparam + CMD_WHILE_NOT_READY: /* Gameblabla : According to mednafen, Result size should be 5 and done this way. */ SetResultSize(5); cdr.Result[1] = cdr.Mode; cdr.Result[2] = 0; cdr.Result[3] = cdr.File; cdr.Result[4] = cdr.Channel; - no_busy_error = 1; 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: @@ -915,11 +997,11 @@ void cdrInterrupt(void) { case CdlReadT: // SetSession? // really long - AddIrqQueue(CdlReadT + 0x100, cdReadTime * 290 / 4); + second_resp_time = cdReadTime * 290 / 4; start_rotating = 1; break; - case CdlReadT + 0x100: + case CdlReadT + CMD_PART2: cdr.Stat = Complete; break; @@ -956,7 +1038,7 @@ void cdrInterrupt(void) { 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); @@ -973,11 +1055,26 @@ void cdrInterrupt(void) { Rockman X5 = 0.5-4x - fix capcom logo */ - CDRPLAYSEEKREAD_INT(cdReadTime + seekTime); + 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); + UpdateSubq(cdr.SetSectorPlay); + cdr.TrackChanged = FALSE; + break; + case CdlTest: + case CdlTest + CMD_WHILE_NOT_READY: switch (cdr.Param[0]) { case 0x20: // System Controller ROM Version SetResultSize(4); @@ -992,14 +1089,13 @@ void cdrInterrupt(void) { memcpy(cdr.Result, Test23, 4); break; } - no_busy_error = 1; break; case CdlID: - AddIrqQueue(CdlID + 0x100, 20480); + second_resp_time = 20480; break; - case CdlID + 0x100: + case CdlID + CMD_PART2: SetResultSize(8); cdr.Result[0] = cdr.StatP; cdr.Result[1] = 0; @@ -1024,34 +1120,38 @@ void cdrInterrupt(void) { break; case CdlInit: + case CdlInit + CMD_WHILE_NOT_READY: StopCdda(); StopReading(); SetPlaySeekRead(cdr.StatP, 0); // yes, it really sets STATUS_SHELLOPEN cdr.StatP |= STATUS_SHELLOPEN; cdr.DriveState = DRIVESTATE_RESCAN_CD; - CDRLID_INT(20480); - no_busy_error = 1; + set_event(PSXINT_CDRLID, 20480); start_rotating = 1; break; case CdlGetQ: - no_busy_error = 1; + case CdlGetQ + CMD_WHILE_NOT_READY: break; case CdlReadToc: - AddIrqQueue(CdlReadToc + 0x100, cdReadTime * 180 / 4); - no_busy_error = 1; + case CdlReadToc + CMD_WHILE_NOT_READY: + cdr.LocL[0] = LOCL_INVALID; + second_resp_time = cdReadTime * 180 / 4; start_rotating = 1; break; - case CdlReadToc + 0x100: + case CdlReadToc + CMD_PART2: + case CdlReadToc + CMD_PART2 + CMD_WHILE_NOT_READY: cdr.Stat = Complete; - no_busy_error = 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) @@ -1069,23 +1169,31 @@ void cdrInterrupt(void) { // Fighting Force 2 - update subq time immediately // - fixes new game - ReadTrack(cdr.SetSectorPlay); + UpdateSubq(cdr.SetSectorPlay); + cdr.LocL[0] = LOCL_INVALID; + cdr.SubqForwardSectors = 1; + cdr.sectorsRead = 0; - CDRPLAYSEEKREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime); + cycles = (cdr.Mode & MODE_SPEED) ? cdReadTime : cdReadTime * 2; + cycles += seekTime; + if (Config.hacks.cdr_read_timing) + 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\n", Irq); error = ERROR_INVALIDCMD; // FALLTHROUGH set_error: + CDR_LOG_I("cmd %02x error %02x\n", Cmd, error); SetResultSize(2); cdr.Result[0] = cdr.StatP | STATUS_ERROR; - cdr.Result[1] = error; + cdr.Result[1] = not_ready ? ERROR_NOTREADY : error; cdr.Stat = DiskError; break; } @@ -1095,22 +1203,16 @@ void cdrInterrupt(void) { cdr.StatP |= STATUS_ROTATING; } - if (!no_busy_error) { - switch (cdr.DriveState) { - case DRIVESTATE_LID_OPEN: - case DRIVESTATE_RESCAN_CD: - case DRIVESTATE_PREPARE_CD: - SetResultSize(2); - cdr.Result[0] = cdr.StatP | STATUS_ERROR; - cdr.Result[1] = ERROR_NOTREADY; - cdr.Stat = DiskError; - break; - } + if (second_resp_time) { + cdr.CmdInProgress = Cmd | 0x100; + set_event(PSXINT_CDR, second_resp_time); + } + else if (cdr.Cmd && cdr.Cmd != (Cmd & 0xff)) { + cdr.CmdInProgress = cdr.Cmd; + CDR_LOG_I("cmd %02x came before %02x finished\n", cdr.Cmd, Cmd); } -finish: - setIrq(Irq); - cdr.ParamC = 0; + setIrq(Cmd); } #ifdef HAVE_ARMV7 @@ -1123,7 +1225,18 @@ finish: } while (0) #endif -void cdrAttenuate(s16 *buf, int samples, int stereo) +static void cdrPrepCdda(s16 *buf, int samples) +{ +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + int i; + for (i = 0; i < samples; i++) { + buf[i * 2 + 0] = SWAP16(buf[i * 2 + 0]); + buf[i * 2 + 1] = SWAP16(buf[i * 2 + 1]); + } +#endif +} + +static void cdrAttenuate(s16 *buf, int samples, int stereo) { int i, l, r; int ll = cdr.AttenuatorLeftToLeft; @@ -1161,47 +1274,74 @@ void cdrAttenuate(s16 *buf, int samples, int stereo) } } -static void cdrReadInterrupt(void) +static void cdrReadInterruptSetResult(unsigned char result) +{ + if (cdr.Stat) { + 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; + } + SetResultSize(1); + cdr.Result[0] = result; + cdr.Stat = (result & STATUS_ERROR) ? DiskError : DataReady; + setIrq(0x1004); +} + +static void cdrUpdateTransferBuf(const u8 *buf) { - u8 *buf; + if (!buf) + return; + memcpy(cdr.Transfer, buf, DATA_SIZE); + CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[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); +} - if (cdr.Irq || cdr.Stat) { - CDR_LOG_I("cdrom: read stat hack %02x %x\n", cdr.Irq, cdr.Stat); - CDRPLAYSEEKREAD_INT(2048); +static void cdrReadInterrupt(void) +{ + u8 *buf = NULL, *hdr; + u8 subqPos[3]; + int read_ok; + + memcpy(subqPos, cdr.SetSectorPlay, sizeof(subqPos)); + msfiAdd(subqPos, cdr.SubqForwardSectors); + UpdateSubq(subqPos); + if (cdr.SubqForwardSectors < SUBQ_FORWARD_SECTORS) { + cdr.SubqForwardSectors++; + CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0); return; } - cdr.OCUP = 1; - SetResultSize(1); + // note: CdlGetlocL should work as soon as STATUS_READ is indicated SetPlaySeekRead(cdr.StatP, STATUS_READ | STATUS_ROTATING); - cdr.Result[0] = cdr.StatP; - - ReadTrack(cdr.SetSectorPlay); + cdr.sectorsRead++; - buf = CDR_getBuffer(); + 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); - cdr.Stat = DiskError; - cdr.Result[0] |= STATUS_ERROR; - setIrq(0x205); + cdrReadInterruptSetResult(cdr.StatP | STATUS_ERROR); return; } + memcpy(cdr.LocL, buf, 8); - memcpy(cdr.Transfer, buf, DATA_SIZE); - CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]); - - - CDR_LOG("cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]); + if (!cdr.Stat && !cdr.Irq1Pending) + cdrUpdateTransferBuf(buf); if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA + hdr = buf + 4; // Firemen 2: Multi-XA files - briefings, cutscenes if( cdr.FirstSector == 1 && (cdr.Mode & MODE_SF)==0 ) { - cdr.File = cdr.Transfer[4 + 0]; - cdr.Channel = cdr.Transfer[4 + 1]; + cdr.File = hdr[0]; + cdr.Channel = hdr[1]; } /* Gameblabla @@ -1209,46 +1349,29 @@ static void cdrReadInterrupt(void) * Fixes missing audio in Blue's Clues : Blue's Big Musical. (Should also fix Taxi 2) * TODO : Check if this is the proper behaviour. * */ - if((cdr.Transfer[4 + 2] & 0x4) && - (cdr.Transfer[4 + 1] == cdr.Channel) && - (cdr.Transfer[4 + 0] == cdr.File) && cdr.Channel != 255) { - int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector); + if ((hdr[2] & 0x4) && hdr[0] == cdr.File && hdr[1] == cdr.Channel && cdr.Channel != 255) { + int ret = xa_decode_sector(&cdr.Xa, buf + 4, cdr.FirstSector); if (!ret) { cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo); - SPU_playADPCMchannel(&cdr.Xa); + SPU_playADPCMchannel(&cdr.Xa, psxRegs.cycle, cdr.FirstSector); cdr.FirstSector = 0; } else cdr.FirstSector = -1; } } - cdr.SetSectorPlay[2]++; - if (cdr.SetSectorPlay[2] == 75) { - cdr.SetSectorPlay[2] = 0; - cdr.SetSectorPlay[1]++; - if (cdr.SetSectorPlay[1] == 60) { - cdr.SetSectorPlay[1] = 0; - cdr.SetSectorPlay[0]++; - } - } - - cdr.Readed = 0; - - CDRPLAYSEEKREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime); - /* Croc 2: $40 - only FORM1 (*) Judge Dredd: $C8 - only FORM1 (*) Sim Theme Park - no adpcm at all (zero) */ - if (!(cdr.Mode & MODE_STRSND) || !(cdr.Transfer[4+2] & 0x4)) { - cdr.Stat = DataReady; - setIrq(0x203); - } + if (!(cdr.Mode & MODE_STRSND) || !(buf[4+2] & 0x4)) + cdrReadInterruptSetResult(cdr.StatP); - // update for CdlGetlocP - ReadTrack(cdr.SetSectorPlay); + msfiAdd(cdr.SetSectorPlay, 1); + + CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0); } /* @@ -1268,10 +1391,7 @@ unsigned char cdrRead0(void) { else cdr.Ctrl &= ~0x20; - if (cdr.OCUP) - cdr.Ctrl |= 0x40; -// else -// cdr.Ctrl &= ~0x40; + cdr.Ctrl |= 0x40; // data fifo not empty // What means the 0x10 and the 0x08 bits? I only saw it used by the bios cdr.Ctrl |= 0x18; @@ -1315,11 +1435,8 @@ void cdrWrite1(unsigned char rt) { return; } - cdr.Cmd = rt; - cdr.OCUP = 0; - #ifdef CDR_LOG_CMD_IRQ - SysPrintf("CD1 write: %x (%s)", rt, CmdName[rt]); + CDR_LOG_I("CD1 write: %x (%s)", rt, CmdName[rt]); if (cdr.ParamC) { int i; SysPrintf(" Param[%d] = {", cdr.ParamC); @@ -1333,26 +1450,29 @@ void cdrWrite1(unsigned char rt) { cdr.ResultReady = 0; cdr.Ctrl |= 0x80; - // cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - switch (cdr.Cmd) { - case CdlSetmode: - CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]); - - cdr.Mode = cdr.Param[0]; - break; + if (!cdr.CmdInProgress) { + cdr.CmdInProgress = rt; + // should be something like 12k + controller delays + set_event(PSXINT_CDR, 5000); + } + else { + 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; } + + cdr.Cmd = rt; } unsigned char cdrRead2(void) { - unsigned char ret; + unsigned char ret = cdr.Transfer[0x920]; - if (cdr.Readed == 0) { - ret = 0; - } else { - ret = *pTransfer++; - } + if (cdr.FifoOffset < cdr.FifoSize) + ret = cdr.Transfer[cdr.FifoOffset++]; + else + CDR_LOG_I("read empty fifo (%d)\n", cdr.FifoSize); CDR_LOG_IO("cdr r2.dat: %02x\n", ret); return ret; @@ -1369,7 +1489,7 @@ void cdrWrite2(unsigned char rt) { return; case 1: cdr.Reg2 = rt; - setIrq(0x204); + setIrq(0x1005); return; case 2: cdr.AttenuatorLeftToLeftT = rt; @@ -1398,6 +1518,26 @@ void cdrWrite3(unsigned char rt) { case 0: break; // transfer case 1: + 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 + 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 (!pending && (cdr.CmdInProgress || cdr.Irq1Pending)) + { + s32 c = 2048; + if (cdr.CmdInProgress) { + c = 2048 - (psxRegs.cycle - nextCycle); + c = MAX_VALUE(c, 512); + } + set_event(PSXINT_CDR, c); + } + } cdr.Stat &= ~rt; if (rt & 0x40) @@ -1409,68 +1549,59 @@ void cdrWrite3(unsigned char rt) { case 3: if (rt & 0x20) { memcpy(&cdr.AttenuatorLeftToLeft, &cdr.AttenuatorLeftToLeftT, 4); - CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n", + CDR_LOG("CD-XA Volume: %02x %02x | %02x %02x\n", cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight, cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight); } return; } - if ((rt & 0x80) && cdr.Readed == 0) { - cdr.Readed = 1; - pTransfer = cdr.Transfer; - - switch (cdr.Mode & 0x30) { + // test: Viewpoint + if ((rt & 0x80) && cdr.FifoOffset < cdr.FifoSize) { + CDR_LOG("cdrom: FifoOffset(2) %d/%d\n", cdr.FifoOffset, cdr.FifoSize); + } + else if (rt & 0x80) { + switch (cdr.Mode & (MODE_SIZE_2328|MODE_SIZE_2340)) { case MODE_SIZE_2328: case 0x00: - pTransfer += 12; + cdr.FifoOffset = 12; + cdr.FifoSize = 2048 + 12; break; case MODE_SIZE_2340: - pTransfer += 0; - break; - default: + cdr.FifoOffset = 0; + cdr.FifoSize = 2340; break; } } + else if (!(rt & 0xc0)) + cdr.FifoOffset = DATA_SIZE; // fifo empty } 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) { + switch (chcr & 0x71000000) { case 0x11000000: - case 0x11400100: - if (cdr.Readed == 0) { - CDR_LOG("psxDma3() Log: *** DMA 3 *** NOT READY\n"); + ptr = getDmaRam(madr, &max_words); + if (ptr == INVALID_PTR) { + CDR_LOG_I("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n"); break; } - cdsize = (bcr & 0xffff) * 4; - - // Ape Escape: bcr = 0001 / 0000 - // - fix boot - if( cdsize == 0 ) - { - switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) { - case MODE_SIZE_2340: cdsize = 2340; break; - case MODE_SIZE_2328: cdsize = 2328; break; - default: - case MODE_SIZE_2048: cdsize = 2048; break; - } - } - - - ptr = (u8 *)PSXM(madr); - if (ptr == NULL) { - CDR_LOG("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n"); - break; - } + cdsize = (((bcr - 1) & 0xffff) + 1) * 4; /* GS CDX: Enhancement CD crash @@ -1478,31 +1609,37 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) { - CdlPlay - Spams DMA3 and gets buffer overrun */ - size = CD_FRAMESIZE_RAW - (pTransfer - cdr.Transfer); + size = DATA_SIZE - cdr.FifoOffset; if (size > cdsize) size = cdsize; + if (size > max_words * 4) + size = max_words * 4; if (size > 0) { - memcpy(ptr, pTransfer, size); + memcpy(ptr, cdr.Transfer + cdr.FifoOffset, size); + cdr.FifoOffset += size; + } + 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); - pTransfer += cdsize; - if( chcr == 0x11400100 ) { + set_event(PSXINT_CDRDMA, (cdsize / 4) * 24); + + HW_DMA3_CHCR &= SWAPu32(~0x10000000); + if (chcr & 0x100) { HW_DMA3_MADR = SWAPu32(madr + cdsize); - CDRDMA_INT( (cdsize/4) / 4 ); + HW_DMA3_BCR &= SWAPu32(0xffff0000); } - else if( chcr == 0x11000000 ) { - // CDRDMA_INT( (cdsize/4) * 1 ); + else { // halted - psxRegs.cycle += (cdsize/4) * 24/2; - CDRDMA_INT(16); + psxRegs.cycle += (cdsize/4) * 24 - 20; } return; default: - CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr); + CDR_LOG_I("psxDma3() Log: Unknown cddma %x\n", chcr); break; } @@ -1537,9 +1674,15 @@ void cdrReset() { cdr.Channel = 1; cdr.Reg2 = 0x1f; cdr.Stat = NoIntr; - cdr.DriveState = DRIVESTATE_STANDBY; - cdr.StatP = STATUS_ROTATING; - pTransfer = cdr.Transfer; + 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; @@ -1562,7 +1705,7 @@ int cdrFreeze(void *f, int Mode) { if (Mode == 1) { cdr.ParamP = cdr.ParamC; - tmp = pTransfer - cdr.Transfer; + tmp = cdr.FifoOffset; } gzfreeze(&tmp, sizeof(tmp)); @@ -1570,7 +1713,10 @@ int cdrFreeze(void *f, int Mode) { if (Mode == 0) { getCdInfo(); - pTransfer = cdr.Transfer + tmp; + cdr.FifoOffset = tmp < DATA_SIZE ? tmp : DATA_SIZE; + cdr.FifoSize = (cdr.Mode & MODE_SIZE_2340) ? 2340 : 2048 + 12; + if (cdr.SubqForwardSectors > SUBQ_FORWARD_SECTORS) + cdr.SubqForwardSectors = SUBQ_FORWARD_SECTORS; // read right sub data tmpp[0] = btoi(cdr.Prev[0]); @@ -1586,8 +1732,6 @@ int cdrFreeze(void *f, int Mode) { Find_CurTrack(cdr.SetSectorPlay); if (!Config.Cdda) CDR_play(cdr.SetSectorPlay); - if (psxRegs.interrupt & (1 << PSXINT_CDRPLAY_OLD)) - CDRPLAYSEEKREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime); } if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {