#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 Readed;
+ unsigned char unused4;
unsigned char SetlocPending;
u32 Reading;
xa_decode_t Xa;
- u32 unused4;
+ u16 FifoOffset;
+ u16 FifoSize;
u16 CmdInProgress;
- u16 unused5;
+ u8 Irq1Pending;
+ u8 unused5;
u32 unused6;
u8 unused7;
u8 AttenuatorLeftToLeftT, AttenuatorLeftToRightT;
u8 AttenuatorRightToRightT, AttenuatorRightToLeftT;
} cdr;
-static unsigned char *pTransfer;
static s16 read_buf[CD_FRAMESIZE_RAW/2];
/* CD-ROM magic numbers */
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");
//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 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)
{
cdr.StatP |= STATUS_ROTATING;
SetPlaySeekRead(cdr.StatP, 0);
cdr.Result[0] = cdr.StatP;
- if (cdr.Stat == 0) {
- cdr.Stat = Complete;
- setIrq(0x202);
- }
+ cdr.Stat = Complete;
+ setIrq(0x1002);
Find_CurTrack(cdr.SetSectorPlay);
ReadTrack(cdr.SetSectorPlay);
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;
}
}
- CDRPLAYSEEKREAD_INT(cdReadTime, 0);
-
// update for CdlGetlocP/autopause
generate_subq(cdr.SetSectorPlay);
+
+ CDRPLAYSEEKREAD_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 second_resp_time = 0;
u8 ParamC;
u8 set_loc[3];
+ u16 not_ready = 0;
u16 Cmd;
int i;
- // Reschedule IRQ
if (cdr.Stat) {
- CDR_LOG_I("cdrom: cmd %02x with irqstat %x\n", cdr.CmdInProgress, cdr.Stat);
- CDR_INT(1000);
+ 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 (Cmd) {
+ switch (cdr.DriveState) {
+ case DRIVESTATE_LID_OPEN:
+ case DRIVESTATE_RESCAN_CD:
+ case DRIVESTATE_PREPARE_CD:
+ // no disk or busy with the initial scan, allowed cmds are limited
+ not_ready = CMD_WHILE_NOT_READY;
+ break;
+ }
+
+ 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
start_rotating = 1;
break;
- case CdlStandby + 0x100:
+ case CdlStandby + CMD_PART2:
cdr.Stat = Complete;
break;
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.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:
start_rotating = 1;
break;
- case CdlReadT + 0x100:
+ case CdlReadT + CMD_PART2:
cdr.Stat = Complete;
break;
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:
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:
break;
case CdlSync:
default:
- CDR_LOG_I("Invalid command: %02x\n", Cmd);
+ CDR_LOG_I("Invalid command: %02x%s\n",
+ Cmd, not_ready ? " (not_ready)" : "");
error = ERROR_INVALIDCMD;
// FALLTHROUGH
set_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;
}
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;
}
- 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_INT(256);
+ 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;
}
}
-static void cdrReadInterrupt(void)
+static void cdrReadInterruptSetResult(unsigned char result)
{
- u8 *buf;
-
if (cdr.Stat) {
- CDR_LOG_I("cdrom: read stat hack %02x %02x\n", cdr.Cmd, cdr.Stat);
- CDRPLAYSEEKREAD_INT(2048, 1);
+ CDR_LOG_I("cdrom: %d:%02d:%02d irq miss, cmd=%02x irqstat=%02x\n",
+ cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2],
+ cdr.CmdInProgress, cdr.Stat);
+ cdr.Irq1Pending = result;
return;
}
-
SetResultSize(1);
+ cdr.Result[0] = result;
+ cdr.Stat = (result & STATUS_ERROR) ? DiskError : DataReady;
+ setIrq(0x1004);
+}
+
+static void cdrUpdateTransferBuf(const u8 *buf)
+{
+ if (!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]);
+ if (cdr.FifoOffset < 2048 + 12)
+ CDR_LOG("cdrom: FifoOffset(1) %d/%d\n", cdr.FifoOffset, cdr.FifoSize);
+}
+
+static void cdrReadInterrupt(void)
+{
+ u8 *buf = NULL, *hdr;
+
SetPlaySeekRead(cdr.StatP, STATUS_READ | STATUS_ROTATING);
- cdr.Result[0] = cdr.StatP;
ReadTrack(cdr.SetSectorPlay);
-
- buf = CDR_getBuffer();
+ if (cdr.NoErr)
+ buf = CDR_getBuffer();
if (buf == NULL)
cdr.NoErr = 0;
if (!cdr.NoErr) {
CDR_LOG_I("cdrReadInterrupt() Log: err\n");
memset(cdr.Transfer, 0, DATA_SIZE);
- cdr.Stat = DiskError;
- cdr.Result[0] |= STATUS_ERROR;
- setIrq(0x205);
+ cdrReadInterruptSetResult(cdr.StatP | STATUS_ERROR);
return;
}
- memcpy(cdr.Transfer, buf, DATA_SIZE);
- CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]);
-
-
- CDR_LOG("cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]);
+ if (!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 = cdr.Transfer[4 + 0];
- cdr.Channel = cdr.Transfer[4 + 1];
+ cdr.File = hdr[0];
+ cdr.Channel = hdr[1];
}
/* Gameblabla
* 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((cdr.Transfer[4 + 2] & 0x4) &&
- (cdr.Transfer[4 + 1] == cdr.Channel) &&
- (cdr.Transfer[4 + 0] == cdr.File) && cdr.Channel != 255) {
- int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector);
+ 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);
}
}
+ /*
+ Croc 2: $40 - only FORM1 (*)
+ Judge Dredd: $C8 - only FORM1 (*)
+ Sim Theme Park - no adpcm at all (zero)
+ */
+
+ 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.Readed = 0;
-
- CDRPLAYSEEKREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 0);
-
- /*
- Croc 2: $40 - only FORM1 (*)
- Judge Dredd: $C8 - only FORM1 (*)
- Sim Theme Park - no adpcm at all (zero)
- */
-
- if (!(cdr.Mode & MODE_STRSND) || !(cdr.Transfer[4+2] & 0x4)) {
- cdr.Stat = DataReady;
- setIrq(0x203);
+ if (!cdr.Irq1Pending) {
+ // update for CdlGetlocP
+ ReadTrack(cdr.SetSectorPlay);
}
- // update for CdlGetlocP
- ReadTrack(cdr.SetSectorPlay);
+ CDRPLAYSEEKREAD_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;
+ unsigned char ret = 0;
- if (cdr.Readed == 0) {
- ret = 0;
- } else {
- ret = *pTransfer++;
- }
+ if (cdr.FifoOffset < cdr.FifoSize)
+ ret = cdr.Transfer[cdr.FifoOffset++];
+ else
+ CDR_LOG_I("cdrom: read empty fifo (%d)\n", cdr.FifoSize);
CDR_LOG_IO("cdr r2.dat: %02x\n", ret);
return ret;
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) {
#ifdef CDR_LOG_CMD_IRQ
- if (cdr.Stat & rt)
- SysPrintf("ack %02x\n", cdr.Stat & rt);
+ SysPrintf("%u cdrom: ack %02x (w %02x)\n",
+ psxRegs.cycle, cdr.Stat & rt, rt);
#endif
+ // note: Croc vs Discworld Noir
+ if (!(psxRegs.interrupt & (1 << PSXINT_CDR)) &&
+ (cdr.CmdInProgress || cdr.Irq1Pending))
+ CDR_INT(850); // 711-993
+ }
cdr.Stat &= ~rt;
if (rt & 0x40)
return;
}
- if ((rt & 0x80) && cdr.Readed == 0) {
- cdr.Readed = 1;
- pTransfer = cdr.Transfer;
-
+ // test: Viewpoint
+ if ((rt & 0x80) && cdr.FifoOffset < cdr.FifoSize) {
+ CDR_LOG("cdrom: FifoOffset(2) %d/%d\n", cdr.FifoOffset, cdr.FifoSize);
+ }
+ else if (rt & 0x80) {
switch (cdr.Mode & 0x30) {
case MODE_SIZE_2328:
case 0x00:
- pTransfer += 12;
+ cdr.FifoOffset = 12;
+ cdr.FifoSize = 2048 + 12;
break;
case MODE_SIZE_2340:
- pTransfer += 0;
- break;
-
default:
+ cdr.FifoOffset = 0;
+ cdr.FifoSize = 2340;
break;
}
}
+ else if (!(rt & 0xc0))
+ cdr.FifoOffset = DATA_SIZE; // fifo empty
}
void psxDma3(u32 madr, u32 bcr, u32 chcr) {
CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr);
- switch (chcr) {
+ switch (chcr & 0x71000000) {
case 0x11000000:
- case 0x11400100:
- if (cdr.Readed == 0) {
- CDR_LOG("psxDma3() Log: *** DMA 3 *** NOT READY\n");
- break;
- }
-
- cdsize = (bcr & 0xffff) * 4;
-
- // Ape Escape: bcr = 0001 / 0000
- // - fix boot
- if( cdsize == 0 )
- {
- switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {
- case MODE_SIZE_2340: cdsize = 2340; break;
- case MODE_SIZE_2328: cdsize = 2328; break;
- default:
- case MODE_SIZE_2048: cdsize = 2048; break;
- }
- }
-
-
ptr = (u8 *)PSXM(madr);
if (ptr == NULL) {
- CDR_LOG("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n");
+ CDR_LOG_I("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n");
break;
}
+ cdsize = (((bcr - 1) & 0xffff) + 1) * 4;
+
/*
GS CDX: Enhancement CD crash
- Setloc 0:0:0
- CdlPlay
- Spams DMA3 and gets buffer overrun
*/
- size = CD_FRAMESIZE_RAW - (pTransfer - cdr.Transfer);
+ size = DATA_SIZE - cdr.FifoOffset;
if (size > cdsize)
size = cdsize;
if (size > 0)
{
- memcpy(ptr, pTransfer, size);
+ 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);
- psxCpu->Clear(madr, cdsize / 4);
- pTransfer += cdsize;
+ CDRDMA_INT((cdsize/4) * 24);
- if( chcr == 0x11400100 ) {
+ HW_DMA3_CHCR &= SWAPu32(~0x10000000);
+ if (chcr & 0x100) {
HW_DMA3_MADR = SWAPu32(madr + cdsize);
- CDRDMA_INT( (cdsize/4) / 4 );
+ HW_DMA3_BCR &= SWAPu32(0xffff0000);
}
- else if( chcr == 0x11000000 ) {
- // CDRDMA_INT( (cdsize/4) * 1 );
+ else {
// halted
- psxRegs.cycle += (cdsize/4) * 24/2;
- CDRDMA_INT(16);
+ psxRegs.cycle += (cdsize/4) * 24 - 20;
}
return;
default:
- CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr);
+ CDR_LOG_I("psxDma3() Log: Unknown cddma %x\n", chcr);
break;
}
cdr.Stat = NoIntr;
cdr.DriveState = DRIVESTATE_STANDBY;
cdr.StatP = STATUS_ROTATING;
- pTransfer = cdr.Transfer;
+ cdr.FifoOffset = DATA_SIZE; // fifo empty
// BIOS player - default values
cdr.AttenuatorLeftToLeft = 0x80;
if (Mode == 1) {
cdr.ParamP = cdr.ParamC;
- tmp = pTransfer - cdr.Transfer;
+ tmp = cdr.FifoOffset;
}
gzfreeze(&tmp, sizeof(tmp));
if (Mode == 0) {
getCdInfo();
- pTransfer = cdr.Transfer + tmp;
+ cdr.FifoOffset = tmp;
+ cdr.FifoSize = (cdr.Mode & 0x20) ? 2340 : 2048 + 12;
// read right sub data
tmpp[0] = btoi(cdr.Prev[0]);
notaz.gp2x.de / pcsx_rearmed.git / blobdiff