X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?p=pcsx_rearmed.git;a=blobdiff_plain;f=libpcsxcore%2Fcdrom.c;h=753c51262f3788a89986ff141046a58061f6cc72;hp=95e1f05f1e2ccfe9e3a3d58997509a3caaa06728;hb=3968e69e7fa8f9cb0d44ac79477d5929b9649271;hpb=80f91a20e39eed8294b125af199c504cf8519d45

diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c
index 95e1f05f..753c5126 100644
--- a/libpcsxcore/cdrom.c
+++ b/libpcsxcore/cdrom.c
@@ -14,16 +14,17 @@
  *   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 "cdrom.h"
 #include "ppf.h"
 #include "psxdma.h"
+#include "arm_features.h"
 
 /* logging */
 #if 0
@@ -45,9 +46,10 @@
 
 cdrStruct cdr;
 static unsigned char *pTransfer;
+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 +59,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,18 +77,19 @@ 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]= {
     "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
 };
 
 unsigned char Test04[] = { 0 };
@@ -124,6 +127,10 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 };
 #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_INVALIDARG (1<<5) // 0x20
 
 // 1x = 75 sectors per second
 // PSXCLK = 1 sec in the ps
@@ -135,6 +142,7 @@ enum drive_state {
 	DRIVESTATE_LID_OPEN,
 	DRIVESTATE_RESCAN_CD,
 	DRIVESTATE_PREPARE_CD,
+	DRIVESTATE_STOPPED,
 };
 
 // for cdr.Seeked
@@ -199,7 +207,7 @@ static void sec2msf(unsigned int s, u8 *msf) {
 		cdr.Reading = 0; \
 		psxRegs.interrupt &= ~(1 << PSXINT_CDREAD); \
 	} \
-	cdr.StatP &= ~STATUS_READ;\
+	cdr.StatP &= ~(STATUS_READ|STATUS_SEEK);\
 }
 
 #define StopCdda() { \
@@ -375,7 +383,7 @@ static void ReadTrack(const u8 *time) {
 
 	CDR_LOG("ReadTrack *** %02x:%02x:%02x\n", tmp[0], tmp[1], tmp[2]);
 
-	cdr.RErr = CDR_readTrack(tmp);
+	cdr.NoErr = CDR_readTrack(tmp);
 	memcpy(cdr.Prev, tmp, 3);
 
 	if (CheckSBI(time))
@@ -405,9 +413,16 @@ 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)
+static void AddIrqQueue(unsigned short irq, unsigned long ecycle) {
+	if (cdr.Irq != 0) {
+		if (irq == cdr.Irq || irq + 0x100 == cdr.Irq) {
+			cdr.IrqRepeated = 1;
+			CDR_INT(ecycle);
+			return;
+		}
+
 		CDR_LOG_I("cdr: override cmd %02x -> %02x\n", cdr.Irq, irq);
+	}
 
 	cdr.Irq = irq;
 	cdr.eCycle = ecycle;
@@ -417,6 +432,10 @@ static void AddIrqQueue(unsigned char irq, unsigned long ecycle) {
 
 static void cdrPlayInterrupt_Autopause()
 {
+	u32 abs_lev_max = 0;
+	boolean abs_lev_chselect;
+	u32 i;
+
 	if ((cdr.Mode & MODE_AUTOPAUSE) && cdr.TrackChanged) {
 		CDR_LOG( "CDDA STOP\n" );
 
@@ -431,11 +450,21 @@ static void cdrPlayInterrupt_Autopause()
 
 		StopCdda();
 	}
-	else if (cdr.Mode & MODE_REPORT) {
-
+	else if (((cdr.Mode & MODE_REPORT) || cdr.FastForward || cdr.FastBackward)) {
+		CDR_readCDDA(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], (u8 *)read_buf);
 		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];
@@ -448,8 +477,8 @@ static void cdrPlayInterrupt_Autopause()
 			cdr.Result[5] = cdr.subq.Absolute[2];
 		}
 
-		cdr.Result[6] = 0;
-		cdr.Result[7] = 0;
+		cdr.Result[6] = abs_lev_max >> 0;
+		cdr.Result[7] = abs_lev_max >> 8;
 
 		// Rayman: Logo freeze (resultready + dataready)
 		cdr.ResultReady = 1;
@@ -479,7 +508,11 @@ void cdrPlayInterrupt()
 			setIrq();
 		}
 
-		memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
+		if (cdr.SetlocPending) {
+			memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
+			cdr.SetlocPending = 0;
+			cdr.m_locationChanged = TRUE;
+		}
 		Find_CurTrack(cdr.SetSectorPlay);
 		ReadTrack(cdr.SetSectorPlay);
 		cdr.TrackChanged = FALSE;
@@ -499,6 +532,12 @@ void cdrPlayInterrupt()
 		cdrPlayInterrupt_Autopause();
 
 	if (!cdr.Play) return;
+	
+	if (CDR_readCDDA && !cdr.Muted && cdr.Mode & MODE_REPORT) {
+		cdrAttenuate(read_buf, CD_FRAMESIZE_RAW / 4, 1);
+		if (SPU_playCDDAchannel)
+			SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW);
+	}
 
 	cdr.SetSectorPlay[2]++;
 	if (cdr.SetSectorPlay[2] == 75) {
@@ -510,15 +549,29 @@ void cdrPlayInterrupt()
 		}
 	}
 
-	CDRMISC_INT(cdReadTime);
+	if (cdr.m_locationChanged)
+	{
+		CDRMISC_INT(cdReadTime * 30);
+		cdr.m_locationChanged = FALSE;
+	}
+	else
+	{
+		CDRMISC_INT(cdReadTime);
+	}
 
 	// update for CdlGetlocP/autopause
 	generate_subq(cdr.SetSectorPlay);
 }
 
 void cdrInterrupt() {
+	u16 Irq = cdr.Irq;
+	int no_busy_error = 0;
+	int start_rotating = 0;
+	int error = 0;
+	int delay;
+	unsigned int seekTime = 0;
+	u8 set_loc[3];
 	int i;
-	unsigned char Irq = cdr.Irq;
 
 	// Reschedule IRQ
 	if (cdr.Stat) {
@@ -527,40 +580,74 @@ void cdrInterrupt() {
 		return;
 	}
 
-	cdr.Irq = 0;
 	cdr.Ctrl &= ~0x80;
 
-	switch (Irq) {
-		case CdlSync:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
-			break;
+	// default response
+	SetResultSize(1);
+	cdr.Result[0] = cdr.StatP;
+	cdr.Stat = Acknowledge;
 
-		case CdlNop:
-			SetResultSize(1);
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
+	if (cdr.IrqRepeated) {
+		cdr.IrqRepeated = 0;
+		if (cdr.eCycle > psxRegs.cycle) {
+			CDR_INT(cdr.eCycle);
+			goto finish;
+		}
+	}
+
+	cdr.Irq = 0;
 
+	switch (Irq) {
+		case CdlNop:
 			if (cdr.DriveState != DRIVESTATE_LID_OPEN)
 				cdr.StatP &= ~STATUS_SHELLOPEN;
+			no_busy_error = 1;
 			break;
 
 		case CdlSetloc:
-			cdr.CmdProcess = 0;
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
+			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]);
+				error = ERROR_INVALIDARG;
+				goto set_error;
+			}
+			else
+			{
+				for (i = 0; i < 3; i++)
+				{
+					set_loc[i] = btoi(cdr.Param[i]);
+				}
+
+				i = msf2sec(cdr.SetSectorPlay);
+				i = abs(i - msf2sec(set_loc));
+				if (i > 16)
+					cdr.Seeked = SEEK_PENDING;
+
+				memcpy(cdr.SetSector, set_loc, 3);
+				cdr.SetSector[3] = 0;
+				cdr.SetlocPending = 1;
+			}
 			break;
 
+		do_CdlPlay:
 		case CdlPlay:
+			StopCdda();
 			if (cdr.Seeked == SEEK_PENDING) {
 				// XXX: wrong, should seek instead..
-				memcpy( cdr.SetSectorPlay, cdr.SetSector, 4 );
 				cdr.Seeked = SEEK_DONE;
 			}
+			
+			cdr.FastBackward = 0;
+			cdr.FastForward = 0;
+
+			if (cdr.SetlocPending) {
+				memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
+				cdr.SetlocPending = 0;
+				cdr.m_locationChanged = TRUE;
+			}
 
 			// BIOS CD Player
 			// - Pause player, hit Track 01/02/../xx (Setloc issued!!)
@@ -604,74 +691,75 @@ void cdrInterrupt() {
 
 			// 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;
-
 			
 			// BIOS player - set flag again
 			cdr.Play = TRUE;
 
 			CDRMISC_INT( cdReadTime );
+			start_rotating = 1;
 			break;
 
 		case CdlForward:
-			cdr.CmdProcess = 0;
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
+			// TODO: error 80 if stopped
 			cdr.Stat = 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;
 
-
 			// 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;
+			if (cdr.DriveState != DRIVESTATE_STOPPED) {
+				error = ERROR_INVALIDARG;
+				goto set_error;
+			}
+			AddIrqQueue(CdlStandby + 0x100, cdReadTime * 125 / 2);
+			start_rotating = 1;
+			break;
+
+		case CdlStandby + 0x100:
 			cdr.Stat = 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();
+
+			delay = 0x800;
+			if (cdr.DriveState == DRIVESTATE_STANDBY)
+				delay = cdReadTime * 30 / 2;
+
+			cdr.DriveState = DRIVESTATE_STOPPED;
+			AddIrqQueue(CdlStop + 0x100, delay);
+			break;
+
+		case CdlStop + 0x100:
 			cdr.StatP &= ~STATUS_ROTATING;
 			cdr.Result[0] = cdr.StatP;
 			cdr.Stat = Complete;
-//			cdr.Stat = Acknowledge;
 			break;
 
 		case CdlPause:
-			SetResultSize(1);
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
-
 			/*
 			Gundam Battle Assault 2: much slower (*)
 			- Fixes boot, gameplay
@@ -682,97 +770,91 @@ void cdrInterrupt() {
 			InuYasha - Feudal Fairy Tale: slower
 			- Fixes battles
 			*/
-			AddIrqQueue(CdlPause + 0x20, cdReadTime * 3);
+			/* Gameblabla - Tightening the timings (as taken from Duckstation). 
+			 * The timings from Duckstation are based upon hardware tests.
+			 * Mednafen's timing don't work for Gundam Battle Assault 2 in PAL/50hz mode,
+			 * seems to be timing sensitive as it can depend on the CPU's clock speed.
+			 * */
+			if (cdr.DriveState != DRIVESTATE_STANDBY)
+			{
+				delay = 7000;
+			}
+			else
+			{
+				delay = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * (1000000));
+				CDRMISC_INT((cdr.Mode & MODE_SPEED) ? cdReadTime / 2 : cdReadTime);
+			}
+			AddIrqQueue(CdlPause + 0x100, delay);
 			cdr.Ctrl |= 0x80;
 			break;
 
-		case CdlPause + 0x20:
-			SetResultSize(1);
+		case CdlPause + 0x100:
 			cdr.StatP &= ~STATUS_READ;
-			cdr.StatP |= STATUS_ROTATING;
 			cdr.Result[0] = cdr.StatP;
 			cdr.Stat = 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 CdlReset:
+			cdr.Muted = FALSE;
+			cdr.Mode = 0x20; /* This fixes This is Football 2, Pooh's Party lockups */
+			AddIrqQueue(CdlReset + 0x100, 4100000);
+			no_busy_error = 1;
+			start_rotating = 1;
+			break;
 
-		case CdlInit + 0x20:
-			SetResultSize(1);
-			cdr.Result[0] = cdr.StatP;
+		case CdlReset + 0x100:
 			cdr.Stat = Complete;
-			cdr.Init = 1;
 			break;
 
 		case CdlMute:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
+			cdr.Muted = TRUE;
 			break;
 
 		case CdlDemute:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
+			cdr.Muted = FALSE;
 			break;
 
 		case CdlSetfilter:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge; 
+			cdr.File = cdr.Param[0];
+			cdr.Channel = cdr.Param[1];
 			break;
 
 		case CdlSetmode:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
+			no_busy_error = 1;
 			break;
 
-		case CdlGetmode:
-			SetResultSize(6);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
+		case CdlGetparam:
+			/* 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.File;
+			cdr.Result[4] = cdr.Channel;
+			no_busy_error = 1;
 			break;
 
 		case CdlGetlocL:
 			SetResultSize(8);
-			for (i = 0; i < 8; i++)
-				cdr.Result[i] = cdr.Transfer[i];
-			cdr.Stat = Acknowledge;
+			memcpy(cdr.Result, cdr.Transfer, 8);
 			break;
 
 		case CdlGetlocP:
 			SetResultSize(8);
 			memcpy(&cdr.Result, &cdr.subq, 8);
+			break;
 
-			if (!cdr.Play && !cdr.Reading)
-				cdr.Result[1] = 0; // HACK?
+		case CdlReadT: // SetSession?
+			// really long
+			AddIrqQueue(CdlReadT + 0x100, cdReadTime * 290 / 4);
+			start_rotating = 1;
+			break;
 
-			cdr.Stat = Acknowledge;
+		case CdlReadT + 0x100:
+			cdr.Stat = 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;
@@ -784,10 +866,8 @@ void cdrInterrupt() {
 			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;
@@ -796,17 +876,17 @@ void cdrInterrupt() {
 				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]);
+				/* According to Nocash's documentation, the function doesn't care about ff.
+				 * This can be seen also in Mednafen's implementation. */
+				//cdr.Result[3] = itob(cdr.ResultTD[0]);
 			}
 			break;
 
 		case CdlSeekL:
 		case CdlSeekP:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
+			StopCdda();
+			StopReading();
 			cdr.StatP |= STATUS_SEEK;
-			cdr.Stat = Acknowledge;
 
 			/*
 			Crusaders of Might and Magic = 0.5x-4x
@@ -823,10 +903,10 @@ void cdrInterrupt() {
 			*/
 			CDRMISC_INT(cdr.Seeked == SEEK_DONE ? 0x800 : cdReadTime * 4);
 			cdr.Seeked = SEEK_PENDING;
+			start_rotating = 1;
 			break;
 
 		case CdlTest:
-			cdr.Stat = Acknowledge;
 			switch (cdr.Param[0]) {
 				case 0x20: // System Controller ROM Version
 					SetResultSize(4);
@@ -841,17 +921,14 @@ void cdrInterrupt() {
 					memcpy(cdr.Result, Test23, 4);
 					break;
 			}
+			no_busy_error = 1;
 			break;
 
 		case CdlID:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
-			AddIrqQueue(CdlID + 0x20, 0x800);
+			AddIrqQueue(CdlID + 0x100, 20480);
 			break;
 
-		case CdlID + 0x20:
+		case CdlID + 0x100:
 			SetResultSize(8);
 			cdr.Result[0] = cdr.StatP;
 			cdr.Result[1] = 0;
@@ -874,51 +951,66 @@ void cdrInterrupt() {
 			cdr.Stat = Complete;
 			break;
 
-		case CdlReset:
-			SetResultSize(1);
-			cdr.StatP = STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
+		case CdlInit:
+			// yes, it really sets STATUS_SHELLOPEN
+			cdr.StatP |= STATUS_SHELLOPEN;
+			cdr.DriveState = DRIVESTATE_RESCAN_CD;
+			CDRLID_INT(20480);
+			no_busy_error = 1;
+			start_rotating = 1;
 			break;
 
-		case CdlReadT:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
-			AddIrqQueue(CdlReadT + 0x20, 0x800);
-			break;
-
-		case CdlReadT + 0x20:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Complete;
+		case CdlGetQ:
+			no_busy_error = 1;
 			break;
 
 		case CdlReadToc:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
-			AddIrqQueue(CdlReadToc + 0x20, cdReadTime * 16);
+			AddIrqQueue(CdlReadToc + 0x100, cdReadTime * 180 / 4);
+			no_busy_error = 1;
+			start_rotating = 1;
 			break;
 
-		case CdlReadToc + 0x20:
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
-			cdr.Result[0] = cdr.StatP;
+		case CdlReadToc + 0x100:
 			cdr.Stat = Complete;
+			no_busy_error = 1;
 			break;
 
 		case CdlReadN:
 		case CdlReadS:
-			if (!cdr.Reading) return;
+			if (cdr.SetlocPending) {
+				seekTime = abs(msf2sec(cdr.SetSectorPlay) - msf2sec(cdr.SetSector)) * (cdReadTime / 200);
+				/*
+				* Gameblabla :
+				* It was originally set to 1000000 for Driver, however it is not high enough for Worms Pinball
+				* and was unreliable for that game.
+				* I also tested it against Mednafen and Driver's titlescreen music starts 25 frames later, not immediatly.
+				* 
+				* Obviously, this isn't perfect but right now, it should be a bit better.
+				* Games to test this against if you change that setting :
+				* - Driver (titlescreen music delay and retry mission)
+				* - Worms Pinball (Will either not boot or crash in the memory card screen)
+				* - Viewpoint (short pauses if the delay in the ingame music is too long)
+				* 
+				* It seems that 3386880 * 5 is too much for Driver's titlescreen and it starts skipping.
+				* However, 1000000 is not enough for Worms Pinball to reliably boot.
+				*/
+				if(seekTime > 3386880 * 2) seekTime = 3386880 * 2;
+				memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
+				cdr.SetlocPending = 0;
+				cdr.m_locationChanged = TRUE;
+			}
+			Find_CurTrack(cdr.SetSectorPlay);
+
+			if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1)
+				// Read* acts as play for cdda tracks in cdda mode
+				goto do_CdlPlay;
+
+			cdr.Reading = 1;
+			cdr.FirstSector = 1;
 
 			// Fighting Force 2 - update subq time immediately
 			// - fixes new game
-			Find_CurTrack(cdr.SetSector);
-			ReadTrack(cdr.SetSector);
+			ReadTrack(cdr.SetSectorPlay);
 
 
 			// Crusaders of Might and Magic - update getlocl now
@@ -934,61 +1026,82 @@ void cdrInterrupt() {
 			- fixes cutscenes
 			C-12 - Final Resistance - doesn't like seek
 			*/
+			
+			/*	
+				By nicolasnoble from PCSX Redux :
+				"It LOOKS like this logic is wrong, therefore disabling it with `&& false` for now.
+				For "PoPoLoCrois Monogatari II", the game logic will soft lock and will never issue GetLocP to detect
+				the end of its XA streams, as it seems to assume ReadS will not return a status byte with the SEEK
+				flag set. I think the reasonning is that since it's invalid to call GetLocP while seeking, the game
+				tries to protect itself against errors by preventing from issuing a GetLocP while it knows the
+				last status was "seek". But this makes the logic just softlock as it'll never get a notification
+				about the fact the drive is done seeking and the read actually started.
+
+				In other words, this state machine here is probably wrong in assuming the response to ReadS/ReadN is
+				done right away. It's rather when it's done seeking, and the read has actually started. This probably
+				requires a bit more work to make sure seek delays are processed properly.
+				Checked with a few games, this seems to work fine."
+				
+				Gameblabla additional notes :
+				This still needs the "+ seekTime" that PCSX Redux doesn't have for the Driver "retry" mission error.
+			*/
+			cdr.StatP |= STATUS_READ;
+			cdr.StatP &= ~STATUS_SEEK;
 
-			if (cdr.Seeked != SEEK_DONE) {
-				cdr.StatP |= STATUS_SEEK;
-				cdr.StatP &= ~STATUS_READ;
-
-				// Crusaders of Might and Magic - use short time
-				// - fix cutscene speech (startup)
-
-				// ??? - use more accurate seek time later
-				CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1);
-			} else {
-				cdr.StatP |= STATUS_READ;
-				cdr.StatP &= ~STATUS_SEEK;
-
-				CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1);
-			}
+			CDREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime);
 
-			SetResultSize(1);
-			cdr.StatP |= STATUS_ROTATING;
 			cdr.Result[0] = cdr.StatP;
-			cdr.Stat = Acknowledge;
+			start_rotating = 1;
 			break;
-
+		case CdlSync:
 		default:
-			cdr.Stat = Complete;
+			CDR_LOG_I("Invalid command: %02x\n", Irq);
+			error = ERROR_INVALIDCMD;
+			// FALLTHROUGH
+
+		set_error:
+			SetResultSize(2);
+			cdr.Result[0] = cdr.StatP | STATUS_ERROR;
+			cdr.Result[1] = error;
+			cdr.Stat = DiskError;
 			break;
 	}
 
-	if (Irq != CdlNop) {
+	if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) {
+		cdr.DriveState = DRIVESTATE_STANDBY;
+		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] = 0x80;
+			cdr.Result[1] = ERROR_NOTREADY;
 			cdr.Stat = DiskError;
 			break;
 		}
 	}
 
-	cdr.ParamC = 0;
-
+finish:
 	setIrq();
+	cdr.ParamC = 0;
 
 #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");
+	{
+		int i;
+		SysPrintf("CDR 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
 }
 
-#ifdef __ARM_ARCH_7A__
+#ifdef HAVE_ARMV7
  #define ssat32_to_16(v) \
   asm("ssat %0,#16,%1" : "=r" (v) : "r" (v))
 #else
@@ -1055,13 +1168,13 @@ void cdrReadInterrupt() {
 	cdr.Result[0] = cdr.StatP;
 	cdr.Seeked = SEEK_DONE;
 
-	ReadTrack(cdr.SetSector);
+	ReadTrack(cdr.SetSectorPlay);
 
 	buf = CDR_getBuffer();
 	if (buf == NULL)
-		cdr.RErr = -1;
+		cdr.NoErr = 0;
 
-	if (cdr.RErr == -1) {
+	if (!cdr.NoErr) {
 		CDR_LOG_I("cdrReadInterrupt() Log: err\n");
 		memset(cdr.Transfer, 0, DATA_SIZE);
 		cdr.Stat = DiskError;
@@ -1083,12 +1196,30 @@ void cdrReadInterrupt() {
 			cdr.Channel = cdr.Transfer[4 + 1];
 		}
 
+		/* Gameblabla 
+		 * Skips playing on channel 255.
+		 * Fixes missing audio in Blue's Clues : Blue's Big Musical. (Should also fix Taxi 2)
+		 * TODO : Check if this is the proper behaviour.
+		 * */
 		if((cdr.Transfer[4 + 2] & 0x4) &&
 			 (cdr.Transfer[4 + 1] == cdr.Channel) &&
-			 (cdr.Transfer[4 + 0] == cdr.File)) {
+			 (cdr.Transfer[4 + 0] == cdr.File) && cdr.Channel != 255) {
 			int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector);
 			if (!ret) {
 				cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo);
+				/*
+				 * Gameblabla -
+				 * This is a hack for Megaman X4, Castlevania etc...
+				 * that regressed from the new m_locationChanged and CDROM timings changes.
+				 * It is mostly noticeable in Castevania however and the stuttering can be very jarring.
+				 * 
+				 * According to PCSX redux authors, we shouldn't cause a location change if
+				 * the sector difference is too small. 
+				 * I attempted to go with that approach but came empty handed.
+				 * So for now, let's just set cdr.m_locationChanged to false when playing back any ADPCM samples.
+				 * This does not regress Crash Team Racing's intro at least.
+				*/
+				cdr.m_locationChanged = FALSE;
 				SPU_playADPCMchannel(&cdr.Xa);
 				cdr.FirstSector = 0;
 			}
@@ -1096,19 +1227,25 @@ void cdrReadInterrupt() {
 		}
 	}
 
-	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]++;
+	cdr.SetSectorPlay[2]++;
+	if (cdr.SetSectorPlay[2] == 75) {
+		cdr.SetSectorPlay[2] = 0;
+		cdr.SetSectorPlay[1]++;
+		if (cdr.SetSectorPlay[1] == 60) {
+			cdr.SetSectorPlay[1] = 0;
+			cdr.SetSectorPlay[0]++;
 		}
 	}
 
 	cdr.Readed = 0;
 
-	CDREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime);
+	uint32_t delay = (cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime;
+	if (cdr.m_locationChanged) {
+		CDREAD_INT(delay * 30);
+		cdr.m_locationChanged = FALSE;
+	} else {
+		CDREAD_INT(delay);
+	}
 
 	/*
 	Croc 2: $40 - only FORM1 (*)
@@ -1122,7 +1259,7 @@ void cdrReadInterrupt() {
 	}
 
 	// update for CdlGetlocP
-	ReadTrack(cdr.SetSector);
+	ReadTrack(cdr.SetSectorPlay);
 }
 
 /*
@@ -1176,9 +1313,6 @@ unsigned char cdrRead1(void) {
 }
 
 void cdrWrite1(unsigned char rt) {
-	u8 set_loc[3];
-	int i;
-
 	CDR_LOG_IO("cdr w1: %02x\n", rt);
 
 	switch (cdr.Ctrl & 3) {
@@ -1212,120 +1346,21 @@ void cdrWrite1(unsigned char rt) {
 	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 CdlReadS:
 	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:
+	case CdlReset:
 		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]);
 
@@ -1336,32 +1371,6 @@ void cdrWrite1(unsigned char rt) {
 		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;
 	}
 }
 
@@ -1507,13 +1516,15 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) {
 			psxCpu->Clear(madr, cdsize / 4);
 			pTransfer += cdsize;
 
-
-			// burst vs normal
 			if( chcr == 0x11400100 ) {
+				HW_DMA3_MADR = SWAPu32(madr + cdsize);
 				CDRDMA_INT( (cdsize/4) / 4 );
 			}
 			else if( chcr == 0x11000000 ) {
-				CDRDMA_INT( (cdsize/4) * 1 );
+				// CDRDMA_INT( (cdsize/4) * 1 );
+				// halted
+				psxRegs.cycle += (cdsize/4) * 24/2;
+				CDRDMA_INT(16);
 			}
 			return;
 
@@ -1554,8 +1565,9 @@ void cdrReset() {
 	cdr.Reg2 = 0x1f;
 	cdr.Stat = NoIntr;
 	cdr.DriveState = DRIVESTATE_STANDBY;
+	cdr.StatP = STATUS_ROTATING;
 	pTransfer = cdr.Transfer;
-
+	
 	// BIOS player - default values
 	cdr.AttenuatorLeftToLeft = 0x80;
 	cdr.AttenuatorLeftToRight = 0x00;
@@ -1572,7 +1584,7 @@ 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) {
@@ -1588,11 +1600,16 @@ int cdrFreeze(void *f, int Mode) {
 		pTransfer = cdr.Transfer + tmp;
 
 		// 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);
@@ -1604,6 +1621,12 @@ int cdrFreeze(void *f, int Mode) {
 				SysPrintf("cdrom: fixing up old savestate\n");
 				cdr.Reg2 = 7;
 			}
+			// also did not save Attenuator..
+			if ((cdr.AttenuatorLeftToLeft | cdr.AttenuatorLeftToRight
+			     | cdr.AttenuatorRightToLeft | cdr.AttenuatorRightToRight) == 0)
+			{
+				cdr.AttenuatorLeftToLeft = cdr.AttenuatorRightToRight = 0x80;
+			}
 		}
 	}