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