libpcsxcore/cdrom.c

   1 /***************************************************************************
   2  *   Copyright (C) 2007 Ryan Schultz, PCSX-df Team, PCSX team              *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
  18  ***************************************************************************/
  19
  20 /*
  21 * Handles all CD-ROM registers and functions.
  22 */
  23
  24 #include "cdrom.h"
  25 #include "ppf.h"
  26 #include "psxdma.h"
  27 #include "arm_features.h"
  28
  29 /* logging */
  30 #if 0
  31 #define CDR_LOG SysPrintf
  32 #else
  33 #define CDR_LOG(...)
  34 #endif
  35 #if 0
  36 #define CDR_LOG_I SysPrintf
  37 #else
  38 #define CDR_LOG_I(...)
  39 #endif
  40 #if 0
  41 #define CDR_LOG_IO SysPrintf
  42 #else
  43 #define CDR_LOG_IO(...)
  44 #endif
  45 //#define CDR_LOG_CMD_IRQ
  46
  47 cdrStruct cdr;
  48 static unsigned char *pTransfer;
  49 static s16 read_buf[CD_FRAMESIZE_RAW/2];
  50
  51 /* CD-ROM magic numbers */
  52 #define CdlSync        0 /* nocash documentation : "Uh, actually, returns error code 40h = Invalid Command...?" */
  53 #define CdlNop         1
  54 #define CdlSetloc      2
  55 #define CdlPlay        3
  56 #define CdlForward     4
  57 #define CdlBackward    5
  58 #define CdlReadN       6
  59 #define CdlStandby     7
  60 #define CdlStop        8
  61 #define CdlPause       9
  62 #define CdlReset       10
  63 #define CdlMute        11
  64 #define CdlDemute      12
  65 #define CdlSetfilter   13
  66 #define CdlSetmode     14
  67 #define CdlGetparam    15
  68 #define CdlGetlocL     16
  69 #define CdlGetlocP     17
  70 #define CdlReadT       18
  71 #define CdlGetTN       19
  72 #define CdlGetTD       20
  73 #define CdlSeekL       21
  74 #define CdlSeekP       22
  75 #define CdlSetclock    23
  76 #define CdlGetclock    24
  77 #define CdlTest        25
  78 #define CdlID          26
  79 #define CdlReadS       27
  80 #define CdlInit        28
  81 #define CdlGetQ        29
  82 #define CdlReadToc     30
  83
  84 char *CmdName[0x100]= {
  85     "CdlSync",     "CdlNop",       "CdlSetloc",  "CdlPlay",
  86     "CdlForward",  "CdlBackward",  "CdlReadN",   "CdlStandby",
  87     "CdlStop",     "CdlPause",     "CdlReset",   "CdlMute",
  88     "CdlDemute",   "CdlSetfilter", "CdlSetmode", "CdlGetparam",
  89     "CdlGetlocL",  "CdlGetlocP",   "CdlReadT",   "CdlGetTN",
  90     "CdlGetTD",    "CdlSeekL",     "CdlSeekP",   "CdlSetclock",
  91     "CdlGetclock", "CdlTest",      "CdlID",      "CdlReadS",
  92     "CdlInit",    NULL,           "CDlReadToc", NULL
  93 };
  94
  95 unsigned char Test04[] = { 0 };
  96 unsigned char Test05[] = { 0 };
  97 unsigned char Test20[] = { 0x98, 0x06, 0x10, 0xC3 };
  98 unsigned char Test22[] = { 0x66, 0x6F, 0x72, 0x20, 0x45, 0x75, 0x72, 0x6F };
  99 unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 };
 100
 101 // cdr.Stat:
 102 #define NoIntr          0
 103 #define DataReady       1
 104 #define Complete        2
 105 #define Acknowledge     3
 106 #define DataEnd         4
 107 #define DiskError       5
 108
 109 /* Modes flags */
 110 #define MODE_SPEED       (1<<7) // 0x80
 111 #define MODE_STRSND      (1<<6) // 0x40 ADPCM on/off
 112 #define MODE_SIZE_2340   (1<<5) // 0x20
 113 #define MODE_SIZE_2328   (1<<4) // 0x10
 114 #define MODE_SIZE_2048   (0<<4) // 0x00
 115 #define MODE_SF          (1<<3) // 0x08 channel on/off
 116 #define MODE_REPORT      (1<<2) // 0x04
 117 #define MODE_AUTOPAUSE   (1<<1) // 0x02
 118 #define MODE_CDDA        (1<<0) // 0x01
 119
 120 /* Status flags */
 121 #define STATUS_PLAY      (1<<7) // 0x80
 122 #define STATUS_SEEK      (1<<6) // 0x40
 123 #define STATUS_READ      (1<<5) // 0x20
 124 #define STATUS_SHELLOPEN (1<<4) // 0x10
 125 #define STATUS_UNKNOWN3  (1<<3) // 0x08
 126 #define STATUS_UNKNOWN2  (1<<2) // 0x04
 127 #define STATUS_ROTATING  (1<<1) // 0x02
 128 #define STATUS_ERROR     (1<<0) // 0x01
 129
 130 /* Errors */
 131 #define ERROR_NOTREADY   (1<<7) // 0x80
 132 #define ERROR_INVALIDCMD (1<<6) // 0x40
 133 #define ERROR_INVALIDARG (1<<5) // 0x20
 134
 135 // 1x = 75 sectors per second
 136 // PSXCLK = 1 sec in the ps
 137 // so (PSXCLK / 75) = cdr read time (linuzappz)
 138 #define cdReadTime (PSXCLK / 75)
 139
 140 enum drive_state {
 141         DRIVESTATE_STANDBY = 0,
 142         DRIVESTATE_LID_OPEN,
 143         DRIVESTATE_RESCAN_CD,
 144         DRIVESTATE_PREPARE_CD,
 145         DRIVESTATE_STOPPED,
 146 };
 147
 148 // for cdr.Seeked
 149 enum seeked_state {
 150         SEEK_PENDING = 0,
 151         SEEK_DONE = 1,
 152 };
 153
 154 static struct CdrStat stat;
 155
 156 static unsigned int msf2sec(const u8 *msf) {
 157         return ((msf[0] * 60 + msf[1]) * 75) + msf[2];
 158 }
 159
 160 // for that weird psemu API..
 161 static unsigned int fsm2sec(const u8 *msf) {
 162         return ((msf[2] * 60 + msf[1]) * 75) + msf[0];
 163 }
 164
 165 static void sec2msf(unsigned int s, u8 *msf) {
 166         msf[0] = s / 75 / 60;
 167         s = s - msf[0] * 75 * 60;
 168         msf[1] = s / 75;
 169         s = s - msf[1] * 75;
 170         msf[2] = s;
 171 }
 172
 173 // cdrInterrupt
 174 #define CDR_INT(eCycle) { \
 175         psxRegs.interrupt |= (1 << PSXINT_CDR); \
 176         psxRegs.intCycle[PSXINT_CDR].cycle = eCycle; \
 177         psxRegs.intCycle[PSXINT_CDR].sCycle = psxRegs.cycle; \
 178         new_dyna_set_event(PSXINT_CDR, eCycle); \
 179 }
 180
 181 // cdrReadInterrupt
 182 #define CDREAD_INT(eCycle) { \
 183         psxRegs.interrupt |= (1 << PSXINT_CDREAD); \
 184         psxRegs.intCycle[PSXINT_CDREAD].cycle = eCycle; \
 185         psxRegs.intCycle[PSXINT_CDREAD].sCycle = psxRegs.cycle; \
 186         new_dyna_set_event(PSXINT_CDREAD, eCycle); \
 187 }
 188
 189 // cdrLidSeekInterrupt
 190 #define CDRLID_INT(eCycle) { \
 191         psxRegs.interrupt |= (1 << PSXINT_CDRLID); \
 192         psxRegs.intCycle[PSXINT_CDRLID].cycle = eCycle; \
 193         psxRegs.intCycle[PSXINT_CDRLID].sCycle = psxRegs.cycle; \
 194         new_dyna_set_event(PSXINT_CDRLID, eCycle); \
 195 }
 196
 197 // cdrPlayInterrupt
 198 #define CDRMISC_INT(eCycle) { \
 199         psxRegs.interrupt |= (1 << PSXINT_CDRPLAY); \
 200         psxRegs.intCycle[PSXINT_CDRPLAY].cycle = eCycle; \
 201         psxRegs.intCycle[PSXINT_CDRPLAY].sCycle = psxRegs.cycle; \
 202         new_dyna_set_event(PSXINT_CDRPLAY, eCycle); \
 203 }
 204
 205 #define StopReading() { \
 206         if (cdr.Reading) { \
 207                 cdr.Reading = 0; \
 208                 psxRegs.interrupt &= ~(1 << PSXINT_CDREAD); \
 209         } \
 210         cdr.StatP &= ~(STATUS_READ|STATUS_SEEK);\
 211 }
 212
 213 #define StopCdda() { \
 214         if (cdr.Play) { \
 215                 if (!Config.Cdda) CDR_stop(); \
 216                 cdr.StatP &= ~STATUS_PLAY; \
 217                 cdr.Play = FALSE; \
 218                 cdr.FastForward = 0; \
 219                 cdr.FastBackward = 0; \
 220                 /*SPU_registerCallback( SPUirq );*/ \
 221         } \
 222 }
 223
 224 #define SetResultSize(size) { \
 225         cdr.ResultP = 0; \
 226         cdr.ResultC = size; \
 227         cdr.ResultReady = 1; \
 228 }
 229
 230 static void setIrq(void)
 231 {
 232         if (cdr.Stat & cdr.Reg2)
 233                 psxHu32ref(0x1070) |= SWAP32((u32)0x4);
 234 }
 235
 236 // timing used in this function was taken from tests on real hardware
 237 // (yes it's slow, but you probably don't want to modify it)
 238 void cdrLidSeekInterrupt()
 239 {
 240         switch (cdr.DriveState) {
 241         default:
 242         case DRIVESTATE_STANDBY:
 243                 cdr.StatP &= ~STATUS_SEEK;
 244
 245                 if (CDR_getStatus(&stat) == -1)
 246                         return;
 247
 248                 if (stat.Status & STATUS_SHELLOPEN)
 249                 {
 250                         StopCdda();
 251                         cdr.DriveState = DRIVESTATE_LID_OPEN;
 252                         CDRLID_INT(0x800);
 253                 }
 254                 break;
 255
 256         case DRIVESTATE_LID_OPEN:
 257                 if (CDR_getStatus(&stat) == -1)
 258                         stat.Status &= ~STATUS_SHELLOPEN;
 259
 260                 // 02, 12, 10
 261                 if (!(cdr.StatP & STATUS_SHELLOPEN)) {
 262                         StopReading();
 263                         cdr.StatP |= STATUS_SHELLOPEN;
 264
 265                         // could generate error irq here, but real hardware
 266                         // only sometimes does that
 267                         // (not done when lots of commands are sent?)
 268
 269                         CDRLID_INT(cdReadTime * 30);
 270                         break;
 271                 }
 272                 else if (cdr.StatP & STATUS_ROTATING) {
 273                         cdr.StatP &= ~STATUS_ROTATING;
 274                 }
 275                 else if (!(stat.Status & STATUS_SHELLOPEN)) {
 276                         // closed now
 277                         CheckCdrom();
 278
 279                         // cdr.StatP STATUS_SHELLOPEN is "sticky"
 280                         // and is only cleared by CdlNop
 281
 282                         cdr.DriveState = DRIVESTATE_RESCAN_CD;
 283                         CDRLID_INT(cdReadTime * 105);
 284                         break;
 285                 }
 286
 287                 // recheck for close
 288                 CDRLID_INT(cdReadTime * 3);
 289                 break;
 290
 291         case DRIVESTATE_RESCAN_CD:
 292                 cdr.StatP |= STATUS_ROTATING;
 293                 cdr.DriveState = DRIVESTATE_PREPARE_CD;
 294
 295                 // this is very long on real hardware, over 6 seconds
 296                 // make it a bit faster here...
 297                 CDRLID_INT(cdReadTime * 150);
 298                 break;
 299
 300         case DRIVESTATE_PREPARE_CD:
 301                 cdr.StatP |= STATUS_SEEK;
 302
 303                 cdr.DriveState = DRIVESTATE_STANDBY;
 304                 CDRLID_INT(cdReadTime * 26);
 305                 break;
 306         }
 307 }
 308
 309 static void Find_CurTrack(const u8 *time)
 310 {
 311         int current, sect;
 312
 313         current = msf2sec(time);
 314
 315         for (cdr.CurTrack = 1; cdr.CurTrack < cdr.ResultTN[1]; cdr.CurTrack++) {
 316                 CDR_getTD(cdr.CurTrack + 1, cdr.ResultTD);
 317                 sect = fsm2sec(cdr.ResultTD);
 318                 if (sect - current >= 150)
 319                         break;
 320         }
 321 }
 322
 323 static void generate_subq(const u8 *time)
 324 {
 325         unsigned char start[3], next[3];
 326         unsigned int this_s, start_s, next_s, pregap;
 327         int relative_s;
 328
 329         CDR_getTD(cdr.CurTrack, start);
 330         if (cdr.CurTrack + 1 <= cdr.ResultTN[1]) {
 331                 pregap = 150;
 332                 CDR_getTD(cdr.CurTrack + 1, next);
 333         }
 334         else {
 335                 // last track - cd size
 336                 pregap = 0;
 337                 next[0] = cdr.SetSectorEnd[2];
 338                 next[1] = cdr.SetSectorEnd[1];
 339                 next[2] = cdr.SetSectorEnd[0];
 340         }
 341
 342         this_s = msf2sec(time);
 343         start_s = fsm2sec(start);
 344         next_s = fsm2sec(next);
 345
 346         cdr.TrackChanged = FALSE;
 347
 348         if (next_s - this_s < pregap) {
 349                 cdr.TrackChanged = TRUE;
 350                 cdr.CurTrack++;
 351                 start_s = next_s;
 352         }
 353
 354         cdr.subq.Index = 1;
 355
 356         relative_s = this_s - start_s;
 357         if (relative_s < 0) {
 358                 cdr.subq.Index = 0;
 359                 relative_s = -relative_s;
 360         }
 361         sec2msf(relative_s, cdr.subq.Relative);
 362
 363         cdr.subq.Track = itob(cdr.CurTrack);
 364         cdr.subq.Relative[0] = itob(cdr.subq.Relative[0]);
 365         cdr.subq.Relative[1] = itob(cdr.subq.Relative[1]);
 366         cdr.subq.Relative[2] = itob(cdr.subq.Relative[2]);
 367         cdr.subq.Absolute[0] = itob(time[0]);
 368         cdr.subq.Absolute[1] = itob(time[1]);
 369         cdr.subq.Absolute[2] = itob(time[2]);
 370 }
 371
 372 static void ReadTrack(const u8 *time) {
 373         unsigned char tmp[3];
 374         struct SubQ *subq;
 375         u16 crc;
 376
 377         tmp[0] = itob(time[0]);
 378         tmp[1] = itob(time[1]);
 379         tmp[2] = itob(time[2]);
 380
 381         if (memcmp(cdr.Prev, tmp, 3) == 0)
 382                 return;
 383
 384         CDR_LOG("ReadTrack *** %02x:%02x:%02x\n", tmp[0], tmp[1], tmp[2]);
 385
 386         cdr.NoErr = CDR_readTrack(tmp);
 387         memcpy(cdr.Prev, tmp, 3);
 388
 389         if (CheckSBI(time))
 390                 return;
 391
 392         subq = (struct SubQ *)CDR_getBufferSub();
 393         if (subq != NULL && cdr.CurTrack == 1) {
 394                 crc = calcCrc((u8 *)subq + 12, 10);
 395                 if (crc == (((u16)subq->CRC[0] << 8) | subq->CRC[1])) {
 396                         cdr.subq.Track = subq->TrackNumber;
 397                         cdr.subq.Index = subq->IndexNumber;
 398                         memcpy(cdr.subq.Relative, subq->TrackRelativeAddress, 3);
 399                         memcpy(cdr.subq.Absolute, subq->AbsoluteAddress, 3);
 400                 }
 401                 else {
 402                         CDR_LOG_I("subq bad crc @%02x:%02x:%02x\n",
 403                                 tmp[0], tmp[1], tmp[2]);
 404                 }
 405         }
 406         else {
 407                 generate_subq(time);
 408         }
 409
 410         CDR_LOG(" -> %02x,%02x %02x:%02x:%02x %02x:%02x:%02x\n",
 411                 cdr.subq.Track, cdr.subq.Index,
 412                 cdr.subq.Relative[0], cdr.subq.Relative[1], cdr.subq.Relative[2],
 413                 cdr.subq.Absolute[0], cdr.subq.Absolute[1], cdr.subq.Absolute[2]);
 414 }
 415
 416 static void AddIrqQueue(unsigned short irq, unsigned long ecycle) {
 417         if (cdr.Irq != 0) {
 418                 if (irq == cdr.Irq || irq + 0x100 == cdr.Irq) {
 419                         cdr.IrqRepeated = 1;
 420                         CDR_INT(ecycle);
 421                         return;
 422                 }
 423
 424                 CDR_LOG_I("cdr: override cmd %02x -> %02x\n", cdr.Irq, irq);
 425         }
 426
 427         cdr.Irq = irq;
 428         cdr.eCycle = ecycle;
 429
 430         CDR_INT(ecycle);
 431 }
 432
 433 static void cdrPlayInterrupt_Autopause()
 434 {
 435         u32 abs_lev_max = 0;
 436         boolean abs_lev_chselect;
 437         u32 i;
 438
 439         if ((cdr.Mode & MODE_AUTOPAUSE) && cdr.TrackChanged) {
 440                 CDR_LOG( "CDDA STOP\n" );
 441
 442                 // Magic the Gathering
 443                 // - looping territory cdda
 444
 445                 // ...?
 446                 //cdr.ResultReady = 1;
 447                 //cdr.Stat = DataReady;
 448                 cdr.Stat = DataEnd;
 449                 setIrq();
 450
 451                 StopCdda();
 452         }
 453         else if (((cdr.Mode & MODE_REPORT) || cdr.FastForward || cdr.FastBackward)) {
 454                 cdr.Result[0] = cdr.StatP;
 455                 cdr.Result[1] = cdr.subq.Track;
 456                 cdr.Result[2] = cdr.subq.Index;
 457
 458                 abs_lev_chselect = cdr.subq.Absolute[1] & 0x01;
 459
 460                 /* 8 is a hack. For accuracy, it should be 588. */
 461                 for (i = 0; i < 8; i++)
 462                 {
 463                         abs_lev_max = MAX_VALUE(abs_lev_max, abs(read_buf[i * 2 + abs_lev_chselect]));
 464                 }
 465                 abs_lev_max = MIN_VALUE(abs_lev_max, 32767);
 466                 abs_lev_max |= abs_lev_chselect << 15;
 467
 468                 if (cdr.subq.Absolute[2] & 0x10) {
 469                         cdr.Result[3] = cdr.subq.Relative[0];
 470                         cdr.Result[4] = cdr.subq.Relative[1] | 0x80;
 471                         cdr.Result[5] = cdr.subq.Relative[2];
 472                 }
 473                 else {
 474                         cdr.Result[3] = cdr.subq.Absolute[0];
 475                         cdr.Result[4] = cdr.subq.Absolute[1];
 476                         cdr.Result[5] = cdr.subq.Absolute[2];
 477                 }
 478
 479                 cdr.Result[6] = abs_lev_max >> 0;
 480                 cdr.Result[7] = abs_lev_max >> 8;
 481
 482                 // Rayman: Logo freeze (resultready + dataready)
 483                 cdr.ResultReady = 1;
 484                 cdr.Stat = DataReady;
 485
 486                 SetResultSize(8);
 487                 setIrq();
 488         }
 489 }
 490
 491 // also handles seek
 492 void cdrPlayInterrupt()
 493 {
 494         if (cdr.Seeked == SEEK_PENDING) {
 495                 if (cdr.Stat) {
 496                         CDR_LOG_I("cdrom: seek stat hack\n");
 497                         CDRMISC_INT(0x1000);
 498                         return;
 499                 }
 500                 SetResultSize(1);
 501                 cdr.StatP |= STATUS_ROTATING;
 502                 cdr.StatP &= ~STATUS_SEEK;
 503                 cdr.Result[0] = cdr.StatP;
 504                 cdr.Seeked = SEEK_DONE;
 505                 if (cdr.Irq == 0) {
 506                         cdr.Stat = Complete;
 507                         setIrq();
 508                 }
 509
 510                 if (cdr.SetlocPending) {
 511                         memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
 512                         cdr.SetlocPending = 0;
 513                         cdr.m_locationChanged = TRUE;
 514                 }
 515                 Find_CurTrack(cdr.SetSectorPlay);
 516                 ReadTrack(cdr.SetSectorPlay);
 517                 cdr.TrackChanged = FALSE;
 518         }
 519
 520         if (!cdr.Play) return;
 521
 522         CDR_LOG( "CDDA - %d:%d:%d\n",
 523                 cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] );
 524
 525         if (memcmp(cdr.SetSectorPlay, cdr.SetSectorEnd, 3) == 0) {
 526                 StopCdda();
 527                 cdr.TrackChanged = TRUE;
 528         }
 529         else {
 530                 CDR_readCDDA(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], (u8 *)read_buf);
 531         }
 532
 533         if (!cdr.Irq && !cdr.Stat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT)))
 534                 cdrPlayInterrupt_Autopause();
 535
 536         if (CDR_readCDDA && !cdr.Muted && !Config.Cdda) {
 537                 cdrAttenuate(read_buf, CD_FRAMESIZE_RAW / 4, 1);
 538                 if (SPU_playCDDAchannel)
 539                         SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW);
 540         }
 541
 542         cdr.SetSectorPlay[2]++;
 543         if (cdr.SetSectorPlay[2] == 75) {
 544                 cdr.SetSectorPlay[2] = 0;
 545                 cdr.SetSectorPlay[1]++;
 546                 if (cdr.SetSectorPlay[1] == 60) {
 547                         cdr.SetSectorPlay[1] = 0;
 548                         cdr.SetSectorPlay[0]++;
 549                 }
 550         }
 551
 552         if (cdr.m_locationChanged)
 553         {
 554                 CDRMISC_INT(cdReadTime * 30);
 555                 cdr.m_locationChanged = FALSE;
 556         }
 557         else
 558         {
 559                 CDRMISC_INT(cdReadTime);
 560         }
 561
 562         // update for CdlGetlocP/autopause
 563         generate_subq(cdr.SetSectorPlay);
 564 }
 565
 566 void cdrInterrupt() {
 567         u16 Irq = cdr.Irq;
 568         int no_busy_error = 0;
 569         int start_rotating = 0;
 570         int error = 0;
 571         int delay;
 572         unsigned int seekTime = 0;
 573         u8 set_loc[3];
 574         int i;
 575
 576         // Reschedule IRQ
 577         if (cdr.Stat) {
 578                 CDR_LOG_I("cdrom: stat hack: %02x %x\n", cdr.Irq, cdr.Stat);
 579                 CDR_INT(0x1000);
 580                 return;
 581         }
 582
 583         cdr.Ctrl &= ~0x80;
 584
 585         // default response
 586         SetResultSize(1);
 587         cdr.Result[0] = cdr.StatP;
 588         cdr.Stat = Acknowledge;
 589
 590         if (cdr.IrqRepeated) {
 591                 cdr.IrqRepeated = 0;
 592                 if (cdr.eCycle > psxRegs.cycle) {
 593                         CDR_INT(cdr.eCycle);
 594                         goto finish;
 595                 }
 596         }
 597
 598         cdr.Irq = 0;
 599
 600         switch (Irq) {
 601                 case CdlNop:
 602                         if (cdr.DriveState != DRIVESTATE_LID_OPEN)
 603                                 cdr.StatP &= ~STATUS_SHELLOPEN;
 604                         no_busy_error = 1;
 605                         break;
 606
 607                 case CdlSetloc:
 608                         CDR_LOG("CDROM setloc command (%02X, %02X, %02X)\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
 609
 610                         // MM must be BCD, SS must be BCD and <0x60, FF must be BCD and <0x75
 611                         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))
 612                         {
 613                                 CDR_LOG("Invalid/out of range seek to %02X:%02X:%02X\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
 614                                 error = ERROR_INVALIDARG;
 615                                 goto set_error;
 616                         }
 617                         else
 618                         {
 619                                 for (i = 0; i < 3; i++)
 620                                 {
 621                                         set_loc[i] = btoi(cdr.Param[i]);
 622                                 }
 623
 624                                 i = msf2sec(cdr.SetSectorPlay);
 625                                 i = abs(i - msf2sec(set_loc));
 626                                 if (i > 16)
 627                                         cdr.Seeked = SEEK_PENDING;
 628
 629                                 memcpy(cdr.SetSector, set_loc, 3);
 630                                 cdr.SetSector[3] = 0;
 631                                 cdr.SetlocPending = 1;
 632                         }
 633                         break;
 634
 635                 do_CdlPlay:
 636                 case CdlPlay:
 637                         StopCdda();
 638                         if (cdr.Seeked == SEEK_PENDING) {
 639                                 // XXX: wrong, should seek instead..
 640                                 cdr.Seeked = SEEK_DONE;
 641                         }
 642
 643                         cdr.FastBackward = 0;
 644                         cdr.FastForward = 0;
 645
 646                         if (cdr.SetlocPending) {
 647                                 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
 648                                 cdr.SetlocPending = 0;
 649                                 cdr.m_locationChanged = TRUE;
 650                         }
 651
 652                         // BIOS CD Player
 653                         // - Pause player, hit Track 01/02/../xx (Setloc issued!!)
 654
 655                         if (cdr.ParamC == 0 || cdr.Param[0] == 0) {
 656                                 CDR_LOG("PLAY Resume @ %d:%d:%d\n",
 657                                         cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]);
 658                         }
 659                         else
 660                         {
 661                                 int track = btoi( cdr.Param[0] );
 662
 663                                 if (track <= cdr.ResultTN[1])
 664                                         cdr.CurTrack = track;
 665
 666                                 CDR_LOG("PLAY track %d\n", cdr.CurTrack);
 667
 668                                 if (CDR_getTD((u8)cdr.CurTrack, cdr.ResultTD) != -1) {
 669                                         cdr.SetSectorPlay[0] = cdr.ResultTD[2];
 670                                         cdr.SetSectorPlay[1] = cdr.ResultTD[1];
 671                                         cdr.SetSectorPlay[2] = cdr.ResultTD[0];
 672                                 }
 673                         }
 674
 675                         /*
 676                         Rayman: detect track changes
 677                         - fixes logo freeze
 678
 679                         Twisted Metal 2: skip PREGAP + starting accurate SubQ
 680                         - plays tracks without retry play
 681
 682                         Wild 9: skip PREGAP + starting accurate SubQ
 683                         - plays tracks without retry play
 684                         */
 685                         Find_CurTrack(cdr.SetSectorPlay);
 686                         ReadTrack(cdr.SetSectorPlay);
 687                         cdr.TrackChanged = FALSE;
 688
 689                         StopReading();
 690                         if (!Config.Cdda)
 691                                 CDR_play();
 692
 693                         // Vib Ribbon: gameplay checks flag
 694                         cdr.StatP &= ~STATUS_SEEK;
 695                         cdr.Result[0] = cdr.StatP;
 696
 697                         cdr.StatP |= STATUS_PLAY;
 698
 699                         // BIOS player - set flag again
 700                         cdr.Play = TRUE;
 701
 702                         CDRMISC_INT( cdReadTime );
 703                         start_rotating = 1;
 704                         break;
 705
 706                 case CdlForward:
 707                         // TODO: error 80 if stopped
 708                         cdr.Stat = Complete;
 709                         // GameShark CD Player: Calls 2x + Play 2x
 710                         cdr.FastForward = 1;
 711                         cdr.FastBackward = 0;
 712                         break;
 713
 714                 case CdlBackward:
 715                         cdr.Stat = Complete;
 716
 717                         // GameShark CD Player: Calls 2x + Play 2x
 718                         cdr.FastBackward =1;
 719                         cdr.FastForward = 0;
 720                         break;
 721
 722                 case CdlStandby:
 723                         if (cdr.DriveState != DRIVESTATE_STOPPED) {
 724                                 error = ERROR_INVALIDARG;
 725                                 goto set_error;
 726                         }
 727                         AddIrqQueue(CdlStandby + 0x100, cdReadTime * 125 / 2);
 728                         start_rotating = 1;
 729                         break;
 730
 731                 case CdlStandby + 0x100:
 732                         cdr.Stat = Complete;
 733                         break;
 734
 735                 case CdlStop:
 736                         if (cdr.Play) {
 737                                 // grab time for current track
 738                                 CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD);
 739
 740                                 cdr.SetSectorPlay[0] = cdr.ResultTD[2];
 741                                 cdr.SetSectorPlay[1] = cdr.ResultTD[1];
 742                                 cdr.SetSectorPlay[2] = cdr.ResultTD[0];
 743                         }
 744
 745                         StopCdda();
 746                         StopReading();
 747
 748                         delay = 0x800;
 749                         if (cdr.DriveState == DRIVESTATE_STANDBY)
 750                                 delay = cdReadTime * 30 / 2;
 751
 752                         cdr.DriveState = DRIVESTATE_STOPPED;
 753                         AddIrqQueue(CdlStop + 0x100, delay);
 754                         break;
 755
 756                 case CdlStop + 0x100:
 757                         cdr.StatP &= ~STATUS_ROTATING;
 758                         cdr.Result[0] = cdr.StatP;
 759                         cdr.Stat = Complete;
 760                         break;
 761
 762                 case CdlPause:
 763                         /*
 764                         Gundam Battle Assault 2: much slower (*)
 765                         - Fixes boot, gameplay
 766                         Hokuto no Ken 2: slower
 767                         - Fixes intro + subtitles
 768                         InuYasha - Feudal Fairy Tale: slower
 769                         - Fixes battles
 770                         */
 771                         /* Gameblabla - Tightening the timings (as taken from Duckstation).
 772                          * The timings from Duckstation are based upon hardware tests.
 773                          * Mednafen's timing don't work for Gundam Battle Assault 2 in PAL/50hz mode,
 774                          * seems to be timing sensitive as it can depend on the CPU's clock speed.
 775                          *
 776                          * We will need to get around this for Bedlam/Rise 2 later...
 777                          * */
 778                         if (cdr.DriveState == DRIVESTATE_STANDBY)
 779                         {
 780                                 delay = 7000;
 781                         }
 782                         else
 783                         {
 784                                 delay = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * (1000000));
 785                                 CDRMISC_INT((cdr.Mode & MODE_SPEED) ? cdReadTime / 2 : cdReadTime);
 786                         }
 787                         AddIrqQueue(CdlPause + 0x100, delay);
 788                         cdr.Ctrl |= 0x80;
 789                         break;
 790
 791                 case CdlPause + 0x100:
 792                         cdr.StatP &= ~STATUS_READ;
 793                         cdr.Result[0] = cdr.StatP;
 794                         cdr.Stat = Complete;
 795                         break;
 796
 797                 case CdlReset:
 798                         cdr.Muted = FALSE;
 799                         cdr.Mode = 0x20; /* Needed for This is Football 2, Pooh's Party and possibly others. */
 800                         AddIrqQueue(CdlReset + 0x100, 4100000);
 801                         no_busy_error = 1;
 802                         start_rotating = 1;
 803                         break;
 804
 805                 case CdlReset + 0x100:
 806                         cdr.Stat = Complete;
 807                         break;
 808
 809                 case CdlMute:
 810                         cdr.Muted = TRUE;
 811                         break;
 812
 813                 case CdlDemute:
 814                         cdr.Muted = FALSE;
 815                         break;
 816
 817                 case CdlSetfilter:
 818                         cdr.File = cdr.Param[0];
 819                         cdr.Channel = cdr.Param[1];
 820                         break;
 821
 822                 case CdlSetmode:
 823                         no_busy_error = 1;
 824                         break;
 825
 826                 case CdlGetparam:
 827                         SetResultSize(5);
 828                         cdr.Result[1] = cdr.Mode;
 829                         cdr.Result[2] = 0;
 830                         cdr.Result[3] = cdr.File;
 831                         cdr.Result[4] = cdr.Channel;
 832                         no_busy_error = 1;
 833                         break;
 834
 835                 case CdlGetlocL:
 836                         SetResultSize(8);
 837                         memcpy(cdr.Result, cdr.Transfer, 8);
 838                         break;
 839
 840                 case CdlGetlocP:
 841                         SetResultSize(8);
 842                         memcpy(&cdr.Result, &cdr.subq, 8);
 843                         break;
 844
 845                 case CdlReadT: // SetSession?
 846                         // really long
 847                         AddIrqQueue(CdlReadT + 0x100, cdReadTime * 290 / 4);
 848                         start_rotating = 1;
 849                         break;
 850
 851                 case CdlReadT + 0x100:
 852                         cdr.Stat = Complete;
 853                         break;
 854
 855                 case CdlGetTN:
 856                         SetResultSize(3);
 857                         if (CDR_getTN(cdr.ResultTN) == -1) {
 858                                 cdr.Stat = DiskError;
 859                                 cdr.Result[0] |= STATUS_ERROR;
 860                         } else {
 861                                 cdr.Stat = Acknowledge;
 862                                 cdr.Result[1] = itob(cdr.ResultTN[0]);
 863                                 cdr.Result[2] = itob(cdr.ResultTN[1]);
 864                         }
 865                         break;
 866
 867                 case CdlGetTD:
 868                         cdr.Track = btoi(cdr.Param[0]);
 869                         SetResultSize(4);
 870                         if (CDR_getTD(cdr.Track, cdr.ResultTD) == -1) {
 871                                 cdr.Stat = DiskError;
 872                                 cdr.Result[0] |= STATUS_ERROR;
 873                         } else {
 874                                 cdr.Stat = Acknowledge;
 875                                 cdr.Result[0] = cdr.StatP;
 876                                 cdr.Result[1] = itob(cdr.ResultTD[2]);
 877                                 cdr.Result[2] = itob(cdr.ResultTD[1]);
 878                                 /* According to Nocash's documentation, the function doesn't care about ff.
 879                                  * This can be seen also in Mednafen's implementation. */
 880                                 //cdr.Result[3] = itob(cdr.ResultTD[0]);
 881                         }
 882                         break;
 883
 884                 case CdlSeekL:
 885                 case CdlSeekP:
 886                         StopCdda();
 887                         StopReading();
 888                         cdr.StatP |= STATUS_SEEK;
 889
 890                         /*
 891                         Crusaders of Might and Magic = 0.5x-4x
 892                         - fix cutscene speech start
 893
 894                         Eggs of Steel = 2x-?
 895                         - fix new game
 896
 897                         Medievil = ?-4x
 898                         - fix cutscene speech
 899
 900                         Rockman X5 = 0.5-4x
 901                         - fix capcom logo
 902                         */
 903                         CDRMISC_INT(cdr.Seeked == SEEK_DONE ? 0x800 : cdReadTime * 4);
 904                         cdr.Seeked = SEEK_PENDING;
 905                         start_rotating = 1;
 906                         break;
 907
 908                 case CdlTest:
 909                         switch (cdr.Param[0]) {
 910                                 case 0x20: // System Controller ROM Version
 911                                         SetResultSize(4);
 912                                         memcpy(cdr.Result, Test20, 4);
 913                                         break;
 914                                 case 0x22:
 915                                         SetResultSize(8);
 916                                         memcpy(cdr.Result, Test22, 4);
 917                                         break;
 918                                 case 0x23: case 0x24:
 919                                         SetResultSize(8);
 920                                         memcpy(cdr.Result, Test23, 4);
 921                                         break;
 922                         }
 923                         no_busy_error = 1;
 924                         break;
 925
 926                 case CdlID:
 927                         AddIrqQueue(CdlID + 0x100, 20480);
 928                         break;
 929
 930                 case CdlID + 0x100:
 931                         SetResultSize(8);
 932                         cdr.Result[0] = cdr.StatP;
 933                         cdr.Result[1] = 0;
 934                         cdr.Result[2] = 0;
 935                         cdr.Result[3] = 0;
 936
 937                         // 0x10 - audio | 0x40 - disk missing | 0x80 - unlicensed
 938                         if (CDR_getStatus(&stat) == -1 || stat.Type == 0 || stat.Type == 0xff) {
 939                                 cdr.Result[1] = 0xc0;
 940                         }
 941                         else {
 942                                 if (stat.Type == 2)
 943                                         cdr.Result[1] |= 0x10;
 944                                 if (CdromId[0] == '\0')
 945                                         cdr.Result[1] |= 0x80;
 946                         }
 947                         cdr.Result[0] |= (cdr.Result[1] >> 4) & 0x08;
 948
 949                         /* This adds the string "PCSX" in Playstation bios boot screen */
 950                         memcpy((char *)&cdr.Result[4], "PCSX", 4);
 951                         cdr.Stat = Complete;
 952                         break;
 953
 954                 case CdlInit:
 955                         // yes, it really sets STATUS_SHELLOPEN
 956                         cdr.StatP |= STATUS_SHELLOPEN;
 957                         cdr.DriveState = DRIVESTATE_RESCAN_CD;
 958                         CDRLID_INT(20480);
 959                         no_busy_error = 1;
 960                         start_rotating = 1;
 961                         break;
 962
 963                 case CdlGetQ:
 964                         no_busy_error = 1;
 965                         break;
 966
 967                 case CdlReadToc:
 968                         AddIrqQueue(CdlReadToc + 0x100, cdReadTime * 180 / 4);
 969                         no_busy_error = 1;
 970                         start_rotating = 1;
 971                         break;
 972
 973                 case CdlReadToc + 0x100:
 974                         cdr.Stat = Complete;
 975                         no_busy_error = 1;
 976                         break;
 977
 978                 case CdlReadN:
 979                 case CdlReadS:
 980                         if (cdr.SetlocPending) {
 981                                 seekTime = abs(msf2sec(cdr.SetSectorPlay) - msf2sec(cdr.SetSector)) * (cdReadTime / 200);
 982                                 /*
 983                                 * Gameblabla :
 984                                 * It was originally set to 1000000 for Driver, however it is not high enough for Worms Pinball
 985                                 * and was unreliable for that game.
 986                                 * I also tested it against Mednafen and Driver's titlescreen music starts 25 frames later, not immediatly.
 987                                 *
 988                                 * Obviously, this isn't perfect but right now, it should be a bit better.
 989                                 * Games to test this against if you change that setting :
 990                                 * - Driver (titlescreen music delay and retry mission)
 991                                 * - Worms Pinball (Will either not boot or crash in the memory card screen)
 992                                 * - Viewpoint (short pauses if the delay in the ingame music is too long)
 993                                 *
 994                                 * It seems that 3386880 * 5 is too much for Driver's titlescreen and it starts skipping.
 995                                 * However, 1000000 is not enough for Worms Pinball to reliably boot.
 996                                 */
 997                                 if(seekTime > 3386880 * 2) seekTime = 3386880 * 2;
 998                                 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
 999                                 cdr.SetlocPending = 0;
1000                                 cdr.m_locationChanged = TRUE;
1001                         }
1002                         Find_CurTrack(cdr.SetSectorPlay);
1003
1004                         if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1)
1005                                 // Read* acts as play for cdda tracks in cdda mode
1006                                 goto do_CdlPlay;
1007
1008                         cdr.Reading = 1;
1009                         cdr.FirstSector = 1;
1010
1011                         // Fighting Force 2 - update subq time immediately
1012                         // - fixes new game
1013                         ReadTrack(cdr.SetSectorPlay);
1014
1015
1016                         // Crusaders of Might and Magic - update getlocl now
1017                         // - fixes cutscene speech
1018                         {
1019                                 u8 *buf = CDR_getBuffer();
1020                                 if (buf != NULL)
1021                                         memcpy(cdr.Transfer, buf, 8);
1022                         }
1023
1024                         /*
1025                         Duke Nukem: Land of the Babes - seek then delay read for one frame
1026                         - fixes cutscenes
1027                         C-12 - Final Resistance - doesn't like seek
1028                         */
1029
1030                         /*
1031                                 By nicolasnoble from PCSX Redux :
1032                                 "It LOOKS like this logic is wrong, therefore disabling it with `&& false` for now.
1033                                 For "PoPoLoCrois Monogatari II", the game logic will soft lock and will never issue GetLocP to detect
1034                                 the end of its XA streams, as it seems to assume ReadS will not return a status byte with the SEEK
1035                                 flag set. I think the reasonning is that since it's invalid to call GetLocP while seeking, the game
1036                                 tries to protect itself against errors by preventing from issuing a GetLocP while it knows the
1037                                 last status was "seek". But this makes the logic just softlock as it'll never get a notification
1038                                 about the fact the drive is done seeking and the read actually started.
1039                                 In other words, this state machine here is probably wrong in assuming the response to ReadS/ReadN is
1040                                 done right away. It's rather when it's done seeking, and the read has actually started. This probably
1041                                 requires a bit more work to make sure seek delays are processed properly.
1042                                 Checked with a few games, this seems to work fine."
1043
1044                                 Gameblabla additional notes :
1045                                 This still needs the "+ seekTime" that PCSX Redux doesn't have for the Driver "retry" mission error.
1046                         */
1047                         cdr.StatP |= STATUS_READ;
1048                         cdr.StatP &= ~STATUS_SEEK;
1049                         CDREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime);
1050
1051                         cdr.Result[0] = cdr.StatP;
1052                         start_rotating = 1;
1053                         break;
1054
1055                 case CdlSync:
1056                 default:
1057                         CDR_LOG_I("Invalid command: %02x\n", Irq);
1058                         error = ERROR_INVALIDCMD;
1059                         // FALLTHROUGH
1060
1061                 set_error:
1062                         SetResultSize(2);
1063                         cdr.Result[0] = cdr.StatP | STATUS_ERROR;
1064                         cdr.Result[1] = error;
1065                         cdr.Stat = DiskError;
1066                         break;
1067         }
1068
1069         if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) {
1070                 cdr.DriveState = DRIVESTATE_STANDBY;
1071                 cdr.StatP |= STATUS_ROTATING;
1072         }
1073
1074         if (!no_busy_error) {
1075                 switch (cdr.DriveState) {
1076                 case DRIVESTATE_LID_OPEN:
1077                 case DRIVESTATE_RESCAN_CD:
1078                 case DRIVESTATE_PREPARE_CD:
1079                         SetResultSize(2);
1080                         cdr.Result[0] = cdr.StatP | STATUS_ERROR;
1081                         cdr.Result[1] = ERROR_NOTREADY;
1082                         cdr.Stat = DiskError;
1083                         break;
1084                 }
1085         }
1086
1087 finish:
1088         setIrq();
1089         cdr.ParamC = 0;
1090
1091 #ifdef CDR_LOG_CMD_IRQ
1092         {
1093                 int i;
1094                 SysPrintf("CDR IRQ %d cmd %02x stat %02x: ",
1095                         !!(cdr.Stat & cdr.Reg2), Irq, cdr.Stat);
1096                 for (i = 0; i < cdr.ResultC; i++)
1097                         SysPrintf("%02x ", cdr.Result[i]);
1098                 SysPrintf("\n");
1099         }
1100 #endif
1101 }
1102
1103 #ifdef HAVE_ARMV7
1104  #define ssat32_to_16(v) \
1105   asm("ssat %0,#16,%1" : "=r" (v) : "r" (v))
1106 #else
1107  #define ssat32_to_16(v) do { \
1108   if (v < -32768) v = -32768; \
1109   else if (v > 32767) v = 32767; \
1110  } while (0)
1111 #endif
1112
1113 void cdrAttenuate(s16 *buf, int samples, int stereo)
1114 {
1115         int i, l, r;
1116         int ll = cdr.AttenuatorLeftToLeft;
1117         int lr = cdr.AttenuatorLeftToRight;
1118         int rl = cdr.AttenuatorRightToLeft;
1119         int rr = cdr.AttenuatorRightToRight;
1120
1121         if (lr == 0 && rl == 0 && 0x78 <= ll && ll <= 0x88 && 0x78 <= rr && rr <= 0x88)
1122                 return;
1123
1124         if (!stereo && ll == 0x40 && lr == 0x40 && rl == 0x40 && rr == 0x40)
1125                 return;
1126
1127         if (stereo) {
1128                 for (i = 0; i < samples; i++) {
1129                         l = buf[i * 2];
1130                         r = buf[i * 2 + 1];
1131                         l = (l * ll + r * rl) >> 7;
1132                         r = (r * rr + l * lr) >> 7;
1133                         ssat32_to_16(l);
1134                         ssat32_to_16(r);
1135                         buf[i * 2] = l;
1136                         buf[i * 2 + 1] = r;
1137                 }
1138         }
1139         else {
1140                 for (i = 0; i < samples; i++) {
1141                         l = buf[i];
1142                         l = l * (ll + rl) >> 7;
1143                         //r = r * (rr + lr) >> 7;
1144                         ssat32_to_16(l);
1145                         //ssat32_to_16(r);
1146                         buf[i] = l;
1147                 }
1148         }
1149 }
1150
1151 void cdrReadInterrupt() {
1152         u8 *buf;
1153
1154         if (!cdr.Reading)
1155                 return;
1156
1157         if (cdr.Irq || cdr.Stat) {
1158                 CDR_LOG_I("cdrom: read stat hack %02x %x\n", cdr.Irq, cdr.Stat);
1159                 CDREAD_INT(0x1000);
1160                 return;
1161         }
1162
1163         cdr.OCUP = 1;
1164         SetResultSize(1);
1165         cdr.StatP |= STATUS_READ|STATUS_ROTATING;
1166         cdr.StatP &= ~STATUS_SEEK;
1167         cdr.Result[0] = cdr.StatP;
1168         cdr.Seeked = SEEK_DONE;
1169
1170         ReadTrack(cdr.SetSectorPlay);
1171
1172         buf = CDR_getBuffer();
1173         if (buf == NULL)
1174                 cdr.NoErr = 0;
1175
1176         if (cdr.NoErr == 0) {
1177                 CDR_LOG_I("cdrReadInterrupt() Log: err\n");
1178                 memset(cdr.Transfer, 0, DATA_SIZE);
1179                 cdr.Stat = DiskError;
1180                 cdr.Result[0] |= STATUS_ERROR;
1181                 CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime);
1182                 return;
1183         }
1184
1185         memcpy(cdr.Transfer, buf, DATA_SIZE);
1186         CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]);
1187
1188
1189         CDR_LOG("cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]);
1190
1191         if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA
1192                 // Firemen 2: Multi-XA files - briefings, cutscenes
1193                 if( cdr.FirstSector == 1 && (cdr.Mode & MODE_SF)==0 ) {
1194                         cdr.File = cdr.Transfer[4 + 0];
1195                         cdr.Channel = cdr.Transfer[4 + 1];
1196                 }
1197
1198                 /* Gameblabla
1199                  * Skips playing on channel 255.
1200                  * Fixes missing audio in Blue's Clues : Blue's Big Musical. (Should also fix Taxi 2)
1201                  * TODO : Check if this is the proper behaviour.
1202                  * */
1203                 if((cdr.Transfer[4 + 2] & 0x4) &&
1204                          (cdr.Transfer[4 + 1] == cdr.Channel) &&
1205                          (cdr.Transfer[4 + 0] == cdr.File) && cdr.Channel != 255) {
1206                         int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector);
1207                         if (!ret) {
1208                                 cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo);
1209                                 /*
1210                                  * Gameblabla -
1211                                  * This is a hack for Megaman X4, Castlevania etc...
1212                                  * that regressed from the new m_locationChanged and CDROM timings changes.
1213                                  * It is mostly noticeable in Castevania however and the stuttering can be very jarring.
1214                                  *
1215                                  * According to PCSX redux authors, we shouldn't cause a location change if
1216                                  * the sector difference is too small.
1217                                  * I attempted to go with that approach but came empty handed.
1218                                  * So for now, let's just set cdr.m_locationChanged to false when playing back any ADPCM samples.
1219                                  * This does not regress Crash Team Racing's intro at least.
1220                                 */
1221                                 cdr.m_locationChanged = FALSE;
1222                                 SPU_playADPCMchannel(&cdr.Xa);
1223                                 cdr.FirstSector = 0;
1224                         }
1225                         else cdr.FirstSector = -1;
1226                 }
1227         }
1228
1229         cdr.SetSectorPlay[2]++;
1230         if (cdr.SetSectorPlay[2] == 75) {
1231                 cdr.SetSectorPlay[2] = 0;
1232                 cdr.SetSectorPlay[1]++;
1233                 if (cdr.SetSectorPlay[1] == 60) {
1234                         cdr.SetSectorPlay[1] = 0;
1235                         cdr.SetSectorPlay[0]++;
1236                 }
1237         }
1238
1239         cdr.Readed = 0;
1240
1241         uint32_t delay = (cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime;
1242         if (cdr.m_locationChanged) {
1243                 CDREAD_INT(delay * 30);
1244                 cdr.m_locationChanged = FALSE;
1245         } else {
1246                 CDREAD_INT(delay);
1247         }
1248
1249         /*
1250         Croc 2: $40 - only FORM1 (*)
1251         Judge Dredd: $C8 - only FORM1 (*)
1252         Sim Theme Park - no adpcm at all (zero)
1253         */
1254
1255         if (!(cdr.Mode & MODE_STRSND) || !(cdr.Transfer[4+2] & 0x4)) {
1256                 cdr.Stat = DataReady;
1257                 setIrq();
1258         }
1259
1260         // update for CdlGetlocP
1261         ReadTrack(cdr.SetSectorPlay);
1262 }
1263
1264 /*
1265 cdrRead0:
1266         bit 0,1 - mode
1267         bit 2 - unknown
1268         bit 3 - unknown
1269         bit 4 - unknown
1270         bit 5 - 1 result ready
1271         bit 6 - 1 dma ready
1272         bit 7 - 1 command being processed
1273 */
1274
1275 unsigned char cdrRead0(void) {
1276         if (cdr.ResultReady)
1277                 cdr.Ctrl |= 0x20;
1278         else
1279                 cdr.Ctrl &= ~0x20;
1280
1281         if (cdr.OCUP)
1282                 cdr.Ctrl |= 0x40;
1283 //  else
1284 //              cdr.Ctrl &= ~0x40;
1285
1286         // What means the 0x10 and the 0x08 bits? I only saw it used by the bios
1287         cdr.Ctrl |= 0x18;
1288
1289         CDR_LOG_IO("cdr r0: %02x\n", cdr.Ctrl);
1290
1291         return psxHu8(0x1800) = cdr.Ctrl;
1292 }
1293
1294 void cdrWrite0(unsigned char rt) {
1295         CDR_LOG_IO("cdr w0: %02x\n", rt);
1296
1297         cdr.Ctrl = (rt & 3) | (cdr.Ctrl & ~3);
1298 }
1299
1300 unsigned char cdrRead1(void) {
1301         if ((cdr.ResultP & 0xf) < cdr.ResultC)
1302                 psxHu8(0x1801) = cdr.Result[cdr.ResultP & 0xf];
1303         else
1304                 psxHu8(0x1801) = 0;
1305         cdr.ResultP++;
1306         if (cdr.ResultP == cdr.ResultC)
1307                 cdr.ResultReady = 0;
1308
1309         CDR_LOG_IO("cdr r1: %02x\n", psxHu8(0x1801));
1310
1311         return psxHu8(0x1801);
1312 }
1313
1314 void cdrWrite1(unsigned char rt) {
1315         CDR_LOG_IO("cdr w1: %02x\n", rt);
1316
1317         switch (cdr.Ctrl & 3) {
1318         case 0:
1319                 break;
1320         case 3:
1321                 cdr.AttenuatorRightToRightT = rt;
1322                 return;
1323         default:
1324                 return;
1325         }
1326
1327         cdr.Cmd = rt;
1328         cdr.OCUP = 0;
1329
1330 #ifdef CDR_LOG_CMD_IRQ
1331         SysPrintf("CD1 write: %x (%s)", rt, CmdName[rt]);
1332         if (cdr.ParamC) {
1333                 SysPrintf(" Param[%d] = {", cdr.ParamC);
1334                 for (i = 0; i < cdr.ParamC; i++)
1335                         SysPrintf(" %x,", cdr.Param[i]);
1336                 SysPrintf("}\n");
1337         } else {
1338                 SysPrintf("\n");
1339         }
1340 #endif
1341
1342         cdr.ResultReady = 0;
1343         cdr.Ctrl |= 0x80;
1344         // cdr.Stat = NoIntr;
1345         AddIrqQueue(cdr.Cmd, 0x800);
1346
1347         switch (cdr.Cmd) {
1348         case CdlReadN:
1349         case CdlReadS:
1350         case CdlPause:
1351                 StopCdda();
1352                 StopReading();
1353                 break;
1354
1355         case CdlInit:
1356         case CdlReset:
1357                 cdr.Seeked = SEEK_DONE;
1358                 StopCdda();
1359                 StopReading();
1360                 break;
1361
1362         case CdlSetmode:
1363                 CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]);
1364
1365                 cdr.Mode = cdr.Param[0];
1366
1367                 // Squaresoft on PlayStation 1998 Collector's CD Vol. 1
1368                 // - fixes choppy movie sound
1369                 if( cdr.Play && (cdr.Mode & MODE_CDDA) == 0 )
1370                         StopCdda();
1371                 break;
1372         }
1373 }
1374
1375 unsigned char cdrRead2(void) {
1376         unsigned char ret;
1377
1378         if (cdr.Readed == 0) {
1379                 ret = 0;
1380         } else {
1381                 ret = *pTransfer++;
1382         }
1383
1384         CDR_LOG_IO("cdr r2: %02x\n", ret);
1385         return ret;
1386 }
1387
1388 void cdrWrite2(unsigned char rt) {
1389         CDR_LOG_IO("cdr w2: %02x\n", rt);
1390
1391         switch (cdr.Ctrl & 3) {
1392         case 0:
1393                 if (cdr.ParamC < 8) // FIXME: size and wrapping
1394                         cdr.Param[cdr.ParamC++] = rt;
1395                 return;
1396         case 1:
1397                 cdr.Reg2 = rt;
1398                 setIrq();
1399                 return;
1400         case 2:
1401                 cdr.AttenuatorLeftToLeftT = rt;
1402                 return;
1403         case 3:
1404                 cdr.AttenuatorRightToLeftT = rt;
1405                 return;
1406         }
1407 }
1408
1409 unsigned char cdrRead3(void) {
1410         if (cdr.Ctrl & 0x1)
1411                 psxHu8(0x1803) = cdr.Stat | 0xE0;
1412         else
1413                 psxHu8(0x1803) = cdr.Reg2 | 0xE0;
1414
1415         CDR_LOG_IO("cdr r3: %02x\n", psxHu8(0x1803));
1416         return psxHu8(0x1803);
1417 }
1418
1419 void cdrWrite3(unsigned char rt) {
1420         CDR_LOG_IO("cdr w3: %02x\n", rt);
1421
1422         switch (cdr.Ctrl & 3) {
1423         case 0:
1424                 break; // transfer
1425         case 1:
1426                 cdr.Stat &= ~rt;
1427
1428                 if (rt & 0x40)
1429                         cdr.ParamC = 0;
1430                 return;
1431         case 2:
1432                 cdr.AttenuatorLeftToRightT = rt;
1433                 return;
1434         case 3:
1435                 if (rt & 0x20) {
1436                         memcpy(&cdr.AttenuatorLeftToLeft, &cdr.AttenuatorLeftToLeftT, 4);
1437                         CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n",
1438                                 cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
1439                                 cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight);
1440                 }
1441                 return;
1442         }
1443
1444         if ((rt & 0x80) && cdr.Readed == 0) {
1445                 cdr.Readed = 1;
1446                 pTransfer = cdr.Transfer;
1447
1448                 switch (cdr.Mode & 0x30) {
1449                         case MODE_SIZE_2328:
1450                         case 0x00:
1451                                 pTransfer += 12;
1452                                 break;
1453
1454                         case MODE_SIZE_2340:
1455                                 pTransfer += 0;
1456                                 break;
1457
1458                         default:
1459                                 break;
1460                 }
1461         }
1462 }
1463
1464 void psxDma3(u32 madr, u32 bcr, u32 chcr) {
1465         u32 cdsize;
1466         int size;
1467         u8 *ptr;
1468
1469         CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr);
1470
1471         switch (chcr) {
1472                 case 0x11000000:
1473                 case 0x11400100:
1474                         if (cdr.Readed == 0) {
1475                                 CDR_LOG("psxDma3() Log: *** DMA 3 *** NOT READY\n");
1476                                 break;
1477                         }
1478
1479                         cdsize = (bcr & 0xffff) * 4;
1480
1481                         // Ape Escape: bcr = 0001 / 0000
1482                         // - fix boot
1483                         if( cdsize == 0 )
1484                         {
1485                                 switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {
1486                                         case MODE_SIZE_2340: cdsize = 2340; break;
1487                                         case MODE_SIZE_2328: cdsize = 2328; break;
1488                                         default:
1489                                         case MODE_SIZE_2048: cdsize = 2048; break;
1490                                 }
1491                         }
1492
1493
1494                         ptr = (u8 *)PSXM(madr);
1495                         if (ptr == INVALID_PTR) {
1496                                 CDR_LOG("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n");
1497                                 break;
1498                         }
1499
1500                         /*
1501                         GS CDX: Enhancement CD crash
1502                         - Setloc 0:0:0
1503                         - CdlPlay
1504                         - Spams DMA3 and gets buffer overrun
1505                         */
1506                         size = CD_FRAMESIZE_RAW - (pTransfer - cdr.Transfer);
1507                         if (size > cdsize)
1508                                 size = cdsize;
1509                         if (size > 0)
1510                         {
1511                                 memcpy(ptr, pTransfer, size);
1512                         }
1513
1514                         psxCpu->Clear(madr, cdsize / 4);
1515                         pTransfer += cdsize;
1516
1517                         if( chcr == 0x11400100 ) {
1518                                 HW_DMA3_MADR = SWAPu32(madr + cdsize);
1519                                 CDRDMA_INT( (cdsize/4) / 4 );
1520                         }
1521                         else if( chcr == 0x11000000 ) {
1522                                 // CDRDMA_INT( (cdsize/4) * 1 );
1523                                 // halted
1524                                 psxRegs.cycle += (cdsize/4) * 24/2;
1525                                 CDRDMA_INT(16);
1526                         }
1527                         return;
1528
1529                 default:
1530                         CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr);
1531                         break;
1532         }
1533
1534         HW_DMA3_CHCR &= SWAP32(~0x01000000);
1535         DMA_INTERRUPT(3);
1536 }
1537
1538 void cdrDmaInterrupt()
1539 {
1540         if (HW_DMA3_CHCR & SWAP32(0x01000000))
1541         {
1542                 HW_DMA3_CHCR &= SWAP32(~0x01000000);
1543                 DMA_INTERRUPT(3);
1544         }
1545 }
1546
1547 static void getCdInfo(void)
1548 {
1549         u8 tmp;
1550
1551         CDR_getTN(cdr.ResultTN);
1552         CDR_getTD(0, cdr.SetSectorEnd);
1553         tmp = cdr.SetSectorEnd[0];
1554         cdr.SetSectorEnd[0] = cdr.SetSectorEnd[2];
1555         cdr.SetSectorEnd[2] = tmp;
1556 }
1557
1558 void cdrReset() {
1559         memset(&cdr, 0, sizeof(cdr));
1560         cdr.CurTrack = 1;
1561         cdr.File = 1;
1562         cdr.Channel = 1;
1563         cdr.Reg2 = 0x1f;
1564         cdr.Stat = NoIntr;
1565         cdr.DriveState = DRIVESTATE_STANDBY;
1566         cdr.StatP = STATUS_ROTATING;
1567         pTransfer = cdr.Transfer;
1568         cdr.SetlocPending = 0;
1569         cdr.m_locationChanged = FALSE;
1570
1571         // BIOS player - default values
1572         cdr.AttenuatorLeftToLeft = 0x80;
1573         cdr.AttenuatorLeftToRight = 0x00;
1574         cdr.AttenuatorRightToLeft = 0x00;
1575         cdr.AttenuatorRightToRight = 0x80;
1576
1577         getCdInfo();
1578 }
1579
1580 int cdrFreeze(void *f, int Mode) {
1581         u32 tmp;
1582         u8 tmpp[3];
1583
1584         if (Mode == 0 && !Config.Cdda)
1585                 CDR_stop();
1586
1587         cdr.freeze_ver = 0x63647202;
1588         gzfreeze(&cdr, sizeof(cdr));
1589
1590         if (Mode == 1) {
1591                 cdr.ParamP = cdr.ParamC;
1592                 tmp = pTransfer - cdr.Transfer;
1593         }
1594
1595         gzfreeze(&tmp, sizeof(tmp));
1596
1597         if (Mode == 0) {
1598                 getCdInfo();
1599
1600                 pTransfer = cdr.Transfer + tmp;
1601
1602                 // read right sub data
1603                 tmpp[0] = btoi(cdr.Prev[0]);
1604                 tmpp[1] = btoi(cdr.Prev[1]);
1605                 tmpp[2] = btoi(cdr.Prev[2]);
1606                 cdr.Prev[0]++;
1607                 ReadTrack(tmpp);
1608
1609                 if (cdr.Play) {
1610                         if (cdr.freeze_ver < 0x63647202)
1611                                 memcpy(cdr.SetSectorPlay, cdr.SetSector, 3);
1612
1613                         Find_CurTrack(cdr.SetSectorPlay);
1614                         if (!Config.Cdda)
1615                                 CDR_play();
1616                 }
1617
1618                 if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {
1619                         // old versions did not latch Reg2, have to fixup..
1620                         if (cdr.Reg2 == 0) {
1621                                 SysPrintf("cdrom: fixing up old savestate\n");
1622                                 cdr.Reg2 = 7;
1623                         }
1624                         // also did not save Attenuator..
1625                         if ((cdr.AttenuatorLeftToLeft | cdr.AttenuatorLeftToRight
1626                              | cdr.AttenuatorRightToLeft | cdr.AttenuatorRightToRight) == 0)
1627                         {
1628                                 cdr.AttenuatorLeftToLeft = cdr.AttenuatorRightToRight = 0x80;
1629                         }
1630                 }
1631         }
1632
1633         return 0;
1634 }
1635
1636 void LidInterrupt() {
1637         getCdInfo();
1638         StopCdda();
1639         cdrLidSeekInterrupt();
1640 }