notaz.gp2x.de / pcsx_rearmed.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
cdrom: some debugging aid
[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 start_rotating = 1;
989 break;
990
991 case CdlTest:
992 switch (cdr.Param[0]) {
993 case 0x20: // System Controller ROM Version
994 SetResultSize(4);
995 memcpy(cdr.Result, Test20, 4);
996 break;
997 case 0x22:
998 SetResultSize(8);
999 memcpy(cdr.Result, Test22, 4);
1000 break;
1001 case 0x23: case 0x24:
1002 SetResultSize(8);
1003 memcpy(cdr.Result, Test23, 4);
1004 break;
1005 }
1006 no_busy_error = 1;
1007 break;
1008
1009 case CdlID:
1010 AddIrqQueue(CdlID + 0x100, 20480);
1011 break;
1012
1013 case CdlID + 0x100:
1014 SetResultSize(8);
1015 cdr.Result[0] = cdr.StatP;
1016 cdr.Result[1] = 0;
1017 cdr.Result[2] = 0;
1018 cdr.Result[3] = 0;
1019
1020 // 0x10 - audio | 0x40 - disk missing | 0x80 - unlicensed
1021 if (CDR_getStatus(&stat) == -1 || stat.Type == 0 || stat.Type == 0xff) {
1022 cdr.Result[1] = 0xc0;
1023 }
1024 else {
1025 if (stat.Type == 2)
1026 cdr.Result[1] |= 0x10;
1027 if (CdromId[0] == '\0')
1028 cdr.Result[1] |= 0x80;
1029 }
1030 cdr.Result[0] |= (cdr.Result[1] >> 4) & 0x08;
1031
1032 strncpy((char *)&cdr.Result[4], "PCSX", 4);
1033 cdr.Stat = Complete;
1034 break;
1035
1036 case CdlInit:
1037 // yes, it really sets STATUS_SHELLOPEN
1038 cdr.StatP |= STATUS_SHELLOPEN;
1039 cdr.DriveState = DRIVESTATE_RESCAN_CD;
1040 CDRLID_INT(20480);
1041 no_busy_error = 1;
1042 start_rotating = 1;
1043 break;
1044
1045 case CdlGetQ:
1046 no_busy_error = 1;
1047 break;
1048
1049 case CdlReadToc:
1050 AddIrqQueue(CdlReadToc + 0x100, cdReadTime * 180 / 4);
1051 no_busy_error = 1;
1052 start_rotating = 1;
1053 break;
1054
1055 case CdlReadToc + 0x100:
1056 cdr.Stat = Complete;
1057 no_busy_error = 1;
1058 break;
1059
1060 case CdlReadN:
1061 case CdlReadS:
1062 if (cdr.SetlocPending) {
1063 seekTime = abs(msf2sec(cdr.SetSectorPlay) - msf2sec(cdr.SetSector)) * (cdReadTime / 200);
1064 /*
1065 * Gameblabla :
1066 * It was originally set to 1000000 for Driver, however it is not high enough for Worms Pinball
1067 * and was unreliable for that game.
1068 * I also tested it against Mednafen and Driver's titlescreen music starts 25 frames later, not immediatly.
1069 *
1070 * Obviously, this isn't perfect but right now, it should be a bit better.
1071 * Games to test this against if you change that setting :
1072 * - Driver (titlescreen music delay and retry mission)
1073 * - Worms Pinball (Will either not boot or crash in the memory card screen)
1074 * - Viewpoint (short pauses if the delay in the ingame music is too long)
1075 *
1076 * It seems that 3386880 * 5 is too much for Driver's titlescreen and it starts skipping.
1077 * However, 1000000 is not enough for Worms Pinball to reliably boot.
1078 */
1079 if(seekTime > 3386880 * 2) seekTime = 3386880 * 2;
1080 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
1081 cdr.SetlocPending = 0;
1082 cdr.m_locationChanged = TRUE;
1083 }
1084 Find_CurTrack(cdr.SetSectorPlay);
1085
1086 if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1)
1087 // Read* acts as play for cdda tracks in cdda mode
1088 goto do_CdlPlay;
1089
1090 cdr.Reading = 1;
1091 cdr.FirstSector = 1;
1092
1093 // Fighting Force 2 - update subq time immediately
1094 // - fixes new game
1095 ReadTrack(cdr.SetSectorPlay);
1096
1097
1098 // Crusaders of Might and Magic - update getlocl now
1099 // - fixes cutscene speech
1100 {
1101 u8 *buf = CDR_getBuffer();
1102 if (buf != NULL)
1103 memcpy(cdr.Transfer, buf, 8);
1104 }
1105
1106 /*
1107 Duke Nukem: Land of the Babes - seek then delay read for one frame
1108 - fixes cutscenes
1109 C-12 - Final Resistance - doesn't like seek
1110 */
1111
1112 /*
1113 By nicolasnoble from PCSX Redux :
1114 "It LOOKS like this logic is wrong, therefore disabling it with `&& false` for now.
1115 For "PoPoLoCrois Monogatari II", the game logic will soft lock and will never issue GetLocP to detect
1116 the end of its XA streams, as it seems to assume ReadS will not return a status byte with the SEEK
1117 flag set. I think the reasonning is that since it's invalid to call GetLocP while seeking, the game
1118 tries to protect itself against errors by preventing from issuing a GetLocP while it knows the
1119 last status was "seek". But this makes the logic just softlock as it'll never get a notification
1120 about the fact the drive is done seeking and the read actually started.
1121
1122 In other words, this state machine here is probably wrong in assuming the response to ReadS/ReadN is
1123 done right away. It's rather when it's done seeking, and the read has actually started. This probably
1124 requires a bit more work to make sure seek delays are processed properly.
1125 Checked with a few games, this seems to work fine."
1126
1127 Gameblabla additional notes :
1128 This still needs the "+ seekTime" that PCSX Redux doesn't have for the Driver "retry" mission error.
1129 */
1130 cdr.StatP |= STATUS_READ;
1131 cdr.StatP &= ~STATUS_SEEK;
1132
1133 CDREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime);
1134
1135 cdr.Result[0] = cdr.StatP;
1136 start_rotating = 1;
1137 break;
1138 case CdlSync:
1139 default:
1140 CDR_LOG_I("Invalid command: %02x\n", Irq);
1141 error = ERROR_INVALIDCMD;
1142 // FALLTHROUGH
1143
1144 set_error:
1145 SetResultSize(2);
1146 cdr.Result[0] = cdr.StatP | STATUS_ERROR;
1147 cdr.Result[1] = error;
1148 cdr.Stat = DiskError;
1149 break;
1150 }
1151
1152 if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) {
1153 cdr.DriveState = DRIVESTATE_STANDBY;
1154 cdr.StatP |= STATUS_ROTATING;
1155 }
1156
1157 if (!no_busy_error) {
1158 switch (cdr.DriveState) {
1159 case DRIVESTATE_LID_OPEN:
1160 case DRIVESTATE_RESCAN_CD:
1161 case DRIVESTATE_PREPARE_CD:
1162 SetResultSize(2);
1163 cdr.Result[0] = cdr.StatP | STATUS_ERROR;
1164 cdr.Result[1] = ERROR_NOTREADY;
1165 cdr.Stat = DiskError;
1166 break;
1167 }
1168 }
1169
1170finish:
1171 setIrq(Irq);
1172 cdr.ParamC = 0;
1173}
1174
1175#ifdef HAVE_ARMV7
1176 #define ssat32_to_16(v) \
1177 asm("ssat %0,#16,%1" : "=r" (v) : "r" (v))
1178#else
1179 #define ssat32_to_16(v) do { \
1180 if (v < -32768) v = -32768; \
1181 else if (v > 32767) v = 32767; \
1182 } while (0)
1183#endif
1184
1185void cdrAttenuate(s16 *buf, int samples, int stereo)
1186{
1187 int i, l, r;
1188 int ll = cdr.AttenuatorLeftToLeft;
1189 int lr = cdr.AttenuatorLeftToRight;
1190 int rl = cdr.AttenuatorRightToLeft;
1191 int rr = cdr.AttenuatorRightToRight;
1192
1193 if (lr == 0 && rl == 0 && 0x78 <= ll && ll <= 0x88 && 0x78 <= rr && rr <= 0x88)
1194 return;
1195
1196 if (!stereo && ll == 0x40 && lr == 0x40 && rl == 0x40 && rr == 0x40)
1197 return;
1198
1199 if (stereo) {
1200 for (i = 0; i < samples; i++) {
1201 l = buf[i * 2];
1202 r = buf[i * 2 + 1];
1203 l = (l * ll + r * rl) >> 7;
1204 r = (r * rr + l * lr) >> 7;
1205 ssat32_to_16(l);
1206 ssat32_to_16(r);
1207 buf[i * 2] = l;
1208 buf[i * 2 + 1] = r;
1209 }
1210 }
1211 else {
1212 for (i = 0; i < samples; i++) {
1213 l = buf[i];
1214 l = l * (ll + rl) >> 7;
1215 //r = r * (rr + lr) >> 7;
1216 ssat32_to_16(l);
1217 //ssat32_to_16(r);
1218 buf[i] = l;
1219 }
1220 }
1221}
1222
1223void cdrReadInterrupt() {
1224 u8 *buf;
1225
1226 if (!cdr.Reading)
1227 return;
1228
1229 if (cdr.Irq || cdr.Stat) {
1230 CDR_LOG_I("cdrom: read stat hack %02x %x\n", cdr.Irq, cdr.Stat);
1231 CDREAD_INT(0x1000);
1232 return;
1233 }
1234
1235 cdr.OCUP = 1;
1236 SetResultSize(1);
1237 cdr.StatP |= STATUS_READ|STATUS_ROTATING;
1238 cdr.StatP &= ~STATUS_SEEK;
1239 cdr.Result[0] = cdr.StatP;
1240 cdr.Seeked = SEEK_DONE;
1241
1242 ReadTrack(cdr.SetSectorPlay);
1243
1244 buf = CDR_getBuffer();
1245 if (buf == NULL)
1246 cdr.NoErr = 0;
1247
1248 if (!cdr.NoErr) {
1249 CDR_LOG_I("cdrReadInterrupt() Log: err\n");
1250 memset(cdr.Transfer, 0, DATA_SIZE);
1251 cdr.Stat = DiskError;
1252 cdr.Result[0] |= STATUS_ERROR;
1253 CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime);
1254 return;
1255 }
1256
1257 memcpy(cdr.Transfer, buf, DATA_SIZE);
1258 CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]);
1259
1260
1261 CDR_LOG("cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]);
1262
1263 if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA
1264 // Firemen 2: Multi-XA files - briefings, cutscenes
1265 if( cdr.FirstSector == 1 && (cdr.Mode & MODE_SF)==0 ) {
1266 cdr.File = cdr.Transfer[4 + 0];
1267 cdr.Channel = cdr.Transfer[4 + 1];
1268 }
1269
1270 /* Gameblabla
1271 * Skips playing on channel 255.
1272 * Fixes missing audio in Blue's Clues : Blue's Big Musical. (Should also fix Taxi 2)
1273 * TODO : Check if this is the proper behaviour.
1274 * */
1275 if((cdr.Transfer[4 + 2] & 0x4) &&
1276 (cdr.Transfer[4 + 1] == cdr.Channel) &&
1277 (cdr.Transfer[4 + 0] == cdr.File) && cdr.Channel != 255) {
1278 int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector);
1279 if (!ret) {
1280 cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo);
1281 /*
1282 * Gameblabla -
1283 * This is a hack for Megaman X4, Castlevania etc...
1284 * that regressed from the new m_locationChanged and CDROM timings changes.
1285 * It is mostly noticeable in Castevania however and the stuttering can be very jarring.
1286 *
1287 * According to PCSX redux authors, we shouldn't cause a location change if
1288 * the sector difference is too small.
1289 * I attempted to go with that approach but came empty handed.
1290 * So for now, let's just set cdr.m_locationChanged to false when playing back any ADPCM samples.
1291 * This does not regress Crash Team Racing's intro at least.
1292 */
1293 cdr.m_locationChanged = FALSE;
1294 SPU_playADPCMchannel(&cdr.Xa);
1295 cdr.FirstSector = 0;
1296 }
1297 else cdr.FirstSector = -1;
1298 }
1299 }
1300
1301 cdr.SetSectorPlay[2]++;
1302 if (cdr.SetSectorPlay[2] == 75) {
1303 cdr.SetSectorPlay[2] = 0;
1304 cdr.SetSectorPlay[1]++;
1305 if (cdr.SetSectorPlay[1] == 60) {
1306 cdr.SetSectorPlay[1] = 0;
1307 cdr.SetSectorPlay[0]++;
1308 }
1309 }
1310
1311 cdr.Readed = 0;
1312
1313 uint32_t delay = (cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime;
1314 if (cdr.m_locationChanged) {
1315 CDREAD_INT(delay * 30);
1316 cdr.m_locationChanged = FALSE;
1317 } else {
1318 CDREAD_INT(delay);
1319 }
1320
1321 /*
1322 Croc 2: $40 - only FORM1 (*)
1323 Judge Dredd: $C8 - only FORM1 (*)
1324 Sim Theme Park - no adpcm at all (zero)
1325 */
1326
1327 if (!(cdr.Mode & MODE_STRSND) || !(cdr.Transfer[4+2] & 0x4)) {
1328 cdr.Stat = DataReady;
1329 setIrq(0x203);
1330 }
1331
1332 // update for CdlGetlocP
1333 ReadTrack(cdr.SetSectorPlay);
1334}
1335
1336/*
1337cdrRead0:
1338 bit 0,1 - mode
1339 bit 2 - unknown
1340 bit 3 - unknown
1341 bit 4 - unknown
1342 bit 5 - 1 result ready
1343 bit 6 - 1 dma ready
1344 bit 7 - 1 command being processed
1345*/
1346
1347unsigned char cdrRead0(void) {
1348 if (cdr.ResultReady)
1349 cdr.Ctrl |= 0x20;
1350 else
1351 cdr.Ctrl &= ~0x20;
1352
1353 if (cdr.OCUP)
1354 cdr.Ctrl |= 0x40;
1355// else
1356// cdr.Ctrl &= ~0x40;
1357
1358 // What means the 0x10 and the 0x08 bits? I only saw it used by the bios
1359 cdr.Ctrl |= 0x18;
1360
1361 CDR_LOG_IO("cdr r0.sta: %02x\n", cdr.Ctrl);
1362
1363 return psxHu8(0x1800) = cdr.Ctrl;
1364}
1365
1366void cdrWrite0(unsigned char rt) {
1367 CDR_LOG_IO("cdr w0.idx: %02x\n", rt);
1368
1369 cdr.Ctrl = (rt & 3) | (cdr.Ctrl & ~3);
1370}
1371
1372unsigned char cdrRead1(void) {
1373 if ((cdr.ResultP & 0xf) < cdr.ResultC)
1374 psxHu8(0x1801) = cdr.Result[cdr.ResultP & 0xf];
1375 else
1376 psxHu8(0x1801) = 0;
1377 cdr.ResultP++;
1378 if (cdr.ResultP == cdr.ResultC)
1379 cdr.ResultReady = 0;
1380
1381 CDR_LOG_IO("cdr r1.rsp: %02x #%u\n", psxHu8(0x1801), cdr.ResultP - 1);
1382
1383 return psxHu8(0x1801);
1384}
1385
1386void cdrWrite1(unsigned char rt) {
1387 const char *rnames[] = { "cmd", "smd", "smc", "arr" }; (void)rnames;
1388 CDR_LOG_IO("cdr w1.%s: %02x\n", rnames[cdr.Ctrl & 3], rt);
1389
1390 switch (cdr.Ctrl & 3) {
1391 case 0:
1392 break;
1393 case 3:
1394 cdr.AttenuatorRightToRightT = rt;
1395 return;
1396 default:
1397 return;
1398 }
1399
1400 cdr.Cmd = rt;
1401 cdr.OCUP = 0;
1402
1403#ifdef CDR_LOG_CMD_IRQ
1404 SysPrintf("CD1 write: %x (%s)", rt, CmdName[rt]);
1405 if (cdr.ParamC) {
1406 int i;
1407 SysPrintf(" Param[%d] = {", cdr.ParamC);
1408 for (i = 0; i < cdr.ParamC; i++)
1409 SysPrintf(" %x,", cdr.Param[i]);
1410 SysPrintf("}\n");
1411 } else {
1412 SysPrintf("\n");
1413 }
1414#endif
1415
1416 cdr.ResultReady = 0;
1417 cdr.Ctrl |= 0x80;
1418 // cdr.Stat = NoIntr;
1419 AddIrqQueue(cdr.Cmd, 0x800);
1420
1421 switch (cdr.Cmd) {
1422
1423 case CdlReadN:
1424 case CdlReadS:
1425 case CdlPause:
1426 StopCdda();
1427 StopReading();
1428 break;
1429
1430 case CdlInit:
1431 case CdlReset:
1432 cdr.Seeked = SEEK_DONE;
1433 StopCdda();
1434 StopReading();
1435 break;
1436
1437 case CdlSetmode:
1438 CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]);
1439
1440 cdr.Mode = cdr.Param[0];
1441
1442 // Squaresoft on PlayStation 1998 Collector's CD Vol. 1
1443 // - fixes choppy movie sound
1444 if( cdr.Play && (cdr.Mode & MODE_CDDA) == 0 )
1445 StopCdda();
1446 break;
1447 }
1448}
1449
1450unsigned char cdrRead2(void) {
1451 unsigned char ret;
1452
1453 if (cdr.Readed == 0) {
1454 ret = 0;
1455 } else {
1456 ret = *pTransfer++;
1457 }
1458
1459 CDR_LOG_IO("cdr r2.dat: %02x\n", ret);
1460 return ret;
1461}
1462
1463void cdrWrite2(unsigned char rt) {
1464 const char *rnames[] = { "prm", "ien", "all", "arl" }; (void)rnames;
1465 CDR_LOG_IO("cdr w2.%s: %02x\n", rnames[cdr.Ctrl & 3], rt);
1466
1467 switch (cdr.Ctrl & 3) {
1468 case 0:
1469 if (cdr.ParamC < 8) // FIXME: size and wrapping
1470 cdr.Param[cdr.ParamC++] = rt;
1471 return;
1472 case 1:
1473 cdr.Reg2 = rt;
1474 setIrq(0x204);
1475 return;
1476 case 2:
1477 cdr.AttenuatorLeftToLeftT = rt;
1478 return;
1479 case 3:
1480 cdr.AttenuatorRightToLeftT = rt;
1481 return;
1482 }
1483}
1484
1485unsigned char cdrRead3(void) {
1486 if (cdr.Ctrl & 0x1)
1487 psxHu8(0x1803) = cdr.Stat | 0xE0;
1488 else
1489 psxHu8(0x1803) = cdr.Reg2 | 0xE0;
1490
1491 CDR_LOG_IO("cdr r3.%s: %02x\n", (cdr.Ctrl & 1) ? "ifl" : "ien", psxHu8(0x1803));
1492 return psxHu8(0x1803);
1493}
1494
1495void cdrWrite3(unsigned char rt) {
1496 const char *rnames[] = { "req", "ifl", "alr", "ava" }; (void)rnames;
1497 CDR_LOG_IO("cdr w3.%s: %02x\n", rnames[cdr.Ctrl & 3], rt);
1498
1499 switch (cdr.Ctrl & 3) {
1500 case 0:
1501 break; // transfer
1502 case 1:
1503 cdr.Stat &= ~rt;
1504
1505 if (rt & 0x40)
1506 cdr.ParamC = 0;
1507 return;
1508 case 2:
1509 cdr.AttenuatorLeftToRightT = rt;
1510 return;
1511 case 3:
1512 if (rt & 0x20) {
1513 memcpy(&cdr.AttenuatorLeftToLeft, &cdr.AttenuatorLeftToLeftT, 4);
1514 CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n",
1515 cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
1516 cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight);
1517 }
1518 return;
1519 }
1520
1521 if ((rt & 0x80) && cdr.Readed == 0) {
1522 cdr.Readed = 1;
1523 pTransfer = cdr.Transfer;
1524
1525 switch (cdr.Mode & 0x30) {
1526 case MODE_SIZE_2328:
1527 case 0x00:
1528 pTransfer += 12;
1529 break;
1530
1531 case MODE_SIZE_2340:
1532 pTransfer += 0;
1533 break;
1534
1535 default:
1536 break;
1537 }
1538 }
1539}
1540
1541void psxDma3(u32 madr, u32 bcr, u32 chcr) {
1542 u32 cdsize;
1543 int size;
1544 u8 *ptr;
1545
1546 CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr);
1547
1548 switch (chcr) {
1549 case 0x11000000:
1550 case 0x11400100:
1551 if (cdr.Readed == 0) {
1552 CDR_LOG("psxDma3() Log: *** DMA 3 *** NOT READY\n");
1553 break;
1554 }
1555
1556 cdsize = (bcr & 0xffff) * 4;
1557
1558 // Ape Escape: bcr = 0001 / 0000
1559 // - fix boot
1560 if( cdsize == 0 )
1561 {
1562 switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {
1563 case MODE_SIZE_2340: cdsize = 2340; break;
1564 case MODE_SIZE_2328: cdsize = 2328; break;
1565 default:
1566 case MODE_SIZE_2048: cdsize = 2048; break;
1567 }
1568 }
1569
1570
1571 ptr = (u8 *)PSXM(madr);
1572 if (ptr == NULL) {
1573 CDR_LOG("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n");
1574 break;
1575 }
1576
1577 /*
1578 GS CDX: Enhancement CD crash
1579 - Setloc 0:0:0
1580 - CdlPlay
1581 - Spams DMA3 and gets buffer overrun
1582 */
1583 size = CD_FRAMESIZE_RAW - (pTransfer - cdr.Transfer);
1584 if (size > cdsize)
1585 size = cdsize;
1586 if (size > 0)
1587 {
1588 memcpy(ptr, pTransfer, size);
1589 }
1590
1591 psxCpu->Clear(madr, cdsize / 4);
1592 pTransfer += cdsize;
1593
1594 if( chcr == 0x11400100 ) {
1595 HW_DMA3_MADR = SWAPu32(madr + cdsize);
1596 CDRDMA_INT( (cdsize/4) / 4 );
1597 }
1598 else if( chcr == 0x11000000 ) {
1599 // CDRDMA_INT( (cdsize/4) * 1 );
1600 // halted
1601 psxRegs.cycle += (cdsize/4) * 24/2;
1602 CDRDMA_INT(16);
1603 }
1604 return;
1605
1606 default:
1607 CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr);
1608 break;
1609 }
1610
1611 HW_DMA3_CHCR &= SWAP32(~0x01000000);
1612 DMA_INTERRUPT(3);
1613}
1614
1615void cdrDmaInterrupt()
1616{
1617 if (HW_DMA3_CHCR & SWAP32(0x01000000))
1618 {
1619 HW_DMA3_CHCR &= SWAP32(~0x01000000);
1620 DMA_INTERRUPT(3);
1621 }
1622}
1623
1624static void getCdInfo(void)
1625{
1626 u8 tmp;
1627
1628 CDR_getTN(cdr.ResultTN);
1629 CDR_getTD(0, cdr.SetSectorEnd);
1630 tmp = cdr.SetSectorEnd[0];
1631 cdr.SetSectorEnd[0] = cdr.SetSectorEnd[2];
1632 cdr.SetSectorEnd[2] = tmp;
1633}
1634
1635void cdrReset() {
1636 memset(&cdr, 0, sizeof(cdr));
1637 cdr.CurTrack = 1;
1638 cdr.File = 1;
1639 cdr.Channel = 1;
1640 cdr.Reg2 = 0x1f;
1641 cdr.Stat = NoIntr;
1642 cdr.DriveState = DRIVESTATE_STANDBY;
1643 cdr.StatP = STATUS_ROTATING;
1644 pTransfer = cdr.Transfer;
1645
1646 // BIOS player - default values
1647 cdr.AttenuatorLeftToLeft = 0x80;
1648 cdr.AttenuatorLeftToRight = 0x00;
1649 cdr.AttenuatorRightToLeft = 0x00;
1650 cdr.AttenuatorRightToRight = 0x80;
1651
1652 getCdInfo();
1653}
1654
1655int cdrFreeze(void *f, int Mode) {
1656 u32 tmp;
1657 u8 tmpp[3];
1658
1659 if (Mode == 0 && !Config.Cdda)
1660 CDR_stop();
1661
1662 cdr.freeze_ver = 0x63647202;
1663 gzfreeze(&cdr, sizeof(cdr));
1664
1665 if (Mode == 1) {
1666 cdr.ParamP = cdr.ParamC;
1667 tmp = pTransfer - cdr.Transfer;
1668 }
1669
1670 gzfreeze(&tmp, sizeof(tmp));
1671
1672 if (Mode == 0) {
1673 getCdInfo();
1674
1675 pTransfer = cdr.Transfer + tmp;
1676
1677 // read right sub data
1678 tmpp[0] = btoi(cdr.Prev[0]);
1679 tmpp[1] = btoi(cdr.Prev[1]);
1680 tmpp[2] = btoi(cdr.Prev[2]);
1681 cdr.Prev[0]++;
1682 ReadTrack(tmpp);
1683
1684 if (cdr.Play) {
1685 if (cdr.freeze_ver < 0x63647202)
1686 memcpy(cdr.SetSectorPlay, cdr.SetSector, 3);
1687
1688 Find_CurTrack(cdr.SetSectorPlay);
1689 if (!Config.Cdda)
1690 CDR_play(cdr.SetSectorPlay);
1691 }
1692
1693 if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {
1694 // old versions did not latch Reg2, have to fixup..
1695 if (cdr.Reg2 == 0) {
1696 SysPrintf("cdrom: fixing up old savestate\n");
1697 cdr.Reg2 = 7;
1698 }
1699 // also did not save Attenuator..
1700 if ((cdr.AttenuatorLeftToLeft | cdr.AttenuatorLeftToRight
1701 | cdr.AttenuatorRightToLeft | cdr.AttenuatorRightToRight) == 0)
1702 {
1703 cdr.AttenuatorLeftToLeft = cdr.AttenuatorRightToRight = 0x80;
1704 }
1705 }
1706 }
1707
1708 return 0;
1709}
1710
1711void LidInterrupt() {
1712 getCdInfo();
1713 StopCdda();
1714 cdrLidSeekInterrupt();
1715}
ARM optimized PCSX fork