* Handles all CD-ROM registers and functions.
*/
+#include <assert.h>
#include "cdrom.h"
#include "ppf.h"
#include "psxdma.h"
#if 0
#define CDR_LOG_I SysPrintf
#else
-#define CDR_LOG_I(...)
+#define CDR_LOG_I log_unhandled
#endif
#if 0
#define CDR_LOG_IO SysPrintf
unsigned char ResultP;
unsigned char ResultReady;
unsigned char Cmd;
- unsigned char unused4;
+ unsigned char SubqForwardSectors;
unsigned char SetlocPending;
u32 Reading;
boolean Play, Muted;
int CurTrack;
int Mode, File, Channel;
- int Reset;
- int NoErr;
+ unsigned char LocL[8];
int FirstSector;
xa_decode_t Xa;
// so (PSXCLK / 75) = cdr read time (linuzappz)
#define cdReadTime (PSXCLK / 75)
+#define LOCL_INVALID 0xff
+#define SUBQ_FORWARD_SECTORS 2u
+
enum drive_state {
DRIVESTATE_STANDBY = 0, // pause, play, read
DRIVESTATE_LID_OPEN,
new_dyna_set_event(PSXINT_CDR, eCycle); \
}
-// cdrPlaySeekReadInterrupt
-#define CDRPLAYSEEKREAD_INT(eCycle, isFirst) { \
+// cdrPlayReadInterrupt
+#define CDRPLAYREAD_INT(eCycle, isFirst) { \
u32 e_ = eCycle; \
psxRegs.interrupt |= (1 << PSXINT_CDREAD); \
if (isFirst) \
if (cdr.Stat)
{
int i;
- SysPrintf("CDR IRQ=%d cmd %02x stat %02x: ",
- !!(cdr.Stat & cdr.Reg2), log_cmd, cdr.Stat);
+ SysPrintf("%u cdrom: CDR IRQ=%d cmd %02x stat %02x: ",
+ psxRegs.cycle, !!(cdr.Stat & cdr.Reg2), log_cmd, cdr.Stat);
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);
+
switch (cdr.DriveState) {
default:
case DRIVESTATE_STANDBY:
if (stat.Status & STATUS_SHELLOPEN)
{
+ memset(cdr.Prev, 0xff, sizeof(cdr.Prev));
cdr.DriveState = DRIVESTATE_LID_OPEN;
CDRLID_INT(0x800);
}
break;
case DRIVESTATE_PREPARE_CD:
- cdr.StatP |= STATUS_SEEK;
-
- cdr.DriveState = DRIVESTATE_STANDBY;
- CDRLID_INT(cdReadTime * 26);
+ if (cdr.StatP & STATUS_SEEK) {
+ SetPlaySeekRead(cdr.StatP, 0);
+ cdr.DriveState = DRIVESTATE_STANDBY;
+ }
+ else {
+ SetPlaySeekRead(cdr.StatP, STATUS_SEEK);
+ CDRLID_INT(cdReadTime * 26);
+ }
break;
}
}
cdr.subq.Absolute[2] = itob(time[2]);
}
-static void ReadTrack(const u8 *time) {
+static int ReadTrack(const u8 *time)
+{
unsigned char tmp[3];
- struct SubQ *subq;
- u16 crc;
+ int read_ok;
tmp[0] = itob(time[0]);
tmp[1] = itob(time[1]);
tmp[2] = itob(time[2]);
if (memcmp(cdr.Prev, tmp, 3) == 0)
- return;
+ return 1;
CDR_LOG("ReadTrack *** %02x:%02x:%02x\n", tmp[0], tmp[1], tmp[2]);
- cdr.NoErr = CDR_readTrack(tmp);
- memcpy(cdr.Prev, tmp, 3);
+ read_ok = CDR_readTrack(tmp);
+ if (read_ok)
+ memcpy(cdr.Prev, tmp, 3);
+ return read_ok;
+}
+
+static void UpdateSubq(const u8 *time)
+{
+ const struct SubQ *subq;
+ u16 crc;
if (CheckSBI(time))
return;
- subq = (struct SubQ *)CDR_getBufferSub();
+ subq = (struct SubQ *)CDR_getBufferSub(MSF2SECT(time[0], time[1], time[2]));
if (subq != NULL && cdr.CurTrack == 1) {
crc = calcCrc((u8 *)subq + 12, 10);
if (crc == (((u16)subq->CRC[0] << 8) | subq->CRC[1])) {
memcpy(cdr.subq.Absolute, subq->AbsoluteAddress, 3);
}
else {
- CDR_LOG_I("subq bad crc @%02x:%02x:%02x\n",
- tmp[0], tmp[1], tmp[2]);
+ CDR_LOG_I("subq bad crc @%02d:%02d:%02d\n",
+ time[0], time[1], time[2]);
}
}
else {
//cdr.ResultReady = 1;
//cdr.Stat = DataReady;
cdr.Stat = DataEnd;
- setIrq(0x200);
+ setIrq(0x1000); // 0x1000 just for logging purposes
StopCdda();
SetPlaySeekRead(cdr.StatP, 0);
cdr.Stat = DataReady;
SetResultSize(8);
- setIrq(0x201);
+ setIrq(0x1001);
}
}
static int cdrSeekTime(unsigned char *target)
{
- int seekTime = abs(msf2sec(cdr.SetSectorPlay) - msf2sec(target)) * (cdReadTime / 200);
+ 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
return seekTime;
}
+static u32 cdrAlignTimingHack(u32 cycles)
+{
+ /*
+ * timing hack for T'ai Fu - Wrath of the Tiger:
+ * The game has a bug where it issues some cdc commands from a low priority
+ * vint handler, however there is a higher priority default bios handler
+ * that acks the vint irq and returns, so game's handler is not reached
+ * (see bios irq handler chains at e004 and the game's irq handling func
+ * at 80036810). For the game to work, vint has to arrive after the bios
+ * vint handler rejects some other irq (of which only cd and rcnt2 are
+ * active), but before the game's handler loop reads I_STAT. The time
+ * window for this is quite small (~1k cycles of so). Apparently this
+ * somehow happens naturally on the real hardware.
+ *
+ * Note: always enforcing this breaks other games like Crash PAL version
+ * (inputs get dropped because bios handler doesn't see interrupts).
+ */
+ u32 vint_rel;
+ if (psxRegs.cycle - rcnts[3].cycleStart > 250000)
+ return cycles;
+ vint_rel = rcnts[3].cycleStart + 63000 - psxRegs.cycle;
+ vint_rel += PSXCLK / 60;
+ while ((s32)(vint_rel - cycles) < 0)
+ vint_rel += PSXCLK / 60;
+ return vint_rel;
+}
+
+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);
-void cdrPlaySeekReadInterrupt(void)
+static void msfiAdd(u8 *msfi, u32 count)
{
- if (cdr.Reading) {
- cdrReadInterrupt();
- return;
- }
-
- if (!cdr.Play && (cdr.StatP & STATUS_SEEK)) {
- if (cdr.Stat) {
- CDR_LOG_I("cdrom: seek stat hack\n");
- CDRPLAYSEEKREAD_INT(0x1000, 1);
- return;
+ assert(count < 75);
+ msfi[2] += count;
+ if (msfi[2] >= 75) {
+ msfi[2] -= 75;
+ msfi[1]++;
+ if (msfi[1] == 60) {
+ msfi[1] = 0;
+ msfi[0]++;
}
- SetResultSize(1);
- cdr.StatP |= STATUS_ROTATING;
- SetPlaySeekRead(cdr.StatP, 0);
- cdr.Result[0] = cdr.StatP;
- cdr.Stat = Complete;
- setIrq(0x202);
+ }
+}
- Find_CurTrack(cdr.SetSectorPlay);
- ReadTrack(cdr.SetSectorPlay);
- cdr.TrackChanged = FALSE;
+void cdrPlayReadInterrupt(void)
+{
+ if (cdr.Reading) {
+ cdrReadInterrupt();
return;
}
cdrPlayInterrupt_Autopause();
if (!cdr.Muted && !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;
}
- cdr.SetSectorPlay[2]++;
- if (cdr.SetSectorPlay[2] == 75) {
- cdr.SetSectorPlay[2] = 0;
- cdr.SetSectorPlay[1]++;
- if (cdr.SetSectorPlay[1] == 60) {
- cdr.SetSectorPlay[1] = 0;
- cdr.SetSectorPlay[0]++;
- }
- }
+ msfiAdd(cdr.SetSectorPlay, 1);
// update for CdlGetlocP/autopause
generate_subq(cdr.SetSectorPlay);
- CDRPLAYSEEKREAD_INT(cdReadTime, 0);
+ CDRPLAYREAD_INT(cdReadTime, 0);
}
+#define CMD_PART2 0x100
+#define CMD_WHILE_NOT_READY 0x200
+
void cdrInterrupt(void) {
- int no_busy_error = 0;
int start_rotating = 0;
int error = 0;
- unsigned int seekTime = 0;
+ u32 cycles, seekTime = 0;
u32 second_resp_time = 0;
+ const void *buf;
u8 ParamC;
u8 set_loc[3];
+ int read_ok;
+ u16 not_ready = 0;
u16 Cmd;
int i;
if (cdr.Stat) {
- CDR_LOG_I("cdrom: cmd %02x with irqstat %x\n", cdr.CmdInProgress, cdr.Stat);
+ CDR_LOG_I("%u cdrom: cmd %02x with irqstat %x\n",
+ psxRegs.cycle, cdr.CmdInProgress, cdr.Stat);
+ 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]);
+ SetResultSize(1);
+ cdr.Result[0] = cdr.Irq1Pending;
+ cdr.Stat = (cdr.Irq1Pending & STATUS_ERROR) ? DiskError : DataReady;
+ cdr.Irq1Pending = 0;
+ setIrq(0x1003);
return;
}
-
- cdr.Ctrl &= ~0x80;
// default response
SetResultSize(1);
ParamC = cdr.ParamC;
if (Cmd < 0x100) {
- cdr.Cmd = 0;
+ cdr.Ctrl &= ~0x80;
cdr.ParamC = 0;
+ cdr.Cmd = 0;
+ }
+
+ switch (cdr.DriveState) {
+ case DRIVESTATE_PREPARE_CD:
+ if (Cmd > 2) {
+ // Syphon filter 2 expects commands to work shortly after it sees
+ // STATUS_ROTATING, so give up trying to emulate the startup seq
+ cdr.DriveState = DRIVESTATE_STANDBY;
+ cdr.StatP &= ~STATUS_SEEK;
+ psxRegs.interrupt &= ~(1 << PSXINT_CDRLID);
+ break;
+ }
+ // fallthrough
+ case DRIVESTATE_LID_OPEN:
+ case DRIVESTATE_RESCAN_CD:
+ // no disk or busy with the initial scan, allowed cmds are limited
+ not_ready = CMD_WHILE_NOT_READY;
+ break;
}
- switch (Cmd) {
+ switch (Cmd | not_ready) {
case CdlNop:
+ case CdlNop + CMD_WHILE_NOT_READY:
if (cdr.DriveState != DRIVESTATE_LID_OPEN)
cdr.StatP &= ~STATUS_SHELLOPEN;
- no_busy_error = 1;
break;
case CdlSetloc:
+ case CdlSetloc + CMD_WHILE_NOT_READY:
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("Invalid/out of range seek to %02X:%02X:%02X\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
+ 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;
goto set_error;
}
- plays tracks without retry play
*/
Find_CurTrack(cdr.SetSectorPlay);
- ReadTrack(cdr.SetSectorPlay);
+ generate_subq(cdr.SetSectorPlay);
+ cdr.LocL[0] = LOCL_INVALID;
+ cdr.SubqForwardSectors = 1;
cdr.TrackChanged = FALSE;
cdr.FirstSector = 1;
// BIOS player - set flag again
cdr.Play = TRUE;
- CDRPLAYSEEKREAD_INT(cdReadTime + seekTime, 1);
+ CDRPLAYREAD_INT(cdReadTime + seekTime, 1);
start_rotating = 1;
break;
start_rotating = 1;
break;
- case CdlStandby + 0x100:
+ case CdlStandby + CMD_PART2:
cdr.Stat = Complete;
break;
StopReading();
SetPlaySeekRead(cdr.StatP, 0);
cdr.StatP &= ~STATUS_ROTATING;
+ cdr.LocL[0] = LOCL_INVALID;
second_resp_time = 0x800;
if (cdr.DriveState == DRIVESTATE_STANDBY)
cdr.DriveState = DRIVESTATE_STOPPED;
break;
- case CdlStop + 0x100:
+ case CdlStop + CMD_PART2:
cdr.Stat = Complete;
break;
second_resp_time = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * 1000000);
}
SetPlaySeekRead(cdr.StatP, 0);
- cdr.Ctrl |= 0x80;
break;
- case CdlPause + 0x100:
+ case CdlPause + CMD_PART2:
cdr.Stat = Complete;
break;
case CdlReset:
+ case CdlReset + CMD_WHILE_NOT_READY:
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 */
- second_resp_time = 4100000;
- no_busy_error = 1;
+ second_resp_time = not_ready ? 70000 : 4100000;
start_rotating = 1;
break;
- case CdlReset + 0x100:
+ case CdlReset + CMD_PART2:
+ case CdlReset + CMD_PART2 + CMD_WHILE_NOT_READY:
cdr.Stat = Complete;
break;
break;
case CdlSetmode:
+ case CdlSetmode + CMD_WHILE_NOT_READY:
CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]);
cdr.Mode = cdr.Param[0];
- no_busy_error = 1;
break;
case CdlGetparam:
+ case CdlGetparam + CMD_WHILE_NOT_READY:
/* Gameblabla : According to mednafen, Result size should be 5 and done this way. */
SetResultSize(5);
cdr.Result[1] = cdr.Mode;
cdr.Result[2] = 0;
cdr.Result[3] = cdr.File;
cdr.Result[4] = cdr.Channel;
- no_busy_error = 1;
break;
case CdlGetlocL:
+ if (cdr.LocL[0] == LOCL_INVALID) {
+ error = 0x80;
+ goto set_error;
+ }
SetResultSize(8);
- memcpy(cdr.Result, cdr.Transfer, 8);
+ memcpy(cdr.Result, cdr.LocL, 8);
break;
case CdlGetlocP:
start_rotating = 1;
break;
- case CdlReadT + 0x100:
+ case CdlReadT + CMD_PART2:
cdr.Stat = Complete;
break;
case CdlSeekP:
StopCdda();
StopReading();
- SetPlaySeekRead(cdr.StatP, STATUS_SEEK);
+ SetPlaySeekRead(cdr.StatP, STATUS_SEEK | STATUS_ROTATING);
seekTime = cdrSeekTime(cdr.SetSector);
memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
Rockman X5 = 0.5-4x
- fix capcom logo
*/
- CDRPLAYSEEKREAD_INT(cdReadTime + seekTime, 1);
+ second_resp_time = cdReadTime + seekTime;
start_rotating = 1;
break;
+ case CdlSeekL + CMD_PART2:
+ case CdlSeekP + CMD_PART2:
+ SetPlaySeekRead(cdr.StatP, 0);
+ cdr.Result[0] = cdr.StatP;
+ cdr.Stat = 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.TrackChanged = FALSE;
+ break;
+
case CdlTest:
+ case CdlTest + CMD_WHILE_NOT_READY:
switch (cdr.Param[0]) {
case 0x20: // System Controller ROM Version
SetResultSize(4);
memcpy(cdr.Result, Test23, 4);
break;
}
- no_busy_error = 1;
break;
case CdlID:
second_resp_time = 20480;
break;
- case CdlID + 0x100:
+ case CdlID + CMD_PART2:
SetResultSize(8);
cdr.Result[0] = cdr.StatP;
cdr.Result[1] = 0;
break;
case CdlInit:
+ case CdlInit + CMD_WHILE_NOT_READY:
StopCdda();
StopReading();
SetPlaySeekRead(cdr.StatP, 0);
cdr.StatP |= STATUS_SHELLOPEN;
cdr.DriveState = DRIVESTATE_RESCAN_CD;
CDRLID_INT(20480);
- no_busy_error = 1;
start_rotating = 1;
break;
case CdlGetQ:
- no_busy_error = 1;
+ case CdlGetQ + CMD_WHILE_NOT_READY:
break;
case CdlReadToc:
+ case CdlReadToc + CMD_WHILE_NOT_READY:
+ cdr.LocL[0] = LOCL_INVALID;
second_resp_time = cdReadTime * 180 / 4;
- no_busy_error = 1;
start_rotating = 1;
break;
- case CdlReadToc + 0x100:
+ case CdlReadToc + CMD_PART2:
+ case CdlReadToc + CMD_PART2 + CMD_WHILE_NOT_READY:
cdr.Stat = Complete;
- no_busy_error = 1;
break;
case CdlReadN:
case CdlReadS:
+ if (cdr.Reading && !cdr.SetlocPending)
+ break;
+
Find_CurTrack(cdr.SetlocPending ? cdr.SetSector : cdr.SetSectorPlay);
if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1)
// Fighting Force 2 - update subq time immediately
// - fixes new game
- ReadTrack(cdr.SetSectorPlay);
+ UpdateSubq(cdr.SetSectorPlay);
+ cdr.LocL[0] = LOCL_INVALID;
+ cdr.SubqForwardSectors = 1;
- CDRPLAYSEEKREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime, 1);
+ cycles = (cdr.Mode & 0x80) ? cdReadTime : cdReadTime * 2;
+ cycles += seekTime;
+ if (Config.hacks.cdr_read_timing)
+ cycles = cdrAlignTimingHack(cycles);
+ CDRPLAYREAD_INT(cycles, 1);
SetPlaySeekRead(cdr.StatP, STATUS_SEEK);
start_rotating = 1;
break;
+
case CdlSync:
default:
- CDR_LOG_I("Invalid command: %02x\n", Cmd);
error = ERROR_INVALIDCMD;
// FALLTHROUGH
set_error:
+ CDR_LOG_I("cdrom: cmd %02x error %02x\n", Cmd, error);
SetResultSize(2);
cdr.Result[0] = cdr.StatP | STATUS_ERROR;
- cdr.Result[1] = error;
+ cdr.Result[1] = not_ready ? ERROR_NOTREADY : error;
cdr.Stat = DiskError;
break;
}
cdr.StatP |= STATUS_ROTATING;
}
- if (!no_busy_error) {
- switch (cdr.DriveState) {
- case DRIVESTATE_LID_OPEN:
- case DRIVESTATE_RESCAN_CD:
- case DRIVESTATE_PREPARE_CD:
- SetResultSize(2);
- cdr.Result[0] = cdr.StatP | STATUS_ERROR;
- cdr.Result[1] = ERROR_NOTREADY;
- cdr.Stat = DiskError;
- break;
- }
- }
-
if (second_resp_time) {
cdr.CmdInProgress = Cmd | 0x100;
CDR_INT(second_resp_time);
}
else if (cdr.Cmd && cdr.Cmd != (Cmd & 0xff)) {
cdr.CmdInProgress = cdr.Cmd;
- CDR_LOG_I("cdrom: cmd %02x came before %02x finished\n", cdr.Cmd, Cmd);
+ CDR_LOG_I("%u cdrom: cmd %02x came before %02x finished\n",
+ psxRegs.cycle, cdr.Cmd, Cmd);
}
setIrq(Cmd);
} while (0)
#endif
-void cdrAttenuate(s16 *buf, int samples, int stereo)
+static void cdrPrepCdda(s16 *buf, int samples)
+{
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+ int i;
+ for (i = 0; i < samples; i++) {
+ buf[i * 2 + 0] = SWAP16(buf[i * 2 + 0]);
+ buf[i * 2 + 1] = SWAP16(buf[i * 2 + 1]);
+ }
+#endif
+}
+
+static void cdrAttenuate(s16 *buf, int samples, int stereo)
{
int i, l, r;
int ll = cdr.AttenuatorLeftToLeft;
SetResultSize(1);
cdr.Result[0] = result;
cdr.Stat = (result & STATUS_ERROR) ? DiskError : DataReady;
- setIrq(0x203);
+ setIrq(0x1004);
}
static void cdrUpdateTransferBuf(const u8 *buf)
static void cdrReadInterrupt(void)
{
u8 *buf = NULL, *hdr;
+ u8 subqPos[3];
+ int read_ok;
+
+ memcpy(subqPos, cdr.SetSectorPlay, sizeof(subqPos));
+ msfiAdd(subqPos, cdr.SubqForwardSectors);
+ UpdateSubq(subqPos);
+ if (cdr.SubqForwardSectors < SUBQ_FORWARD_SECTORS) {
+ cdr.SubqForwardSectors++;
+ CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0);
+ return;
+ }
+ // note: CdlGetlocL should work as soon as STATUS_READ is indicated
SetPlaySeekRead(cdr.StatP, STATUS_READ | STATUS_ROTATING);
- ReadTrack(cdr.SetSectorPlay);
- if (cdr.NoErr)
+ read_ok = ReadTrack(cdr.SetSectorPlay);
+ if (read_ok)
buf = CDR_getBuffer();
if (buf == NULL)
- cdr.NoErr = 0;
+ read_ok = 0;
- if (!cdr.NoErr) {
+ if (!read_ok) {
CDR_LOG_I("cdrReadInterrupt() Log: err\n");
- memset(cdr.Transfer, 0, DATA_SIZE);
cdrReadInterruptSetResult(cdr.StatP | STATUS_ERROR);
return;
}
+ memcpy(cdr.LocL, buf, 8);
if (!cdr.Irq1Pending)
cdrUpdateTransferBuf(buf);
if (!(cdr.Mode & MODE_STRSND) || !(buf[4+2] & 0x4))
cdrReadInterruptSetResult(cdr.StatP);
- cdr.SetSectorPlay[2]++;
- if (cdr.SetSectorPlay[2] == 75) {
- cdr.SetSectorPlay[2] = 0;
- cdr.SetSectorPlay[1]++;
- if (cdr.SetSectorPlay[1] == 60) {
- cdr.SetSectorPlay[1] = 0;
- cdr.SetSectorPlay[0]++;
- }
- }
-
- if (!cdr.Irq1Pending) {
- // update for CdlGetlocP
- ReadTrack(cdr.SetSectorPlay);
- }
+ msfiAdd(cdr.SetSectorPlay, 1);
- CDRPLAYSEEKREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0);
-}
-
-static void doMissedIrqs(void)
-{
- if (cdr.Irq1Pending)
- {
- // hand out the "newest" sector, according to nocash
- cdrUpdateTransferBuf(CDR_getBuffer());
- CDR_LOG_I("cdrom: %x:%02x:%02x loaded on ack\n",
- cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]);
- SetResultSize(1);
- cdr.Result[0] = cdr.Irq1Pending;
- cdr.Stat = (cdr.Irq1Pending & STATUS_ERROR) ? DiskError : DataReady;
- cdr.Irq1Pending = 0;
- setIrq(0x205);
- return;
- }
- if (!(psxRegs.interrupt & (1 << PSXINT_CDR)) && cdr.CmdInProgress)
- CDR_INT(256);
+ CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0);
}
/*
}
#ifdef CDR_LOG_CMD_IRQ
- SysPrintf("CD1 write: %x (%s)", rt, CmdName[rt]);
+ SysPrintf("%u cdrom: CD1 write: %x (%s)", psxRegs.cycle, rt, CmdName[rt]);
if (cdr.ParamC) {
int i;
SysPrintf(" Param[%d] = {", cdr.ParamC);
CDR_INT(5000);
}
else {
- CDR_LOG_I("cdr: cmd while busy: %02x, prev %02x, busy %02x\n",
- rt, cdr.Cmd, cdr.CmdInProgress);
+ CDR_LOG_I("%u cdrom: cmd while busy: %02x, prev %02x, busy %02x\n",
+ psxRegs.cycle, rt, cdr.Cmd, cdr.CmdInProgress);
if (cdr.CmdInProgress < 0x100) // no pending 2nd response
cdr.CmdInProgress = rt;
}
}
unsigned char cdrRead2(void) {
- unsigned char ret = 0;
+ unsigned char ret = cdr.Transfer[0x920];
if (cdr.FifoOffset < cdr.FifoSize)
ret = cdr.Transfer[cdr.FifoOffset++];
return;
case 1:
cdr.Reg2 = rt;
- setIrq(0x204);
+ setIrq(0x1005);
return;
case 2:
cdr.AttenuatorLeftToLeftT = rt;
case 0:
break; // transfer
case 1:
+ if (cdr.Stat & rt) {
+ u32 nextCycle = psxRegs.intCycle[PSXINT_CDR].sCycle
+ + psxRegs.intCycle[PSXINT_CDR].cycle;
#ifdef CDR_LOG_CMD_IRQ
- if (cdr.Stat & rt)
- SysPrintf("ack %02x\n", cdr.Stat & rt);
+ SysPrintf("%u cdrom: ack %02x (w=%02x p=%d,%d)\n",
+ psxRegs.cycle, cdr.Stat & rt, rt,
+ !!(psxRegs.interrupt & (1 << PSXINT_CDR)),
+ nextCycle - psxRegs.cycle);
#endif
+ // note: Croc, Shadow Tower (more) vs Discworld Noir (<993)
+ if (!(psxRegs.interrupt & (1 << PSXINT_CDR)) &&
+ (cdr.CmdInProgress || cdr.Irq1Pending))
+ {
+ s32 c = 2048 - (psxRegs.cycle - nextCycle);
+ c = MAX_VALUE(c, 512);
+ CDR_INT(c);
+ }
+ }
cdr.Stat &= ~rt;
if (rt & 0x40)
cdr.ParamC = 0;
- doMissedIrqs();
return;
case 2:
cdr.AttenuatorLeftToRightT = rt;
switch (chcr & 0x71000000) {
case 0x11000000:
ptr = (u8 *)PSXM(madr);
- if (ptr == NULL) {
+ if (ptr == INVALID_PTR) {
CDR_LOG_I("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n");
break;
}
{
memcpy(ptr, cdr.Transfer + cdr.FifoOffset, size);
cdr.FifoOffset += size;
- psxCpu->Clear(madr, size / 4);
}
+ if (size < cdsize) {
+ CDR_LOG_I("cdrom: dma3 %d/%d\n", size, cdsize);
+ memset(ptr + size, cdr.Transfer[0x920], cdsize - size);
+ }
+ psxCpu->Clear(madr, cdsize / 4);
CDRDMA_INT((cdsize/4) * 24);
return;
default:
- CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr);
+ CDR_LOG_I("psxDma3() Log: Unknown cddma %x\n", chcr);
break;
}
cdr.Channel = 1;
cdr.Reg2 = 0x1f;
cdr.Stat = NoIntr;
- cdr.DriveState = DRIVESTATE_STANDBY;
- cdr.StatP = STATUS_ROTATING;
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;
+ }
// BIOS player - default values
cdr.AttenuatorLeftToLeft = 0x80;
if (Mode == 0) {
getCdInfo();
- cdr.FifoOffset = tmp;
+ cdr.FifoOffset = tmp < DATA_SIZE ? tmp : DATA_SIZE;
cdr.FifoSize = (cdr.Mode & 0x20) ? 2340 : 2048 + 12;
+ if (cdr.SubqForwardSectors > SUBQ_FORWARD_SECTORS)
+ cdr.SubqForwardSectors = SUBQ_FORWARD_SECTORS;
// read right sub data
tmpp[0] = btoi(cdr.Prev[0]);
if (!Config.Cdda)
CDR_play(cdr.SetSectorPlay);
if (psxRegs.interrupt & (1 << PSXINT_CDRPLAY_OLD))
- CDRPLAYSEEKREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime, 1);
+ CDRPLAYREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime, 1);
}
if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {
notaz.gp2x.de / pcsx_rearmed.git / blobdiff