X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=libpcsxcore%2Fcdrom.c;h=098b77d0b9691a910a135abcb628b94fb4453a1c;hb=399f666e98e02f2d451b0df140c57d1a308a1b86;hp=a3ddb44737fdd82cb9b4d40a9e44709bce515add;hpb=742a21f278bff9a6c5c7f07a3fd8026fef47676a;p=pcsx_rearmed.git

diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c
index a3ddb447..098b77d0 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,7 @@
 #if 0
 #define CDR_LOG_I SysPrintf
 #else
-#define CDR_LOG_I(...)
+#define CDR_LOG_I log_unhandled
 #endif
 #if 0
 #define CDR_LOG_IO SysPrintf
@@ -76,7 +77,7 @@ static struct {
 	unsigned char ResultP;
 	unsigned char ResultReady;
 	unsigned char Cmd;
-	unsigned char unused4;
+	unsigned char SubqForwardSectors;
 	unsigned char SetlocPending;
 	u32 Reading;
 
@@ -89,8 +90,7 @@ 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;
@@ -208,6 +208,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,
@@ -243,8 +246,8 @@ static void sec2msf(unsigned int s, u8 *msf) {
 	new_dyna_set_event(PSXINT_CDR, eCycle); \
 }
 
-// cdrPlaySeekReadInterrupt
-#define CDRPLAYSEEKREAD_INT(eCycle, isFirst) { \
+// cdrPlayReadInterrupt
+#define CDRPLAYREAD_INT(eCycle, isFirst) { \
 	u32 e_ = eCycle; \
 	psxRegs.interrupt |= (1 << PSXINT_CDREAD); \
 	if (isFirst) \
@@ -295,8 +298,8 @@ static void setIrq(int log_cmd)
 	if (cdr.Stat)
 	{
 		int i;
-		SysPrintf("CDR IRQ=%d cmd %02x stat %02x: ",
-			!!(cdr.Stat & cdr.Reg2), log_cmd, cdr.Stat);
+		SysPrintf("%u cdrom: CDR IRQ=%d cmd %02x stat %02x: ",
+			psxRegs.cycle, !!(cdr.Stat & cdr.Reg2), log_cmd, cdr.Stat);
 		for (i = 0; i < cdr.ResultC; i++)
 			SysPrintf("%02x ", cdr.Result[i]);
 		SysPrintf("\n");
@@ -308,6 +311,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("%u %s cdr.DriveState=%d\n", psxRegs.cycle, __func__, cdr.DriveState);
+
 	switch (cdr.DriveState) {
 	default:
 	case DRIVESTATE_STANDBY:
@@ -320,6 +325,7 @@ void cdrLidSeekInterrupt(void)
 
 		if (stat.Status & STATUS_SHELLOPEN)
 		{
+			memset(cdr.Prev, 0xff, sizeof(cdr.Prev));
 			cdr.DriveState = DRIVESTATE_LID_OPEN;
 			CDRLID_INT(0x800);
 		}
@@ -369,10 +375,14 @@ void cdrLidSeekInterrupt(void)
 		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);
+			CDRLID_INT(cdReadTime * 26);
+		}
 		break;
 	}
 }
@@ -440,27 +450,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])) {
@@ -470,8 +488,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 {
@@ -500,7 +518,7 @@ 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);
@@ -539,13 +557,14 @@ static void cdrPlayInterrupt_Autopause()
 		cdr.Stat = DataReady;
 
 		SetResultSize(8);
-		setIrq(0x201);
+		setIrq(0x1001);
 	}
 }
 
 static int cdrSeekTime(unsigned char *target)
 {
-	int seekTime = abs(msf2sec(cdr.SetSectorPlay) - msf2sec(target)) * (cdReadTime / 200);
+	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
@@ -566,31 +585,56 @@ static int cdrSeekTime(unsigned char *target)
 	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;
-	}
-
-	if (!cdr.Play && (cdr.StatP & STATUS_SEEK)) {
-		if (cdr.Stat) {
-			CDR_LOG_I("cdrom: seek stat hack\n");
-			CDRPLAYSEEKREAD_INT(0x1000, 1);
-			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]++;
 		}
-		SetResultSize(1);
-		cdr.StatP |= STATUS_ROTATING;
-		SetPlaySeekRead(cdr.StatP, 0);
-		cdr.Result[0] = cdr.StatP;
-		cdr.Stat = Complete;
-		setIrq(0x202);
+	}
+}
 
-		Find_CurTrack(cdr.SetSectorPlay);
-		ReadTrack(cdr.SetSectorPlay);
-		cdr.TrackChanged = FALSE;
+void cdrPlayReadInterrupt(void)
+{
+	if (cdr.Reading) {
+		cdrReadInterrupt();
 		return;
 	}
 
@@ -613,44 +657,53 @@ void cdrPlaySeekReadInterrupt(void)
 		cdrPlayInterrupt_Autopause();
 
 	if (!cdr.Muted && !Config.Cdda) {
+		cdrPrepCdda(read_buf, CD_FRAMESIZE_RAW / 4);
 		cdrAttenuate(read_buf, CD_FRAMESIZE_RAW / 4, 1);
 		SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW, psxRegs.cycle, cdr.FirstSector);
 		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);
 
-	CDRPLAYSEEKREAD_INT(cdReadTime, 0);
+	CDRPLAYREAD_INT(cdReadTime, 0);
 }
 
+#define CMD_PART2           0x100
+#define CMD_WHILE_NOT_READY 0x200
+
 void cdrInterrupt(void) {
-	int no_busy_error = 0;
 	int start_rotating = 0;
 	int error = 0;
-	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;
 
 	if (cdr.Stat) {
-		CDR_LOG_I("cdrom: cmd %02x with irqstat %x\n", cdr.CmdInProgress, cdr.Stat);
+		CDR_LOG_I("%u cdrom: cmd %02x with irqstat %x\n",
+			psxRegs.cycle, 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]);
+		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);
@@ -662,24 +715,44 @@ void cdrInterrupt(void) {
 	ParamC = cdr.ParamC;
 
 	if (Cmd < 0x100) {
-		cdr.Cmd = 0;
+		cdr.Ctrl &= ~0x80;
 		cdr.ParamC = 0;
+		cdr.Cmd = 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 (Cmd) {
+	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]);
 				error = ERROR_INVALIDARG;
 				goto set_error;
 			}
@@ -740,7 +813,9 @@ 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;
 
@@ -752,7 +827,7 @@ void cdrInterrupt(void) {
 			// BIOS player - set flag again
 			cdr.Play = TRUE;
 
-			CDRPLAYSEEKREAD_INT(cdReadTime + seekTime, 1);
+			CDRPLAYREAD_INT(cdReadTime + seekTime, 1);
 			start_rotating = 1;
 			break;
 
@@ -782,7 +857,7 @@ void cdrInterrupt(void) {
 			start_rotating = 1;
 			break;
 
-		case CdlStandby + 0x100:
+		case CdlStandby + CMD_PART2:
 			cdr.Stat = Complete;
 			break;
 
@@ -800,6 +875,7 @@ void cdrInterrupt(void) {
 			StopReading();
 			SetPlaySeekRead(cdr.StatP, 0);
 			cdr.StatP &= ~STATUS_ROTATING;
+			cdr.LocL[0] = LOCL_INVALID;
 
 			second_resp_time = 0x800;
 			if (cdr.DriveState == DRIVESTATE_STANDBY)
@@ -808,7 +884,7 @@ void cdrInterrupt(void) {
 			cdr.DriveState = DRIVESTATE_STOPPED;
 			break;
 
-		case CdlStop + 0x100:
+		case CdlStop + CMD_PART2:
 			cdr.Stat = Complete;
 			break;
 
@@ -839,25 +915,26 @@ void cdrInterrupt(void) {
 				second_resp_time = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * 1000000);
 			}
 			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 */
-			second_resp_time = 4100000;
-			no_busy_error = 1;
+			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;
 
@@ -875,24 +952,28 @@ void cdrInterrupt(void) {
 			break;
 
 		case CdlSetmode:
+		case CdlSetmode + CMD_WHILE_NOT_READY:
 			CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]);
 			cdr.Mode = cdr.Param[0];
-			no_busy_error = 1;
 			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:
@@ -906,7 +987,7 @@ void cdrInterrupt(void) {
 			start_rotating = 1;
 			break;
 
-		case CdlReadT + 0x100:
+		case CdlReadT + CMD_PART2:
 			cdr.Stat = Complete;
 			break;
 
@@ -943,7 +1024,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);
@@ -960,11 +1041,26 @@ void cdrInterrupt(void) {
 			Rockman X5 = 0.5-4x
 			- fix capcom logo
 			*/
-			CDRPLAYSEEKREAD_INT(cdReadTime + seekTime, 1);
+			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);
@@ -979,14 +1075,13 @@ void cdrInterrupt(void) {
 					memcpy(cdr.Result, Test23, 4);
 					break;
 			}
-			no_busy_error = 1;
 			break;
 
 		case CdlID:
 			second_resp_time = 20480;
 			break;
 
-		case CdlID + 0x100:
+		case CdlID + CMD_PART2:
 			SetResultSize(8);
 			cdr.Result[0] = cdr.StatP;
 			cdr.Result[1] = 0;
@@ -1011,6 +1106,7 @@ void cdrInterrupt(void) {
 			break;
 
 		case CdlInit:
+		case CdlInit + CMD_WHILE_NOT_READY:
 			StopCdda();
 			StopReading();
 			SetPlaySeekRead(cdr.StatP, 0);
@@ -1018,27 +1114,30 @@ void cdrInterrupt(void) {
 			cdr.StatP |= STATUS_SHELLOPEN;
 			cdr.DriveState = DRIVESTATE_RESCAN_CD;
 			CDRLID_INT(20480);
-			no_busy_error = 1;
 			start_rotating = 1;
 			break;
 
 		case CdlGetQ:
-			no_busy_error = 1;
+		case CdlGetQ + CMD_WHILE_NOT_READY:
 			break;
 
 		case CdlReadToc:
+		case CdlReadToc + CMD_WHILE_NOT_READY:
+			cdr.LocL[0] = LOCL_INVALID;
 			second_resp_time = cdReadTime * 180 / 4;
-			no_busy_error = 1;
 			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)
@@ -1056,23 +1155,30 @@ 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;
 
-			CDRPLAYSEEKREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime, 1);
+			cycles = (cdr.Mode & 0x80) ? 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", Cmd);
 			error = ERROR_INVALIDCMD;
 			// FALLTHROUGH
 
 		set_error:
+			CDR_LOG_I("cdrom: 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;
 	}
@@ -1082,26 +1188,14 @@ 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;
 		CDR_INT(second_resp_time);
 	}
 	else if (cdr.Cmd && cdr.Cmd != (Cmd & 0xff)) {
 		cdr.CmdInProgress = cdr.Cmd;
-		CDR_LOG_I("cdrom: cmd %02x came before %02x finished\n", cdr.Cmd, Cmd);
+		CDR_LOG_I("%u cdrom: cmd %02x came before %02x finished\n",
+			psxRegs.cycle, cdr.Cmd, Cmd);
 	}
 
 	setIrq(Cmd);
@@ -1117,7 +1211,18 @@ void cdrInterrupt(void) {
  } 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;
@@ -1167,7 +1272,7 @@ static void cdrReadInterruptSetResult(unsigned char result)
 	SetResultSize(1);
 	cdr.Result[0] = result;
 	cdr.Stat = (result & STATUS_ERROR) ? DiskError : DataReady;
-	setIrq(0x203);
+	setIrq(0x1004);
 }
 
 static void cdrUpdateTransferBuf(const u8 *buf)
@@ -1184,21 +1289,33 @@ static void cdrUpdateTransferBuf(const u8 *buf)
 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);
 
-	ReadTrack(cdr.SetSectorPlay);
-	if (cdr.NoErr)
+	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);
 		cdrReadInterruptSetResult(cdr.StatP | STATUS_ERROR);
 		return;
 	}
+	memcpy(cdr.LocL, buf, 8);
 
 	if (!cdr.Irq1Pending)
 		cdrUpdateTransferBuf(buf);
@@ -1236,41 +1353,9 @@ 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);
 
-	CDRPLAYSEEKREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0);
-}
-
-static void doMissedIrqs(void)
-{
-	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]);
-		SetResultSize(1);
-		cdr.Result[0] = cdr.Irq1Pending;
-		cdr.Stat = (cdr.Irq1Pending & STATUS_ERROR) ? DiskError : DataReady;
-		cdr.Irq1Pending = 0;
-		setIrq(0x205);
-		return;
-	}
-	if (!(psxRegs.interrupt & (1 << PSXINT_CDR)) && cdr.CmdInProgress)
-		CDR_INT(256);
+	CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0);
 }
 
 /*
@@ -1335,7 +1420,7 @@ void cdrWrite1(unsigned char rt) {
 	}
 
 #ifdef CDR_LOG_CMD_IRQ
-	SysPrintf("CD1 write: %x (%s)", rt, CmdName[rt]);
+	SysPrintf("%u cdrom: CD1 write: %x (%s)", psxRegs.cycle, rt, CmdName[rt]);
 	if (cdr.ParamC) {
 		int i;
 		SysPrintf(" Param[%d] = {", cdr.ParamC);
@@ -1356,8 +1441,8 @@ void cdrWrite1(unsigned char rt) {
 		CDR_INT(5000);
 	}
 	else {
-		CDR_LOG_I("cdr: cmd while busy: %02x, prev %02x, busy %02x\n",
-			rt, cdr.Cmd, cdr.CmdInProgress);
+		CDR_LOG_I("%u cdrom: cmd while busy: %02x, prev %02x, busy %02x\n",
+			psxRegs.cycle, rt, cdr.Cmd, cdr.CmdInProgress);
 		if (cdr.CmdInProgress < 0x100) // no pending 2nd response
 			cdr.CmdInProgress = rt;
 	}
@@ -1366,7 +1451,7 @@ void cdrWrite1(unsigned char rt) {
 }
 
 unsigned char cdrRead2(void) {
-	unsigned char ret = 0;
+	unsigned char ret = cdr.Transfer[0x920];
 
 	if (cdr.FifoOffset < cdr.FifoSize)
 		ret = cdr.Transfer[cdr.FifoOffset++];
@@ -1388,7 +1473,7 @@ void cdrWrite2(unsigned char rt) {
 		return;
 	case 1:
 		cdr.Reg2 = rt;
-		setIrq(0x204);
+		setIrq(0x1005);
 		return;
 	case 2:
 		cdr.AttenuatorLeftToLeftT = rt;
@@ -1417,15 +1502,28 @@ 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;
 #ifdef CDR_LOG_CMD_IRQ
-		if (cdr.Stat & rt)
-			SysPrintf("ack %02x\n", cdr.Stat & rt);
+			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);
 #endif
+			// note: Croc, Shadow Tower (more) vs Discworld Noir (<993)
+			if (!(psxRegs.interrupt & (1 << PSXINT_CDR)) &&
+			    (cdr.CmdInProgress || cdr.Irq1Pending))
+			{
+				s32 c = 2048 - (psxRegs.cycle - nextCycle);
+				c = MAX_VALUE(c, 512);
+				CDR_INT(c);
+			}
+		}
 		cdr.Stat &= ~rt;
 
 		if (rt & 0x40)
 			cdr.ParamC = 0;
-		doMissedIrqs();
 		return;
 	case 2:
 		cdr.AttenuatorLeftToRightT = rt;
@@ -1473,7 +1571,7 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) {
 	switch (chcr & 0x71000000) {
 		case 0x11000000:
 			ptr = (u8 *)PSXM(madr);
-			if (ptr == NULL) {
+			if (ptr == INVALID_PTR) {
 				CDR_LOG_I("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n");
 				break;
 			}
@@ -1493,8 +1591,12 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) {
 			{
 				memcpy(ptr, cdr.Transfer + cdr.FifoOffset, size);
 				cdr.FifoOffset += size;
-				psxCpu->Clear(madr, size / 4);
 			}
+			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);
 
 			CDRDMA_INT((cdsize/4) * 24);
 
@@ -1510,7 +1612,7 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) {
 			return;
 
 		default:
-			CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr);
+			CDR_LOG_I("psxDma3() Log: Unknown cddma %x\n", chcr);
 			break;
 	}
 
@@ -1545,9 +1647,15 @@ void cdrReset() {
 	cdr.Channel = 1;
 	cdr.Reg2 = 0x1f;
 	cdr.Stat = NoIntr;
-	cdr.DriveState = DRIVESTATE_STANDBY;
-	cdr.StatP = STATUS_ROTATING;
 	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;
@@ -1578,8 +1686,10 @@ int cdrFreeze(void *f, int Mode) {
 	if (Mode == 0) {
 		getCdInfo();
 
-		cdr.FifoOffset = tmp;
+		cdr.FifoOffset = tmp < DATA_SIZE ? tmp : DATA_SIZE;
 		cdr.FifoSize = (cdr.Mode & 0x20) ? 2340 : 2048 + 12;
+		if (cdr.SubqForwardSectors > SUBQ_FORWARD_SECTORS)
+			cdr.SubqForwardSectors = SUBQ_FORWARD_SECTORS;
 
 		// read right sub data
 		tmpp[0] = btoi(cdr.Prev[0]);
@@ -1596,7 +1706,7 @@ int cdrFreeze(void *f, int Mode) {
 			if (!Config.Cdda)
 				CDR_play(cdr.SetSectorPlay);
 			if (psxRegs.interrupt & (1 << PSXINT_CDRPLAY_OLD))
-				CDRPLAYSEEKREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime, 1);
+				CDRPLAYREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime, 1);
 		}
 
 		if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {