X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=libpcsxcore%2Fcdrom.c;h=e01d7debd1e4b43f09a2510b13e423badb8f8b6b;hb=8aeb66dcc917d0271e4574799b1793da7f3426c4;hp=034e6577e16d7ec8752f5df419d6a657ef932cad;hpb=968795e31448884c2e46b5f4518a4cbe8ba7dac2;p=pcsx_rearmed.git diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c index 034e6577..e01d7deb 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 @@ -34,7 +35,7 @@ #if 0 #define CDR_LOG_I SysPrintf #else -#define CDR_LOG_I(...) +#define CDR_LOG_I log_unhandled #endif #if 0 #define CDR_LOG_IO SysPrintf @@ -43,11 +44,81 @@ #endif //#define CDR_LOG_CMD_IRQ -cdrStruct cdr; -static unsigned char *pTransfer; +static struct { + // unused members maintain savesate compatibility + unsigned char unused0; + unsigned char unused1; + unsigned char Reg2; + unsigned char unused2; + unsigned char Ctrl; + unsigned char Stat; + + unsigned char StatP; + + unsigned char Transfer[DATA_SIZE]; + struct { + unsigned char Track; + unsigned char Index; + unsigned char Relative[3]; + unsigned char Absolute[3]; + } subq; + unsigned char TrackChanged; + unsigned char unused3[3]; + unsigned int freeze_ver; + + unsigned char Prev[4]; + unsigned char Param[8]; + unsigned char Result[16]; + + unsigned char ParamC; + unsigned char ParamP; + unsigned char ResultC; + unsigned char ResultP; + unsigned char ResultReady; + unsigned char Cmd; + unsigned char unused4; + unsigned char SetlocPending; + u32 Reading; + + unsigned char ResultTN[6]; + unsigned char ResultTD[4]; + unsigned char SetSectorPlay[4]; + unsigned char SetSectorEnd[4]; + unsigned char SetSector[4]; + unsigned char Track; + boolean Play, Muted; + int CurTrack; + int Mode, File, Channel; + int Reset; + int NoErr; + int FirstSector; + + xa_decode_t Xa; + + u16 FifoOffset; + u16 FifoSize; + + u16 CmdInProgress; + u8 Irq1Pending; + u8 unused5; + u32 unused6; + + u8 unused7; + + u8 DriveState; + u8 FastForward; + u8 FastBackward; + u8 unused8; + + u8 AttenuatorLeftToLeft, AttenuatorLeftToRight; + u8 AttenuatorRightToRight, AttenuatorRightToLeft; + u8 AttenuatorLeftToLeftT, AttenuatorLeftToRightT; + u8 AttenuatorRightToRightT, AttenuatorRightToLeftT; +} cdr; +static s16 read_buf[CD_FRAMESIZE_RAW/2]; /* CD-ROM magic numbers */ -#define CdlSync 0 +#define CdlSync 0 /* nocash documentation : "Uh, actually, returns error code 40h = Invalid Command...?" */ #define CdlNop 1 #define CdlSetloc 2 #define CdlPlay 3 @@ -57,12 +128,12 @@ static unsigned char *pTransfer; #define CdlStandby 7 #define CdlStop 8 #define CdlPause 9 -#define CdlInit 10 +#define CdlReset 10 #define CdlMute 11 #define CdlDemute 12 #define CdlSetfilter 13 #define CdlSetmode 14 -#define CdlGetmode 15 +#define CdlGetparam 15 #define CdlGetlocL 16 #define CdlGetlocP 17 #define CdlReadT 18 @@ -75,19 +146,22 @@ static unsigned char *pTransfer; #define CdlTest 25 #define CdlID 26 #define CdlReadS 27 -#define CdlReset 28 +#define CdlInit 28 +#define CdlGetQ 29 #define CdlReadToc 30 -char *CmdName[0x100]= { +#ifdef CDR_LOG_CMD_IRQ +static const char * const CmdName[0x100] = { "CdlSync", "CdlNop", "CdlSetloc", "CdlPlay", "CdlForward", "CdlBackward", "CdlReadN", "CdlStandby", - "CdlStop", "CdlPause", "CdlInit", "CdlMute", - "CdlDemute", "CdlSetfilter", "CdlSetmode", "CdlGetmode", + "CdlStop", "CdlPause", "CdlReset", "CdlMute", + "CdlDemute", "CdlSetfilter", "CdlSetmode", "CdlGetparam", "CdlGetlocL", "CdlGetlocP", "CdlReadT", "CdlGetTN", "CdlGetTD", "CdlSeekL", "CdlSeekP", "CdlSetclock", "CdlGetclock", "CdlTest", "CdlID", "CdlReadS", - "CdlReset", NULL, "CDlReadToc", NULL + "CdlInit", NULL, "CDlReadToc", NULL }; +#endif unsigned char Test04[] = { 0 }; unsigned char Test05[] = { 0 }; @@ -124,16 +198,22 @@ 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 // so (PSXCLK / 75) = cdr read time (linuzappz) #define cdReadTime (PSXCLK / 75) -// for cdr.Seeked -enum seeked_state { - SEEK_PENDING = 0, - SEEK_DONE = 1, +enum drive_state { + DRIVESTATE_STANDBY = 0, // pause, play, read + DRIVESTATE_LID_OPEN, + DRIVESTATE_RESCAN_CD, + DRIVESTATE_PREPARE_CD, + DRIVESTATE_STOPPED, }; static struct CdrStat stat; @@ -163,12 +243,16 @@ static void sec2msf(unsigned int s, u8 *msf) { new_dyna_set_event(PSXINT_CDR, eCycle); \ } -// cdrReadInterrupt -#define CDREAD_INT(eCycle) { \ +// cdrPlaySeekReadInterrupt +#define CDRPLAYSEEKREAD_INT(eCycle, isFirst) { \ + u32 e_ = eCycle; \ psxRegs.interrupt |= (1 << PSXINT_CDREAD); \ - psxRegs.intCycle[PSXINT_CDREAD].cycle = eCycle; \ - psxRegs.intCycle[PSXINT_CDREAD].sCycle = psxRegs.cycle; \ - new_dyna_set_event(PSXINT_CDREAD, eCycle); \ + if (isFirst) \ + psxRegs.intCycle[PSXINT_CDREAD].sCycle = psxRegs.cycle; \ + else \ + psxRegs.intCycle[PSXINT_CDREAD].sCycle += psxRegs.intCycle[PSXINT_CDREAD].cycle; \ + psxRegs.intCycle[PSXINT_CDREAD].cycle = e_; \ + new_dyna_set_event_abs(PSXINT_CDREAD, psxRegs.intCycle[PSXINT_CDREAD].sCycle + e_); \ } // cdrLidSeekInterrupt @@ -179,31 +263,21 @@ static void sec2msf(unsigned int s, u8 *msf) { new_dyna_set_event(PSXINT_CDRLID, eCycle); \ } -// cdrPlayInterrupt -#define CDRMISC_INT(eCycle) { \ - psxRegs.interrupt |= (1 << PSXINT_CDRPLAY); \ - psxRegs.intCycle[PSXINT_CDRPLAY].cycle = eCycle; \ - psxRegs.intCycle[PSXINT_CDRPLAY].sCycle = psxRegs.cycle; \ - new_dyna_set_event(PSXINT_CDRPLAY, eCycle); \ -} - #define StopReading() { \ - if (cdr.Reading) { \ - cdr.Reading = 0; \ - psxRegs.interrupt &= ~(1 << PSXINT_CDREAD); \ - } \ - cdr.StatP &= ~STATUS_READ;\ + cdr.Reading = 0; \ + psxRegs.interrupt &= ~(1 << PSXINT_CDREAD); \ } #define StopCdda() { \ - if (cdr.Play) { \ - if (!Config.Cdda) CDR_stop(); \ - cdr.StatP &= ~STATUS_PLAY; \ - cdr.Play = FALSE; \ - cdr.FastForward = 0; \ - cdr.FastBackward = 0; \ - /*SPU_registerCallback( SPUirq );*/ \ - } \ + if (cdr.Play && !Config.Cdda) CDR_stop(); \ + cdr.Play = FALSE; \ + cdr.FastForward = 0; \ + cdr.FastBackward = 0; \ +} + +#define SetPlaySeekRead(x, f) { \ + x &= ~(STATUS_PLAY | STATUS_SEEK | STATUS_READ); \ + x |= f; \ } #define SetResultSize(size) { \ @@ -212,171 +286,94 @@ static void sec2msf(unsigned int s, u8 *msf) { cdr.ResultReady = 1; \ } -static void setIrq(void) +static void setIrq(int log_cmd) { if (cdr.Stat & cdr.Reg2) psxHu32ref(0x1070) |= SWAP32((u32)0x4); -} - -void cdrLidSeekInterrupt() -{ - // turn back on checking - if( cdr.LidCheck == 0x10 ) - { - cdr.LidCheck = 0; - } - // official lid close - else if( cdr.LidCheck == 0x30 ) - { - // GS CDX 3.3: $13 - cdr.StatP |= STATUS_ROTATING; - - - // GS CDX 3.3 - ~50 getlocp tries - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x40; - } - - // turn off ready - else if( cdr.LidCheck == 0x40 ) - { - // GS CDX 3.3: $01 - cdr.StatP &= ~STATUS_SHELLOPEN; - cdr.StatP &= ~STATUS_ROTATING; - - - // GS CDX 3.3 - ~50 getlocp tries - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x50; - } - - // now seek - else if( cdr.LidCheck == 0x50 ) - { - // GameShark Lite: Start seeking ($42) - cdr.StatP |= STATUS_SEEK; - cdr.StatP |= STATUS_ROTATING; - cdr.StatP &= ~STATUS_ERROR; - - - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x60; - } - - // done = cd ready - else if( cdr.LidCheck == 0x60 ) +#ifdef CDR_LOG_CMD_IRQ + if (cdr.Stat) { - // GameShark Lite: Seek detection done ($02) - cdr.StatP &= ~STATUS_SEEK; - - cdr.LidCheck = 0; + int i; + SysPrintf("%u cdrom: CDR IRQ=%d cmd %02x stat %02x: ", + psxRegs.cycle, !!(cdr.Stat & cdr.Reg2), log_cmd, cdr.Stat); + for (i = 0; i < cdr.ResultC; i++) + SysPrintf("%02x ", cdr.Result[i]); + SysPrintf("\n"); } +#endif } -static void Check_Shell( int Irq ) +// timing used in this function was taken from tests on real hardware +// (yes it's slow, but you probably don't want to modify it) +void cdrLidSeekInterrupt(void) { - // check case open/close - if (cdr.LidCheck > 0) - { - CDR_LOG( "LidCheck\n" ); - - // $20 = check lid state - if( cdr.LidCheck == 0x20 ) - { - u32 i; - - i = stat.Status; - if (CDR_getStatus(&stat) != -1) - { - // BIOS hangs + BIOS error messages - //if (stat.Type == 0xff) - //cdr.Stat = DiskError; - - // case now open - if (stat.Status & STATUS_SHELLOPEN) - { - // Vib Ribbon: pre-CD swap - StopCdda(); - - - // GameShark Lite: Death if DiskError happens - // - // Vib Ribbon: Needs DiskError for CD swap - - if (Irq != CdlNop) - { - cdr.Stat = DiskError; - - cdr.StatP |= STATUS_ERROR; - cdr.Result[0] |= STATUS_ERROR; - } - - // GameShark Lite: Wants -exactly- $10 - cdr.StatP |= STATUS_SHELLOPEN; - cdr.StatP &= ~STATUS_ROTATING; - - - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x10; - - - // GS CDX 3.3 = $11 - } - - // case just closed - else if ( i & STATUS_SHELLOPEN ) - { - cdr.StatP |= STATUS_ROTATING; - - CheckCdrom(); - + switch (cdr.DriveState) { + default: + case DRIVESTATE_STANDBY: + StopCdda(); + StopReading(); + SetPlaySeekRead(cdr.StatP, 0); - if( cdr.Stat == NoIntr ) - cdr.Stat = Acknowledge; + if (CDR_getStatus(&stat) == -1) + return; - setIrq(); + if (stat.Status & STATUS_SHELLOPEN) + { + cdr.DriveState = DRIVESTATE_LID_OPEN; + CDRLID_INT(0x800); + } + break; - // begin close-seek-ready cycle - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x30; + case DRIVESTATE_LID_OPEN: + if (CDR_getStatus(&stat) == -1) + stat.Status &= ~STATUS_SHELLOPEN; + // 02, 12, 10 + if (!(cdr.StatP & STATUS_SHELLOPEN)) { + cdr.StatP |= STATUS_SHELLOPEN; - // GameShark Lite: Wants -exactly- $42, then $02 - // GS CDX 3.3: Wants $11/$80, $13/$80, $01/$00 - } + // could generate error irq here, but real hardware + // only sometimes does that + // (not done when lots of commands are sent?) - // case still closed - wait for recheck - else - { - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x10; - } - } + CDRLID_INT(cdReadTime * 30); + break; } + else if (cdr.StatP & STATUS_ROTATING) { + cdr.StatP &= ~STATUS_ROTATING; + } + else if (!(stat.Status & STATUS_SHELLOPEN)) { + // closed now + CheckCdrom(); + // cdr.StatP STATUS_SHELLOPEN is "sticky" + // and is only cleared by CdlNop - // GS CDX: clear all values but #1,#2 - if( (cdr.LidCheck >= 0x30) || (cdr.StatP & STATUS_SHELLOPEN) ) - { - SetResultSize(16); - memset( cdr.Result, 0, 16 ); - - cdr.Result[0] = cdr.StatP; + cdr.DriveState = DRIVESTATE_RESCAN_CD; + CDRLID_INT(cdReadTime * 105); + break; + } + // recheck for close + CDRLID_INT(cdReadTime * 3); + break; - // GS CDX: special return value - if( cdr.StatP & STATUS_SHELLOPEN ) - { - cdr.Result[1] = 0x80; - } + case DRIVESTATE_RESCAN_CD: + cdr.StatP |= STATUS_ROTATING; + cdr.DriveState = DRIVESTATE_PREPARE_CD; + // this is very long on real hardware, over 6 seconds + // make it a bit faster here... + CDRLID_INT(cdReadTime * 150); + break; - if( cdr.Stat == NoIntr ) - cdr.Stat = Acknowledge; + case DRIVESTATE_PREPARE_CD: + cdr.StatP |= STATUS_SEEK; - setIrq(); - } + cdr.DriveState = DRIVESTATE_STANDBY; + CDRLID_INT(cdReadTime * 26); + break; } } @@ -457,7 +454,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)) @@ -487,18 +484,12 @@ static void ReadTrack(const u8 *time) { cdr.subq.Absolute[0], cdr.subq.Absolute[1], cdr.subq.Absolute[2]); } -static void AddIrqQueue(unsigned char irq, unsigned long ecycle) { - if (cdr.Irq != 0) - CDR_LOG_I("cdr: override cmd %02x -> %02x\n", cdr.Irq, irq); - - cdr.Irq = irq; - cdr.eCycle = ecycle; - - CDR_INT(ecycle); -} - static void cdrPlayInterrupt_Autopause() { + u32 abs_lev_max = 0; + boolean abs_lev_chselect; + u32 i; + if ((cdr.Mode & MODE_AUTOPAUSE) && cdr.TrackChanged) { CDR_LOG( "CDDA STOP\n" ); @@ -509,15 +500,25 @@ static void cdrPlayInterrupt_Autopause() //cdr.ResultReady = 1; //cdr.Stat = DataReady; cdr.Stat = DataEnd; - setIrq(); + setIrq(0x1000); // 0x1000 just for logging purposes StopCdda(); + SetPlaySeekRead(cdr.StatP, 0); } - else if (cdr.Mode & MODE_REPORT) { - + else if (((cdr.Mode & MODE_REPORT) || cdr.FastForward || cdr.FastBackward)) { cdr.Result[0] = cdr.StatP; cdr.Result[1] = cdr.subq.Track; cdr.Result[2] = cdr.subq.Index; + + abs_lev_chselect = cdr.subq.Absolute[1] & 0x01; + + /* 8 is a hack. For accuracy, it should be 588. */ + for (i = 0; i < 8; i++) + { + abs_lev_max = MAX_VALUE(abs_lev_max, abs(read_buf[i * 2 + abs_lev_chselect])); + } + abs_lev_max = MIN_VALUE(abs_lev_max, 32767); + abs_lev_max |= abs_lev_chselect << 15; if (cdr.subq.Absolute[2] & 0x10) { cdr.Result[3] = cdr.subq.Relative[0]; @@ -530,41 +531,71 @@ 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; cdr.Stat = DataReady; SetResultSize(8); - setIrq(); + setIrq(0x1001); } } -// also handles seek -void cdrPlayInterrupt() +static int cdrSeekTime(unsigned char *target) +{ + int diff = msf2sec(cdr.SetSectorPlay) - msf2sec(target); + int seekTime = abs(diff) * (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; + CDR_LOG("seek: %.2f %.2f\n", (float)seekTime / PSXCLK, (float)seekTime / cdReadTime); + return seekTime; +} + +static void cdrUpdateTransferBuf(const u8 *buf); +static void cdrReadInterrupt(void); +static void cdrPrepCdda(s16 *buf, int samples); +static void cdrAttenuate(s16 *buf, int samples, int stereo); + +void cdrPlaySeekReadInterrupt(void) { - if (cdr.Seeked == SEEK_PENDING) { + if (cdr.Reading) { + cdrReadInterrupt(); + return; + } + + if (!cdr.Play && (cdr.StatP & STATUS_SEEK)) { if (cdr.Stat) { CDR_LOG_I("cdrom: seek stat hack\n"); - CDRMISC_INT(0x1000); + CDRPLAYSEEKREAD_INT(0x1000, 1); return; } SetResultSize(1); cdr.StatP |= STATUS_ROTATING; - cdr.StatP &= ~STATUS_SEEK; + SetPlaySeekRead(cdr.StatP, 0); cdr.Result[0] = cdr.StatP; - cdr.Seeked = SEEK_DONE; - if (cdr.Irq == 0) { - cdr.Stat = Complete; - setIrq(); - } + cdr.Stat = Complete; + setIrq(0x1002); - memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); Find_CurTrack(cdr.SetSectorPlay); ReadTrack(cdr.SetSectorPlay); cdr.TrackChanged = FALSE; + return; } if (!cdr.Play) return; @@ -572,15 +603,25 @@ void cdrPlayInterrupt() CDR_LOG( "CDDA - %d:%d:%d\n", cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] ); + SetPlaySeekRead(cdr.StatP, STATUS_PLAY); if (memcmp(cdr.SetSectorPlay, cdr.SetSectorEnd, 3) == 0) { StopCdda(); + SetPlaySeekRead(cdr.StatP, 0); cdr.TrackChanged = TRUE; } + else { + CDR_readCDDA(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], (u8 *)read_buf); + } - if (!cdr.Irq && !cdr.Stat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT))) + if (!cdr.Stat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT))) cdrPlayInterrupt_Autopause(); - if (!cdr.Play) return; + if (!cdr.Muted && !Config.Cdda) { + cdrPrepCdda(read_buf, CD_FRAMESIZE_RAW / 4); + cdrAttenuate(read_buf, CD_FRAMESIZE_RAW / 4, 1); + SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW, psxRegs.cycle, cdr.FirstSector); + cdr.FirstSector = 0; + } cdr.SetSectorPlay[2]++; if (cdr.SetSectorPlay[2] == 75) { @@ -592,66 +633,108 @@ void cdrPlayInterrupt() } } - CDRMISC_INT(cdReadTime); - // update for CdlGetlocP/autopause generate_subq(cdr.SetSectorPlay); + + CDRPLAYSEEKREAD_INT(cdReadTime, 0); } -void cdrInterrupt() { +#define CMD_PART2 0x100 +#define CMD_WHILE_NOT_READY 0x200 + +void cdrInterrupt(void) { + int start_rotating = 0; + int error = 0; + unsigned int seekTime = 0; + u32 second_resp_time = 0; + u8 ParamC; + u8 set_loc[3]; + u16 not_ready = 0; + u16 Cmd; int i; - unsigned char Irq = cdr.Irq; - // Reschedule IRQ if (cdr.Stat) { - CDR_LOG_I("cdrom: stat hack: %02x %x\n", cdr.Irq, cdr.Stat); - CDR_INT(0x1000); + CDR_LOG_I("%u cdrom: cmd %02x with irqstat %x\n", + psxRegs.cycle, cdr.CmdInProgress, cdr.Stat); + return; + } + if (cdr.Irq1Pending) { + // hand out the "newest" sector, according to nocash + cdrUpdateTransferBuf(CDR_getBuffer()); + CDR_LOG_I("cdrom: %x:%02x:%02x loaded on ack\n", + cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]); + SetResultSize(1); + cdr.Result[0] = cdr.Irq1Pending; + cdr.Stat = (cdr.Irq1Pending & STATUS_ERROR) ? DiskError : DataReady; + cdr.Irq1Pending = 0; + setIrq(0x1003); return; } - cdr.Irq = 0; - cdr.Ctrl &= ~0x80; + // default response + SetResultSize(1); + cdr.Result[0] = cdr.StatP; + cdr.Stat = Acknowledge; - switch (Irq) { - case CdlSync: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; - break; + Cmd = cdr.CmdInProgress; + cdr.CmdInProgress = 0; + ParamC = cdr.ParamC; - case CdlNop: - SetResultSize(1); - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + if (Cmd < 0x100) { + cdr.Ctrl &= ~0x80; + cdr.ParamC = 0; + cdr.Cmd = 0; + } + + switch (cdr.DriveState) { + case DRIVESTATE_LID_OPEN: + case DRIVESTATE_RESCAN_CD: + case DRIVESTATE_PREPARE_CD: + // no disk or busy with the initial scan, allowed cmds are limited + not_ready = CMD_WHILE_NOT_READY; + break; + } - if (cdr.LidCheck == 0) cdr.LidCheck = 0x20; + switch (Cmd | not_ready) { + case CdlNop: + case CdlNop + CMD_WHILE_NOT_READY: + if (cdr.DriveState != DRIVESTATE_LID_OPEN) + cdr.StatP &= ~STATUS_SHELLOPEN; break; case CdlSetloc: - cdr.CmdProcess = 0; - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + case CdlSetloc + CMD_WHILE_NOT_READY: + 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]); + memcpy(cdr.SetSector, set_loc, 3); + cdr.SetSector[3] = 0; + cdr.SetlocPending = 1; + } break; + do_CdlPlay: case CdlPlay: - if (cdr.Seeked == SEEK_PENDING) { - // XXX: wrong, should seek instead.. - memcpy( cdr.SetSectorPlay, cdr.SetSector, 4 ); - cdr.Seeked = SEEK_DONE; - } + StopCdda(); + StopReading(); + + cdr.FastBackward = 0; + cdr.FastForward = 0; // BIOS CD Player // - Pause player, hit Track 01/02/../xx (Setloc issued!!) - if (cdr.ParamC == 0 || cdr.Param[0] == 0) { - CDR_LOG("PLAY Resume @ %d:%d:%d\n", - cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]); - } - else - { + if (ParamC != 0 && cdr.Param[0] != 0) { int track = btoi( cdr.Param[0] ); if (track <= cdr.ResultTN[1]) @@ -660,11 +743,21 @@ void cdrInterrupt() { CDR_LOG("PLAY track %d\n", cdr.CurTrack); if (CDR_getTD((u8)cdr.CurTrack, cdr.ResultTD) != -1) { - cdr.SetSectorPlay[0] = cdr.ResultTD[2]; - cdr.SetSectorPlay[1] = cdr.ResultTD[1]; - cdr.SetSectorPlay[2] = cdr.ResultTD[0]; + for (i = 0; i < 3; i++) + set_loc[i] = cdr.ResultTD[2 - i]; + seekTime = cdrSeekTime(set_loc); + memcpy(cdr.SetSectorPlay, set_loc, 3); } } + else if (cdr.SetlocPending) { + seekTime = cdrSeekTime(cdr.SetSector); + memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); + } + else { + CDR_LOG("PLAY Resume @ %d:%d:%d\n", + cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]); + } + cdr.SetlocPending = 0; /* Rayman: detect track changes @@ -679,82 +772,79 @@ void cdrInterrupt() { Find_CurTrack(cdr.SetSectorPlay); ReadTrack(cdr.SetSectorPlay); cdr.TrackChanged = FALSE; + cdr.FirstSector = 1; if (!Config.Cdda) CDR_play(cdr.SetSectorPlay); - // Vib Ribbon: gameplay checks flag - cdr.StatP &= ~STATUS_SEEK; - - cdr.CmdProcess = 0; - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; - - cdr.StatP |= STATUS_PLAY; - + SetPlaySeekRead(cdr.StatP, STATUS_SEEK | STATUS_ROTATING); // BIOS player - set flag again cdr.Play = TRUE; - CDRMISC_INT( cdReadTime ); + CDRPLAYSEEKREAD_INT(cdReadTime + seekTime, 1); + 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; + } + second_resp_time = cdReadTime * 125 / 2; + start_rotating = 1; + break; + + case CdlStandby + CMD_PART2: 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(); + SetPlaySeekRead(cdr.StatP, 0); cdr.StatP &= ~STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Complete; -// cdr.Stat = Acknowledge; - if (cdr.LidCheck == 0) cdr.LidCheck = 0x20; + second_resp_time = 0x800; + if (cdr.DriveState == DRIVESTATE_STANDBY) + second_resp_time = cdReadTime * 30 / 2; + + cdr.DriveState = DRIVESTATE_STOPPED; break; - case CdlPause: - SetResultSize(1); - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + case CdlStop + CMD_PART2: + cdr.Stat = Complete; + break; + case CdlPause: + StopCdda(); + StopReading(); /* Gundam Battle Assault 2: much slower (*) - Fixes boot, gameplay @@ -765,97 +855,93 @@ void cdrInterrupt() { InuYasha - Feudal Fairy Tale: slower - Fixes battles */ - AddIrqQueue(CdlPause + 0x20, cdReadTime * 3); - cdr.Ctrl |= 0x80; + /* 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.StatP & (STATUS_PLAY | STATUS_READ))) + { + second_resp_time = 7000; + } + else + { + second_resp_time = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * 1000000); + } + SetPlaySeekRead(cdr.StatP, 0); break; - case CdlPause + 0x20: - SetResultSize(1); - cdr.StatP &= ~STATUS_READ; - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; + case CdlPause + CMD_PART2: 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 CdlInit + 0x20: - SetResultSize(1); - cdr.Result[0] = cdr.StatP; + case CdlReset: + case CdlReset + CMD_WHILE_NOT_READY: + StopCdda(); + StopReading(); + SetPlaySeekRead(cdr.StatP, 0); + cdr.Muted = FALSE; + cdr.Mode = 0x20; /* This fixes This is Football 2, Pooh's Party lockups */ + second_resp_time = not_ready ? 70000 : 4100000; + start_rotating = 1; + break; + + case CdlReset + CMD_PART2: + case CdlReset + CMD_PART2 + CMD_WHILE_NOT_READY: 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; + case CdlSetmode + CMD_WHILE_NOT_READY: + CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]); + cdr.Mode = cdr.Param[0]; break; - case CdlGetmode: - SetResultSize(6); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; + case CdlGetparam: + case CdlGetparam + CMD_WHILE_NOT_READY: + /* Gameblabla : According to mednafen, Result size should be 5 and done this way. */ + SetResultSize(5); cdr.Result[1] = cdr.Mode; - cdr.Result[2] = cdr.File; - cdr.Result[3] = cdr.Channel; - cdr.Result[4] = 0; - cdr.Result[5] = 0; - cdr.Stat = Acknowledge; + cdr.Result[2] = 0; + cdr.Result[3] = cdr.File; + cdr.Result[4] = cdr.Channel; 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 + second_resp_time = cdReadTime * 290 / 4; + start_rotating = 1; + break; - cdr.Stat = Acknowledge; + case CdlReadT + CMD_PART2: + 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; @@ -867,10 +953,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; @@ -879,18 +963,20 @@ 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; - cdr.StatP |= STATUS_SEEK; - cdr.Stat = Acknowledge; + StopCdda(); + StopReading(); + SetPlaySeekRead(cdr.StatP, STATUS_SEEK); + seekTime = cdrSeekTime(cdr.SetSector); + memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); /* Crusaders of Might and Magic = 0.5x-4x - fix cutscene speech start @@ -904,12 +990,12 @@ void cdrInterrupt() { Rockman X5 = 0.5-4x - fix capcom logo */ - CDRMISC_INT(cdr.Seeked == SEEK_DONE ? 0x800 : cdReadTime * 4); - cdr.Seeked = SEEK_PENDING; + CDRPLAYSEEKREAD_INT(cdReadTime + seekTime, 1); + start_rotating = 1; break; case CdlTest: - cdr.Stat = Acknowledge; + case CdlTest + CMD_WHILE_NOT_READY: switch (cdr.Param[0]) { case 0x20: // System Controller ROM Version SetResultSize(4); @@ -927,14 +1013,10 @@ void cdrInterrupt() { break; case CdlID: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; - AddIrqQueue(CdlID + 0x20, 0x800); + second_resp_time = 20480; break; - case CdlID + 0x20: + case CdlID + CMD_PART2: SetResultSize(8); cdr.Result[0] = cdr.StatP; cdr.Result[1] = 0; @@ -953,114 +1035,99 @@ void cdrInterrupt() { } cdr.Result[0] |= (cdr.Result[1] >> 4) & 0x08; - strncpy((char *)&cdr.Result[4], "PCSX", 4); + /* This adds the string "PCSX" in Playstation bios boot screen */ + memcpy((char *)&cdr.Result[4], "PCSX", 4); cdr.Stat = Complete; break; - case CdlReset: - SetResultSize(1); - cdr.StatP = STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; - break; - - case CdlReadT: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; - AddIrqQueue(CdlReadT + 0x20, 0x800); + case CdlInit: + case CdlInit + CMD_WHILE_NOT_READY: + StopCdda(); + StopReading(); + SetPlaySeekRead(cdr.StatP, 0); + // yes, it really sets STATUS_SHELLOPEN + cdr.StatP |= STATUS_SHELLOPEN; + cdr.DriveState = DRIVESTATE_RESCAN_CD; + CDRLID_INT(20480); + start_rotating = 1; break; - case CdlReadT + 0x20: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Complete; + case CdlGetQ: + case CdlGetQ + CMD_WHILE_NOT_READY: break; case CdlReadToc: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; - AddIrqQueue(CdlReadToc + 0x20, cdReadTime * 16); + case CdlReadToc + CMD_WHILE_NOT_READY: + second_resp_time = cdReadTime * 180 / 4; + start_rotating = 1; break; - case CdlReadToc + 0x20: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; + case CdlReadToc + CMD_PART2: + case CdlReadToc + CMD_PART2 + CMD_WHILE_NOT_READY: cdr.Stat = Complete; break; case CdlReadN: case CdlReadS: - if (!cdr.Reading) return; - - // Fighting Force 2 - update subq time immediately - // - fixes new game - Find_CurTrack(cdr.SetSector); - ReadTrack(cdr.SetSector); + Find_CurTrack(cdr.SetlocPending ? cdr.SetSector : cdr.SetSectorPlay); + if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1) + // Read* acts as play for cdda tracks in cdda mode + goto do_CdlPlay; - // Crusaders of Might and Magic - update getlocl now - // - fixes cutscene speech - { - u8 *buf = CDR_getBuffer(); - if (buf != NULL) - memcpy(cdr.Transfer, buf, 8); + StopCdda(); + if (cdr.SetlocPending) { + seekTime = cdrSeekTime(cdr.SetSector); + memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); + cdr.SetlocPending = 0; } + cdr.Reading = 1; + cdr.FirstSector = 1; - /* - Duke Nukem: Land of the Babes - seek then delay read for one frame - - fixes cutscenes - C-12 - Final Resistance - doesn't like seek - */ - - if (cdr.Seeked != SEEK_DONE) { - cdr.StatP |= STATUS_SEEK; - cdr.StatP &= ~STATUS_READ; - - // 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; + // Fighting Force 2 - update subq time immediately + // - fixes new game + ReadTrack(cdr.SetSectorPlay); - CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1); - } + CDRPLAYSEEKREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime, 1); - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + SetPlaySeekRead(cdr.StatP, STATUS_SEEK); + start_rotating = 1; break; - + case CdlSync: default: - cdr.Stat = Complete; + CDR_LOG_I("Invalid command: %02x%s\n", + Cmd, not_ready ? " (not_ready)" : ""); + error = ERROR_INVALIDCMD; + // FALLTHROUGH + + set_error: + SetResultSize(2); + cdr.Result[0] = cdr.StatP | STATUS_ERROR; + cdr.Result[1] = not_ready ? ERROR_NOTREADY : error; + cdr.Stat = DiskError; break; } - Check_Shell( Irq ); - - cdr.ParamC = 0; + if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) { + printf("cdr.DriveState %d->%d\n", cdr.DriveState, DRIVESTATE_STANDBY); + cdr.DriveState = DRIVESTATE_STANDBY; + cdr.StatP |= STATUS_ROTATING; + } - setIrq(); + if (second_resp_time) { + cdr.CmdInProgress = Cmd | 0x100; + CDR_INT(second_resp_time); + } + else if (cdr.Cmd && cdr.Cmd != (Cmd & 0xff)) { + cdr.CmdInProgress = cdr.Cmd; + CDR_LOG_I("%u cdrom: cmd %02x came before %02x finished\n", + psxRegs.cycle, cdr.Cmd, Cmd); + } -#ifdef CDR_LOG_CMD_IRQ - SysPrintf("IRQ %d cmd %02x stat %02x: ", - !!(cdr.Stat & cdr.Reg2), Irq, cdr.Stat); - for (i = 0; i < cdr.ResultC; i++) - SysPrintf("%02x ", cdr.Result[i]); - SysPrintf("\n"); -#endif + setIrq(Cmd); } -#ifdef __ARM_ARCH_7A__ +#ifdef HAVE_ARMV7 #define ssat32_to_16(v) \ asm("ssat %0,#16,%1" : "=r" (v) : "r" (v)) #else @@ -1070,7 +1137,18 @@ void cdrInterrupt() { } while (0) #endif -void cdrAttenuate(s16 *buf, int samples, int stereo) +static void cdrPrepCdda(s16 *buf, int samples) +{ +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + int i; + for (i = 0; i < samples; i++) { + buf[i * 2 + 0] = SWAP16(buf[i * 2 + 0]); + buf[i * 2 + 1] = SWAP16(buf[i * 2 + 1]); + } +#endif +} + +static void cdrAttenuate(s16 *buf, int samples, int stereo) { int i, l, r; int ll = cdr.AttenuatorLeftToLeft; @@ -1108,95 +1186,103 @@ void cdrAttenuate(s16 *buf, int samples, int stereo) } } -void cdrReadInterrupt() { - u8 *buf; - - if (!cdr.Reading) +static void cdrReadInterruptSetResult(unsigned char result) +{ + if (cdr.Stat) { + CDR_LOG_I("cdrom: %d:%02d:%02d irq miss, cmd=%02x irqstat=%02x\n", + cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], + cdr.CmdInProgress, cdr.Stat); + cdr.Irq1Pending = result; return; + } + SetResultSize(1); + cdr.Result[0] = result; + cdr.Stat = (result & STATUS_ERROR) ? DiskError : DataReady; + setIrq(0x1004); +} - if (cdr.Irq || cdr.Stat) { - CDR_LOG_I("cdrom: read stat hack %02x %x\n", cdr.Irq, cdr.Stat); - CDREAD_INT(0x1000); +static void cdrUpdateTransferBuf(const u8 *buf) +{ + if (!buf) return; - } + memcpy(cdr.Transfer, buf, DATA_SIZE); + CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]); + CDR_LOG("cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]); + if (cdr.FifoOffset < 2048 + 12) + CDR_LOG("cdrom: FifoOffset(1) %d/%d\n", cdr.FifoOffset, cdr.FifoSize); +} - cdr.OCUP = 1; - SetResultSize(1); - cdr.StatP |= STATUS_READ|STATUS_ROTATING; - cdr.StatP &= ~STATUS_SEEK; - cdr.Result[0] = cdr.StatP; - cdr.Seeked = SEEK_DONE; +static void cdrReadInterrupt(void) +{ + u8 *buf = NULL, *hdr; - ReadTrack(cdr.SetSector); + SetPlaySeekRead(cdr.StatP, STATUS_READ | STATUS_ROTATING); - buf = CDR_getBuffer(); + ReadTrack(cdr.SetSectorPlay); + if (cdr.NoErr) + 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; - cdr.Result[0] |= STATUS_ERROR; - CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime); + cdrReadInterruptSetResult(cdr.StatP | STATUS_ERROR); return; } - memcpy(cdr.Transfer, buf, DATA_SIZE); - CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]); - - - CDR_LOG("cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]); + if (!cdr.Irq1Pending) + cdrUpdateTransferBuf(buf); if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA + hdr = buf + 4; // Firemen 2: Multi-XA files - briefings, cutscenes if( cdr.FirstSector == 1 && (cdr.Mode & MODE_SF)==0 ) { - cdr.File = cdr.Transfer[4 + 0]; - cdr.Channel = cdr.Transfer[4 + 1]; + cdr.File = hdr[0]; + cdr.Channel = hdr[1]; } - if((cdr.Transfer[4 + 2] & 0x4) && - (cdr.Transfer[4 + 1] == cdr.Channel) && - (cdr.Transfer[4 + 0] == cdr.File)) { - int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector); + /* 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 ((hdr[2] & 0x4) && hdr[0] == cdr.File && hdr[1] == cdr.Channel && cdr.Channel != 255) { + int ret = xa_decode_sector(&cdr.Xa, buf + 4, cdr.FirstSector); if (!ret) { cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo); - SPU_playADPCMchannel(&cdr.Xa); + SPU_playADPCMchannel(&cdr.Xa, psxRegs.cycle, cdr.FirstSector); cdr.FirstSector = 0; } else cdr.FirstSector = -1; } } - 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.Readed = 0; - - CDREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime); - /* Croc 2: $40 - only FORM1 (*) Judge Dredd: $C8 - only FORM1 (*) Sim Theme Park - no adpcm at all (zero) */ - if (!(cdr.Mode & MODE_STRSND) || !(cdr.Transfer[4+2] & 0x4)) { - cdr.Stat = DataReady; - setIrq(); + if (!(cdr.Mode & MODE_STRSND) || !(buf[4+2] & 0x4)) + cdrReadInterruptSetResult(cdr.StatP); + + 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]++; + } } - // update for CdlGetlocP - ReadTrack(cdr.SetSector); + if (!cdr.Irq1Pending) { + // update for CdlGetlocP + ReadTrack(cdr.SetSectorPlay); + } - Check_Shell(0); + CDRPLAYSEEKREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0); } /* @@ -1216,21 +1302,18 @@ unsigned char cdrRead0(void) { else cdr.Ctrl &= ~0x20; - if (cdr.OCUP) - cdr.Ctrl |= 0x40; -// else -// cdr.Ctrl &= ~0x40; + cdr.Ctrl |= 0x40; // data fifo not empty // What means the 0x10 and the 0x08 bits? I only saw it used by the bios cdr.Ctrl |= 0x18; - CDR_LOG_IO("cdr r0: %02x\n", cdr.Ctrl); + CDR_LOG_IO("cdr r0.sta: %02x\n", cdr.Ctrl); return psxHu8(0x1800) = cdr.Ctrl; } void cdrWrite0(unsigned char rt) { - CDR_LOG_IO("cdr w0: %02x\n", rt); + CDR_LOG_IO("cdr w0.idx: %02x\n", rt); cdr.Ctrl = (rt & 3) | (cdr.Ctrl & ~3); } @@ -1244,16 +1327,14 @@ unsigned char cdrRead1(void) { if (cdr.ResultP == cdr.ResultC) cdr.ResultReady = 0; - CDR_LOG_IO("cdr r1: %02x\n", psxHu8(0x1801)); + CDR_LOG_IO("cdr r1.rsp: %02x #%u\n", psxHu8(0x1801), cdr.ResultP - 1); return psxHu8(0x1801); } void cdrWrite1(unsigned char rt) { - u8 set_loc[3]; - int i; - - CDR_LOG_IO("cdr w1: %02x\n", rt); + const char *rnames[] = { "cmd", "smd", "smc", "arr" }; (void)rnames; + CDR_LOG_IO("cdr w1.%s: %02x\n", rnames[cdr.Ctrl & 3], rt); switch (cdr.Ctrl & 3) { case 0: @@ -1265,12 +1346,10 @@ void cdrWrite1(unsigned char rt) { return; } - cdr.Cmd = rt; - cdr.OCUP = 0; - #ifdef CDR_LOG_CMD_IRQ - SysPrintf("CD1 write: %x (%s)", rt, CmdName[rt]); + SysPrintf("%u cdrom: CD1 write: %x (%s)", psxRegs.cycle, rt, CmdName[rt]); if (cdr.ParamC) { + int i; SysPrintf(" Param[%d] = {", cdr.ParamC); for (i = 0; i < cdr.ParamC; i++) SysPrintf(" %x,", cdr.Param[i]); @@ -1282,178 +1361,37 @@ void cdrWrite1(unsigned char rt) { cdr.ResultReady = 0; cdr.Ctrl |= 0x80; - // cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - - switch (cdr.Cmd) { - case CdlSync: - case CdlNop: - case CdlForward: - case CdlBackward: - case CdlReadT: - case CdlTest: - case CdlID: - case CdlReadToc: - case CdlGetmode: - case CdlGetlocL: - case CdlGetlocP: - case CdlGetTD: - break; - - case CdlSetloc: - StopReading(); - for (i = 0; i < 3; i++) - set_loc[i] = btoi(cdr.Param[i]); - - // FIXME: clean up this SetSector/SetSectorPlay mess, - // there should be single var tracking current sector pos - if (cdr.Play) - i = msf2sec(cdr.SetSectorPlay); - else - i = msf2sec(cdr.SetSector); - i = abs(i - msf2sec(set_loc)); - if (i > 16) - cdr.Seeked = SEEK_PENDING; - - memcpy(cdr.SetSector, set_loc, 3); - cdr.SetSector[3] = 0; - break; - - case CdlPlay: - // Vib Ribbon: try same track again - StopCdda(); - - // Vib Ribbon - decoded buffer IRQ for CDDA reading - // - fixes ribbon timing + music CD mode - //CDRDBUF_INT( PSXCLK / 44100 * 0x100 ); - - cdr.Play = TRUE; - - cdr.StatP |= STATUS_SEEK; - cdr.StatP &= ~STATUS_ROTATING; - break; - - case CdlReadN: - StopReading(); - cdr.Reading = 1; - cdr.FirstSector = 1; - cdr.Readed = 0xff; - break; - - case CdlStandby: - StopCdda(); - StopReading(); - break; - - case CdlStop: - // GameShark CD Player: Reset CDDA to track start - if (cdr.Play) { - // grab time for current track - CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD); - - cdr.SetSectorPlay[0] = cdr.ResultTD[2]; - cdr.SetSectorPlay[1] = cdr.ResultTD[1]; - cdr.SetSectorPlay[2] = cdr.ResultTD[0]; - } - - StopCdda(); - StopReading(); - break; - - case CdlPause: - /* - GameShark CD Player: save time for resume - - Twisted Metal - World Tour: don't mix Setloc / CdlPlay cursors - */ - - StopCdda(); - StopReading(); - break; - - case CdlReset: - case CdlInit: - cdr.Seeked = SEEK_DONE; - StopCdda(); - StopReading(); - break; - - case CdlMute: - cdr.Muted = TRUE; - // Duke Nukem - Time to Kill - // - do not directly set cd-xa volume - //SPU_writeRegister( H_CDLeft, 0x0000 ); - //SPU_writeRegister( H_CDRight, 0x0000 ); - break; - - case CdlDemute: - cdr.Muted = FALSE; - - // Duke Nukem - Time to Kill - // - do not directly set cd-xa volume - //SPU_writeRegister( H_CDLeft, 0x7f00 ); - //SPU_writeRegister( H_CDRight, 0x7f00 ); - break; - - case CdlSetfilter: - cdr.File = cdr.Param[0]; - cdr.Channel = cdr.Param[1]; - break; - - case CdlSetmode: - CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]); - - cdr.Mode = cdr.Param[0]; - - // Squaresoft on PlayStation 1998 Collector's CD Vol. 1 - // - fixes choppy movie sound - if( cdr.Play && (cdr.Mode & MODE_CDDA) == 0 ) - StopCdda(); - break; - case CdlGetTN: - //AddIrqQueue(cdr.Cmd, 0x800); - - // GameShark CDX CD Player: very long time - AddIrqQueue(cdr.Cmd, 0x100000); - break; - - case CdlSeekL: - case CdlSeekP: - // Tomb Raider 2 - reset cdda - StopCdda(); - StopReading(); - break; - - case CdlReadS: - StopReading(); - cdr.Reading = 2; - cdr.FirstSector = 1; - cdr.Readed = 0xff; - break; - - default: - cdr.ParamC = 0; - CDR_LOG_I("cdrWrite1() Log: Unknown command: %x\n", cdr.Cmd); - return; + if (!cdr.CmdInProgress) { + cdr.CmdInProgress = rt; + // should be something like 12k + controller delays + CDR_INT(5000); + } + else { + CDR_LOG_I("%u cdrom: cmd while busy: %02x, prev %02x, busy %02x\n", + psxRegs.cycle, rt, cdr.Cmd, cdr.CmdInProgress); + if (cdr.CmdInProgress < 0x100) // no pending 2nd response + cdr.CmdInProgress = rt; } + + cdr.Cmd = rt; } unsigned char cdrRead2(void) { - unsigned char ret; + unsigned char ret = 0; - if (cdr.Readed == 0) { - ret = 0; - } else { - ret = *pTransfer++; - } + if (cdr.FifoOffset < cdr.FifoSize) + ret = cdr.Transfer[cdr.FifoOffset++]; + else + CDR_LOG_I("cdrom: read empty fifo (%d)\n", cdr.FifoSize); - CDR_LOG_IO("cdr r2: %02x\n", ret); + CDR_LOG_IO("cdr r2.dat: %02x\n", ret); return ret; } void cdrWrite2(unsigned char rt) { - CDR_LOG_IO("cdr w2: %02x\n", rt); + const char *rnames[] = { "prm", "ien", "all", "arl" }; (void)rnames; + CDR_LOG_IO("cdr w2.%s: %02x\n", rnames[cdr.Ctrl & 3], rt); switch (cdr.Ctrl & 3) { case 0: @@ -1462,7 +1400,7 @@ void cdrWrite2(unsigned char rt) { return; case 1: cdr.Reg2 = rt; - setIrq(); + setIrq(0x1005); return; case 2: cdr.AttenuatorLeftToLeftT = rt; @@ -1479,17 +1417,28 @@ unsigned char cdrRead3(void) { else psxHu8(0x1803) = cdr.Reg2 | 0xE0; - CDR_LOG_IO("cdr r3: %02x\n", psxHu8(0x1803)); + CDR_LOG_IO("cdr r3.%s: %02x\n", (cdr.Ctrl & 1) ? "ifl" : "ien", psxHu8(0x1803)); return psxHu8(0x1803); } void cdrWrite3(unsigned char rt) { - CDR_LOG_IO("cdr w3: %02x\n", rt); + const char *rnames[] = { "req", "ifl", "alr", "ava" }; (void)rnames; + CDR_LOG_IO("cdr w3.%s: %02x\n", rnames[cdr.Ctrl & 3], rt); switch (cdr.Ctrl & 3) { case 0: break; // transfer case 1: + if (cdr.Stat & rt) { +#ifdef CDR_LOG_CMD_IRQ + SysPrintf("%u cdrom: ack %02x (w %02x)\n", + psxRegs.cycle, cdr.Stat & rt, rt); +#endif + // note: Croc vs Discworld Noir + if (!(psxRegs.interrupt & (1 << PSXINT_CDR)) && + (cdr.CmdInProgress || cdr.Irq1Pending)) + CDR_INT(850); // 711-993 + } cdr.Stat &= ~rt; if (rt & 0x40) @@ -1501,31 +1450,34 @@ void cdrWrite3(unsigned char rt) { case 3: if (rt & 0x20) { memcpy(&cdr.AttenuatorLeftToLeft, &cdr.AttenuatorLeftToLeftT, 4); - CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n", + CDR_LOG("CD-XA Volume: %02x %02x | %02x %02x\n", cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight, cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight); } return; } - if ((rt & 0x80) && cdr.Readed == 0) { - cdr.Readed = 1; - pTransfer = cdr.Transfer; - + // test: Viewpoint + if ((rt & 0x80) && cdr.FifoOffset < cdr.FifoSize) { + CDR_LOG("cdrom: FifoOffset(2) %d/%d\n", cdr.FifoOffset, cdr.FifoSize); + } + else if (rt & 0x80) { switch (cdr.Mode & 0x30) { case MODE_SIZE_2328: case 0x00: - pTransfer += 12; + cdr.FifoOffset = 12; + cdr.FifoSize = 2048 + 12; break; case MODE_SIZE_2340: - pTransfer += 0; - break; - default: + cdr.FifoOffset = 0; + cdr.FifoSize = 2340; break; } } + else if (!(rt & 0xc0)) + cdr.FifoOffset = DATA_SIZE; // fifo empty } void psxDma3(u32 madr, u32 bcr, u32 chcr) { @@ -1535,64 +1487,49 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) { CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr); - switch (chcr) { + switch (chcr & 0x71000000) { case 0x11000000: - case 0x11400100: - if (cdr.Readed == 0) { - CDR_LOG("psxDma3() Log: *** DMA 3 *** NOT READY\n"); - break; - } - - cdsize = (bcr & 0xffff) * 4; - - // Ape Escape: bcr = 0001 / 0000 - // - fix boot - if( cdsize == 0 ) - { - switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) { - case MODE_SIZE_2340: cdsize = 2340; break; - case MODE_SIZE_2328: cdsize = 2328; break; - default: - case MODE_SIZE_2048: cdsize = 2048; break; - } - } - - ptr = (u8 *)PSXM(madr); if (ptr == NULL) { - CDR_LOG("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n"); + CDR_LOG_I("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n"); break; } + cdsize = (((bcr - 1) & 0xffff) + 1) * 4; + /* GS CDX: Enhancement CD crash - Setloc 0:0:0 - CdlPlay - Spams DMA3 and gets buffer overrun */ - size = CD_FRAMESIZE_RAW - (pTransfer - cdr.Transfer); + size = DATA_SIZE - cdr.FifoOffset; if (size > cdsize) size = cdsize; if (size > 0) { - memcpy(ptr, pTransfer, size); + memcpy(ptr, cdr.Transfer + cdr.FifoOffset, size); + cdr.FifoOffset += size; + psxCpu->Clear(madr, size / 4); } + if (size < cdsize) + CDR_LOG_I("cdrom: dma3 %d/%d\n", size, cdsize); - psxCpu->Clear(madr, cdsize / 4); - pTransfer += cdsize; - + CDRDMA_INT((cdsize/4) * 24); - // burst vs normal - if( chcr == 0x11400100 ) { - CDRDMA_INT( (cdsize/4) / 4 ); + HW_DMA3_CHCR &= SWAPu32(~0x10000000); + if (chcr & 0x100) { + HW_DMA3_MADR = SWAPu32(madr + cdsize); + HW_DMA3_BCR &= SWAPu32(0xffff0000); } - else if( chcr == 0x11000000 ) { - CDRDMA_INT( (cdsize/4) * 1 ); + else { + // halted + psxRegs.cycle += (cdsize/4) * 24 - 20; } return; default: - CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr); + CDR_LOG_I("psxDma3() Log: Unknown cddma %x\n", chcr); break; } @@ -1600,7 +1537,7 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) { DMA_INTERRUPT(3); } -void cdrDmaInterrupt() +void cdrDmaInterrupt(void) { if (HW_DMA3_CHCR & SWAP32(0x01000000)) { @@ -1627,8 +1564,10 @@ void cdrReset() { cdr.Channel = 1; cdr.Reg2 = 0x1f; cdr.Stat = NoIntr; - pTransfer = cdr.Transfer; - + cdr.DriveState = DRIVESTATE_STANDBY; + cdr.StatP = STATUS_ROTATING; + cdr.FifoOffset = DATA_SIZE; // fifo empty + // BIOS player - default values cdr.AttenuatorLeftToLeft = 0x80; cdr.AttenuatorLeftToRight = 0x00; @@ -1645,12 +1584,12 @@ int cdrFreeze(void *f, int Mode) { if (Mode == 0 && !Config.Cdda) CDR_stop(); - cdr.freeze_ver = 0x63647201; + cdr.freeze_ver = 0x63647202; gzfreeze(&cdr, sizeof(cdr)); if (Mode == 1) { cdr.ParamP = cdr.ParamC; - tmp = pTransfer - cdr.Transfer; + tmp = cdr.FifoOffset; } gzfreeze(&tmp, sizeof(tmp)); @@ -1658,17 +1597,25 @@ int cdrFreeze(void *f, int Mode) { if (Mode == 0) { getCdInfo(); - pTransfer = cdr.Transfer + tmp; + cdr.FifoOffset = tmp; + cdr.FifoSize = (cdr.Mode & 0x20) ? 2340 : 2048 + 12; // read right sub data - memcpy(tmpp, cdr.Prev, 3); + tmpp[0] = btoi(cdr.Prev[0]); + tmpp[1] = btoi(cdr.Prev[1]); + tmpp[2] = btoi(cdr.Prev[2]); cdr.Prev[0]++; ReadTrack(tmpp); if (cdr.Play) { + if (cdr.freeze_ver < 0x63647202) + memcpy(cdr.SetSectorPlay, cdr.SetSector, 3); + Find_CurTrack(cdr.SetSectorPlay); if (!Config.Cdda) CDR_play(cdr.SetSectorPlay); + if (psxRegs.interrupt & (1 << PSXINT_CDRPLAY_OLD)) + CDRPLAYSEEKREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime, 1); } if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) { @@ -1677,24 +1624,19 @@ 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; + } } } return 0; } -void LidInterrupt() { - cdr.LidCheck = 0x20; // start checker - +void LidInterrupt(void) { getCdInfo(); - - StopCdda(); - CDRLID_INT( cdReadTime * 3 ); - - // generate interrupt if none active - open or close - if (cdr.Irq == 0 || cdr.Irq == 0xff) { - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(CdlNop, 0x800); - } + cdrLidSeekInterrupt(); }