1 /***************************************************************************
2 * Copyright (C) 2007 Ryan Schultz, PCSX-df Team, PCSX team *
4 * This program is free software; you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation; either version 2 of the License, or *
7 * (at your option) any later version. *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program; if not, write to the *
16 * Free Software Foundation, Inc., *
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
18 ***************************************************************************/
21 * Handles all CD-ROM registers and functions.
27 #include "arm_features.h"
31 #define CDR_LOG SysPrintf
36 #define CDR_LOG_I SysPrintf
38 #define CDR_LOG_I(...)
41 #define CDR_LOG_IO SysPrintf
43 #define CDR_LOG_IO(...)
45 //#define CDR_LOG_CMD_IRQ
48 static unsigned char *pTransfer;
50 /* CD-ROM magic numbers */
51 #define CdlSync 0 /* nocash documentation : "Uh, actually, returns error code 40h = Invalid Command...?" */
64 #define CdlSetfilter 13
66 #define CdlGetparam 15
74 #define CdlSetclock 23
75 #define CdlGetclock 24
83 char *CmdName[0x100]= {
84 "CdlSync", "CdlNop", "CdlSetloc", "CdlPlay",
85 "CdlForward", "CdlBackward", "CdlReadN", "CdlStandby",
86 "CdlStop", "CdlPause", "CdlReset", "CdlMute",
87 "CdlDemute", "CdlSetfilter", "CdlSetmode", "CdlGetparam",
88 "CdlGetlocL", "CdlGetlocP", "CdlReadT", "CdlGetTN",
89 "CdlGetTD", "CdlSeekL", "CdlSeekP", "CdlSetclock",
90 "CdlGetclock", "CdlTest", "CdlID", "CdlReadS",
91 "CdlInit", NULL, "CDlReadToc", NULL
94 unsigned char Test04[] = { 0 };
95 unsigned char Test05[] = { 0 };
96 unsigned char Test20[] = { 0x98, 0x06, 0x10, 0xC3 };
97 unsigned char Test22[] = { 0x66, 0x6F, 0x72, 0x20, 0x45, 0x75, 0x72, 0x6F };
98 unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 };
104 #define Acknowledge 3
109 #define MODE_SPEED (1<<7) // 0x80
110 #define MODE_STRSND (1<<6) // 0x40 ADPCM on/off
111 #define MODE_SIZE_2340 (1<<5) // 0x20
112 #define MODE_SIZE_2328 (1<<4) // 0x10
113 #define MODE_SIZE_2048 (0<<4) // 0x00
114 #define MODE_SF (1<<3) // 0x08 channel on/off
115 #define MODE_REPORT (1<<2) // 0x04
116 #define MODE_AUTOPAUSE (1<<1) // 0x02
117 #define MODE_CDDA (1<<0) // 0x01
120 #define STATUS_PLAY (1<<7) // 0x80
121 #define STATUS_SEEK (1<<6) // 0x40
122 #define STATUS_READ (1<<5) // 0x20
123 #define STATUS_SHELLOPEN (1<<4) // 0x10
124 #define STATUS_UNKNOWN3 (1<<3) // 0x08
125 #define STATUS_UNKNOWN2 (1<<2) // 0x04
126 #define STATUS_ROTATING (1<<1) // 0x02
127 #define STATUS_ERROR (1<<0) // 0x01
130 #define ERROR_NOTREADY (1<<7) // 0x80
131 #define ERROR_INVALIDCMD (1<<6) // 0x40
132 #define ERROR_INVALIDARG (1<<5) // 0x20
134 // 1x = 75 sectors per second
135 // PSXCLK = 1 sec in the ps
136 // so (PSXCLK / 75) = cdr read time (linuzappz)
137 #define cdReadTime (PSXCLK / 75)
140 DRIVESTATE_STANDBY = 0,
142 DRIVESTATE_RESCAN_CD,
143 DRIVESTATE_PREPARE_CD,
153 static struct CdrStat stat;
155 static unsigned int msf2sec(const u8 *msf) {
156 return ((msf[0] * 60 + msf[1]) * 75) + msf[2];
159 // for that weird psemu API..
160 static unsigned int fsm2sec(const u8 *msf) {
161 return ((msf[2] * 60 + msf[1]) * 75) + msf[0];
164 static void sec2msf(unsigned int s, u8 *msf) {
165 msf[0] = s / 75 / 60;
166 s = s - msf[0] * 75 * 60;
173 #define CDR_INT(eCycle) { \
174 psxRegs.interrupt |= (1 << PSXINT_CDR); \
175 psxRegs.intCycle[PSXINT_CDR].cycle = eCycle; \
176 psxRegs.intCycle[PSXINT_CDR].sCycle = psxRegs.cycle; \
177 new_dyna_set_event(PSXINT_CDR, eCycle); \
181 #define CDREAD_INT(eCycle) { \
182 psxRegs.interrupt |= (1 << PSXINT_CDREAD); \
183 psxRegs.intCycle[PSXINT_CDREAD].cycle = eCycle; \
184 psxRegs.intCycle[PSXINT_CDREAD].sCycle = psxRegs.cycle; \
185 new_dyna_set_event(PSXINT_CDREAD, eCycle); \
188 // cdrLidSeekInterrupt
189 #define CDRLID_INT(eCycle) { \
190 psxRegs.interrupt |= (1 << PSXINT_CDRLID); \
191 psxRegs.intCycle[PSXINT_CDRLID].cycle = eCycle; \
192 psxRegs.intCycle[PSXINT_CDRLID].sCycle = psxRegs.cycle; \
193 new_dyna_set_event(PSXINT_CDRLID, eCycle); \
197 #define CDRMISC_INT(eCycle) { \
198 psxRegs.interrupt |= (1 << PSXINT_CDRPLAY); \
199 psxRegs.intCycle[PSXINT_CDRPLAY].cycle = eCycle; \
200 psxRegs.intCycle[PSXINT_CDRPLAY].sCycle = psxRegs.cycle; \
201 new_dyna_set_event(PSXINT_CDRPLAY, eCycle); \
204 #define StopReading() { \
207 psxRegs.interrupt &= ~(1 << PSXINT_CDREAD); \
209 cdr.StatP &= ~(STATUS_READ|STATUS_SEEK);\
212 #define StopCdda() { \
214 if (!Config.Cdda) CDR_stop(); \
215 cdr.StatP &= ~STATUS_PLAY; \
217 cdr.FastForward = 0; \
218 cdr.FastBackward = 0; \
219 /*SPU_registerCallback( SPUirq );*/ \
223 #define SetResultSize(size) { \
225 cdr.ResultC = size; \
226 cdr.ResultReady = 1; \
229 static void setIrq(void)
231 if (cdr.Stat & cdr.Reg2)
232 psxHu32ref(0x1070) |= SWAP32((u32)0x4);
235 // timing used in this function was taken from tests on real hardware
236 // (yes it's slow, but you probably don't want to modify it)
237 void cdrLidSeekInterrupt()
239 switch (cdr.DriveState) {
241 case DRIVESTATE_STANDBY:
242 cdr.StatP &= ~STATUS_SEEK;
244 if (CDR_getStatus(&stat) == -1)
247 if (stat.Status & STATUS_SHELLOPEN)
250 cdr.DriveState = DRIVESTATE_LID_OPEN;
255 case DRIVESTATE_LID_OPEN:
256 if (CDR_getStatus(&stat) == -1)
257 stat.Status &= ~STATUS_SHELLOPEN;
260 if (!(cdr.StatP & STATUS_SHELLOPEN)) {
262 cdr.StatP |= STATUS_SHELLOPEN;
264 // could generate error irq here, but real hardware
265 // only sometimes does that
266 // (not done when lots of commands are sent?)
268 CDRLID_INT(cdReadTime * 30);
271 else if (cdr.StatP & STATUS_ROTATING) {
272 cdr.StatP &= ~STATUS_ROTATING;
274 else if (!(stat.Status & STATUS_SHELLOPEN)) {
278 // cdr.StatP STATUS_SHELLOPEN is "sticky"
279 // and is only cleared by CdlNop
281 cdr.DriveState = DRIVESTATE_RESCAN_CD;
282 CDRLID_INT(cdReadTime * 105);
287 CDRLID_INT(cdReadTime * 3);
290 case DRIVESTATE_RESCAN_CD:
291 cdr.StatP |= STATUS_ROTATING;
292 cdr.DriveState = DRIVESTATE_PREPARE_CD;
294 // this is very long on real hardware, over 6 seconds
295 // make it a bit faster here...
296 CDRLID_INT(cdReadTime * 150);
299 case DRIVESTATE_PREPARE_CD:
300 cdr.StatP |= STATUS_SEEK;
302 cdr.DriveState = DRIVESTATE_STANDBY;
303 CDRLID_INT(cdReadTime * 26);
308 static void Find_CurTrack(const u8 *time)
312 current = msf2sec(time);
314 for (cdr.CurTrack = 1; cdr.CurTrack < cdr.ResultTN[1]; cdr.CurTrack++) {
315 CDR_getTD(cdr.CurTrack + 1, cdr.ResultTD);
316 sect = fsm2sec(cdr.ResultTD);
317 if (sect - current >= 150)
322 static void generate_subq(const u8 *time)
324 unsigned char start[3], next[3];
325 unsigned int this_s, start_s, next_s, pregap;
328 CDR_getTD(cdr.CurTrack, start);
329 if (cdr.CurTrack + 1 <= cdr.ResultTN[1]) {
331 CDR_getTD(cdr.CurTrack + 1, next);
334 // last track - cd size
336 next[0] = cdr.SetSectorEnd[2];
337 next[1] = cdr.SetSectorEnd[1];
338 next[2] = cdr.SetSectorEnd[0];
341 this_s = msf2sec(time);
342 start_s = fsm2sec(start);
343 next_s = fsm2sec(next);
345 cdr.TrackChanged = FALSE;
347 if (next_s - this_s < pregap) {
348 cdr.TrackChanged = TRUE;
355 relative_s = this_s - start_s;
356 if (relative_s < 0) {
358 relative_s = -relative_s;
360 sec2msf(relative_s, cdr.subq.Relative);
362 cdr.subq.Track = itob(cdr.CurTrack);
363 cdr.subq.Relative[0] = itob(cdr.subq.Relative[0]);
364 cdr.subq.Relative[1] = itob(cdr.subq.Relative[1]);
365 cdr.subq.Relative[2] = itob(cdr.subq.Relative[2]);
366 cdr.subq.Absolute[0] = itob(time[0]);
367 cdr.subq.Absolute[1] = itob(time[1]);
368 cdr.subq.Absolute[2] = itob(time[2]);
371 static void ReadTrack(const u8 *time) {
372 unsigned char tmp[3];
376 tmp[0] = itob(time[0]);
377 tmp[1] = itob(time[1]);
378 tmp[2] = itob(time[2]);
380 if (memcmp(cdr.Prev, tmp, 3) == 0)
383 CDR_LOG("ReadTrack *** %02x:%02x:%02x\n", tmp[0], tmp[1], tmp[2]);
385 cdr.RErr = CDR_readTrack(tmp);
386 memcpy(cdr.Prev, tmp, 3);
391 subq = (struct SubQ *)CDR_getBufferSub();
392 if (subq != NULL && cdr.CurTrack == 1) {
393 crc = calcCrc((u8 *)subq + 12, 10);
394 if (crc == (((u16)subq->CRC[0] << 8) | subq->CRC[1])) {
395 cdr.subq.Track = subq->TrackNumber;
396 cdr.subq.Index = subq->IndexNumber;
397 memcpy(cdr.subq.Relative, subq->TrackRelativeAddress, 3);
398 memcpy(cdr.subq.Absolute, subq->AbsoluteAddress, 3);
401 CDR_LOG_I("subq bad crc @%02x:%02x:%02x\n",
402 tmp[0], tmp[1], tmp[2]);
409 CDR_LOG(" -> %02x,%02x %02x:%02x:%02x %02x:%02x:%02x\n",
410 cdr.subq.Track, cdr.subq.Index,
411 cdr.subq.Relative[0], cdr.subq.Relative[1], cdr.subq.Relative[2],
412 cdr.subq.Absolute[0], cdr.subq.Absolute[1], cdr.subq.Absolute[2]);
415 static void AddIrqQueue(unsigned short irq, unsigned long ecycle) {
417 if (irq == cdr.Irq || irq + 0x100 == cdr.Irq) {
423 CDR_LOG_I("cdr: override cmd %02x -> %02x\n", cdr.Irq, irq);
432 static void cdrPlayInterrupt_Autopause()
434 if ((cdr.Mode & MODE_AUTOPAUSE) && cdr.TrackChanged) {
435 CDR_LOG( "CDDA STOP\n" );
437 // Magic the Gathering
438 // - looping territory cdda
441 //cdr.ResultReady = 1;
442 //cdr.Stat = DataReady;
448 else if (((cdr.Mode & MODE_REPORT) || cdr.FastForward || cdr.FastBackward)) {
450 cdr.Result[0] = cdr.StatP;
451 cdr.Result[1] = cdr.subq.Track;
452 cdr.Result[2] = cdr.subq.Index;
454 if (cdr.subq.Absolute[2] & 0x10) {
455 cdr.Result[3] = cdr.subq.Relative[0];
456 cdr.Result[4] = cdr.subq.Relative[1] | 0x80;
457 cdr.Result[5] = cdr.subq.Relative[2];
460 cdr.Result[3] = cdr.subq.Absolute[0];
461 cdr.Result[4] = cdr.subq.Absolute[1];
462 cdr.Result[5] = cdr.subq.Absolute[2];
468 // Rayman: Logo freeze (resultready + dataready)
470 cdr.Stat = DataReady;
478 void cdrPlayInterrupt()
480 if (cdr.Seeked == SEEK_PENDING) {
482 CDR_LOG_I("cdrom: seek stat hack\n");
487 cdr.StatP |= STATUS_ROTATING;
488 cdr.StatP &= ~STATUS_SEEK;
489 cdr.Result[0] = cdr.StatP;
490 cdr.Seeked = SEEK_DONE;
497 if (cdr.SetlocPending) {
498 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
499 cdr.SetlocPending = 0;
500 cdr.m_locationChanged = TRUE;
502 Find_CurTrack(cdr.SetSectorPlay);
503 ReadTrack(cdr.SetSectorPlay);
504 cdr.TrackChanged = FALSE;
507 if (!cdr.Play) return;
509 CDR_LOG( "CDDA - %d:%d:%d\n",
510 cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] );
512 if (memcmp(cdr.SetSectorPlay, cdr.SetSectorEnd, 3) == 0) {
514 cdr.TrackChanged = TRUE;
517 if (!cdr.Irq && !cdr.Stat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT)))
518 cdrPlayInterrupt_Autopause();
520 if (!cdr.Play) return;
522 cdr.SetSectorPlay[2]++;
523 if (cdr.SetSectorPlay[2] == 75) {
524 cdr.SetSectorPlay[2] = 0;
525 cdr.SetSectorPlay[1]++;
526 if (cdr.SetSectorPlay[1] == 60) {
527 cdr.SetSectorPlay[1] = 0;
528 cdr.SetSectorPlay[0]++;
532 if (cdr.m_locationChanged)
534 CDRMISC_INT(cdReadTime * 30);
535 cdr.m_locationChanged = FALSE;
539 CDRMISC_INT(cdReadTime);
542 // update for CdlGetlocP/autopause
543 generate_subq(cdr.SetSectorPlay);
546 void cdrInterrupt() {
548 int no_busy_error = 0;
549 int start_rotating = 0;
552 unsigned int seekTime = 0;
556 CDR_LOG_I("cdrom: stat hack: %02x %x\n", cdr.Irq, cdr.Stat);
565 cdr.Result[0] = cdr.StatP;
566 cdr.Stat = Acknowledge;
568 if (cdr.IrqRepeated) {
570 if (cdr.eCycle > psxRegs.cycle) {
580 if (cdr.DriveState != DRIVESTATE_LID_OPEN)
581 cdr.StatP &= ~STATUS_SHELLOPEN;
591 /* It would set it to SEEK_DONE*/
592 cdr.Seeked = SEEK_PENDING;
594 cdr.FastBackward = 0;
597 if (cdr.SetlocPending) {
598 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
599 cdr.SetlocPending = 0;
600 cdr.m_locationChanged = TRUE;
604 // - Pause player, hit Track 01/02/../xx (Setloc issued!!)
606 if (cdr.ParamC == 0 || cdr.Param[0] == 0) {
607 CDR_LOG("PLAY Resume @ %d:%d:%d\n",
608 cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]);
612 int track = btoi( cdr.Param[0] );
614 if (track <= cdr.ResultTN[1])
615 cdr.CurTrack = track;
617 CDR_LOG("PLAY track %d\n", cdr.CurTrack);
619 if (CDR_getTD((u8)cdr.CurTrack, cdr.ResultTD) != -1) {
620 cdr.SetSectorPlay[0] = cdr.ResultTD[2];
621 cdr.SetSectorPlay[1] = cdr.ResultTD[1];
622 cdr.SetSectorPlay[2] = cdr.ResultTD[0];
627 Rayman: detect track changes
630 Twisted Metal 2: skip PREGAP + starting accurate SubQ
631 - plays tracks without retry play
633 Wild 9: skip PREGAP + starting accurate SubQ
634 - plays tracks without retry play
636 Find_CurTrack(cdr.SetSectorPlay);
637 ReadTrack(cdr.SetSectorPlay);
638 cdr.TrackChanged = FALSE;
641 CDR_play(cdr.SetSectorPlay);
643 // Vib Ribbon: gameplay checks flag
644 cdr.StatP &= ~STATUS_SEEK;
645 cdr.Result[0] = cdr.StatP;
647 cdr.StatP |= STATUS_PLAY;
649 // BIOS player - set flag again
652 CDRMISC_INT( cdReadTime );
657 // TODO: error 80 if stopped
660 // GameShark CD Player: Calls 2x + Play 2x
662 cdr.FastBackward = 0;
668 // GameShark CD Player: Calls 2x + Play 2x
674 if (cdr.DriveState != DRIVESTATE_STOPPED) {
675 error = ERROR_INVALIDARG;
678 AddIrqQueue(CdlStandby + 0x100, cdReadTime * 125 / 2);
682 case CdlStandby + 0x100:
689 // grab time for current track
690 CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD);
692 cdr.SetSectorPlay[0] = cdr.ResultTD[2];
693 cdr.SetSectorPlay[1] = cdr.ResultTD[1];
694 cdr.SetSectorPlay[2] = cdr.ResultTD[0];
701 if (cdr.DriveState == DRIVESTATE_STANDBY)
702 delay = cdReadTime * 30 / 2;
704 cdr.DriveState = DRIVESTATE_STOPPED;
705 AddIrqQueue(CdlStop + 0x100, delay);
708 case CdlStop + 0x100:
709 cdr.StatP &= ~STATUS_ROTATING;
710 cdr.Result[0] = cdr.StatP;
717 Gundam Battle Assault 2: much slower (*)
718 - Fixes boot, gameplay
719 Hokuto no Ken 2: slower
720 - Fixes intro + subtitles
721 InuYasha - Feudal Fairy Tale: slower
724 /* Gameblabla - Tightening the timings (as taken from Duckstation).
725 * The timings from Duckstation are based upon hardware tests.
726 * Mednafen's timing don't work for Gundam Battle Assault 2 in PAL/50hz mode,
727 * seems to be timing sensitive as it can depend on the CPU's clock speed.
729 * We will need to get around this for Bedlam/Rise 2 later...
731 if (cdr.DriveState != DRIVESTATE_STANDBY)
737 delay = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * (1000000));
738 CDRMISC_INT((cdr.Mode & MODE_SPEED) ? cdReadTime / 2 : cdReadTime);
740 AddIrqQueue(CdlPause + 0x100, delay);
744 case CdlPause + 0x100:
745 cdr.StatP &= ~STATUS_READ;
746 cdr.Result[0] = cdr.StatP;
753 cdr.Mode = 0x20; /* Needed for This is Football 2, Pooh's Party and possibly others. */
754 AddIrqQueue(CdlReset + 0x100, 4100000);
759 case CdlReset + 0x100:
773 cdr.File = cdr.Param[0];
774 cdr.Channel = cdr.Param[1];
783 cdr.Result[1] = cdr.Mode;
785 cdr.Result[3] = cdr.File;
786 cdr.Result[4] = cdr.Channel;
792 memcpy(cdr.Result, cdr.Transfer, 8);
797 memcpy(&cdr.Result, &cdr.subq, 8);
799 if (!cdr.Play && !cdr.Reading)
800 cdr.Result[1] = 0; // HACK?
803 case CdlReadT: // SetSession?
805 AddIrqQueue(CdlReadT + 0x100, cdReadTime * 290 / 4);
809 case CdlReadT + 0x100:
816 if (CDR_getTN(cdr.ResultTN) == -1) {
817 cdr.Stat = DiskError;
818 cdr.Result[0] |= STATUS_ERROR;
820 cdr.Stat = Acknowledge;
821 cdr.Result[1] = itob(cdr.ResultTN[0]);
822 cdr.Result[2] = itob(cdr.ResultTN[1]);
827 cdr.Track = btoi(cdr.Param[0]);
829 if (CDR_getTD(cdr.Track, cdr.ResultTD) == -1) {
830 cdr.Stat = DiskError;
831 cdr.Result[0] |= STATUS_ERROR;
833 cdr.Stat = Acknowledge;
834 cdr.Result[0] = cdr.StatP;
835 cdr.Result[1] = itob(cdr.ResultTD[2]);
836 cdr.Result[2] = itob(cdr.ResultTD[1]);
837 /* According to Nocash's documentation, the function doesn't care about ff.
838 * This can be seen also in Mednafen's implementation. */
839 //cdr.Result[3] = itob(cdr.ResultTD[0]);
847 cdr.StatP |= STATUS_SEEK;
850 Crusaders of Might and Magic = 0.5x-4x
851 - fix cutscene speech start
857 - fix cutscene speech
862 CDRMISC_INT(cdr.Seeked == SEEK_DONE ? 0x800 : cdReadTime * 4);
863 cdr.Seeked = SEEK_PENDING;
868 switch (cdr.Param[0]) {
869 case 0x20: // System Controller ROM Version
871 memcpy(cdr.Result, Test20, 4);
875 memcpy(cdr.Result, Test22, 4);
877 case 0x23: case 0x24:
879 memcpy(cdr.Result, Test23, 4);
886 AddIrqQueue(CdlID + 0x100, 20480);
891 cdr.Result[0] = cdr.StatP;
896 // 0x10 - audio | 0x40 - disk missing | 0x80 - unlicensed
897 if (CDR_getStatus(&stat) == -1 || stat.Type == 0 || stat.Type == 0xff) {
898 cdr.Result[1] = 0xc0;
902 cdr.Result[1] |= 0x10;
903 if (CdromId[0] == '\0')
904 cdr.Result[1] |= 0x80;
906 cdr.Result[0] |= (cdr.Result[1] >> 4) & 0x08;
908 /* This adds the string "PCSX" in Playstation bios boot screen */
909 memcpy((char *)&cdr.Result[4], "PCSX", 4);
915 // yes, it really sets STATUS_SHELLOPEN
916 cdr.StatP |= STATUS_SHELLOPEN;
917 cdr.DriveState = DRIVESTATE_RESCAN_CD;
928 AddIrqQueue(CdlReadToc + 0x100, cdReadTime * 180 / 4);
933 case CdlReadToc + 0x100:
941 if (cdr.SetlocPending) {
942 seekTime = abs(msf2sec(cdr.SetSectorPlay) - msf2sec(cdr.SetSector)) * (cdReadTime / 200);
945 * It was originally set to 1000000 for Driver, however it is not high enough for Worms Pinball
946 * and was unreliable for that game.
947 * I also tested it against Mednafen and Driver's titlescreen music starts 25 frames later, not immediatly.
949 * Obviously, this isn't perfect but right now, it should be a bit better.
950 * Games to test this against if you change that setting :
951 * - Driver (titlescreen music delay and retry mission)
952 * - Worms Pinball (Will either not boot or crash in the memory card screen)
953 * - Viewpoint (short pauses if the delay in the ingame music is too long)
955 * It seems that 3386880 * 5 is too much for Driver's titlescreen and it starts skipping.
956 * However, 1000000 is not enough for Worms Pinball to reliably boot.
958 if(seekTime > 3386880 * 2) seekTime = 3386880 * 2;
959 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
960 cdr.SetlocPending = 0;
961 cdr.m_locationChanged = TRUE;
963 Find_CurTrack(cdr.SetSectorPlay);
965 if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1)
966 // Read* acts as play for cdda tracks in cdda mode
972 // Fighting Force 2 - update subq time immediately
974 ReadTrack(cdr.SetSectorPlay);
977 // Crusaders of Might and Magic - update getlocl now
978 // - fixes cutscene speech
980 u8 *buf = CDR_getBuffer();
982 memcpy(cdr.Transfer, buf, 8);
986 Duke Nukem: Land of the Babes - seek then delay read for one frame
988 C-12 - Final Resistance - doesn't like seek
992 By nicolasnoble from PCSX Redux :
993 "It LOOKS like this logic is wrong, therefore disabling it with `&& false` for now.
994 For "PoPoLoCrois Monogatari II", the game logic will soft lock and will never issue GetLocP to detect
995 the end of its XA streams, as it seems to assume ReadS will not return a status byte with the SEEK
996 flag set. I think the reasonning is that since it's invalid to call GetLocP while seeking, the game
997 tries to protect itself against errors by preventing from issuing a GetLocP while it knows the
998 last status was "seek". But this makes the logic just softlock as it'll never get a notification
999 about the fact the drive is done seeking and the read actually started.
1000 In other words, this state machine here is probably wrong in assuming the response to ReadS/ReadN is
1001 done right away. It's rather when it's done seeking, and the read has actually started. This probably
1002 requires a bit more work to make sure seek delays are processed properly.
1003 Checked with a few games, this seems to work fine."
1005 Gameblabla additional notes :
1006 This still needs the "+ seekTime" that PCSX Redux doesn't have for the Driver "retry" mission error.
1008 cdr.StatP |= STATUS_READ;
1009 cdr.StatP &= ~STATUS_SEEK;
1010 CDREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime);
1012 cdr.Result[0] = cdr.StatP;
1018 CDR_LOG_I("Invalid command: %02x\n", Irq);
1019 error = ERROR_INVALIDCMD;
1024 cdr.Result[0] = cdr.StatP | STATUS_ERROR;
1025 cdr.Result[1] = error;
1026 cdr.Stat = DiskError;
1030 if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) {
1031 cdr.DriveState = DRIVESTATE_STANDBY;
1032 cdr.StatP |= STATUS_ROTATING;
1035 if (!no_busy_error) {
1036 switch (cdr.DriveState) {
1037 case DRIVESTATE_LID_OPEN:
1038 case DRIVESTATE_RESCAN_CD:
1039 case DRIVESTATE_PREPARE_CD:
1041 cdr.Result[0] = cdr.StatP | STATUS_ERROR;
1042 cdr.Result[1] = ERROR_NOTREADY;
1043 cdr.Stat = DiskError;
1052 #ifdef CDR_LOG_CMD_IRQ
1055 SysPrintf("CDR IRQ %d cmd %02x stat %02x: ",
1056 !!(cdr.Stat & cdr.Reg2), Irq, cdr.Stat);
1057 for (i = 0; i < cdr.ResultC; i++)
1058 SysPrintf("%02x ", cdr.Result[i]);
1065 #define ssat32_to_16(v) \
1066 asm("ssat %0,#16,%1" : "=r" (v) : "r" (v))
1068 #define ssat32_to_16(v) do { \
1069 if (v < -32768) v = -32768; \
1070 else if (v > 32767) v = 32767; \
1074 void cdrAttenuate(s16 *buf, int samples, int stereo)
1077 int ll = cdr.AttenuatorLeftToLeft;
1078 int lr = cdr.AttenuatorLeftToRight;
1079 int rl = cdr.AttenuatorRightToLeft;
1080 int rr = cdr.AttenuatorRightToRight;
1082 if (lr == 0 && rl == 0 && 0x78 <= ll && ll <= 0x88 && 0x78 <= rr && rr <= 0x88)
1085 if (!stereo && ll == 0x40 && lr == 0x40 && rl == 0x40 && rr == 0x40)
1089 for (i = 0; i < samples; i++) {
1092 l = (l * ll + r * rl) >> 7;
1093 r = (r * rr + l * lr) >> 7;
1101 for (i = 0; i < samples; i++) {
1103 l = l * (ll + rl) >> 7;
1104 //r = r * (rr + lr) >> 7;
1112 void cdrReadInterrupt() {
1118 if (cdr.Irq || cdr.Stat) {
1119 CDR_LOG_I("cdrom: read stat hack %02x %x\n", cdr.Irq, cdr.Stat);
1126 cdr.StatP |= STATUS_READ|STATUS_ROTATING;
1127 cdr.StatP &= ~STATUS_SEEK;
1128 cdr.Result[0] = cdr.StatP;
1129 cdr.Seeked = SEEK_DONE;
1131 ReadTrack(cdr.SetSectorPlay);
1133 buf = CDR_getBuffer();
1137 if (cdr.RErr == 0) {
1138 CDR_LOG_I("cdrReadInterrupt() Log: err\n");
1139 memset(cdr.Transfer, 0, DATA_SIZE);
1140 cdr.Stat = DiskError;
1141 cdr.Result[0] |= STATUS_ERROR;
1142 CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime);
1146 memcpy(cdr.Transfer, buf, DATA_SIZE);
1147 CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]);
1150 CDR_LOG("cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]);
1152 if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA
1153 // Firemen 2: Multi-XA files - briefings, cutscenes
1154 if( cdr.FirstSector == 1 && (cdr.Mode & MODE_SF)==0 ) {
1155 cdr.File = cdr.Transfer[4 + 0];
1156 cdr.Channel = cdr.Transfer[4 + 1];
1160 * Skips playing on channel 255.
1161 * Fixes missing audio in Blue's Clues : Blue's Big Musical. (Should also fix Taxi 2)
1162 * TODO : Check if this is the proper behaviour.
1164 if((cdr.Transfer[4 + 2] & 0x4) &&
1165 (cdr.Transfer[4 + 1] == cdr.Channel) &&
1166 (cdr.Transfer[4 + 0] == cdr.File) && cdr.Channel != 255) {
1167 int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector);
1169 cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo);
1170 SPU_playADPCMchannel(&cdr.Xa);
1171 cdr.FirstSector = 0;
1173 else cdr.FirstSector = -1;
1177 cdr.SetSectorPlay[2]++;
1178 if (cdr.SetSectorPlay[2] == 75) {
1179 cdr.SetSectorPlay[2] = 0;
1180 cdr.SetSectorPlay[1]++;
1181 if (cdr.SetSectorPlay[1] == 60) {
1182 cdr.SetSectorPlay[1] = 0;
1183 cdr.SetSectorPlay[0]++;
1189 uint32_t delay = (cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime;
1190 if (cdr.m_locationChanged) {
1191 CDREAD_INT(delay * 30);
1192 cdr.m_locationChanged = FALSE;
1198 Croc 2: $40 - only FORM1 (*)
1199 Judge Dredd: $C8 - only FORM1 (*)
1200 Sim Theme Park - no adpcm at all (zero)
1203 if (!(cdr.Mode & MODE_STRSND) || !(cdr.Transfer[4+2] & 0x4)) {
1204 cdr.Stat = DataReady;
1208 // update for CdlGetlocP
1209 ReadTrack(cdr.SetSectorPlay);
1218 bit 5 - 1 result ready
1220 bit 7 - 1 command being processed
1223 unsigned char cdrRead0(void) {
1224 if (cdr.ResultReady)
1232 // cdr.Ctrl &= ~0x40;
1234 // What means the 0x10 and the 0x08 bits? I only saw it used by the bios
1237 CDR_LOG_IO("cdr r0: %02x\n", cdr.Ctrl);
1239 return psxHu8(0x1800) = cdr.Ctrl;
1242 void cdrWrite0(unsigned char rt) {
1243 CDR_LOG_IO("cdr w0: %02x\n", rt);
1245 cdr.Ctrl = (rt & 3) | (cdr.Ctrl & ~3);
1248 unsigned char cdrRead1(void) {
1249 if ((cdr.ResultP & 0xf) < cdr.ResultC)
1250 psxHu8(0x1801) = cdr.Result[cdr.ResultP & 0xf];
1254 if (cdr.ResultP == cdr.ResultC)
1255 cdr.ResultReady = 0;
1257 CDR_LOG_IO("cdr r1: %02x\n", psxHu8(0x1801));
1259 return psxHu8(0x1801);
1262 void cdrWrite1(unsigned char rt) {
1266 CDR_LOG_IO("cdr w1: %02x\n", rt);
1268 switch (cdr.Ctrl & 3) {
1272 cdr.AttenuatorRightToRightT = rt;
1281 #ifdef CDR_LOG_CMD_IRQ
1282 SysPrintf("CD1 write: %x (%s)", rt, CmdName[rt]);
1284 SysPrintf(" Param[%d] = {", cdr.ParamC);
1285 for (i = 0; i < cdr.ParamC; i++)
1286 SysPrintf(" %x,", cdr.Param[i]);
1293 cdr.ResultReady = 0;
1295 // cdr.Stat = NoIntr;
1296 AddIrqQueue(cdr.Cmd, 0x800);
1300 CDR_LOG("CDROM setloc command (%02X, %02X, %02X)\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
1302 // MM must be BCD, SS must be BCD and <0x60, FF must be BCD and <0x75
1303 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))
1305 CDR_LOG("Invalid/out of range seek to %02X:%02X:%02X\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
1309 for (i = 0; i < 3; i++)
1311 set_loc[i] = btoi(cdr.Param[i]);
1314 i = msf2sec(cdr.SetSectorPlay);
1315 i = abs(i - msf2sec(set_loc));
1317 cdr.Seeked = SEEK_PENDING;
1319 memcpy(cdr.SetSector, set_loc, 3);
1320 cdr.SetSector[3] = 0;
1321 cdr.SetlocPending = 1;
1334 cdr.Seeked = SEEK_DONE;
1340 CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]);
1342 cdr.Mode = cdr.Param[0];
1344 // Squaresoft on PlayStation 1998 Collector's CD Vol. 1
1345 // - fixes choppy movie sound
1346 if( cdr.Play && (cdr.Mode & MODE_CDDA) == 0 )
1352 unsigned char cdrRead2(void) {
1355 if (cdr.Readed == 0) {
1361 CDR_LOG_IO("cdr r2: %02x\n", ret);
1365 void cdrWrite2(unsigned char rt) {
1366 CDR_LOG_IO("cdr w2: %02x\n", rt);
1368 switch (cdr.Ctrl & 3) {
1370 if (cdr.ParamC < 8) // FIXME: size and wrapping
1371 cdr.Param[cdr.ParamC++] = rt;
1378 cdr.AttenuatorLeftToLeftT = rt;
1381 cdr.AttenuatorRightToLeftT = rt;
1386 unsigned char cdrRead3(void) {
1388 psxHu8(0x1803) = cdr.Stat | 0xE0;
1390 psxHu8(0x1803) = cdr.Reg2 | 0xE0;
1392 CDR_LOG_IO("cdr r3: %02x\n", psxHu8(0x1803));
1393 return psxHu8(0x1803);
1396 void cdrWrite3(unsigned char rt) {
1397 CDR_LOG_IO("cdr w3: %02x\n", rt);
1399 switch (cdr.Ctrl & 3) {
1409 cdr.AttenuatorLeftToRightT = rt;
1413 memcpy(&cdr.AttenuatorLeftToLeft, &cdr.AttenuatorLeftToLeftT, 4);
1414 CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n",
1415 cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
1416 cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight);
1421 if ((rt & 0x80) && cdr.Readed == 0) {
1423 pTransfer = cdr.Transfer;
1425 switch (cdr.Mode & 0x30) {
1426 case MODE_SIZE_2328:
1431 case MODE_SIZE_2340:
1441 void psxDma3(u32 madr, u32 bcr, u32 chcr) {
1446 CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr);
1451 if (cdr.Readed == 0) {
1452 CDR_LOG("psxDma3() Log: *** DMA 3 *** NOT READY\n");
1456 cdsize = (bcr & 0xffff) * 4;
1458 // Ape Escape: bcr = 0001 / 0000
1462 switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {
1463 case MODE_SIZE_2340: cdsize = 2340; break;
1464 case MODE_SIZE_2328: cdsize = 2328; break;
1466 case MODE_SIZE_2048: cdsize = 2048; break;
1471 ptr = (u8 *)PSXM(madr);
1473 CDR_LOG("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n");
1478 GS CDX: Enhancement CD crash
1481 - Spams DMA3 and gets buffer overrun
1483 size = CD_FRAMESIZE_RAW - (pTransfer - cdr.Transfer);
1488 memcpy(ptr, pTransfer, size);
1491 psxCpu->Clear(madr, cdsize / 4);
1492 pTransfer += cdsize;
1494 if( chcr == 0x11400100 ) {
1495 HW_DMA3_MADR = SWAPu32(madr + cdsize);
1496 CDRDMA_INT( (cdsize/4) / 4 );
1498 else if( chcr == 0x11000000 ) {
1499 // CDRDMA_INT( (cdsize/4) * 1 );
1501 psxRegs.cycle += (cdsize/4) * 24/2;
1507 CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr);
1511 HW_DMA3_CHCR &= SWAP32(~0x01000000);
1515 void cdrDmaInterrupt()
1517 if (HW_DMA3_CHCR & SWAP32(0x01000000))
1519 HW_DMA3_CHCR &= SWAP32(~0x01000000);
1524 static void getCdInfo(void)
1528 CDR_getTN(cdr.ResultTN);
1529 CDR_getTD(0, cdr.SetSectorEnd);
1530 tmp = cdr.SetSectorEnd[0];
1531 cdr.SetSectorEnd[0] = cdr.SetSectorEnd[2];
1532 cdr.SetSectorEnd[2] = tmp;
1536 memset(&cdr, 0, sizeof(cdr));
1542 cdr.DriveState = DRIVESTATE_STANDBY;
1543 cdr.StatP = STATUS_ROTATING;
1544 pTransfer = cdr.Transfer;
1545 cdr.SetlocPending = 0;
1546 cdr.m_locationChanged = FALSE;
1548 // BIOS player - default values
1549 cdr.AttenuatorLeftToLeft = 0x80;
1550 cdr.AttenuatorLeftToRight = 0x00;
1551 cdr.AttenuatorRightToLeft = 0x00;
1552 cdr.AttenuatorRightToRight = 0x80;
1557 int cdrFreeze(void *f, int Mode) {
1561 if (Mode == 0 && !Config.Cdda)
1564 cdr.freeze_ver = 0x63647202;
1565 gzfreeze(&cdr, sizeof(cdr));
1568 cdr.ParamP = cdr.ParamC;
1569 tmp = pTransfer - cdr.Transfer;
1572 gzfreeze(&tmp, sizeof(tmp));
1577 pTransfer = cdr.Transfer + tmp;
1579 // read right sub data
1580 tmpp[0] = btoi(cdr.Prev[0]);
1581 tmpp[1] = btoi(cdr.Prev[1]);
1582 tmpp[2] = btoi(cdr.Prev[2]);
1587 if (cdr.freeze_ver < 0x63647202)
1588 memcpy(cdr.SetSectorPlay, cdr.SetSector, 3);
1590 Find_CurTrack(cdr.SetSectorPlay);
1592 CDR_play(cdr.SetSectorPlay);
1595 if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {
1596 // old versions did not latch Reg2, have to fixup..
1597 if (cdr.Reg2 == 0) {
1598 SysPrintf("cdrom: fixing up old savestate\n");
1601 // also did not save Attenuator..
1602 if ((cdr.AttenuatorLeftToLeft | cdr.AttenuatorLeftToRight
1603 | cdr.AttenuatorRightToLeft | cdr.AttenuatorRightToRight) == 0)
1605 cdr.AttenuatorLeftToLeft = cdr.AttenuatorRightToRight = 0x80;
1613 void LidInterrupt() {
1616 cdrLidSeekInterrupt();