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