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 02111-1307 USA. *
18 ***************************************************************************/
21 * Handles all CD-ROM registers and functions.
30 #define CDR_LOG SysPrintf
35 #define CDR_LOG_I SysPrintf
37 #define CDR_LOG_I(...)
40 #define CDR_LOG_IO SysPrintf
42 #define CDR_LOG_IO(...)
44 //#define CDR_LOG_CMD_IRQ
47 static unsigned char *pTransfer;
49 /* CD-ROM magic numbers */
63 #define CdlSetfilter 13
73 #define CdlSetclock 23
74 #define CdlGetclock 24
81 char *CmdName[0x100]= {
82 "CdlSync", "CdlNop", "CdlSetloc", "CdlPlay",
83 "CdlForward", "CdlBackward", "CdlReadN", "CdlStandby",
84 "CdlStop", "CdlPause", "CdlInit", "CdlMute",
85 "CdlDemute", "CdlSetfilter", "CdlSetmode", "CdlGetmode",
86 "CdlGetlocL", "CdlGetlocP", "CdlReadT", "CdlGetTN",
87 "CdlGetTD", "CdlSeekL", "CdlSeekP", "CdlSetclock",
88 "CdlGetclock", "CdlTest", "CdlID", "CdlReadS",
89 "CdlReset", NULL, "CDlReadToc", NULL
92 unsigned char Test04[] = { 0 };
93 unsigned char Test05[] = { 0 };
94 unsigned char Test20[] = { 0x98, 0x06, 0x10, 0xC3 };
95 unsigned char Test22[] = { 0x66, 0x6F, 0x72, 0x20, 0x45, 0x75, 0x72, 0x6F };
96 unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 };
102 #define Acknowledge 3
107 #define MODE_SPEED (1<<7) // 0x80
108 #define MODE_STRSND (1<<6) // 0x40 ADPCM on/off
109 #define MODE_SIZE_2340 (1<<5) // 0x20
110 #define MODE_SIZE_2328 (1<<4) // 0x10
111 #define MODE_SIZE_2048 (0<<4) // 0x00
112 #define MODE_SF (1<<3) // 0x08 channel on/off
113 #define MODE_REPORT (1<<2) // 0x04
114 #define MODE_AUTOPAUSE (1<<1) // 0x02
115 #define MODE_CDDA (1<<0) // 0x01
118 #define STATUS_PLAY (1<<7) // 0x80
119 #define STATUS_SEEK (1<<6) // 0x40
120 #define STATUS_READ (1<<5) // 0x20
121 #define STATUS_SHELLOPEN (1<<4) // 0x10
122 #define STATUS_UNKNOWN3 (1<<3) // 0x08
123 #define STATUS_UNKNOWN2 (1<<2) // 0x04
124 #define STATUS_ROTATING (1<<1) // 0x02
125 #define STATUS_ERROR (1<<0) // 0x01
128 // 1x = 75 sectors per second
129 // PSXCLK = 1 sec in the ps
130 // so (PSXCLK / 75) = cdr read time (linuzappz)
131 #define cdReadTime (PSXCLK / 75)
134 DRIVESTATE_STANDBY = 0,
136 DRIVESTATE_RESCAN_CD,
137 DRIVESTATE_PREPARE_CD,
146 static struct CdrStat stat;
148 static unsigned int msf2sec(const u8 *msf) {
149 return ((msf[0] * 60 + msf[1]) * 75) + msf[2];
152 // for that weird psemu API..
153 static unsigned int fsm2sec(const u8 *msf) {
154 return ((msf[2] * 60 + msf[1]) * 75) + msf[0];
157 static void sec2msf(unsigned int s, u8 *msf) {
158 msf[0] = s / 75 / 60;
159 s = s - msf[0] * 75 * 60;
166 #define CDR_INT(eCycle) { \
167 psxRegs.interrupt |= (1 << PSXINT_CDR); \
168 psxRegs.intCycle[PSXINT_CDR].cycle = eCycle; \
169 psxRegs.intCycle[PSXINT_CDR].sCycle = psxRegs.cycle; \
170 new_dyna_set_event(PSXINT_CDR, eCycle); \
174 #define CDREAD_INT(eCycle) { \
175 psxRegs.interrupt |= (1 << PSXINT_CDREAD); \
176 psxRegs.intCycle[PSXINT_CDREAD].cycle = eCycle; \
177 psxRegs.intCycle[PSXINT_CDREAD].sCycle = psxRegs.cycle; \
178 new_dyna_set_event(PSXINT_CDREAD, eCycle); \
181 // cdrLidSeekInterrupt
182 #define CDRLID_INT(eCycle) { \
183 psxRegs.interrupt |= (1 << PSXINT_CDRLID); \
184 psxRegs.intCycle[PSXINT_CDRLID].cycle = eCycle; \
185 psxRegs.intCycle[PSXINT_CDRLID].sCycle = psxRegs.cycle; \
186 new_dyna_set_event(PSXINT_CDRLID, eCycle); \
190 #define CDRMISC_INT(eCycle) { \
191 psxRegs.interrupt |= (1 << PSXINT_CDRPLAY); \
192 psxRegs.intCycle[PSXINT_CDRPLAY].cycle = eCycle; \
193 psxRegs.intCycle[PSXINT_CDRPLAY].sCycle = psxRegs.cycle; \
194 new_dyna_set_event(PSXINT_CDRPLAY, eCycle); \
197 #define StopReading() { \
200 psxRegs.interrupt &= ~(1 << PSXINT_CDREAD); \
202 cdr.StatP &= ~STATUS_READ;\
205 #define StopCdda() { \
207 if (!Config.Cdda) CDR_stop(); \
208 cdr.StatP &= ~STATUS_PLAY; \
210 cdr.FastForward = 0; \
211 cdr.FastBackward = 0; \
212 /*SPU_registerCallback( SPUirq );*/ \
216 #define SetResultSize(size) { \
218 cdr.ResultC = size; \
219 cdr.ResultReady = 1; \
222 static void setIrq(void)
224 if (cdr.Stat & cdr.Reg2)
225 psxHu32ref(0x1070) |= SWAP32((u32)0x4);
228 // timing used in this function was taken from tests on real hardware
229 // (yes it's slow, but you probably don't want to modify it)
230 void cdrLidSeekInterrupt()
232 switch (cdr.DriveState) {
234 case DRIVESTATE_STANDBY:
235 cdr.StatP &= ~STATUS_SEEK;
237 if (CDR_getStatus(&stat) == -1)
240 if (stat.Status & STATUS_SHELLOPEN)
243 cdr.DriveState = DRIVESTATE_LID_OPEN;
248 case DRIVESTATE_LID_OPEN:
249 if (CDR_getStatus(&stat) == -1)
250 stat.Status &= ~STATUS_SHELLOPEN;
253 if (!(cdr.StatP & STATUS_SHELLOPEN)) {
255 cdr.StatP |= STATUS_SHELLOPEN;
257 // could generate error irq here, but real hardware
258 // only sometimes does that
259 // (not done when lots of commands are sent?)
261 CDRLID_INT(cdReadTime * 30);
264 else if (cdr.StatP & STATUS_ROTATING) {
265 cdr.StatP &= ~STATUS_ROTATING;
267 else if (!(stat.Status & STATUS_SHELLOPEN)) {
271 // cdr.StatP STATUS_SHELLOPEN is "sticky"
272 // and is only cleared by CdlNop
274 cdr.DriveState = DRIVESTATE_RESCAN_CD;
275 CDRLID_INT(cdReadTime * 105);
280 CDRLID_INT(cdReadTime * 3);
283 case DRIVESTATE_RESCAN_CD:
284 cdr.StatP |= STATUS_ROTATING;
285 cdr.DriveState = DRIVESTATE_PREPARE_CD;
287 // this is very long on real hardware, over 6 seconds
288 // make it a bit faster here...
289 CDRLID_INT(cdReadTime * 150);
292 case DRIVESTATE_PREPARE_CD:
293 cdr.StatP |= STATUS_SEEK;
295 cdr.DriveState = DRIVESTATE_STANDBY;
296 CDRLID_INT(cdReadTime * 26);
301 static void Find_CurTrack(const u8 *time)
305 current = msf2sec(time);
307 for (cdr.CurTrack = 1; cdr.CurTrack < cdr.ResultTN[1]; cdr.CurTrack++) {
308 CDR_getTD(cdr.CurTrack + 1, cdr.ResultTD);
309 sect = fsm2sec(cdr.ResultTD);
310 if (sect - current >= 150)
315 static void generate_subq(const u8 *time)
317 unsigned char start[3], next[3];
318 unsigned int this_s, start_s, next_s, pregap;
321 CDR_getTD(cdr.CurTrack, start);
322 if (cdr.CurTrack + 1 <= cdr.ResultTN[1]) {
324 CDR_getTD(cdr.CurTrack + 1, next);
327 // last track - cd size
329 next[0] = cdr.SetSectorEnd[2];
330 next[1] = cdr.SetSectorEnd[1];
331 next[2] = cdr.SetSectorEnd[0];
334 this_s = msf2sec(time);
335 start_s = fsm2sec(start);
336 next_s = fsm2sec(next);
338 cdr.TrackChanged = FALSE;
340 if (next_s - this_s < pregap) {
341 cdr.TrackChanged = TRUE;
348 relative_s = this_s - start_s;
349 if (relative_s < 0) {
351 relative_s = -relative_s;
353 sec2msf(relative_s, cdr.subq.Relative);
355 cdr.subq.Track = itob(cdr.CurTrack);
356 cdr.subq.Relative[0] = itob(cdr.subq.Relative[0]);
357 cdr.subq.Relative[1] = itob(cdr.subq.Relative[1]);
358 cdr.subq.Relative[2] = itob(cdr.subq.Relative[2]);
359 cdr.subq.Absolute[0] = itob(time[0]);
360 cdr.subq.Absolute[1] = itob(time[1]);
361 cdr.subq.Absolute[2] = itob(time[2]);
364 static void ReadTrack(const u8 *time) {
365 unsigned char tmp[3];
369 tmp[0] = itob(time[0]);
370 tmp[1] = itob(time[1]);
371 tmp[2] = itob(time[2]);
373 if (memcmp(cdr.Prev, tmp, 3) == 0)
376 CDR_LOG("ReadTrack *** %02x:%02x:%02x\n", tmp[0], tmp[1], tmp[2]);
378 cdr.RErr = CDR_readTrack(tmp);
379 memcpy(cdr.Prev, tmp, 3);
384 subq = (struct SubQ *)CDR_getBufferSub();
385 if (subq != NULL && cdr.CurTrack == 1) {
386 crc = calcCrc((u8 *)subq + 12, 10);
387 if (crc == (((u16)subq->CRC[0] << 8) | subq->CRC[1])) {
388 cdr.subq.Track = subq->TrackNumber;
389 cdr.subq.Index = subq->IndexNumber;
390 memcpy(cdr.subq.Relative, subq->TrackRelativeAddress, 3);
391 memcpy(cdr.subq.Absolute, subq->AbsoluteAddress, 3);
394 CDR_LOG_I("subq bad crc @%02x:%02x:%02x\n",
395 tmp[0], tmp[1], tmp[2]);
402 CDR_LOG(" -> %02x,%02x %02x:%02x:%02x %02x:%02x:%02x\n",
403 cdr.subq.Track, cdr.subq.Index,
404 cdr.subq.Relative[0], cdr.subq.Relative[1], cdr.subq.Relative[2],
405 cdr.subq.Absolute[0], cdr.subq.Absolute[1], cdr.subq.Absolute[2]);
408 static void AddIrqQueue(unsigned char irq, unsigned long ecycle) {
410 CDR_LOG_I("cdr: override cmd %02x -> %02x\n", cdr.Irq, irq);
418 static void cdrPlayInterrupt_Autopause()
420 if ((cdr.Mode & MODE_AUTOPAUSE) && cdr.TrackChanged) {
421 CDR_LOG( "CDDA STOP\n" );
423 // Magic the Gathering
424 // - looping territory cdda
427 //cdr.ResultReady = 1;
428 //cdr.Stat = DataReady;
434 else if (cdr.Mode & MODE_REPORT) {
436 cdr.Result[0] = cdr.StatP;
437 cdr.Result[1] = cdr.subq.Track;
438 cdr.Result[2] = cdr.subq.Index;
440 if (cdr.subq.Absolute[2] & 0x10) {
441 cdr.Result[3] = cdr.subq.Relative[0];
442 cdr.Result[4] = cdr.subq.Relative[1] | 0x80;
443 cdr.Result[5] = cdr.subq.Relative[2];
446 cdr.Result[3] = cdr.subq.Absolute[0];
447 cdr.Result[4] = cdr.subq.Absolute[1];
448 cdr.Result[5] = cdr.subq.Absolute[2];
454 // Rayman: Logo freeze (resultready + dataready)
456 cdr.Stat = DataReady;
464 void cdrPlayInterrupt()
466 if (cdr.Seeked == SEEK_PENDING) {
468 CDR_LOG_I("cdrom: seek stat hack\n");
473 cdr.StatP |= STATUS_ROTATING;
474 cdr.StatP &= ~STATUS_SEEK;
475 cdr.Result[0] = cdr.StatP;
476 cdr.Seeked = SEEK_DONE;
482 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
483 Find_CurTrack(cdr.SetSectorPlay);
484 ReadTrack(cdr.SetSectorPlay);
485 cdr.TrackChanged = FALSE;
488 if (!cdr.Play) return;
490 CDR_LOG( "CDDA - %d:%d:%d\n",
491 cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] );
493 if (memcmp(cdr.SetSectorPlay, cdr.SetSectorEnd, 3) == 0) {
495 cdr.TrackChanged = TRUE;
498 if (!cdr.Irq && !cdr.Stat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT)))
499 cdrPlayInterrupt_Autopause();
501 if (!cdr.Play) return;
503 cdr.SetSectorPlay[2]++;
504 if (cdr.SetSectorPlay[2] == 75) {
505 cdr.SetSectorPlay[2] = 0;
506 cdr.SetSectorPlay[1]++;
507 if (cdr.SetSectorPlay[1] == 60) {
508 cdr.SetSectorPlay[1] = 0;
509 cdr.SetSectorPlay[0]++;
513 CDRMISC_INT(cdReadTime);
515 // update for CdlGetlocP/autopause
516 generate_subq(cdr.SetSectorPlay);
519 void cdrInterrupt() {
521 unsigned char Irq = cdr.Irq;
525 CDR_LOG_I("cdrom: stat hack: %02x %x\n", cdr.Irq, cdr.Stat);
536 cdr.StatP |= STATUS_ROTATING;
537 cdr.Result[0] = cdr.StatP;
538 cdr.Stat = Acknowledge;
543 cdr.Result[0] = cdr.StatP;
544 cdr.Stat = Acknowledge;
546 if (cdr.DriveState != DRIVESTATE_LID_OPEN)
547 cdr.StatP &= ~STATUS_SHELLOPEN;
553 cdr.StatP |= STATUS_ROTATING;
554 cdr.Result[0] = cdr.StatP;
555 cdr.Stat = Acknowledge;
559 if (cdr.Seeked == SEEK_PENDING) {
560 // XXX: wrong, should seek instead..
561 memcpy( cdr.SetSectorPlay, cdr.SetSector, 4 );
562 cdr.Seeked = SEEK_DONE;
566 // - Pause player, hit Track 01/02/../xx (Setloc issued!!)
568 if (cdr.ParamC == 0 || cdr.Param[0] == 0) {
569 CDR_LOG("PLAY Resume @ %d:%d:%d\n",
570 cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]);
574 int track = btoi( cdr.Param[0] );
576 if (track <= cdr.ResultTN[1])
577 cdr.CurTrack = track;
579 CDR_LOG("PLAY track %d\n", cdr.CurTrack);
581 if (CDR_getTD((u8)cdr.CurTrack, cdr.ResultTD) != -1) {
582 cdr.SetSectorPlay[0] = cdr.ResultTD[2];
583 cdr.SetSectorPlay[1] = cdr.ResultTD[1];
584 cdr.SetSectorPlay[2] = cdr.ResultTD[0];
589 Rayman: detect track changes
592 Twisted Metal 2: skip PREGAP + starting accurate SubQ
593 - plays tracks without retry play
595 Wild 9: skip PREGAP + starting accurate SubQ
596 - plays tracks without retry play
598 Find_CurTrack(cdr.SetSectorPlay);
599 ReadTrack(cdr.SetSectorPlay);
600 cdr.TrackChanged = FALSE;
603 CDR_play(cdr.SetSectorPlay);
605 // Vib Ribbon: gameplay checks flag
606 cdr.StatP &= ~STATUS_SEEK;
610 cdr.StatP |= STATUS_ROTATING;
611 cdr.Result[0] = cdr.StatP;
612 cdr.Stat = Acknowledge;
614 cdr.StatP |= STATUS_PLAY;
617 // BIOS player - set flag again
620 CDRMISC_INT( cdReadTime );
626 cdr.StatP |= STATUS_ROTATING;
627 cdr.Result[0] = cdr.StatP;
631 // GameShark CD Player: Calls 2x + Play 2x
632 if( cdr.FastForward == 0 ) cdr.FastForward = 2;
633 else cdr.FastForward++;
635 cdr.FastBackward = 0;
641 cdr.StatP |= STATUS_ROTATING;
642 cdr.Result[0] = cdr.StatP;
646 // GameShark CD Player: Calls 2x + Play 2x
647 if( cdr.FastBackward == 0 ) cdr.FastBackward = 2;
648 else cdr.FastBackward++;
656 cdr.StatP |= STATUS_ROTATING;
657 cdr.Result[0] = cdr.StatP;
664 cdr.StatP &= ~STATUS_ROTATING;
665 cdr.Result[0] = cdr.StatP;
667 // cdr.Stat = Acknowledge;
672 cdr.Result[0] = cdr.StatP;
673 cdr.Stat = Acknowledge;
676 Gundam Battle Assault 2: much slower (*)
677 - Fixes boot, gameplay
679 Hokuto no Ken 2: slower
680 - Fixes intro + subtitles
682 InuYasha - Feudal Fairy Tale: slower
685 AddIrqQueue(CdlPause + 0x20, cdReadTime * 3);
689 case CdlPause + 0x20:
691 cdr.StatP &= ~STATUS_READ;
692 cdr.StatP |= STATUS_ROTATING;
693 cdr.Result[0] = cdr.StatP;
699 cdr.StatP = STATUS_ROTATING;
700 cdr.Result[0] = cdr.StatP;
701 cdr.Stat = Acknowledge;
703 AddIrqQueue(CdlInit + 0x20, 0x800);
709 cdr.Result[0] = cdr.StatP;
716 cdr.StatP |= STATUS_ROTATING;
717 cdr.Result[0] = cdr.StatP;
718 cdr.Stat = Acknowledge;
723 cdr.StatP |= STATUS_ROTATING;
724 cdr.Result[0] = cdr.StatP;
725 cdr.Stat = Acknowledge;
730 cdr.StatP |= STATUS_ROTATING;
731 cdr.Result[0] = cdr.StatP;
732 cdr.Stat = Acknowledge;
737 cdr.StatP |= STATUS_ROTATING;
738 cdr.Result[0] = cdr.StatP;
739 cdr.Stat = Acknowledge;
744 cdr.StatP |= STATUS_ROTATING;
745 cdr.Result[0] = cdr.StatP;
746 cdr.Result[1] = cdr.Mode;
747 cdr.Result[2] = cdr.File;
748 cdr.Result[3] = cdr.Channel;
751 cdr.Stat = Acknowledge;
756 for (i = 0; i < 8; i++)
757 cdr.Result[i] = cdr.Transfer[i];
758 cdr.Stat = Acknowledge;
763 memcpy(&cdr.Result, &cdr.subq, 8);
765 if (!cdr.Play && !cdr.Reading)
766 cdr.Result[1] = 0; // HACK?
768 cdr.Stat = Acknowledge;
774 cdr.StatP |= STATUS_ROTATING;
775 cdr.Result[0] = cdr.StatP;
776 if (CDR_getTN(cdr.ResultTN) == -1) {
777 cdr.Stat = DiskError;
778 cdr.Result[0] |= STATUS_ERROR;
780 cdr.Stat = Acknowledge;
781 cdr.Result[1] = itob(cdr.ResultTN[0]);
782 cdr.Result[2] = itob(cdr.ResultTN[1]);
788 cdr.Track = btoi(cdr.Param[0]);
790 cdr.StatP |= STATUS_ROTATING;
791 if (CDR_getTD(cdr.Track, cdr.ResultTD) == -1) {
792 cdr.Stat = DiskError;
793 cdr.Result[0] |= STATUS_ERROR;
795 cdr.Stat = Acknowledge;
796 cdr.Result[0] = cdr.StatP;
797 cdr.Result[1] = itob(cdr.ResultTD[2]);
798 cdr.Result[2] = itob(cdr.ResultTD[1]);
799 cdr.Result[3] = itob(cdr.ResultTD[0]);
806 cdr.StatP |= STATUS_ROTATING;
807 cdr.Result[0] = cdr.StatP;
808 cdr.StatP |= STATUS_SEEK;
809 cdr.Stat = Acknowledge;
812 Crusaders of Might and Magic = 0.5x-4x
813 - fix cutscene speech start
819 - fix cutscene speech
824 CDRMISC_INT(cdr.Seeked == SEEK_DONE ? 0x800 : cdReadTime * 4);
825 cdr.Seeked = SEEK_PENDING;
829 cdr.Stat = Acknowledge;
830 switch (cdr.Param[0]) {
831 case 0x20: // System Controller ROM Version
833 memcpy(cdr.Result, Test20, 4);
837 memcpy(cdr.Result, Test22, 4);
839 case 0x23: case 0x24:
841 memcpy(cdr.Result, Test23, 4);
848 cdr.StatP |= STATUS_ROTATING;
849 cdr.Result[0] = cdr.StatP;
850 cdr.Stat = Acknowledge;
851 AddIrqQueue(CdlID + 0x20, 0x800);
856 cdr.Result[0] = cdr.StatP;
861 // 0x10 - audio | 0x40 - disk missing | 0x80 - unlicensed
862 if (CDR_getStatus(&stat) == -1 || stat.Type == 0 || stat.Type == 0xff) {
863 cdr.Result[1] = 0xc0;
867 cdr.Result[1] |= 0x10;
868 if (CdromId[0] == '\0')
869 cdr.Result[1] |= 0x80;
871 cdr.Result[0] |= (cdr.Result[1] >> 4) & 0x08;
873 strncpy((char *)&cdr.Result[4], "PCSX", 4);
879 cdr.StatP = STATUS_ROTATING;
880 cdr.Result[0] = cdr.StatP;
881 cdr.Stat = Acknowledge;
886 cdr.StatP |= STATUS_ROTATING;
887 cdr.Result[0] = cdr.StatP;
888 cdr.Stat = Acknowledge;
889 AddIrqQueue(CdlReadT + 0x20, 0x800);
892 case CdlReadT + 0x20:
894 cdr.StatP |= STATUS_ROTATING;
895 cdr.Result[0] = cdr.StatP;
901 cdr.StatP |= STATUS_ROTATING;
902 cdr.Result[0] = cdr.StatP;
903 cdr.Stat = Acknowledge;
904 AddIrqQueue(CdlReadToc + 0x20, cdReadTime * 16);
907 case CdlReadToc + 0x20:
909 cdr.StatP |= STATUS_ROTATING;
910 cdr.Result[0] = cdr.StatP;
916 if (!cdr.Reading) return;
918 // Fighting Force 2 - update subq time immediately
920 Find_CurTrack(cdr.SetSector);
921 ReadTrack(cdr.SetSector);
924 // Crusaders of Might and Magic - update getlocl now
925 // - fixes cutscene speech
927 u8 *buf = CDR_getBuffer();
929 memcpy(cdr.Transfer, buf, 8);
933 Duke Nukem: Land of the Babes - seek then delay read for one frame
935 C-12 - Final Resistance - doesn't like seek
938 if (cdr.Seeked != SEEK_DONE) {
939 cdr.StatP |= STATUS_SEEK;
940 cdr.StatP &= ~STATUS_READ;
942 // Crusaders of Might and Magic - use short time
943 // - fix cutscene speech (startup)
945 // ??? - use more accurate seek time later
946 CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1);
948 cdr.StatP |= STATUS_READ;
949 cdr.StatP &= ~STATUS_SEEK;
951 CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1);
955 cdr.StatP |= STATUS_ROTATING;
956 cdr.Result[0] = cdr.StatP;
957 cdr.Stat = Acknowledge;
966 switch (cdr.DriveState) {
967 case DRIVESTATE_LID_OPEN:
968 case DRIVESTATE_RESCAN_CD:
969 case DRIVESTATE_PREPARE_CD:
971 cdr.Result[0] = cdr.StatP | STATUS_ERROR;
972 cdr.Result[1] = 0x80;
973 cdr.Stat = DiskError;
982 #ifdef CDR_LOG_CMD_IRQ
983 SysPrintf("IRQ %d cmd %02x stat %02x: ",
984 !!(cdr.Stat & cdr.Reg2), Irq, cdr.Stat);
985 for (i = 0; i < cdr.ResultC; i++)
986 SysPrintf("%02x ", cdr.Result[i]);
991 #ifdef __ARM_ARCH_7A__
992 #define ssat32_to_16(v) \
993 asm("ssat %0,#16,%1" : "=r" (v) : "r" (v))
995 #define ssat32_to_16(v) do { \
996 if (v < -32768) v = -32768; \
997 else if (v > 32767) v = 32767; \
1001 void cdrAttenuate(s16 *buf, int samples, int stereo)
1004 int ll = cdr.AttenuatorLeftToLeft;
1005 int lr = cdr.AttenuatorLeftToRight;
1006 int rl = cdr.AttenuatorRightToLeft;
1007 int rr = cdr.AttenuatorRightToRight;
1009 if (lr == 0 && rl == 0 && 0x78 <= ll && ll <= 0x88 && 0x78 <= rr && rr <= 0x88)
1012 if (!stereo && ll == 0x40 && lr == 0x40 && rl == 0x40 && rr == 0x40)
1016 for (i = 0; i < samples; i++) {
1019 l = (l * ll + r * rl) >> 7;
1020 r = (r * rr + l * lr) >> 7;
1028 for (i = 0; i < samples; i++) {
1030 l = l * (ll + rl) >> 7;
1031 //r = r * (rr + lr) >> 7;
1039 void cdrReadInterrupt() {
1045 if (cdr.Irq || cdr.Stat) {
1046 CDR_LOG_I("cdrom: read stat hack %02x %x\n", cdr.Irq, cdr.Stat);
1053 cdr.StatP |= STATUS_READ|STATUS_ROTATING;
1054 cdr.StatP &= ~STATUS_SEEK;
1055 cdr.Result[0] = cdr.StatP;
1056 cdr.Seeked = SEEK_DONE;
1058 ReadTrack(cdr.SetSector);
1060 buf = CDR_getBuffer();
1064 if (cdr.RErr == -1) {
1065 CDR_LOG_I("cdrReadInterrupt() Log: err\n");
1066 memset(cdr.Transfer, 0, DATA_SIZE);
1067 cdr.Stat = DiskError;
1068 cdr.Result[0] |= STATUS_ERROR;
1069 CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime);
1073 memcpy(cdr.Transfer, buf, DATA_SIZE);
1074 CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]);
1077 CDR_LOG("cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]);
1079 if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA
1080 // Firemen 2: Multi-XA files - briefings, cutscenes
1081 if( cdr.FirstSector == 1 && (cdr.Mode & MODE_SF)==0 ) {
1082 cdr.File = cdr.Transfer[4 + 0];
1083 cdr.Channel = cdr.Transfer[4 + 1];
1086 if((cdr.Transfer[4 + 2] & 0x4) &&
1087 (cdr.Transfer[4 + 1] == cdr.Channel) &&
1088 (cdr.Transfer[4 + 0] == cdr.File)) {
1089 int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector);
1091 cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo);
1092 SPU_playADPCMchannel(&cdr.Xa);
1093 cdr.FirstSector = 0;
1095 else cdr.FirstSector = -1;
1100 if (cdr.SetSector[2] == 75) {
1101 cdr.SetSector[2] = 0;
1103 if (cdr.SetSector[1] == 60) {
1104 cdr.SetSector[1] = 0;
1111 CDREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime);
1114 Croc 2: $40 - only FORM1 (*)
1115 Judge Dredd: $C8 - only FORM1 (*)
1116 Sim Theme Park - no adpcm at all (zero)
1119 if (!(cdr.Mode & MODE_STRSND) || !(cdr.Transfer[4+2] & 0x4)) {
1120 cdr.Stat = DataReady;
1124 // update for CdlGetlocP
1125 ReadTrack(cdr.SetSector);
1134 bit 5 - 1 result ready
1136 bit 7 - 1 command being processed
1139 unsigned char cdrRead0(void) {
1140 if (cdr.ResultReady)
1148 // cdr.Ctrl &= ~0x40;
1150 // What means the 0x10 and the 0x08 bits? I only saw it used by the bios
1153 CDR_LOG_IO("cdr r0: %02x\n", cdr.Ctrl);
1155 return psxHu8(0x1800) = cdr.Ctrl;
1158 void cdrWrite0(unsigned char rt) {
1159 CDR_LOG_IO("cdr w0: %02x\n", rt);
1161 cdr.Ctrl = (rt & 3) | (cdr.Ctrl & ~3);
1164 unsigned char cdrRead1(void) {
1165 if ((cdr.ResultP & 0xf) < cdr.ResultC)
1166 psxHu8(0x1801) = cdr.Result[cdr.ResultP & 0xf];
1170 if (cdr.ResultP == cdr.ResultC)
1171 cdr.ResultReady = 0;
1173 CDR_LOG_IO("cdr r1: %02x\n", psxHu8(0x1801));
1175 return psxHu8(0x1801);
1178 void cdrWrite1(unsigned char rt) {
1182 CDR_LOG_IO("cdr w1: %02x\n", rt);
1184 switch (cdr.Ctrl & 3) {
1188 cdr.AttenuatorRightToRightT = rt;
1197 #ifdef CDR_LOG_CMD_IRQ
1198 SysPrintf("CD1 write: %x (%s)", rt, CmdName[rt]);
1200 SysPrintf(" Param[%d] = {", cdr.ParamC);
1201 for (i = 0; i < cdr.ParamC; i++)
1202 SysPrintf(" %x,", cdr.Param[i]);
1209 cdr.ResultReady = 0;
1211 // cdr.Stat = NoIntr;
1212 AddIrqQueue(cdr.Cmd, 0x800);
1231 for (i = 0; i < 3; i++)
1232 set_loc[i] = btoi(cdr.Param[i]);
1234 // FIXME: clean up this SetSector/SetSectorPlay mess,
1235 // there should be single var tracking current sector pos
1237 i = msf2sec(cdr.SetSectorPlay);
1239 i = msf2sec(cdr.SetSector);
1240 i = abs(i - msf2sec(set_loc));
1242 cdr.Seeked = SEEK_PENDING;
1244 memcpy(cdr.SetSector, set_loc, 3);
1245 cdr.SetSector[3] = 0;
1249 // Vib Ribbon: try same track again
1252 // Vib Ribbon - decoded buffer IRQ for CDDA reading
1253 // - fixes ribbon timing + music CD mode
1254 //CDRDBUF_INT( PSXCLK / 44100 * 0x100 );
1258 cdr.StatP |= STATUS_SEEK;
1259 cdr.StatP &= ~STATUS_ROTATING;
1265 cdr.FirstSector = 1;
1275 // GameShark CD Player: Reset CDDA to track start
1277 // grab time for current track
1278 CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD);
1280 cdr.SetSectorPlay[0] = cdr.ResultTD[2];
1281 cdr.SetSectorPlay[1] = cdr.ResultTD[1];
1282 cdr.SetSectorPlay[2] = cdr.ResultTD[0];
1291 GameShark CD Player: save time for resume
1293 Twisted Metal - World Tour: don't mix Setloc / CdlPlay cursors
1302 cdr.Seeked = SEEK_DONE;
1309 // Duke Nukem - Time to Kill
1310 // - do not directly set cd-xa volume
1311 //SPU_writeRegister( H_CDLeft, 0x0000 );
1312 //SPU_writeRegister( H_CDRight, 0x0000 );
1318 // Duke Nukem - Time to Kill
1319 // - do not directly set cd-xa volume
1320 //SPU_writeRegister( H_CDLeft, 0x7f00 );
1321 //SPU_writeRegister( H_CDRight, 0x7f00 );
1325 cdr.File = cdr.Param[0];
1326 cdr.Channel = cdr.Param[1];
1330 CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]);
1332 cdr.Mode = cdr.Param[0];
1334 // Squaresoft on PlayStation 1998 Collector's CD Vol. 1
1335 // - fixes choppy movie sound
1336 if( cdr.Play && (cdr.Mode & MODE_CDDA) == 0 )
1341 //AddIrqQueue(cdr.Cmd, 0x800);
1343 // GameShark CDX CD Player: very long time
1344 AddIrqQueue(cdr.Cmd, 0x100000);
1349 // Tomb Raider 2 - reset cdda
1357 cdr.FirstSector = 1;
1363 CDR_LOG_I("cdrWrite1() Log: Unknown command: %x\n", cdr.Cmd);
1368 unsigned char cdrRead2(void) {
1371 if (cdr.Readed == 0) {
1377 CDR_LOG_IO("cdr r2: %02x\n", ret);
1381 void cdrWrite2(unsigned char rt) {
1382 CDR_LOG_IO("cdr w2: %02x\n", rt);
1384 switch (cdr.Ctrl & 3) {
1386 if (cdr.ParamC < 8) // FIXME: size and wrapping
1387 cdr.Param[cdr.ParamC++] = rt;
1394 cdr.AttenuatorLeftToLeftT = rt;
1397 cdr.AttenuatorRightToLeftT = rt;
1402 unsigned char cdrRead3(void) {
1404 psxHu8(0x1803) = cdr.Stat | 0xE0;
1406 psxHu8(0x1803) = cdr.Reg2 | 0xE0;
1408 CDR_LOG_IO("cdr r3: %02x\n", psxHu8(0x1803));
1409 return psxHu8(0x1803);
1412 void cdrWrite3(unsigned char rt) {
1413 CDR_LOG_IO("cdr w3: %02x\n", rt);
1415 switch (cdr.Ctrl & 3) {
1425 cdr.AttenuatorLeftToRightT = rt;
1429 memcpy(&cdr.AttenuatorLeftToLeft, &cdr.AttenuatorLeftToLeftT, 4);
1430 CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n",
1431 cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
1432 cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight);
1437 if ((rt & 0x80) && cdr.Readed == 0) {
1439 pTransfer = cdr.Transfer;
1441 switch (cdr.Mode & 0x30) {
1442 case MODE_SIZE_2328:
1447 case MODE_SIZE_2340:
1457 void psxDma3(u32 madr, u32 bcr, u32 chcr) {
1462 CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr);
1467 if (cdr.Readed == 0) {
1468 CDR_LOG("psxDma3() Log: *** DMA 3 *** NOT READY\n");
1472 cdsize = (bcr & 0xffff) * 4;
1474 // Ape Escape: bcr = 0001 / 0000
1478 switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {
1479 case MODE_SIZE_2340: cdsize = 2340; break;
1480 case MODE_SIZE_2328: cdsize = 2328; break;
1482 case MODE_SIZE_2048: cdsize = 2048; break;
1487 ptr = (u8 *)PSXM(madr);
1489 CDR_LOG("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n");
1494 GS CDX: Enhancement CD crash
1497 - Spams DMA3 and gets buffer overrun
1499 size = CD_FRAMESIZE_RAW - (pTransfer - cdr.Transfer);
1504 memcpy(ptr, pTransfer, size);
1507 psxCpu->Clear(madr, cdsize / 4);
1508 pTransfer += cdsize;
1512 if( chcr == 0x11400100 ) {
1513 CDRDMA_INT( (cdsize/4) / 4 );
1515 else if( chcr == 0x11000000 ) {
1516 CDRDMA_INT( (cdsize/4) * 1 );
1521 CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr);
1525 HW_DMA3_CHCR &= SWAP32(~0x01000000);
1529 void cdrDmaInterrupt()
1531 if (HW_DMA3_CHCR & SWAP32(0x01000000))
1533 HW_DMA3_CHCR &= SWAP32(~0x01000000);
1538 static void getCdInfo(void)
1542 CDR_getTN(cdr.ResultTN);
1543 CDR_getTD(0, cdr.SetSectorEnd);
1544 tmp = cdr.SetSectorEnd[0];
1545 cdr.SetSectorEnd[0] = cdr.SetSectorEnd[2];
1546 cdr.SetSectorEnd[2] = tmp;
1550 memset(&cdr, 0, sizeof(cdr));
1556 cdr.DriveState = DRIVESTATE_STANDBY;
1557 pTransfer = cdr.Transfer;
1559 // BIOS player - default values
1560 cdr.AttenuatorLeftToLeft = 0x80;
1561 cdr.AttenuatorLeftToRight = 0x00;
1562 cdr.AttenuatorRightToLeft = 0x00;
1563 cdr.AttenuatorRightToRight = 0x80;
1568 int cdrFreeze(void *f, int Mode) {
1572 if (Mode == 0 && !Config.Cdda)
1575 cdr.freeze_ver = 0x63647201;
1576 gzfreeze(&cdr, sizeof(cdr));
1579 cdr.ParamP = cdr.ParamC;
1580 tmp = pTransfer - cdr.Transfer;
1583 gzfreeze(&tmp, sizeof(tmp));
1588 pTransfer = cdr.Transfer + tmp;
1590 // read right sub data
1591 memcpy(tmpp, cdr.Prev, 3);
1596 Find_CurTrack(cdr.SetSectorPlay);
1598 CDR_play(cdr.SetSectorPlay);
1601 if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {
1602 // old versions did not latch Reg2, have to fixup..
1603 if (cdr.Reg2 == 0) {
1604 SysPrintf("cdrom: fixing up old savestate\n");
1613 void LidInterrupt() {
1616 cdrLidSeekInterrupt();