X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=libpcsxcore%2Fcdrom.c;h=3e31c0aeb63fe491bbb5613b13da395d01f6a2c9;hb=HEAD;hp=3bf3e033b7fb15a8e45212aad0b13d4f7611b893;hpb=0e2e3f498456d1175916ecd69d0a9e80e701e760;p=pcsx_rearmed.git diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c index 3bf3e033..d4d14742 100644 --- a/libpcsxcore/cdrom.c +++ b/libpcsxcore/cdrom.c @@ -14,21 +14,119 @@ * 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 #include "cdrom.h" +#include "misc.h" #include "ppf.h" #include "psxdma.h" +#include "psxevents.h" +#include "arm_features.h" -cdrStruct cdr; +/* logging */ +#if 0 +#define CDR_LOG SysPrintf +#else +#define CDR_LOG(...) +#endif +#if 0 +#define CDR_LOG_I SysPrintf +#else +#define CDR_LOG_I(fmt, ...) \ + log_unhandled("%u cdrom: " fmt, psxRegs.cycle, ##__VA_ARGS__) +#endif +#if 0 +#define CDR_LOG_IO SysPrintf +#else +#define CDR_LOG_IO(...) +#endif +//#define CDR_LOG_CMD_IRQ + +static struct { + // unused members maintain savesate compatibility + unsigned char unused0; + unsigned char unused1; + unsigned char IrqMask; + unsigned char unused2; + unsigned char Ctrl; + unsigned char IrqStat; + + 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 ReportDelay; + unsigned char PhysCdPropagations; + unsigned short sectorsRead; + 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 SubqForwardSectors; + 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; + unsigned char Mode; + unsigned char FileChannelSelected; + unsigned char CurFile, CurChannel; + int FilterFile, FilterChannel; + unsigned char LocL[8]; + int unused4; + + xa_decode_t Xa; + + u16 FifoOffset; + u16 FifoSize; + + u16 CmdInProgress; + u8 Irq1Pending; + u8 AdpcmActive; + u32 LastReadSeekCycles; + + u8 unused7; + + u8 DriveState; // enum drive_state + u8 FastForward; + u8 FastBackward; + u8 errorRetryhack; + + 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 @@ -38,12 +136,12 @@ cdrStruct cdr; #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 @@ -56,27 +154,22 @@ cdrStruct cdr; #define CdlTest 25 #define CdlID 26 #define CdlReadS 27 -#define CdlReset 28 +#define CdlInit 28 +#define CdlGetQ 29 #define CdlReadToc 30 -#define AUTOPAUSE 249 -#define READ_ACK 250 -#define READ 251 -#define REPPLAY_ACK 252 -#define REPPLAY 253 -#define ASYNC 254 -/* don't set 255, it's reserved */ - -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 }; @@ -84,7 +177,7 @@ unsigned char Test20[] = { 0x98, 0x06, 0x10, 0xC3 }; unsigned char Test22[] = { 0x66, 0x6F, 0x72, 0x20, 0x45, 0x75, 0x72, 0x6F }; unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 }; -// cdr.Stat: +// cdr.IrqStat: #define NoIntr 0 #define DataReady 1 #define Complete 2 @@ -97,6 +190,7 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 }; #define MODE_STRSND (1<<6) // 0x40 ADPCM on/off #define MODE_SIZE_2340 (1<<5) // 0x20 #define MODE_SIZE_2328 (1<<4) // 0x10 +#define MODE_SIZE_2048 (0<<4) // 0x00 #define MODE_SF (1<<3) // 0x08 channel on/off #define MODE_REPORT (1<<2) // 0x04 #define MODE_AUTOPAUSE (1<<1) // 0x02 @@ -108,24 +202,48 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 }; #define STATUS_READ (1<<5) // 0x20 #define STATUS_SHELLOPEN (1<<4) // 0x10 #define STATUS_UNKNOWN3 (1<<3) // 0x08 -#define STATUS_UNKNOWN2 (1<<2) // 0x04 +#define STATUS_SEEKERROR (1<<2) // 0x04 #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_BAD_ARGNUM (1<<5) // 0x20 +#define ERROR_BAD_ARGVAL (1<<4) // 0x10 +#define ERROR_SHELLOPEN (1<<3) // 0x08 // 1x = 75 sectors per second // PSXCLK = 1 sec in the ps // so (PSXCLK / 75) = cdr read time (linuzappz) #define cdReadTime (PSXCLK / 75) +#define LOCL_INVALID 0xff +#define SUBQ_FORWARD_SECTORS 2u + +enum drive_state { + DRIVESTATE_STANDBY = 0, // different from paused + DRIVESTATE_LID_OPEN, + DRIVESTATE_RESCAN_CD, + DRIVESTATE_PREPARE_CD, + DRIVESTATE_STOPPED, + DRIVESTATE_PAUSED, + DRIVESTATE_PLAY_READ, + DRIVESTATE_SEEK, +}; + static struct CdrStat stat; -static unsigned int msf2sec(char *msf) { +static unsigned int msf2sec(const u8 *msf) { return ((msf[0] * 60 + msf[1]) * 75) + msf[2]; } -static void sec2msf(unsigned int s, char *msf) { +// for that weird psemu API.. +static unsigned int fsm2sec(const u8 *msf) { + return ((msf[2] * 60 + msf[1]) * 75) + msf[0]; +} + +static void sec2msf(unsigned int s, u8 *msf) { msf[0] = s / 75 / 60; s = s - msf[0] * 75 * 60; msf[1] = s / 75; @@ -133,576 +251,619 @@ static void sec2msf(unsigned int s, char *msf) { msf[2] = s; } - -#define CDR_INT(eCycle) { \ - psxRegs.interrupt |= (1 << PSXINT_CDR); \ - psxRegs.intCycle[PSXINT_CDR].cycle = eCycle; \ - psxRegs.intCycle[PSXINT_CDR].sCycle = psxRegs.cycle; \ - new_dyna_set_event(PSXINT_CDR, eCycle); \ -} - -#define CDREAD_INT(eCycle) { \ +// cdrPlayReadInterrupt +#define CDRPLAYREAD_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); \ -} - -#define CDRLID_INT(eCycle) { \ - psxRegs.interrupt |= (1 << PSXINT_CDRLID); \ - psxRegs.intCycle[PSXINT_CDRLID].cycle = eCycle; \ - psxRegs.intCycle[PSXINT_CDRLID].sCycle = psxRegs.cycle; \ - new_dyna_set_event(PSXINT_CDRLID, eCycle); \ -} - -#define CDRPLAY_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 StartReading(type, eCycle) { \ - cdr.Reading = type; \ - cdr.FirstSector = 1; \ - cdr.Readed = 0xff; \ - AddIrqQueue(READ_ACK, 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_; \ + set_event_raw_abs(PSXINT_CDREAD, psxRegs.intCycle[PSXINT_CDREAD].sCycle + e_); \ } #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 SetResultSize(size) { \ - cdr.ResultP = 0; \ +#define SetPlaySeekRead(x, f) { \ + x &= ~(STATUS_PLAY | STATUS_SEEK | STATUS_READ); \ + x |= f; \ +} + +#define SetResultSize_(size) { \ + cdr.ResultP = 0; \ cdr.ResultC = size; \ cdr.ResultReady = 1; \ } +#define SetResultSize(size) { \ + if (cdr.ResultP < cdr.ResultC) \ + CDR_LOG_I("overwriting result, len=%u\n", cdr.ResultC); \ + SetResultSize_(size); \ +} -void cdrLidSeekInterrupt() +static void setIrq(u8 irq, int log_cmd) { - // 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; + u8 old = cdr.IrqStat & cdr.IrqMask ? 1 : 0; + u8 new_ = irq & cdr.IrqMask ? 1 : 0; + cdr.IrqStat = irq; + if ((old ^ new_) & new_) + psxHu32ref(0x1070) |= SWAP32((u32)0x4); - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x60; - } - - // done = cd ready - else if( cdr.LidCheck == 0x60 ) +#ifdef CDR_LOG_CMD_IRQ + if (cdr.IrqStat) { - // GameShark Lite: Seek detection done ($02) - cdr.StatP &= ~STATUS_SEEK; - - cdr.LidCheck = 0; + int i; + CDR_LOG_I("CDR IRQ=%d cmd %02x irqstat %02x: ", + !!(cdr.IrqStat & cdr.IrqMask), log_cmd, cdr.IrqStat); + 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) - { -#ifdef CDR_LOG - CDR_LOG( "LidCheck\n" ); -#endif - - // $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(); - - - if( cdr.Stat == NoIntr ) - cdr.Stat = Acknowledge; - - psxHu32ref(0x1070) |= SWAP32((u32)0x4); + CDR_LOG_I("%s cdr.DriveState=%d\n", __func__, cdr.DriveState); + switch (cdr.DriveState) { + default: + case DRIVESTATE_STANDBY: + StopCdda(); + //StopReading(); + SetPlaySeekRead(cdr.StatP, 0); - // begin close-seek-ready cycle - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x30; + if (CDR_getStatus(&stat) == -1) + return; + if (stat.Status & STATUS_SHELLOPEN) + { + memset(cdr.Prev, 0xff, sizeof(cdr.Prev)); + cdr.DriveState = DRIVESTATE_LID_OPEN; + set_event(PSXINT_CDRLID, 0x800); + } + break; - // GameShark Lite: Wants -exactly- $42, then $02 - // GS CDX 3.3: Wants $11/$80, $13/$80, $01/$00 - } + case DRIVESTATE_LID_OPEN: + if (CDR_getStatus(&stat) == -1) + stat.Status &= ~STATUS_SHELLOPEN; - // case still closed - wait for recheck - else - { - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x10; - } + // 02, 12, 10 + if (!(cdr.StatP & STATUS_SHELLOPEN)) { + StopReading(); + SetPlaySeekRead(cdr.StatP, 0); + cdr.StatP |= STATUS_SHELLOPEN; + + // IIRC this sometimes doesn't happen on real hw + // (when lots of commands are sent?) + SetResultSize(2); + cdr.Result[0] = cdr.StatP | STATUS_SEEKERROR; + cdr.Result[1] = ERROR_SHELLOPEN; + if (cdr.CmdInProgress) { + psxRegs.interrupt &= ~(1 << PSXINT_CDR); + cdr.CmdInProgress = 0; + cdr.Result[0] = cdr.StatP | STATUS_ERROR; + cdr.Result[1] = ERROR_NOTREADY; } - } + setIrq(DiskError, 0x1006); + set_event(PSXINT_CDRLID, cdReadTime * 30); + break; + } + else if (cdr.StatP & STATUS_ROTATING) { + cdr.StatP &= ~STATUS_ROTATING; + } + else if (!(stat.Status & STATUS_SHELLOPEN)) { + // closed now + CheckCdrom(); - // 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.StatP STATUS_SHELLOPEN is "sticky" + // and is only cleared by CdlNop + cdr.DriveState = DRIVESTATE_RESCAN_CD; + set_event(PSXINT_CDRLID, cdReadTime * 105); + break; + } - // GS CDX: special return value - if( cdr.StatP & STATUS_SHELLOPEN ) - { - cdr.Result[1] = 0x80; - } + // recheck for close + set_event(PSXINT_CDRLID, cdReadTime * 3); + break; + case DRIVESTATE_RESCAN_CD: + cdr.StatP |= STATUS_ROTATING; + cdr.DriveState = DRIVESTATE_PREPARE_CD; - if( cdr.Stat == NoIntr ) - cdr.Stat = Acknowledge; + // this is very long on real hardware, over 6 seconds + // make it a bit faster here... + set_event(PSXINT_CDRLID, cdReadTime * 150); + break; - psxHu32ref(0x1070) |= SWAP32((u32)0x4); + case DRIVESTATE_PREPARE_CD: + if (cdr.StatP & STATUS_SEEK) { + SetPlaySeekRead(cdr.StatP, 0); + cdr.DriveState = DRIVESTATE_STANDBY; } + else { + SetPlaySeekRead(cdr.StatP, STATUS_SEEK); + set_event(PSXINT_CDRLID, cdReadTime * 26); + } + break; } } +static void Find_CurTrack(const u8 *time) +{ + int current, sect; -void Find_CurTrack() { - cdr.CurTrack = 0; + current = msf2sec(time); - if (CDR_getTN(cdr.ResultTN) != -1) { - int lcv; + for (cdr.CurTrack = 1; cdr.CurTrack < cdr.ResultTN[1]; cdr.CurTrack++) { + CDR_getTD(cdr.CurTrack + 1, cdr.ResultTD); + sect = fsm2sec(cdr.ResultTD); + if (sect - current >= 150) + break; + } +} - for( lcv = 1; lcv <= cdr.ResultTN[1]; lcv++ ) { - if (CDR_getTD((u8)(lcv), cdr.ResultTD) != -1) { - u32 sect1, sect2; +static void generate_subq(const u8 *time) +{ + unsigned char start[3], next[3]; + unsigned int this_s, start_s, next_s, pregap; + int relative_s; -#ifdef CDR_LOG___0 - CDR_LOG( "curtrack %d %d %d | %d %d %d | %d\n", - cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], - cdr.ResultTD[2], cdr.ResultTD[1], cdr.ResultTD[0], - cdr.CurTrack ); -#endif + CDR_getTD(cdr.CurTrack, start); + if (cdr.CurTrack + 1 <= cdr.ResultTN[1]) { + pregap = 150; + CDR_getTD(cdr.CurTrack + 1, next); + } + else { + // last track - cd size + pregap = 0; + next[0] = cdr.SetSectorEnd[2]; + next[1] = cdr.SetSectorEnd[1]; + next[2] = cdr.SetSectorEnd[0]; + } - // find next track boundary - only need m:s accuracy - sect1 = cdr.SetSectorPlay[0] * 60 * 75 + cdr.SetSectorPlay[1] * 75; - sect2 = cdr.ResultTD[2] * 60 * 75 + cdr.ResultTD[1] * 75; + this_s = msf2sec(time); + start_s = fsm2sec(start); + next_s = fsm2sec(next); - // Twisted Metal 4 - psx cdda pregap (2-sec) - // - fix in-game music - sect2 -= 75 * 2; + cdr.TrackChanged = FALSE; - if( sect1 >= sect2 ) { - cdr.CurTrack++; - continue; - } - } + if (next_s - this_s < pregap) { + cdr.TrackChanged = TRUE; + cdr.CurTrack++; + start_s = next_s; + } - break; - } + cdr.subq.Index = 1; + + relative_s = this_s - start_s; + if (relative_s < 0) { + cdr.subq.Index = 0; + relative_s = -relative_s; } + sec2msf(relative_s, cdr.subq.Relative); + + cdr.subq.Track = itob(cdr.CurTrack); + cdr.subq.Relative[0] = itob(cdr.subq.Relative[0]); + cdr.subq.Relative[1] = itob(cdr.subq.Relative[1]); + cdr.subq.Relative[2] = itob(cdr.subq.Relative[2]); + cdr.subq.Absolute[0] = itob(time[0]); + cdr.subq.Absolute[1] = itob(time[1]); + cdr.subq.Absolute[2] = itob(time[2]); } -static void ReadTrack( u8 *time ) { - cdr.Prev[0] = itob( time[0] ); - cdr.Prev[1] = itob( time[1] ); - cdr.Prev[2] = itob( time[2] ); +static int ReadTrack(const u8 *time) +{ + unsigned char tmp[3]; + int read_ok; -#ifdef CDR_LOG - CDR_LOG("ReadTrack() Log: KEY *** %x:%x:%x\n", cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]); -#endif - cdr.RErr = CDR_readTrack(cdr.Prev); -} + tmp[0] = itob(time[0]); + tmp[1] = itob(time[1]); + tmp[2] = itob(time[2]); + CDR_LOG("ReadTrack *** %02x:%02x:%02x\n", tmp[0], tmp[1], tmp[2]); -void AddIrqQueue(unsigned char irq, unsigned long ecycle) { - cdr.Irq = irq; - cdr.eCycle = ecycle; + if (memcmp(cdr.Prev, tmp, 3) == 0) + return 1; - // Doom: Force rescheduling - // - Fixes boot - CDR_INT(ecycle); + read_ok = CDR_readTrack(tmp); + if (read_ok) + memcpy(cdr.Prev, tmp, 3); + return read_ok; } - -void Set_Track() +static void UpdateSubq(const u8 *time) { - if (CDR_getTN(cdr.ResultTN) != -1) { - int lcv; - - for( lcv = 1; lcv < cdr.ResultTN[1]; lcv++ ) { - if (CDR_getTD((u8)(lcv), cdr.ResultTD) != -1) { -#ifdef CDR_LOG___0 - CDR_LOG( "settrack %d %d %d | %d %d %d | %d\n", - cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], - cdr.ResultTD[2], cdr.ResultTD[1], cdr.ResultTD[0], - cdr.CurTrack ); -#endif + const struct SubQ *subq; + int s = MSF2SECT(time[0], time[1], time[2]); + u16 crc; - // check if time matches track start (only need min, sec accuracy) - // - m:s:f vs f:s:m - if( cdr.SetSectorPlay[0] == cdr.ResultTD[2] && - cdr.SetSectorPlay[1] == cdr.ResultTD[1] ) { - // skip pregap frames - if( cdr.SetSectorPlay[2] < cdr.ResultTD[0] ) - cdr.SetSectorPlay[2] = cdr.ResultTD[0]; + if (CheckSBI(s)) + return; - break; - } - else if( cdr.SetSectorPlay[0] < cdr.ResultTD[2] ) - break; - } + subq = (struct SubQ *)CDR_getBufferSub(s); + if (subq != NULL && cdr.CurTrack == 1) { + crc = calcCrc((u8 *)subq + 12, 10); + if (crc == (((u16)subq->CRC[0] << 8) | subq->CRC[1])) { + cdr.subq.Track = subq->TrackNumber; + cdr.subq.Index = subq->IndexNumber; + memcpy(cdr.subq.Relative, subq->TrackRelativeAddress, 3); + memcpy(cdr.subq.Absolute, subq->AbsoluteAddress, 3); + } + else { + CDR_LOG_I("subq bad crc @%02d:%02d:%02d\n", + time[0], time[1], time[2]); } } -} - - -static u8 fake_subq_local[3], fake_subq_real[3], fake_subq_index, fake_subq_change; -static void Create_Fake_Subq() -{ - u8 temp_cur[3], temp_next[3], temp_start[3], pregap; - int diff; - - if (CDR_getTN(cdr.ResultTN) == -1) return; - if( cdr.CurTrack+1 <= cdr.ResultTN[1] ) { - pregap = 150; - if( CDR_getTD(cdr.CurTrack+1, cdr.ResultTD) == -1 ) return; - } else { - // last track - cd size - pregap = 0; - if( CDR_getTD(0, cdr.ResultTD) == -1 ) return; - } - - if( cdr.Play == TRUE ) { - temp_cur[0] = cdr.SetSectorPlay[0]; - temp_cur[1] = cdr.SetSectorPlay[1]; - temp_cur[2] = cdr.SetSectorPlay[2]; - } else { - temp_cur[0] = btoi( cdr.Prev[0] ); - temp_cur[1] = btoi( cdr.Prev[1] ); - temp_cur[2] = btoi( cdr.Prev[2] ); + else { + generate_subq(time); } - fake_subq_real[0] = temp_cur[0]; - fake_subq_real[1] = temp_cur[1]; - fake_subq_real[2] = temp_cur[2]; - - temp_next[0] = cdr.ResultTD[2]; - temp_next[1] = cdr.ResultTD[1]; - temp_next[2] = cdr.ResultTD[0]; + CDR_LOG(" -> %02x,%02x %02x:%02x:%02x %02x:%02x:%02x\n", + cdr.subq.Track, cdr.subq.Index, + cdr.subq.Relative[0], cdr.subq.Relative[1], cdr.subq.Relative[2], + cdr.subq.Absolute[0], cdr.subq.Absolute[1], cdr.subq.Absolute[2]); +} +static void cdrPlayInterrupt_Autopause() +{ + u32 abs_lev_max = 0; + boolean abs_lev_chselect; + u32 i; - // flag- next track - if( msf2sec(temp_cur) >= msf2sec( temp_next )-pregap ) { - fake_subq_change = 1; + if ((cdr.Mode & MODE_AUTOPAUSE) && cdr.TrackChanged) { + CDR_LOG_I("autopause\n"); - cdr.CurTrack++; + SetResultSize(1); + cdr.Result[0] = cdr.StatP; + setIrq(DataEnd, 0x1000); // 0x1000 just for logging purposes - // end cd - if( pregap == 0 ) StopCdda(); + StopCdda(); + SetPlaySeekRead(cdr.StatP, 0); + cdr.DriveState = DRIVESTATE_PAUSED; } + else if ((cdr.Mode & MODE_REPORT) && !cdr.ReportDelay && + ((cdr.subq.Absolute[2] & 0x0f) == 0 || cdr.FastForward || cdr.FastBackward)) + { + SetResultSize(8); + 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]; + cdr.Result[4] = cdr.subq.Relative[1] | 0x80; + cdr.Result[5] = cdr.subq.Relative[2]; + } + else { + cdr.Result[3] = cdr.subq.Absolute[0]; + cdr.Result[4] = cdr.subq.Absolute[1]; + cdr.Result[5] = cdr.subq.Absolute[2]; + } + cdr.Result[6] = abs_lev_max >> 0; + cdr.Result[7] = abs_lev_max >> 8; - // repair - if( cdr.CurTrack <= cdr.ResultTN[1] ) { - if( CDR_getTD(cdr.CurTrack, cdr.ResultTD) == -1 ) return; - } else { - // last track - cd size - if( CDR_getTD(0, cdr.ResultTD) == -1 ) return; + setIrq(DataReady, 0x1001); } - - temp_start[0] = cdr.ResultTD[2]; - temp_start[1] = cdr.ResultTD[1]; - temp_start[2] = cdr.ResultTD[0]; - - -#ifdef CDR_LOG - CDR_LOG( "CDDA FAKE SUB - %d:%d:%d / %d:%d:%d / %d:%d:%d\n", - temp_cur[0], temp_cur[1], temp_cur[2], - temp_start[0], temp_start[1], temp_start[2], - temp_next[0], temp_next[1], temp_next[2]); -#endif + if (cdr.ReportDelay) + cdr.ReportDelay--; +} +static int cdrSeekTime(unsigned char *target) +{ + int diff = msf2sec(cdr.SetSectorPlay) - msf2sec(target); + int seekTime = abs(diff) * (cdReadTime / 2000); + int cyclesSinceRS = psxRegs.cycle - cdr.LastReadSeekCycles; + seekTime = MAX_VALUE(seekTime, 20000); + + // Transformers Beast Wars Transmetals does Setloc(x),SeekL,Setloc(x),ReadN + // and then wants some slack time + if (cdr.DriveState == DRIVESTATE_PAUSED || cyclesSinceRS < cdReadTime *3/2) + seekTime += cdReadTime; + + seekTime = MIN_VALUE(seekTime, PSXCLK * 2 / 3); + CDR_LOG("seek: %.2f %.2f (%.2f) st %d di %d\n", (float)seekTime / PSXCLK, + (float)seekTime / cdReadTime, (float)cyclesSinceRS / cdReadTime, + cdr.DriveState, diff); + return seekTime; +} - // local time - pregap / real - diff = msf2sec(temp_cur) - msf2sec( temp_start ); - if( diff < 0 ) { - fake_subq_index = 0; +static u32 cdrAlignTimingHack(u32 cycles) +{ + /* + * timing hack for T'ai Fu - Wrath of the Tiger: + * The game has a bug where it issues some cdc commands from a low priority + * vint handler, however there is a higher priority default bios handler + * that acks the vint irq and returns, so game's handler is not reached + * (see bios irq handler chains at e004 and the game's irq handling func + * at 80036810). For the game to work, vint has to arrive after the bios + * vint handler rejects some other irq (of which only cd and rcnt2 are + * active), but before the game's handler loop reads I_STAT. The time + * window for this is quite small (~1k cycles of so). Apparently this + * somehow happens naturally on the real hardware. + * + * Note: always enforcing this breaks other games like Crash PAL version + * (inputs get dropped because bios handler doesn't see interrupts). + */ + u32 vint_rel; + if (psxRegs.cycle - rcnts[3].cycleStart > 250000) + return cycles; + vint_rel = rcnts[3].cycleStart + 63000 - psxRegs.cycle; + vint_rel += PSXCLK / 60; + while ((s32)(vint_rel - cycles) < 0) + vint_rel += PSXCLK / 60; + return vint_rel; +} - sec2msf( -diff, fake_subq_local ); - } else { - fake_subq_index = 1; +static void cdrUpdateTransferBuf(const u8 *buf); +static void cdrReadInterrupt(void); +static void cdrPrepCdda(s16 *buf, int samples); - sec2msf( diff, fake_subq_local ); +static void msfiAdd(u8 *msfi, u32 count) +{ + assert(count < 75); + msfi[2] += count; + if (msfi[2] >= 75) { + msfi[2] -= 75; + msfi[1]++; + if (msfi[1] == 60) { + msfi[1] = 0; + msfi[0]++; + } } } - -static void cdrPlayInterrupt_Autopause() +static void msfiSub(u8 *msfi, u32 count) { - struct SubQ *subq = (struct SubQ *)CDR_getBufferSub(); - int track_changed = 0; - if (subq != NULL ) { - // update subq - ReadTrack( cdr.SetSectorPlay ); - -#ifdef CDR_LOG - CDR_LOG( "CDDA SUB - %X:%X:%X\n", - subq->AbsoluteAddress[0], subq->AbsoluteAddress[1], subq->AbsoluteAddress[2] ); -#endif - - /* - CDDA Autopause + assert(count < 75); + msfi[2] -= count; + if ((s8)msfi[2] < 0) { + msfi[2] += 75; + msfi[1]--; + if ((s8)msfi[1] < 0) { + msfi[1] = 60; + msfi[0]--; + } + } +} - Silhouette Mirage ($3) - Tomb Raider 1 ($7) - */ +void cdrPlayReadInterrupt(void) +{ + int hit = CDR_prefetch(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]); + if (!hit && cdr.PhysCdPropagations++ < 222) { + // this propagates real cdrom delays to the emulated game + CDRPLAYREAD_INT(cdReadTime / 2, 0); + return; + } + cdr.PhysCdPropagations = 0; - if( cdr.CurTrack + 1 == btoi( subq->TrackNumber ) ) - track_changed = 1; - } else { - Create_Fake_Subq(); -#ifdef CDR_LOG___0 - CDR_LOG( "CDDA FAKE SUB - %d:%d:%d\n", - fake_subq_real[0], fake_subq_real[1], fake_subq_real[2] ); -#endif + cdr.LastReadSeekCycles = psxRegs.cycle; - track_changed = fake_subq_change; - fake_subq_change = 0; + if (cdr.Reading) { + cdrReadInterrupt(); + return; } - if ((cdr.Mode & MODE_AUTOPAUSE) && track_changed) { -#ifdef CDR_LOG - CDR_LOG( "CDDA STOP\n" ); -#endif - - // Magic the Gathering - // - looping territory cdda + if (!cdr.Play) return; - // ...? - //cdr.ResultReady = 1; - //cdr.Stat = DataReady; - cdr.Stat = DataEnd; - psxHu32ref(0x1070) |= SWAP32((u32)0x4); + CDR_LOG("CDDA - %02d:%02d:%02d m %02x\n", + cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], cdr.Mode); + cdr.DriveState = DRIVESTATE_PLAY_READ; + SetPlaySeekRead(cdr.StatP, STATUS_PLAY); + if (memcmp(cdr.SetSectorPlay, cdr.SetSectorEnd, 3) == 0) { + CDR_LOG_I("end stop\n"); StopCdda(); + SetPlaySeekRead(cdr.StatP, 0); + cdr.TrackChanged = TRUE; + cdr.DriveState = DRIVESTATE_PAUSED; + } + else { + CDR_readCDDA(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], (u8 *)read_buf); } - if (cdr.Mode & MODE_REPORT) { - if (subq != NULL) { -#ifdef CDR_LOG - CDR_LOG( "REPPLAY SUB - %X:%X:%X\n", - subq->AbsoluteAddress[0], subq->AbsoluteAddress[1], subq->AbsoluteAddress[2] ); -#endif - cdr.CurTrack = btoi( subq->TrackNumber ); - - if (subq->AbsoluteAddress[2] & 0xf) - return; - cdr.Result[0] = cdr.StatP; - // BIOS CD Player: data already BCD format - cdr.Result[1] = subq->TrackNumber; - cdr.Result[2] = subq->IndexNumber; - - cdr.Result[3] = subq->AbsoluteAddress[0]; - cdr.Result[4] = subq->AbsoluteAddress[1]; - cdr.Result[5] = subq->AbsoluteAddress[2]; - } else { -#ifdef CDR_LOG___0 - CDR_LOG( "REPPLAY FAKE - %d:%d:%d\n", - fake_subq_real[0], fake_subq_real[1], fake_subq_real[2] ); -#endif + if (!cdr.IrqStat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT))) + cdrPlayInterrupt_Autopause(); - if (fake_subq_real[2] & 0xf) - return; + if (cdr.Play && !Config.Cdda) { + cdrPrepCdda(read_buf, CD_FRAMESIZE_RAW / 4); + SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW, psxRegs.cycle, 0); + } - cdr.Result[0] = cdr.StatP; - // track # / index # - cdr.Result[1] = itob(cdr.CurTrack); - cdr.Result[2] = itob(fake_subq_index); - // absolute - cdr.Result[3] = itob( fake_subq_real[0] ); - cdr.Result[4] = itob( fake_subq_real[1] ); - cdr.Result[5] = itob( fake_subq_real[2] ); - } + msfiAdd(cdr.SetSectorPlay, 1); + CDR_prefetch(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]); - // Rayman: Logo freeze (resultready + dataready) - cdr.ResultReady = 1; - cdr.Stat = DataReady; + // update for CdlGetlocP/autopause + generate_subq(cdr.SetSectorPlay); - SetResultSize(8); - psxHu32ref(0x1070) |= SWAP32((u32)0x4); - } + CDRPLAYREAD_INT(cdReadTime, 0); } -void cdrPlayInterrupt() +static void softReset(void) { - if( !cdr.Play ) return; - -#ifdef CDR_LOG - CDR_LOG( "CDDA - %d:%d:%d\n", - cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] ); -#endif - CDRPLAY_INT( cdReadTime ); - - if (!cdr.Irq && !cdr.Stat && (cdr.Mode & MODE_CDDA) && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT))) - cdrPlayInterrupt_Autopause(); - - cdr.SetSectorPlay[2]++; - if (cdr.SetSectorPlay[2] == 75) { - cdr.SetSectorPlay[2] = 0; - cdr.SetSectorPlay[1]++; - if (cdr.SetSectorPlay[1] == 60) { - cdr.SetSectorPlay[1] = 0; - cdr.SetSectorPlay[0]++; - } + CDR_getStatus(&stat); + if (stat.Status & STATUS_SHELLOPEN) { + cdr.DriveState = DRIVESTATE_LID_OPEN; + cdr.StatP = STATUS_SHELLOPEN; + } + else if (CdromId[0] == '\0') { + cdr.DriveState = DRIVESTATE_STOPPED; + cdr.StatP = 0; + } + else { + cdr.DriveState = DRIVESTATE_STANDBY; + cdr.StatP = STATUS_ROTATING; } - //Check_Shell(0); + cdr.FifoOffset = DATA_SIZE; // fifo empty + cdr.LocL[0] = LOCL_INVALID; + cdr.Mode = MODE_SIZE_2340; + cdr.Muted = FALSE; + SPU_setCDvol(cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight, + cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight, psxRegs.cycle); } -void cdrInterrupt() { +#define CMD_PART2 0x100 +#define CMD_WHILE_NOT_READY 0x200 + +void cdrInterrupt(void) { + int start_rotating = 0; + int error = 0; + u32 cycles, seekTime = 0; + u32 second_resp_time = 0; + const void *buf; + u8 ParamC; + u8 set_loc[3]; + int read_ok; + u16 not_ready = 0; + u8 IrqStat = Acknowledge; + u8 DriveStateOld; + u16 Cmd; int i; - unsigned char Irq = cdr.Irq; - struct SubQ *subq; - // Reschedule IRQ - if (cdr.Stat) { - CDR_INT( 0x100 ); + if (cdr.IrqStat) { + CDR_LOG_I("cmd %02x with irqstat %x\n", + cdr.CmdInProgress, cdr.IrqStat); + return; + } + if (cdr.Irq1Pending) { + // hand out the "newest" sector, according to nocash + cdrUpdateTransferBuf(CDR_getBuffer()); + CDR_LOG_I("%x:%02x:%02x loaded on ack, cmd=%02x res=%02x\n", + cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2], + cdr.CmdInProgress, cdr.Irq1Pending); + SetResultSize(1); + cdr.Result[0] = cdr.Irq1Pending; + cdr.Irq1Pending = 0; + setIrq((cdr.Irq1Pending & STATUS_ERROR) ? DiskError : DataReady, 0x1003); return; } - cdr.Irq = 0xff; - cdr.Ctrl &= ~0x80; + // default response + SetResultSize(1); + cdr.Result[0] = cdr.StatP; - switch (Irq) { - case CdlSync: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + Cmd = cdr.CmdInProgress; + cdr.CmdInProgress = 0; + ParamC = cdr.ParamC; + + if (Cmd < 0x100) { + cdr.Ctrl &= ~0x80; + cdr.ParamC = 0; + cdr.Cmd = 0; + } + + switch (cdr.DriveState) { + case DRIVESTATE_PREPARE_CD: + if (Cmd > 2) { + // Syphon filter 2 expects commands to work shortly after it sees + // STATUS_ROTATING, so give up trying to emulate the startup seq + cdr.DriveState = DRIVESTATE_STANDBY; + cdr.StatP &= ~STATUS_SEEK; + psxRegs.interrupt &= ~(1 << PSXINT_CDRLID); break; + } + // fallthrough + case DRIVESTATE_LID_OPEN: + case DRIVESTATE_RESCAN_CD: + // no disk or busy with the initial scan, allowed cmds are limited + not_ready = CMD_WHILE_NOT_READY; + break; + } + switch (Cmd | not_ready) { case CdlNop: - SetResultSize(1); - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; - - if (cdr.LidCheck == 0) cdr.LidCheck = 0x20; + 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: // or is it? + 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_I("Invalid/out of range seek to %02X:%02X:%02X\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]); + if (++cdr.errorRetryhack > 100) + break; + error = ERROR_BAD_ARGNUM; + 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; + cdr.errorRetryhack = 0; + } break; + do_CdlPlay: case CdlPlay: - fake_subq_change = 0; + StopCdda(); + StopReading(); + + cdr.FastBackward = 0; + cdr.FastForward = 0; + + // BIOS CD Player + // - Pause player, hit Track 01/02/../xx (Setloc issued!!) - if( cdr.Seeked == FALSE ) { - memcpy( cdr.SetSectorPlay, cdr.SetSector, 4 ); - cdr.Seeked = TRUE; + if (ParamC != 0 && cdr.Param[0] != 0) { + int track = btoi( cdr.Param[0] ); + + if (track <= cdr.ResultTN[1]) + cdr.CurTrack = track; + + CDR_LOG("PLAY track %d\n", cdr.CurTrack); + + if (CDR_getTD((u8)cdr.CurTrack, cdr.ResultTD) != -1) { + 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 @@ -714,340 +875,239 @@ void cdrInterrupt() { Wild 9: skip PREGAP + starting accurate SubQ - plays tracks without retry play */ - /* unneeded with correct cdriso? - Set_Track(); - */ - Find_CurTrack(); - ReadTrack( cdr.SetSectorPlay ); - - // GameShark CD Player: Calls 2x + Play 2x - if( cdr.FastBackward || cdr.FastForward ) { - if( cdr.FastForward ) cdr.FastForward--; - if( cdr.FastBackward ) cdr.FastBackward--; - - if( cdr.FastBackward == 0 && cdr.FastForward == 0 ) { - if( cdr.Play && CDR_getStatus(&stat) != -1 ) { - cdr.SetSectorPlay[0] = stat.Time[0]; - cdr.SetSectorPlay[1] = stat.Time[1]; - cdr.SetSectorPlay[2] = stat.Time[2]; - } - } - } + Find_CurTrack(cdr.SetSectorPlay); + generate_subq(cdr.SetSectorPlay); + cdr.LocL[0] = LOCL_INVALID; + cdr.SubqForwardSectors = 1; + cdr.TrackChanged = FALSE; + cdr.FileChannelSelected = 0; + cdr.AdpcmActive = 0; + cdr.ReportDelay = 60; + cdr.sectorsRead = 0; + + if (!Config.Cdda) + CDR_play(cdr.SetSectorPlay); + + SetPlaySeekRead(cdr.StatP, STATUS_SEEK | STATUS_ROTATING); + + // BIOS player - set flag again + cdr.Play = TRUE; + cdr.DriveState = DRIVESTATE_PLAY_READ; + CDRPLAYREAD_INT(cdReadTime + seekTime, 1); + start_rotating = 1; + break; - if (!Config.Cdda) { - // BIOS CD Player - // - Pause player, hit Track 01/02/../xx (Setloc issued!!) + case CdlForward: + // TODO: error 80 if stopped + IrqStat = Complete; - // GameShark CD Player: Resume play - if( cdr.ParamC == 0 ) { -#ifdef CDR_LOG___0 - CDR_LOG( "PLAY Resume @ %d:%d:%d\n", - cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] ); -#endif + // GameShark CD Player: Calls 2x + Play 2x + cdr.FastForward = 1; + cdr.FastBackward = 0; + break; - //CDR_play( cdr.SetSectorPlay ); - } - else - { - // BIOS CD Player: Resume play - if( cdr.Param[0] == 0 ) { -#ifdef CDR_LOG___0 - CDR_LOG( "PLAY Resume T0 @ %d:%d:%d\n", - cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] ); -#endif + case CdlBackward: + IrqStat = Complete; - //CDR_play( cdr.SetSectorPlay ); - } - else { -#ifdef CDR_LOG___0 - CDR_LOG( "PLAY Resume Td @ %d:%d:%d\n", - cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] ); -#endif - - // BIOS CD Player: Allow track replaying - StopCdda(); - - - cdr.CurTrack = btoi( cdr.Param[0] ); - - if (CDR_getTN(cdr.ResultTN) != -1) { - // check last track - if (cdr.CurTrack > cdr.ResultTN[1]) - cdr.CurTrack = cdr.ResultTN[1]; - - 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]; - - // reset data - Set_Track(); - Find_CurTrack(); - ReadTrack( cdr.SetSectorPlay ); + // GameShark CD Player: Calls 2x + Play 2x + cdr.FastBackward = 1; + cdr.FastForward = 0; + break; - //CDR_play(cdr.SetSectorPlay); - } - } - } - } + case CdlStandby: + if (cdr.DriveState != DRIVESTATE_STOPPED) { + error = ERROR_BAD_ARGNUM; + goto set_error; } - - - // Vib Ribbon: gameplay checks flag - cdr.StatP &= ~STATUS_SEEK; - - - cdr.CmdProcess = 0; - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; - - cdr.StatP |= STATUS_PLAY; - - - // BIOS player - set flag again - cdr.Play = TRUE; - - CDRPLAY_INT( cdReadTime ); + cdr.DriveState = DRIVESTATE_STANDBY; + second_resp_time = cdReadTime * 125 / 2; + start_rotating = 1; break; - case CdlForward: - 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.FastForward == 0 ) cdr.FastForward = 2; - else cdr.FastForward++; - - cdr.FastBackward = 0; + case CdlStandby + CMD_PART2: + IrqStat = Complete; break; - case CdlBackward: - cdr.CmdProcess = 0; - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Complete; + case CdlStop: + 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]; + } - // GameShark CD Player: Calls 2x + Play 2x - if( cdr.FastBackward == 0 ) cdr.FastBackward = 2; - else cdr.FastBackward++; + StopCdda(); + StopReading(); + SetPlaySeekRead(cdr.StatP, 0); + cdr.StatP &= ~STATUS_ROTATING; + cdr.LocL[0] = LOCL_INVALID; - cdr.FastForward = 0; - break; + second_resp_time = 0x800; + if (cdr.DriveState != DRIVESTATE_STOPPED) + second_resp_time = cdReadTime * 30 / 2; - case CdlStandby: - cdr.CmdProcess = 0; - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Complete; + cdr.DriveState = DRIVESTATE_STOPPED; break; - case CdlStop: - cdr.CmdProcess = 0; - SetResultSize(1); - cdr.StatP &= ~STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Complete; -// cdr.Stat = Acknowledge; - - if (cdr.LidCheck == 0) cdr.LidCheck = 0x20; + case CdlStop + CMD_PART2: + IrqStat = Complete; break; case CdlPause: - SetResultSize(1); - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; - - /* - Gundam Battle Assault 2: much slower (*) - - Fixes boot, gameplay + if (cdr.AdpcmActive) { + cdr.AdpcmActive = 0; + cdr.Xa.nsamples = 0; + SPU_playADPCMchannel(&cdr.Xa, psxRegs.cycle, 1); // flush adpcm + } + StopCdda(); + StopReading(); - Hokuto no Ken 2: slower - - Fixes intro + subtitles + // how the drive maintains the position while paused is quite + // complicated, this is the minimum to make "Bedlam" happy + msfiSub(cdr.SetSectorPlay, MIN_VALUE(cdr.sectorsRead, 4)); + cdr.sectorsRead = 0; - InuYasha - Feudal Fairy Tale: slower - - Fixes battles + /* + Gundam Battle Assault 2 + Hokuto no Ken 2 + InuYasha - Feudal Fairy Tale + Dance Dance Revolution Konamix + ... */ - AddIrqQueue(CdlPause + 0x20, cdReadTime * 3); - cdr.Ctrl |= 0x80; + if (!(cdr.StatP & (STATUS_PLAY | STATUS_READ))) + { + second_resp_time = 7000; + } + else + { + second_resp_time = 2 * 1097107; + } + SetPlaySeekRead(cdr.StatP, 0); + DriveStateOld = cdr.DriveState; + cdr.DriveState = DRIVESTATE_PAUSED; + if (DriveStateOld == DRIVESTATE_SEEK) { + // According to Duckstation this fails, but the + // exact conditions and effects are not clear. + // Moto Racer World Tour seems to rely on this. + // For now assume pause works anyway, just errors out. + error = ERROR_NOTREADY; + goto set_error; + } break; - case CdlPause + 0x20: - SetResultSize(1); - cdr.StatP &= ~STATUS_READ; - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Complete; + case CdlPause + CMD_PART2: + IrqStat = 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; - cdr.Stat = Complete; - cdr.Init = 1; + case CdlReset: + case CdlReset + CMD_WHILE_NOT_READY: + // note: nocash and Duckstation calls this 'Init', but + // the official SDK calls it 'Reset', and so do we + StopCdda(); + StopReading(); + softReset(); + second_resp_time = not_ready ? 70000 : 4100000; + start_rotating = 1; + break; + + case CdlReset + CMD_PART2: + case CdlReset + CMD_PART2 + CMD_WHILE_NOT_READY: + IrqStat = Complete; break; case CdlMute: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + cdr.Muted = TRUE; + SPU_setCDvol(0, 0, 0, 0, psxRegs.cycle); break; case CdlDemute: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + cdr.Muted = FALSE; + SPU_setCDvol(cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight, + cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight, psxRegs.cycle); break; case CdlSetfilter: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + cdr.FilterFile = cdr.Param[0]; + cdr.FilterChannel = cdr.Param[1]; + cdr.FileChannelSelected = 0; 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.FilterFile; + cdr.Result[4] = cdr.FilterChannel; break; case CdlGetlocL: - SetResultSize(8); - for (i = 0; i < 8; i++) - cdr.Result[i] = cdr.Transfer[i]; - cdr.Stat = Acknowledge; + if (cdr.LocL[0] == LOCL_INVALID) { + error = 0x80; + goto set_error; + } + SetResultSize_(8); + memcpy(cdr.Result, cdr.LocL, 8); break; case CdlGetlocP: - // GameShark CDX CD Player: uses 17 bytes output (wraps around) - SetResultSize(17); - memset( cdr.Result, 0, 16 ); - - subq = (struct SubQ *)CDR_getBufferSub(); - - if (subq != NULL) { - // update subq - ReadTrack( cdr.SetSectorPlay ); - - cdr.Result[0] = subq->TrackNumber; - cdr.Result[1] = subq->IndexNumber; - memcpy(cdr.Result + 2, subq->TrackRelativeAddress, 3); - memcpy(cdr.Result + 5, subq->AbsoluteAddress, 3); - - - // subQ integrity check - data only (skip audio) - if( subq->TrackNumber == 1 && stat.Type == 0x01 ) { - if (calcCrc((u8 *)subq + 12, 10) != (((u16)subq->CRC[0] << 8) | subq->CRC[1])) { - memset(cdr.Result + 2, 0, 3 + 3); // CRC wrong, wipe out time data - } - } - } else { - if( cdr.Play == FALSE || !(cdr.Mode & MODE_CDDA) || !(cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT)) ) - Create_Fake_Subq(); - - - // track # / index # - cdr.Result[0] = itob(cdr.CurTrack); - cdr.Result[1] = itob(fake_subq_index); - - // local - cdr.Result[2] = itob( fake_subq_local[0] ); - cdr.Result[3] = itob( fake_subq_local[1] ); - cdr.Result[4] = itob( fake_subq_local[2] ); - - // absolute - cdr.Result[5] = itob( fake_subq_real[0] ); - cdr.Result[6] = itob( fake_subq_real[1] ); - cdr.Result[7] = itob( fake_subq_real[2] ); - } + SetResultSize_(8); + memcpy(&cdr.Result, &cdr.subq, 8); + break; - // redump.org - wipe time - if( !cdr.Play && CheckSBI(cdr.Result+5) ) { - memset( cdr.Result+2, 0, 6 ); - } + case CdlReadT: // SetSession? + // really long + second_resp_time = cdReadTime * 290 / 4; + start_rotating = 1; + break; - cdr.Stat = Acknowledge; + case CdlReadT + CMD_PART2: + IrqStat = Complete; break; case CdlGetTN: - // 5-Star Racing: don't stop CDDA - // - // Vib Ribbon: CD swap - StopReading(); - - 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; - } else { - cdr.Stat = Acknowledge; - cdr.Result[1] = itob(cdr.ResultTN[0]); - cdr.Result[2] = itob(cdr.ResultTN[1]); + assert(0); } + SetResultSize_(3); + cdr.Result[1] = itob(cdr.ResultTN[0]); + cdr.Result[2] = itob(cdr.ResultTN[1]); 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; - } else { - cdr.Stat = Acknowledge; - 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]); + error = ERROR_BAD_ARGVAL; + goto set_error; } + SetResultSize_(3); + cdr.Result[1] = itob(cdr.ResultTD[2]); + cdr.Result[2] = itob(cdr.ResultTD[1]); + // no sector number + //cdr.Result[3] = itob(cdr.ResultTD[0]); break; case CdlSeekL: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.StatP |= STATUS_SEEK; - cdr.Stat = Acknowledge; + case CdlSeekP: + StopCdda(); + StopReading(); + SetPlaySeekRead(cdr.StatP, STATUS_SEEK | STATUS_ROTATING); + seekTime = cdrSeekTime(cdr.SetSector); + memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); + cdr.DriveState = DRIVESTATE_SEEK; + CDR_prefetch(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], + cdr.SetSectorPlay[2]); /* Crusaders of Might and Magic = 0.5x-4x - fix cutscene speech start @@ -1061,343 +1121,298 @@ void cdrInterrupt() { Rockman X5 = 0.5-4x - fix capcom logo */ - AddIrqQueue(CdlSeekL + 0x20, cdReadTime * 4); - break; - - case CdlSeekL + 0x20: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.StatP &= ~STATUS_SEEK; - cdr.Result[0] = cdr.StatP; - cdr.Seeked = TRUE; - cdr.Stat = Complete; - - - // Mega Man Legends 2: must update read cursor for getlocp - ReadTrack( cdr.SetSector ); + second_resp_time = cdReadTime + seekTime; + start_rotating = 1; break; - case CdlSeekP: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; + case CdlSeekL + CMD_PART2: + case CdlSeekP + CMD_PART2: + SetPlaySeekRead(cdr.StatP, 0); cdr.Result[0] = cdr.StatP; - cdr.StatP |= STATUS_SEEK; - cdr.Stat = Acknowledge; - AddIrqQueue(CdlSeekP + 0x20, cdReadTime * 1); - break; - - case CdlSeekP + 0x20: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.StatP &= ~STATUS_SEEK; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Complete; - cdr.Seeked = TRUE; - - // GameShark Music Player - memcpy( cdr.SetSectorPlay, cdr.SetSector, 4 ); - - // Tomb Raider 2: must update read cursor for getlocp - Find_CurTrack(); - ReadTrack( cdr.SetSectorPlay ); + IrqStat = Complete; + + Find_CurTrack(cdr.SetSectorPlay); + read_ok = ReadTrack(cdr.SetSectorPlay); + if (read_ok && (buf = CDR_getBuffer())) + memcpy(cdr.LocL, buf, 8); + UpdateSubq(cdr.SetSectorPlay); + cdr.DriveState = DRIVESTATE_STANDBY; + cdr.TrackChanged = FALSE; + cdr.LastReadSeekCycles = psxRegs.cycle; break; case CdlTest: - cdr.Stat = Acknowledge; + case CdlTest + CMD_WHILE_NOT_READY: switch (cdr.Param[0]) { case 0x20: // System Controller ROM Version - SetResultSize(4); + SetResultSize_(4); memcpy(cdr.Result, Test20, 4); break; case 0x22: - SetResultSize(8); + SetResultSize_(8); memcpy(cdr.Result, Test22, 4); break; case 0x23: case 0x24: - SetResultSize(8); + SetResultSize_(8); memcpy(cdr.Result, Test23, 4); break; } 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: - SetResultSize(8); + case CdlID + CMD_PART2: + SetResultSize_(8); + cdr.Result[0] = cdr.StatP; + cdr.Result[1] = 0; + cdr.Result[2] = 0; + cdr.Result[3] = 0; - if (CDR_getStatus(&stat) == -1) { - cdr.Result[0] = 0x00; // 0x08 and cdr.Result[1]|0x10 : audio cd, enters cd player - cdr.Result[1] = 0x80; // 0x80 leads to the menu in the bios, else loads CD + // 0x10 - audio | 0x40 - disk missing | 0x80 - unlicensed + if (CDR_getStatus(&stat) == -1 || stat.Type == 0 || stat.Type == 0xff) { + cdr.Result[1] = 0xc0; } else { - if (stat.Type == 2) { - // Music CD - cdr.Result[0] = 0x08; - cdr.Result[1] = 0x10; - + if (stat.Type == 2) + cdr.Result[1] |= 0x10; + if (CdromId[0] == '\0') cdr.Result[1] |= 0x80; - } - else { - // Data CD - if (CdromId[0] == '\0') { - cdr.Result[0] = 0x00; - cdr.Result[1] = 0x80; - } - else { - cdr.Result[0] = 0x08; - cdr.Result[1] = 0x00; - } - } } + cdr.Result[0] |= (cdr.Result[1] >> 4) & 0x08; + CDR_LOG_I("CdlID: %02x %02x %02x %02x\n", cdr.Result[0], + cdr.Result[1], cdr.Result[2], cdr.Result[3]); - cdr.Result[2] = 0x00; - cdr.Result[3] = 0x00; - strncpy((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; + /* This adds the string "PCSX" in Playstation bios boot screen */ + memcpy((char *)&cdr.Result[4], "PCSX", 4); + IrqStat = Complete; 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; + set_event(PSXINT_CDRLID, 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, 0x800); + case CdlReadToc + CMD_WHILE_NOT_READY: + cdr.LocL[0] = LOCL_INVALID; + second_resp_time = cdReadTime * 180 / 4; + start_rotating = 1; break; - case CdlReadToc + 0x20: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Complete; + case CdlReadToc + CMD_PART2: + case CdlReadToc + CMD_PART2 + CMD_WHILE_NOT_READY: + IrqStat = Complete; break; - case AUTOPAUSE: - cdr.OCUP = 0; -/* SetResultSize(1); - StopCdda(); - StopReading(); - cdr.OCUP = 0; - cdr.StatP&=~0x20; - cdr.StatP|= 0x2; - cdr.Result[0] = cdr.StatP; - cdr.Stat = DataEnd; -*/ AddIrqQueue(CdlPause, 0x800); - break; - - case READ_ACK: - if (!cdr.Reading) return; - - - // Fighting Force 2 - update subq time immediately - // - fixes new game - ReadTrack( cdr.SetSector ); - - - // Crusaders of Might and Magic - update getlocl now - // - fixes cutscene speech - { - u8 *buf = CDR_getBuffer(); - if (buf != NULL) - memcpy(cdr.Transfer, buf, 8); - } - - - /* - 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) { - cdr.Seeked = TRUE; - - cdr.StatP |= STATUS_SEEK; - cdr.StatP &= ~STATUS_READ; + case CdlReadN: + case CdlReadS: + if (cdr.Reading && !cdr.SetlocPending) + break; - // Crusaders of Might and Magic - use short time - // - fix cutscene speech (startup) + Find_CurTrack(cdr.SetlocPending ? cdr.SetSector : cdr.SetSectorPlay); - // ??? - use more accurate seek time later - CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1); - } else { - cdr.StatP |= STATUS_READ; - cdr.StatP &= ~STATUS_SEEK; + if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1) + // Read* acts as play for cdda tracks in cdda mode + goto do_CdlPlay; - CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1); + StopCdda(); + if (cdr.SetlocPending) { + seekTime = cdrSeekTime(cdr.SetSector); + memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); + cdr.SetlocPending = 0; } + cdr.Reading = 1; + cdr.FileChannelSelected = 0; + cdr.AdpcmActive = 0; - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + // Fighting Force 2 - update subq time immediately + // - fixes new game + UpdateSubq(cdr.SetSectorPlay); + cdr.LocL[0] = LOCL_INVALID; + cdr.SubqForwardSectors = 1; + cdr.sectorsRead = 0; + cdr.DriveState = DRIVESTATE_SEEK; + CDR_prefetch(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], + cdr.SetSectorPlay[2]); + + cycles = (cdr.Mode & MODE_SPEED) ? cdReadTime : cdReadTime * 2; + cycles += seekTime; + if (Config.hacks.cdr_read_timing) + cycles = cdrAlignTimingHack(cycles); + CDRPLAYREAD_INT(cycles, 1); + + SetPlaySeekRead(cdr.StatP, STATUS_SEEK); + start_rotating = 1; break; - case 0xff: - return; - + case CdlSync: default: - cdr.Stat = Complete; + error = ERROR_INVALIDCMD; + // FALLTHROUGH + + set_error: + SetResultSize_(2); + cdr.Result[0] = cdr.StatP | STATUS_ERROR; + cdr.Result[1] = not_ready ? ERROR_NOTREADY : error; + IrqStat = DiskError; + CDR_LOG_I("cmd %02x error %02x\n", Cmd, cdr.Result[1]); break; } - Check_Shell( Irq ); - - cdr.ParamP = 0; - cdr.ParamC = 0; + if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) { + cdr.DriveState = DRIVESTATE_STANDBY; + cdr.StatP |= STATUS_ROTATING; + } - if (cdr.Stat != NoIntr && cdr.Reg2 != 0x18) { - psxHu32ref(0x1070) |= SWAP32((u32)0x4); + if (second_resp_time) { + cdr.CmdInProgress = Cmd | 0x100; + set_event(PSXINT_CDR, second_resp_time); + } + else if (cdr.Cmd && cdr.Cmd != (Cmd & 0xff)) { + cdr.CmdInProgress = cdr.Cmd; + CDR_LOG_I("cmd %02x came before %02x finished\n", cdr.Cmd, Cmd); } -#ifdef CDR_LOG - CDR_LOG("cdrInterrupt() Log: CDR Interrupt IRQ %x\n", Irq); -#endif + setIrq(IrqStat, Cmd); } -void cdrReadInterrupt() { - u8 *buf; - - if (!cdr.Reading) - return; +#ifdef HAVE_ARMV7 + #define ssat32_to_16(v) \ + asm("ssat %0,#16,%1" : "=r" (v) : "r" (v)) +#else + #define ssat32_to_16(v) do { \ + if (v < -32768) v = -32768; \ + else if (v > 32767) v = 32767; \ + } while (0) +#endif - if (cdr.Irq || cdr.Stat) { - CDREAD_INT(0x100); - return; +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]); } - -#ifdef CDR_LOG - CDR_LOG("cdrReadInterrupt() Log: KEY END"); #endif +} - cdr.OCUP = 1; - SetResultSize(1); - cdr.StatP |= STATUS_READ|STATUS_ROTATING; - cdr.StatP &= ~STATUS_SEEK; - cdr.Result[0] = cdr.StatP; - - ReadTrack( cdr.SetSector ); - - buf = CDR_getBuffer(); - if (buf == NULL) - cdr.RErr = -1; - - if (cdr.RErr == -1) { -#ifdef CDR_LOG - fprintf(emuLog, "cdrReadInterrupt() Log: err\n"); -#endif - memset(cdr.Transfer, 0, DATA_SIZE); - cdr.Stat = DiskError; - cdr.Result[0] |= STATUS_ERROR; - CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime); +static void cdrReadInterruptSetResult(unsigned char result) +{ + if (cdr.IrqStat) { + CDR_LOG_I("%d:%02d:%02d irq miss, cmd=%02x irqstat=%02x\n", + cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], + cdr.CmdInProgress, cdr.IrqStat); + cdr.Irq1Pending = result; return; } + SetResultSize(1); + cdr.Result[0] = result; + setIrq((result & STATUS_ERROR) ? DiskError : DataReady, 0x1004); +} +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 %02x:%02x:%02x\n", + cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]); + if (cdr.FifoOffset < 2048 + 12) + CDR_LOG("FifoOffset(1) %d/%d\n", cdr.FifoOffset, cdr.FifoSize); +} +static void cdrReadInterrupt(void) +{ + const struct { u8 file, chan, mode, coding; } *subhdr; + const u8 *buf = NULL; + int deliver_data = 1; + u8 subqPos[3]; + int read_ok; + int is_start; + + memcpy(subqPos, cdr.SetSectorPlay, sizeof(subqPos)); + msfiAdd(subqPos, cdr.SubqForwardSectors); + UpdateSubq(subqPos); + if (cdr.SubqForwardSectors < SUBQ_FORWARD_SECTORS) { + cdr.SubqForwardSectors++; + CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0); + return; + } -#ifdef CDR_LOG - fprintf(emuLog, "cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]); -#endif - - if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA - // 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]; - } + // note: CdlGetlocL should work as soon as STATUS_READ is indicated + SetPlaySeekRead(cdr.StatP, STATUS_READ | STATUS_ROTATING); + cdr.DriveState = DRIVESTATE_PLAY_READ; + cdr.sectorsRead++; - 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); - - if (!ret) { - // only handle attenuator basic channel switch for now - if (cdr.Xa.stereo) { - int i; - if ((cdr.AttenuatorLeft[0] | cdr.AttenuatorLeft[1]) - && !(cdr.AttenuatorRight[0] | cdr.AttenuatorRight[1])) - { - for (i = 0; i < cdr.Xa.nsamples; i++) - cdr.Xa.pcm[i*2 + 1] = cdr.Xa.pcm[i*2]; - } - else if (!(cdr.AttenuatorLeft[0] | cdr.AttenuatorLeft[1]) - && (cdr.AttenuatorRight[0] | cdr.AttenuatorRight[1])) - { - for (i = 0; i < cdr.Xa.nsamples; i++) - cdr.Xa.pcm[i*2] = cdr.Xa.pcm[i*2 + 1]; - } - } + read_ok = ReadTrack(cdr.SetSectorPlay); + if (read_ok) + buf = CDR_getBuffer(); + if (buf == NULL) + read_ok = 0; - SPU_playADPCMchannel(&cdr.Xa); - cdr.FirstSector = 0; + if (!read_ok) { + CDR_LOG_I("cdrReadInterrupt() Log: err\n"); + cdrReadInterruptSetResult(cdr.StatP | STATUS_ERROR); + cdr.DriveState = DRIVESTATE_PAUSED; // ? + return; + } + memcpy(cdr.LocL, buf, 8); -#if 0 - // Crash Team Racing: music, speech - // - done using cdda decoded buffer (spu irq) - // - don't do here + if (!cdr.IrqStat && !cdr.Irq1Pending) + cdrUpdateTransferBuf(buf); - // signal ADPCM data ready - psxHu32ref(0x1070) |= SWAP32((u32)0x200); -#endif - } - else cdr.FirstSector = -1; + subhdr = (void *)(buf + 4); + do { + // try to process as adpcm + if (!(cdr.Mode & MODE_STRSND)) + break; + if (buf[3] != 2 || (subhdr->mode & 0x44) != 0x44) // or 0x64? + break; + CDR_LOG("f=%d m=%d %d,%3d | %d,%2d | %d,%2d\n", !!(cdr.Mode & MODE_SF), cdr.Muted, + subhdr->file, subhdr->chan, cdr.CurFile, cdr.CurChannel, cdr.FilterFile, cdr.FilterChannel); + if ((cdr.Mode & MODE_SF) && (subhdr->file != cdr.FilterFile || subhdr->chan != cdr.FilterChannel)) + break; + if (subhdr->chan & 0x80) { // ? + if (subhdr->chan != 0xff) + log_unhandled("adpcm %d:%d\n", subhdr->file, subhdr->chan); + break; } - } - - 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]++; + if (!cdr.FileChannelSelected) { + cdr.CurFile = subhdr->file; + cdr.CurChannel = subhdr->chan; + cdr.FileChannelSelected = 1; } - } + else if (subhdr->file != cdr.CurFile || subhdr->chan != cdr.CurChannel) + break; - cdr.Readed = 0; + // accepted as adpcm + deliver_data = 0; - // G-Police: Don't autopause ADPCM even if mode set (music) - if ((cdr.Transfer[4 + 2] & 0x80) && (cdr.Mode & MODE_AUTOPAUSE) && - (cdr.Transfer[4 + 2] & 0x4) != 0x4 ) { // EOF -#ifdef CDR_LOG - CDR_LOG("cdrReadInterrupt() Log: Autopausing read\n"); -#endif -// AddIrqQueue(AUTOPAUSE, 0x2000); - AddIrqQueue(CdlPause, 0x2000); - } - else { - CDREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime); - } + if (Config.Xa) + break; + is_start = !cdr.AdpcmActive; + cdr.AdpcmActive = !xa_decode_sector(&cdr.Xa, buf + 4, is_start); + if (cdr.AdpcmActive) + SPU_playADPCMchannel(&cdr.Xa, psxRegs.cycle, is_start); + } while (0); + + if ((cdr.Mode & MODE_SF) && (subhdr->mode & 0x44) == 0x44) // according to nocash + deliver_data = 0; /* Croc 2: $40 - only FORM1 (*) @@ -1405,607 +1420,251 @@ void cdrReadInterrupt() { Sim Theme Park - no adpcm at all (zero) */ - if( (cdr.Mode & MODE_STRSND) == 0 || (cdr.Transfer[4+2] & 0x4) != 0x4 ) { - cdr.Stat = DataReady; - } else { - // Breath of Fire 3 - fix inn sleeping - // Rockman X5 - no music restart problem - cdr.Stat = NoIntr; - } - psxHu32ref(0x1070) |= SWAP32((u32)0x4); + if (deliver_data) + cdrReadInterruptSetResult(cdr.StatP); + + msfiAdd(cdr.SetSectorPlay, 1); + CDR_prefetch(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]); - Check_Shell(0); + CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0); } /* cdrRead0: - bit 0 - 0 REG1 command send / 1 REG1 data read - bit 1 - 0 data transfer finish / 1 data transfer ready/in progress - bit 2 - unknown - bit 3 - unknown - bit 4 - unknown + bit 0,1 - reg index + bit 2 - adpcm active bit 5 - 1 result ready bit 6 - 1 dma ready bit 7 - 1 command being processed */ unsigned char cdrRead0(void) { - if (cdr.ResultReady) - cdr.Ctrl |= 0x20; - else - cdr.Ctrl &= ~0x20; + cdr.Ctrl &= ~0x24; + cdr.Ctrl |= cdr.AdpcmActive << 2; + cdr.Ctrl |= cdr.ResultReady << 5; - 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; -#ifdef CDR_LOG - CDR_LOG("cdrRead0() Log: CD0 Read: %x\n", cdr.Ctrl); -#endif + CDR_LOG_IO("cdr r0.sta: %02x\n", cdr.Ctrl); return psxHu8(0x1800) = cdr.Ctrl; } -/* -cdrWrite0: - 0 - to send a command / 1 - to get the result -*/ - void cdrWrite0(unsigned char rt) { -#ifdef CDR_LOG - CDR_LOG("cdrWrite0() Log: CD0 write: %x\n", rt); -#endif + CDR_LOG_IO("cdr w0.x.idx: %02x\n", rt); + cdr.Ctrl = (rt & 3) | (cdr.Ctrl & ~3); } unsigned char cdrRead1(void) { - if (cdr.ResultReady) { // && cdr.Ctrl & 0x1) { - // GameShark CDX CD Player: uses 17 bytes output (wraps around) + if ((cdr.ResultP & 0xf) < cdr.ResultC) psxHu8(0x1801) = cdr.Result[cdr.ResultP & 0xf]; - cdr.ResultP++; - if (cdr.ResultP == cdr.ResultC) - cdr.ResultReady = 0; - } else { + else psxHu8(0x1801) = 0; - } -#ifdef CDR_LOG - CDR_LOG("cdrRead1() Log: CD1 Read: %x\n", psxHu8(0x1801)); -#endif + cdr.ResultP++; + if (cdr.ResultP == cdr.ResultC) + cdr.ResultReady = 0; + + CDR_LOG_IO("cdr r1.x.rsp: %02x #%u\n", psxHu8(0x1801), cdr.ResultP - 1); + return psxHu8(0x1801); } void cdrWrite1(unsigned char rt) { - char set_loc[3]; - int i; + const char *rnames[] = { "0.cmd", "1.smd", "2.smc", "3.arr" }; (void)rnames; + CDR_LOG_IO("cdr w1.%s: %02x\n", rnames[cdr.Ctrl & 3], rt); -#ifdef CDR_LOG - CDR_LOG("cdrWrite1() Log: CD1 write: %x (%s)\n", rt, CmdName[rt]); -#endif - - - // Tekken: CDXA fade-out - if( (cdr.Ctrl & 3) == 3 ) { - cdr.AttenuatorRight[0] = rt; + switch (cdr.Ctrl & 3) { + case 0: + break; + case 3: + cdr.AttenuatorRightToRightT = rt; + return; + default: + return; } - -// psxHu8(0x1801) = rt; - cdr.Cmd = rt; - cdr.OCUP = 0; - -#ifdef CDRCMD_DEBUG - SysPrintf("cdrWrite1() Log: CD1 write: %x (%s)", rt, CmdName[rt]); +#ifdef CDR_LOG_CMD_IRQ + CDR_LOG_I("CD1 write: %x (%s)", 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]); - SysPrintf("}\n"); - } else { - SysPrintf("\n"); + SysPrintf("}"); } + SysPrintf(" @%08x\n", psxRegs.pc); #endif - if (cdr.Ctrl & 0x3) return; - cdr.ResultReady = 0; + cdr.Ctrl |= 0x80; - switch (cdr.Cmd) { - case CdlSync: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlNop: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - - // Twisted Metal 3 - fix music - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlSetloc: - StopReading(); - for (i = 0; i < 3; i++) - set_loc[i] = btoi(cdr.Param[i]); - i = abs(msf2sec(cdr.SetSector) - msf2sec(set_loc)); - if (i > 16) - cdr.Seeked = FALSE; - memcpy(cdr.SetSector, set_loc, 3); - cdr.SetSector[3] = 0; - - /* - if ((cdr.SetSector[0] | cdr.SetSector[1] | cdr.SetSector[2]) == 0) { - *(u32 *)cdr.SetSector = *(u32 *)cdr.SetSectorSeek; - }*/ - - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlPlay: - // Vib Ribbon: try same track again - StopCdda(); - - if (!cdr.SetSector[0] & !cdr.SetSector[1] & !cdr.SetSector[2]) { - if (CDR_getTN(cdr.ResultTN) != -1) { - if (cdr.CurTrack > cdr.ResultTN[1]) - cdr.CurTrack = cdr.ResultTN[1]; - if (CDR_getTD((unsigned char)(cdr.CurTrack), cdr.ResultTD) != -1) { - int tmp = cdr.ResultTD[2]; - cdr.ResultTD[2] = cdr.ResultTD[0]; - cdr.ResultTD[0] = tmp; - if (!Config.Cdda) CDR_play(cdr.ResultTD); - } - } - } else if (!Config.Cdda) { - CDR_play(cdr.SetSector); - } - - // Vib Ribbon - decoded buffer IRQ for CDDA reading - // - fixes ribbon timing + music CD mode - //TODO? - //CDRDBUF_INT( PSXCLK / 44100 * 0x100 ); - - - cdr.Play = TRUE; - - cdr.StatP |= STATUS_SEEK; - cdr.StatP &= ~STATUS_ROTATING; - - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlForward: - //if (cdr.CurTrack < 0xaa) - // cdr.CurTrack++; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlBackward: - //if (cdr.CurTrack > 1) - //cdr.CurTrack--; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlReadN: - cdr.Irq = 0; - StopReading(); - cdr.Ctrl|= 0x80; - cdr.Stat = NoIntr; - StartReading(1, 0x800); - break; - - case CdlStandby: - StopCdda(); - StopReading(); - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlStop: - // GameShark CD Player: Reset CDDA to track start - if( cdr.Play && CDR_getStatus(&stat) != -1 ) { - cdr.SetSectorPlay[0] = stat.Time[0]; - cdr.SetSectorPlay[1] = stat.Time[1]; - cdr.SetSectorPlay[2] = stat.Time[2]; - - Find_CurTrack(); - - - // 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(); - - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlPause: - /* - GameShark CD Player: save time for resume - - Twisted Metal - World Tour: don't mix Setloc / CdlPlay cursors - */ - - StopCdda(); - StopReading(); - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlReset: - case CdlInit: - StopCdda(); - StopReading(); - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlMute: - cdr.Muted = TRUE; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - - // 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; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - - // 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]; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlSetmode: -#ifdef CDR_LOG - CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]); -#endif - cdr.Mode = cdr.Param[0]; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - - // Squaresoft on PlayStation 1998 Collector's CD Vol. 1 - // - fixes choppy movie sound - if( cdr.Play && (cdr.Mode & MODE_CDDA) == 0 ) - StopCdda(); - break; - - case CdlGetmode: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlGetlocL: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - - // Crusaders of Might and Magic - cutscene speech - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlGetlocP: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - - // GameShark CDX / Lite Player: pretty narrow time window - // - doesn't always work due to time inprecision - //AddIrqQueue(cdr.Cmd, 0x28); - - // Tomb Raider 2 - cdda - //AddIrqQueue(cdr.Cmd, 0x40); - - // rearmed: the above works in pcsxr-svn, but breaks here - // (TOCA world touring cars), perhaps some other code is not merged yet - AddIrqQueue(cdr.Cmd, 0x1000); - break; - - case CdlGetTN: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - //AddIrqQueue(cdr.Cmd, 0x800); - - // GameShark CDX CD Player: very long time - AddIrqQueue(cdr.Cmd, 0x100000); - break; - - case CdlGetTD: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlSeekL: -// ((u32 *)cdr.SetSectorSeek)[0] = ((u32 *)cdr.SetSector)[0]; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - - StopCdda(); - StopReading(); - - break; - - case CdlSeekP: -// ((u32 *)cdr.SetSectorSeek)[0] = ((u32 *)cdr.SetSector)[0]; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - - // Tomb Raider 2 - reset cdda - StopCdda(); - StopReading(); - - AddIrqQueue(cdr.Cmd, 0x800); - break; - - // Destruction Derby: read TOC? GetTD after this - case CdlReadT: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlTest: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlID: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlReadS: - cdr.Irq = 0; - StopReading(); - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - StartReading(2, 0x800); - break; - - case CdlReadToc: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - default: - cdr.ParamP = 0; - cdr.ParamC = 0; -#ifdef CDR_LOG - CDR_LOG("cdrWrite1() Log: Unknown command: %x\n", cdr.Cmd); -#endif - return; + if (!cdr.CmdInProgress) { + cdr.CmdInProgress = rt; + // should be something like 12k + controller delays + set_event(PSXINT_CDR, 5000); } - if (cdr.Stat != NoIntr) { - psxHu32ref(0x1070) |= SWAP32((u32)0x4); + else { + CDR_LOG_I("cmd while busy: %02x, prev %02x, busy %02x\n", + 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 = cdr.Transfer[0x920]; - if (cdr.Readed == 0) { - ret = 0; - } else { - ret = *cdr.pTransfer++; - } + if (cdr.FifoOffset < cdr.FifoSize) + ret = cdr.Transfer[cdr.FifoOffset++]; + else + CDR_LOG_I("read empty fifo (%d)\n", cdr.FifoSize); -#ifdef CDR_LOG - CDR_LOG("cdrRead2() Log: CD2 Read: %x\n", ret); -#endif + CDR_LOG_IO("cdr r2.x.dat: %02x\n", ret); return ret; } void cdrWrite2(unsigned char rt) { -#ifdef CDR_LOG - CDR_LOG("cdrWrite2() Log: CD2 write: %x\n", rt); -#endif - - // Tekken: CDXA fade-out - if( (cdr.Ctrl & 3) == 2 ) { - cdr.AttenuatorLeft[0] = rt; - } - else if( (cdr.Ctrl & 3) == 3 ) { - cdr.AttenuatorRight[1] = rt; - } - + const char *rnames[] = { "0.prm", "1.ien", "2.all", "3.arl" }; (void)rnames; + CDR_LOG_IO("cdr w2.%s: %02x\n", rnames[cdr.Ctrl & 3], rt); - if (cdr.Ctrl & 0x1) { - switch (rt) { - case 0x07: - cdr.ParamP = 0; - cdr.ParamC = 0; - cdr.ResultReady = 1; //0; - cdr.Ctrl &= ~3; //cdr.Ctrl = 0; - break; - - default: - cdr.Reg2 = rt; - break; - } - } else if (!(cdr.Ctrl & 0x3) && cdr.ParamP < 8) { - cdr.Param[cdr.ParamP++] = rt; - cdr.ParamC++; + switch (cdr.Ctrl & 3) { + case 0: + if (cdr.ParamC < 8) // FIXME: size and wrapping + cdr.Param[cdr.ParamC++] = rt; + return; + case 1: + cdr.IrqMask = rt; + setIrq(cdr.IrqStat, 0x1005); + return; + case 2: + cdr.AttenuatorLeftToLeftT = rt; + return; + case 3: + cdr.AttenuatorRightToLeftT = rt; + return; } } unsigned char cdrRead3(void) { - if (cdr.Stat) { - if (cdr.Ctrl & 0x1) - psxHu8(0x1803) = cdr.Stat | 0xE0; - else - psxHu8(0x1803) = 0xff; - } else { - psxHu8(0x1803) = 0; - } -#ifdef CDR_LOG - CDR_LOG("cdrRead3() Log: CD3 Read: %x\n", psxHu8(0x1803)); -#endif + if (cdr.Ctrl & 0x1) + psxHu8(0x1803) = cdr.IrqStat | 0xE0; + else + psxHu8(0x1803) = cdr.IrqMask | 0xE0; + + CDR_LOG_IO("cdr r3.%d.%s: %02x\n", cdr.Ctrl & 3, + (cdr.Ctrl & 1) ? "ifl" : "ien", psxHu8(0x1803)); return psxHu8(0x1803); } void cdrWrite3(unsigned char rt) { -#ifdef CDR_LOG - CDR_LOG("cdrWrite3() Log: CD3 write: %x\n", rt); -#endif - - // Tekken: CDXA fade-out - if( (cdr.Ctrl & 3) == 2 ) { - cdr.AttenuatorLeft[1] = rt; - } - else if( (cdr.Ctrl & 3) == 3 && rt == 0x20 ) { -#ifdef CDR_LOG - CDR_LOG( "CD-XA Volume: %X %X | %X %X\n", - cdr.AttenuatorLeft[0], cdr.AttenuatorLeft[1], - cdr.AttenuatorRight[0], cdr.AttenuatorRight[1] ); + const char *rnames[] = { "0.req", "1.ifl", "2.alr", "3.ava" }; (void)rnames; + u8 ll, lr, rl, rr; + 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.IrqStat & rt) { + u32 nextCycle = psxRegs.intCycle[PSXINT_CDR].sCycle + + psxRegs.intCycle[PSXINT_CDR].cycle; + int pending = psxRegs.interrupt & (1 << PSXINT_CDR); +#ifdef CDR_LOG_CMD_IRQ + CDR_LOG_I("ack %02x (w=%02x p=%d,%x,%x,%d)\n", + cdr.IrqStat & rt, rt, !!pending, cdr.CmdInProgress, + cdr.Irq1Pending, nextCycle - psxRegs.cycle); #endif - } - - - // GameShark CDX CD Player: Irq timing mania - if( rt == 0 && - cdr.Irq != 0 && cdr.Irq != 0xff && - cdr.ResultReady == 0 ) { - - // GS CDX: ~0x28 cycle timing - way too precise - if( cdr.Irq == CdlGetlocP ) { - cdrInterrupt(); - - psxRegs.interrupt &= ~(1 << PSXINT_CDR); - } - } - - - if (rt == 0x07 && (cdr.Ctrl & 3) == 1) { - cdr.Stat = 0; - - if (cdr.Irq == 0xff) { - cdr.Irq = 0; - return; - } - - // XA streaming - incorrect timing because of this reschedule - // - Final Fantasy Tactics - // - various other games - - if (cdr.Reading && !cdr.ResultReady) { - int left = psxRegs.intCycle[PSXINT_CDREAD].sCycle + psxRegs.intCycle[PSXINT_CDREAD].cycle - psxRegs.cycle; - int time = (cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime; - if (Config.CdrReschedule != 2) - if (left < time / 2 || Config.CdrReschedule) { // rearmed guesswork hack - //printf("-- resched %d -> %d\n", left, time); - CDREAD_INT(time); + // note: Croc, Shadow Tower (more) vs Discworld Noir (<993) + if (!pending && (cdr.CmdInProgress || cdr.Irq1Pending)) + { + s32 c = 2048; + if (cdr.CmdInProgress) { + c = 2048 - (psxRegs.cycle - nextCycle); + c = MAX_VALUE(c, 512); + } + set_event(PSXINT_CDR, c); } } + cdr.IrqStat &= ~rt; + if (rt & 0x40) + cdr.ParamC = 0; + return; + case 2: + cdr.AttenuatorLeftToRightT = rt; + return; + case 3: + if (rt & 0x01) + log_unhandled("Mute ADPCM?\n"); + if (rt & 0x20) { + ll = cdr.AttenuatorLeftToLeftT; lr = cdr.AttenuatorLeftToRightT; + rl = cdr.AttenuatorRightToLeftT; rr = cdr.AttenuatorRightToRightT; + if (ll == cdr.AttenuatorLeftToLeft && + lr == cdr.AttenuatorLeftToRight && + rl == cdr.AttenuatorRightToLeft && + rr == cdr.AttenuatorRightToRight) + return; + cdr.AttenuatorLeftToLeft = ll; cdr.AttenuatorLeftToRight = lr; + cdr.AttenuatorRightToLeft = rl; cdr.AttenuatorRightToRight = rr; + CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n", ll, lr, rl, rr); + SPU_setCDvol(ll, lr, rl, rr, psxRegs.cycle); + } return; } - if (rt == 0x80 && !(cdr.Ctrl & 0x3) && cdr.Readed == 0) { - cdr.Readed = 1; - cdr.pTransfer = cdr.Transfer; - - switch (cdr.Mode & 0x30) { + // 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 & (MODE_SIZE_2328|MODE_SIZE_2340)) { case MODE_SIZE_2328: case 0x00: - cdr.pTransfer += 12; + cdr.FifoOffset = 12; + cdr.FifoSize = 2048 + 12; break; case MODE_SIZE_2340: - cdr.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) { - u32 cdsize; + u32 cdsize, max_words; int size; u8 *ptr; -#ifdef CDR_LOG - CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr); +#if 0 + CDR_LOG_I("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x", chcr, madr, bcr); + if (cdr.FifoOffset == 0) { + ptr = cdr.Transfer; + SysPrintf(" %02x:%02x:%02x", ptr[0], ptr[1], ptr[2]); + } + SysPrintf("\n"); #endif - switch (chcr) { + switch (chcr & 0x71000000) { case 0x11000000: - case 0x11400100: - if (cdr.Readed == 0) { -#ifdef CDR_LOG - CDR_LOG("psxDma3() Log: *** DMA 3 *** NOT READY\n"); -#endif + madr &= ~3; + ptr = getDmaRam(madr, &max_words); + if (ptr == INVALID_PTR) { + CDR_LOG_I("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n"); break; } - cdsize = (bcr & 0xffff) * 4; - - // Ape Escape: bcr = 0001 / 0000 - // - fix boot - if( cdsize == 0 ) - { - switch (cdr.Mode & 0x30) { - case 0x00: cdsize = 2048; break; - case MODE_SIZE_2328: cdsize = 2328; break; - case MODE_SIZE_2340: cdsize = 2340; break; - } - } - - - ptr = (u8 *)PSXM(madr); - if (ptr == NULL) { -#ifdef CPU_LOG - CDR_LOG("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n"); -#endif - break; - } + cdsize = (((bcr - 1) & 0xffff) + 1) * 4; /* GS CDX: Enhancement CD crash @@ -2013,31 +1672,37 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) { - CdlPlay - Spams DMA3 and gets buffer overrun */ - size = CD_FRAMESIZE_RAW - (cdr.pTransfer - cdr.Transfer); + size = DATA_SIZE - cdr.FifoOffset; if (size > cdsize) size = cdsize; + if (size > max_words * 4) + size = max_words * 4; if (size > 0) { - memcpy(ptr, cdr.pTransfer, size); + memcpy(ptr, cdr.Transfer + cdr.FifoOffset, size); + cdr.FifoOffset += size; + } + if (size < cdsize) { + CDR_LOG_I("cdrom: dma3 %d/%d\n", size, cdsize); + memset(ptr + size, cdr.Transfer[0x920], cdsize - size); } - psxCpu->Clear(madr, cdsize / 4); - cdr.pTransfer += cdsize; + set_event(PSXINT_CDRDMA, (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: -#ifdef CDR_LOG - CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr); -#endif + CDR_LOG_I("psxDma3() Log: Unknown cddma %x\n", chcr); break; } @@ -2045,7 +1710,7 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) { DMA_INTERRUPT(3); } -void cdrDmaInterrupt() +void cdrDmaInterrupt(void) { if (HW_DMA3_CHCR & SWAP32(0x01000000)) { @@ -2054,53 +1719,86 @@ void cdrDmaInterrupt() } } +static void getCdInfo(void) +{ + u8 tmp; + + CDR_getTN(cdr.ResultTN); + CDR_getTD(0, cdr.SetSectorEnd); + tmp = cdr.SetSectorEnd[0]; + cdr.SetSectorEnd[0] = cdr.SetSectorEnd[2]; + cdr.SetSectorEnd[2] = tmp; +} + void cdrReset() { memset(&cdr, 0, sizeof(cdr)); cdr.CurTrack = 1; - cdr.File = 1; - cdr.Channel = 1; + cdr.FilterFile = 0; + cdr.FilterChannel = 0; + cdr.IrqMask = 0x1f; + cdr.IrqStat = NoIntr; // BIOS player - default values - cdr.AttenuatorLeft[0] = 0x80; - cdr.AttenuatorLeft[1] = 0x00; - cdr.AttenuatorRight[0] = 0x80; - cdr.AttenuatorRight[1] = 0x00; -} + cdr.AttenuatorLeftToLeft = 0x80; + cdr.AttenuatorLeftToRight = 0x00; + cdr.AttenuatorRightToLeft = 0x00; + cdr.AttenuatorRightToRight = 0x80; -int cdrFreeze(gzFile f, int Mode) { - uintptr_t tmp; + softReset(); + getCdInfo(); +} +int cdrFreeze(void *f, int Mode) { + u32 tmp; + u8 tmpp[3]; - if( Mode == 0 ) { - StopCdda(); - } + if (Mode == 0 && !Config.Cdda) + CDR_stop(); + cdr.freeze_ver = 0x63647202; gzfreeze(&cdr, sizeof(cdr)); - if (Mode == 1) - tmp = cdr.pTransfer - cdr.Transfer; + if (Mode == 1) { + cdr.ParamP = cdr.ParamC; + tmp = cdr.FifoOffset; + } gzfreeze(&tmp, sizeof(tmp)); if (Mode == 0) { - cdr.pTransfer = cdr.Transfer + tmp; - - if (cdr.Play && !Config.Cdda) - CDR_play(cdr.SetSectorPlay); + u8 ll = 0, lr = 0, rl = 0, rr = 0; + getCdInfo(); + + cdr.FifoOffset = tmp < DATA_SIZE ? tmp : DATA_SIZE; + cdr.FifoSize = (cdr.Mode & MODE_SIZE_2340) ? 2340 : 2048 + 12; + if (cdr.SubqForwardSectors > SUBQ_FORWARD_SECTORS) + cdr.SubqForwardSectors = SUBQ_FORWARD_SECTORS; + + // read right sub data + 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 (!cdr.Muted) + ll = cdr.AttenuatorLeftToLeft, lr = cdr.AttenuatorLeftToLeft, + rl = cdr.AttenuatorRightToLeft, rr = cdr.AttenuatorRightToRight; + SPU_setCDvol(ll, lr, rl, rr, psxRegs.cycle); } return 0; } -void LidInterrupt() { - cdr.LidCheck = 0x20; // start checker - - 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); - } +void LidInterrupt(void) { + getCdInfo(); + cdrLidSeekInterrupt(); }