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