X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?p=pcsx_rearmed.git;a=blobdiff_plain;f=libpcsxcore%2Fcdrom.c;h=38fecf71996ae1f6f58d3de2ed08276f35bc9dc8;hp=fff316065484a3e969ae8613b060206754ba92df;hb=650adfd2da779ba8855623362c2900583e22931e;hpb=9f8b032dc5074e29f2e93ce06651f6da3bb70a86 diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c index fff31606..38fecf71 100644 --- a/libpcsxcore/cdrom.c +++ b/libpcsxcore/cdrom.c @@ -14,10 +14,10 @@ * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * - * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * ***************************************************************************/ -/* +/* * Handles all CD-ROM registers and functions. */ @@ -25,7 +25,26 @@ #include "ppf.h" #include "psxdma.h" +/* logging */ +#if 0 +#define CDR_LOG SysPrintf +#else +#define CDR_LOG(...) +#endif +#if 0 +#define CDR_LOG_I SysPrintf +#else +#define CDR_LOG_I(...) +#endif +#if 0 +#define CDR_LOG_IO SysPrintf +#else +#define CDR_LOG_IO(...) +#endif +//#define CDR_LOG_CMD_IRQ + cdrStruct cdr; +static unsigned char *pTransfer; /* CD-ROM magic numbers */ #define CdlSync 0 @@ -57,16 +76,9 @@ cdrStruct cdr; #define CdlID 26 #define CdlReadS 27 #define CdlReset 28 +#define CdlGetQ 29 #define CdlReadToc 30 -#define AUTOPAUSE 249 -#define READ_ACK 250 -#define READ 251 -#define REPPLAY_ACK 252 -#define REPPLAY 253 -#define ASYNC 254 -/* don't set 255, it's reserved */ - char *CmdName[0x100]= { "CdlSync", "CdlNop", "CdlSetloc", "CdlPlay", "CdlForward", "CdlBackward", "CdlReadN", "CdlStandby", @@ -97,6 +109,7 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 }; #define MODE_STRSND (1<<6) // 0x40 ADPCM on/off #define MODE_SIZE_2340 (1<<5) // 0x20 #define MODE_SIZE_2328 (1<<4) // 0x10 +#define MODE_SIZE_2048 (0<<4) // 0x00 #define MODE_SF (1<<3) // 0x08 channel on/off #define MODE_REPORT (1<<2) // 0x04 #define MODE_AUTOPAUSE (1<<1) // 0x02 @@ -112,21 +125,42 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 }; #define STATUS_ROTATING (1<<1) // 0x02 #define STATUS_ERROR (1<<0) // 0x01 - +/* Errors */ +#define ERROR_NOT_READY (1<<7) // 0x80 +#define ERROR_INVALIDCMD (1<<6) // 0x40 +#define ERROR_INVALIDARG (1<<5) // 0x20 // 1x = 75 sectors per second // PSXCLK = 1 sec in the ps // so (PSXCLK / 75) = cdr read time (linuzappz) #define cdReadTime (PSXCLK / 75) +enum drive_state { + DRIVESTATE_STANDBY = 0, + DRIVESTATE_LID_OPEN, + DRIVESTATE_RESCAN_CD, + DRIVESTATE_PREPARE_CD, + DRIVESTATE_STOPPED, +}; + +// for cdr.Seeked +enum seeked_state { + SEEK_PENDING = 0, + SEEK_DONE = 1, +}; + static struct CdrStat stat; -static struct SubQ *subq; -static unsigned int msf2sec(char *msf) { +static unsigned int msf2sec(const u8 *msf) { return ((msf[0] * 60 + msf[1]) * 75) + msf[2]; } -static void sec2msf(unsigned int s, char *msf) { +// for that weird psemu API.. +static unsigned int fsm2sec(const u8 *msf) { + return ((msf[2] * 60 + msf[1]) * 75) + msf[0]; +} + +static void sec2msf(unsigned int s, u8 *msf) { msf[0] = s / 75 / 60; s = s - msf[0] * 75 * 60; msf[1] = s / 75; @@ -134,7 +168,7 @@ static void sec2msf(unsigned int s, char *msf) { msf[2] = s; } - +// cdrInterrupt #define CDR_INT(eCycle) { \ psxRegs.interrupt |= (1 << PSXINT_CDR); \ psxRegs.intCycle[PSXINT_CDR].cycle = eCycle; \ @@ -142,6 +176,7 @@ static void sec2msf(unsigned int s, char *msf) { new_dyna_set_event(PSXINT_CDR, eCycle); \ } +// cdrReadInterrupt #define CDREAD_INT(eCycle) { \ psxRegs.interrupt |= (1 << PSXINT_CDREAD); \ psxRegs.intCycle[PSXINT_CDREAD].cycle = eCycle; \ @@ -149,6 +184,7 @@ static void sec2msf(unsigned int s, char *msf) { new_dyna_set_event(PSXINT_CDREAD, eCycle); \ } +// cdrLidSeekInterrupt #define CDRLID_INT(eCycle) { \ psxRegs.interrupt |= (1 << PSXINT_CDRLID); \ psxRegs.intCycle[PSXINT_CDRLID].cycle = eCycle; \ @@ -156,11 +192,12 @@ static void sec2msf(unsigned int s, char *msf) { new_dyna_set_event(PSXINT_CDRLID, eCycle); \ } -#define StartReading(type, eCycle) { \ - cdr.Reading = type; \ - cdr.FirstSector = 1; \ - cdr.Readed = 0xff; \ - AddIrqQueue(READ_ACK, eCycle); \ +// cdrPlayInterrupt +#define CDRMISC_INT(eCycle) { \ + psxRegs.interrupt |= (1 << PSXINT_CDRPLAY); \ + psxRegs.intCycle[PSXINT_CDRPLAY].cycle = eCycle; \ + psxRegs.intCycle[PSXINT_CDRPLAY].sCycle = psxRegs.cycle; \ + new_dyna_set_event(PSXINT_CDRPLAY, eCycle); \ } #define StopReading() { \ @@ -168,7 +205,7 @@ static void sec2msf(unsigned int s, char *msf) { cdr.Reading = 0; \ psxRegs.interrupt &= ~(1 << PSXINT_CDREAD); \ } \ - cdr.StatP &= ~STATUS_READ;\ + cdr.StatP &= ~(STATUS_READ|STATUS_SEEK);\ } #define StopCdda() { \ @@ -183,395 +220,396 @@ static void sec2msf(unsigned int s, char *msf) { } #define SetResultSize(size) { \ - cdr.ResultP = 0; \ + cdr.ResultP = 0; \ cdr.ResultC = size; \ cdr.ResultReady = 1; \ } +static void setIrq(void) +{ + if (cdr.Stat & cdr.Reg2) + psxHu32ref(0x1070) |= SWAP32((u32)0x4); +} +// timing used in this function was taken from tests on real hardware +// (yes it's slow, but you probably don't want to modify it) void cdrLidSeekInterrupt() { - // turn back on checking - if( cdr.LidCheck == 0x10 ) - { - cdr.LidCheck = 0; - } - - // official lid close - else if( cdr.LidCheck == 0x30 ) - { - // GS CDX 3.3: $13 - cdr.StatP |= STATUS_ROTATING; - - - // GS CDX 3.3 - ~50 getlocp tries - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x40; - } - - // turn off ready - else if( cdr.LidCheck == 0x40 ) - { - // GS CDX 3.3: $01 - cdr.StatP &= ~STATUS_SHELLOPEN; - cdr.StatP &= ~STATUS_ROTATING; - - - // GS CDX 3.3 - ~50 getlocp tries - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x50; - } - - // now seek - else if( cdr.LidCheck == 0x50 ) - { - // GameShark Lite: Start seeking ($42) - cdr.StatP |= STATUS_SEEK; - cdr.StatP |= STATUS_ROTATING; - cdr.StatP &= ~STATUS_ERROR; - - - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x60; - } - - // done = cd ready - else if( cdr.LidCheck == 0x60 ) - { - // GameShark Lite: Seek detection done ($02) + switch (cdr.DriveState) { + default: + case DRIVESTATE_STANDBY: cdr.StatP &= ~STATUS_SEEK; - cdr.LidCheck = 0; - } -} - - -static void Check_Shell( int Irq ) -{ - // check case open/close - if (cdr.LidCheck > 0) - { -#ifdef CDR_LOG - CDR_LOG( "LidCheck\n" ); -#endif + if (CDR_getStatus(&stat) == -1) + return; - // $20 = check lid state - if( cdr.LidCheck == 0x20 ) + if (stat.Status & STATUS_SHELLOPEN) { - u32 i; - - i = stat.Status; - if (CDR_getStatus(&stat) != -1) - { - if (stat.Type == 0xff) - cdr.Stat = DiskError; - - // case now open - else if (stat.Status & STATUS_SHELLOPEN) - { - // Vib Ribbon: pre-CD swap - StopCdda(); - - - // GameShark Lite: Death if DiskError happens - // - // Vib Ribbon: Needs DiskError for CD swap - - if (Irq != CdlNop) - { - cdr.Stat = DiskError; - - cdr.StatP |= STATUS_ERROR; - cdr.Result[0] |= STATUS_ERROR; - } - - // GameShark Lite: Wants -exactly- $10 - cdr.StatP |= STATUS_SHELLOPEN; - cdr.StatP &= ~STATUS_ROTATING; + StopCdda(); + cdr.DriveState = DRIVESTATE_LID_OPEN; + CDRLID_INT(0x800); + } + break; + case DRIVESTATE_LID_OPEN: + if (CDR_getStatus(&stat) == -1) + stat.Status &= ~STATUS_SHELLOPEN; - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x10; + // 02, 12, 10 + if (!(cdr.StatP & STATUS_SHELLOPEN)) { + StopReading(); + cdr.StatP |= STATUS_SHELLOPEN; + // could generate error irq here, but real hardware + // only sometimes does that + // (not done when lots of commands are sent?) - // GS CDX 3.3 = $11 - } - - // case just closed - else if ( i & STATUS_SHELLOPEN ) - { - cdr.StatP |= STATUS_ROTATING; + CDRLID_INT(cdReadTime * 30); + break; + } + else if (cdr.StatP & STATUS_ROTATING) { + cdr.StatP &= ~STATUS_ROTATING; + } + else if (!(stat.Status & STATUS_SHELLOPEN)) { + // closed now + CheckCdrom(); - CheckCdrom(); + // cdr.StatP STATUS_SHELLOPEN is "sticky" + // and is only cleared by CdlNop + cdr.DriveState = DRIVESTATE_RESCAN_CD; + CDRLID_INT(cdReadTime * 105); + break; + } - if( cdr.Stat == NoIntr ) - cdr.Stat = Acknowledge; + // recheck for close + CDRLID_INT(cdReadTime * 3); + break; - psxHu32ref(0x1070) |= SWAP32((u32)0x4); + case DRIVESTATE_RESCAN_CD: + cdr.StatP |= STATUS_ROTATING; + cdr.DriveState = DRIVESTATE_PREPARE_CD; + // this is very long on real hardware, over 6 seconds + // make it a bit faster here... + CDRLID_INT(cdReadTime * 150); + break; - // begin close-seek-ready cycle - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x30; + case DRIVESTATE_PREPARE_CD: + cdr.StatP |= STATUS_SEEK; + cdr.DriveState = DRIVESTATE_STANDBY; + CDRLID_INT(cdReadTime * 26); + break; + } +} - // GameShark Lite: Wants -exactly- $42, then $02 - // GS CDX 3.3: Wants $11/$80, $13/$80, $01/$00 - } +static void Find_CurTrack(const u8 *time) +{ + int current, sect; - // case still closed - wait for recheck - else - { - CDRLID_INT( cdReadTime * 3 ); - cdr.LidCheck = 0x10; - } - } - } + current = msf2sec(time); + for (cdr.CurTrack = 1; cdr.CurTrack < cdr.ResultTN[1]; cdr.CurTrack++) { + CDR_getTD(cdr.CurTrack + 1, cdr.ResultTD); + sect = fsm2sec(cdr.ResultTD); + if (sect - current >= 150) + break; + } +} - // GS CDX: clear all values but #1,#2 - if( (cdr.LidCheck >= 0x30) || (cdr.StatP & STATUS_SHELLOPEN) ) - { - SetResultSize(16); - memset( cdr.Result, 0, 16 ); +static void generate_subq(const u8 *time) +{ + unsigned char start[3], next[3]; + unsigned int this_s, start_s, next_s, pregap; + int relative_s; - cdr.Result[0] = cdr.StatP; + CDR_getTD(cdr.CurTrack, start); + if (cdr.CurTrack + 1 <= cdr.ResultTN[1]) { + pregap = 150; + CDR_getTD(cdr.CurTrack + 1, next); + } + else { + // last track - cd size + pregap = 0; + next[0] = cdr.SetSectorEnd[2]; + next[1] = cdr.SetSectorEnd[1]; + next[2] = cdr.SetSectorEnd[0]; + } + this_s = msf2sec(time); + start_s = fsm2sec(start); + next_s = fsm2sec(next); - // GS CDX: special return value - if( cdr.StatP & STATUS_SHELLOPEN ) - { - cdr.Result[1] = 0x80; - } + cdr.TrackChanged = FALSE; + if (next_s - this_s < pregap) { + cdr.TrackChanged = TRUE; + cdr.CurTrack++; + start_s = next_s; + } - if( cdr.Stat == NoIntr ) - cdr.Stat = Acknowledge; + cdr.subq.Index = 1; - psxHu32ref(0x1070) |= SWAP32((u32)0x4); - } + relative_s = this_s - start_s; + if (relative_s < 0) { + cdr.subq.Index = 0; + relative_s = -relative_s; } + sec2msf(relative_s, cdr.subq.Relative); + + cdr.subq.Track = itob(cdr.CurTrack); + cdr.subq.Relative[0] = itob(cdr.subq.Relative[0]); + cdr.subq.Relative[1] = itob(cdr.subq.Relative[1]); + cdr.subq.Relative[2] = itob(cdr.subq.Relative[2]); + cdr.subq.Absolute[0] = itob(time[0]); + cdr.subq.Absolute[1] = itob(time[1]); + cdr.subq.Absolute[2] = itob(time[2]); } +static void ReadTrack(const u8 *time) { + unsigned char tmp[3]; + struct SubQ *subq; + u16 crc; -void Find_CurTrack() { - cdr.CurTrack = 0; - - if (CDR_getTN(cdr.ResultTN) != -1) { - int lcv; + tmp[0] = itob(time[0]); + tmp[1] = itob(time[1]); + tmp[2] = itob(time[2]); - for( lcv = 1; lcv <= cdr.ResultTN[1]; lcv++ ) { - if (CDR_getTD((u8)(lcv), cdr.ResultTD) != -1) { - u32 sect1, sect2; - -#ifdef CDR_LOG___0 - CDR_LOG( "curtrack %d %d %d | %d %d %d | %d\n", - cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], - cdr.ResultTD[2], cdr.ResultTD[1], cdr.ResultTD[0], - cdr.CurTrack ); -#endif + if (memcmp(cdr.Prev, tmp, 3) == 0) + return; - // find next track boundary - only need m:s accuracy - sect1 = cdr.SetSectorPlay[0] * 60 * 75 + cdr.SetSectorPlay[1] * 75; - sect2 = cdr.ResultTD[2] * 60 * 75 + cdr.ResultTD[1] * 75; + CDR_LOG("ReadTrack *** %02x:%02x:%02x\n", tmp[0], tmp[1], tmp[2]); - // Twisted Metal 4 - psx cdda pregap (2-sec) - // - fix in-game music - sect2 -= 75 * 2; + cdr.RErr = CDR_readTrack(tmp); + memcpy(cdr.Prev, tmp, 3); - if( sect1 >= sect2 ) { - cdr.CurTrack++; - continue; - } - } + if (CheckSBI(time)) + return; - break; + subq = (struct SubQ *)CDR_getBufferSub(); + if (subq != NULL && cdr.CurTrack == 1) { + crc = calcCrc((u8 *)subq + 12, 10); + if (crc == (((u16)subq->CRC[0] << 8) | subq->CRC[1])) { + cdr.subq.Track = subq->TrackNumber; + cdr.subq.Index = subq->IndexNumber; + memcpy(cdr.subq.Relative, subq->TrackRelativeAddress, 3); + memcpy(cdr.subq.Absolute, subq->AbsoluteAddress, 3); + } + else { + CDR_LOG_I("subq bad crc @%02x:%02x:%02x\n", + tmp[0], tmp[1], tmp[2]); } } -} - -static void ReadTrack( u8 *time ) { - cdr.Prev[0] = itob( time[0] ); - cdr.Prev[1] = itob( time[1] ); - cdr.Prev[2] = itob( time[2] ); + else { + generate_subq(time); + } -#ifdef CDR_LOG - CDR_LOG("ReadTrack() Log: KEY *** %x:%x:%x\n", cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]); -#endif - cdr.RErr = CDR_readTrack(cdr.Prev); + CDR_LOG(" -> %02x,%02x %02x:%02x:%02x %02x:%02x:%02x\n", + 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]); } +static void AddIrqQueue(unsigned short irq, unsigned long ecycle) { + if (cdr.Irq != 0) { + if (irq == cdr.Irq || irq + 0x100 == cdr.Irq) { + cdr.IrqRepeated = 1; + CDR_INT(ecycle); + return; + } + + CDR_LOG_I("cdr: override cmd %02x -> %02x\n", cdr.Irq, irq); + } -void AddIrqQueue(unsigned char irq, unsigned long ecycle) { cdr.Irq = irq; cdr.eCycle = ecycle; - // Doom: Force rescheduling - // - Fixes boot CDR_INT(ecycle); } - -void Set_Track() +static void cdrPlayInterrupt_Autopause() { - if (CDR_getTN(cdr.ResultTN) != -1) { - int lcv; - - for( lcv = 1; lcv < cdr.ResultTN[1]; lcv++ ) { - if (CDR_getTD((u8)(lcv), cdr.ResultTD) != -1) { -#ifdef CDR_LOG___0 - CDR_LOG( "settrack %d %d %d | %d %d %d | %d\n", - cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], - cdr.ResultTD[2], cdr.ResultTD[1], cdr.ResultTD[0], - cdr.CurTrack ); -#endif - - // check if time matches track start (only need min, sec accuracy) - // - m:s:f vs f:s:m - if( cdr.SetSectorPlay[0] == cdr.ResultTD[2] && - cdr.SetSectorPlay[1] == cdr.ResultTD[1] ) { - // skip pregap frames - if( cdr.SetSectorPlay[2] < cdr.ResultTD[0] ) - cdr.SetSectorPlay[2] = cdr.ResultTD[0]; - - break; - } - else if( cdr.SetSectorPlay[0] < cdr.ResultTD[2] ) - break; - } - } - } -} - + if ((cdr.Mode & MODE_AUTOPAUSE) && cdr.TrackChanged) { + CDR_LOG( "CDDA STOP\n" ); -static u8 fake_subq_local[3], fake_subq_real[3], fake_subq_index, fake_subq_change; -void Create_Fake_Subq() -{ - u8 temp_cur[3], temp_next[3], temp_start[3], pregap; - int diff; + // Magic the Gathering + // - looping territory cdda - if (CDR_getTN(cdr.ResultTN) == -1) return; - if( cdr.CurTrack+1 <= cdr.ResultTN[1] ) { - pregap = 150; - if( CDR_getTD(cdr.CurTrack+1, cdr.ResultTD) == -1 ) return; - } else { - // last track - cd size - pregap = 0; - if( CDR_getTD(0, cdr.ResultTD) == -1 ) return; - } + // ...? + //cdr.ResultReady = 1; + //cdr.Stat = DataReady; + cdr.Stat = DataEnd; + setIrq(); - if( cdr.Play == TRUE ) { - temp_cur[0] = cdr.SetSectorPlay[0]; - temp_cur[1] = cdr.SetSectorPlay[1]; - temp_cur[2] = cdr.SetSectorPlay[2]; - } else { - temp_cur[0] = btoi( cdr.Prev[0] ); - temp_cur[1] = btoi( cdr.Prev[1] ); - temp_cur[2] = btoi( cdr.Prev[2] ); + StopCdda(); } + else if (cdr.Mode & MODE_REPORT) { - fake_subq_real[0] = temp_cur[0]; - fake_subq_real[1] = temp_cur[1]; - fake_subq_real[2] = temp_cur[2]; - - temp_next[0] = cdr.ResultTD[2]; - temp_next[1] = cdr.ResultTD[1]; - temp_next[2] = cdr.ResultTD[0]; + cdr.Result[0] = cdr.StatP; + cdr.Result[1] = cdr.subq.Track; + cdr.Result[2] = cdr.subq.Index; + if (cdr.subq.Absolute[2] & 0x10) { + cdr.Result[3] = cdr.subq.Relative[0]; + cdr.Result[4] = cdr.subq.Relative[1] | 0x80; + cdr.Result[5] = cdr.subq.Relative[2]; + } + else { + cdr.Result[3] = cdr.subq.Absolute[0]; + cdr.Result[4] = cdr.subq.Absolute[1]; + cdr.Result[5] = cdr.subq.Absolute[2]; + } - // flag- next track - if( msf2sec(temp_cur) >= msf2sec( temp_next )-pregap ) { - fake_subq_change = 1; + cdr.Result[6] = 0; + cdr.Result[7] = 0; - cdr.CurTrack++; + // Rayman: Logo freeze (resultready + dataready) + cdr.ResultReady = 1; + cdr.Stat = DataReady; - // end cd - if( pregap == 0 ) StopCdda(); + SetResultSize(8); + setIrq(); } +} - ////////////////////////////////////////////////// - ////////////////////////////////////////////////// +// also handles seek +void cdrPlayInterrupt() +{ + if (cdr.Seeked == SEEK_PENDING) { + if (cdr.Stat) { + CDR_LOG_I("cdrom: seek stat hack\n"); + CDRMISC_INT(0x1000); + return; + } + SetResultSize(1); + cdr.StatP |= STATUS_ROTATING; + cdr.StatP &= ~STATUS_SEEK; + cdr.Result[0] = cdr.StatP; + cdr.Seeked = SEEK_DONE; + if (cdr.Irq == 0) { + cdr.Stat = Complete; + setIrq(); + } - // repair - if( cdr.CurTrack <= cdr.ResultTN[1] ) { - if( CDR_getTD(cdr.CurTrack, cdr.ResultTD) == -1 ) return; - } else { - // last track - cd size - if( CDR_getTD(0, cdr.ResultTD) == -1 ) return; + if (cdr.SetlocPending) { + memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); + cdr.SetlocPending = 0; + } + Find_CurTrack(cdr.SetSectorPlay); + ReadTrack(cdr.SetSectorPlay); + cdr.TrackChanged = FALSE; } - - temp_start[0] = cdr.ResultTD[2]; - temp_start[1] = cdr.ResultTD[1]; - temp_start[2] = cdr.ResultTD[0]; + if (!cdr.Play) return; -#ifdef CDR_LOG - CDR_LOG( "CDDA FAKE SUB - %d:%d:%d / %d:%d:%d / %d:%d:%d\n", - temp_cur[0], temp_cur[1], temp_cur[2], - temp_start[0], temp_start[1], temp_start[2], - temp_next[0], temp_next[1], temp_next[2]); -#endif - + CDR_LOG( "CDDA - %d:%d:%d\n", + cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] ); + if (memcmp(cdr.SetSectorPlay, cdr.SetSectorEnd, 3) == 0) { + StopCdda(); + cdr.TrackChanged = TRUE; + } - // local time - pregap / real - diff = msf2sec(temp_cur) - msf2sec( temp_start ); - if( diff < 0 ) { - fake_subq_index = 0; + if (!cdr.Irq && !cdr.Stat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT))) + cdrPlayInterrupt_Autopause(); - sec2msf( -diff, fake_subq_local ); - } else { - fake_subq_index = 1; + if (!cdr.Play) return; - sec2msf( diff, fake_subq_local ); + 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]++; + } } -} + CDRMISC_INT(cdReadTime); + + // update for CdlGetlocP/autopause + generate_subq(cdr.SetSectorPlay); +} void cdrInterrupt() { - int i; - unsigned char Irq = cdr.Irq; + u16 Irq = cdr.Irq; + int no_busy_error = 0; + int start_rotating = 0; + int error = 0; + int delay; // Reschedule IRQ if (cdr.Stat) { - CDR_INT( 0x100 ); + CDR_LOG_I("cdrom: stat hack: %02x %x\n", cdr.Irq, cdr.Stat); + CDR_INT(0x1000); return; } - cdr.Irq = 0xff; cdr.Ctrl &= ~0x80; + // default response + SetResultSize(1); + cdr.Result[0] = cdr.StatP; + cdr.Stat = Acknowledge; + + if (cdr.IrqRepeated) { + cdr.IrqRepeated = 0; + if (cdr.eCycle > psxRegs.cycle) { + CDR_INT(cdr.eCycle); + goto finish; + } + } + + cdr.Irq = 0; + switch (Irq) { case CdlSync: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + // TOOD: sometimes/always return error? break; case CdlNop: - SetResultSize(1); - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; - - if (cdr.LidCheck == 0) cdr.LidCheck = 0x20; + if (cdr.DriveState != DRIVESTATE_LID_OPEN) + cdr.StatP &= ~STATUS_SHELLOPEN; + no_busy_error = 1; break; case CdlSetloc: - cdr.CmdProcess = 0; - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; break; + do_CdlPlay: case CdlPlay: - fake_subq_change = 0; + StopCdda(); + if (cdr.Seeked == SEEK_PENDING) { + // XXX: wrong, should seek instead.. + cdr.Seeked = SEEK_DONE; + } + if (cdr.SetlocPending) { + memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); + cdr.SetlocPending = 0; + } + + // BIOS CD Player + // - Pause player, hit Track 01/02/../xx (Setloc issued!!) + + if (cdr.ParamC == 0 || cdr.Param[0] == 0) { + CDR_LOG("PLAY Resume @ %d:%d:%d\n", + cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]); + } + else + { + int track = btoi( cdr.Param[0] ); - if( cdr.Seeked == FALSE ) { - memcpy( cdr.SetSectorPlay, cdr.SetSector, 4 ); - cdr.Seeked = TRUE; + if (track <= cdr.ResultTN[1]) + cdr.CurTrack = track; + + CDR_LOG("PLAY track %d\n", cdr.CurTrack); + + if (CDR_getTD((u8)cdr.CurTrack, cdr.ResultTD) != -1) { + cdr.SetSectorPlay[0] = cdr.ResultTD[2]; + cdr.SetSectorPlay[1] = cdr.ResultTD[1]; + cdr.SetSectorPlay[2] = cdr.ResultTD[0]; + } } /* @@ -584,113 +622,30 @@ void cdrInterrupt() { Wild 9: skip PREGAP + starting accurate SubQ - plays tracks without retry play */ - Set_Track(); - Find_CurTrack(); - ReadTrack( cdr.SetSectorPlay ); - - - // GameShark CD Player: Calls 2x + Play 2x - if( cdr.FastBackward || cdr.FastForward ) { - if( cdr.FastForward ) cdr.FastForward--; - if( cdr.FastBackward ) cdr.FastBackward--; - - if( cdr.FastBackward == 0 && cdr.FastForward == 0 ) { - if( cdr.Play && CDR_getStatus(&stat) != -1 ) { - cdr.SetSectorPlay[0] = stat.Time[0]; - cdr.SetSectorPlay[1] = stat.Time[1]; - cdr.SetSectorPlay[2] = stat.Time[2]; - } - } - } - - - if (!Config.Cdda) { - // BIOS CD Player - // - Pause player, hit Track 01/02/../xx (Setloc issued!!) - - // GameShark CD Player: Resume play - if( cdr.ParamC == 0 ) { -#ifdef CDR_LOG___0 - CDR_LOG( "PLAY Resume @ %d:%d:%d\n", - cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] ); -#endif - - //CDR_play( cdr.SetSectorPlay ); - } - else - { - // BIOS CD Player: Resume play - if( cdr.Param[0] == 0 ) { -#ifdef CDR_LOG___0 - CDR_LOG( "PLAY Resume T0 @ %d:%d:%d\n", - cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] ); -#endif - - //CDR_play( cdr.SetSectorPlay ); - } - else { -#ifdef CDR_LOG___0 - CDR_LOG( "PLAY Resume Td @ %d:%d:%d\n", - cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] ); -#endif - - // BIOS CD Player: Allow track replaying - StopCdda(); - - - cdr.CurTrack = btoi( cdr.Param[0] ); - - if (CDR_getTN(cdr.ResultTN) != -1) { - // check last track - if (cdr.CurTrack > cdr.ResultTN[1]) - cdr.CurTrack = cdr.ResultTN[1]; - - if (CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD) != -1) { - cdr.SetSectorPlay[0] = cdr.ResultTD[2]; - cdr.SetSectorPlay[1] = cdr.ResultTD[1]; - cdr.SetSectorPlay[2] = cdr.ResultTD[0]; - - // reset data - Set_Track(); - Find_CurTrack(); - ReadTrack( cdr.SetSectorPlay ); - - //CDR_play(cdr.SetSectorPlay); - } - } - } - } - } + Find_CurTrack(cdr.SetSectorPlay); + ReadTrack(cdr.SetSectorPlay); + cdr.TrackChanged = FALSE; + if (!Config.Cdda) + CDR_play(cdr.SetSectorPlay); // Vib Ribbon: gameplay checks flag cdr.StatP &= ~STATUS_SEEK; - - - cdr.CmdProcess = 0; - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; cdr.StatP |= STATUS_PLAY; - // BIOS player - set flag again cdr.Play = TRUE; - // TODO? - // CDRPLAY_INT( cdReadTime ); + CDRMISC_INT( cdReadTime ); + start_rotating = 1; break; case CdlForward: - cdr.CmdProcess = 0; - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; + // TODO: error 80 if stopped cdr.Stat = Complete; - // GameShark CD Player: Calls 2x + Play 2x if( cdr.FastForward == 0 ) cdr.FastForward = 2; else cdr.FastForward++; @@ -699,13 +654,8 @@ void cdrInterrupt() { break; case CdlBackward: - cdr.CmdProcess = 0; - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; - // GameShark CD Player: Calls 2x + Play 2x if( cdr.FastBackward == 0 ) cdr.FastBackward = 2; else cdr.FastBackward++; @@ -714,163 +664,128 @@ void cdrInterrupt() { break; case CdlStandby: - cdr.CmdProcess = 0; - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; + if (cdr.DriveState != DRIVESTATE_STOPPED) { + error = ERROR_INVALIDARG; + goto set_error; + } + AddIrqQueue(CdlStandby + 0x100, cdReadTime * 125 / 2); + start_rotating = 1; + break; + + case CdlStandby + 0x100: cdr.Stat = Complete; break; case CdlStop: - cdr.CmdProcess = 0; - SetResultSize(1); + if (cdr.Play) { + // grab time for current track + CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD); + + cdr.SetSectorPlay[0] = cdr.ResultTD[2]; + cdr.SetSectorPlay[1] = cdr.ResultTD[1]; + cdr.SetSectorPlay[2] = cdr.ResultTD[0]; + } + + StopCdda(); + StopReading(); + + delay = 0x800; + if (cdr.DriveState == DRIVESTATE_STANDBY) + delay = cdReadTime * 30 / 2; + + cdr.DriveState = DRIVESTATE_STOPPED; + AddIrqQueue(CdlStop + 0x100, delay); + break; + + case CdlStop + 0x100: cdr.StatP &= ~STATUS_ROTATING; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; -// cdr.Stat = Acknowledge; - - if (cdr.LidCheck == 0) cdr.LidCheck = 0x20; break; case CdlPause: - SetResultSize(1); - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + /* + Gundam Battle Assault 2: much slower (*) + - Fixes boot, gameplay - AddIrqQueue(CdlPause + 0x20, 0x800); + Hokuto no Ken 2: slower + - Fixes intro + subtitles + + InuYasha - Feudal Fairy Tale: slower + - Fixes battles + */ + AddIrqQueue(CdlPause + 0x100, cdReadTime * 3); cdr.Ctrl |= 0x80; break; - case CdlPause + 0x20: - SetResultSize(1); + case CdlPause + 0x100: cdr.StatP &= ~STATUS_READ; - cdr.StatP |= STATUS_ROTATING; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlInit: - SetResultSize(1); - cdr.StatP = STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; -// if (!cdr.Init) { - AddIrqQueue(CdlInit + 0x20, 0x800); -// } - break; + AddIrqQueue(CdlInit + 0x100, cdReadTime * 6); + no_busy_error = 1; + start_rotating = 1; + break; - case CdlInit + 0x20: - SetResultSize(1); - cdr.Result[0] = cdr.StatP; + case CdlInit + 0x100: cdr.Stat = Complete; - cdr.Init = 1; break; case CdlMute: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + cdr.Muted = TRUE; break; case CdlDemute: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + cdr.Muted = FALSE; break; case CdlSetfilter: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + cdr.File = cdr.Param[0]; + cdr.Channel = cdr.Param[1]; break; case CdlSetmode: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + no_busy_error = 1; break; case CdlGetmode: SetResultSize(6); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; cdr.Result[1] = cdr.Mode; cdr.Result[2] = cdr.File; cdr.Result[3] = cdr.Channel; cdr.Result[4] = 0; cdr.Result[5] = 0; - cdr.Stat = Acknowledge; + no_busy_error = 1; break; case CdlGetlocL: SetResultSize(8); - for (i = 0; i < 8; i++) - cdr.Result[i] = cdr.Transfer[i]; - cdr.Stat = Acknowledge; + memcpy(cdr.Result, cdr.Transfer, 8); break; case CdlGetlocP: - // GameShark CDX CD Player: uses 17 bytes output (wraps around) - SetResultSize(17); - memset( cdr.Result, 0, 16 ); - - subq = (struct SubQ *)CDR_getBufferSub(); - - if (subq != NULL) { - cdr.Result[0] = subq->TrackNumber; - cdr.Result[1] = subq->IndexNumber; - memcpy(cdr.Result + 2, subq->TrackRelativeAddress, 3); - memcpy(cdr.Result + 5, subq->AbsoluteAddress, 3); - - - // subQ integrity check - data only (skip audio) - if( subq->TrackNumber == 1 && stat.Type == 0x01 ) { - if (calcCrc((u8 *)subq + 12, 10) != (((u16)subq->CRC[0] << 8) | subq->CRC[1])) { - memset(cdr.Result + 2, 0, 3 + 3); // CRC wrong, wipe out time data - } - } - } else { - if( cdr.Play == FALSE ) Create_Fake_Subq(); - - - // track # / index # - cdr.Result[0] = itob(cdr.CurTrack); - cdr.Result[1] = itob(fake_subq_index); - - // local - cdr.Result[2] = itob( fake_subq_local[0] ); - cdr.Result[3] = itob( fake_subq_local[1] ); - cdr.Result[4] = itob( fake_subq_local[2] ); + SetResultSize(8); + memcpy(&cdr.Result, &cdr.subq, 8); - // absolute - cdr.Result[5] = itob( fake_subq_real[0] ); - cdr.Result[6] = itob( fake_subq_real[1] ); - cdr.Result[7] = itob( fake_subq_real[2] ); - } + if (!cdr.Play && !cdr.Reading) + cdr.Result[1] = 0; // HACK? + break; - // redump.org - wipe time - /*if( !cdr.Play && CheckSBI(cdr.Result+5) ) { - memset( cdr.Result+2, 0, 6 ); - } - */ + case CdlReadT: // SetSession? + // really long + AddIrqQueue(CdlReadT + 0x100, cdReadTime * 290 / 4); + start_rotating = 1; + break; - cdr.Stat = Acknowledge; + case CdlReadT + 0x100: + cdr.Stat = Complete; break; case CdlGetTN: - // 5-Star Racing: don't stop CDDA - // - // Vib Ribbon: CD swap - StopReading(); - - cdr.CmdProcess = 0; SetResultSize(3); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; if (CDR_getTN(cdr.ResultTN) == -1) { cdr.Stat = DiskError; cdr.Result[0] |= STATUS_ERROR; @@ -882,10 +797,8 @@ void cdrInterrupt() { break; case CdlGetTD: - cdr.CmdProcess = 0; cdr.Track = btoi(cdr.Param[0]); SetResultSize(4); - cdr.StatP |= STATUS_ROTATING; if (CDR_getTD(cdr.Track, cdr.ResultTD) == -1) { cdr.Stat = DiskError; cdr.Result[0] |= STATUS_ERROR; @@ -899,11 +812,10 @@ void cdrInterrupt() { break; case CdlSeekL: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; + case CdlSeekP: + StopCdda(); + StopReading(); cdr.StatP |= STATUS_SEEK; - cdr.Stat = Acknowledge; /* Crusaders of Might and Magic = 0.5x-4x @@ -913,54 +825,17 @@ void cdrInterrupt() { - fix new game Medievil = ?-4x - - fix cutscene speech - - Rockman X5 = 0.5-4x - - fix capcom logo - */ - AddIrqQueue(CdlSeekL + 0x20, cdReadTime * 4); - break; - - case CdlSeekL + 0x20: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.StatP &= ~STATUS_SEEK; - cdr.Result[0] = cdr.StatP; - cdr.Seeked = TRUE; - cdr.Stat = Complete; - - - // Mega Man Legends 2: must update read cursor for getlocp - ReadTrack( cdr.SetSector ); - break; - - case CdlSeekP: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.StatP |= STATUS_SEEK; - cdr.Stat = Acknowledge; - AddIrqQueue(CdlSeekP + 0x20, cdReadTime * 1); - break; - - case CdlSeekP + 0x20: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.StatP &= ~STATUS_SEEK; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Complete; - cdr.Seeked = TRUE; - - // GameShark Music Player - memcpy( cdr.SetSectorPlay, cdr.SetSector, 4 ); + - fix cutscene speech - // Tomb Raider 2: must update read cursor for getlocp - Find_CurTrack(); - ReadTrack( cdr.SetSectorPlay ); + Rockman X5 = 0.5-4x + - fix capcom logo + */ + CDRMISC_INT(cdr.Seeked == SEEK_DONE ? 0x800 : cdReadTime * 4); + cdr.Seeked = SEEK_PENDING; + start_rotating = 1; break; case CdlTest: - cdr.Stat = Acknowledge; switch (cdr.Param[0]) { case 0x20: // System Controller ROM Version SetResultSize(4); @@ -975,125 +850,96 @@ void cdrInterrupt() { memcpy(cdr.Result, Test23, 4); break; } + no_busy_error = 1; break; case CdlID: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; - AddIrqQueue(CdlID + 0x20, 0x800); + AddIrqQueue(CdlID + 0x100, 20480); break; - case CdlID + 0x20: + case CdlID + 0x100: SetResultSize(8); + cdr.Result[0] = cdr.StatP; + cdr.Result[1] = 0; + cdr.Result[2] = 0; + cdr.Result[3] = 0; - if (CDR_getStatus(&stat) == -1) { - cdr.Result[0] = 0x00; // 0x08 and cdr.Result[1]|0x10 : audio cd, enters cd player - cdr.Result[1] = 0x80; // 0x80 leads to the menu in the bios, else loads CD + // 0x10 - audio | 0x40 - disk missing | 0x80 - unlicensed + if (CDR_getStatus(&stat) == -1 || stat.Type == 0 || stat.Type == 0xff) { + cdr.Result[1] = 0xc0; } else { - if (stat.Type == 2) { - // Music CD - cdr.Result[0] = 0x08; - cdr.Result[1] = 0x10; - + if (stat.Type == 2) + cdr.Result[1] |= 0x10; + if (CdromId[0] == '\0') cdr.Result[1] |= 0x80; - } - else { - // Data CD - if (CdromId[0] == '\0') { - cdr.Result[0] = 0x00; - cdr.Result[1] = 0x80; - } - else { - cdr.Result[0] = 0x08; - cdr.Result[1] = 0x00; - } - } } + cdr.Result[0] |= (cdr.Result[1] >> 4) & 0x08; - cdr.Result[2] = 0x00; - cdr.Result[3] = 0x00; strncpy((char *)&cdr.Result[4], "PCSX", 4); cdr.Stat = Complete; break; case CdlReset: - SetResultSize(1); - cdr.StatP = STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; - break; - - case CdlReadT: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; - AddIrqQueue(CdlReadT + 0x20, 0x800); + // yes, it really sets STATUS_SHELLOPEN + cdr.StatP |= STATUS_SHELLOPEN; + cdr.DriveState = DRIVESTATE_RESCAN_CD; + CDRLID_INT(20480); + no_busy_error = 1; + start_rotating = 1; break; - case CdlReadT + 0x20: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Complete; + case CdlGetQ: + // TODO? + CDR_LOG_I("got CdlGetQ\n"); break; case CdlReadToc: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; - AddIrqQueue(CdlReadToc + 0x20, 0x800); + AddIrqQueue(CdlReadToc + 0x100, cdReadTime * 180 / 4); + no_busy_error = 1; + start_rotating = 1; break; - case CdlReadToc + 0x20: - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; - cdr.Result[0] = cdr.StatP; + case CdlReadToc + 0x100: cdr.Stat = Complete; + no_busy_error = 1; break; - case AUTOPAUSE: - cdr.OCUP = 0; -/* SetResultSize(1); - StopCdda(); - StopReading(); - cdr.OCUP = 0; - cdr.StatP&=~0x20; - cdr.StatP|= 0x2; - cdr.Result[0] = cdr.StatP; - cdr.Stat = DataEnd; -*/ AddIrqQueue(CdlPause, 0x800); - break; + case CdlReadN: + case CdlReadS: + if (cdr.SetlocPending) { + memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); + cdr.SetlocPending = 0; + } + Find_CurTrack(cdr.SetSectorPlay); - case READ_ACK: - if (!cdr.Reading) return; + if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1) + // Read* acts as play for cdda tracks in cdda mode + goto do_CdlPlay; + cdr.Reading = 1; + cdr.FirstSector = 1; // Fighting Force 2 - update subq time immediately // - fixes new game - ReadTrack( cdr.SetSector ); + ReadTrack(cdr.SetSectorPlay); // Crusaders of Might and Magic - update getlocl now // - fixes cutscene speech { u8 *buf = CDR_getBuffer(); - memcpy(cdr.Transfer, buf, 8); + if (buf != NULL) + memcpy(cdr.Transfer, buf, 8); } - - + /* Duke Nukem: Land of the Babes - seek then delay read for one frame - fixes cutscenes + C-12 - Final Resistance - doesn't like seek */ - if (!cdr.Seeked) { - cdr.Seeked = TRUE; - + if (cdr.Seeked != SEEK_DONE) { cdr.StatP |= STATUS_SEEK; cdr.StatP &= ~STATUS_READ; @@ -1109,29 +955,103 @@ void cdrInterrupt() { CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1); } - SetResultSize(1); - cdr.StatP |= STATUS_ROTATING; cdr.Result[0] = cdr.StatP; - cdr.Stat = Acknowledge; + start_rotating = 1; break; - case 0xff: - return; - default: - cdr.Stat = Complete; + CDR_LOG_I("Invalid command: %02x\n", Irq); + error = ERROR_INVALIDCMD; + // FALLTHROUGH + + set_error: + SetResultSize(2); + cdr.Result[0] = cdr.StatP | STATUS_ERROR; + cdr.Result[1] = error; + cdr.Stat = DiskError; + break; + } + + if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) { + 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_NOT_READY; + cdr.Stat = DiskError; break; + } } - Check_Shell( Irq ); +finish: + setIrq(); + cdr.ParamC = 0; - if (cdr.Stat != NoIntr && cdr.Reg2 != 0x18) { - psxHu32ref(0x1070) |= SWAP32((u32)0x4); +#ifdef CDR_LOG_CMD_IRQ + { + int i; + SysPrintf("CDR IRQ %d cmd %02x stat %02x: ", + !!(cdr.Stat & cdr.Reg2), Irq, cdr.Stat); + for (i = 0; i < cdr.ResultC; i++) + SysPrintf("%02x ", cdr.Result[i]); + SysPrintf("\n"); } +#endif +} -#ifdef CDR_LOG - CDR_LOG("cdrInterrupt() Log: CDR Interrupt IRQ %x\n", Irq); +#ifdef __ARM_ARCH_7A__ + #define ssat32_to_16(v) \ + asm("ssat %0,#16,%1" : "=r" (v) : "r" (v)) +#else + #define ssat32_to_16(v) do { \ + if (v < -32768) v = -32768; \ + else if (v > 32767) v = 32767; \ + } while (0) #endif + +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; + } + } } void cdrReadInterrupt() { @@ -1141,30 +1061,26 @@ void cdrReadInterrupt() { return; if (cdr.Irq || cdr.Stat) { - CDREAD_INT(0x100); + CDR_LOG_I("cdrom: read stat hack %02x %x\n", cdr.Irq, cdr.Stat); + CDREAD_INT(0x1000); return; } -#ifdef CDR_LOG - CDR_LOG("cdrReadInterrupt() Log: KEY END"); -#endif - cdr.OCUP = 1; SetResultSize(1); cdr.StatP |= STATUS_READ|STATUS_ROTATING; cdr.StatP &= ~STATUS_SEEK; cdr.Result[0] = cdr.StatP; + cdr.Seeked = SEEK_DONE; - ReadTrack( cdr.SetSector ); + ReadTrack(cdr.SetSectorPlay); buf = CDR_getBuffer(); if (buf == NULL) cdr.RErr = -1; if (cdr.RErr == -1) { -#ifdef CDR_LOG - fprintf(emuLog, "cdrReadInterrupt() Log: err\n"); -#endif + CDR_LOG_I("cdrReadInterrupt() Log: err\n"); memset(cdr.Transfer, 0, DATA_SIZE); cdr.Stat = DiskError; cdr.Result[0] |= STATUS_ERROR; @@ -1176,9 +1092,7 @@ void cdrReadInterrupt() { CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]); -#ifdef CDR_LOG - fprintf(emuLog, "cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]); -#endif + CDR_LOG("cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]); if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA // Firemen 2: Multi-XA files - briefings, cutscenes @@ -1187,49 +1101,32 @@ void cdrReadInterrupt() { cdr.Channel = cdr.Transfer[4 + 1]; } - if ((cdr.Transfer[4 + 2] & 0x4) && + if((cdr.Transfer[4 + 2] & 0x4) && (cdr.Transfer[4 + 1] == cdr.Channel) && - (cdr.Transfer[4 + 0] == cdr.File)) { + (cdr.Transfer[4 + 0] == cdr.File)) { int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector); - if (!ret) { + cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo); SPU_playADPCMchannel(&cdr.Xa); cdr.FirstSector = 0; - - - // Crash Team Racing: music, speech - - // signal ADPCM data ready - psxHu32ref(0x1070) |= SWAP32((u32)0x200); } else cdr.FirstSector = -1; } } - cdr.SetSector[2]++; - if (cdr.SetSector[2] == 75) { - cdr.SetSector[2] = 0; - cdr.SetSector[1]++; - if (cdr.SetSector[1] == 60) { - cdr.SetSector[1] = 0; - cdr.SetSector[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]++; } } cdr.Readed = 0; - // G-Police: Don't autopause ADPCM even if mode set (music) - if ((cdr.Transfer[4 + 2] & 0x80) && (cdr.Mode & MODE_AUTOPAUSE) && - (cdr.Transfer[4 + 2] & 0x4) != 0x4 ) { // EOF -#ifdef CDR_LOG - CDR_LOG("cdrReadInterrupt() Log: Autopausing read\n"); -#endif -// AddIrqQueue(AUTOPAUSE, 0x2000); - AddIrqQueue(CdlPause, 0x2000); - } - else { - CDREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime); - } + CDREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime); /* Croc 2: $40 - only FORM1 (*) @@ -1237,22 +1134,18 @@ void cdrReadInterrupt() { Sim Theme Park - no adpcm at all (zero) */ - if( (cdr.Mode & MODE_STRSND) == 0 || (cdr.Transfer[4+2] & 0x4) != 0x4 ) { + if (!(cdr.Mode & MODE_STRSND) || !(cdr.Transfer[4+2] & 0x4)) { cdr.Stat = DataReady; - } else { - // Breath of Fire 3 - fix inn sleeping - // Rockman X5 - no music restart problem - cdr.Stat = NoIntr; + setIrq(); } - psxHu32ref(0x1070) |= SWAP32((u32)0x4); - Check_Shell(0); + // update for CdlGetlocP + ReadTrack(cdr.SetSectorPlay); } /* cdrRead0: - bit 0 - 0 REG1 command send / 1 REG1 data read - bit 1 - 0 data transfer finish / 1 data transfer ready/in progress + bit 0,1 - mode bit 2 - unknown bit 3 - unknown bit 4 - unknown @@ -1275,67 +1168,52 @@ unsigned char cdrRead0(void) { // What means the 0x10 and the 0x08 bits? I only saw it used by the bios cdr.Ctrl |= 0x18; -#ifdef CDR_LOG - CDR_LOG("cdrRead0() Log: CD0 Read: %x\n", cdr.Ctrl); -#endif + CDR_LOG_IO("cdr r0: %02x\n", cdr.Ctrl); return psxHu8(0x1800) = cdr.Ctrl; } -/* -cdrWrite0: - 0 - to send a command / 1 - to get the result -*/ - void cdrWrite0(unsigned char rt) { -#ifdef CDR_LOG - CDR_LOG("cdrWrite0() Log: CD0 write: %x\n", rt); -#endif - cdr.Ctrl = rt | (cdr.Ctrl & ~0x3); + CDR_LOG_IO("cdr w0: %02x\n", rt); - if (rt == 0) { - cdr.ParamP = 0; - cdr.ParamC = 0; - cdr.ResultReady = 0; - } + cdr.Ctrl = (rt & 3) | (cdr.Ctrl & ~3); } unsigned char cdrRead1(void) { - if (cdr.ResultReady) { // && cdr.Ctrl & 0x1) { - // GameShark CDX CD Player: uses 17 bytes output (wraps around) + if ((cdr.ResultP & 0xf) < cdr.ResultC) psxHu8(0x1801) = cdr.Result[cdr.ResultP & 0xf]; - cdr.ResultP++; - if (cdr.ResultP == cdr.ResultC) - cdr.ResultReady = 0; - } else { + else psxHu8(0x1801) = 0; - } -#ifdef CDR_LOG - CDR_LOG("cdrRead1() Log: CD1 Read: %x\n", psxHu8(0x1801)); -#endif + cdr.ResultP++; + if (cdr.ResultP == cdr.ResultC) + cdr.ResultReady = 0; + + CDR_LOG_IO("cdr r1: %02x\n", psxHu8(0x1801)); + return psxHu8(0x1801); } void cdrWrite1(unsigned char rt) { + u8 set_loc[3]; int i; -#ifdef CDR_LOG - CDR_LOG("cdrWrite1() Log: CD1 write: %x (%s)\n", rt, CmdName[rt]); -#endif - + CDR_LOG_IO("cdr w1: %02x\n", rt); - // Tekken: CDXA fade-out - if( (cdr.Ctrl & 3) == 3 ) { - //cdr.AttenuatorRight[0] = rt; + switch (cdr.Ctrl & 3) { + case 0: + break; + case 3: + cdr.AttenuatorRightToRightT = rt; + return; + default: + return; } - -// psxHu8(0x1801) = rt; cdr.Cmd = rt; cdr.OCUP = 0; -#ifdef CDRCMD_DEBUG - SysPrintf("cdrWrite1() Log: CD1 write: %x (%s)", rt, CmdName[rt]); +#ifdef CDR_LOG_CMD_IRQ + SysPrintf("CD1 write: %x (%s)", rt, CmdName[rt]); if (cdr.ParamC) { SysPrintf(" Param[%d] = {", cdr.ParamC); for (i = 0; i < cdr.ParamC; i++) @@ -1346,325 +1224,50 @@ void cdrWrite1(unsigned char rt) { } #endif - if (cdr.Ctrl & 0x1) return; + cdr.ResultReady = 0; + cdr.Ctrl |= 0x80; + // cdr.Stat = NoIntr; + AddIrqQueue(cdr.Cmd, 0x800); switch (cdr.Cmd) { - case CdlSync: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlNop: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - - // Twisted Metal 3 - fix music - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlSetloc: - StopReading(); - cdr.Seeked = FALSE; + case CdlSetloc: for (i = 0; i < 3; i++) - cdr.SetSector[i] = btoi(cdr.Param[i]); - cdr.SetSector[3] = 0; - - /* - if ((cdr.SetSector[0] | cdr.SetSector[1] | cdr.SetSector[2]) == 0) { - *(u32 *)cdr.SetSector = *(u32 *)cdr.SetSectorSeek; - }*/ - - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; + set_loc[i] = btoi(cdr.Param[i]); - case CdlPlay: - // Vib Ribbon: try same track again - StopCdda(); - - if (!cdr.SetSector[0] & !cdr.SetSector[1] & !cdr.SetSector[2]) { - if (CDR_getTN(cdr.ResultTN) != -1) { - if (cdr.CurTrack > cdr.ResultTN[1]) - cdr.CurTrack = cdr.ResultTN[1]; - if (CDR_getTD((unsigned char)(cdr.CurTrack), cdr.ResultTD) != -1) { - int tmp = cdr.ResultTD[2]; - cdr.ResultTD[2] = cdr.ResultTD[0]; - cdr.ResultTD[0] = tmp; - if (!Config.Cdda) CDR_play(cdr.ResultTD); - } - } - } else if (!Config.Cdda) { - CDR_play(cdr.SetSector); - } - - // Vib Ribbon - decoded buffer IRQ for CDDA reading - // - fixes ribbon timing + music CD mode - //TODO? - //CDRDBUF_INT( PSXCLK / 44100 * 0x100 ); - - - cdr.Play = TRUE; + i = msf2sec(cdr.SetSectorPlay); + i = abs(i - msf2sec(set_loc)); + if (i > 16) + cdr.Seeked = SEEK_PENDING; - cdr.StatP |= STATUS_SEEK; - cdr.StatP &= ~STATUS_ROTATING; - - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlForward: - //if (cdr.CurTrack < 0xaa) - // cdr.CurTrack++; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlBackward: - //if (cdr.CurTrack > 1) - //cdr.CurTrack--; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlReadN: - cdr.Irq = 0; - StopReading(); - cdr.Ctrl|= 0x80; - cdr.Stat = NoIntr; - StartReading(1, 0x800); + memcpy(cdr.SetSector, set_loc, 3); + cdr.SetSector[3] = 0; + cdr.SetlocPending = 1; break; - case CdlStandby: - StopCdda(); - StopReading(); - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlStop: - // GameShark CD Player: Reset CDDA to track start - if( cdr.Play && CDR_getStatus(&stat) != -1 ) { - cdr.SetSectorPlay[0] = stat.Time[0]; - cdr.SetSectorPlay[1] = stat.Time[1]; - cdr.SetSectorPlay[2] = stat.Time[2]; - - Find_CurTrack(); - - - // grab time for current track - CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD); - - cdr.SetSectorPlay[0] = cdr.ResultTD[2]; - cdr.SetSectorPlay[1] = cdr.ResultTD[1]; - cdr.SetSectorPlay[2] = cdr.ResultTD[0]; - } - + case CdlReadN: + case CdlReadS: + case CdlPause: StopCdda(); StopReading(); - - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlPause: - /* - GameShark CD Player: save time for resume - - Twisted Metal - World Tour: don't save times for DATA reads - - Only get 1 chance to do this right - */ - if( cdr.Play && CDR_getStatus(&stat) != -1 ) { - cdr.SetSectorPlay[0] = stat.Time[0]; - cdr.SetSectorPlay[1] = stat.Time[1]; - cdr.SetSectorPlay[2] = stat.Time[2]; - } - - StopCdda(); - StopReading(); - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - - /* - Gundam Battle Assault 2: much slower (*) - - Fixes boot, gameplay - - Hokuto no Ken 2: slower - - Fixes intro + subtitles - - InuYasha - Feudal Fairy Tale: slower - - Fixes battles - */ - AddIrqQueue(cdr.Cmd, cdReadTime * 3); break; case CdlReset: - case CdlInit: + case CdlInit: + cdr.Seeked = SEEK_DONE; StopCdda(); StopReading(); - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlMute: - cdr.Muted = TRUE; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - - // Duke Nukem - Time to Kill - // - do not directly set cd-xa volume - //SPU_writeRegister( H_CDLeft, 0x0000 ); - //SPU_writeRegister( H_CDRight, 0x0000 ); - break; - - case CdlDemute: - cdr.Muted = FALSE; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - - // Duke Nukem - Time to Kill - // - do not directly set cd-xa volume - //SPU_writeRegister( H_CDLeft, 0x7f00 ); - //SPU_writeRegister( H_CDRight, 0x7f00 ); - break; - - case CdlSetfilter: - cdr.File = cdr.Param[0]; - cdr.Channel = cdr.Param[1]; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; + break; case CdlSetmode: -#ifdef CDR_LOG CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]); -#endif + cdr.Mode = cdr.Param[0]; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); // Squaresoft on PlayStation 1998 Collector's CD Vol. 1 // - fixes choppy movie sound if( cdr.Play && (cdr.Mode & MODE_CDDA) == 0 ) StopCdda(); break; - - case CdlGetmode: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlGetlocL: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - - // Crusaders of Might and Magic - cutscene speech - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlGetlocP: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - - // GameShark CDX / Lite Player: pretty narrow time window - // - doesn't always work due to time inprecision - //AddIrqQueue(cdr.Cmd, 0x28); - - // Tomb Raider 2 - cdda - AddIrqQueue(cdr.Cmd, 0x40); - break; - - case CdlGetTN: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - //AddIrqQueue(cdr.Cmd, 0x800); - - // GameShark CDX CD Player: very long time - AddIrqQueue(cdr.Cmd, 0x100000); - break; - - case CdlGetTD: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlSeekL: -// ((u32 *)cdr.SetSectorSeek)[0] = ((u32 *)cdr.SetSector)[0]; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - - StopCdda(); - StopReading(); - - break; - - case CdlSeekP: -// ((u32 *)cdr.SetSectorSeek)[0] = ((u32 *)cdr.SetSector)[0]; - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - - // Tomb Raider 2 - reset cdda - StopCdda(); - StopReading(); - - AddIrqQueue(cdr.Cmd, 0x800); - break; - - // Destruction Derby: read TOC? GetTD after this - case CdlReadT: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlTest: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlID: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - case CdlReadS: - cdr.Irq = 0; - StopReading(); - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - StartReading(2, 0x800); - break; - - case CdlReadToc: - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(cdr.Cmd, 0x800); - break; - - default: -#ifdef CDR_LOG - CDR_LOG("cdrWrite1() Log: Unknown command: %x\n", cdr.Cmd); -#endif - return; - } - if (cdr.Stat != NoIntr) { - psxHu32ref(0x1070) |= SWAP32((u32)0x4); } } @@ -1674,122 +1277,81 @@ unsigned char cdrRead2(void) { if (cdr.Readed == 0) { ret = 0; } else { - ret = *cdr.pTransfer++; + ret = *pTransfer++; } -#ifdef CDR_LOG - CDR_LOG("cdrRead2() Log: CD2 Read: %x\n", ret); -#endif + CDR_LOG_IO("cdr r2: %02x\n", ret); return ret; } void cdrWrite2(unsigned char rt) { -#ifdef CDR_LOG - CDR_LOG("cdrWrite2() Log: CD2 write: %x\n", rt); -#endif - - // Tekken: CDXA fade-out - if( (cdr.Ctrl & 3) == 2 ) { - //cdr.AttenuatorLeft[0] = rt; - } - else if( (cdr.Ctrl & 3) == 3 ) { - //cdr.AttenuatorRight[1] = rt; - } + CDR_LOG_IO("cdr w2: %02x\n", rt); - - if (cdr.Ctrl & 0x1) { - switch (rt) { - case 0x07: - cdr.ParamP = 0; - cdr.ParamC = 0; - cdr.ResultReady = 1; //0; - cdr.Ctrl &= ~3; //cdr.Ctrl = 0; - break; - - default: - cdr.Reg2 = rt; - break; - } - } else if (!(cdr.Ctrl & 0x1) && cdr.ParamP < 8) { - cdr.Param[cdr.ParamP++] = rt; - cdr.ParamC++; + switch (cdr.Ctrl & 3) { + case 0: + if (cdr.ParamC < 8) // FIXME: size and wrapping + cdr.Param[cdr.ParamC++] = rt; + return; + case 1: + cdr.Reg2 = rt; + setIrq(); + return; + case 2: + cdr.AttenuatorLeftToLeftT = rt; + return; + case 3: + cdr.AttenuatorRightToLeftT = rt; + return; } } unsigned char cdrRead3(void) { - if (cdr.Stat) { - if (cdr.Ctrl & 0x1) - psxHu8(0x1803) = cdr.Stat | 0xE0; - else - psxHu8(0x1803) = 0xff; - } else { - psxHu8(0x1803) = 0; - } -#ifdef CDR_LOG - CDR_LOG("cdrRead3() Log: CD3 Read: %x\n", psxHu8(0x1803)); -#endif + if (cdr.Ctrl & 0x1) + psxHu8(0x1803) = cdr.Stat | 0xE0; + else + psxHu8(0x1803) = cdr.Reg2 | 0xE0; + + CDR_LOG_IO("cdr r3: %02x\n", psxHu8(0x1803)); return psxHu8(0x1803); } void cdrWrite3(unsigned char rt) { -#ifdef CDR_LOG - CDR_LOG("cdrWrite3() Log: CD3 write: %x\n", rt); -#endif -/* - // Tekken: CDXA fade-out - if( (cdr.Ctrl & 3) == 2 ) { - cdr.AttenuatorLeft[1] = rt; - } - else if( (cdr.Ctrl & 3) == 3 && rt == 0x20 ) { -#ifdef CDR_LOG - CDR_LOG( "CD-XA Volume: %X %X | %X %X\n", - cdr.AttenuatorLeft[0], cdr.AttenuatorLeft[1], - cdr.AttenuatorRight[0], cdr.AttenuatorRight[1] ); -#endif - } -*/ - - // GameShark CDX CD Player: Irq timing mania - if( rt == 0 && - cdr.Irq != 0 && cdr.Irq != 0xff && - cdr.ResultReady == 0 ) { - - // GS CDX: ~0x28 cycle timing - way too precise - if( cdr.Irq == CdlGetlocP ) { - cdrInterrupt(); - - psxRegs.interrupt &= ~(1 << PSXINT_CDR); - } - } - + CDR_LOG_IO("cdr w3: %02x\n", rt); - if (rt == 0x07 && cdr.Ctrl & 0x1) { - cdr.Stat = 0; + switch (cdr.Ctrl & 3) { + case 0: + break; // transfer + case 1: + cdr.Stat &= ~rt; - if (cdr.Irq == 0xff) { - cdr.Irq = 0; - return; - } - - if (cdr.Reading && !cdr.ResultReady) { - CDREAD_INT((cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime); + if (rt & 0x40) + cdr.ParamC = 0; + return; + case 2: + cdr.AttenuatorLeftToRightT = rt; + return; + case 3: + if (rt & 0x20) { + memcpy(&cdr.AttenuatorLeftToLeft, &cdr.AttenuatorLeftToLeftT, 4); + CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n", + cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight, + cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight); } - return; } - if (rt == 0x80 && !(cdr.Ctrl & 0x1) && cdr.Readed == 0) { + if ((rt & 0x80) && cdr.Readed == 0) { cdr.Readed = 1; - cdr.pTransfer = cdr.Transfer; + pTransfer = cdr.Transfer; switch (cdr.Mode & 0x30) { case MODE_SIZE_2328: case 0x00: - cdr.pTransfer += 12; + pTransfer += 12; break; case MODE_SIZE_2340: - cdr.pTransfer += 0; + pTransfer += 0; break; default: @@ -1800,19 +1362,16 @@ void cdrWrite3(unsigned char rt) { void psxDma3(u32 madr, u32 bcr, u32 chcr) { u32 cdsize; + int size; u8 *ptr; -#ifdef CDR_LOG CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr); -#endif switch (chcr) { case 0x11000000: case 0x11400100: if (cdr.Readed == 0) { -#ifdef CDR_LOG CDR_LOG("psxDma3() Log: *** DMA 3 *** NOT READY\n"); -#endif break; } @@ -1822,19 +1381,18 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) { // - fix boot if( cdsize == 0 ) { - switch (cdr.Mode & 0x30) { - case 0x00: cdsize = 2048; break; - case MODE_SIZE_2328: cdsize = 2328; break; + 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) { -#ifdef CPU_LOG CDR_LOG("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n"); -#endif break; } @@ -1844,19 +1402,16 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) { - CdlPlay - Spams DMA3 and gets buffer overrun */ - - if( (cdr.pTransfer-cdr.Transfer) + cdsize > 2352 ) + size = CD_FRAMESIZE_RAW - (pTransfer - cdr.Transfer); + if (size > cdsize) + size = cdsize; + if (size > 0) { - // avoid crash - probably should wrap here - //memcpy(ptr, cdr.pTransfer, cdsize); - } - else - { - memcpy(ptr, cdr.pTransfer, cdsize); + memcpy(ptr, pTransfer, size); } psxCpu->Clear(madr, cdsize / 4); - cdr.pTransfer += cdsize; + pTransfer += cdsize; // burst vs normal @@ -1869,9 +1424,7 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) { return; default: -#ifdef CDR_LOG CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr); -#endif break; } @@ -1881,8 +1434,22 @@ void psxDma3(u32 madr, u32 bcr, u32 chcr) { void cdrDmaInterrupt() { - HW_DMA3_CHCR &= SWAP32(~0x01000000); - DMA_INTERRUPT(3); + if (HW_DMA3_CHCR & SWAP32(0x01000000)) + { + HW_DMA3_CHCR &= SWAP32(~0x01000000); + DMA_INTERRUPT(3); + } +} + +static void getCdInfo(void) +{ + u8 tmp; + + CDR_getTN(cdr.ResultTN); + CDR_getTD(0, cdr.SetSectorEnd); + tmp = cdr.SetSectorEnd[0]; + cdr.SetSectorEnd[0] = cdr.SetSectorEnd[2]; + cdr.SetSectorEnd[2] = tmp; } void cdrReset() { @@ -1890,38 +1457,71 @@ void cdrReset() { cdr.CurTrack = 1; cdr.File = 1; cdr.Channel = 1; + cdr.Reg2 = 0x1f; + cdr.Stat = NoIntr; + cdr.DriveState = DRIVESTATE_STANDBY; + cdr.StatP = STATUS_ROTATING; + pTransfer = cdr.Transfer; + + // BIOS player - default values + cdr.AttenuatorLeftToLeft = 0x80; + cdr.AttenuatorLeftToRight = 0x00; + cdr.AttenuatorRightToLeft = 0x00; + cdr.AttenuatorRightToRight = 0x80; + + getCdInfo(); } -int cdrFreeze(gzFile f, int Mode) { - uintptr_t tmp; +int cdrFreeze(void *f, int Mode) { + u32 tmp; + u8 tmpp[3]; - - if( Mode == 0 ) { - StopCdda(); - } + if (Mode == 0 && !Config.Cdda) + CDR_stop(); + cdr.freeze_ver = 0x63647202; gzfreeze(&cdr, sizeof(cdr)); - if (Mode == 1) - tmp = cdr.pTransfer - cdr.Transfer; + if (Mode == 1) { + cdr.ParamP = cdr.ParamC; + tmp = pTransfer - cdr.Transfer; + } gzfreeze(&tmp, sizeof(tmp)); - if (Mode == 0) - cdr.pTransfer = cdr.Transfer + tmp; + if (Mode == 0) { + getCdInfo(); + + pTransfer = cdr.Transfer + tmp; + + // read right sub data + memcpy(tmpp, cdr.Prev, 3); + cdr.Prev[0]++; + ReadTrack(tmpp); + + if (cdr.Play) { + if (cdr.freeze_ver < 0x63647202) + memcpy(cdr.SetSectorPlay, cdr.SetSector, 3); + + Find_CurTrack(cdr.SetSectorPlay); + if (!Config.Cdda) + CDR_play(cdr.SetSectorPlay); + } + + 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; + } + } + } return 0; } void LidInterrupt() { - cdr.LidCheck = 0x20; // start checker - - CDRLID_INT( cdReadTime * 3 ); - - // generate interrupt if none active - open or close - if (cdr.Irq == 0 || cdr.Irq == 0xff) { - cdr.Ctrl |= 0x80; - cdr.Stat = NoIntr; - AddIrqQueue(CdlNop, 0x800); - } + getCdInfo(); + StopCdda(); + cdrLidSeekInterrupt(); }