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
+
enum drive_state {
DRIVESTATE_STANDBY = 0, // pause, play, read
DRIVESTATE_LID_OPEN,
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;
+ int read_ok;
u16 crc;
tmp[0] = itob(time[0]);
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);
if (CheckSBI(time))
- return;
+ return read_ok;
subq = (struct SubQ *)CDR_getBufferSub();
if (subq != NULL && cdr.CurTrack == 1) {
cdr.subq.Track, cdr.subq.Index,
cdr.subq.Relative[0], cdr.subq.Relative[1], cdr.subq.Relative[2],
cdr.subq.Absolute[0], cdr.subq.Absolute[1], cdr.subq.Absolute[2]);
+
+ return read_ok;
}
static void cdrPlayInterrupt_Autopause()
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.
+ */
+ u32 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);
void cdrInterrupt(void) {
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;
// 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;
}
*/
Find_CurTrack(cdr.SetSectorPlay);
ReadTrack(cdr.SetSectorPlay);
+ cdr.LocL[0] = LOCL_INVALID;
cdr.TrackChanged = FALSE;
cdr.FirstSector = 1;
StopReading();
SetPlaySeekRead(cdr.StatP, 0);
cdr.StatP &= ~STATUS_ROTATING;
+ cdr.LocL[0] = LOCL_INVALID;
second_resp_time = 0x800;
if (cdr.DriveState == DRIVESTATE_STANDBY)
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 = not_ready ? 70000 : 4100000;
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:
case CdlSeekL + CMD_PART2:
case CdlSeekP + CMD_PART2:
SetPlaySeekRead(cdr.StatP, 0);
+ cdr.Result[0] = cdr.StatP;
cdr.Stat = Complete;
Find_CurTrack(cdr.SetSectorPlay);
- ReadTrack(cdr.SetSectorPlay);
+ read_ok = ReadTrack(cdr.SetSectorPlay);
+ if (read_ok && (buf = CDR_getBuffer()))
+ memcpy(cdr.LocL, buf, 8);
cdr.TrackChanged = FALSE;
break;
case CdlReadToc:
case CdlReadToc + CMD_WHILE_NOT_READY:
+ cdr.LocL[0] = LOCL_INVALID;
second_resp_time = cdReadTime * 180 / 4;
start_rotating = 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);
+ cdr.LocL[0] = LOCL_INVALID;
- CDRPLAYREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime, 1);
+ cycles = (cdr.Mode & 0x80) ? cdReadTime : cdReadTime * 2;
+ cycles += seekTime;
+ 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%s\n",
- Cmd, not_ready ? " (not_ready)" : "");
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] = not_ready ? ERROR_NOTREADY : error;
}
if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) {
- printf("cdr.DriveState %d->%d\n", cdr.DriveState, DRIVESTATE_STANDBY);
cdr.DriveState = DRIVESTATE_STANDBY;
cdr.StatP |= STATUS_ROTATING;
}
static void cdrReadInterrupt(void)
{
u8 *buf = NULL, *hdr;
+ int read_ok;
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);
}
unsigned char cdrRead2(void) {
- unsigned char ret = 0;
+ unsigned char ret = cdr.Transfer[0x920];
if (cdr.FifoOffset < cdr.FifoSize)
ret = cdr.Transfer[cdr.FifoOffset++];
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)
+ 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);
if (Mode == 0) {
getCdInfo();
- cdr.FifoOffset = tmp;
+ cdr.FifoOffset = tmp < DATA_SIZE ? tmp : DATA_SIZE;
cdr.FifoSize = (cdr.Mode & 0x20) ? 2340 : 2048 + 12;
// read right sub data
notaz.gp2x.de / pcsx_rearmed.git / blobdiff