X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=libpcsxcore%2Fcdrom.c;h=3e31c0aeb63fe491bbb5613b13da395d01f6a2c9;hb=HEAD;hp=bcf83e71f8baa272047acbc1ec0233597df02f66;hpb=6320e9bf2cb2e02dabae682385d5fa9410114c9d;p=pcsx_rearmed.git

diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c
index bcf83e71..d4d14742 100644
--- a/libpcsxcore/cdrom.c
+++ b/libpcsxcore/cdrom.c
@@ -14,16 +14,20 @@
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
- *   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
+ *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
  ***************************************************************************/
 
-/* 
+/*
 * Handles all CD-ROM registers and functions.
 */
 
+#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
@@ -34,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
@@ -43,11 +48,85 @@
 #endif
 //#define CDR_LOG_CMD_IRQ
 
-cdrStruct cdr;
-static unsigned char *pTransfer;
+static struct {
+	// unused members maintain savesate compatibility
+	unsigned char unused0;
+	unsigned char unused1;
+	unsigned char IrqMask;
+	unsigned char unused2;
+	unsigned char Ctrl;
+	unsigned char IrqStat;
+
+	unsigned char StatP;
+
+	unsigned char Transfer[DATA_SIZE];
+	struct {
+		unsigned char Track;
+		unsigned char Index;
+		unsigned char Relative[3];
+		unsigned char Absolute[3];
+	} subq;
+	unsigned char TrackChanged;
+	unsigned char ReportDelay;
+	unsigned char PhysCdPropagations;
+	unsigned short sectorsRead;
+	unsigned int  freeze_ver;
+
+	unsigned char Prev[4];
+	unsigned char Param[8];
+	unsigned char Result[16];
+
+	unsigned char ParamC;
+	unsigned char ParamP;
+	unsigned char ResultC;
+	unsigned char ResultP;
+	unsigned char ResultReady;
+	unsigned char Cmd;
+	unsigned char SubqForwardSectors;
+	unsigned char SetlocPending;
+	u32 Reading;
+
+	unsigned char ResultTN[6];
+	unsigned char ResultTD[4];
+	unsigned char SetSectorPlay[4];
+	unsigned char SetSectorEnd[4];
+	unsigned char SetSector[4];
+	unsigned char Track;
+	boolean Play, Muted;
+	int CurTrack;
+	unsigned char Mode;
+	unsigned char FileChannelSelected;
+	unsigned char CurFile, CurChannel;
+	int FilterFile, FilterChannel;
+	unsigned char LocL[8];
+	int unused4;
+
+	xa_decode_t Xa;
+
+	u16 FifoOffset;
+	u16 FifoSize;
+
+	u16 CmdInProgress;
+	u8 Irq1Pending;
+	u8 AdpcmActive;
+	u32 LastReadSeekCycles;
+
+	u8 unused7;
+
+	u8 DriveState; // enum drive_state
+	u8 FastForward;
+	u8 FastBackward;
+	u8 errorRetryhack;
+
+	u8 AttenuatorLeftToLeft, AttenuatorLeftToRight;
+	u8 AttenuatorRightToRight, AttenuatorRightToLeft;
+	u8 AttenuatorLeftToLeftT, AttenuatorLeftToRightT;
+	u8 AttenuatorRightToRightT, AttenuatorRightToLeftT;
+} cdr;
+static s16 read_buf[CD_FRAMESIZE_RAW/2];
 
 /* CD-ROM magic numbers */
-#define CdlSync        0
+#define CdlSync        0  /* nocash documentation : "Uh, actually, returns error code 40h = Invalid Command...?" */
 #define CdlNop         1
 #define CdlSetloc      2
 #define CdlPlay        3
@@ -57,12 +136,12 @@ static unsigned char *pTransfer;
 #define CdlStandby     7
 #define CdlStop        8
 #define CdlPause       9
-#define CdlInit        10
+#define CdlReset       10
 #define CdlMute        11
 #define CdlDemute      12
 #define CdlSetfilter   13
 #define CdlSetmode     14
-#define CdlGetmode     15
+#define CdlGetparam    15
 #define CdlGetlocL     16
 #define CdlGetlocP     17
 #define CdlReadT       18
@@ -75,19 +154,22 @@ static unsigned char *pTransfer;
 #define CdlTest        25
 #define CdlID          26
 #define CdlReadS       27
-#define CdlReset       28
+#define CdlInit        28
+#define CdlGetQ        29
 #define CdlReadToc     30
 
-char *CmdName[0x100]= {
+#ifdef CDR_LOG_CMD_IRQ
+static const char * const CmdName[0x100] = {
     "CdlSync",     "CdlNop",       "CdlSetloc",  "CdlPlay",
     "CdlForward",  "CdlBackward",  "CdlReadN",   "CdlStandby",
-    "CdlStop",     "CdlPause",     "CdlInit",    "CdlMute",
-    "CdlDemute",   "CdlSetfilter", "CdlSetmode", "CdlGetmode",
+    "CdlStop",     "CdlPause",     "CdlReset",    "CdlMute",
+    "CdlDemute",   "CdlSetfilter", "CdlSetmode", "CdlGetparam",
     "CdlGetlocL",  "CdlGetlocP",   "CdlReadT",   "CdlGetTN",
     "CdlGetTD",    "CdlSeekL",     "CdlSeekP",   "CdlSetclock",
     "CdlGetclock", "CdlTest",      "CdlID",      "CdlReadS",
-    "CdlReset",    NULL,           "CDlReadToc", NULL
+    "CdlInit",     NULL,           "CDlReadToc", NULL
 };
+#endif
 
 unsigned char Test04[] = { 0 };
 unsigned char Test05[] = { 0 };
@@ -95,7 +177,7 @@ unsigned char Test20[] = { 0x98, 0x06, 0x10, 0xC3 };
 unsigned char Test22[] = { 0x66, 0x6F, 0x72, 0x20, 0x45, 0x75, 0x72, 0x6F };
 unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 };
 
-// cdr.Stat:
+// cdr.IrqStat:
 #define NoIntr		0
 #define DataReady	1
 #define Complete	2
@@ -120,20 +202,34 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 };
 #define STATUS_READ      (1<<5) // 0x20
 #define STATUS_SHELLOPEN (1<<4) // 0x10
 #define STATUS_UNKNOWN3  (1<<3) // 0x08
-#define STATUS_UNKNOWN2  (1<<2) // 0x04
+#define STATUS_SEEKERROR (1<<2) // 0x04
 #define STATUS_ROTATING  (1<<1) // 0x02
 #define STATUS_ERROR     (1<<0) // 0x01
 
+/* Errors */
+#define ERROR_NOTREADY   (1<<7) // 0x80
+#define ERROR_INVALIDCMD (1<<6) // 0x40
+#define ERROR_BAD_ARGNUM (1<<5) // 0x20
+#define ERROR_BAD_ARGVAL (1<<4) // 0x10
+#define ERROR_SHELLOPEN  (1<<3) // 0x08
 
 // 1x = 75 sectors per second
 // PSXCLK = 1 sec in the ps
 // so (PSXCLK / 75) = cdr read time (linuzappz)
 #define cdReadTime (PSXCLK / 75)
 
-// for cdr.Seeked
-enum seeked_state {
-	SEEK_PENDING = 0,
-	SEEK_DONE = 1,
+#define LOCL_INVALID 0xff
+#define SUBQ_FORWARD_SECTORS 2u
+
+enum drive_state {
+	DRIVESTATE_STANDBY = 0, // different from paused
+	DRIVESTATE_LID_OPEN,
+	DRIVESTATE_RESCAN_CD,
+	DRIVESTATE_PREPARE_CD,
+	DRIVESTATE_STOPPED,
+	DRIVESTATE_PAUSED,
+	DRIVESTATE_PLAY_READ,
+	DRIVESTATE_SEEK,
 };
 
 static struct CdrStat stat;
@@ -155,229 +251,157 @@ 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); \
-}
-
-// cdrReadInterrupt
-#define CDREAD_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); \
-}
-
-// cdrPlayInterrupt
-#define CDRMISC_INT(eCycle) { \
-	psxRegs.interrupt |= (1 << PSXINT_CDRPLAY); \
-	psxRegs.intCycle[PSXINT_CDRPLAY].cycle = eCycle; \
-	psxRegs.intCycle[PSXINT_CDRPLAY].sCycle = psxRegs.cycle; \
-	new_dyna_set_event(PSXINT_CDRPLAY, 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() { \
-	if (cdr.Reading) { \
-		cdr.Reading = 0; \
-		psxRegs.interrupt &= ~(1 << PSXINT_CDREAD); \
-	} \
-	cdr.StatP &= ~STATUS_READ;\
+	cdr.Reading = 0; \
+	psxRegs.interrupt &= ~(1 << PSXINT_CDREAD); \
 }
 
 #define StopCdda() { \
-	if (cdr.Play) { \
-		if (!Config.Cdda) CDR_stop(); \
-		cdr.StatP &= ~STATUS_PLAY; \
-		cdr.Play = FALSE; \
-		cdr.FastForward = 0; \
-		cdr.FastBackward = 0; \
-		/*SPU_registerCallback( SPUirq );*/ \
-	} \
+	if (cdr.Play && !Config.Cdda) CDR_stop(); \
+	cdr.Play = FALSE; \
+	cdr.FastForward = 0; \
+	cdr.FastBackward = 0; \
 }
 
-#define SetResultSize(size) { \
+#define SetPlaySeekRead(x, f) { \
+	x &= ~(STATUS_PLAY | STATUS_SEEK | STATUS_READ); \
+	x |= f; \
+}
+
+#define SetResultSize_(size) { \
 	cdr.ResultP = 0; \
 	cdr.ResultC = size; \
 	cdr.ResultReady = 1; \
 }
 
-static void setIrq(void)
-{
-	if (cdr.Stat & cdr.Reg2)
-		psxHu32ref(0x1070) |= SWAP32((u32)0x4);
+#define SetResultSize(size) { \
+	if (cdr.ResultP < cdr.ResultC) \
+		CDR_LOG_I("overwriting result, len=%u\n", cdr.ResultC); \
+	SetResultSize_(size); \
 }
 
-void cdrLidSeekInterrupt()
+static void setIrq(u8 irq, int log_cmd)
 {
-	// turn back on checking
-	if( cdr.LidCheck == 0x10 )
-	{
-		cdr.LidCheck = 0;
-	}
-
-	// official lid close
-	else if( cdr.LidCheck == 0x30 )
-	{
-		// GS CDX 3.3: $13
-		cdr.StatP |= STATUS_ROTATING;
-
+	u8 old = cdr.IrqStat & cdr.IrqMask ? 1 : 0;
+	u8 new_ = irq & cdr.IrqMask ? 1 : 0;
 
-		// GS CDX 3.3 - ~50 getlocp tries
-		CDRLID_INT( cdReadTime * 3 );
-		cdr.LidCheck = 0x40;
-	}
-
-	// turn off ready
-	else if( cdr.LidCheck == 0x40 )
-	{
-		// GS CDX 3.3: $01
-		cdr.StatP &= ~STATUS_SHELLOPEN;
-		cdr.StatP &= ~STATUS_ROTATING;
-
-
-		// GS CDX 3.3 - ~50 getlocp tries
-		CDRLID_INT( cdReadTime * 3 );
-		cdr.LidCheck = 0x50;
-	}
-
-	// now seek
-	else if( cdr.LidCheck == 0x50 )
-	{
-		// GameShark Lite: Start seeking ($42)
-		cdr.StatP |= STATUS_SEEK;
-		cdr.StatP |= STATUS_ROTATING;
-		cdr.StatP &= ~STATUS_ERROR;
-
-
-		CDRLID_INT( cdReadTime * 3 );
-		cdr.LidCheck = 0x60;
-	}
+	cdr.IrqStat = irq;
+	if ((old ^ new_) & new_)
+		psxHu32ref(0x1070) |= SWAP32((u32)0x4);
 
-	// done = cd ready
-	else if( cdr.LidCheck == 0x60 )
+#ifdef CDR_LOG_CMD_IRQ
+	if (cdr.IrqStat)
 	{
-		// GameShark Lite: Seek detection done ($02)
-		cdr.StatP &= ~STATUS_SEEK;
-
-		cdr.LidCheck = 0;
+		int i;
+		CDR_LOG_I("CDR IRQ=%d cmd %02x irqstat %02x: ",
+			!!(cdr.IrqStat & cdr.IrqMask), log_cmd, cdr.IrqStat);
+		for (i = 0; i < cdr.ResultC; i++)
+			SysPrintf("%02x ", cdr.Result[i]);
+		SysPrintf("\n");
 	}
+#endif
 }
 
-static void Check_Shell( int Irq )
+// timing used in this function was taken from tests on real hardware
+// (yes it's slow, but you probably don't want to modify it)
+void cdrLidSeekInterrupt(void)
 {
-	// check case open/close
-	if (cdr.LidCheck > 0)
-	{
-		CDR_LOG( "LidCheck\n" );
-
-		// $20 = check lid state
-		if( cdr.LidCheck == 0x20 )
-		{
-			u32 i;
-
-			i = stat.Status;
-			if (CDR_getStatus(&stat) != -1)
-			{
-				// BIOS hangs + BIOS error messages
-				//if (stat.Type == 0xff)
-					//cdr.Stat = DiskError;
-
-				// case now open
-				if (stat.Status & STATUS_SHELLOPEN)
-				{
-					// Vib Ribbon: pre-CD swap
-					StopCdda();
-					StopReading();
-
-
-					// GameShark Lite: Death if DiskError happens
-					//
-					// Vib Ribbon: Needs DiskError for CD swap
-
-					//if (Irq != CdlNop)
-					{
-						cdr.Stat = DiskError;
-
-						cdr.StatP |= STATUS_ERROR;
-						cdr.Result[0] |= STATUS_ERROR;
-					}
-
-					// GameShark Lite: Wants -exactly- $10
-					cdr.StatP |= STATUS_SHELLOPEN;
-					cdr.StatP &= ~STATUS_ROTATING;
-
-
-					CDRLID_INT( cdReadTime * 3 );
-					cdr.LidCheck = 0x10;
-
-
-					// GS CDX 3.3 = $11
-				}
-
-				// case just closed
-				else if ( i & STATUS_SHELLOPEN )
-				{
-					cdr.StatP |= STATUS_ROTATING;
-
-					CheckCdrom();
-
-
-					if( cdr.Stat == NoIntr )
-						cdr.Stat = Acknowledge;
-
-					setIrq();
-
-					// begin close-seek-ready cycle
-					CDRLID_INT( cdReadTime * 3 );
-					cdr.LidCheck = 0x30;
+	CDR_LOG_I("%s cdr.DriveState=%d\n", __func__, cdr.DriveState);
 
+	switch (cdr.DriveState) {
+	default:
+	case DRIVESTATE_STANDBY:
+		StopCdda();
+		//StopReading();
+		SetPlaySeekRead(cdr.StatP, 0);
 
-					// GameShark Lite: Wants -exactly- $42, then $02
-					// GS CDX 3.3: Wants $11/$80, $13/$80, $01/$00
-				}
+		if (CDR_getStatus(&stat) == -1)
+			return;
 
-				// case still closed - wait for recheck
-				else
-				{
-					CDRLID_INT( cdReadTime * 3 );
-					cdr.LidCheck = 0x10;
-				}
-			}
+		if (stat.Status & STATUS_SHELLOPEN)
+		{
+			memset(cdr.Prev, 0xff, sizeof(cdr.Prev));
+			cdr.DriveState = DRIVESTATE_LID_OPEN;
+			set_event(PSXINT_CDRLID, 0x800);
 		}
+		break;
 
+	case DRIVESTATE_LID_OPEN:
+		if (CDR_getStatus(&stat) == -1)
+			stat.Status &= ~STATUS_SHELLOPEN;
+
+		// 02, 12, 10
+		if (!(cdr.StatP & STATUS_SHELLOPEN)) {
+			StopReading();
+			SetPlaySeekRead(cdr.StatP, 0);
+			cdr.StatP |= STATUS_SHELLOPEN;
+
+			// IIRC this sometimes doesn't happen on real hw
+			// (when lots of commands are sent?)
+			SetResultSize(2);
+			cdr.Result[0] = cdr.StatP | STATUS_SEEKERROR;
+			cdr.Result[1] = ERROR_SHELLOPEN;
+			if (cdr.CmdInProgress) {
+				psxRegs.interrupt &= ~(1 << PSXINT_CDR);
+				cdr.CmdInProgress = 0;
+				cdr.Result[0] = cdr.StatP | STATUS_ERROR;
+				cdr.Result[1] = ERROR_NOTREADY;
+			}
+			setIrq(DiskError, 0x1006);
 
-		// GS CDX: clear all values but #1,#2
-		if( (cdr.LidCheck >= 0x30) || (cdr.StatP & STATUS_SHELLOPEN) )
-		{
-			SetResultSize(16);
-			memset( cdr.Result, 0, 16 );
+			set_event(PSXINT_CDRLID, cdReadTime * 30);
+			break;
+		}
+		else if (cdr.StatP & STATUS_ROTATING) {
+			cdr.StatP &= ~STATUS_ROTATING;
+		}
+		else if (!(stat.Status & STATUS_SHELLOPEN)) {
+			// closed now
+			CheckCdrom();
 
-			cdr.Result[0] = cdr.StatP;
+			// cdr.StatP STATUS_SHELLOPEN is "sticky"
+			// and is only cleared by CdlNop
 
+			cdr.DriveState = DRIVESTATE_RESCAN_CD;
+			set_event(PSXINT_CDRLID, cdReadTime * 105);
+			break;
+		}
 
-			// GS CDX: special return value
-			if( cdr.StatP & STATUS_SHELLOPEN )
-			{
-				cdr.Result[1] = 0x80;
-			}
+		// recheck for close
+		set_event(PSXINT_CDRLID, cdReadTime * 3);
+		break;
 
+	case DRIVESTATE_RESCAN_CD:
+		cdr.StatP |= STATUS_ROTATING;
+		cdr.DriveState = DRIVESTATE_PREPARE_CD;
 
-			if( cdr.Stat == NoIntr )
-				cdr.Stat = Acknowledge;
+		// this is very long on real hardware, over 6 seconds
+		// make it a bit faster here...
+		set_event(PSXINT_CDRLID, cdReadTime * 150);
+		break;
 
-			setIrq();
+	case DRIVESTATE_PREPARE_CD:
+		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;
 	}
 }
 
@@ -444,27 +468,36 @@ 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]);
 
+	CDR_LOG("ReadTrack *** %02x:%02x:%02x\n", tmp[0], tmp[1], tmp[2]);
+
 	if (memcmp(cdr.Prev, tmp, 3) == 0)
-		return;
+		return 1;
 
-	CDR_LOG("ReadTrack *** %02x:%02x:%02x\n", tmp[0], tmp[1], tmp[2]);
+	read_ok = CDR_readTrack(tmp);
+	if (read_ok)
+		memcpy(cdr.Prev, tmp, 3);
+	return read_ok;
+}
 
-	cdr.RErr = CDR_readTrack(tmp);
-	memcpy(cdr.Prev, tmp, 3);
+static void UpdateSubq(const u8 *time)
+{
+	const struct SubQ *subq;
+	int s = MSF2SECT(time[0], time[1], time[2]);
+	u16 crc;
 
-	if (CheckSBI(time))
+	if (CheckSBI(s))
 		return;
 
-	subq = (struct SubQ *)CDR_getBufferSub();
+	subq = (struct SubQ *)CDR_getBufferSub(s);
 	if (subq != NULL && cdr.CurTrack == 1) {
 		crc = calcCrc((u8 *)subq + 12, 10);
 		if (crc == (((u16)subq->CRC[0] << 8) | subq->CRC[1])) {
@@ -474,8 +507,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 {
@@ -488,37 +521,40 @@ static void ReadTrack(const u8 *time) {
 		cdr.subq.Absolute[0], cdr.subq.Absolute[1], cdr.subq.Absolute[2]);
 }
 
-static void AddIrqQueue(unsigned char irq, unsigned long ecycle) {
-	if (cdr.Irq != 0)
-		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()
 {
-	if ((cdr.Mode & MODE_AUTOPAUSE) && cdr.TrackChanged) {
-		CDR_LOG( "CDDA STOP\n" );
+	u32 abs_lev_max = 0;
+	boolean abs_lev_chselect;
+	u32 i;
 
-		// Magic the Gathering
-		// - looping territory cdda
+	if ((cdr.Mode & MODE_AUTOPAUSE) && cdr.TrackChanged) {
+		CDR_LOG_I("autopause\n");
 
-		// ...?
-		//cdr.ResultReady = 1;
-		//cdr.Stat = DataReady;
-		cdr.Stat = DataEnd;
-		setIrq();
+		SetResultSize(1);
+		cdr.Result[0] = cdr.StatP;
+		setIrq(DataEnd, 0x1000); // 0x1000 just for logging purposes
 
 		StopCdda();
+		SetPlaySeekRead(cdr.StatP, 0);
+		cdr.DriveState = DRIVESTATE_PAUSED;
 	}
-	else if (cdr.Mode & MODE_REPORT) {
-
+	else if ((cdr.Mode & MODE_REPORT) && !cdr.ReportDelay &&
+		 ((cdr.subq.Absolute[2] & 0x0f) == 0 || cdr.FastForward || cdr.FastBackward))
+	{
+		SetResultSize(8);
 		cdr.Result[0] = cdr.StatP;
 		cdr.Result[1] = cdr.subq.Track;
 		cdr.Result[2] = cdr.subq.Index;
+		
+		abs_lev_chselect = cdr.subq.Absolute[1] & 0x01;
+		
+		/* 8 is a hack. For accuracy, it should be 588. */
+		for (i = 0; i < 8; i++)
+		{
+			abs_lev_max = MAX_VALUE(abs_lev_max, abs(read_buf[i * 2 + abs_lev_chselect]));
+		}
+		abs_lev_max = MIN_VALUE(abs_lev_max, 32767);
+		abs_lev_max |= abs_lev_chselect << 15;
 
 		if (cdr.subq.Absolute[2] & 0x10) {
 			cdr.Result[3] = cdr.subq.Relative[0];
@@ -530,129 +566,281 @@ static void cdrPlayInterrupt_Autopause()
 			cdr.Result[4] = cdr.subq.Absolute[1];
 			cdr.Result[5] = cdr.subq.Absolute[2];
 		}
+		cdr.Result[6] = abs_lev_max >> 0;
+		cdr.Result[7] = abs_lev_max >> 8;
 
-		cdr.Result[6] = 0;
-		cdr.Result[7] = 0;
+		setIrq(DataReady, 0x1001);
+	}
 
-		// Rayman: Logo freeze (resultready + dataready)
-		cdr.ResultReady = 1;
-		cdr.Stat = DataReady;
+	if (cdr.ReportDelay)
+		cdr.ReportDelay--;
+}
 
-		SetResultSize(8);
-		setIrq();
-	}
+static int cdrSeekTime(unsigned char *target)
+{
+	int diff = msf2sec(cdr.SetSectorPlay) - msf2sec(target);
+	int seekTime = abs(diff) * (cdReadTime / 2000);
+	int cyclesSinceRS = psxRegs.cycle - cdr.LastReadSeekCycles;
+	seekTime = MAX_VALUE(seekTime, 20000);
+
+	// Transformers Beast Wars Transmetals does Setloc(x),SeekL,Setloc(x),ReadN
+	// and then wants some slack time
+	if (cdr.DriveState == DRIVESTATE_PAUSED || cyclesSinceRS < cdReadTime *3/2)
+		seekTime += cdReadTime;
+
+	seekTime = MIN_VALUE(seekTime, PSXCLK * 2 / 3);
+	CDR_LOG("seek: %.2f %.2f (%.2f) st %d di %d\n", (float)seekTime / PSXCLK,
+		(float)seekTime / cdReadTime, (float)cyclesSinceRS / cdReadTime,
+		cdr.DriveState, diff);
+	return seekTime;
 }
 
-// also handles seek
-void cdrPlayInterrupt()
+static u32 cdrAlignTimingHack(u32 cycles)
 {
-	if (cdr.Seeked == SEEK_PENDING) {
-		if (cdr.Stat) {
-			CDR_LOG_I("cdrom: seek stat hack\n");
-			CDRMISC_INT(0x1000);
-			return;
+	/*
+	 * 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 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]++;
 		}
-		SetResultSize(1);
-		cdr.StatP |= STATUS_ROTATING;
-		cdr.StatP &= ~STATUS_SEEK;
-		cdr.Result[0] = cdr.StatP;
-		cdr.Seeked = SEEK_DONE;
-		if (cdr.Irq == 0) {
-			cdr.Stat = Complete;
-			setIrq();
+	}
+}
+
+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]--;
 		}
+	}
+}
 
-		memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
-		Find_CurTrack(cdr.SetSectorPlay);
-		ReadTrack(cdr.SetSectorPlay);
-		cdr.TrackChanged = FALSE;
+void cdrPlayReadInterrupt(void)
+{
+	int hit = CDR_prefetch(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]);
+	if (!hit && cdr.PhysCdPropagations++ < 222) {
+		// this propagates real cdrom delays to the emulated game
+		CDRPLAYREAD_INT(cdReadTime / 2, 0);
+		return;
+	}
+	cdr.PhysCdPropagations = 0;
+
+	cdr.LastReadSeekCycles = psxRegs.cycle;
+
+	if (cdr.Reading) {
+		cdrReadInterrupt();
+		return;
 	}
 
 	if (!cdr.Play) return;
 
-	CDR_LOG( "CDDA - %d:%d:%d\n",
-		cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] );
+	CDR_LOG("CDDA - %02d:%02d:%02d m %02x\n",
+		cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], cdr.Mode);
 
+	cdr.DriveState = DRIVESTATE_PLAY_READ;
+	SetPlaySeekRead(cdr.StatP, STATUS_PLAY);
 	if (memcmp(cdr.SetSectorPlay, cdr.SetSectorEnd, 3) == 0) {
+		CDR_LOG_I("end stop\n");
 		StopCdda();
+		SetPlaySeekRead(cdr.StatP, 0);
 		cdr.TrackChanged = TRUE;
+		cdr.DriveState = DRIVESTATE_PAUSED;
+	}
+	else {
+		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.IrqStat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT)))
 		cdrPlayInterrupt_Autopause();
 
-	if (!cdr.Play) return;
-
-	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.Play && !Config.Cdda) {
+		cdrPrepCdda(read_buf, CD_FRAMESIZE_RAW / 4);
+		SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW, psxRegs.cycle, 0);
 	}
 
-	CDRMISC_INT(cdReadTime);
+	msfiAdd(cdr.SetSectorPlay, 1);
+	CDR_prefetch(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]);
 
 	// update for CdlGetlocP/autopause
 	generate_subq(cdr.SetSectorPlay);
+
+	CDRPLAYREAD_INT(cdReadTime, 0);
+}
+
+static void softReset(void)
+{
+	CDR_getStatus(&stat);
+	if (stat.Status & STATUS_SHELLOPEN) {
+		cdr.DriveState = DRIVESTATE_LID_OPEN;
+		cdr.StatP = STATUS_SHELLOPEN;
+	}
+	else if (CdromId[0] == '\0') {
+		cdr.DriveState = DRIVESTATE_STOPPED;
+		cdr.StatP = 0;
+	}
+	else {
+		cdr.DriveState = DRIVESTATE_STANDBY;
+		cdr.StatP = STATUS_ROTATING;
+	}
+
+	cdr.FifoOffset = DATA_SIZE; // fifo empty
+	cdr.LocL[0] = LOCL_INVALID;
+	cdr.Mode = MODE_SIZE_2340;
+	cdr.Muted = FALSE;
+	SPU_setCDvol(cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
+		cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight, psxRegs.cycle);
 }
 
-void cdrInterrupt() {
+#define CMD_PART2           0x100
+#define CMD_WHILE_NOT_READY 0x200
+
+void cdrInterrupt(void) {
+	int start_rotating = 0;
+	int error = 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;
+	u8 IrqStat = Acknowledge;
+	u8 DriveStateOld;
+	u16 Cmd;
 	int i;
-	unsigned char Irq = cdr.Irq;
 
-	// Reschedule IRQ
-	if (cdr.Stat) {
-		CDR_LOG_I("cdrom: stat hack: %02x %x\n", cdr.Irq, cdr.Stat);
-		CDR_INT(0x1000);
+	if (cdr.IrqStat) {
+		CDR_LOG_I("cmd %02x with irqstat %x\n",
+			cdr.CmdInProgress, cdr.IrqStat);
+		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.Irq1Pending = 0;
+		setIrq((cdr.Irq1Pending & STATUS_ERROR) ? DiskError : DataReady, 0x1003);
 		return;
 	}
 
-	cdr.Irq = 0;
-	cdr.Ctrl &= ~0x80;
+	// default response
+	SetResultSize(1);
+	cdr.Result[0] = cdr.StatP;
 
-	switch (Irq) {
-		case CdlSync:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
+	Cmd = cdr.CmdInProgress;
+	cdr.CmdInProgress = 0;
+	ParamC = cdr.ParamC;
+
+	if (Cmd < 0x100) {
+		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 | not_ready) {
 		case CdlNop:
-			SetResultSize(1);
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
-
-			if (cdr.LidCheck == 0) cdr.LidCheck = 0x20;
+		case CdlNop + CMD_WHILE_NOT_READY:
+			if (cdr.DriveState != DRIVESTATE_LID_OPEN)
+				cdr.StatP &= ~STATUS_SHELLOPEN;
 			break;
 
 		case CdlSetloc:
-			cdr.CmdProcess = 0;
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
+		// case CdlSetloc + CMD_WHILE_NOT_READY: // or is it?
+			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_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_BAD_ARGNUM;
+				goto set_error;
+			}
+			else
+			{
+				for (i = 0; i < 3; i++)
+					set_loc[i] = btoi(cdr.Param[i]);
+				memcpy(cdr.SetSector, set_loc, 3);
+				cdr.SetSector[3] = 0;
+				cdr.SetlocPending = 1;
+				cdr.errorRetryhack = 0;
+			}
 			break;
 
+		do_CdlPlay:
 		case CdlPlay:
-			if (cdr.Seeked == SEEK_PENDING) {
-				// XXX: wrong, should seek instead..
-				memcpy( cdr.SetSectorPlay, cdr.SetSector, 4 );
-				cdr.Seeked = SEEK_DONE;
-			}
+			StopCdda();
+			StopReading();
+
+			cdr.FastBackward = 0;
+			cdr.FastForward = 0;
 
 			// BIOS CD Player
 			// - Pause player, hit Track 01/02/../xx (Setloc issued!!)
 
-			if (cdr.ParamC == 0 || cdr.Param[0] == 0) {
-				CDR_LOG("PLAY Resume @ %d:%d:%d\n",
-					cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]);
-			}
-			else
-			{
+			if (ParamC != 0 && cdr.Param[0] != 0) {
 				int track = btoi( cdr.Param[0] );
 
 				if (track <= cdr.ResultTN[1])
@@ -661,11 +849,21 @@ void cdrInterrupt() {
 				CDR_LOG("PLAY track %d\n", cdr.CurTrack);
 
 				if (CDR_getTD((u8)cdr.CurTrack, cdr.ResultTD) != -1) {
-					cdr.SetSectorPlay[0] = cdr.ResultTD[2];
-					cdr.SetSectorPlay[1] = cdr.ResultTD[1];
-					cdr.SetSectorPlay[2] = cdr.ResultTD[0];
+					for (i = 0; i < 3; i++)
+						set_loc[i] = cdr.ResultTD[2 - i];
+					seekTime = cdrSeekTime(set_loc);
+					memcpy(cdr.SetSectorPlay, set_loc, 3);
 				}
 			}
+			else if (cdr.SetlocPending) {
+				seekTime = cdrSeekTime(cdr.SetSector);
+				memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
+			}
+			else {
+				CDR_LOG("PLAY Resume @ %d:%d:%d\n",
+					cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]);
+			}
+			cdr.SetlocPending = 0;
 
 			/*
 			Rayman: detect track changes
@@ -678,220 +876,238 @@ void cdrInterrupt() {
 			- 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.FileChannelSelected = 0;
+			cdr.AdpcmActive = 0;
+			cdr.ReportDelay = 60;
+			cdr.sectorsRead = 0;
 
 			if (!Config.Cdda)
 				CDR_play(cdr.SetSectorPlay);
 
-			// Vib Ribbon: gameplay checks flag
-			cdr.StatP &= ~STATUS_SEEK;
-
-			cdr.CmdProcess = 0;
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
-
-			cdr.StatP |= STATUS_PLAY;
-
+			SetPlaySeekRead(cdr.StatP, STATUS_SEEK | STATUS_ROTATING);
 			
 			// BIOS player - set flag again
 			cdr.Play = TRUE;
+			cdr.DriveState = DRIVESTATE_PLAY_READ;
 
-			CDRMISC_INT( cdReadTime );
+			CDRPLAYREAD_INT(cdReadTime + seekTime, 1);
+			start_rotating = 1;
 			break;
 
 		case CdlForward:
-			cdr.CmdProcess = 0;
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Complete;
-
+			// TODO: error 80 if stopped
+			IrqStat = Complete;
 
 			// GameShark CD Player: Calls 2x + Play 2x
-			if( cdr.FastForward == 0 ) cdr.FastForward = 2;
-			else cdr.FastForward++;
-
+			cdr.FastForward = 1;
 			cdr.FastBackward = 0;
 			break;
 
 		case CdlBackward:
-			cdr.CmdProcess = 0;
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Complete;
-
+			IrqStat = Complete;
 
 			// GameShark CD Player: Calls 2x + Play 2x
-			if( cdr.FastBackward == 0 ) cdr.FastBackward = 2;
-			else cdr.FastBackward++;
-
+			cdr.FastBackward = 1;
 			cdr.FastForward = 0;
 			break;
 
 		case CdlStandby:
-			cdr.CmdProcess = 0;
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Complete;
+			if (cdr.DriveState != DRIVESTATE_STOPPED) {
+				error = ERROR_BAD_ARGNUM;
+				goto set_error;
+			}
+			cdr.DriveState = DRIVESTATE_STANDBY;
+			second_resp_time = cdReadTime * 125 / 2;
+			start_rotating = 1;
+			break;
+
+		case CdlStandby + CMD_PART2:
+			IrqStat = Complete;
 			break;
 
 		case CdlStop:
-			cdr.CmdProcess = 0;
-			SetResultSize(1);
+			if (cdr.Play) {
+				// grab time for current track
+				CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD);
+
+				cdr.SetSectorPlay[0] = cdr.ResultTD[2];
+				cdr.SetSectorPlay[1] = cdr.ResultTD[1];
+				cdr.SetSectorPlay[2] = cdr.ResultTD[0];
+			}
+
+			StopCdda();
+			StopReading();
+			SetPlaySeekRead(cdr.StatP, 0);
 			cdr.StatP &= ~STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Complete;
-//			cdr.Stat = Acknowledge;
+			cdr.LocL[0] = LOCL_INVALID;
+
+			second_resp_time = 0x800;
+			if (cdr.DriveState != DRIVESTATE_STOPPED)
+				second_resp_time = cdReadTime * 30 / 2;
 
-			if (cdr.LidCheck == 0) cdr.LidCheck = 0x20;
+			cdr.DriveState = DRIVESTATE_STOPPED;
 			break;
 
-		case CdlPause:
-			SetResultSize(1);
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
+		case CdlStop + CMD_PART2:
+			IrqStat = Complete;
+			break;
 
-			/*
-			Gundam Battle Assault 2: much slower (*)
-			- Fixes boot, gameplay
+		case CdlPause:
+			if (cdr.AdpcmActive) {
+				cdr.AdpcmActive = 0;
+				cdr.Xa.nsamples = 0;
+				SPU_playADPCMchannel(&cdr.Xa, psxRegs.cycle, 1); // flush adpcm
+			}
+			StopCdda();
+			StopReading();
 
-			Hokuto no Ken 2: slower
-			- Fixes intro + subtitles
+			// 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;
 
-			InuYasha - Feudal Fairy Tale: slower
-			- Fixes battles
+			/*
+			Gundam Battle Assault 2
+			Hokuto no Ken 2
+			InuYasha - Feudal Fairy Tale
+			Dance Dance Revolution Konamix
+			...
 			*/
-			AddIrqQueue(CdlPause + 0x20, cdReadTime * 3);
-			cdr.Ctrl |= 0x80;
+			if (!(cdr.StatP & (STATUS_PLAY | STATUS_READ)))
+			{
+				second_resp_time = 7000;
+			}
+			else
+			{
+				second_resp_time = 2 * 1097107;
+			}
+			SetPlaySeekRead(cdr.StatP, 0);
+			DriveStateOld = cdr.DriveState;
+			cdr.DriveState = DRIVESTATE_PAUSED;
+			if (DriveStateOld == DRIVESTATE_SEEK) {
+				// According to Duckstation this fails, but the
+				// exact conditions and effects are not clear.
+				// Moto Racer World Tour seems to rely on this.
+				// For now assume pause works anyway, just errors out.
+				error = ERROR_NOTREADY;
+				goto set_error;
+			}
 			break;
 
-		case CdlPause + 0x20:
-			SetResultSize(1);
-			cdr.StatP &= ~STATUS_READ;
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Complete;
+		case CdlPause + CMD_PART2:
+			IrqStat = Complete;
 			break;
 
-		case CdlInit:
-			SetResultSize(1);
-			cdr.StatP = STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
-//			if (!cdr.Init) {
-				AddIrqQueue(CdlInit + 0x20, 0x800);
-//			}
-        	break;
-
-		case CdlInit + 0x20:
-			SetResultSize(1);
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Complete;
-			cdr.Init = 1;
+		case CdlReset:
+		case CdlReset + CMD_WHILE_NOT_READY:
+			// note: nocash and Duckstation calls this 'Init', but
+			// the official SDK calls it 'Reset', and so do we
+			StopCdda();
+			StopReading();
+			softReset();
+			second_resp_time = not_ready ? 70000 : 4100000;
+			start_rotating = 1;
+			break;
+
+		case CdlReset + CMD_PART2:
+		case CdlReset + CMD_PART2 + CMD_WHILE_NOT_READY:
+			IrqStat = Complete;
 			break;
 
 		case CdlMute:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
+			cdr.Muted = TRUE;
+			SPU_setCDvol(0, 0, 0, 0, psxRegs.cycle);
 			break;
 
 		case CdlDemute:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
+			cdr.Muted = FALSE;
+			SPU_setCDvol(cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
+				cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight, psxRegs.cycle);
 			break;
 
 		case CdlSetfilter:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge; 
+			cdr.FilterFile = cdr.Param[0];
+			cdr.FilterChannel = cdr.Param[1];
+			cdr.FileChannelSelected = 0;
 			break;
 
 		case CdlSetmode:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
+		case CdlSetmode + CMD_WHILE_NOT_READY:
+			CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]);
+			cdr.Mode = cdr.Param[0];
 			break;
 
-		case CdlGetmode:
-			SetResultSize(6);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
+		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] = cdr.File;
-			cdr.Result[3] = cdr.Channel;
-			cdr.Result[4] = 0;
-			cdr.Result[5] = 0;
-			cdr.Stat = Acknowledge;
+			cdr.Result[2] = 0;
+			cdr.Result[3] = cdr.FilterFile;
+			cdr.Result[4] = cdr.FilterChannel;
 			break;
 
 		case CdlGetlocL:
-			SetResultSize(8);
-			for (i = 0; i < 8; i++)
-				cdr.Result[i] = cdr.Transfer[i];
-			cdr.Stat = Acknowledge;
+			if (cdr.LocL[0] == LOCL_INVALID) {
+				error = 0x80;
+				goto set_error;
+			}
+			SetResultSize_(8);
+			memcpy(cdr.Result, cdr.LocL, 8);
 			break;
 
 		case CdlGetlocP:
-			SetResultSize(8);
+			SetResultSize_(8);
 			memcpy(&cdr.Result, &cdr.subq, 8);
+			break;
 
-			if (!cdr.Play && !cdr.Reading)
-				cdr.Result[1] = 0; // HACK?
+		case CdlReadT: // SetSession?
+			// really long
+			second_resp_time = cdReadTime * 290 / 4;
+			start_rotating = 1;
+			break;
 
-			cdr.Stat = Acknowledge;
+		case CdlReadT + CMD_PART2:
+			IrqStat = Complete;
 			break;
 
 		case CdlGetTN:
-			cdr.CmdProcess = 0;
-			SetResultSize(3);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
 			if (CDR_getTN(cdr.ResultTN) == -1) {
-				cdr.Stat = DiskError;
-				cdr.Result[0] |= STATUS_ERROR;
-			} else {
-				cdr.Stat = Acknowledge;
-				cdr.Result[1] = itob(cdr.ResultTN[0]);
-				cdr.Result[2] = itob(cdr.ResultTN[1]);
+				assert(0);
 			}
+			SetResultSize_(3);
+			cdr.Result[1] = itob(cdr.ResultTN[0]);
+			cdr.Result[2] = itob(cdr.ResultTN[1]);
 			break;
 
 		case CdlGetTD:
-			cdr.CmdProcess = 0;
 			cdr.Track = btoi(cdr.Param[0]);
-			SetResultSize(4);
-			cdr.StatP |= STATUS_ROTATING;
 			if (CDR_getTD(cdr.Track, cdr.ResultTD) == -1) {
-				cdr.Stat = DiskError;
-				cdr.Result[0] |= STATUS_ERROR;
-			} else {
-				cdr.Stat = Acknowledge;
-				cdr.Result[0] = cdr.StatP;
-				cdr.Result[1] = itob(cdr.ResultTD[2]);
-				cdr.Result[2] = itob(cdr.ResultTD[1]);
-				cdr.Result[3] = itob(cdr.ResultTD[0]);
+				error = ERROR_BAD_ARGVAL;
+				goto set_error;
 			}
+			SetResultSize_(3);
+			cdr.Result[1] = itob(cdr.ResultTD[2]);
+			cdr.Result[2] = itob(cdr.ResultTD[1]);
+			// no sector number
+			//cdr.Result[3] = itob(cdr.ResultTD[0]);
 			break;
 
 		case CdlSeekL:
 		case CdlSeekP:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.StatP |= STATUS_SEEK;
-			cdr.Stat = Acknowledge;
-
+			StopCdda();
+			StopReading();
+			SetPlaySeekRead(cdr.StatP, STATUS_SEEK | STATUS_ROTATING);
+
+			seekTime = cdrSeekTime(cdr.SetSector);
+			memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
+			cdr.DriveState = DRIVESTATE_SEEK;
+			CDR_prefetch(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1],
+					cdr.SetSectorPlay[2]);
 			/*
 			Crusaders of Might and Magic = 0.5x-4x
 			- fix cutscene speech start
@@ -905,38 +1121,50 @@ void cdrInterrupt() {
 			Rockman X5 = 0.5-4x
 			- fix capcom logo
 			*/
-			CDRMISC_INT(cdr.Seeked == SEEK_DONE ? 0x800 : cdReadTime * 4);
-			cdr.Seeked = SEEK_PENDING;
+			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;
+			IrqStat = 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.DriveState = DRIVESTATE_STANDBY;
+			cdr.TrackChanged = FALSE;
+			cdr.LastReadSeekCycles = psxRegs.cycle;
 			break;
 
 		case CdlTest:
-			cdr.Stat = Acknowledge;
+		case CdlTest + CMD_WHILE_NOT_READY:
 			switch (cdr.Param[0]) {
 				case 0x20: // System Controller ROM Version
-					SetResultSize(4);
+					SetResultSize_(4);
 					memcpy(cdr.Result, Test20, 4);
 					break;
 				case 0x22:
-					SetResultSize(8);
+					SetResultSize_(8);
 					memcpy(cdr.Result, Test22, 4);
 					break;
 				case 0x23: case 0x24:
-					SetResultSize(8);
+					SetResultSize_(8);
 					memcpy(cdr.Result, Test23, 4);
 					break;
 			}
 			break;
 
 		case CdlID:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
-			AddIrqQueue(CdlID + 0x20, 0x800);
+			second_resp_time = 20480;
 			break;
 
-		case CdlID + 0x20:
-			SetResultSize(8);
+		case CdlID + CMD_PART2:
+			SetResultSize_(8);
 			cdr.Result[0] = cdr.StatP;
 			cdr.Result[1] = 0;
 			cdr.Result[2] = 0;
@@ -953,115 +1181,115 @@ void cdrInterrupt() {
 					cdr.Result[1] |= 0x80;
 			}
 			cdr.Result[0] |= (cdr.Result[1] >> 4) & 0x08;
+			CDR_LOG_I("CdlID: %02x %02x %02x %02x\n", cdr.Result[0],
+				cdr.Result[1], cdr.Result[2], cdr.Result[3]);
 
-			strncpy((char *)&cdr.Result[4], "PCSX", 4);
-			cdr.Stat = Complete;
+			/* This adds the string "PCSX" in Playstation bios boot screen */
+			memcpy((char *)&cdr.Result[4], "PCSX", 4);
+			IrqStat = Complete;
 			break;
 
-		case CdlReset:
-			SetResultSize(1);
-			cdr.StatP = STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
-			break;
-
-		case CdlReadT:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
-			AddIrqQueue(CdlReadT + 0x20, 0x800);
+		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;
+			set_event(PSXINT_CDRLID, 20480);
+			start_rotating = 1;
 			break;
 
-		case CdlReadT + 0x20:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Complete;
+		case CdlGetQ:
+		case CdlGetQ + CMD_WHILE_NOT_READY:
 			break;
 
 		case CdlReadToc:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
-			AddIrqQueue(CdlReadToc + 0x20, cdReadTime * 16);
+		case CdlReadToc + CMD_WHILE_NOT_READY:
+			cdr.LocL[0] = LOCL_INVALID;
+			second_resp_time = cdReadTime * 180 / 4;
+			start_rotating = 1;
 			break;
 
-		case CdlReadToc + 0x20:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Complete;
+		case CdlReadToc + CMD_PART2:
+		case CdlReadToc + CMD_PART2 + CMD_WHILE_NOT_READY:
+			IrqStat = Complete;
 			break;
 
 		case CdlReadN:
 		case CdlReadS:
-			if (!cdr.Reading) return;
-
-			// Fighting Force 2 - update subq time immediately
-			// - fixes new game
-			Find_CurTrack(cdr.SetSector);
-			ReadTrack(cdr.SetSector);
-
-
-			// Crusaders of Might and Magic - update getlocl now
-			// - fixes cutscene speech
-			{
-				u8 *buf = CDR_getBuffer();
-				if (buf != NULL)
-					memcpy(cdr.Transfer, buf, 8);
-			}
-
-			/*
-			Duke Nukem: Land of the Babes - seek then delay read for one frame
-			- fixes cutscenes
-			C-12 - Final Resistance - doesn't like seek
-			*/
-
-			if (cdr.Seeked != SEEK_DONE) {
-				cdr.StatP |= STATUS_SEEK;
-				cdr.StatP &= ~STATUS_READ;
+			if (cdr.Reading && !cdr.SetlocPending)
+				break;
 
-				// Crusaders of Might and Magic - use short time
-				// - fix cutscene speech (startup)
+			Find_CurTrack(cdr.SetlocPending ? cdr.SetSector : cdr.SetSectorPlay);
 
-				// ??? - use more accurate seek time later
-				CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1);
-			} else {
-				cdr.StatP |= STATUS_READ;
-				cdr.StatP &= ~STATUS_SEEK;
+			if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1)
+				// Read* acts as play for cdda tracks in cdda mode
+				goto do_CdlPlay;
 
-				CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1);
+			StopCdda();
+			if (cdr.SetlocPending) {
+				seekTime = cdrSeekTime(cdr.SetSector);
+				memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
+				cdr.SetlocPending = 0;
 			}
+			cdr.Reading = 1;
+			cdr.FileChannelSelected = 0;
+			cdr.AdpcmActive = 0;
 
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
+			// Fighting Force 2 - update subq time immediately
+			// - fixes new game
+			UpdateSubq(cdr.SetSectorPlay);
+			cdr.LocL[0] = LOCL_INVALID;
+			cdr.SubqForwardSectors = 1;
+			cdr.sectorsRead = 0;
+			cdr.DriveState = DRIVESTATE_SEEK;
+			CDR_prefetch(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1],
+					cdr.SetSectorPlay[2]);
+
+			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.Stat = Complete;
+			error = ERROR_INVALIDCMD;
+			// FALLTHROUGH
+
+		set_error:
+			SetResultSize_(2);
+			cdr.Result[0] = cdr.StatP | STATUS_ERROR;
+			cdr.Result[1] = not_ready ? ERROR_NOTREADY : error;
+			IrqStat = DiskError;
+			CDR_LOG_I("cmd %02x error %02x\n", Cmd, cdr.Result[1]);
 			break;
 	}
 
-	Check_Shell( Irq );
-
-	cdr.ParamC = 0;
+	if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) {
+		cdr.DriveState = DRIVESTATE_STANDBY;
+		cdr.StatP |= STATUS_ROTATING;
+	}
 
-	setIrq();
+	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);
+	}
 
-#ifdef CDR_LOG_CMD_IRQ
-	SysPrintf("IRQ %d cmd %02x stat %02x: ",
-		!!(cdr.Stat & cdr.Reg2), Irq, cdr.Stat);
-	for (i = 0; i < cdr.ResultC; i++)
-		SysPrintf("%02x ", cdr.Result[i]);
-	SysPrintf("\n");
-#endif
+	setIrq(IrqStat, Cmd);
 }
 
-#ifdef __ARM_ARCH_7A__
+#ifdef HAVE_ARMV7
  #define ssat32_to_16(v) \
   asm("ssat %0,#16,%1" : "=r" (v) : "r" (v))
 #else
@@ -1071,117 +1299,120 @@ void cdrInterrupt() {
  } while (0)
 #endif
 
-void cdrAttenuate(s16 *buf, int samples, int stereo)
+static void cdrPrepCdda(s16 *buf, int samples)
 {
-	int i, l, r;
-	int ll = cdr.AttenuatorLeftToLeft;
-	int lr = cdr.AttenuatorLeftToRight;
-	int rl = cdr.AttenuatorRightToLeft;
-	int rr = cdr.AttenuatorRightToRight;
-
-	if (lr == 0 && rl == 0 && 0x78 <= ll && ll <= 0x88 && 0x78 <= rr && rr <= 0x88)
-		return;
+#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
+}
 
-	if (!stereo && ll == 0x40 && lr == 0x40 && rl == 0x40 && rr == 0x40)
+static void cdrReadInterruptSetResult(unsigned char result)
+{
+	if (cdr.IrqStat) {
+		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.IrqStat);
+		cdr.Irq1Pending = result;
 		return;
-
-	if (stereo) {
-		for (i = 0; i < samples; i++) {
-			l = buf[i * 2];
-			r = buf[i * 2 + 1];
-			l = (l * ll + r * rl) >> 7;
-			r = (r * rr + l * lr) >> 7;
-			ssat32_to_16(l);
-			ssat32_to_16(r);
-			buf[i * 2] = l;
-			buf[i * 2 + 1] = r;
-		}
-	}
-	else {
-		for (i = 0; i < samples; i++) {
-			l = buf[i];
-			l = l * (ll + rl) >> 7;
-			//r = r * (rr + lr) >> 7;
-			ssat32_to_16(l);
-			//ssat32_to_16(r);
-			buf[i] = l;
-		}
 	}
+	SetResultSize(1);
+	cdr.Result[0] = result;
+	setIrq((result & STATUS_ERROR) ? DiskError : DataReady, 0x1004);
 }
 
-void cdrReadInterrupt() {
-	u8 *buf;
-
-	if (!cdr.Reading)
+static void cdrUpdateTransferBuf(const 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);
-		CDREAD_INT(0x1000);
+static void cdrReadInterrupt(void)
+{
+	const struct { u8 file, chan, mode, coding; } *subhdr;
+	const u8 *buf = NULL;
+	int deliver_data = 1;
+	u8 subqPos[3];
+	int read_ok;
+	int is_start;
+
+	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);
-	cdr.StatP |= STATUS_READ|STATUS_ROTATING;
-	cdr.StatP &= ~STATUS_SEEK;
-	cdr.Result[0] = cdr.StatP;
-	cdr.Seeked = SEEK_DONE;
-
-	ReadTrack(cdr.SetSector);
+	// note: CdlGetlocL should work as soon as STATUS_READ is indicated
+	SetPlaySeekRead(cdr.StatP, STATUS_READ | STATUS_ROTATING);
+	cdr.DriveState = DRIVESTATE_PLAY_READ;
+	cdr.sectorsRead++;
 
-	buf = CDR_getBuffer();
+	read_ok = ReadTrack(cdr.SetSectorPlay);
+	if (read_ok)
+		buf = CDR_getBuffer();
 	if (buf == NULL)
-		cdr.RErr = -1;
+		read_ok = 0;
 
-	if (cdr.RErr == -1) {
+	if (!read_ok) {
 		CDR_LOG_I("cdrReadInterrupt() Log: err\n");
-		memset(cdr.Transfer, 0, DATA_SIZE);
-		cdr.Stat = DiskError;
-		cdr.Result[0] |= STATUS_ERROR;
-		CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime);
+		cdrReadInterruptSetResult(cdr.StatP | STATUS_ERROR);
+		cdr.DriveState = DRIVESTATE_PAUSED; // ?
 		return;
 	}
+	memcpy(cdr.LocL, buf, 8);
 
-	memcpy(cdr.Transfer, buf, DATA_SIZE);
-	CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]);
-
+	if (!cdr.IrqStat && !cdr.Irq1Pending)
+		cdrUpdateTransferBuf(buf);
 
-	CDR_LOG("cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]);
-
-	if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA
-		// 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];
+	subhdr = (void *)(buf + 4);
+	do {
+		// try to process as adpcm
+		if (!(cdr.Mode & MODE_STRSND))
+			break;
+		if (buf[3] != 2 || (subhdr->mode & 0x44) != 0x44) // or 0x64?
+			break;
+		CDR_LOG("f=%d m=%d %d,%3d | %d,%2d | %d,%2d\n", !!(cdr.Mode & MODE_SF), cdr.Muted,
+			subhdr->file, subhdr->chan, cdr.CurFile, cdr.CurChannel, cdr.FilterFile, cdr.FilterChannel);
+		if ((cdr.Mode & MODE_SF) && (subhdr->file != cdr.FilterFile || subhdr->chan != cdr.FilterChannel))
+			break;
+		if (subhdr->chan & 0x80) { // ?
+			if (subhdr->chan != 0xff)
+				log_unhandled("adpcm %d:%d\n", subhdr->file, subhdr->chan);
+			break;
 		}
-
-		if((cdr.Transfer[4 + 2] & 0x4) &&
-			 (cdr.Transfer[4 + 1] == cdr.Channel) &&
-			 (cdr.Transfer[4 + 0] == cdr.File)) {
-			int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector);
-			if (!ret) {
-				cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo);
-				SPU_playADPCMchannel(&cdr.Xa);
-				cdr.FirstSector = 0;
-			}
-			else cdr.FirstSector = -1;
+		if (!cdr.FileChannelSelected) {
+			cdr.CurFile = subhdr->file;
+			cdr.CurChannel = subhdr->chan;
+			cdr.FileChannelSelected = 1;
 		}
-	}
+		else if (subhdr->file != cdr.CurFile || subhdr->chan != cdr.CurChannel)
+			break;
 
-	cdr.SetSector[2]++;
-	if (cdr.SetSector[2] == 75) {
-		cdr.SetSector[2] = 0;
-		cdr.SetSector[1]++;
-		if (cdr.SetSector[1] == 60) {
-			cdr.SetSector[1] = 0;
-			cdr.SetSector[0]++;
-		}
-	}
+		// accepted as adpcm
+		deliver_data = 0;
 
-	cdr.Readed = 0;
+		if (Config.Xa)
+			break;
+		is_start = !cdr.AdpcmActive;
+		cdr.AdpcmActive = !xa_decode_sector(&cdr.Xa, buf + 4, is_start);
+		if (cdr.AdpcmActive)
+			SPU_playADPCMchannel(&cdr.Xa, psxRegs.cycle, is_start);
+	} while (0);
 
-	CDREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime);
+	if ((cdr.Mode & MODE_SF) && (subhdr->mode & 0x44) == 0x44) // according to nocash
+		deliver_data = 0;
 
 	/*
 	Croc 2: $40 - only FORM1 (*)
@@ -1189,49 +1420,41 @@ void cdrReadInterrupt() {
 	Sim Theme Park - no adpcm at all (zero)
 	*/
 
-	if (!(cdr.Mode & MODE_STRSND) || !(cdr.Transfer[4+2] & 0x4)) {
-		cdr.Stat = DataReady;
-		setIrq();
-	}
+	if (deliver_data)
+		cdrReadInterruptSetResult(cdr.StatP);
 
-	// update for CdlGetlocP
-	ReadTrack(cdr.SetSector);
+	msfiAdd(cdr.SetSectorPlay, 1);
+	CDR_prefetch(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]);
 
-	Check_Shell(0);
+	CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0);
 }
 
 /*
 cdrRead0:
-	bit 0,1 - mode
-	bit 2 - unknown
-	bit 3 - unknown
-	bit 4 - unknown
+	bit 0,1 - reg index
+	bit 2 - adpcm active
 	bit 5 - 1 result ready
 	bit 6 - 1 dma ready
 	bit 7 - 1 command being processed
 */
 
 unsigned char cdrRead0(void) {
-	if (cdr.ResultReady)
-		cdr.Ctrl |= 0x20;
-	else
-		cdr.Ctrl &= ~0x20;
+	cdr.Ctrl &= ~0x24;
+	cdr.Ctrl |= cdr.AdpcmActive << 2;
+	cdr.Ctrl |= cdr.ResultReady << 5;
 
-	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;
 
-	CDR_LOG_IO("cdr r0: %02x\n", cdr.Ctrl);
+	CDR_LOG_IO("cdr r0.sta: %02x\n", cdr.Ctrl);
 
 	return psxHu8(0x1800) = cdr.Ctrl;
 }
 
 void cdrWrite0(unsigned char rt) {
-	CDR_LOG_IO("cdr w0: %02x\n", rt);
+	CDR_LOG_IO("cdr w0.x.idx: %02x\n", rt);
 
 	cdr.Ctrl = (rt & 3) | (cdr.Ctrl & ~3);
 }
@@ -1245,16 +1468,14 @@ unsigned char cdrRead1(void) {
 	if (cdr.ResultP == cdr.ResultC)
 		cdr.ResultReady = 0;
 
-	CDR_LOG_IO("cdr r1: %02x\n", psxHu8(0x1801));
+	CDR_LOG_IO("cdr r1.x.rsp: %02x #%u\n", psxHu8(0x1801), cdr.ResultP - 1);
 
 	return psxHu8(0x1801);
 }
 
 void cdrWrite1(unsigned char rt) {
-	u8 set_loc[3];
-	int i;
-
-	CDR_LOG_IO("cdr w1: %02x\n", rt);
+	const char *rnames[] = { "0.cmd", "1.smd", "2.smc", "3.arr" }; (void)rnames;
+	CDR_LOG_IO("cdr w1.%s: %02x\n", rnames[cdr.Ctrl & 3], rt);
 
 	switch (cdr.Ctrl & 3) {
 	case 0:
@@ -1266,195 +1487,51 @@ 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);
 		for (i = 0; i < cdr.ParamC; i++)
 			SysPrintf(" %x,", cdr.Param[i]);
-		SysPrintf("}\n");
-	} else {
-		SysPrintf("\n");
+		SysPrintf("}");
 	}
+	SysPrintf(" @%08x\n", psxRegs.pc);
 #endif
 
 	cdr.ResultReady = 0;
 	cdr.Ctrl |= 0x80;
-	// cdr.Stat = NoIntr; 
-	AddIrqQueue(cdr.Cmd, 0x800);
-
-	switch (cdr.Cmd) {
-	case CdlSync:
-	case CdlNop:
-	case CdlForward:
-	case CdlBackward:
-	case CdlReadT:
-	case CdlTest:
-	case CdlID:
-	case CdlReadToc:
-	case CdlGetmode:
-	case CdlGetlocL:
-	case CdlGetlocP:
-	case CdlGetTD:
-		break;
-
-	case CdlSetloc:
-		StopReading();
-		for (i = 0; i < 3; i++)
-			set_loc[i] = btoi(cdr.Param[i]);
-
-		// FIXME: clean up this SetSector/SetSectorPlay mess,
-		// there should be single var tracking current sector pos
-		if (cdr.Play)
-			i = msf2sec(cdr.SetSectorPlay);
-		else
-			i = msf2sec(cdr.SetSector);
-		i = abs(i - msf2sec(set_loc));
-		if (i > 16)
-			cdr.Seeked = SEEK_PENDING;
-
-		memcpy(cdr.SetSector, set_loc, 3);
-		cdr.SetSector[3] = 0;
-		break;
-
-	case CdlPlay:
-		// Vib Ribbon: try same track again
-		StopCdda();
-
-		// Vib Ribbon - decoded buffer IRQ for CDDA reading
-		// - fixes ribbon timing + music CD mode
-		//CDRDBUF_INT( PSXCLK / 44100 * 0x100 );
-
-		cdr.Play = TRUE;
-
-		cdr.StatP |= STATUS_SEEK;
-		cdr.StatP &= ~STATUS_ROTATING;
-		break;
-
-	case CdlReadN:
-		StopReading();
-		cdr.Reading = 1;
-		cdr.FirstSector = 1;
-		cdr.Readed = 0xff;
-		break;
-
-	case CdlStandby:
-		StopCdda();
-		StopReading();
-		break;
-
-	case CdlStop:
-		// GameShark CD Player: Reset CDDA to track start
-		if (cdr.Play) {
-			// grab time for current track
-			CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD);
-
-			cdr.SetSectorPlay[0] = cdr.ResultTD[2];
-			cdr.SetSectorPlay[1] = cdr.ResultTD[1];
-			cdr.SetSectorPlay[2] = cdr.ResultTD[0];
-		}
-
-		StopCdda();
-		StopReading();
-		break;
-
-	case CdlPause:
-		/*
-		   GameShark CD Player: save time for resume
-
-		   Twisted Metal - World Tour: don't mix Setloc / CdlPlay cursors
-		*/
-
-		StopCdda();
-		StopReading();
-		break;
-
-	case CdlReset:
-	case CdlInit:
-		cdr.Seeked = SEEK_DONE;
-		StopCdda();
-		StopReading();
-		break;
-
-	case CdlMute:
-		cdr.Muted = TRUE;
-			// Duke Nukem - Time to Kill
-			// - do not directly set cd-xa volume
-			//SPU_writeRegister( H_CDLeft, 0x0000 );
-			//SPU_writeRegister( H_CDRight, 0x0000 );
-		break;
-
-	case CdlDemute:
-		cdr.Muted = FALSE;
-
-			// Duke Nukem - Time to Kill
-			// - do not directly set cd-xa volume
-			//SPU_writeRegister( H_CDLeft, 0x7f00 );
-			//SPU_writeRegister( H_CDRight, 0x7f00 );
-		break;
-
-    	case CdlSetfilter:
-        	cdr.File = cdr.Param[0];
-        	cdr.Channel = cdr.Param[1];
-        	break;
 
-    	case CdlSetmode:
-		CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]);
-
-        	cdr.Mode = cdr.Param[0];
-
-		// Squaresoft on PlayStation 1998 Collector's CD Vol. 1
-		// - fixes choppy movie sound
-		if( cdr.Play && (cdr.Mode & MODE_CDDA) == 0 )
-			StopCdda();
-        	break;
-
-    	case CdlGetTN:
-		//AddIrqQueue(cdr.Cmd, 0x800);
-
-		// GameShark CDX CD Player: very long time
-		AddIrqQueue(cdr.Cmd, 0x100000);
-		break;
-
-    	case CdlSeekL:
-    	case CdlSeekP:
-		// Tomb Raider 2 - reset cdda
-		StopCdda();
-		StopReading();
-		break;
-
-    	case CdlReadS:
-		StopReading();
-		cdr.Reading = 2;
-		cdr.FirstSector = 1;
-		cdr.Readed = 0xff;
-		break;
-
-	default:
-		cdr.ParamC = 0;
-		CDR_LOG_I("cdrWrite1() Log: Unknown command: %x\n", cdr.Cmd);
-		return;
+	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: %02x\n", ret);
+	CDR_LOG_IO("cdr r2.x.dat: %02x\n", ret);
 	return ret;
 }
 
 void cdrWrite2(unsigned char rt) {
-	CDR_LOG_IO("cdr w2: %02x\n", rt);
+	const char *rnames[] = { "0.prm", "1.ien", "2.all", "3.arl" }; (void)rnames;
+	CDR_LOG_IO("cdr w2.%s: %02x\n", rnames[cdr.Ctrl & 3], rt);
 
 	switch (cdr.Ctrl & 3) {
 	case 0:
@@ -1462,8 +1539,8 @@ void cdrWrite2(unsigned char rt) {
 			cdr.Param[cdr.ParamC++] = rt;
 		return;
 	case 1:
-		cdr.Reg2 = rt;
-		setIrq();
+		cdr.IrqMask = rt;
+		setIrq(cdr.IrqStat, 0x1005);
 		return;
 	case 2:
 		cdr.AttenuatorLeftToLeftT = rt;
@@ -1476,22 +1553,45 @@ void cdrWrite2(unsigned char rt) {
 
 unsigned char cdrRead3(void) {
 	if (cdr.Ctrl & 0x1)
-		psxHu8(0x1803) = cdr.Stat | 0xE0;
+		psxHu8(0x1803) = cdr.IrqStat | 0xE0;
 	else
-		psxHu8(0x1803) = cdr.Reg2 | 0xE0;
+		psxHu8(0x1803) = cdr.IrqMask | 0xE0;
 
-	CDR_LOG_IO("cdr r3: %02x\n", psxHu8(0x1803));
+	CDR_LOG_IO("cdr r3.%d.%s: %02x\n", cdr.Ctrl & 3,
+		(cdr.Ctrl & 1) ? "ifl" : "ien", psxHu8(0x1803));
 	return psxHu8(0x1803);
 }
 
 void cdrWrite3(unsigned char rt) {
-	CDR_LOG_IO("cdr w3: %02x\n", rt);
+	const char *rnames[] = { "0.req", "1.ifl", "2.alr", "3.ava" }; (void)rnames;
+	u8 ll, lr, rl, rr;
+	CDR_LOG_IO("cdr w3.%s: %02x\n", rnames[cdr.Ctrl & 3], rt);
 
 	switch (cdr.Ctrl & 3) {
 	case 0:
 		break; // transfer
 	case 1:
-		cdr.Stat &= ~rt;
+		if (cdr.IrqStat & 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.IrqStat & 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.IrqStat &= ~rt;
 
 		if (rt & 0x40)
 			cdr.ParamC = 0;
@@ -1500,70 +1600,71 @@ void cdrWrite3(unsigned char rt) {
 		cdr.AttenuatorLeftToRightT = rt;
 		return;
 	case 3:
+		if (rt & 0x01)
+			log_unhandled("Mute ADPCM?\n");
 		if (rt & 0x20) {
-			memcpy(&cdr.AttenuatorLeftToLeft, &cdr.AttenuatorLeftToLeftT, 4);
-			CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n",
-				cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
-				cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight);
+			ll = cdr.AttenuatorLeftToLeftT; lr = cdr.AttenuatorLeftToRightT;
+			rl = cdr.AttenuatorRightToLeftT; rr = cdr.AttenuatorRightToRightT;
+			if (ll == cdr.AttenuatorLeftToLeft &&
+			    lr == cdr.AttenuatorLeftToRight &&
+			    rl == cdr.AttenuatorRightToLeft &&
+			    rr == cdr.AttenuatorRightToRight)
+				return;
+			cdr.AttenuatorLeftToLeft = ll; cdr.AttenuatorLeftToRight = lr;
+			cdr.AttenuatorRightToLeft = rl; cdr.AttenuatorRightToRight = rr;
+			CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n", ll, lr, rl, rr);
+			SPU_setCDvol(ll, lr, rl, rr, psxRegs.cycle);
 		}
 		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");
+			madr &= ~3;
+			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
@@ -1571,29 +1672,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;
 
+			set_event(PSXINT_CDRDMA, (cdsize / 4) * 24);
 
-			// burst vs normal
-			if( chcr == 0x11400100 ) {
-				CDRDMA_INT( (cdsize/4) / 4 );
+			HW_DMA3_CHCR &= SWAPu32(~0x10000000);
+			if (chcr & 0x100) {
+				HW_DMA3_MADR = SWAPu32(madr + cdsize);
+				HW_DMA3_BCR &= SWAPu32(0xffff0000);
 			}
-			else if( chcr == 0x11000000 ) {
-				CDRDMA_INT( (cdsize/4) * 1 );
+			else {
+				// halted
+				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;
 	}
 
@@ -1601,7 +1710,7 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) {
 	DMA_INTERRUPT(3);
 }
 
-void cdrDmaInterrupt()
+void cdrDmaInterrupt(void)
 {
 	if (HW_DMA3_CHCR & SWAP32(0x01000000))
 	{
@@ -1624,11 +1733,10 @@ static void getCdInfo(void)
 void cdrReset() {
 	memset(&cdr, 0, sizeof(cdr));
 	cdr.CurTrack = 1;
-	cdr.File = 1;
-	cdr.Channel = 1;
-	cdr.Reg2 = 0x1f;
-	cdr.Stat = NoIntr;
-	pTransfer = cdr.Transfer;
+	cdr.FilterFile = 0;
+	cdr.FilterChannel = 0;
+	cdr.IrqMask = 0x1f;
+	cdr.IrqStat = NoIntr;
 
 	// BIOS player - default values
 	cdr.AttenuatorLeftToLeft = 0x80;
@@ -1636,6 +1744,7 @@ void cdrReset() {
 	cdr.AttenuatorRightToLeft = 0x00;
 	cdr.AttenuatorRightToRight = 0x80;
 
+	softReset();
 	getCdInfo();
 }
 
@@ -1646,56 +1755,50 @@ int cdrFreeze(void *f, int Mode) {
 	if (Mode == 0 && !Config.Cdda)
 		CDR_stop();
 	
-	cdr.freeze_ver = 0x63647201;
+	cdr.freeze_ver = 0x63647202;
 	gzfreeze(&cdr, sizeof(cdr));
 	
 	if (Mode == 1) {
 		cdr.ParamP = cdr.ParamC;
-		tmp = pTransfer - cdr.Transfer;
+		tmp = cdr.FifoOffset;
 	}
 
 	gzfreeze(&tmp, sizeof(tmp));
 
 	if (Mode == 0) {
+		u8 ll = 0, lr = 0, rl = 0, rr = 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
-		memcpy(tmpp, cdr.Prev, 3);
+		tmpp[0] = btoi(cdr.Prev[0]);
+		tmpp[1] = btoi(cdr.Prev[1]);
+		tmpp[2] = btoi(cdr.Prev[2]);
 		cdr.Prev[0]++;
 		ReadTrack(tmpp);
 
 		if (cdr.Play) {
+			if (cdr.freeze_ver < 0x63647202)
+				memcpy(cdr.SetSectorPlay, cdr.SetSector, 3);
+
 			Find_CurTrack(cdr.SetSectorPlay);
 			if (!Config.Cdda)
 				CDR_play(cdr.SetSectorPlay);
 		}
-
-		if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {
-			// old versions did not latch Reg2, have to fixup..
-			if (cdr.Reg2 == 0) {
-				SysPrintf("cdrom: fixing up old savestate\n");
-				cdr.Reg2 = 7;
-			}
-		}
+		if (!cdr.Muted)
+			ll = cdr.AttenuatorLeftToLeft, lr = cdr.AttenuatorLeftToLeft,
+			rl = cdr.AttenuatorRightToLeft, rr = cdr.AttenuatorRightToRight;
+		SPU_setCDvol(ll, lr, rl, rr, psxRegs.cycle);
 	}
 
 	return 0;
 }
 
-void LidInterrupt() {
-	cdr.LidCheck = 0x20; // start checker
-
+void LidInterrupt(void) {
 	getCdInfo();
-       
-	StopCdda();
-	CDRLID_INT( cdReadTime * 3 );
-
-	// generate interrupt if none active - open or close
-	if (cdr.Irq == 0 || cdr.Irq == 0xff) {
-		cdr.Ctrl |= 0x80;
-		cdr.Stat = NoIntr;
-		AddIrqQueue(CdlNop, 0x800);
-	}
+	cdrLidSeekInterrupt();
 }