X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?p=pcsx_rearmed.git;a=blobdiff_plain;f=libpcsxcore%2Fcdrom.c;h=098b77d0b9691a910a135abcb628b94fb4453a1c;hp=10fc61562ee7d250a98e1d3a20a5654087b7b2ab;hb=HEAD;hpb=ae36bb287237de0a199f52de86dbfc6115d4cb70 diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c index 10fc6156..d4d14742 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 */ @@ -36,7 +38,8 @@ #if 0 #define CDR_LOG_I SysPrintf #else -#define CDR_LOG_I log_unhandled +#define CDR_LOG_I(fmt, ...) \ + log_unhandled("%u cdrom: " fmt, psxRegs.cycle, ##__VA_ARGS__) #endif #if 0 #define CDR_LOG_IO SysPrintf @@ -49,10 +52,10 @@ static struct { // unused members maintain savesate compatibility unsigned char unused0; unsigned char unused1; - unsigned char Reg2; + unsigned char IrqMask; unsigned char unused2; unsigned char Ctrl; - unsigned char Stat; + unsigned char IrqStat; unsigned char StatP; @@ -64,7 +67,9 @@ static struct { unsigned char Absolute[3]; } subq; unsigned char TrackChanged; - unsigned char unused3[3]; + unsigned char ReportDelay; + unsigned char PhysCdPropagations; + unsigned short sectorsRead; unsigned int freeze_ver; unsigned char Prev[4]; @@ -89,9 +94,12 @@ static struct { unsigned char Track; boolean Play, Muted; int CurTrack; - int Mode, File, Channel; + unsigned char Mode; + unsigned char FileChannelSelected; + unsigned char CurFile, CurChannel; + int FilterFile, FilterChannel; unsigned char LocL[8]; - int FirstSector; + int unused4; xa_decode_t Xa; @@ -100,15 +108,15 @@ static struct { u16 CmdInProgress; u8 Irq1Pending; - u8 unused5; - u32 unused6; + u8 AdpcmActive; + u32 LastReadSeekCycles; u8 unused7; - u8 DriveState; + u8 DriveState; // enum drive_state u8 FastForward; u8 FastBackward; - u8 unused8; + u8 errorRetryhack; u8 AttenuatorLeftToLeft, AttenuatorLeftToRight; u8 AttenuatorRightToRight, AttenuatorRightToLeft; @@ -169,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 @@ -194,14 +202,16 @@ 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_INVALIDARG (1<<5) // 0x20 +#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 @@ -212,11 +222,14 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 }; #define SUBQ_FORWARD_SECTORS 2u enum drive_state { - DRIVESTATE_STANDBY = 0, // pause, play, read + 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; @@ -238,14 +251,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; \ @@ -255,15 +260,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() { \ @@ -283,23 +280,33 @@ static void sec2msf(unsigned int s, u8 *msf) { x |= f; \ } -#define SetResultSize(size) { \ +#define SetResultSize_(size) { \ cdr.ResultP = 0; \ cdr.ResultC = size; \ cdr.ResultReady = 1; \ } -static void setIrq(int log_cmd) +#define SetResultSize(size) { \ + if (cdr.ResultP < cdr.ResultC) \ + CDR_LOG_I("overwriting result, len=%u\n", cdr.ResultC); \ + SetResultSize_(size); \ +} + +static void setIrq(u8 irq, int log_cmd) { - if (cdr.Stat & cdr.Reg2) + 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); #ifdef CDR_LOG_CMD_IRQ - if (cdr.Stat) + if (cdr.IrqStat) { int i; - SysPrintf("%u cdrom: CDR IRQ=%d cmd %02x stat %02x: ", - psxRegs.cycle, !!(cdr.Stat & cdr.Reg2), log_cmd, cdr.Stat); + 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"); @@ -311,13 +318,13 @@ static void setIrq(int log_cmd) // (yes it's slow, but you probably don't want to modify it) void cdrLidSeekInterrupt(void) { - CDR_LOG_I("%u %s cdr.DriveState=%d\n", psxRegs.cycle, __func__, cdr.DriveState); + CDR_LOG_I("%s cdr.DriveState=%d\n", __func__, cdr.DriveState); switch (cdr.DriveState) { default: case DRIVESTATE_STANDBY: StopCdda(); - StopReading(); + //StopReading(); SetPlaySeekRead(cdr.StatP, 0); if (CDR_getStatus(&stat) == -1) @@ -327,7 +334,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; @@ -337,13 +344,24 @@ void cdrLidSeekInterrupt(void) // 02, 12, 10 if (!(cdr.StatP & STATUS_SHELLOPEN)) { + StopReading(); + 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?) + 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); - CDRLID_INT(cdReadTime * 30); + set_event(PSXINT_CDRLID, cdReadTime * 30); break; } else if (cdr.StatP & STATUS_ROTATING) { @@ -357,12 +375,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: @@ -371,7 +389,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: @@ -381,7 +399,7 @@ void cdrLidSeekInterrupt(void) } else { SetPlaySeekRead(cdr.StatP, STATUS_SEEK); - CDRLID_INT(cdReadTime * 26); + set_event(PSXINT_CDRLID, cdReadTime * 26); } break; } @@ -459,11 +477,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); @@ -473,12 +491,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])) { @@ -509,21 +528,20 @@ static void cdrPlayInterrupt_Autopause() u32 i; if ((cdr.Mode & MODE_AUTOPAUSE) && cdr.TrackChanged) { - CDR_LOG( "CDDA STOP\n" ); - - // Magic the Gathering - // - looping territory cdda + CDR_LOG_I("autopause\n"); - // ...? - //cdr.ResultReady = 1; - //cdr.Stat = DataReady; - cdr.Stat = DataEnd; - setIrq(0x1000); // 0x1000 just for logging purposes + SetResultSize(1); + cdr.Result[0] = cdr.StatP; + setIrq(DataEnd, 0x1000); // 0x1000 just for logging purposes StopCdda(); SetPlaySeekRead(cdr.StatP, 0); + cdr.DriveState = DRIVESTATE_PAUSED; } - 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; @@ -548,40 +566,32 @@ 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); + setIrq(DataReady, 0x1001); } + + if (cdr.ReportDelay) + cdr.ReportDelay--; } static int cdrSeekTime(unsigned char *target) { int diff = msf2sec(cdr.SetSectorPlay) - msf2sec(target); - int seekTime = abs(diff) * (cdReadTime / 200); - /* - * Gameblabla : - * It was originally set to 1000000 for Driver, however it is not high enough for Worms Pinball - * and was unreliable for that game. - * I also tested it against Mednafen and Driver's titlescreen music starts 25 frames later, not immediatly. - * - * Obviously, this isn't perfect but right now, it should be a bit better. - * Games to test this against if you change that setting : - * - Driver (titlescreen music delay and retry mission) - * - Worms Pinball (Will either not boot or crash in the memory card screen) - * - Viewpoint (short pauses if the delay in the ingame music is too long) - * - * It seems that 3386880 * 5 is too much for Driver's titlescreen and it starts skipping. - * However, 1000000 is not enough for Worms Pinball to reliably boot. - */ - if(seekTime > 3386880 * 2) seekTime = 3386880 * 2; - CDR_LOG("seek: %.2f %.2f\n", (float)seekTime / PSXCLK, (float)seekTime / cdReadTime); + 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; } @@ -615,7 +625,6 @@ static u32 cdrAlignTimingHack(u32 cycles) static void cdrUpdateTransferBuf(const u8 *buf); static void cdrReadInterrupt(void); static void cdrPrepCdda(s16 *buf, int samples); -static void cdrAttenuate(s16 *buf, int samples, int stereo); static void msfiAdd(u8 *msfi, u32 count) { @@ -631,8 +640,32 @@ 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) { + 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; + + cdr.LastReadSeekCycles = psxRegs.cycle; + if (cdr.Reading) { cdrReadInterrupt(); return; @@ -640,30 +673,32 @@ 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); + 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.Stat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT))) + if (!cdr.IrqStat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT))) cdrPlayInterrupt_Autopause(); - if (!cdr.Muted && !Config.Cdda) { + if (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); - cdr.FirstSector = 0; + SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW, psxRegs.cycle, 0); } msfiAdd(cdr.SetSectorPlay, 1); + CDR_prefetch(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]); // update for CdlGetlocP/autopause generate_subq(cdr.SetSectorPlay); @@ -671,6 +706,30 @@ void cdrPlayReadInterrupt(void) CDRPLAYREAD_INT(cdReadTime, 0); } +static void softReset(void) +{ + 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; + } + + 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); +} + #define CMD_PART2 0x100 #define CMD_WHILE_NOT_READY 0x200 @@ -684,31 +743,32 @@ void cdrInterrupt(void) { u8 set_loc[3]; int read_ok; u16 not_ready = 0; + u8 IrqStat = Acknowledge; + u8 DriveStateOld; u16 Cmd; int i; - if (cdr.Stat) { - CDR_LOG_I("%u cdrom: cmd %02x with irqstat %x\n", - psxRegs.cycle, cdr.CmdInProgress, cdr.Stat); + 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("cdrom: %x:%02x:%02x loaded on ack\n", - cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]); + 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.Stat = (cdr.Irq1Pending & STATUS_ERROR) ? DiskError : DataReady; cdr.Irq1Pending = 0; - setIrq(0x1003); + setIrq((cdr.Irq1Pending & STATUS_ERROR) ? DiskError : DataReady, 0x1003); return; } // default response SetResultSize(1); cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; Cmd = cdr.CmdInProgress; cdr.CmdInProgress = 0; @@ -746,14 +806,16 @@ 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]); - error = ERROR_INVALIDARG; + if (++cdr.errorRetryhack > 100) + break; + error = ERROR_BAD_ARGNUM; goto set_error; } else @@ -763,6 +825,7 @@ void cdrInterrupt(void) { memcpy(cdr.SetSector, set_loc, 3); cdr.SetSector[3] = 0; cdr.SetlocPending = 1; + cdr.errorRetryhack = 0; } break; @@ -817,7 +880,10 @@ void cdrInterrupt(void) { cdr.LocL[0] = LOCL_INVALID; cdr.SubqForwardSectors = 1; cdr.TrackChanged = FALSE; - cdr.FirstSector = 1; + cdr.FileChannelSelected = 0; + cdr.AdpcmActive = 0; + cdr.ReportDelay = 60; + cdr.sectorsRead = 0; if (!Config.Cdda) CDR_play(cdr.SetSectorPlay); @@ -826,6 +892,7 @@ void cdrInterrupt(void) { // BIOS player - set flag again cdr.Play = TRUE; + cdr.DriveState = DRIVESTATE_PLAY_READ; CDRPLAYREAD_INT(cdReadTime + seekTime, 1); start_rotating = 1; @@ -833,7 +900,7 @@ void cdrInterrupt(void) { case CdlForward: // TODO: error 80 if stopped - cdr.Stat = Complete; + IrqStat = Complete; // GameShark CD Player: Calls 2x + Play 2x cdr.FastForward = 1; @@ -841,7 +908,7 @@ void cdrInterrupt(void) { break; case CdlBackward: - cdr.Stat = Complete; + IrqStat = Complete; // GameShark CD Player: Calls 2x + Play 2x cdr.FastBackward = 1; @@ -850,15 +917,16 @@ void cdrInterrupt(void) { case CdlStandby: if (cdr.DriveState != DRIVESTATE_STOPPED) { - error = ERROR_INVALIDARG; + error = ERROR_BAD_ARGNUM; goto set_error; } + cdr.DriveState = DRIVESTATE_STANDBY; second_resp_time = cdReadTime * 125 / 2; start_rotating = 1; break; case CdlStandby + CMD_PART2: - cdr.Stat = Complete; + IrqStat = Complete; break; case CdlStop: @@ -878,77 +946,93 @@ void cdrInterrupt(void) { cdr.LocL[0] = LOCL_INVALID; second_resp_time = 0x800; - if (cdr.DriveState == DRIVESTATE_STANDBY) + if (cdr.DriveState != DRIVESTATE_STOPPED) second_resp_time = cdReadTime * 30 / 2; cdr.DriveState = DRIVESTATE_STOPPED; break; case CdlStop + CMD_PART2: - cdr.Stat = Complete; + IrqStat = Complete; break; case CdlPause: + if (cdr.AdpcmActive) { + cdr.AdpcmActive = 0; + cdr.Xa.nsamples = 0; + SPU_playADPCMchannel(&cdr.Xa, psxRegs.cycle, 1); // flush adpcm + } StopCdda(); StopReading(); - /* - Gundam Battle Assault 2: much slower (*) - - Fixes boot, gameplay - 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 + ... */ - /* Gameblabla - Tightening the timings (as taken from Duckstation). - * The timings from Duckstation are based upon hardware tests. - * Mednafen's timing don't work for Gundam Battle Assault 2 in PAL/50hz mode, - * seems to be timing sensitive as it can depend on the CPU's clock speed. - * */ if (!(cdr.StatP & (STATUS_PLAY | STATUS_READ))) { second_resp_time = 7000; } else { - second_resp_time = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * 1000000); + 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 + CMD_PART2: - cdr.Stat = Complete; + IrqStat = Complete; break; 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(); - SetPlaySeekRead(cdr.StatP, 0); - cdr.LocL[0] = LOCL_INVALID; - cdr.Muted = FALSE; - cdr.Mode = 0x20; /* This fixes This is Football 2, Pooh's Party lockups */ + softReset(); second_resp_time = not_ready ? 70000 : 4100000; start_rotating = 1; break; case CdlReset + CMD_PART2: case CdlReset + CMD_PART2 + CMD_WHILE_NOT_READY: - cdr.Stat = Complete; + IrqStat = Complete; break; case CdlMute: cdr.Muted = TRUE; + SPU_setCDvol(0, 0, 0, 0, psxRegs.cycle); break; case CdlDemute: cdr.Muted = FALSE; + SPU_setCDvol(cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight, + cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight, psxRegs.cycle); break; case CdlSetfilter: - cdr.File = cdr.Param[0]; - cdr.Channel = cdr.Param[1]; + cdr.FilterFile = cdr.Param[0]; + cdr.FilterChannel = cdr.Param[1]; + cdr.FileChannelSelected = 0; break; case CdlSetmode: @@ -960,11 +1044,11 @@ void cdrInterrupt(void) { case CdlGetparam: case CdlGetparam + CMD_WHILE_NOT_READY: /* Gameblabla : According to mednafen, Result size should be 5 and done this way. */ - SetResultSize(5); + SetResultSize_(5); cdr.Result[1] = cdr.Mode; cdr.Result[2] = 0; - cdr.Result[3] = cdr.File; - cdr.Result[4] = cdr.Channel; + cdr.Result[3] = cdr.FilterFile; + cdr.Result[4] = cdr.FilterChannel; break; case CdlGetlocL: @@ -972,12 +1056,12 @@ void cdrInterrupt(void) { error = 0x80; goto set_error; } - SetResultSize(8); + SetResultSize_(8); memcpy(cdr.Result, cdr.LocL, 8); break; case CdlGetlocP: - SetResultSize(8); + SetResultSize_(8); memcpy(&cdr.Result, &cdr.subq, 8); break; @@ -988,36 +1072,29 @@ void cdrInterrupt(void) { break; case CdlReadT + CMD_PART2: - cdr.Stat = Complete; + IrqStat = Complete; break; case CdlGetTN: - SetResultSize(3); 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.Track = btoi(cdr.Param[0]); - SetResultSize(4); 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]); - /* According to Nocash's documentation, the function doesn't care about ff. - * This can be seen also in Mednafen's implementation. */ - //cdr.Result[3] = itob(cdr.ResultTD[0]); + 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: @@ -1028,6 +1105,9 @@ void cdrInterrupt(void) { 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 @@ -1049,29 +1129,31 @@ void cdrInterrupt(void) { case CdlSeekP + CMD_PART2: SetPlaySeekRead(cdr.StatP, 0); cdr.Result[0] = cdr.StatP; - cdr.Stat = Complete; + 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: 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; } @@ -1082,7 +1164,7 @@ void cdrInterrupt(void) { break; case CdlID + CMD_PART2: - SetResultSize(8); + SetResultSize_(8); cdr.Result[0] = cdr.StatP; cdr.Result[1] = 0; cdr.Result[2] = 0; @@ -1099,10 +1181,12 @@ void cdrInterrupt(void) { cdr.Result[1] |= 0x80; } 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]); /* This adds the string "PCSX" in Playstation bios boot screen */ memcpy((char *)&cdr.Result[4], "PCSX", 4); - cdr.Stat = Complete; + IrqStat = Complete; break; case CdlInit: @@ -1113,7 +1197,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; @@ -1130,7 +1214,7 @@ void cdrInterrupt(void) { case CdlReadToc + CMD_PART2: case CdlReadToc + CMD_PART2 + CMD_WHILE_NOT_READY: - cdr.Stat = Complete; + IrqStat = Complete; break; case CdlReadN: @@ -1151,15 +1235,20 @@ void cdrInterrupt(void) { cdr.SetlocPending = 0; } cdr.Reading = 1; - cdr.FirstSector = 1; + cdr.FileChannelSelected = 0; + cdr.AdpcmActive = 0; // 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 & 0x80) ? cdReadTime : cdReadTime * 2; + cycles = (cdr.Mode & MODE_SPEED) ? cdReadTime : cdReadTime * 2; cycles += seekTime; if (Config.hacks.cdr_read_timing) cycles = cdrAlignTimingHack(cycles); @@ -1175,11 +1264,11 @@ void cdrInterrupt(void) { // FALLTHROUGH set_error: - CDR_LOG_I("cdrom: cmd %02x error %02x\n", Cmd, error); - SetResultSize(2); + SetResultSize_(2); cdr.Result[0] = cdr.StatP | STATUS_ERROR; cdr.Result[1] = not_ready ? ERROR_NOTREADY : error; - cdr.Stat = DiskError; + IrqStat = DiskError; + CDR_LOG_I("cmd %02x error %02x\n", Cmd, cdr.Result[1]); break; } @@ -1190,15 +1279,14 @@ 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; - CDR_LOG_I("%u cdrom: cmd %02x came before %02x finished\n", - psxRegs.cycle, cdr.Cmd, Cmd); + CDR_LOG_I("cmd %02x came before %02x finished\n", cdr.Cmd, Cmd); } - setIrq(Cmd); + setIrq(IrqStat, Cmd); } #ifdef HAVE_ARMV7 @@ -1222,57 +1310,18 @@ static void cdrPrepCdda(s16 *buf, int samples) #endif } -static void cdrAttenuate(s16 *buf, int samples, int stereo) -{ - int i, l, r; - int ll = cdr.AttenuatorLeftToLeft; - int lr = cdr.AttenuatorLeftToRight; - int rl = cdr.AttenuatorRightToLeft; - int rr = cdr.AttenuatorRightToRight; - - if (lr == 0 && rl == 0 && 0x78 <= ll && ll <= 0x88 && 0x78 <= rr && rr <= 0x88) - return; - - if (!stereo && ll == 0x40 && lr == 0x40 && rl == 0x40 && rr == 0x40) - return; - - if (stereo) { - for (i = 0; i < samples; i++) { - l = buf[i * 2]; - r = buf[i * 2 + 1]; - l = (l * ll + r * rl) >> 7; - r = (r * rr + l * lr) >> 7; - ssat32_to_16(l); - ssat32_to_16(r); - buf[i * 2] = l; - buf[i * 2 + 1] = r; - } - } - else { - for (i = 0; i < samples; i++) { - l = buf[i]; - l = l * (ll + rl) >> 7; - //r = r * (rr + lr) >> 7; - ssat32_to_16(l); - //ssat32_to_16(r); - buf[i] = l; - } - } -} - static void cdrReadInterruptSetResult(unsigned char result) { - if (cdr.Stat) { - CDR_LOG_I("cdrom: %d:%02d:%02d irq miss, cmd=%02x irqstat=%02x\n", + 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.Stat); + cdr.CmdInProgress, cdr.IrqStat); cdr.Irq1Pending = result; return; } SetResultSize(1); cdr.Result[0] = result; - cdr.Stat = (result & STATUS_ERROR) ? DiskError : DataReady; - setIrq(0x1004); + setIrq((result & STATUS_ERROR) ? DiskError : DataReady, 0x1004); } static void cdrUpdateTransferBuf(const u8 *buf) @@ -1281,16 +1330,20 @@ 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("cdrom: FifoOffset(1) %d/%d\n", cdr.FifoOffset, cdr.FifoSize); + CDR_LOG("FifoOffset(1) %d/%d\n", cdr.FifoOffset, cdr.FifoSize); } static void cdrReadInterrupt(void) { - u8 *buf = NULL, *hdr; + 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); @@ -1303,6 +1356,8 @@ static void cdrReadInterrupt(void) // 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++; read_ok = ReadTrack(cdr.SetSectorPlay); if (read_ok) @@ -1313,36 +1368,51 @@ static void cdrReadInterrupt(void) 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 (!cdr.Irq1Pending) + if (!cdr.IrqStat && !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 = hdr[0]; - cdr.Channel = hdr[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; } - - /* Gameblabla - * Skips playing on channel 255. - * Fixes missing audio in Blue's Clues : Blue's Big Musical. (Should also fix Taxi 2) - * TODO : Check if this is the proper behaviour. - * */ - if ((hdr[2] & 0x4) && hdr[0] == cdr.File && hdr[1] == cdr.Channel && cdr.Channel != 255) { - int ret = xa_decode_sector(&cdr.Xa, buf + 4, cdr.FirstSector); - if (!ret) { - cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo); - SPU_playADPCMchannel(&cdr.Xa, psxRegs.cycle, cdr.FirstSector); - cdr.FirstSector = 0; - } - else cdr.FirstSector = -1; + 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; + + // accepted as adpcm + deliver_data = 0; + + 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 (*) @@ -1350,30 +1420,28 @@ static void cdrReadInterrupt(void) Sim Theme Park - no adpcm at all (zero) */ - if (!(cdr.Mode & MODE_STRSND) || !(buf[4+2] & 0x4)) + if (deliver_data) cdrReadInterruptSetResult(cdr.StatP); msfiAdd(cdr.SetSectorPlay, 1); + CDR_prefetch(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]); CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0); } /* cdrRead0: - bit 0,1 - mode - 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; cdr.Ctrl |= 0x40; // data fifo not empty @@ -1386,7 +1454,7 @@ unsigned char cdrRead0(void) { } void cdrWrite0(unsigned char rt) { - CDR_LOG_IO("cdr w0.idx: %02x\n", rt); + CDR_LOG_IO("cdr w0.x.idx: %02x\n", rt); cdr.Ctrl = (rt & 3) | (cdr.Ctrl & ~3); } @@ -1400,13 +1468,13 @@ unsigned char cdrRead1(void) { if (cdr.ResultP == cdr.ResultC) cdr.ResultReady = 0; - CDR_LOG_IO("cdr r1.rsp: %02x #%u\n", psxHu8(0x1801), cdr.ResultP - 1); + CDR_LOG_IO("cdr r1.x.rsp: %02x #%u\n", psxHu8(0x1801), cdr.ResultP - 1); return psxHu8(0x1801); } void cdrWrite1(unsigned char rt) { - const char *rnames[] = { "cmd", "smd", "smc", "arr" }; (void)rnames; + 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); switch (cdr.Ctrl & 3) { @@ -1420,16 +1488,15 @@ void cdrWrite1(unsigned char rt) { } #ifdef CDR_LOG_CMD_IRQ - SysPrintf("%u cdrom: CD1 write: %x (%s)", psxRegs.cycle, rt, CmdName[rt]); + 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 cdr.ResultReady = 0; @@ -1438,11 +1505,11 @@ 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("%u cdrom: cmd while busy: %02x, prev %02x, busy %02x\n", - psxRegs.cycle, rt, cdr.Cmd, cdr.CmdInProgress); + 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; } @@ -1456,14 +1523,14 @@ unsigned char cdrRead2(void) { if (cdr.FifoOffset < cdr.FifoSize) ret = cdr.Transfer[cdr.FifoOffset++]; else - CDR_LOG_I("cdrom: read empty fifo (%d)\n", cdr.FifoSize); + CDR_LOG_I("read empty fifo (%d)\n", cdr.FifoSize); - CDR_LOG_IO("cdr r2.dat: %02x\n", ret); + CDR_LOG_IO("cdr r2.x.dat: %02x\n", ret); return ret; } void cdrWrite2(unsigned char rt) { - const char *rnames[] = { "prm", "ien", "all", "arl" }; (void)rnames; + 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); switch (cdr.Ctrl & 3) { @@ -1472,8 +1539,8 @@ void cdrWrite2(unsigned char rt) { cdr.Param[cdr.ParamC++] = rt; return; case 1: - cdr.Reg2 = rt; - setIrq(0x1005); + cdr.IrqMask = rt; + setIrq(cdr.IrqStat, 0x1005); return; case 2: cdr.AttenuatorLeftToLeftT = rt; @@ -1486,33 +1553,45 @@ void cdrWrite2(unsigned char rt) { unsigned char cdrRead3(void) { if (cdr.Ctrl & 0x1) - psxHu8(0x1803) = cdr.Stat | 0xE0; + psxHu8(0x1803) = cdr.IrqStat | 0xE0; else - psxHu8(0x1803) = cdr.Reg2 | 0xE0; + psxHu8(0x1803) = cdr.IrqMask | 0xE0; - CDR_LOG_IO("cdr r3.%s: %02x\n", (cdr.Ctrl & 1) ? "ifl" : "ien", psxHu8(0x1803)); + 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) { - const char *rnames[] = { "req", "ifl", "alr", "ava" }; (void)rnames; + 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.Stat & rt) { + 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 - SysPrintf("%u cdrom: ack %02x (w %02x)\n", - psxRegs.cycle, cdr.Stat & rt, rt); + 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 - // note: Croc vs Discworld Noir - if (!(psxRegs.interrupt & (1 << PSXINT_CDR)) && - (cdr.CmdInProgress || cdr.Irq1Pending)) - CDR_INT(850); // 711-993 + // 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.Stat &= ~rt; + cdr.IrqStat &= ~rt; if (rt & 0x40) cdr.ParamC = 0; @@ -1521,11 +1600,20 @@ void cdrWrite3(unsigned char rt) { cdr.AttenuatorLeftToRightT = rt; return; case 3: + if (rt & 0x01) + log_unhandled("Mute ADPCM?\n"); if (rt & 0x20) { - memcpy(&cdr.AttenuatorLeftToLeft, &cdr.AttenuatorLeftToLeftT, 4); - CDR_LOG("CD-XA Volume: %02x %02x | %02x %02x\n", - cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight, - cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight); + 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; } @@ -1535,7 +1623,7 @@ void cdrWrite3(unsigned char rt) { CDR_LOG("cdrom: FifoOffset(2) %d/%d\n", cdr.FifoOffset, cdr.FifoSize); } else if (rt & 0x80) { - switch (cdr.Mode & 0x30) { + switch (cdr.Mode & (MODE_SIZE_2328|MODE_SIZE_2340)) { case MODE_SIZE_2328: case 0x00: cdr.FifoOffset = 12; @@ -1554,15 +1642,23 @@ void cdrWrite3(unsigned char rt) { } void psxDma3(u32 madr, u32 bcr, u32 chcr) { - u32 cdsize; + u32 cdsize, max_words; int size; u8 *ptr; - 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 & 0x71000000) { case 0x11000000: - ptr = (u8 *)PSXM(madr); + madr &= ~3; + ptr = getDmaRam(madr, &max_words); if (ptr == INVALID_PTR) { CDR_LOG_I("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n"); break; @@ -1579,6 +1675,8 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) { 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.Transfer + cdr.FifoOffset, size); @@ -1590,7 +1688,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) { @@ -1635,26 +1733,18 @@ static void getCdInfo(void) void cdrReset() { memset(&cdr, 0, sizeof(cdr)); cdr.CurTrack = 1; - cdr.File = 1; - cdr.Channel = 1; - cdr.Reg2 = 0x1f; - cdr.Stat = NoIntr; - cdr.FifoOffset = DATA_SIZE; // fifo empty - if (CdromId[0] == '\0') { - cdr.DriveState = DRIVESTATE_STOPPED; - cdr.StatP = 0; - } - else { - cdr.DriveState = DRIVESTATE_STANDBY; - cdr.StatP = STATUS_ROTATING; - } - + cdr.FilterFile = 0; + cdr.FilterChannel = 0; + cdr.IrqMask = 0x1f; + cdr.IrqStat = NoIntr; + // BIOS player - default values cdr.AttenuatorLeftToLeft = 0x80; cdr.AttenuatorLeftToRight = 0x00; cdr.AttenuatorRightToLeft = 0x00; cdr.AttenuatorRightToRight = 0x80; + softReset(); getCdInfo(); } @@ -1676,10 +1766,11 @@ int cdrFreeze(void *f, int Mode) { gzfreeze(&tmp, sizeof(tmp)); if (Mode == 0) { + u8 ll = 0, lr = 0, rl = 0, rr = 0; getCdInfo(); cdr.FifoOffset = tmp < DATA_SIZE ? tmp : DATA_SIZE; - cdr.FifoSize = (cdr.Mode & 0x20) ? 2340 : 2048 + 12; + cdr.FifoSize = (cdr.Mode & MODE_SIZE_2340) ? 2340 : 2048 + 12; if (cdr.SubqForwardSectors > SUBQ_FORWARD_SECTORS) cdr.SubqForwardSectors = SUBQ_FORWARD_SECTORS; @@ -1697,23 +1788,11 @@ 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 & 0x80) ? (cdReadTime / 2) : cdReadTime, 1); - } - - if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) { - // old versions did not latch Reg2, have to fixup.. - if (cdr.Reg2 == 0) { - SysPrintf("cdrom: fixing up old savestate\n"); - cdr.Reg2 = 7; - } - // also did not save Attenuator.. - if ((cdr.AttenuatorLeftToLeft | cdr.AttenuatorLeftToRight - | cdr.AttenuatorRightToLeft | cdr.AttenuatorRightToRight) == 0) - { - cdr.AttenuatorLeftToLeft = cdr.AttenuatorRightToRight = 0x80; - } } + 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;