X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=libpcsxcore%2Fcdrom.c;h=3c016dfd2be1c8fd7c2fc35f3b1e77cb14a085bb;hb=f5450cfbaf8651524f23579832ddb5bc08fe545a;hp=016b9939c7a43e47ebbe42db7d1a95148bac2a57;hpb=2da09dae586e9677b0ff3bfc1ce746b9ea6c9479;p=pcsx_rearmed.git diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c index 016b9939..3c016dfd 100644 --- a/libpcsxcore/cdrom.c +++ b/libpcsxcore/cdrom.c @@ -44,7 +44,76 @@ #endif //#define CDR_LOG_CMD_IRQ -cdrStruct cdr; +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 Readed; + 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; + + u32 unused4; + + 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 unsigned char *pTransfer; static s16 read_buf[CD_FRAMESIZE_RAW/2]; @@ -81,7 +150,8 @@ static s16 read_buf[CD_FRAMESIZE_RAW/2]; #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", "CdlReset", "CdlMute", @@ -91,6 +161,7 @@ char *CmdName[0x100]= { "CdlGetclock", "CdlTest", "CdlID", "CdlReadS", "CdlInit", NULL, "CDlReadToc", NULL }; +#endif unsigned char Test04[] = { 0 }; unsigned char Test05[] = { 0 }; @@ -138,19 +209,13 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 }; #define cdReadTime (PSXCLK / 75) enum drive_state { - DRIVESTATE_STANDBY = 0, + DRIVESTATE_STANDBY = 0, // pause, play, read DRIVESTATE_LID_OPEN, DRIVESTATE_RESCAN_CD, DRIVESTATE_PREPARE_CD, DRIVESTATE_STOPPED, }; -// for cdr.Seeked -enum seeked_state { - SEEK_PENDING = 0, - SEEK_DONE = 1, -}; - static struct CdrStat stat; static unsigned int msf2sec(const u8 *msf) { @@ -178,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 @@ -194,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|STATUS_SEEK);\ + 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) { \ @@ -227,27 +286,40 @@ 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); + +#ifdef CDR_LOG_CMD_IRQ + if (cdr.Stat) + { + int i; + SysPrintf("CDR IRQ=%d cmd %02x stat %02x: ", + !!(cdr.Stat & cdr.Reg2), log_cmd, cdr.Stat); + for (i = 0; i < cdr.ResultC; i++) + SysPrintf("%02x ", cdr.Result[i]); + SysPrintf("\n"); + } +#endif } // 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 cdrLidSeekInterrupt(void) { switch (cdr.DriveState) { default: case DRIVESTATE_STANDBY: - cdr.StatP &= ~STATUS_SEEK; + StopCdda(); + StopReading(); + SetPlaySeekRead(cdr.StatP, 0); if (CDR_getStatus(&stat) == -1) return; if (stat.Status & STATUS_SHELLOPEN) { - StopCdda(); cdr.DriveState = DRIVESTATE_LID_OPEN; CDRLID_INT(0x800); } @@ -259,7 +331,6 @@ void cdrLidSeekInterrupt() // 02, 12, 10 if (!(cdr.StatP & STATUS_SHELLOPEN)) { - StopReading(); cdr.StatP |= STATUS_SHELLOPEN; // could generate error irq here, but real hardware @@ -413,23 +484,6 @@ static void ReadTrack(const u8 *time) { cdr.subq.Absolute[0], cdr.subq.Absolute[1], cdr.subq.Absolute[2]); } -static void AddIrqQueue(unsigned short irq, unsigned long ecycle) { - if (cdr.Irq != 0) { - if (irq == cdr.Irq || irq + 0x100 == cdr.Irq) { - cdr.IrqRepeated = 1; - CDR_INT(ecycle); - return; - } - - 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; @@ -446,12 +500,12 @@ static void cdrPlayInterrupt_Autopause() //cdr.ResultReady = 1; //cdr.Stat = DataReady; cdr.Stat = DataEnd; - setIrq(); + setIrq(0x200); StopCdda(); + SetPlaySeekRead(cdr.StatP, 0); } else if (((cdr.Mode & MODE_REPORT) || cdr.FastForward || cdr.FastBackward)) { - CDR_readCDDA(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], (u8 *)read_buf); cdr.Result[0] = cdr.StatP; cdr.Result[1] = cdr.subq.Track; cdr.Result[2] = cdr.subq.Index; @@ -485,37 +539,59 @@ static void cdrPlayInterrupt_Autopause() cdr.Stat = DataReady; SetResultSize(8); - setIrq(); + setIrq(0x201); } } -// also handles seek -void cdrPlayInterrupt() +static int cdrSeekTime(unsigned char *target) +{ + int seekTime = abs(msf2sec(cdr.SetSectorPlay) - msf2sec(target)) * (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 cdrReadInterrupt(void); + +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(0x202); - if (cdr.SetlocPending) { - memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); - cdr.SetlocPending = 0; - cdr.m_locationChanged = TRUE; - } Find_CurTrack(cdr.SetSectorPlay); ReadTrack(cdr.SetSectorPlay); cdr.TrackChanged = FALSE; + return; } if (!cdr.Play) return; @@ -523,20 +599,23 @@ 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_readCDDA && !cdr.Muted && cdr.Mode & MODE_REPORT) { + if (!cdr.Muted && !Config.Cdda) { cdrAttenuate(read_buf, CD_FRAMESIZE_RAW / 4, 1); - if (SPU_playCDDAchannel) - SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW); + SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW, psxRegs.cycle, cdr.FirstSector); + cdr.FirstSector = 0; } cdr.SetSectorPlay[2]++; @@ -549,34 +628,25 @@ void cdrPlayInterrupt() } } - if (cdr.m_locationChanged) - { - CDRMISC_INT(cdReadTime * 30); - cdr.m_locationChanged = FALSE; - } - else - { - CDRMISC_INT(cdReadTime); - } - // update for CdlGetlocP/autopause generate_subq(cdr.SetSectorPlay); + + CDRPLAYSEEKREAD_INT(cdReadTime, 0); } -void cdrInterrupt() { - u16 Irq = cdr.Irq; +void cdrInterrupt(void) { int no_busy_error = 0; int start_rotating = 0; int error = 0; - int delay; unsigned int seekTime = 0; + u32 second_resp_time = 0; + u8 ParamC; u8 set_loc[3]; + u16 Cmd; int i; - // Reschedule IRQ if (cdr.Stat) { - CDR_LOG_I("cdrom: stat hack: %02x %x\n", cdr.Irq, cdr.Stat); - CDR_INT(0x1000); + CDR_LOG_I("cdrom: cmd %02x with irqstat %x\n", cdr.CmdInProgress, cdr.Stat); return; } @@ -587,17 +657,16 @@ void cdrInterrupt() { cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; - if (cdr.IrqRepeated) { - cdr.IrqRepeated = 0; - if (cdr.eCycle > psxRegs.cycle) { - CDR_INT(cdr.eCycle); - goto finish; - } - } + Cmd = cdr.CmdInProgress; + cdr.CmdInProgress = 0; + ParamC = cdr.ParamC; - cdr.Irq = 0; + if (Cmd < 0x100) { + cdr.Cmd = 0; + cdr.ParamC = 0; + } - switch (Irq) { + switch (Cmd) { case CdlNop: if (cdr.DriveState != DRIVESTATE_LID_OPEN) cdr.StatP &= ~STATUS_SHELLOPEN; @@ -617,15 +686,7 @@ void cdrInterrupt() { else { for (i = 0; i < 3; i++) - { set_loc[i] = btoi(cdr.Param[i]); - } - - i = msf2sec(cdr.SetSectorPlay); - i = abs(i - msf2sec(set_loc)); - if (i > 16) - cdr.Seeked = SEEK_PENDING; - memcpy(cdr.SetSector, set_loc, 3); cdr.SetSector[3] = 0; cdr.SetlocPending = 1; @@ -635,29 +696,15 @@ void cdrInterrupt() { do_CdlPlay: case CdlPlay: StopCdda(); - if (cdr.Seeked == SEEK_PENDING) { - // XXX: wrong, should seek instead.. - cdr.Seeked = SEEK_DONE; - } - + StopReading(); + cdr.FastBackward = 0; cdr.FastForward = 0; - if (cdr.SetlocPending) { - memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); - cdr.SetlocPending = 0; - cdr.m_locationChanged = TRUE; - } - // 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]) @@ -666,11 +713,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 @@ -685,20 +742,17 @@ 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.Result[0] = cdr.StatP; - - 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; @@ -724,7 +778,7 @@ void cdrInterrupt() { error = ERROR_INVALIDARG; goto set_error; } - AddIrqQueue(CdlStandby + 0x100, cdReadTime * 125 / 2); + second_resp_time = cdReadTime * 125 / 2; start_rotating = 1; break; @@ -744,22 +798,23 @@ void cdrInterrupt() { StopCdda(); StopReading(); + SetPlaySeekRead(cdr.StatP, 0); + cdr.StatP &= ~STATUS_ROTATING; - delay = 0x800; + second_resp_time = 0x800; if (cdr.DriveState == DRIVESTATE_STANDBY) - delay = cdReadTime * 30 / 2; + second_resp_time = cdReadTime * 30 / 2; cdr.DriveState = DRIVESTATE_STOPPED; - AddIrqQueue(CdlStop + 0x100, delay); break; case CdlStop + 0x100: - cdr.StatP &= ~STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlPause: + StopCdda(); + StopReading(); /* Gundam Battle Assault 2: much slower (*) - Fixes boot, gameplay @@ -775,29 +830,29 @@ void cdrInterrupt() { * 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.DriveState != DRIVESTATE_STANDBY) + if (!(cdr.StatP & (STATUS_PLAY | STATUS_READ))) { - delay = 7000; + second_resp_time = 7000; } else { - delay = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * (1000000)); - CDRMISC_INT((cdr.Mode & MODE_SPEED) ? cdReadTime / 2 : cdReadTime); + second_resp_time = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * 1000000); } - AddIrqQueue(CdlPause + 0x100, delay); + SetPlaySeekRead(cdr.StatP, 0); cdr.Ctrl |= 0x80; break; case CdlPause + 0x100: - cdr.StatP &= ~STATUS_READ; - cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlReset: + StopCdda(); + StopReading(); + SetPlaySeekRead(cdr.StatP, 0); cdr.Muted = FALSE; cdr.Mode = 0x20; /* This fixes This is Football 2, Pooh's Party lockups */ - AddIrqQueue(CdlReset + 0x100, 4100000); + second_resp_time = 4100000; no_busy_error = 1; start_rotating = 1; break; @@ -820,6 +875,8 @@ void cdrInterrupt() { break; case CdlSetmode: + CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]); + cdr.Mode = cdr.Param[0]; no_busy_error = 1; break; @@ -841,14 +898,11 @@ void cdrInterrupt() { case CdlGetlocP: SetResultSize(8); memcpy(&cdr.Result, &cdr.subq, 8); - - if (!cdr.Play && !cdr.Reading) - cdr.Result[1] = 0; // HACK? break; case CdlReadT: // SetSession? // really long - AddIrqQueue(CdlReadT + 0x100, cdReadTime * 290 / 4); + second_resp_time = cdReadTime * 290 / 4; start_rotating = 1; break; @@ -889,8 +943,10 @@ void cdrInterrupt() { case CdlSeekP: StopCdda(); StopReading(); - cdr.StatP |= STATUS_SEEK; + 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,8 +960,7 @@ 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; @@ -928,7 +983,7 @@ void cdrInterrupt() { break; case CdlID: - AddIrqQueue(CdlID + 0x100, 20480); + second_resp_time = 20480; break; case CdlID + 0x100: @@ -950,11 +1005,15 @@ 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 CdlInit: + StopCdda(); + StopReading(); + SetPlaySeekRead(cdr.StatP, 0); // yes, it really sets STATUS_SHELLOPEN cdr.StatP |= STATUS_SHELLOPEN; cdr.DriveState = DRIVESTATE_RESCAN_CD; @@ -968,7 +1027,7 @@ void cdrInterrupt() { break; case CdlReadToc: - AddIrqQueue(CdlReadToc + 0x100, cdReadTime * 180 / 4); + second_resp_time = cdReadTime * 180 / 4; no_busy_error = 1; start_rotating = 1; break; @@ -980,34 +1039,18 @@ void cdrInterrupt() { case CdlReadN: case CdlReadS: - if (cdr.SetlocPending) { - seekTime = abs(msf2sec(cdr.SetSectorPlay) - msf2sec(cdr.SetSector)) * (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; - memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); - cdr.SetlocPending = 0; - cdr.m_locationChanged = TRUE; - } - Find_CurTrack(cdr.SetSectorPlay); + 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; + StopCdda(); + if (cdr.SetlocPending) { + seekTime = cdrSeekTime(cdr.SetSector); + memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); + cdr.SetlocPending = 0; + } cdr.Reading = 1; cdr.FirstSector = 1; @@ -1015,50 +1058,14 @@ void cdrInterrupt() { // - fixes new game ReadTrack(cdr.SetSectorPlay); + CDRPLAYSEEKREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime, 1); - // 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 - */ - - /* - By nicolasnoble from PCSX Redux : - "It LOOKS like this logic is wrong, therefore disabling it with `&& false` for now. - For "PoPoLoCrois Monogatari II", the game logic will soft lock and will never issue GetLocP to detect - the end of its XA streams, as it seems to assume ReadS will not return a status byte with the SEEK - flag set. I think the reasonning is that since it's invalid to call GetLocP while seeking, the game - tries to protect itself against errors by preventing from issuing a GetLocP while it knows the - last status was "seek". But this makes the logic just softlock as it'll never get a notification - about the fact the drive is done seeking and the read actually started. - - In other words, this state machine here is probably wrong in assuming the response to ReadS/ReadN is - done right away. It's rather when it's done seeking, and the read has actually started. This probably - requires a bit more work to make sure seek delays are processed properly. - Checked with a few games, this seems to work fine." - - Gameblabla additional notes : - This still needs the "+ seekTime" that PCSX Redux doesn't have for the Driver "retry" mission error. - */ - cdr.StatP |= STATUS_READ; - cdr.StatP &= ~STATUS_SEEK; - - CDREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime); - - cdr.Result[0] = cdr.StatP; + SetPlaySeekRead(cdr.StatP, STATUS_SEEK); start_rotating = 1; break; case CdlSync: default: - CDR_LOG_I("Invalid command: %02x\n", Irq); + CDR_LOG_I("Invalid command: %02x\n", Cmd); error = ERROR_INVALIDCMD; // FALLTHROUGH @@ -1088,20 +1095,16 @@ void cdrInterrupt() { } } -finish: - setIrq(); - cdr.ParamC = 0; - -#ifdef CDR_LOG_CMD_IRQ - { - int i; - SysPrintf("CDR 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"); + if (second_resp_time) { + cdr.CmdInProgress = Cmd | 0x100; + CDR_INT(second_resp_time); } -#endif + else if (cdr.Cmd && cdr.Cmd != (Cmd & 0xff)) { + cdr.CmdInProgress = cdr.Cmd; + CDR_LOG_I("cdrom: cmd %02x came before %02x finished\n", cdr.Cmd, Cmd); + } + + setIrq(Cmd); } #ifdef HAVE_ARMV7 @@ -1152,51 +1155,59 @@ 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(0x203); +} - 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]); + cdr.Readed = 0; +} - 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.SetSectorPlay); + SetPlaySeekRead(cdr.StatP, STATUS_READ | STATUS_ROTATING); - buf = CDR_getBuffer(); + ReadTrack(cdr.SetSectorPlay); + if (cdr.NoErr) + buf = CDR_getBuffer(); if (buf == NULL) cdr.NoErr = 0; 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]; } /* Gameblabla @@ -1204,32 +1215,26 @@ void cdrReadInterrupt() { * 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((cdr.Transfer[4 + 2] & 0x4) && - (cdr.Transfer[4 + 1] == cdr.Channel) && - (cdr.Transfer[4 + 0] == cdr.File) && cdr.Channel != 255) { - int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector); + 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); - /* - * Gameblabla - - * This is a hack for Megaman X4, Castlevania etc... - * that regressed from the new m_locationChanged and CDROM timings changes. - * It is mostly noticeable in Castevania however and the stuttering can be very jarring. - * - * According to PCSX redux authors, we shouldn't cause a location change if - * the sector difference is too small. - * I attempted to go with that approach but came empty handed. - * So for now, let's just set cdr.m_locationChanged to false when playing back any ADPCM samples. - * This does not regress Crash Team Racing's intro at least. - */ - cdr.m_locationChanged = FALSE; - SPU_playADPCMchannel(&cdr.Xa); + SPU_playADPCMchannel(&cdr.Xa, psxRegs.cycle, cdr.FirstSector); cdr.FirstSector = 0; } else cdr.FirstSector = -1; } } + /* + Croc 2: $40 - only FORM1 (*) + Judge Dredd: $C8 - only FORM1 (*) + Sim Theme Park - no adpcm at all (zero) + */ + + if (!(cdr.Mode & MODE_STRSND) || !(buf[4+2] & 0x4)) + cdrReadInterruptSetResult(cdr.StatP); + cdr.SetSectorPlay[2]++; if (cdr.SetSectorPlay[2] == 75) { cdr.SetSectorPlay[2] = 0; @@ -1240,29 +1245,31 @@ void cdrReadInterrupt() { } } - cdr.Readed = 0; - - uint32_t delay = (cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime; - if (cdr.m_locationChanged) { - CDREAD_INT(delay * 30); - cdr.m_locationChanged = FALSE; - } else { - CDREAD_INT(delay); + if (!cdr.Irq1Pending) { + // update for CdlGetlocP + ReadTrack(cdr.SetSectorPlay); } - /* - Croc 2: $40 - only FORM1 (*) - Judge Dredd: $C8 - only FORM1 (*) - Sim Theme Park - no adpcm at all (zero) - */ + CDRPLAYSEEKREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0); +} - if (!(cdr.Mode & MODE_STRSND) || !(cdr.Transfer[4+2] & 0x4)) { - cdr.Stat = DataReady; - setIrq(); +static void doMissedIrqs(void) +{ + 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(0x205); + return; } - - // update for CdlGetlocP - ReadTrack(cdr.SetSectorPlay); + if (!(psxRegs.interrupt & (1 << PSXINT_CDR)) && cdr.CmdInProgress) + CDR_INT(256); } /* @@ -1282,21 +1289,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); } @@ -1310,13 +1314,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) { - 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: @@ -1328,12 +1333,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]); if (cdr.ParamC) { + int i; SysPrintf(" Param[%d] = {", cdr.ParamC); for (i = 0; i < cdr.ParamC; i++) SysPrintf(" %x,", cdr.Param[i]); @@ -1345,36 +1348,20 @@ void cdrWrite1(unsigned char rt) { cdr.ResultReady = 0; cdr.Ctrl |= 0x80; - // cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - - switch (cdr.Cmd) { - - case CdlReadN: - case CdlReadS: - case CdlPause: - StopCdda(); - StopReading(); - break; - - case CdlInit: - case CdlReset: - cdr.Seeked = SEEK_DONE; - StopCdda(); - StopReading(); - 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; + if (!cdr.CmdInProgress) { + cdr.CmdInProgress = rt; + // should be something like 12k + controller delays + CDR_INT(5000); } + else { + CDR_LOG_I("cdr: 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) { @@ -1386,12 +1373,13 @@ unsigned char cdrRead2(void) { ret = *pTransfer++; } - 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: @@ -1400,7 +1388,7 @@ void cdrWrite2(unsigned char rt) { return; case 1: cdr.Reg2 = rt; - setIrq(); + setIrq(0x204); return; case 2: cdr.AttenuatorLeftToLeftT = rt; @@ -1417,21 +1405,27 @@ 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: +#ifdef CDR_LOG_CMD_IRQ + if (cdr.Stat & rt) + SysPrintf("ack %02x\n", cdr.Stat & rt); +#endif cdr.Stat &= ~rt; if (rt & 0x40) cdr.ParamC = 0; + doMissedIrqs(); return; case 2: cdr.AttenuatorLeftToRightT = rt; @@ -1439,7 +1433,7 @@ 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); } @@ -1477,7 +1471,7 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) { case 0x11000000: case 0x11400100: if (cdr.Readed == 0) { - CDR_LOG("psxDma3() Log: *** DMA 3 *** NOT READY\n"); + CDR_LOG_I("psxDma3() Log: *** DMA 3 *** NOT READY\n"); break; } @@ -1540,7 +1534,7 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) { DMA_INTERRUPT(3); } -void cdrDmaInterrupt() +void cdrDmaInterrupt(void) { if (HW_DMA3_CHCR & SWAP32(0x01000000)) { @@ -1616,6 +1610,8 @@ int cdrFreeze(void *f, int Mode) { 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) { @@ -1636,8 +1632,7 @@ int cdrFreeze(void *f, int Mode) { return 0; } -void LidInterrupt() { +void LidInterrupt(void) { getCdInfo(); - StopCdda(); cdrLidSeekInterrupt(); }