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;
49 static s16 read_buf[CD_FRAMESIZE_RAW/2];
51 /* CD-ROM magic numbers */
52 #define CdlSync 0 /* nocash documentation : "Uh, actually, returns error code 40h = Invalid Command...?" */
65 #define CdlSetfilter 13
67 #define CdlGetparam 15
75 #define CdlSetclock 23
76 #define CdlGetclock 24
84 char *CmdName[0x100]= {
85 "CdlSync", "CdlNop", "CdlSetloc", "CdlPlay",
86 "CdlForward", "CdlBackward", "CdlReadN", "CdlStandby",
87 "CdlStop", "CdlPause", "CdlReset", "CdlMute",
88 "CdlDemute", "CdlSetfilter", "CdlSetmode", "CdlGetparam",
89 "CdlGetlocL", "CdlGetlocP", "CdlReadT", "CdlGetTN",
90 "CdlGetTD", "CdlSeekL", "CdlSeekP", "CdlSetclock",
91 "CdlGetclock", "CdlTest", "CdlID", "CdlReadS",
92 "CdlInit", NULL, "CDlReadToc", NULL
95 unsigned char Test04[] = { 0 };
96 unsigned char Test05[] = { 0 };
97 unsigned char Test20[] = { 0x98, 0x06, 0x10, 0xC3 };
98 unsigned char Test22[] = { 0x66, 0x6F, 0x72, 0x20, 0x45, 0x75, 0x72, 0x6F };
99 unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 };
105 #define Acknowledge 3
110 #define MODE_SPEED (1<<7) // 0x80
111 #define MODE_STRSND (1<<6) // 0x40 ADPCM on/off
112 #define MODE_SIZE_2340 (1<<5) // 0x20
113 #define MODE_SIZE_2328 (1<<4) // 0x10
114 #define MODE_SIZE_2048 (0<<4) // 0x00
115 #define MODE_SF (1<<3) // 0x08 channel on/off
116 #define MODE_REPORT (1<<2) // 0x04
117 #define MODE_AUTOPAUSE (1<<1) // 0x02
118 #define MODE_CDDA (1<<0) // 0x01
121 #define STATUS_PLAY (1<<7) // 0x80
122 #define STATUS_SEEK (1<<6) // 0x40
123 #define STATUS_READ (1<<5) // 0x20
124 #define STATUS_SHELLOPEN (1<<4) // 0x10
125 #define STATUS_UNKNOWN3 (1<<3) // 0x08
126 #define STATUS_UNKNOWN2 (1<<2) // 0x04
127 #define STATUS_ROTATING (1<<1) // 0x02
128 #define STATUS_ERROR (1<<0) // 0x01
131 #define ERROR_NOTREADY (1<<7) // 0x80
132 #define ERROR_INVALIDCMD (1<<6) // 0x40
133 #define ERROR_INVALIDARG (1<<5) // 0x20
135 // 1x = 75 sectors per second
136 // PSXCLK = 1 sec in the ps
137 // so (PSXCLK / 75) = cdr read time (linuzappz)
138 #define cdReadTime (PSXCLK / 75)
141 DRIVESTATE_STANDBY = 0,
143 DRIVESTATE_RESCAN_CD,
144 DRIVESTATE_PREPARE_CD,
154 static struct CdrStat stat;
156 static unsigned int msf2sec(const u8 *msf) {
157 return ((msf[0] * 60 + msf[1]) * 75) + msf[2];
160 // for that weird psemu API..
161 static unsigned int fsm2sec(const u8 *msf) {
162 return ((msf[2] * 60 + msf[1]) * 75) + msf[0];
165 static void sec2msf(unsigned int s, u8 *msf) {
166 msf[0] = s / 75 / 60;
167 s = s - msf[0] * 75 * 60;
174 #define CDR_INT(eCycle) { \
175 psxRegs.interrupt |= (1 << PSXINT_CDR); \
176 psxRegs.intCycle[PSXINT_CDR].cycle = eCycle; \
177 psxRegs.intCycle[PSXINT_CDR].sCycle = psxRegs.cycle; \
178 new_dyna_set_event(PSXINT_CDR, eCycle); \
182 #define CDREAD_INT(eCycle) { \
183 psxRegs.interrupt |= (1 << PSXINT_CDREAD); \
184 psxRegs.intCycle[PSXINT_CDREAD].cycle = eCycle; \
185 psxRegs.intCycle[PSXINT_CDREAD].sCycle = psxRegs.cycle; \
186 new_dyna_set_event(PSXINT_CDREAD, eCycle); \
189 // cdrLidSeekInterrupt
190 #define CDRLID_INT(eCycle) { \
191 psxRegs.interrupt |= (1 << PSXINT_CDRLID); \
192 psxRegs.intCycle[PSXINT_CDRLID].cycle = eCycle; \
193 psxRegs.intCycle[PSXINT_CDRLID].sCycle = psxRegs.cycle; \
194 new_dyna_set_event(PSXINT_CDRLID, eCycle); \
198 #define CDRMISC_INT(eCycle) { \
199 psxRegs.interrupt |= (1 << PSXINT_CDRPLAY); \
200 psxRegs.intCycle[PSXINT_CDRPLAY].cycle = eCycle; \
201 psxRegs.intCycle[PSXINT_CDRPLAY].sCycle = psxRegs.cycle; \
202 new_dyna_set_event(PSXINT_CDRPLAY, eCycle); \
205 #define StopReading() { \
208 psxRegs.interrupt &= ~(1 << PSXINT_CDREAD); \
210 cdr.StatP &= ~(STATUS_READ|STATUS_SEEK);\
213 #define StopCdda() { \
215 if (!Config.Cdda) CDR_stop(); \
216 cdr.StatP &= ~STATUS_PLAY; \
218 cdr.FastForward = 0; \
219 cdr.FastBackward = 0; \
220 /*SPU_registerCallback( SPUirq );*/ \
224 #define SetResultSize(size) { \
226 cdr.ResultC = size; \
227 cdr.ResultReady = 1; \
230 static void setIrq(void)
232 if (cdr.Stat & cdr.Reg2)
233 psxHu32ref(0x1070) |= SWAP32((u32)0x4);
236 // timing used in this function was taken from tests on real hardware
237 // (yes it's slow, but you probably don't want to modify it)
238 void cdrLidSeekInterrupt()
240 switch (cdr.DriveState) {
242 case DRIVESTATE_STANDBY:
243 cdr.StatP &= ~STATUS_SEEK;
245 if (CDR_getStatus(&stat) == -1)
248 if (stat.Status & STATUS_SHELLOPEN)
251 cdr.DriveState = DRIVESTATE_LID_OPEN;
256 case DRIVESTATE_LID_OPEN:
257 if (CDR_getStatus(&stat) == -1)
258 stat.Status &= ~STATUS_SHELLOPEN;
261 if (!(cdr.StatP & STATUS_SHELLOPEN)) {
263 cdr.StatP |= STATUS_SHELLOPEN;
265 // could generate error irq here, but real hardware
266 // only sometimes does that
267 // (not done when lots of commands are sent?)
269 CDRLID_INT(cdReadTime * 30);
272 else if (cdr.StatP & STATUS_ROTATING) {
273 cdr.StatP &= ~STATUS_ROTATING;
275 else if (!(stat.Status & STATUS_SHELLOPEN)) {
279 // cdr.StatP STATUS_SHELLOPEN is "sticky"
280 // and is only cleared by CdlNop
282 cdr.DriveState = DRIVESTATE_RESCAN_CD;
283 CDRLID_INT(cdReadTime * 105);
288 CDRLID_INT(cdReadTime * 3);
291 case DRIVESTATE_RESCAN_CD:
292 cdr.StatP |= STATUS_ROTATING;
293 cdr.DriveState = DRIVESTATE_PREPARE_CD;
295 // this is very long on real hardware, over 6 seconds
296 // make it a bit faster here...
297 CDRLID_INT(cdReadTime * 150);
300 case DRIVESTATE_PREPARE_CD:
301 cdr.StatP |= STATUS_SEEK;
303 cdr.DriveState = DRIVESTATE_STANDBY;
304 CDRLID_INT(cdReadTime * 26);
309 static void Find_CurTrack(const u8 *time)
313 current = msf2sec(time);
315 for (cdr.CurTrack = 1; cdr.CurTrack < cdr.ResultTN[1]; cdr.CurTrack++) {
316 CDR_getTD(cdr.CurTrack + 1, cdr.ResultTD);
317 sect = fsm2sec(cdr.ResultTD);
318 if (sect - current >= 150)
323 static void generate_subq(const u8 *time)
325 unsigned char start[3], next[3];
326 unsigned int this_s, start_s, next_s, pregap;
329 CDR_getTD(cdr.CurTrack, start);
330 if (cdr.CurTrack + 1 <= cdr.ResultTN[1]) {
332 CDR_getTD(cdr.CurTrack + 1, next);
335 // last track - cd size
337 next[0] = cdr.SetSectorEnd[2];
338 next[1] = cdr.SetSectorEnd[1];
339 next[2] = cdr.SetSectorEnd[0];
342 this_s = msf2sec(time);
343 start_s = fsm2sec(start);
344 next_s = fsm2sec(next);
346 cdr.TrackChanged = FALSE;
348 if (next_s - this_s < pregap) {
349 cdr.TrackChanged = TRUE;
356 relative_s = this_s - start_s;
357 if (relative_s < 0) {
359 relative_s = -relative_s;
361 sec2msf(relative_s, cdr.subq.Relative);
363 cdr.subq.Track = itob(cdr.CurTrack);
364 cdr.subq.Relative[0] = itob(cdr.subq.Relative[0]);
365 cdr.subq.Relative[1] = itob(cdr.subq.Relative[1]);
366 cdr.subq.Relative[2] = itob(cdr.subq.Relative[2]);
367 cdr.subq.Absolute[0] = itob(time[0]);
368 cdr.subq.Absolute[1] = itob(time[1]);
369 cdr.subq.Absolute[2] = itob(time[2]);
372 static void ReadTrack(const u8 *time) {
373 unsigned char tmp[3];
377 tmp[0] = itob(time[0]);
378 tmp[1] = itob(time[1]);
379 tmp[2] = itob(time[2]);
381 if (memcmp(cdr.Prev, tmp, 3) == 0)
384 CDR_LOG("ReadTrack *** %02x:%02x:%02x\n", tmp[0], tmp[1], tmp[2]);
386 cdr.NoErr = CDR_readTrack(tmp);
387 memcpy(cdr.Prev, tmp, 3);
392 subq = (struct SubQ *)CDR_getBufferSub();
393 if (subq != NULL && cdr.CurTrack == 1) {
394 crc = calcCrc((u8 *)subq + 12, 10);
395 if (crc == (((u16)subq->CRC[0] << 8) | subq->CRC[1])) {
396 cdr.subq.Track = subq->TrackNumber;
397 cdr.subq.Index = subq->IndexNumber;
398 memcpy(cdr.subq.Relative, subq->TrackRelativeAddress, 3);
399 memcpy(cdr.subq.Absolute, subq->AbsoluteAddress, 3);
402 CDR_LOG_I("subq bad crc @%02x:%02x:%02x\n",
403 tmp[0], tmp[1], tmp[2]);
410 CDR_LOG(" -> %02x,%02x %02x:%02x:%02x %02x:%02x:%02x\n",
411 cdr.subq.Track, cdr.subq.Index,
412 cdr.subq.Relative[0], cdr.subq.Relative[1], cdr.subq.Relative[2],
413 cdr.subq.Absolute[0], cdr.subq.Absolute[1], cdr.subq.Absolute[2]);
416 static void AddIrqQueue(unsigned short irq, unsigned long ecycle) {
418 if (irq == cdr.Irq || irq + 0x100 == cdr.Irq) {
424 CDR_LOG_I("cdr: override cmd %02x -> %02x\n", cdr.Irq, irq);
433 static void cdrPlayInterrupt_Autopause()
436 boolean abs_lev_chselect;
439 if ((cdr.Mode & MODE_AUTOPAUSE) && cdr.TrackChanged) {
440 CDR_LOG( "CDDA STOP\n" );
442 // Magic the Gathering
443 // - looping territory cdda
446 //cdr.ResultReady = 1;
447 //cdr.Stat = DataReady;
453 else if (((cdr.Mode & MODE_REPORT) || cdr.FastForward || cdr.FastBackward)) {
454 cdr.Result[0] = cdr.StatP;
455 cdr.Result[1] = cdr.subq.Track;
456 cdr.Result[2] = cdr.subq.Index;
458 abs_lev_chselect = cdr.subq.Absolute[1] & 0x01;
460 /* 8 is a hack. For accuracy, it should be 588. */
461 for (i = 0; i < 8; i++)
463 abs_lev_max = MAX_VALUE(abs_lev_max, abs(read_buf[i * 2 + abs_lev_chselect]));
465 abs_lev_max = MIN_VALUE(abs_lev_max, 32767);
466 abs_lev_max |= abs_lev_chselect << 15;
468 if (cdr.subq.Absolute[2] & 0x10) {
469 cdr.Result[3] = cdr.subq.Relative[0];
470 cdr.Result[4] = cdr.subq.Relative[1] | 0x80;
471 cdr.Result[5] = cdr.subq.Relative[2];
474 cdr.Result[3] = cdr.subq.Absolute[0];
475 cdr.Result[4] = cdr.subq.Absolute[1];
476 cdr.Result[5] = cdr.subq.Absolute[2];
479 cdr.Result[6] = abs_lev_max >> 0;
480 cdr.Result[7] = abs_lev_max >> 8;
482 // Rayman: Logo freeze (resultready + dataready)
484 cdr.Stat = DataReady;
492 void cdrPlayInterrupt()
494 if (cdr.Seeked == SEEK_PENDING) {
496 CDR_LOG_I("cdrom: seek stat hack\n");
501 cdr.StatP |= STATUS_ROTATING;
502 cdr.StatP &= ~STATUS_SEEK;
503 cdr.Result[0] = cdr.StatP;
504 cdr.Seeked = SEEK_DONE;
510 if (cdr.SetlocPending) {
511 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
512 cdr.SetlocPending = 0;
513 cdr.m_locationChanged = TRUE;
515 Find_CurTrack(cdr.SetSectorPlay);
516 ReadTrack(cdr.SetSectorPlay);
517 cdr.TrackChanged = FALSE;
520 if (!cdr.Play) return;
522 CDR_LOG( "CDDA - %d:%d:%d\n",
523 cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] );
525 if (memcmp(cdr.SetSectorPlay, cdr.SetSectorEnd, 3) == 0) {
527 cdr.TrackChanged = TRUE;
530 CDR_readCDDA(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], (u8 *)read_buf);
533 if (!cdr.Irq && !cdr.Stat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT)))
534 cdrPlayInterrupt_Autopause();
536 if (CDR_readCDDA && !cdr.Muted && !Config.Cdda) {
537 cdrAttenuate(read_buf, CD_FRAMESIZE_RAW / 4, 1);
538 if (SPU_playCDDAchannel)
539 SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW);
542 cdr.SetSectorPlay[2]++;
543 if (cdr.SetSectorPlay[2] == 75) {
544 cdr.SetSectorPlay[2] = 0;
545 cdr.SetSectorPlay[1]++;
546 if (cdr.SetSectorPlay[1] == 60) {
547 cdr.SetSectorPlay[1] = 0;
548 cdr.SetSectorPlay[0]++;
552 if (cdr.m_locationChanged)
554 CDRMISC_INT(cdReadTime * 30);
555 cdr.m_locationChanged = FALSE;
559 CDRMISC_INT(cdReadTime);
562 // update for CdlGetlocP/autopause
563 generate_subq(cdr.SetSectorPlay);
566 void cdrInterrupt() {
568 int no_busy_error = 0;
569 int start_rotating = 0;
572 unsigned int seekTime = 0;
578 CDR_LOG_I("cdrom: stat hack: %02x %x\n", cdr.Irq, cdr.Stat);
587 cdr.Result[0] = cdr.StatP;
588 cdr.Stat = Acknowledge;
590 if (cdr.IrqRepeated) {
592 if (cdr.eCycle > psxRegs.cycle) {
602 if (cdr.DriveState != DRIVESTATE_LID_OPEN)
603 cdr.StatP &= ~STATUS_SHELLOPEN;
608 CDR_LOG("CDROM setloc command (%02X, %02X, %02X)\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
610 // MM must be BCD, SS must be BCD and <0x60, FF must be BCD and <0x75
611 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))
613 CDR_LOG("Invalid/out of range seek to %02X:%02X:%02X\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
614 error = ERROR_INVALIDARG;
619 for (i = 0; i < 3; i++)
621 set_loc[i] = btoi(cdr.Param[i]);
624 i = msf2sec(cdr.SetSectorPlay);
625 i = abs(i - msf2sec(set_loc));
627 cdr.Seeked = SEEK_PENDING;
629 memcpy(cdr.SetSector, set_loc, 3);
630 cdr.SetSector[3] = 0;
631 cdr.SetlocPending = 1;
638 if (cdr.Seeked == SEEK_PENDING) {
639 // XXX: wrong, should seek instead..
640 cdr.Seeked = SEEK_DONE;
643 cdr.FastBackward = 0;
646 if (cdr.SetlocPending) {
647 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
648 cdr.SetlocPending = 0;
649 cdr.m_locationChanged = TRUE;
653 // - Pause player, hit Track 01/02/../xx (Setloc issued!!)
655 if (cdr.ParamC == 0 || cdr.Param[0] == 0) {
656 CDR_LOG("PLAY Resume @ %d:%d:%d\n",
657 cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]);
661 int track = btoi( cdr.Param[0] );
663 if (track <= cdr.ResultTN[1])
664 cdr.CurTrack = track;
666 CDR_LOG("PLAY track %d\n", cdr.CurTrack);
668 if (CDR_getTD((u8)cdr.CurTrack, cdr.ResultTD) != -1) {
669 cdr.SetSectorPlay[0] = cdr.ResultTD[2];
670 cdr.SetSectorPlay[1] = cdr.ResultTD[1];
671 cdr.SetSectorPlay[2] = cdr.ResultTD[0];
676 Rayman: detect track changes
679 Twisted Metal 2: skip PREGAP + starting accurate SubQ
680 - plays tracks without retry play
682 Wild 9: skip PREGAP + starting accurate SubQ
683 - plays tracks without retry play
685 Find_CurTrack(cdr.SetSectorPlay);
686 ReadTrack(cdr.SetSectorPlay);
687 cdr.TrackChanged = FALSE;
693 // Vib Ribbon: gameplay checks flag
694 cdr.StatP &= ~STATUS_SEEK;
695 cdr.Result[0] = cdr.StatP;
697 cdr.StatP |= STATUS_PLAY;
699 // BIOS player - set flag again
702 CDRMISC_INT( cdReadTime );
707 // TODO: error 80 if stopped
709 // GameShark CD Player: Calls 2x + Play 2x
711 cdr.FastBackward = 0;
717 // GameShark CD Player: Calls 2x + Play 2x
723 if (cdr.DriveState != DRIVESTATE_STOPPED) {
724 error = ERROR_INVALIDARG;
727 AddIrqQueue(CdlStandby + 0x100, cdReadTime * 125 / 2);
731 case CdlStandby + 0x100:
737 // grab time for current track
738 CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD);
740 cdr.SetSectorPlay[0] = cdr.ResultTD[2];
741 cdr.SetSectorPlay[1] = cdr.ResultTD[1];
742 cdr.SetSectorPlay[2] = cdr.ResultTD[0];
749 if (cdr.DriveState == DRIVESTATE_STANDBY)
750 delay = cdReadTime * 30 / 2;
752 cdr.DriveState = DRIVESTATE_STOPPED;
753 AddIrqQueue(CdlStop + 0x100, delay);
756 case CdlStop + 0x100:
757 cdr.StatP &= ~STATUS_ROTATING;
758 cdr.Result[0] = cdr.StatP;
764 Gundam Battle Assault 2: much slower (*)
765 - Fixes boot, gameplay
766 Hokuto no Ken 2: slower
767 - Fixes intro + subtitles
768 InuYasha - Feudal Fairy Tale: slower
771 /* Gameblabla - Tightening the timings (as taken from Duckstation).
772 * The timings from Duckstation are based upon hardware tests.
773 * Mednafen's timing don't work for Gundam Battle Assault 2 in PAL/50hz mode,
774 * seems to be timing sensitive as it can depend on the CPU's clock speed.
776 * We will need to get around this for Bedlam/Rise 2 later...
778 if (cdr.DriveState == DRIVESTATE_STANDBY)
784 delay = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * (1000000));
785 CDRMISC_INT((cdr.Mode & MODE_SPEED) ? cdReadTime / 2 : cdReadTime);
787 AddIrqQueue(CdlPause + 0x100, delay);
791 case CdlPause + 0x100:
792 cdr.StatP &= ~STATUS_READ;
793 cdr.Result[0] = cdr.StatP;
799 cdr.Mode = 0x20; /* Needed for This is Football 2, Pooh's Party and possibly others. */
800 AddIrqQueue(CdlReset + 0x100, 4100000);
805 case CdlReset + 0x100:
818 cdr.File = cdr.Param[0];
819 cdr.Channel = cdr.Param[1];
828 cdr.Result[1] = cdr.Mode;
830 cdr.Result[3] = cdr.File;
831 cdr.Result[4] = cdr.Channel;
837 memcpy(cdr.Result, cdr.Transfer, 8);
842 memcpy(&cdr.Result, &cdr.subq, 8);
845 case CdlReadT: // SetSession?
847 AddIrqQueue(CdlReadT + 0x100, cdReadTime * 290 / 4);
851 case CdlReadT + 0x100:
857 if (CDR_getTN(cdr.ResultTN) == -1) {
858 cdr.Stat = DiskError;
859 cdr.Result[0] |= STATUS_ERROR;
861 cdr.Stat = Acknowledge;
862 cdr.Result[1] = itob(cdr.ResultTN[0]);
863 cdr.Result[2] = itob(cdr.ResultTN[1]);
868 cdr.Track = btoi(cdr.Param[0]);
870 if (CDR_getTD(cdr.Track, cdr.ResultTD) == -1) {
871 cdr.Stat = DiskError;
872 cdr.Result[0] |= STATUS_ERROR;
874 cdr.Stat = Acknowledge;
875 cdr.Result[0] = cdr.StatP;
876 cdr.Result[1] = itob(cdr.ResultTD[2]);
877 cdr.Result[2] = itob(cdr.ResultTD[1]);
878 /* According to Nocash's documentation, the function doesn't care about ff.
879 * This can be seen also in Mednafen's implementation. */
880 //cdr.Result[3] = itob(cdr.ResultTD[0]);
888 cdr.StatP |= STATUS_SEEK;
891 Crusaders of Might and Magic = 0.5x-4x
892 - fix cutscene speech start
898 - fix cutscene speech
903 CDRMISC_INT(cdr.Seeked == SEEK_DONE ? 0x800 : cdReadTime * 4);
904 cdr.Seeked = SEEK_PENDING;
909 switch (cdr.Param[0]) {
910 case 0x20: // System Controller ROM Version
912 memcpy(cdr.Result, Test20, 4);
916 memcpy(cdr.Result, Test22, 4);
918 case 0x23: case 0x24:
920 memcpy(cdr.Result, Test23, 4);
927 AddIrqQueue(CdlID + 0x100, 20480);
932 cdr.Result[0] = cdr.StatP;
937 // 0x10 - audio | 0x40 - disk missing | 0x80 - unlicensed
938 if (CDR_getStatus(&stat) == -1 || stat.Type == 0 || stat.Type == 0xff) {
939 cdr.Result[1] = 0xc0;
943 cdr.Result[1] |= 0x10;
944 if (CdromId[0] == '\0')
945 cdr.Result[1] |= 0x80;
947 cdr.Result[0] |= (cdr.Result[1] >> 4) & 0x08;
949 /* This adds the string "PCSX" in Playstation bios boot screen */
950 memcpy((char *)&cdr.Result[4], "PCSX", 4);
955 // yes, it really sets STATUS_SHELLOPEN
956 cdr.StatP |= STATUS_SHELLOPEN;
957 cdr.DriveState = DRIVESTATE_RESCAN_CD;
968 AddIrqQueue(CdlReadToc + 0x100, cdReadTime * 180 / 4);
973 case CdlReadToc + 0x100:
980 if (cdr.SetlocPending) {
981 seekTime = abs(msf2sec(cdr.SetSectorPlay) - msf2sec(cdr.SetSector)) * (cdReadTime / 200);
984 * It was originally set to 1000000 for Driver, however it is not high enough for Worms Pinball
985 * and was unreliable for that game.
986 * I also tested it against Mednafen and Driver's titlescreen music starts 25 frames later, not immediatly.
988 * Obviously, this isn't perfect but right now, it should be a bit better.
989 * Games to test this against if you change that setting :
990 * - Driver (titlescreen music delay and retry mission)
991 * - Worms Pinball (Will either not boot or crash in the memory card screen)
992 * - Viewpoint (short pauses if the delay in the ingame music is too long)
994 * It seems that 3386880 * 5 is too much for Driver's titlescreen and it starts skipping.
995 * However, 1000000 is not enough for Worms Pinball to reliably boot.
997 if(seekTime > 3386880 * 2) seekTime = 3386880 * 2;
998 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
999 cdr.SetlocPending = 0;
1000 cdr.m_locationChanged = TRUE;
1002 Find_CurTrack(cdr.SetSectorPlay);
1004 if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1)
1005 // Read* acts as play for cdda tracks in cdda mode
1009 cdr.FirstSector = 1;
1011 // Fighting Force 2 - update subq time immediately
1013 ReadTrack(cdr.SetSectorPlay);
1016 // Crusaders of Might and Magic - update getlocl now
1017 // - fixes cutscene speech
1019 u8 *buf = CDR_getBuffer();
1021 memcpy(cdr.Transfer, buf, 8);
1025 Duke Nukem: Land of the Babes - seek then delay read for one frame
1027 C-12 - Final Resistance - doesn't like seek
1031 By nicolasnoble from PCSX Redux :
1032 "It LOOKS like this logic is wrong, therefore disabling it with `&& false` for now.
1033 For "PoPoLoCrois Monogatari II", the game logic will soft lock and will never issue GetLocP to detect
1034 the end of its XA streams, as it seems to assume ReadS will not return a status byte with the SEEK
1035 flag set. I think the reasonning is that since it's invalid to call GetLocP while seeking, the game
1036 tries to protect itself against errors by preventing from issuing a GetLocP while it knows the
1037 last status was "seek". But this makes the logic just softlock as it'll never get a notification
1038 about the fact the drive is done seeking and the read actually started.
1039 In other words, this state machine here is probably wrong in assuming the response to ReadS/ReadN is
1040 done right away. It's rather when it's done seeking, and the read has actually started. This probably
1041 requires a bit more work to make sure seek delays are processed properly.
1042 Checked with a few games, this seems to work fine."
1044 Gameblabla additional notes :
1045 This still needs the "+ seekTime" that PCSX Redux doesn't have for the Driver "retry" mission error.
1047 cdr.StatP |= STATUS_READ;
1048 cdr.StatP &= ~STATUS_SEEK;
1049 CDREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime);
1051 cdr.Result[0] = cdr.StatP;
1057 CDR_LOG_I("Invalid command: %02x\n", Irq);
1058 error = ERROR_INVALIDCMD;
1063 cdr.Result[0] = cdr.StatP | STATUS_ERROR;
1064 cdr.Result[1] = error;
1065 cdr.Stat = DiskError;
1069 if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) {
1070 cdr.DriveState = DRIVESTATE_STANDBY;
1071 cdr.StatP |= STATUS_ROTATING;
1074 if (!no_busy_error) {
1075 switch (cdr.DriveState) {
1076 case DRIVESTATE_LID_OPEN:
1077 case DRIVESTATE_RESCAN_CD:
1078 case DRIVESTATE_PREPARE_CD:
1080 cdr.Result[0] = cdr.StatP | STATUS_ERROR;
1081 cdr.Result[1] = ERROR_NOTREADY;
1082 cdr.Stat = DiskError;
1091 #ifdef CDR_LOG_CMD_IRQ
1094 SysPrintf("CDR IRQ %d cmd %02x stat %02x: ",
1095 !!(cdr.Stat & cdr.Reg2), Irq, cdr.Stat);
1096 for (i = 0; i < cdr.ResultC; i++)
1097 SysPrintf("%02x ", cdr.Result[i]);
1104 #define ssat32_to_16(v) \
1105 asm("ssat %0,#16,%1" : "=r" (v) : "r" (v))
1107 #define ssat32_to_16(v) do { \
1108 if (v < -32768) v = -32768; \
1109 else if (v > 32767) v = 32767; \
1113 void cdrAttenuate(s16 *buf, int samples, int stereo)
1116 int ll = cdr.AttenuatorLeftToLeft;
1117 int lr = cdr.AttenuatorLeftToRight;
1118 int rl = cdr.AttenuatorRightToLeft;
1119 int rr = cdr.AttenuatorRightToRight;
1121 if (lr == 0 && rl == 0 && 0x78 <= ll && ll <= 0x88 && 0x78 <= rr && rr <= 0x88)
1124 if (!stereo && ll == 0x40 && lr == 0x40 && rl == 0x40 && rr == 0x40)
1128 for (i = 0; i < samples; i++) {
1131 l = (l * ll + r * rl) >> 7;
1132 r = (r * rr + l * lr) >> 7;
1140 for (i = 0; i < samples; i++) {
1142 l = l * (ll + rl) >> 7;
1143 //r = r * (rr + lr) >> 7;
1151 void cdrReadInterrupt() {
1157 if (cdr.Irq || cdr.Stat) {
1158 CDR_LOG_I("cdrom: read stat hack %02x %x\n", cdr.Irq, cdr.Stat);
1165 cdr.StatP |= STATUS_READ|STATUS_ROTATING;
1166 cdr.StatP &= ~STATUS_SEEK;
1167 cdr.Result[0] = cdr.StatP;
1168 cdr.Seeked = SEEK_DONE;
1170 ReadTrack(cdr.SetSectorPlay);
1172 buf = CDR_getBuffer();
1176 if (cdr.NoErr == 0) {
1177 CDR_LOG_I("cdrReadInterrupt() Log: err\n");
1178 memset(cdr.Transfer, 0, DATA_SIZE);
1179 cdr.Stat = DiskError;
1180 cdr.Result[0] |= STATUS_ERROR;
1181 CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime);
1185 memcpy(cdr.Transfer, buf, DATA_SIZE);
1186 CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]);
1189 CDR_LOG("cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]);
1191 if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA
1192 // Firemen 2: Multi-XA files - briefings, cutscenes
1193 if( cdr.FirstSector == 1 && (cdr.Mode & MODE_SF)==0 ) {
1194 cdr.File = cdr.Transfer[4 + 0];
1195 cdr.Channel = cdr.Transfer[4 + 1];
1199 * Skips playing on channel 255.
1200 * Fixes missing audio in Blue's Clues : Blue's Big Musical. (Should also fix Taxi 2)
1201 * TODO : Check if this is the proper behaviour.
1203 if((cdr.Transfer[4 + 2] & 0x4) &&
1204 (cdr.Transfer[4 + 1] == cdr.Channel) &&
1205 (cdr.Transfer[4 + 0] == cdr.File) && cdr.Channel != 255) {
1206 int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector);
1208 cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo);
1211 * This is a hack for Megaman X4, Castlevania etc...
1212 * that regressed from the new m_locationChanged and CDROM timings changes.
1213 * It is mostly noticeable in Castevania however and the stuttering can be very jarring.
1215 * According to PCSX redux authors, we shouldn't cause a location change if
1216 * the sector difference is too small.
1217 * I attempted to go with that approach but came empty handed.
1218 * So for now, let's just set cdr.m_locationChanged to false when playing back any ADPCM samples.
1219 * This does not regress Crash Team Racing's intro at least.
1221 cdr.m_locationChanged = FALSE;
1222 SPU_playADPCMchannel(&cdr.Xa);
1223 cdr.FirstSector = 0;
1225 else cdr.FirstSector = -1;
1229 cdr.SetSectorPlay[2]++;
1230 if (cdr.SetSectorPlay[2] == 75) {
1231 cdr.SetSectorPlay[2] = 0;
1232 cdr.SetSectorPlay[1]++;
1233 if (cdr.SetSectorPlay[1] == 60) {
1234 cdr.SetSectorPlay[1] = 0;
1235 cdr.SetSectorPlay[0]++;
1241 uint32_t delay = (cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime;
1242 if (cdr.m_locationChanged) {
1243 CDREAD_INT(delay * 30);
1244 cdr.m_locationChanged = FALSE;
1250 Croc 2: $40 - only FORM1 (*)
1251 Judge Dredd: $C8 - only FORM1 (*)
1252 Sim Theme Park - no adpcm at all (zero)
1255 if (!(cdr.Mode & MODE_STRSND) || !(cdr.Transfer[4+2] & 0x4)) {
1256 cdr.Stat = DataReady;
1260 // update for CdlGetlocP
1261 ReadTrack(cdr.SetSectorPlay);
1270 bit 5 - 1 result ready
1272 bit 7 - 1 command being processed
1275 unsigned char cdrRead0(void) {
1276 if (cdr.ResultReady)
1284 // cdr.Ctrl &= ~0x40;
1286 // What means the 0x10 and the 0x08 bits? I only saw it used by the bios
1289 CDR_LOG_IO("cdr r0: %02x\n", cdr.Ctrl);
1291 return psxHu8(0x1800) = cdr.Ctrl;
1294 void cdrWrite0(unsigned char rt) {
1295 CDR_LOG_IO("cdr w0: %02x\n", rt);
1297 cdr.Ctrl = (rt & 3) | (cdr.Ctrl & ~3);
1300 unsigned char cdrRead1(void) {
1301 if ((cdr.ResultP & 0xf) < cdr.ResultC)
1302 psxHu8(0x1801) = cdr.Result[cdr.ResultP & 0xf];
1306 if (cdr.ResultP == cdr.ResultC)
1307 cdr.ResultReady = 0;
1309 CDR_LOG_IO("cdr r1: %02x\n", psxHu8(0x1801));
1311 return psxHu8(0x1801);
1314 void cdrWrite1(unsigned char rt) {
1315 CDR_LOG_IO("cdr w1: %02x\n", rt);
1317 switch (cdr.Ctrl & 3) {
1321 cdr.AttenuatorRightToRightT = rt;
1330 #ifdef CDR_LOG_CMD_IRQ
1331 SysPrintf("CD1 write: %x (%s)", rt, CmdName[rt]);
1333 SysPrintf(" Param[%d] = {", cdr.ParamC);
1334 for (i = 0; i < cdr.ParamC; i++)
1335 SysPrintf(" %x,", cdr.Param[i]);
1342 cdr.ResultReady = 0;
1344 // cdr.Stat = NoIntr;
1345 AddIrqQueue(cdr.Cmd, 0x800);
1357 cdr.Seeked = SEEK_DONE;
1363 CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]);
1365 cdr.Mode = cdr.Param[0];
1367 // Squaresoft on PlayStation 1998 Collector's CD Vol. 1
1368 // - fixes choppy movie sound
1369 if( cdr.Play && (cdr.Mode & MODE_CDDA) == 0 )
1375 unsigned char cdrRead2(void) {
1378 if (cdr.Readed == 0) {
1384 CDR_LOG_IO("cdr r2: %02x\n", ret);
1388 void cdrWrite2(unsigned char rt) {
1389 CDR_LOG_IO("cdr w2: %02x\n", rt);
1391 switch (cdr.Ctrl & 3) {
1393 if (cdr.ParamC < 8) // FIXME: size and wrapping
1394 cdr.Param[cdr.ParamC++] = rt;
1401 cdr.AttenuatorLeftToLeftT = rt;
1404 cdr.AttenuatorRightToLeftT = rt;
1409 unsigned char cdrRead3(void) {
1411 psxHu8(0x1803) = cdr.Stat | 0xE0;
1413 psxHu8(0x1803) = cdr.Reg2 | 0xE0;
1415 CDR_LOG_IO("cdr r3: %02x\n", psxHu8(0x1803));
1416 return psxHu8(0x1803);
1419 void cdrWrite3(unsigned char rt) {
1420 CDR_LOG_IO("cdr w3: %02x\n", rt);
1422 switch (cdr.Ctrl & 3) {
1432 cdr.AttenuatorLeftToRightT = rt;
1436 memcpy(&cdr.AttenuatorLeftToLeft, &cdr.AttenuatorLeftToLeftT, 4);
1437 CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n",
1438 cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
1439 cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight);
1444 if ((rt & 0x80) && cdr.Readed == 0) {
1446 pTransfer = cdr.Transfer;
1448 switch (cdr.Mode & 0x30) {
1449 case MODE_SIZE_2328:
1454 case MODE_SIZE_2340:
1464 void psxDma3(u32 madr, u32 bcr, u32 chcr) {
1469 CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr);
1474 if (cdr.Readed == 0) {
1475 CDR_LOG("psxDma3() Log: *** DMA 3 *** NOT READY\n");
1479 cdsize = (bcr & 0xffff) * 4;
1481 // Ape Escape: bcr = 0001 / 0000
1485 switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {
1486 case MODE_SIZE_2340: cdsize = 2340; break;
1487 case MODE_SIZE_2328: cdsize = 2328; break;
1489 case MODE_SIZE_2048: cdsize = 2048; break;
1494 ptr = (u8 *)PSXM(madr);
1495 if (ptr == INVALID_PTR) {
1496 CDR_LOG("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n");
1501 GS CDX: Enhancement CD crash
1504 - Spams DMA3 and gets buffer overrun
1506 size = CD_FRAMESIZE_RAW - (pTransfer - cdr.Transfer);
1511 memcpy(ptr, pTransfer, size);
1514 psxCpu->Clear(madr, cdsize / 4);
1515 pTransfer += cdsize;
1517 if( chcr == 0x11400100 ) {
1518 HW_DMA3_MADR = SWAPu32(madr + cdsize);
1519 CDRDMA_INT( (cdsize/4) / 4 );
1521 else if( chcr == 0x11000000 ) {
1522 // CDRDMA_INT( (cdsize/4) * 1 );
1524 psxRegs.cycle += (cdsize/4) * 24/2;
1530 CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr);
1534 HW_DMA3_CHCR &= SWAP32(~0x01000000);
1538 void cdrDmaInterrupt()
1540 if (HW_DMA3_CHCR & SWAP32(0x01000000))
1542 HW_DMA3_CHCR &= SWAP32(~0x01000000);
1547 static void getCdInfo(void)
1551 CDR_getTN(cdr.ResultTN);
1552 CDR_getTD(0, cdr.SetSectorEnd);
1553 tmp = cdr.SetSectorEnd[0];
1554 cdr.SetSectorEnd[0] = cdr.SetSectorEnd[2];
1555 cdr.SetSectorEnd[2] = tmp;
1559 memset(&cdr, 0, sizeof(cdr));
1565 cdr.DriveState = DRIVESTATE_STANDBY;
1566 cdr.StatP = STATUS_ROTATING;
1567 pTransfer = cdr.Transfer;
1568 cdr.SetlocPending = 0;
1569 cdr.m_locationChanged = FALSE;
1571 // BIOS player - default values
1572 cdr.AttenuatorLeftToLeft = 0x80;
1573 cdr.AttenuatorLeftToRight = 0x00;
1574 cdr.AttenuatorRightToLeft = 0x00;
1575 cdr.AttenuatorRightToRight = 0x80;
1580 int cdrFreeze(void *f, int Mode) {
1584 if (Mode == 0 && !Config.Cdda)
1587 cdr.freeze_ver = 0x63647202;
1588 gzfreeze(&cdr, sizeof(cdr));
1591 cdr.ParamP = cdr.ParamC;
1592 tmp = pTransfer - cdr.Transfer;
1595 gzfreeze(&tmp, sizeof(tmp));
1600 pTransfer = cdr.Transfer + tmp;
1602 // read right sub data
1603 tmpp[0] = btoi(cdr.Prev[0]);
1604 tmpp[1] = btoi(cdr.Prev[1]);
1605 tmpp[2] = btoi(cdr.Prev[2]);
1610 if (cdr.freeze_ver < 0x63647202)
1611 memcpy(cdr.SetSectorPlay, cdr.SetSector, 3);
1613 Find_CurTrack(cdr.SetSectorPlay);
1618 if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {
1619 // old versions did not latch Reg2, have to fixup..
1620 if (cdr.Reg2 == 0) {
1621 SysPrintf("cdrom: fixing up old savestate\n");
1624 // also did not save Attenuator..
1625 if ((cdr.AttenuatorLeftToLeft | cdr.AttenuatorLeftToRight
1626 | cdr.AttenuatorRightToLeft | cdr.AttenuatorRightToRight) == 0)
1628 cdr.AttenuatorLeftToLeft = cdr.AttenuatorRightToRight = 0x80;
1636 void LidInterrupt() {
1639 cdrLidSeekInterrupt();