#include <assert.h>
#include "cdrom.h"
+#include "misc.h"
#include "ppf.h"
#include "psxdma.h"
+#include "psxevents.h"
#include "arm_features.h"
/* logging */
unsigned char Absolute[3];
} subq;
unsigned char TrackChanged;
- unsigned char unused3[3];
+ unsigned char ReportDelay;
+ unsigned char unused3;
+ 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 FastForward;
u8 FastBackward;
- u8 unused8;
+ u8 errorRetryhack;
u8 AttenuatorLeftToLeft, AttenuatorLeftToRight;
u8 AttenuatorRightToRight, AttenuatorRightToLeft;
#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
#define ERROR_NOTREADY (1<<7) // 0x80
#define ERROR_INVALIDCMD (1<<6) // 0x40
#define ERROR_INVALIDARG (1<<5) // 0x20
+#define ERROR_SHELLOPEN (1<<3) // 0x08
// 1x = 75 sectors per second
// PSXCLK = 1 sec in the ps
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() { \
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)) {
+ 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?)
+ if (cdr.Reading) {
+ StopReading();
+ SetResultSize(2);
+ cdr.Result[0] = cdr.StatP | STATUS_SEEKERROR;
+ cdr.Result[1] = ERROR_SHELLOPEN;
+ cdr.Stat = DiskError;
+ setIrq(0x1006);
+ }
+ if (cdr.CmdInProgress) {
+ psxRegs.interrupt &= ~(1 << PSXINT_CDR);
+ cdr.CmdInProgress = 0;
+ SetResultSize(2);
+ cdr.Result[0] = cdr.StatP | STATUS_ERROR;
+ cdr.Result[1] = ERROR_NOTREADY;
+ cdr.Stat = DiskError;
+ setIrq(0x1007);
+ }
- 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;
+ SetResultSize(1);
+ cdr.Result[0] = cdr.StatP;
cdr.Stat = DataEnd;
setIrq(0x1000); // 0x1000 just for logging purposes
StopCdda();
SetPlaySeekRead(cdr.StatP, 0);
}
- 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);
}
+
+ 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);
+
+ // need this stupidly long penalty or else Spyro2 intro desyncs
+ // note: if misapplied this breaks MGS cutscenes among other things
+ if (cyclesSinceRS > cdReadTime * 50)
+ seekTime += cdReadTime * 25;
+ // Transformers Beast Wars Transmetals does Setloc(x),SeekL,Setloc(x),ReadN
+ // and then wants some slack time
+ else if (cyclesSinceRS < cdReadTime *3/2)
+ seekTime += cdReadTime;
+
+ seekTime = MIN_VALUE(seekTime, PSXCLK * 2 / 3);
+ CDR_LOG("seek: %.2f %.2f (%.2f)\n", (float)seekTime / PSXCLK,
+ (float)seekTime / cdReadTime, (float)cyclesSinceRS / cdReadTime);
return seekTime;
}
}
}
+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)
{
+ 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);
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;
if (!cdr.Stat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT)))
cdrPlayInterrupt_Autopause();
- if (!cdr.Muted && !Config.Cdda) {
+ if (!cdr.Muted && 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);
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]);
+ if (++cdr.errorRetryhack > 100)
+ break;
error = ERROR_INVALIDARG;
goto set_error;
}
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);
case CdlPause:
StopCdda();
StopReading();
+
+ // 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;
+
/*
Gundam Battle Assault 2: much slower (*)
- Fixes boot, gameplay
}
else
{
- second_resp_time = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * 1000000);
+ second_resp_time = (((cdr.Mode & MODE_SPEED) ? 1 : 2) * 1097107);
}
SetPlaySeekRead(cdr.StatP, 0);
break;
break;
case CdlSetfilter:
- cdr.File = cdr.Param[0];
- cdr.Channel = cdr.Param[1];
+ cdr.FilterFile = cdr.Param[0];
+ cdr.FilterChannel = cdr.Param[1];
break;
case CdlSetmode:
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:
memcpy(cdr.LocL, buf, 8);
UpdateSubq(cdr.SetSectorPlay);
cdr.TrackChanged = FALSE;
+ cdr.LastReadSeekCycles = psxRegs.cycle;
break;
case CdlTest:
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);
// 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;
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;
cycles = (cdr.Mode & MODE_SPEED) ? cdReadTime : cdReadTime * 2;
cycles += seekTime;
// FALLTHROUGH
set_error:
- CDR_LOG_I("cmd %02x error %02x\n", Cmd, error);
SetResultSize(2);
cdr.Result[0] = cdr.StatP | STATUS_ERROR;
cdr.Result[1] = not_ready ? ERROR_NOTREADY : error;
cdr.Stat = 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;
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("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;
// note: CdlGetlocL should work as soon as STATUS_READ is indicated
SetPlaySeekRead(cdr.StatP, STATUS_READ | STATUS_ROTATING);
+ cdr.sectorsRead++;
read_ok = ReadTrack(cdr.SetSectorPlay);
if (read_ok)
if (!cdr.Stat && !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 & 0xe0) { // ?
+ if (subhdr->chan != 0xff)
+ log_unhandled("adpcm %d:%d\n", subhdr->file, subhdr->chan);
+ break;
+ }
+ 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;
- /* 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;
+ // accepted as adpcm
+ deliver_data = 0;
+
+ if (Config.Xa)
+ break;
+ if (!cdr.Muted && cdr.AdpcmActive) {
+ cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo);
+ SPU_playADPCMchannel(&cdr.Xa, psxRegs.cycle, 0);
}
- }
+ // decode next
+ cdr.AdpcmActive = !xa_decode_sector(&cdr.Xa, buf + 4, !cdr.AdpcmActive);
+ } 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);
/*
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
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("cmd while busy: %02x, prev %02x, busy %02x\n",
c = 2048 - (psxRegs.cycle - nextCycle);
c = MAX_VALUE(c, 512);
}
- CDR_INT(c);
+ set_event(PSXINT_CDR, c);
}
}
cdr.Stat &= ~rt;
}
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.FilterFile = 0;
+ cdr.FilterChannel = 0;
cdr.Reg2 = 0x1f;
cdr.Stat = NoIntr;
cdr.FifoOffset = DATA_SIZE; // fifo empty
- if (CdromId[0] == '\0') {
+
+ 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;
}
Find_CurTrack(cdr.SetSectorPlay);
if (!Config.Cdda)
CDR_play(cdr.SetSectorPlay);
- if (psxRegs.interrupt & (1 << PSXINT_CDRPLAY_OLD))
- CDRPLAYREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime, 1);
}
if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {
notaz.gp2x.de / pcsx_rearmed.git / blobdiff