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_readCDDA(cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2], (u8 *)read_buf);
 455                 cdr.Result[0] = cdr.StatP;
 456                 cdr.Result[1] = cdr.subq.Track;
 457                 cdr.Result[2] = cdr.subq.Index;
 458
 459                 abs_lev_chselect = cdr.subq.Absolute[1] & 0x01;
 460
 461                 /* 8 is a hack. For accuracy, it should be 588. */
 462                 for (i = 0; i < 8; i++)
 463                 {
 464                         abs_lev_max = MAX_VALUE(abs_lev_max, abs(read_buf[i * 2 + abs_lev_chselect]));
 465                 }
 466                 abs_lev_max = MIN_VALUE(abs_lev_max, 32767);
 467                 abs_lev_max |= abs_lev_chselect << 15;
 468
 469                 if (cdr.subq.Absolute[2] & 0x10) {
 470                         cdr.Result[3] = cdr.subq.Relative[0];
 471                         cdr.Result[4] = cdr.subq.Relative[1] | 0x80;
 472                         cdr.Result[5] = cdr.subq.Relative[2];
 473                 }
 474                 else {
 475                         cdr.Result[3] = cdr.subq.Absolute[0];
 476                         cdr.Result[4] = cdr.subq.Absolute[1];
 477                         cdr.Result[5] = cdr.subq.Absolute[2];
 478                 }
 479
 480                 cdr.Result[6] = abs_lev_max >> 0;
 481                 cdr.Result[7] = abs_lev_max >> 8;
 482
 483                 // Rayman: Logo freeze (resultready + dataready)
 484                 cdr.ResultReady = 1;
 485                 cdr.Stat = DataReady;
 486
 487                 SetResultSize(8);
 488                 setIrq();
 489         }
 490 }
 491
 492 // also handles seek
 493 void cdrPlayInterrupt()
 494 {
 495         if (cdr.Seeked == SEEK_PENDING) {
 496                 if (cdr.Stat) {
 497                         CDR_LOG_I("cdrom: seek stat hack\n");
 498                         CDRMISC_INT(0x1000);
 499                         return;
 500                 }
 501                 SetResultSize(1);
 502                 cdr.StatP |= STATUS_ROTATING;
 503                 cdr.StatP &= ~STATUS_SEEK;
 504                 cdr.Result[0] = cdr.StatP;
 505                 cdr.Seeked = SEEK_DONE;
 506                 if (cdr.Irq == 0) {
 507                         cdr.Stat = Complete;
 508                         setIrq();
 509                 }
 510
 511                 if (cdr.SetlocPending) {
 512                         memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
 513                         cdr.SetlocPending = 0;
 514                         cdr.m_locationChanged = TRUE;
 515                 }
 516                 Find_CurTrack(cdr.SetSectorPlay);
 517                 ReadTrack(cdr.SetSectorPlay);
 518                 cdr.TrackChanged = FALSE;
 519         }
 520
 521         if (!cdr.Play) return;
 522
 523         CDR_LOG( "CDDA - %d:%d:%d\n",
 524                 cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] );
 525
 526         if (memcmp(cdr.SetSectorPlay, cdr.SetSectorEnd, 3) == 0) {
 527                 StopCdda();
 528                 cdr.TrackChanged = TRUE;
 529         }
 530
 531         if (!cdr.Irq && !cdr.Stat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT)))
 532                 cdrPlayInterrupt_Autopause();
 533
 534         if (!cdr.Play) return;
 535
 536         if (CDR_readCDDA && !cdr.Muted && cdr.Mode & MODE_REPORT) {
 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
 574         // Reschedule IRQ
 575         if (cdr.Stat) {
 576                 CDR_LOG_I("cdrom: stat hack: %02x %x\n", cdr.Irq, cdr.Stat);
 577                 CDR_INT(0x1000);
 578                 return;
 579         }
 580
 581         cdr.Ctrl &= ~0x80;
 582
 583         // default response
 584         SetResultSize(1);
 585         cdr.Result[0] = cdr.StatP;
 586         cdr.Stat = Acknowledge;
 587
 588         if (cdr.IrqRepeated) {
 589                 cdr.IrqRepeated = 0;
 590                 if (cdr.eCycle > psxRegs.cycle) {
 591                         CDR_INT(cdr.eCycle);
 592                         goto finish;
 593                 }
 594         }
 595
 596         cdr.Irq = 0;
 597
 598         switch (Irq) {
 599                 case CdlNop:
 600                         if (cdr.DriveState != DRIVESTATE_LID_OPEN)
 601                                 cdr.StatP &= ~STATUS_SHELLOPEN;
 602                         no_busy_error = 1;
 603                         break;
 604
 605                 case CdlSetloc:
 606                         break;
 607
 608                 do_CdlPlay:
 609                 case CdlPlay:
 610                         StopCdda();
 611                         if (cdr.Seeked == SEEK_PENDING) {
 612                                 // XXX: wrong, should seek instead..
 613                                 cdr.Seeked = SEEK_DONE;
 614                         }
 615
 616                         cdr.FastBackward = 0;
 617                         cdr.FastForward = 0;
 618
 619                         if (cdr.SetlocPending) {
 620                                 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
 621                                 cdr.SetlocPending = 0;
 622                                 cdr.m_locationChanged = TRUE;
 623                         }
 624
 625                         // BIOS CD Player
 626                         // - Pause player, hit Track 01/02/../xx (Setloc issued!!)
 627
 628                         if (cdr.ParamC == 0 || cdr.Param[0] == 0) {
 629                                 CDR_LOG("PLAY Resume @ %d:%d:%d\n",
 630                                         cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]);
 631                         }
 632                         else
 633                         {
 634                                 int track = btoi( cdr.Param[0] );
 635
 636                                 if (track <= cdr.ResultTN[1])
 637                                         cdr.CurTrack = track;
 638
 639                                 CDR_LOG("PLAY track %d\n", cdr.CurTrack);
 640
 641                                 if (CDR_getTD((u8)cdr.CurTrack, cdr.ResultTD) != -1) {
 642                                         cdr.SetSectorPlay[0] = cdr.ResultTD[2];
 643                                         cdr.SetSectorPlay[1] = cdr.ResultTD[1];
 644                                         cdr.SetSectorPlay[2] = cdr.ResultTD[0];
 645                                 }
 646                         }
 647
 648                         /*
 649                         Rayman: detect track changes
 650                         - fixes logo freeze
 651
 652                         Twisted Metal 2: skip PREGAP + starting accurate SubQ
 653                         - plays tracks without retry play
 654
 655                         Wild 9: skip PREGAP + starting accurate SubQ
 656                         - plays tracks without retry play
 657                         */
 658                         Find_CurTrack(cdr.SetSectorPlay);
 659                         ReadTrack(cdr.SetSectorPlay);
 660                         cdr.TrackChanged = FALSE;
 661
 662                         if (!Config.Cdda)
 663                                 CDR_play();
 664
 665                         // Vib Ribbon: gameplay checks flag
 666                         cdr.StatP &= ~STATUS_SEEK;
 667                         cdr.Result[0] = cdr.StatP;
 668
 669                         cdr.StatP |= STATUS_PLAY;
 670
 671                         // BIOS player - set flag again
 672                         cdr.Play = TRUE;
 673
 674                         CDRMISC_INT( cdReadTime );
 675                         start_rotating = 1;
 676                         break;
 677
 678                 case CdlForward:
 679                         // TODO: error 80 if stopped
 680                         cdr.Stat = Complete;
 681                         // GameShark CD Player: Calls 2x + Play 2x
 682                         cdr.FastForward = 1;
 683                         cdr.FastBackward = 0;
 684                         break;
 685
 686                 case CdlBackward:
 687                         cdr.Stat = Complete;
 688
 689                         // GameShark CD Player: Calls 2x + Play 2x
 690                         cdr.FastBackward =1;
 691                         cdr.FastForward = 0;
 692                         break;
 693
 694                 case CdlStandby:
 695                         if (cdr.DriveState != DRIVESTATE_STOPPED) {
 696                                 error = ERROR_INVALIDARG;
 697                                 goto set_error;
 698                         }
 699                         AddIrqQueue(CdlStandby + 0x100, cdReadTime * 125 / 2);
 700                         start_rotating = 1;
 701                         break;
 702
 703                 case CdlStandby + 0x100:
 704                         cdr.Stat = Complete;
 705                         break;
 706
 707                 case CdlStop:
 708                         if (cdr.Play) {
 709                                 // grab time for current track
 710                                 CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD);
 711
 712                                 cdr.SetSectorPlay[0] = cdr.ResultTD[2];
 713                                 cdr.SetSectorPlay[1] = cdr.ResultTD[1];
 714                                 cdr.SetSectorPlay[2] = cdr.ResultTD[0];
 715                         }
 716
 717                         StopCdda();
 718                         StopReading();
 719
 720                         delay = 0x800;
 721                         if (cdr.DriveState == DRIVESTATE_STANDBY)
 722                                 delay = cdReadTime * 30 / 2;
 723
 724                         cdr.DriveState = DRIVESTATE_STOPPED;
 725                         AddIrqQueue(CdlStop + 0x100, delay);
 726                         break;
 727
 728                 case CdlStop + 0x100:
 729                         cdr.StatP &= ~STATUS_ROTATING;
 730                         cdr.Result[0] = cdr.StatP;
 731                         cdr.Stat = Complete;
 732                         break;
 733
 734                 case CdlPause:
 735                         /*
 736                         Gundam Battle Assault 2: much slower (*)
 737                         - Fixes boot, gameplay
 738                         Hokuto no Ken 2: slower
 739                         - Fixes intro + subtitles
 740                         InuYasha - Feudal Fairy Tale: slower
 741                         - Fixes battles
 742                         */
 743                         /* Gameblabla - Tightening the timings (as taken from Duckstation).
 744                          * The timings from Duckstation are based upon hardware tests.
 745                          * Mednafen's timing don't work for Gundam Battle Assault 2 in PAL/50hz mode,
 746                          * seems to be timing sensitive as it can depend on the CPU's clock speed.
 747                          *
 748                          * We will need to get around this for Bedlam/Rise 2 later...
 749                          * */
 750                         if (cdr.DriveState != DRIVESTATE_STANDBY)
 751                         {
 752                                 delay = 7000;
 753                         }
 754                         else
 755                         {
 756                                 delay = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * (1000000));
 757                                 CDRMISC_INT((cdr.Mode & MODE_SPEED) ? cdReadTime / 2 : cdReadTime);
 758                         }
 759                         AddIrqQueue(CdlPause + 0x100, delay);
 760                         cdr.Ctrl |= 0x80;
 761                         break;
 762
 763                 case CdlPause + 0x100:
 764                         cdr.StatP &= ~STATUS_READ;
 765                         cdr.Result[0] = cdr.StatP;
 766                         cdr.Stat = Complete;
 767                         break;
 768
 769                 case CdlReset:
 770                         cdr.Muted = FALSE;
 771                         cdr.Mode = 0x20; /* Needed for This is Football 2, Pooh's Party and possibly others. */
 772                         AddIrqQueue(CdlReset + 0x100, 4100000);
 773                         no_busy_error = 1;
 774                         start_rotating = 1;
 775                         break;
 776
 777                 case CdlReset + 0x100:
 778                         cdr.Stat = Complete;
 779                         break;
 780
 781                 case CdlMute:
 782                         cdr.Muted = TRUE;
 783                         break;
 784
 785                 case CdlDemute:
 786                         cdr.Muted = FALSE;
 787                         break;
 788
 789                 case CdlSetfilter:
 790                         cdr.File = cdr.Param[0];
 791                         cdr.Channel = cdr.Param[1];
 792                         break;
 793
 794                 case CdlSetmode:
 795                         no_busy_error = 1;
 796                         break;
 797
 798                 case CdlGetparam:
 799                         SetResultSize(5);
 800                         cdr.Result[1] = cdr.Mode;
 801                         cdr.Result[2] = 0;
 802                         cdr.Result[3] = cdr.File;
 803                         cdr.Result[4] = cdr.Channel;
 804                         no_busy_error = 1;
 805                         break;
 806
 807                 case CdlGetlocL:
 808                         SetResultSize(8);
 809                         memcpy(cdr.Result, cdr.Transfer, 8);
 810                         break;
 811
 812                 case CdlGetlocP:
 813                         SetResultSize(8);
 814                         memcpy(&cdr.Result, &cdr.subq, 8);
 815                         break;
 816
 817                 case CdlReadT: // SetSession?
 818                         // really long
 819                         AddIrqQueue(CdlReadT + 0x100, cdReadTime * 290 / 4);
 820                         start_rotating = 1;
 821                         break;
 822
 823                 case CdlReadT + 0x100:
 824                         cdr.Stat = Complete;
 825                         break;
 826
 827                 case CdlGetTN:
 828                         SetResultSize(3);
 829                         if (CDR_getTN(cdr.ResultTN) == -1) {
 830                                 cdr.Stat = DiskError;
 831                                 cdr.Result[0] |= STATUS_ERROR;
 832                         } else {
 833                                 cdr.Stat = Acknowledge;
 834                                 cdr.Result[1] = itob(cdr.ResultTN[0]);
 835                                 cdr.Result[2] = itob(cdr.ResultTN[1]);
 836                         }
 837                         break;
 838
 839                 case CdlGetTD:
 840                         cdr.Track = btoi(cdr.Param[0]);
 841                         SetResultSize(4);
 842                         if (CDR_getTD(cdr.Track, cdr.ResultTD) == -1) {
 843                                 cdr.Stat = DiskError;
 844                                 cdr.Result[0] |= STATUS_ERROR;
 845                         } else {
 846                                 cdr.Stat = Acknowledge;
 847                                 cdr.Result[0] = cdr.StatP;
 848                                 cdr.Result[1] = itob(cdr.ResultTD[2]);
 849                                 cdr.Result[2] = itob(cdr.ResultTD[1]);
 850                                 /* According to Nocash's documentation, the function doesn't care about ff.
 851                                  * This can be seen also in Mednafen's implementation. */
 852                                 //cdr.Result[3] = itob(cdr.ResultTD[0]);
 853                         }
 854                         break;
 855
 856                 case CdlSeekL:
 857                 case CdlSeekP:
 858                         StopCdda();
 859                         StopReading();
 860                         cdr.StatP |= STATUS_SEEK;
 861
 862                         /*
 863                         Crusaders of Might and Magic = 0.5x-4x
 864                         - fix cutscene speech start
 865
 866                         Eggs of Steel = 2x-?
 867                         - fix new game
 868
 869                         Medievil = ?-4x
 870                         - fix cutscene speech
 871
 872                         Rockman X5 = 0.5-4x
 873                         - fix capcom logo
 874                         */
 875                         CDRMISC_INT(cdr.Seeked == SEEK_DONE ? 0x800 : cdReadTime * 4);
 876                         cdr.Seeked = SEEK_PENDING;
 877                         start_rotating = 1;
 878                         break;
 879
 880                 case CdlTest:
 881                         switch (cdr.Param[0]) {
 882                                 case 0x20: // System Controller ROM Version
 883                                         SetResultSize(4);
 884                                         memcpy(cdr.Result, Test20, 4);
 885                                         break;
 886                                 case 0x22:
 887                                         SetResultSize(8);
 888                                         memcpy(cdr.Result, Test22, 4);
 889                                         break;
 890                                 case 0x23: case 0x24:
 891                                         SetResultSize(8);
 892                                         memcpy(cdr.Result, Test23, 4);
 893                                         break;
 894                         }
 895                         no_busy_error = 1;
 896                         break;
 897
 898                 case CdlID:
 899                         AddIrqQueue(CdlID + 0x100, 20480);
 900                         break;
 901
 902                 case CdlID + 0x100:
 903                         SetResultSize(8);
 904                         cdr.Result[0] = cdr.StatP;
 905                         cdr.Result[1] = 0;
 906                         cdr.Result[2] = 0;
 907                         cdr.Result[3] = 0;
 908
 909                         // 0x10 - audio | 0x40 - disk missing | 0x80 - unlicensed
 910                         if (CDR_getStatus(&stat) == -1 || stat.Type == 0 || stat.Type == 0xff) {
 911                                 cdr.Result[1] = 0xc0;
 912                         }
 913                         else {
 914                                 if (stat.Type == 2)
 915                                         cdr.Result[1] |= 0x10;
 916                                 if (CdromId[0] == '\0')
 917                                         cdr.Result[1] |= 0x80;
 918                         }
 919                         cdr.Result[0] |= (cdr.Result[1] >> 4) & 0x08;
 920
 921                         /* This adds the string "PCSX" in Playstation bios boot screen */
 922                         memcpy((char *)&cdr.Result[4], "PCSX", 4);
 923                         cdr.Stat = Complete;
 924                         break;
 925
 926                 case CdlInit:
 927                         // yes, it really sets STATUS_SHELLOPEN
 928                         cdr.StatP |= STATUS_SHELLOPEN;
 929                         cdr.DriveState = DRIVESTATE_RESCAN_CD;
 930                         CDRLID_INT(20480);
 931                         no_busy_error = 1;
 932                         start_rotating = 1;
 933                         break;
 934
 935                 case CdlGetQ:
 936                         no_busy_error = 1;
 937                         break;
 938
 939                 case CdlReadToc:
 940                         AddIrqQueue(CdlReadToc + 0x100, cdReadTime * 180 / 4);
 941                         no_busy_error = 1;
 942                         start_rotating = 1;
 943                         break;
 944
 945                 case CdlReadToc + 0x100:
 946                         cdr.Stat = Complete;
 947                         no_busy_error = 1;
 948                         break;
 949
 950                 case CdlReadN:
 951                 case CdlReadS:
 952                         if (cdr.SetlocPending) {
 953                                 seekTime = abs(msf2sec(cdr.SetSectorPlay) - msf2sec(cdr.SetSector)) * (cdReadTime / 200);
 954                                 /*
 955                                 * Gameblabla :
 956                                 * It was originally set to 1000000 for Driver, however it is not high enough for Worms Pinball
 957                                 * and was unreliable for that game.
 958                                 * I also tested it against Mednafen and Driver's titlescreen music starts 25 frames later, not immediatly.
 959                                 *
 960                                 * Obviously, this isn't perfect but right now, it should be a bit better.
 961                                 * Games to test this against if you change that setting :
 962                                 * - Driver (titlescreen music delay and retry mission)
 963                                 * - Worms Pinball (Will either not boot or crash in the memory card screen)
 964                                 * - Viewpoint (short pauses if the delay in the ingame music is too long)
 965                                 *
 966                                 * It seems that 3386880 * 5 is too much for Driver's titlescreen and it starts skipping.
 967                                 * However, 1000000 is not enough for Worms Pinball to reliably boot.
 968                                 */
 969                                 if(seekTime > 3386880 * 2) seekTime = 3386880 * 2;
 970                                 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
 971                                 cdr.SetlocPending = 0;
 972                                 cdr.m_locationChanged = TRUE;
 973                         }
 974                         Find_CurTrack(cdr.SetSectorPlay);
 975
 976                         if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1)
 977                                 // Read* acts as play for cdda tracks in cdda mode
 978                                 goto do_CdlPlay;
 979
 980                         cdr.Reading = 1;
 981                         cdr.FirstSector = 1;
 982
 983                         // Fighting Force 2 - update subq time immediately
 984                         // - fixes new game
 985                         ReadTrack(cdr.SetSectorPlay);
 986
 987
 988                         // Crusaders of Might and Magic - update getlocl now
 989                         // - fixes cutscene speech
 990                         {
 991                                 u8 *buf = CDR_getBuffer();
 992                                 if (buf != NULL)
 993                                         memcpy(cdr.Transfer, buf, 8);
 994                         }
 995
 996                         /*
 997                         Duke Nukem: Land of the Babes - seek then delay read for one frame
 998                         - fixes cutscenes
 999                         C-12 - Final Resistance - doesn't like seek
1000                         */
1001
1002                         /*
1003                                 By nicolasnoble from PCSX Redux :
1004                                 "It LOOKS like this logic is wrong, therefore disabling it with `&& false` for now.
1005                                 For "PoPoLoCrois Monogatari II", the game logic will soft lock and will never issue GetLocP to detect
1006                                 the end of its XA streams, as it seems to assume ReadS will not return a status byte with the SEEK
1007                                 flag set. I think the reasonning is that since it's invalid to call GetLocP while seeking, the game
1008                                 tries to protect itself against errors by preventing from issuing a GetLocP while it knows the
1009                                 last status was "seek". But this makes the logic just softlock as it'll never get a notification
1010                                 about the fact the drive is done seeking and the read actually started.
1011                                 In other words, this state machine here is probably wrong in assuming the response to ReadS/ReadN is
1012                                 done right away. It's rather when it's done seeking, and the read has actually started. This probably
1013                                 requires a bit more work to make sure seek delays are processed properly.
1014                                 Checked with a few games, this seems to work fine."
1015
1016                                 Gameblabla additional notes :
1017                                 This still needs the "+ seekTime" that PCSX Redux doesn't have for the Driver "retry" mission error.
1018                         */
1019                         cdr.StatP |= STATUS_READ;
1020                         cdr.StatP &= ~STATUS_SEEK;
1021                         CDREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime);
1022
1023                         cdr.Result[0] = cdr.StatP;
1024                         start_rotating = 1;
1025                         break;
1026
1027                 case CdlSync:
1028                 default:
1029                         CDR_LOG_I("Invalid command: %02x\n", Irq);
1030                         error = ERROR_INVALIDCMD;
1031                         // FALLTHROUGH
1032
1033                 set_error:
1034                         SetResultSize(2);
1035                         cdr.Result[0] = cdr.StatP | STATUS_ERROR;
1036                         cdr.Result[1] = error;
1037                         cdr.Stat = DiskError;
1038                         break;
1039         }
1040
1041         if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) {
1042                 cdr.DriveState = DRIVESTATE_STANDBY;
1043                 cdr.StatP |= STATUS_ROTATING;
1044         }
1045
1046         if (!no_busy_error) {
1047                 switch (cdr.DriveState) {
1048                 case DRIVESTATE_LID_OPEN:
1049                 case DRIVESTATE_RESCAN_CD:
1050                 case DRIVESTATE_PREPARE_CD:
1051                         SetResultSize(2);
1052                         cdr.Result[0] = cdr.StatP | STATUS_ERROR;
1053                         cdr.Result[1] = ERROR_NOTREADY;
1054                         cdr.Stat = DiskError;
1055                         break;
1056                 }
1057         }
1058
1059 finish:
1060         setIrq();
1061         cdr.ParamC = 0;
1062
1063 #ifdef CDR_LOG_CMD_IRQ
1064         {
1065                 int i;
1066                 SysPrintf("CDR IRQ %d cmd %02x stat %02x: ",
1067                         !!(cdr.Stat & cdr.Reg2), Irq, cdr.Stat);
1068                 for (i = 0; i < cdr.ResultC; i++)
1069                         SysPrintf("%02x ", cdr.Result[i]);
1070                 SysPrintf("\n");
1071         }
1072 #endif
1073 }
1074
1075 #ifdef HAVE_ARMV7
1076  #define ssat32_to_16(v) \
1077   asm("ssat %0,#16,%1" : "=r" (v) : "r" (v))
1078 #else
1079  #define ssat32_to_16(v) do { \
1080   if (v < -32768) v = -32768; \
1081   else if (v > 32767) v = 32767; \
1082  } while (0)
1083 #endif
1084
1085 void cdrAttenuate(s16 *buf, int samples, int stereo)
1086 {
1087         int i, l, r;
1088         int ll = cdr.AttenuatorLeftToLeft;
1089         int lr = cdr.AttenuatorLeftToRight;
1090         int rl = cdr.AttenuatorRightToLeft;
1091         int rr = cdr.AttenuatorRightToRight;
1092
1093         if (lr == 0 && rl == 0 && 0x78 <= ll && ll <= 0x88 && 0x78 <= rr && rr <= 0x88)
1094                 return;
1095
1096         if (!stereo && ll == 0x40 && lr == 0x40 && rl == 0x40 && rr == 0x40)
1097                 return;
1098
1099         if (stereo) {
1100                 for (i = 0; i < samples; i++) {
1101                         l = buf[i * 2];
1102                         r = buf[i * 2 + 1];
1103                         l = (l * ll + r * rl) >> 7;
1104                         r = (r * rr + l * lr) >> 7;
1105                         ssat32_to_16(l);
1106                         ssat32_to_16(r);
1107                         buf[i * 2] = l;
1108                         buf[i * 2 + 1] = r;
1109                 }
1110         }
1111         else {
1112                 for (i = 0; i < samples; i++) {
1113                         l = buf[i];
1114                         l = l * (ll + rl) >> 7;
1115                         //r = r * (rr + lr) >> 7;
1116                         ssat32_to_16(l);
1117                         //ssat32_to_16(r);
1118                         buf[i] = l;
1119                 }
1120         }
1121 }
1122
1123 void cdrReadInterrupt() {
1124         u8 *buf;
1125
1126         if (!cdr.Reading)
1127                 return;
1128
1129         if (cdr.Irq || cdr.Stat) {
1130                 CDR_LOG_I("cdrom: read stat hack %02x %x\n", cdr.Irq, cdr.Stat);
1131                 CDREAD_INT(0x1000);
1132                 return;
1133         }
1134
1135         cdr.OCUP = 1;
1136         SetResultSize(1);
1137         cdr.StatP |= STATUS_READ|STATUS_ROTATING;
1138         cdr.StatP &= ~STATUS_SEEK;
1139         cdr.Result[0] = cdr.StatP;
1140         cdr.Seeked = SEEK_DONE;
1141
1142         ReadTrack(cdr.SetSectorPlay);
1143
1144         buf = CDR_getBuffer();
1145         if (buf == NULL)
1146                 cdr.NoErr = 0;
1147
1148         if (cdr.NoErr == 0) {
1149                 CDR_LOG_I("cdrReadInterrupt() Log: err\n");
1150                 memset(cdr.Transfer, 0, DATA_SIZE);
1151                 cdr.Stat = DiskError;
1152                 cdr.Result[0] |= STATUS_ERROR;
1153                 CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime);
1154                 return;
1155         }
1156
1157         memcpy(cdr.Transfer, buf, DATA_SIZE);
1158         CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]);
1159
1160
1161         CDR_LOG("cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]);
1162
1163         if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA
1164                 // Firemen 2: Multi-XA files - briefings, cutscenes
1165                 if( cdr.FirstSector == 1 && (cdr.Mode & MODE_SF)==0 ) {
1166                         cdr.File = cdr.Transfer[4 + 0];
1167                         cdr.Channel = cdr.Transfer[4 + 1];
1168                 }
1169
1170                 /* Gameblabla
1171                  * Skips playing on channel 255.
1172                  * Fixes missing audio in Blue's Clues : Blue's Big Musical. (Should also fix Taxi 2)
1173                  * TODO : Check if this is the proper behaviour.
1174                  * */
1175                 if((cdr.Transfer[4 + 2] & 0x4) &&
1176                          (cdr.Transfer[4 + 1] == cdr.Channel) &&
1177                          (cdr.Transfer[4 + 0] == cdr.File) && cdr.Channel != 255) {
1178                         int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector);
1179                         if (!ret) {
1180                                 cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo);
1181                                 /*
1182                                  * Gameblabla -
1183                                  * This is a hack for Megaman X4, Castlevania etc...
1184                                  * that regressed from the new m_locationChanged and CDROM timings changes.
1185                                  * It is mostly noticeable in Castevania however and the stuttering can be very jarring.
1186                                  *
1187                                  * According to PCSX redux authors, we shouldn't cause a location change if
1188                                  * the sector difference is too small.
1189                                  * I attempted to go with that approach but came empty handed.
1190                                  * So for now, let's just set cdr.m_locationChanged to false when playing back any ADPCM samples.
1191                                  * This does not regress Crash Team Racing's intro at least.
1192                                 */
1193                                 cdr.m_locationChanged = FALSE;
1194                                 SPU_playADPCMchannel(&cdr.Xa);
1195                                 cdr.FirstSector = 0;
1196                         }
1197                         else cdr.FirstSector = -1;
1198                 }
1199         }
1200
1201         cdr.SetSectorPlay[2]++;
1202         if (cdr.SetSectorPlay[2] == 75) {
1203                 cdr.SetSectorPlay[2] = 0;
1204                 cdr.SetSectorPlay[1]++;
1205                 if (cdr.SetSectorPlay[1] == 60) {
1206                         cdr.SetSectorPlay[1] = 0;
1207                         cdr.SetSectorPlay[0]++;
1208                 }
1209         }
1210
1211         cdr.Readed = 0;
1212
1213         uint32_t delay = (cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime;
1214         if (cdr.m_locationChanged) {
1215                 CDREAD_INT(delay * 30);
1216                 cdr.m_locationChanged = FALSE;
1217         } else {
1218                 CDREAD_INT(delay);
1219         }
1220
1221         /*
1222         Croc 2: $40 - only FORM1 (*)
1223         Judge Dredd: $C8 - only FORM1 (*)
1224         Sim Theme Park - no adpcm at all (zero)
1225         */
1226
1227         if (!(cdr.Mode & MODE_STRSND) || !(cdr.Transfer[4+2] & 0x4)) {
1228                 cdr.Stat = DataReady;
1229                 setIrq();
1230         }
1231
1232         // update for CdlGetlocP
1233         ReadTrack(cdr.SetSectorPlay);
1234 }
1235
1236 /*
1237 cdrRead0:
1238         bit 0,1 - mode
1239         bit 2 - unknown
1240         bit 3 - unknown
1241         bit 4 - unknown
1242         bit 5 - 1 result ready
1243         bit 6 - 1 dma ready
1244         bit 7 - 1 command being processed
1245 */
1246
1247 unsigned char cdrRead0(void) {
1248         if (cdr.ResultReady)
1249                 cdr.Ctrl |= 0x20;
1250         else
1251                 cdr.Ctrl &= ~0x20;
1252
1253         if (cdr.OCUP)
1254                 cdr.Ctrl |= 0x40;
1255 //  else
1256 //              cdr.Ctrl &= ~0x40;
1257
1258         // What means the 0x10 and the 0x08 bits? I only saw it used by the bios
1259         cdr.Ctrl |= 0x18;
1260
1261         CDR_LOG_IO("cdr r0: %02x\n", cdr.Ctrl);
1262
1263         return psxHu8(0x1800) = cdr.Ctrl;
1264 }
1265
1266 void cdrWrite0(unsigned char rt) {
1267         CDR_LOG_IO("cdr w0: %02x\n", rt);
1268
1269         cdr.Ctrl = (rt & 3) | (cdr.Ctrl & ~3);
1270 }
1271
1272 unsigned char cdrRead1(void) {
1273         if ((cdr.ResultP & 0xf) < cdr.ResultC)
1274                 psxHu8(0x1801) = cdr.Result[cdr.ResultP & 0xf];
1275         else
1276                 psxHu8(0x1801) = 0;
1277         cdr.ResultP++;
1278         if (cdr.ResultP == cdr.ResultC)
1279                 cdr.ResultReady = 0;
1280
1281         CDR_LOG_IO("cdr r1: %02x\n", psxHu8(0x1801));
1282
1283         return psxHu8(0x1801);
1284 }
1285
1286 void cdrWrite1(unsigned char rt) {
1287         u8 set_loc[3];
1288         int i;
1289
1290         CDR_LOG_IO("cdr w1: %02x\n", rt);
1291
1292         switch (cdr.Ctrl & 3) {
1293         case 0:
1294                 break;
1295         case 3:
1296                 cdr.AttenuatorRightToRightT = rt;
1297                 return;
1298         default:
1299                 return;
1300         }
1301
1302         cdr.Cmd = rt;
1303         cdr.OCUP = 0;
1304
1305 #ifdef CDR_LOG_CMD_IRQ
1306         SysPrintf("CD1 write: %x (%s)", rt, CmdName[rt]);
1307         if (cdr.ParamC) {
1308                 SysPrintf(" Param[%d] = {", cdr.ParamC);
1309                 for (i = 0; i < cdr.ParamC; i++)
1310                         SysPrintf(" %x,", cdr.Param[i]);
1311                 SysPrintf("}\n");
1312         } else {
1313                 SysPrintf("\n");
1314         }
1315 #endif
1316
1317         cdr.ResultReady = 0;
1318         cdr.Ctrl |= 0x80;
1319         // cdr.Stat = NoIntr;
1320         AddIrqQueue(cdr.Cmd, 0x800);
1321
1322         switch (cdr.Cmd) {
1323         case CdlSetloc:
1324                 CDR_LOG("CDROM setloc command (%02X, %02X, %02X)\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
1325
1326                 // MM must be BCD, SS must be BCD and <0x60, FF must be BCD and <0x75
1327                 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))
1328                 {
1329                         CDR_LOG("Invalid/out of range seek to %02X:%02X:%02X\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
1330                 }
1331                 else
1332                 {
1333                         for (i = 0; i < 3; i++)
1334                         {
1335                                 set_loc[i] = btoi(cdr.Param[i]);
1336                         }
1337
1338                         i = msf2sec(cdr.SetSectorPlay);
1339                         i = abs(i - msf2sec(set_loc));
1340                         if (i > 16)
1341                                 cdr.Seeked = SEEK_PENDING;
1342
1343                         memcpy(cdr.SetSector, set_loc, 3);
1344                         cdr.SetSector[3] = 0;
1345                         cdr.SetlocPending = 1;
1346                 }
1347                 break;
1348
1349         case CdlReadN:
1350         case CdlReadS:
1351         case CdlPause:
1352                 StopCdda();
1353                 StopReading();
1354                 break;
1355
1356         case CdlInit:
1357         case CdlReset:
1358                 cdr.Seeked = SEEK_DONE;
1359                 StopCdda();
1360                 StopReading();
1361                 break;
1362
1363         case CdlSetmode:
1364                 CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]);
1365
1366                 cdr.Mode = cdr.Param[0];
1367
1368                 // Squaresoft on PlayStation 1998 Collector's CD Vol. 1
1369                 // - fixes choppy movie sound
1370                 if( cdr.Play && (cdr.Mode & MODE_CDDA) == 0 )
1371                         StopCdda();
1372                 break;
1373         }
1374 }
1375
1376 unsigned char cdrRead2(void) {
1377         unsigned char ret;
1378
1379         if (cdr.Readed == 0) {
1380                 ret = 0;
1381         } else {
1382                 ret = *pTransfer++;
1383         }
1384
1385         CDR_LOG_IO("cdr r2: %02x\n", ret);
1386         return ret;
1387 }
1388
1389 void cdrWrite2(unsigned char rt) {
1390         CDR_LOG_IO("cdr w2: %02x\n", rt);
1391
1392         switch (cdr.Ctrl & 3) {
1393         case 0:
1394                 if (cdr.ParamC < 8) // FIXME: size and wrapping
1395                         cdr.Param[cdr.ParamC++] = rt;
1396                 return;
1397         case 1:
1398                 cdr.Reg2 = rt;
1399                 setIrq();
1400                 return;
1401         case 2:
1402                 cdr.AttenuatorLeftToLeftT = rt;
1403                 return;
1404         case 3:
1405                 cdr.AttenuatorRightToLeftT = rt;
1406                 return;
1407         }
1408 }
1409
1410 unsigned char cdrRead3(void) {
1411         if (cdr.Ctrl & 0x1)
1412                 psxHu8(0x1803) = cdr.Stat | 0xE0;
1413         else
1414                 psxHu8(0x1803) = cdr.Reg2 | 0xE0;
1415
1416         CDR_LOG_IO("cdr r3: %02x\n", psxHu8(0x1803));
1417         return psxHu8(0x1803);
1418 }
1419
1420 void cdrWrite3(unsigned char rt) {
1421         CDR_LOG_IO("cdr w3: %02x\n", rt);
1422
1423         switch (cdr.Ctrl & 3) {
1424         case 0:
1425                 break; // transfer
1426         case 1:
1427                 cdr.Stat &= ~rt;
1428
1429                 if (rt & 0x40)
1430                         cdr.ParamC = 0;
1431                 return;
1432         case 2:
1433                 cdr.AttenuatorLeftToRightT = rt;
1434                 return;
1435         case 3:
1436                 if (rt & 0x20) {
1437                         memcpy(&cdr.AttenuatorLeftToLeft, &cdr.AttenuatorLeftToLeftT, 4);
1438                         CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n",
1439                                 cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
1440                                 cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight);
1441                 }
1442                 return;
1443         }
1444
1445         if ((rt & 0x80) && cdr.Readed == 0) {
1446                 cdr.Readed = 1;
1447                 pTransfer = cdr.Transfer;
1448
1449                 switch (cdr.Mode & 0x30) {
1450                         case MODE_SIZE_2328:
1451                         case 0x00:
1452                                 pTransfer += 12;
1453                                 break;
1454
1455                         case MODE_SIZE_2340:
1456                                 pTransfer += 0;
1457                                 break;
1458
1459                         default:
1460                                 break;
1461                 }
1462         }
1463 }
1464
1465 void psxDma3(u32 madr, u32 bcr, u32 chcr) {
1466         u32 cdsize;
1467         int size;
1468         u8 *ptr;
1469
1470         CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr);
1471
1472         switch (chcr) {
1473                 case 0x11000000:
1474                 case 0x11400100:
1475                         if (cdr.Readed == 0) {
1476                                 CDR_LOG("psxDma3() Log: *** DMA 3 *** NOT READY\n");
1477                                 break;
1478                         }
1479
1480                         cdsize = (bcr & 0xffff) * 4;
1481
1482                         // Ape Escape: bcr = 0001 / 0000
1483                         // - fix boot
1484                         if( cdsize == 0 )
1485                         {
1486                                 switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {
1487                                         case MODE_SIZE_2340: cdsize = 2340; break;
1488                                         case MODE_SIZE_2328: cdsize = 2328; break;
1489                                         default:
1490                                         case MODE_SIZE_2048: cdsize = 2048; break;
1491                                 }
1492                         }
1493
1494
1495                         ptr = (u8 *)PSXM(madr);
1496                         if (ptr == NULL) {
1497                                 CDR_LOG("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n");
1498                                 break;
1499                         }
1500
1501                         /*
1502                         GS CDX: Enhancement CD crash
1503                         - Setloc 0:0:0
1504                         - CdlPlay
1505                         - Spams DMA3 and gets buffer overrun
1506                         */
1507                         size = CD_FRAMESIZE_RAW - (pTransfer - cdr.Transfer);
1508                         if (size > cdsize)
1509                                 size = cdsize;
1510                         if (size > 0)
1511                         {
1512                                 memcpy(ptr, pTransfer, size);
1513                         }
1514
1515                         psxCpu->Clear(madr, cdsize / 4);
1516                         pTransfer += cdsize;
1517
1518                         if( chcr == 0x11400100 ) {
1519                                 HW_DMA3_MADR = SWAPu32(madr + cdsize);
1520                                 CDRDMA_INT( (cdsize/4) / 4 );
1521                         }
1522                         else if( chcr == 0x11000000 ) {
1523                                 // CDRDMA_INT( (cdsize/4) * 1 );
1524                                 // halted
1525                                 psxRegs.cycle += (cdsize/4) * 24/2;
1526                                 CDRDMA_INT(16);
1527                         }
1528                         return;
1529
1530                 default:
1531                         CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr);
1532                         break;
1533         }
1534
1535         HW_DMA3_CHCR &= SWAP32(~0x01000000);
1536         DMA_INTERRUPT(3);
1537 }
1538
1539 void cdrDmaInterrupt()
1540 {
1541         if (HW_DMA3_CHCR & SWAP32(0x01000000))
1542         {
1543                 HW_DMA3_CHCR &= SWAP32(~0x01000000);
1544                 DMA_INTERRUPT(3);
1545         }
1546 }
1547
1548 static void getCdInfo(void)
1549 {
1550         u8 tmp;
1551
1552         CDR_getTN(cdr.ResultTN);
1553         CDR_getTD(0, cdr.SetSectorEnd);
1554         tmp = cdr.SetSectorEnd[0];
1555         cdr.SetSectorEnd[0] = cdr.SetSectorEnd[2];
1556         cdr.SetSectorEnd[2] = tmp;
1557 }
1558
1559 void cdrReset() {
1560         memset(&cdr, 0, sizeof(cdr));
1561         cdr.CurTrack = 1;
1562         cdr.File = 1;
1563         cdr.Channel = 1;
1564         cdr.Reg2 = 0x1f;
1565         cdr.Stat = NoIntr;
1566         cdr.DriveState = DRIVESTATE_STANDBY;
1567         cdr.StatP = STATUS_ROTATING;
1568         pTransfer = cdr.Transfer;
1569         cdr.SetlocPending = 0;
1570         cdr.m_locationChanged = FALSE;
1571
1572         // BIOS player - default values
1573         cdr.AttenuatorLeftToLeft = 0x80;
1574         cdr.AttenuatorLeftToRight = 0x00;
1575         cdr.AttenuatorRightToLeft = 0x00;
1576         cdr.AttenuatorRightToRight = 0x80;
1577
1578         getCdInfo();
1579 }
1580
1581 int cdrFreeze(void *f, int Mode) {
1582         u32 tmp;
1583         u8 tmpp[3];
1584
1585         if (Mode == 0 && !Config.Cdda)
1586                 CDR_stop();
1587
1588         cdr.freeze_ver = 0x63647202;
1589         gzfreeze(&cdr, sizeof(cdr));
1590
1591         if (Mode == 1) {
1592                 cdr.ParamP = cdr.ParamC;
1593                 tmp = pTransfer - cdr.Transfer;
1594         }
1595
1596         gzfreeze(&tmp, sizeof(tmp));
1597
1598         if (Mode == 0) {
1599                 getCdInfo();
1600
1601                 pTransfer = cdr.Transfer + tmp;
1602
1603                 // read right sub data
1604                 tmpp[0] = btoi(cdr.Prev[0]);
1605                 tmpp[1] = btoi(cdr.Prev[1]);
1606                 tmpp[2] = btoi(cdr.Prev[2]);
1607                 cdr.Prev[0]++;
1608                 ReadTrack(tmpp);
1609
1610                 if (cdr.Play) {
1611                         if (cdr.freeze_ver < 0x63647202)
1612                                 memcpy(cdr.SetSectorPlay, cdr.SetSector, 3);
1613
1614                         Find_CurTrack(cdr.SetSectorPlay);
1615                         if (!Config.Cdda)
1616                                 CDR_play();
1617                 }
1618
1619                 if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {
1620                         // old versions did not latch Reg2, have to fixup..
1621                         if (cdr.Reg2 == 0) {
1622                                 SysPrintf("cdrom: fixing up old savestate\n");
1623                                 cdr.Reg2 = 7;
1624                         }
1625                         // also did not save Attenuator..
1626                         if ((cdr.AttenuatorLeftToLeft | cdr.AttenuatorLeftToRight
1627                              | cdr.AttenuatorRightToLeft | cdr.AttenuatorRightToRight) == 0)
1628                         {
1629                                 cdr.AttenuatorLeftToLeft = cdr.AttenuatorRightToRight = 0x80;
1630                         }
1631                 }
1632         }
1633
1634         return 0;
1635 }
1636
1637 void LidInterrupt() {
1638         getCdInfo();
1639         StopCdda();
1640         cdrLidSeekInterrupt();
1641 }