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