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