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