X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=libpcsxcore%2Fcdrom.c;h=6f4e3eb4207bb4959cacfcc7a17d6e1afcee24bc;hb=02b1a085fcb5bbabc4a9148daba91c3dc0a798f8;hp=90ec0d30c85927a5a101a6d3468e421e62858949;hpb=4b4164bb8f5019f743d2879b64d8f8f25430685d;p=pcsx_rearmed.git diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c index 90ec0d30..6f4e3eb4 100644 --- a/libpcsxcore/cdrom.c +++ b/libpcsxcore/cdrom.c @@ -23,8 +23,10 @@ #include #include "cdrom.h" +#include "misc.h" #include "ppf.h" #include "psxdma.h" +#include "psxevents.h" #include "arm_features.h" /* logging */ @@ -65,7 +67,9 @@ static struct { unsigned char Absolute[3]; } subq; unsigned char TrackChanged; - unsigned char unused3[3]; + unsigned char ReportDelay; + unsigned char unused3; + unsigned short sectorsRead; unsigned int freeze_ver; unsigned char Prev[4]; @@ -102,14 +106,14 @@ static struct { u16 CmdInProgress; u8 Irq1Pending; u8 unused5; - u32 LastReadCycles; + u32 LastReadSeekCycles; u8 unused7; u8 DriveState; u8 FastForward; u8 FastBackward; - u8 unused8; + u8 errorRetryhack; u8 AttenuatorLeftToLeft, AttenuatorLeftToRight; u8 AttenuatorRightToRight, AttenuatorRightToLeft; @@ -195,7 +199,7 @@ 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 @@ -203,6 +207,7 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 }; #define ERROR_NOTREADY (1<<7) // 0x80 #define ERROR_INVALIDCMD (1<<6) // 0x40 #define ERROR_INVALIDARG (1<<5) // 0x20 +#define ERROR_SHELLOPEN (1<<3) // 0x08 // 1x = 75 sectors per second // PSXCLK = 1 sec in the ps @@ -239,14 +244,6 @@ static void sec2msf(unsigned int s, u8 *msf) { msf[2] = s; } -// cdrInterrupt -#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); \ -} - // cdrPlayReadInterrupt #define CDRPLAYREAD_INT(eCycle, isFirst) { \ u32 e_ = eCycle; \ @@ -256,15 +253,7 @@ static void sec2msf(unsigned int s, u8 *msf) { 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 -#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); \ + set_event_raw_abs(PSXINT_CDREAD, psxRegs.intCycle[PSXINT_CDREAD].sCycle + e_); \ } #define StopReading() { \ @@ -318,7 +307,7 @@ void cdrLidSeekInterrupt(void) default: case DRIVESTATE_STANDBY: StopCdda(); - StopReading(); + //StopReading(); SetPlaySeekRead(cdr.StatP, 0); if (CDR_getStatus(&stat) == -1) @@ -328,7 +317,7 @@ void cdrLidSeekInterrupt(void) { memset(cdr.Prev, 0xff, sizeof(cdr.Prev)); cdr.DriveState = DRIVESTATE_LID_OPEN; - CDRLID_INT(0x800); + set_event(PSXINT_CDRLID, 0x800); } break; @@ -338,13 +327,30 @@ void cdrLidSeekInterrupt(void) // 02, 12, 10 if (!(cdr.StatP & STATUS_SHELLOPEN)) { + SetPlaySeekRead(cdr.StatP, 0); cdr.StatP |= STATUS_SHELLOPEN; - // could generate error irq here, but real hardware - // only sometimes does that - // (not done when lots of commands are sent?) + // IIRC this sometimes doesn't happen on real hw + // (when lots of commands are sent?) + if (cdr.Reading) { + StopReading(); + SetResultSize(2); + cdr.Result[0] = cdr.StatP | STATUS_SEEKERROR; + cdr.Result[1] = ERROR_SHELLOPEN; + cdr.Stat = DiskError; + setIrq(0x1006); + } + if (cdr.CmdInProgress) { + psxRegs.interrupt &= ~(1 << PSXINT_CDR); + cdr.CmdInProgress = 0; + SetResultSize(2); + cdr.Result[0] = cdr.StatP | STATUS_ERROR; + cdr.Result[1] = ERROR_NOTREADY; + cdr.Stat = DiskError; + setIrq(0x1007); + } - CDRLID_INT(cdReadTime * 30); + set_event(PSXINT_CDRLID, cdReadTime * 30); break; } else if (cdr.StatP & STATUS_ROTATING) { @@ -358,12 +364,12 @@ void cdrLidSeekInterrupt(void) // and is only cleared by CdlNop cdr.DriveState = DRIVESTATE_RESCAN_CD; - CDRLID_INT(cdReadTime * 105); + set_event(PSXINT_CDRLID, cdReadTime * 105); break; } // recheck for close - CDRLID_INT(cdReadTime * 3); + set_event(PSXINT_CDRLID, cdReadTime * 3); break; case DRIVESTATE_RESCAN_CD: @@ -372,7 +378,7 @@ void cdrLidSeekInterrupt(void) // this is very long on real hardware, over 6 seconds // make it a bit faster here... - CDRLID_INT(cdReadTime * 150); + set_event(PSXINT_CDRLID, cdReadTime * 150); break; case DRIVESTATE_PREPARE_CD: @@ -382,7 +388,7 @@ void cdrLidSeekInterrupt(void) } else { SetPlaySeekRead(cdr.StatP, STATUS_SEEK); - CDRLID_INT(cdReadTime * 26); + set_event(PSXINT_CDRLID, cdReadTime * 26); } break; } @@ -460,11 +466,11 @@ static int ReadTrack(const u8 *time) tmp[1] = itob(time[1]); tmp[2] = itob(time[2]); + CDR_LOG("ReadTrack *** %02x:%02x:%02x\n", tmp[0], tmp[1], tmp[2]); + if (memcmp(cdr.Prev, tmp, 3) == 0) return 1; - CDR_LOG("ReadTrack *** %02x:%02x:%02x\n", tmp[0], tmp[1], tmp[2]); - read_ok = CDR_readTrack(tmp); if (read_ok) memcpy(cdr.Prev, tmp, 3); @@ -474,12 +480,13 @@ static int ReadTrack(const u8 *time) static void UpdateSubq(const u8 *time) { const struct SubQ *subq; + int s = MSF2SECT(time[0], time[1], time[2]); u16 crc; - if (CheckSBI(time)) + if (CheckSBI(s)) return; - subq = (struct SubQ *)CDR_getBufferSub(MSF2SECT(time[0], time[1], time[2])); + 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])) { @@ -510,21 +517,20 @@ static void cdrPlayInterrupt_Autopause() u32 i; if ((cdr.Mode & MODE_AUTOPAUSE) && cdr.TrackChanged) { - CDR_LOG( "CDDA STOP\n" ); + CDR_LOG_I("autopause\n"); - // Magic the Gathering - // - looping territory cdda - - // ...? - //cdr.ResultReady = 1; - //cdr.Stat = DataReady; + SetResultSize(1); + cdr.Result[0] = cdr.StatP; cdr.Stat = DataEnd; setIrq(0x1000); // 0x1000 just for logging purposes StopCdda(); SetPlaySeekRead(cdr.StatP, 0); } - else if (((cdr.Mode & MODE_REPORT) || cdr.FastForward || cdr.FastBackward)) { + 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; @@ -549,32 +555,36 @@ static void cdrPlayInterrupt_Autopause() 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; - // Rayman: Logo freeze (resultready + dataready) - cdr.ResultReady = 1; cdr.Stat = DataReady; - - SetResultSize(8); setIrq(0x1001); } + + if (cdr.ReportDelay) + cdr.ReportDelay--; } -// LastReadCycles static int cdrSeekTime(unsigned char *target) { int diff = msf2sec(cdr.SetSectorPlay) - msf2sec(target); - int pausePenalty, seekTime = abs(diff) * (cdReadTime / 2000); + int seekTime = abs(diff) * (cdReadTime / 2000); + int cyclesSinceRS = psxRegs.cycle - cdr.LastReadSeekCycles; seekTime = MAX_VALUE(seekTime, 20000); // need this stupidly long penalty or else Spyro2 intro desyncs - pausePenalty = (s32)(psxRegs.cycle - cdr.LastReadCycles) > cdReadTime * 4 ? cdReadTime * 25 : 0; - seekTime += pausePenalty; + // note: if misapplied this breaks MGS cutscenes among other things + if (cyclesSinceRS > cdReadTime * 50) + seekTime += cdReadTime * 25; + // Transformers Beast Wars Transmetals does Setloc(x),SeekL,Setloc(x),ReadN + // and then wants some slack time + else if (cyclesSinceRS < cdReadTime *3/2) + seekTime += cdReadTime; seekTime = MIN_VALUE(seekTime, PSXCLK * 2 / 3); - CDR_LOG("seek: %.2f %.2f\n", (float)seekTime / PSXCLK, (float)seekTime / cdReadTime); + CDR_LOG("seek: %.2f %.2f (%.2f)\n", (float)seekTime / PSXCLK, + (float)seekTime / cdReadTime, (float)cyclesSinceRS / cdReadTime); return seekTime; } @@ -624,9 +634,23 @@ static void msfiAdd(u8 *msfi, u32 count) } } +static void msfiSub(u8 *msfi, u32 count) +{ + 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]--; + } + } +} + void cdrPlayReadInterrupt(void) { - cdr.LastReadCycles = psxRegs.cycle; + cdr.LastReadSeekCycles = psxRegs.cycle; if (cdr.Reading) { cdrReadInterrupt(); @@ -635,11 +659,12 @@ void cdrPlayReadInterrupt(void) if (!cdr.Play) return; - CDR_LOG( "CDDA - %d:%d:%d\n", - cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] ); + CDR_LOG("CDDA - %02d:%02d:%02d m %02x\n", + cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], cdr.Mode); 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; @@ -651,7 +676,7 @@ void cdrPlayReadInterrupt(void) if (!cdr.Stat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT))) cdrPlayInterrupt_Autopause(); - if (!cdr.Muted && !Config.Cdda) { + if (!cdr.Muted && cdr.Play && !Config.Cdda) { cdrPrepCdda(read_buf, CD_FRAMESIZE_RAW / 4); cdrAttenuate(read_buf, CD_FRAMESIZE_RAW / 4, 1); SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW, psxRegs.cycle, cdr.FirstSector); @@ -742,13 +767,15 @@ void cdrInterrupt(void) { break; case CdlSetloc: - case CdlSetloc + CMD_WHILE_NOT_READY: + // 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_INVALIDARG; goto set_error; } @@ -759,6 +786,7 @@ void cdrInterrupt(void) { memcpy(cdr.SetSector, set_loc, 3); cdr.SetSector[3] = 0; cdr.SetlocPending = 1; + cdr.errorRetryhack = 0; } break; @@ -814,6 +842,8 @@ void cdrInterrupt(void) { cdr.SubqForwardSectors = 1; cdr.TrackChanged = FALSE; cdr.FirstSector = 1; + cdr.ReportDelay = 60; + cdr.sectorsRead = 0; if (!Config.Cdda) CDR_play(cdr.SetSectorPlay); @@ -887,6 +917,12 @@ void cdrInterrupt(void) { case CdlPause: StopCdda(); StopReading(); + + // 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; + /* Gundam Battle Assault 2: much slower (*) - Fixes boot, gameplay @@ -1053,6 +1089,7 @@ void cdrInterrupt(void) { memcpy(cdr.LocL, buf, 8); UpdateSubq(cdr.SetSectorPlay); cdr.TrackChanged = FALSE; + cdr.LastReadSeekCycles = psxRegs.cycle; break; case CdlTest: @@ -1109,7 +1146,7 @@ void cdrInterrupt(void) { // yes, it really sets STATUS_SHELLOPEN cdr.StatP |= STATUS_SHELLOPEN; cdr.DriveState = DRIVESTATE_RESCAN_CD; - CDRLID_INT(20480); + set_event(PSXINT_CDRLID, 20480); start_rotating = 1; break; @@ -1154,6 +1191,7 @@ void cdrInterrupt(void) { UpdateSubq(cdr.SetSectorPlay); cdr.LocL[0] = LOCL_INVALID; cdr.SubqForwardSectors = 1; + cdr.sectorsRead = 0; cycles = (cdr.Mode & MODE_SPEED) ? cdReadTime : cdReadTime * 2; cycles += seekTime; @@ -1171,11 +1209,11 @@ void cdrInterrupt(void) { // FALLTHROUGH set_error: - CDR_LOG_I("cmd %02x error %02x\n", Cmd, error); SetResultSize(2); cdr.Result[0] = cdr.StatP | STATUS_ERROR; cdr.Result[1] = not_ready ? ERROR_NOTREADY : error; cdr.Stat = DiskError; + CDR_LOG_I("cmd %02x error %02x\n", Cmd, cdr.Result[1]); break; } @@ -1186,7 +1224,7 @@ void cdrInterrupt(void) { if (second_resp_time) { cdr.CmdInProgress = Cmd | 0x100; - CDR_INT(second_resp_time); + set_event(PSXINT_CDR, second_resp_time); } else if (cdr.Cmd && cdr.Cmd != (Cmd & 0xff)) { cdr.CmdInProgress = cdr.Cmd; @@ -1276,7 +1314,8 @@ static void cdrUpdateTransferBuf(const u8 *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_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); } @@ -1298,6 +1337,7 @@ static void cdrReadInterrupt(void) // note: CdlGetlocL should work as soon as STATUS_READ is indicated SetPlaySeekRead(cdr.StatP, STATUS_READ | STATUS_ROTATING); + cdr.sectorsRead++; read_ok = ReadTrack(cdr.SetSectorPlay); if (read_ok) @@ -1433,7 +1473,7 @@ void cdrWrite1(unsigned char rt) { if (!cdr.CmdInProgress) { cdr.CmdInProgress = rt; // should be something like 12k + controller delays - CDR_INT(5000); + set_event(PSXINT_CDR, 5000); } else { CDR_LOG_I("cmd while busy: %02x, prev %02x, busy %02x\n", @@ -1514,7 +1554,7 @@ void cdrWrite3(unsigned char rt) { c = 2048 - (psxRegs.cycle - nextCycle); c = MAX_VALUE(c, 512); } - CDR_INT(c); + set_event(PSXINT_CDR, c); } } cdr.Stat &= ~rt; @@ -1604,7 +1644,7 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) { } psxCpu->Clear(madr, cdsize / 4); - CDRDMA_INT((cdsize/4) * 24); + set_event(PSXINT_CDRDMA, (cdsize / 4) * 24); HW_DMA3_CHCR &= SWAPu32(~0x10000000); if (chcr & 0x100) { @@ -1654,7 +1694,13 @@ void cdrReset() { cdr.Reg2 = 0x1f; cdr.Stat = NoIntr; cdr.FifoOffset = DATA_SIZE; // fifo empty - if (CdromId[0] == '\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; } @@ -1711,8 +1757,6 @@ int cdrFreeze(void *f, int Mode) { Find_CurTrack(cdr.SetSectorPlay); if (!Config.Cdda) CDR_play(cdr.SetSectorPlay); - if (psxRegs.interrupt & (1 << PSXINT_CDRPLAY_OLD)) - CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 1); } if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {