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