X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=libpcsxcore%2Fcdrom.c;h=0ae2c50baa599efe03634e8fc28c346f0e88e85d;hb=a6e034904c2ae8b254b707a17df7de161efbfd6c;hp=e1065739b665314ecff188f52475dd030c01d023;hpb=afaac9354c80862f1bb153144a811f12d6836eec;p=pcsx_rearmed.git

diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c
index e1065739..0ae2c50b 100644
--- a/libpcsxcore/cdrom.c
+++ b/libpcsxcore/cdrom.c
@@ -21,6 +21,7 @@
 * Handles all CD-ROM registers and functions.
 */
 
+#include <assert.h>
 #include "cdrom.h"
 #include "ppf.h"
 #include "psxdma.h"
@@ -35,7 +36,8 @@
 #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
@@ -63,7 +65,8 @@ static struct {
 		unsigned char Absolute[3];
 	} subq;
 	unsigned char TrackChanged;
-	unsigned char unused3[3];
+	unsigned char ReportDelay;
+	unsigned char unused3[2];
 	unsigned int  freeze_ver;
 
 	unsigned char Prev[4];
@@ -76,7 +79,7 @@ static struct {
 	unsigned char ResultP;
 	unsigned char ResultReady;
 	unsigned char Cmd;
-	unsigned char unused4;
+	unsigned char SubqForwardSectors;
 	unsigned char SetlocPending;
 	u32 Reading;
 
@@ -100,14 +103,14 @@ static struct {
 	u16 CmdInProgress;
 	u8 Irq1Pending;
 	u8 unused5;
-	u32 unused6;
+	u32 LastReadCycles;
 
 	u8 unused7;
 
 	u8 DriveState;
 	u8 FastForward;
 	u8 FastBackward;
-	u8 unused8;
+	u8 errorRetryhack;
 
 	u8 AttenuatorLeftToLeft, AttenuatorLeftToRight;
 	u8 AttenuatorRightToRight, AttenuatorRightToLeft;
@@ -208,6 +211,7 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 };
 #define cdReadTime (PSXCLK / 75)
 
 #define LOCL_INVALID 0xff
+#define SUBQ_FORWARD_SECTORS 2u
 
 enum drive_state {
 	DRIVESTATE_STANDBY = 0, // pause, play, read
@@ -296,8 +300,8 @@ static void setIrq(int log_cmd)
 	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");
@@ -309,7 +313,7 @@ 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("%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:
@@ -323,6 +327,7 @@ void cdrLidSeekInterrupt(void)
 
 		if (stat.Status & STATUS_SHELLOPEN)
 		{
+			memset(cdr.Prev, 0xff, sizeof(cdr.Prev));
 			cdr.DriveState = DRIVESTATE_LID_OPEN;
 			CDRLID_INT(0x800);
 		}
@@ -447,11 +452,10 @@ static void generate_subq(const u8 *time)
 	cdr.subq.Absolute[2] = itob(time[2]);
 }
 
-static int 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[1] = itob(time[1]);
@@ -465,11 +469,18 @@ static int ReadTrack(const u8 *time) {
 	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 read_ok;
+		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])) {
@@ -479,8 +490,8 @@ static int 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 {
@@ -491,8 +502,6 @@ static int ReadTrack(const u8 *time) {
 		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()
@@ -516,7 +525,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;
@@ -552,28 +563,23 @@ static void cdrPlayInterrupt_Autopause()
 		SetResultSize(8);
 		setIrq(0x1001);
 	}
+
+	if (cdr.ReportDelay)
+		cdr.ReportDelay--;
 }
 
+// LastReadCycles
 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 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 * 4 ? 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;
 }
@@ -591,8 +597,14 @@ static u32 cdrAlignTimingHack(u32 cycles)
 	 * 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 = rcnts[3].cycleStart + 63000 - psxRegs.cycle;
+	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;
@@ -604,8 +616,24 @@ static void cdrReadInterrupt(void);
 static void cdrPrepCdda(s16 *buf, int samples);
 static void cdrAttenuate(s16 *buf, int samples, int stereo);
 
+static void msfiAdd(u8 *msfi, u32 count)
+{
+	assert(count < 75);
+	msfi[2] += count;
+	if (msfi[2] >= 75) {
+		msfi[2] -= 75;
+		msfi[1]++;
+		if (msfi[1] == 60) {
+			msfi[1] = 0;
+			msfi[0]++;
+		}
+	}
+}
+
 void cdrPlayReadInterrupt(void)
 {
+	cdr.LastReadCycles = psxRegs.cycle;
+
 	if (cdr.Reading) {
 		cdrReadInterrupt();
 		return;
@@ -636,15 +664,7 @@ void cdrPlayReadInterrupt(void)
 		cdr.FirstSector = 0;
 	}
 
-	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]++;
-		}
-	}
+	msfiAdd(cdr.SetSectorPlay, 1);
 
 	// update for CdlGetlocP/autopause
 	generate_subq(cdr.SetSectorPlay);
@@ -669,15 +689,16 @@ void cdrInterrupt(void) {
 	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;
@@ -734,6 +755,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;
 			}
@@ -744,6 +767,7 @@ void cdrInterrupt(void) {
 				memcpy(cdr.SetSector, set_loc, 3);
 				cdr.SetSector[3] = 0;
 				cdr.SetlocPending = 1;
+				cdr.errorRetryhack = 0;
 			}
 			break;
 
@@ -794,10 +818,12 @@ 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;
 
 			if (!Config.Cdda)
 				CDR_play(cdr.SetSectorPlay);
@@ -892,7 +918,7 @@ void cdrInterrupt(void) {
 			}
 			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;
@@ -908,7 +934,7 @@ void cdrInterrupt(void) {
 			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 */
+			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;
@@ -1035,6 +1061,7 @@ void cdrInterrupt(void) {
 			read_ok = ReadTrack(cdr.SetSectorPlay);
 			if (read_ok && (buf = CDR_getBuffer()))
 				memcpy(cdr.LocL, buf, 8);
+			UpdateSubq(cdr.SetSectorPlay);
 			cdr.TrackChanged = FALSE;
 			break;
 
@@ -1134,12 +1161,14 @@ 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;
 
-			cycles = (cdr.Mode & 0x80) ? cdReadTime : cdReadTime * 2;
+			cycles = (cdr.Mode & MODE_SPEED) ? cdReadTime : cdReadTime * 2;
 			cycles += seekTime;
-			cycles = cdrAlignTimingHack(cycles);
+			if (Config.hacks.cdr_read_timing)
+				cycles = cdrAlignTimingHack(cycles);
 			CDRPLAYREAD_INT(cycles, 1);
 
 			SetPlaySeekRead(cdr.StatP, STATUS_SEEK);
@@ -1152,7 +1181,7 @@ void cdrInterrupt(void) {
 			// 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;
@@ -1171,8 +1200,7 @@ void cdrInterrupt(void) {
 	}
 	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);
@@ -1240,7 +1268,7 @@ static void cdrAttenuate(s16 *buf, int samples, int stereo)
 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;
@@ -1260,14 +1288,25 @@ static void cdrUpdateTransferBuf(const u8 *buf)
 	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]);
 	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)
 {
 	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;
+	}
+
+	// note: CdlGetlocL should work as soon as STATUS_READ is indicated
 	SetPlaySeekRead(cdr.StatP, STATUS_READ | STATUS_ROTATING);
 
 	read_ok = ReadTrack(cdr.SetSectorPlay);
@@ -1283,7 +1322,7 @@ static void cdrReadInterrupt(void)
 	}
 	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
@@ -1319,20 +1358,7 @@ static void cdrReadInterrupt(void)
 	if (!(cdr.Mode & MODE_STRSND) || !(buf[4+2] & 0x4))
 		cdrReadInterruptSetResult(cdr.StatP);
 
-	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]++;
-		}
-	}
-
-	if (!cdr.Irq1Pending) {
-		// update for CdlGetlocP
-		ReadTrack(cdr.SetSectorPlay);
-	}
+	msfiAdd(cdr.SetSectorPlay, 1);
 
 	CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0);
 }
@@ -1399,7 +1425,7 @@ void cdrWrite1(unsigned char rt) {
 	}
 
 #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);
@@ -1420,8 +1446,8 @@ void cdrWrite1(unsigned char rt) {
 		CDR_INT(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;
 	}
@@ -1435,7 +1461,7 @@ unsigned char cdrRead2(void) {
 	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;
@@ -1482,14 +1508,24 @@ void cdrWrite3(unsigned char rt) {
 		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
-			SysPrintf("%u cdrom: ack %02x (w %02x)\n",
-				psxRegs.cycle, cdr.Stat & rt, rt);
+			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 vs Discworld Noir
-			if (!(psxRegs.interrupt & (1 << PSXINT_CDR)) &&
-			    (cdr.CmdInProgress || cdr.Irq1Pending))
-				CDR_INT(850); // 711-993
+			// 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);
+				}
+				CDR_INT(c);
+			}
 		}
 		cdr.Stat &= ~rt;
 
@@ -1514,7 +1550,7 @@ void cdrWrite3(unsigned char rt) {
 		CDR_LOG("cdrom: FifoOffset(2) %d/%d\n", cdr.FifoOffset, cdr.FifoSize);
 	}
 	else if (rt & 0x80) {
-		switch (cdr.Mode & 0x30) {
+		switch (cdr.Mode & (MODE_SIZE_2328|MODE_SIZE_2340)) {
 			case MODE_SIZE_2328:
 			case 0x00:
 				cdr.FifoOffset = 12;
@@ -1533,15 +1569,22 @@ void cdrWrite3(unsigned char 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;
@@ -1558,6 +1601,8 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) {
 			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);
@@ -1658,7 +1703,9 @@ int cdrFreeze(void *f, int Mode) {
 		getCdInfo();
 
 		cdr.FifoOffset = tmp < DATA_SIZE ? tmp : DATA_SIZE;
-		cdr.FifoSize = (cdr.Mode & 0x20) ? 2340 : 2048 + 12;
+		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]);
@@ -1674,8 +1721,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))
-				CDRPLAYREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime, 1);
 		}
 
 		if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {