#include <assert.h>
#include "cdrom.h"
+#include "misc.h"
#include "ppf.h"
#include "psxdma.h"
+#include "psxevents.h"
#include "arm_features.h"
/* logging */
#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
// 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;
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];
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;
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;
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
#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
#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;
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; \
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() { \
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");
// (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)
{
memset(cdr.Prev, 0xff, sizeof(cdr.Prev));
cdr.DriveState = DRIVESTATE_LID_OPEN;
- CDRLID_INT(0x800);
+ set_event(PSXINT_CDRLID, 0x800);
}
break;
// 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) {
// 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:
// 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:
}
else {
SetPlaySeekRead(cdr.StatP, STATUS_SEEK);
- CDRLID_INT(cdReadTime * 26);
+ set_event(PSXINT_CDRLID, cdReadTime * 26);
}
break;
}
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);
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])) {
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;
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;
}
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)
{
}
}
+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;
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);
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
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;
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
memcpy(cdr.SetSector, set_loc, 3);
cdr.SetSector[3] = 0;
cdr.SetlocPending = 1;
+ cdr.errorRetryhack = 0;
}
break;
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);
// BIOS player - set flag again
cdr.Play = TRUE;
+ cdr.DriveState = DRIVESTATE_PLAY_READ;
CDRPLAYREAD_INT(cdReadTime + seekTime, 1);
start_rotating = 1;
case CdlForward:
// TODO: error 80 if stopped
- cdr.Stat = Complete;
+ IrqStat = Complete;
// GameShark CD Player: Calls 2x + Play 2x
cdr.FastForward = 1;
break;
case CdlBackward:
- cdr.Stat = Complete;
+ IrqStat = Complete;
// GameShark CD Player: Calls 2x + Play 2x
cdr.FastBackward = 1;
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:
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:
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:
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;
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:
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
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;
}
break;
case CdlID + CMD_PART2:
- SetResultSize(8);
+ SetResultSize_(8);
cdr.Result[0] = cdr.StatP;
cdr.Result[1] = 0;
cdr.Result[2] = 0;
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:
// 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;
case CdlReadToc + CMD_PART2:
case CdlReadToc + CMD_PART2 + CMD_WHILE_NOT_READY:
- cdr.Stat = Complete;
+ IrqStat = Complete;
break;
case CdlReadN:
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);
// 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;
}
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
#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)
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);
// 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)
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 (*)
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
}
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);
}
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) {
}
#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;
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;
}
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) {
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;
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;
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;
}
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;
}
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;
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);
}
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) {
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();
}
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;
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;
notaz.gp2x.de / pcsx_rearmed.git / blobdiff