notaz.gp2x.de / pcsx_rearmed.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Hack fix for CDROM timings regression (Castlevania, Megaman X4)
[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
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.NoErr = 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 setIrq();
509 }
510
511 if (cdr.SetlocPending) {
512 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
513 cdr.SetlocPending = 0;
514 cdr.m_locationChanged = TRUE;
515 }
516 Find_CurTrack(cdr.SetSectorPlay);
517 ReadTrack(cdr.SetSectorPlay);
518 cdr.TrackChanged = FALSE;
519 }
520
521 if (!cdr.Play) return;
522
523 CDR_LOG( "CDDA - %d:%d:%d\n",
524 cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2] );
525
526 if (memcmp(cdr.SetSectorPlay, cdr.SetSectorEnd, 3) == 0) {
527 StopCdda();
528 cdr.TrackChanged = TRUE;
529 }
530
531 if (!cdr.Irq && !cdr.Stat && (cdr.Mode & (MODE_AUTOPAUSE|MODE_REPORT)))
532 cdrPlayInterrupt_Autopause();
533
534 if (!cdr.Play) return;
535
536 if (CDR_readCDDA && !cdr.Muted && cdr.Mode & MODE_REPORT) {
537 cdrAttenuate(read_buf, CD_FRAMESIZE_RAW / 4, 1);
538 if (SPU_playCDDAchannel)
539 SPU_playCDDAchannel(read_buf, CD_FRAMESIZE_RAW);
540 }
541
542 cdr.SetSectorPlay[2]++;
543 if (cdr.SetSectorPlay[2] == 75) {
544 cdr.SetSectorPlay[2] = 0;
545 cdr.SetSectorPlay[1]++;
546 if (cdr.SetSectorPlay[1] == 60) {
547 cdr.SetSectorPlay[1] = 0;
548 cdr.SetSectorPlay[0]++;
549 }
550 }
551
552 if (cdr.m_locationChanged)
553 {
554 CDRMISC_INT(cdReadTime * 30);
555 cdr.m_locationChanged = FALSE;
556 }
557 else
558 {
559 CDRMISC_INT(cdReadTime);
560 }
561
562 // update for CdlGetlocP/autopause
563 generate_subq(cdr.SetSectorPlay);
564}
565
566void cdrInterrupt() {
567 u16 Irq = cdr.Irq;
568 int no_busy_error = 0;
569 int start_rotating = 0;
570 int error = 0;
571 int delay;
572 unsigned int seekTime = 0;
573
574 // Reschedule IRQ
575 if (cdr.Stat) {
576 CDR_LOG_I("cdrom: stat hack: %02x %x\n", cdr.Irq, cdr.Stat);
577 CDR_INT(0x1000);
578 return;
579 }
580
581 cdr.Ctrl &= ~0x80;
582
583 // default response
584 SetResultSize(1);
585 cdr.Result[0] = cdr.StatP;
586 cdr.Stat = Acknowledge;
587
588 if (cdr.IrqRepeated) {
589 cdr.IrqRepeated = 0;
590 if (cdr.eCycle > psxRegs.cycle) {
591 CDR_INT(cdr.eCycle);
592 goto finish;
593 }
594 }
595
596 cdr.Irq = 0;
597
598 switch (Irq) {
599 case CdlNop:
600 if (cdr.DriveState != DRIVESTATE_LID_OPEN)
601 cdr.StatP &= ~STATUS_SHELLOPEN;
602 no_busy_error = 1;
603 break;
604
605 case CdlSetloc:
606 break;
607
608 do_CdlPlay:
609 case CdlPlay:
610 StopCdda();
611 if (cdr.Seeked == SEEK_PENDING) {
612 // XXX: wrong, should seek instead..
613 cdr.Seeked = SEEK_DONE;
614 }
615
616 cdr.FastBackward = 0;
617 cdr.FastForward = 0;
618
619 if (cdr.SetlocPending) {
620 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
621 cdr.SetlocPending = 0;
622 cdr.m_locationChanged = TRUE;
623 }
624
625 // BIOS CD Player
626 // - Pause player, hit Track 01/02/../xx (Setloc issued!!)
627
628 if (cdr.ParamC == 0 || cdr.Param[0] == 0) {
629 CDR_LOG("PLAY Resume @ %d:%d:%d\n",
630 cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]);
631 }
632 else
633 {
634 int track = btoi( cdr.Param[0] );
635
636 if (track <= cdr.ResultTN[1])
637 cdr.CurTrack = track;
638
639 CDR_LOG("PLAY track %d\n", cdr.CurTrack);
640
641 if (CDR_getTD((u8)cdr.CurTrack, cdr.ResultTD) != -1) {
642 cdr.SetSectorPlay[0] = cdr.ResultTD[2];
643 cdr.SetSectorPlay[1] = cdr.ResultTD[1];
644 cdr.SetSectorPlay[2] = cdr.ResultTD[0];
645 }
646 }
647
648 /*
649 Rayman: detect track changes
650 - fixes logo freeze
651
652 Twisted Metal 2: skip PREGAP + starting accurate SubQ
653 - plays tracks without retry play
654
655 Wild 9: skip PREGAP + starting accurate SubQ
656 - plays tracks without retry play
657 */
658 Find_CurTrack(cdr.SetSectorPlay);
659 ReadTrack(cdr.SetSectorPlay);
660 cdr.TrackChanged = FALSE;
661
662 if (!Config.Cdda)
663 CDR_play();
664
665 // Vib Ribbon: gameplay checks flag
666 cdr.StatP &= ~STATUS_SEEK;
667 cdr.Result[0] = cdr.StatP;
668
669 cdr.StatP |= STATUS_PLAY;
670
671 // BIOS player - set flag again
672 cdr.Play = TRUE;
673
674 CDRMISC_INT( cdReadTime );
675 start_rotating = 1;
676 break;
677
678 case CdlForward:
679 // TODO: error 80 if stopped
680 cdr.Stat = Complete;
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 break;
706
707 case CdlStop:
708 if (cdr.Play) {
709 // grab time for current track
710 CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD);
711
712 cdr.SetSectorPlay[0] = cdr.ResultTD[2];
713 cdr.SetSectorPlay[1] = cdr.ResultTD[1];
714 cdr.SetSectorPlay[2] = cdr.ResultTD[0];
715 }
716
717 StopCdda();
718 StopReading();
719
720 delay = 0x800;
721 if (cdr.DriveState == DRIVESTATE_STANDBY)
722 delay = cdReadTime * 30 / 2;
723
724 cdr.DriveState = DRIVESTATE_STOPPED;
725 AddIrqQueue(CdlStop + 0x100, delay);
726 break;
727
728 case CdlStop + 0x100:
729 cdr.StatP &= ~STATUS_ROTATING;
730 cdr.Result[0] = cdr.StatP;
731 cdr.Stat = Complete;
732 break;
733
734 case CdlPause:
735 /*
736 Gundam Battle Assault 2: much slower (*)
737 - Fixes boot, gameplay
738 Hokuto no Ken 2: slower
739 - Fixes intro + subtitles
740 InuYasha - Feudal Fairy Tale: slower
741 - Fixes battles
742 */
743 /* Gameblabla - Tightening the timings (as taken from Duckstation).
744 * The timings from Duckstation are based upon hardware tests.
745 * Mednafen's timing don't work for Gundam Battle Assault 2 in PAL/50hz mode,
746 * seems to be timing sensitive as it can depend on the CPU's clock speed.
747 *
748 * We will need to get around this for Bedlam/Rise 2 later...
749 * */
750 if (cdr.DriveState != DRIVESTATE_STANDBY)
751 {
752 delay = 7000;
753 }
754 else
755 {
756 delay = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * (1000000));
757 CDRMISC_INT((cdr.Mode & MODE_SPEED) ? cdReadTime / 2 : cdReadTime);
758 }
759 AddIrqQueue(CdlPause + 0x100, delay);
760 cdr.Ctrl |= 0x80;
761 break;
762
763 case CdlPause + 0x100:
764 cdr.StatP &= ~STATUS_READ;
765 cdr.Result[0] = cdr.StatP;
766 cdr.Stat = Complete;
767 break;
768
769 case CdlReset:
770 cdr.Muted = FALSE;
771 cdr.Mode = 0x20; /* Needed for This is Football 2, Pooh's Party and possibly others. */
772 AddIrqQueue(CdlReset + 0x100, 4100000);
773 no_busy_error = 1;
774 start_rotating = 1;
775 break;
776
777 case CdlReset + 0x100:
778 cdr.Stat = Complete;
779 break;
780
781 case CdlMute:
782 cdr.Muted = TRUE;
783 break;
784
785 case CdlDemute:
786 cdr.Muted = FALSE;
787 break;
788
789 case CdlSetfilter:
790 cdr.File = cdr.Param[0];
791 cdr.Channel = cdr.Param[1];
792 break;
793
794 case CdlSetmode:
795 no_busy_error = 1;
796 break;
797
798 case CdlGetparam:
799 SetResultSize(5);
800 cdr.Result[1] = cdr.Mode;
801 cdr.Result[2] = 0;
802 cdr.Result[3] = cdr.File;
803 cdr.Result[4] = cdr.Channel;
804 no_busy_error = 1;
805 break;
806
807 case CdlGetlocL:
808 SetResultSize(8);
809 memcpy(cdr.Result, cdr.Transfer, 8);
810 break;
811
812 case CdlGetlocP:
813 SetResultSize(8);
814 memcpy(&cdr.Result, &cdr.subq, 8);
815
816 if (!cdr.Play && !cdr.Reading)
817 cdr.Result[1] = 0; // HACK?
818 break;
819
820 case CdlReadT: // SetSession?
821 // really long
822 AddIrqQueue(CdlReadT + 0x100, cdReadTime * 290 / 4);
823 start_rotating = 1;
824 break;
825
826 case CdlReadT + 0x100:
827 cdr.Stat = Complete;
828 break;
829
830 case CdlGetTN:
831 SetResultSize(3);
832 if (CDR_getTN(cdr.ResultTN) == -1) {
833 cdr.Stat = DiskError;
834 cdr.Result[0] |= STATUS_ERROR;
835 } else {
836 cdr.Stat = Acknowledge;
837 cdr.Result[1] = itob(cdr.ResultTN[0]);
838 cdr.Result[2] = itob(cdr.ResultTN[1]);
839 }
840 break;
841
842 case CdlGetTD:
843 cdr.Track = btoi(cdr.Param[0]);
844 SetResultSize(4);
845 if (CDR_getTD(cdr.Track, cdr.ResultTD) == -1) {
846 cdr.Stat = DiskError;
847 cdr.Result[0] |= STATUS_ERROR;
848 } else {
849 cdr.Stat = Acknowledge;
850 cdr.Result[0] = cdr.StatP;
851 cdr.Result[1] = itob(cdr.ResultTD[2]);
852 cdr.Result[2] = itob(cdr.ResultTD[1]);
853 /* According to Nocash's documentation, the function doesn't care about ff.
854 * This can be seen also in Mednafen's implementation. */
855 //cdr.Result[3] = itob(cdr.ResultTD[0]);
856 }
857 break;
858
859 case CdlSeekL:
860 case CdlSeekP:
861 StopCdda();
862 StopReading();
863 cdr.StatP |= STATUS_SEEK;
864
865 /*
866 Crusaders of Might and Magic = 0.5x-4x
867 - fix cutscene speech start
868
869 Eggs of Steel = 2x-?
870 - fix new game
871
872 Medievil = ?-4x
873 - fix cutscene speech
874
875 Rockman X5 = 0.5-4x
876 - fix capcom logo
877 */
878 CDRMISC_INT(cdr.Seeked == SEEK_DONE ? 0x800 : cdReadTime * 4);
879 cdr.Seeked = SEEK_PENDING;
880 start_rotating = 1;
881 break;
882
883 case CdlTest:
884 switch (cdr.Param[0]) {
885 case 0x20: // System Controller ROM Version
886 SetResultSize(4);
887 memcpy(cdr.Result, Test20, 4);
888 break;
889 case 0x22:
890 SetResultSize(8);
891 memcpy(cdr.Result, Test22, 4);
892 break;
893 case 0x23: case 0x24:
894 SetResultSize(8);
895 memcpy(cdr.Result, Test23, 4);
896 break;
897 }
898 no_busy_error = 1;
899 break;
900
901 case CdlID:
902 AddIrqQueue(CdlID + 0x100, 20480);
903 break;
904
905 case CdlID + 0x100:
906 SetResultSize(8);
907 cdr.Result[0] = cdr.StatP;
908 cdr.Result[1] = 0;
909 cdr.Result[2] = 0;
910 cdr.Result[3] = 0;
911
912 // 0x10 - audio | 0x40 - disk missing | 0x80 - unlicensed
913 if (CDR_getStatus(&stat) == -1 || stat.Type == 0 || stat.Type == 0xff) {
914 cdr.Result[1] = 0xc0;
915 }
916 else {
917 if (stat.Type == 2)
918 cdr.Result[1] |= 0x10;
919 if (CdromId[0] == '\0')
920 cdr.Result[1] |= 0x80;
921 }
922 cdr.Result[0] |= (cdr.Result[1] >> 4) & 0x08;
923
924 /* This adds the string "PCSX" in Playstation bios boot screen */
925 memcpy((char *)&cdr.Result[4], "PCSX", 4);
926 cdr.Stat = Complete;
927 break;
928
929 case CdlInit:
930 // yes, it really sets STATUS_SHELLOPEN
931 cdr.StatP |= STATUS_SHELLOPEN;
932 cdr.DriveState = DRIVESTATE_RESCAN_CD;
933 CDRLID_INT(20480);
934 no_busy_error = 1;
935 start_rotating = 1;
936 break;
937
938 case CdlGetQ:
939 no_busy_error = 1;
940 break;
941
942 case CdlReadToc:
943 AddIrqQueue(CdlReadToc + 0x100, cdReadTime * 180 / 4);
944 no_busy_error = 1;
945 start_rotating = 1;
946 break;
947
948 case CdlReadToc + 0x100:
949 cdr.Stat = Complete;
950 no_busy_error = 1;
951 break;
952
953 case CdlReadN:
954 case CdlReadS:
955 if (cdr.SetlocPending) {
956 seekTime = abs(msf2sec(cdr.SetSectorPlay) - msf2sec(cdr.SetSector)) * (cdReadTime / 200);
957 /*
958 * Gameblabla :
959 * It was originally set to 1000000 for Driver, however it is not high enough for Worms Pinball
960 * and was unreliable for that game.
961 * I also tested it against Mednafen and Driver's titlescreen music starts 25 frames later, not immediatly.
962 *
963 * Obviously, this isn't perfect but right now, it should be a bit better.
964 * Games to test this against if you change that setting :
965 * - Driver (titlescreen music delay and retry mission)
966 * - Worms Pinball (Will either not boot or crash in the memory card screen)
967 * - Viewpoint (short pauses if the delay in the ingame music is too long)
968 *
969 * It seems that 3386880 * 5 is too much for Driver's titlescreen and it starts skipping.
970 * However, 1000000 is not enough for Worms Pinball to reliably boot.
971 */
972 if(seekTime > 3386880 * 2) seekTime = 3386880 * 2;
973 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
974 cdr.SetlocPending = 0;
975 cdr.m_locationChanged = TRUE;
976 }
977 Find_CurTrack(cdr.SetSectorPlay);
978
979 if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1)
980 // Read* acts as play for cdda tracks in cdda mode
981 goto do_CdlPlay;
982
983 cdr.Reading = 1;
984 cdr.FirstSector = 1;
985
986 // Fighting Force 2 - update subq time immediately
987 // - fixes new game
988 ReadTrack(cdr.SetSectorPlay);
989
990
991 // Crusaders of Might and Magic - update getlocl now
992 // - fixes cutscene speech
993 {
994 u8 *buf = CDR_getBuffer();
995 if (buf != NULL)
996 memcpy(cdr.Transfer, buf, 8);
997 }
998
999 /*
1000 Duke Nukem: Land of the Babes - seek then delay read for one frame
1001 - fixes cutscenes
1002 C-12 - Final Resistance - doesn't like seek
1003 */
1004
1005 /*
1006 By nicolasnoble from PCSX Redux :
1007 "It LOOKS like this logic is wrong, therefore disabling it with `&& false` for now.
1008 For "PoPoLoCrois Monogatari II", the game logic will soft lock and will never issue GetLocP to detect
1009 the end of its XA streams, as it seems to assume ReadS will not return a status byte with the SEEK
1010 flag set. I think the reasonning is that since it's invalid to call GetLocP while seeking, the game
1011 tries to protect itself against errors by preventing from issuing a GetLocP while it knows the
1012 last status was "seek". But this makes the logic just softlock as it'll never get a notification
1013 about the fact the drive is done seeking and the read actually started.
1014 In other words, this state machine here is probably wrong in assuming the response to ReadS/ReadN is
1015 done right away. It's rather when it's done seeking, and the read has actually started. This probably
1016 requires a bit more work to make sure seek delays are processed properly.
1017 Checked with a few games, this seems to work fine."
1018
1019 Gameblabla additional notes :
1020 This still needs the "+ seekTime" that PCSX Redux doesn't have for the Driver "retry" mission error.
1021 */
1022 cdr.StatP |= STATUS_READ;
1023 cdr.StatP &= ~STATUS_SEEK;
1024 CDREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime);
1025
1026 cdr.Result[0] = cdr.StatP;
1027 start_rotating = 1;
1028 break;
1029
1030 case CdlSync:
1031 default:
1032 CDR_LOG_I("Invalid command: %02x\n", Irq);
1033 error = ERROR_INVALIDCMD;
1034 // FALLTHROUGH
1035
1036 set_error:
1037 SetResultSize(2);
1038 cdr.Result[0] = cdr.StatP | STATUS_ERROR;
1039 cdr.Result[1] = error;
1040 cdr.Stat = DiskError;
1041 break;
1042 }
1043
1044 if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) {
1045 cdr.DriveState = DRIVESTATE_STANDBY;
1046 cdr.StatP |= STATUS_ROTATING;
1047 }
1048
1049 if (!no_busy_error) {
1050 switch (cdr.DriveState) {
1051 case DRIVESTATE_LID_OPEN:
1052 case DRIVESTATE_RESCAN_CD:
1053 case DRIVESTATE_PREPARE_CD:
1054 SetResultSize(2);
1055 cdr.Result[0] = cdr.StatP | STATUS_ERROR;
1056 cdr.Result[1] = ERROR_NOTREADY;
1057 cdr.Stat = DiskError;
1058 break;
1059 }
1060 }
1061
1062finish:
1063 setIrq();
1064 cdr.ParamC = 0;
1065
1066#ifdef CDR_LOG_CMD_IRQ
1067 {
1068 int i;
1069 SysPrintf("CDR IRQ %d cmd %02x stat %02x: ",
1070 !!(cdr.Stat & cdr.Reg2), Irq, cdr.Stat);
1071 for (i = 0; i < cdr.ResultC; i++)
1072 SysPrintf("%02x ", cdr.Result[i]);
1073 SysPrintf("\n");
1074 }
1075#endif
1076}
1077
1078#ifdef HAVE_ARMV7
1079 #define ssat32_to_16(v) \
1080 asm("ssat %0,#16,%1" : "=r" (v) : "r" (v))
1081#else
1082 #define ssat32_to_16(v) do { \
1083 if (v < -32768) v = -32768; \
1084 else if (v > 32767) v = 32767; \
1085 } while (0)
1086#endif
1087
1088void cdrAttenuate(s16 *buf, int samples, int stereo)
1089{
1090 int i, l, r;
1091 int ll = cdr.AttenuatorLeftToLeft;
1092 int lr = cdr.AttenuatorLeftToRight;
1093 int rl = cdr.AttenuatorRightToLeft;
1094 int rr = cdr.AttenuatorRightToRight;
1095
1096 if (lr == 0 && rl == 0 && 0x78 <= ll && ll <= 0x88 && 0x78 <= rr && rr <= 0x88)
1097 return;
1098
1099 if (!stereo && ll == 0x40 && lr == 0x40 && rl == 0x40 && rr == 0x40)
1100 return;
1101
1102 if (stereo) {
1103 for (i = 0; i < samples; i++) {
1104 l = buf[i * 2];
1105 r = buf[i * 2 + 1];
1106 l = (l * ll + r * rl) >> 7;
1107 r = (r * rr + l * lr) >> 7;
1108 ssat32_to_16(l);
1109 ssat32_to_16(r);
1110 buf[i * 2] = l;
1111 buf[i * 2 + 1] = r;
1112 }
1113 }
1114 else {
1115 for (i = 0; i < samples; i++) {
1116 l = buf[i];
1117 l = l * (ll + rl) >> 7;
1118 //r = r * (rr + lr) >> 7;
1119 ssat32_to_16(l);
1120 //ssat32_to_16(r);
1121 buf[i] = l;
1122 }
1123 }
1124}
1125
1126void cdrReadInterrupt() {
1127 u8 *buf;
1128
1129 if (!cdr.Reading)
1130 return;
1131
1132 if (cdr.Irq || cdr.Stat) {
1133 CDR_LOG_I("cdrom: read stat hack %02x %x\n", cdr.Irq, cdr.Stat);
1134 CDREAD_INT(0x1000);
1135 return;
1136 }
1137
1138 cdr.OCUP = 1;
1139 SetResultSize(1);
1140 cdr.StatP |= STATUS_READ|STATUS_ROTATING;
1141 cdr.StatP &= ~STATUS_SEEK;
1142 cdr.Result[0] = cdr.StatP;
1143 cdr.Seeked = SEEK_DONE;
1144
1145 ReadTrack(cdr.SetSectorPlay);
1146
1147 buf = CDR_getBuffer();
1148 if (buf == NULL)
1149 cdr.NoErr = 0;
1150
1151 if (cdr.NoErr == 0) {
1152 CDR_LOG_I("cdrReadInterrupt() Log: err\n");
1153 memset(cdr.Transfer, 0, DATA_SIZE);
1154 cdr.Stat = DiskError;
1155 cdr.Result[0] |= STATUS_ERROR;
1156 CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime);
1157 return;
1158 }
1159
1160 memcpy(cdr.Transfer, buf, DATA_SIZE);
1161 CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]);
1162
1163
1164 CDR_LOG("cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]);
1165
1166 if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA
1167 // Firemen 2: Multi-XA files - briefings, cutscenes
1168 if( cdr.FirstSector == 1 && (cdr.Mode & MODE_SF)==0 ) {
1169 cdr.File = cdr.Transfer[4 + 0];
1170 cdr.Channel = cdr.Transfer[4 + 1];
1171 }
1172
1173 /* Gameblabla
1174 * Skips playing on channel 255.
1175 * Fixes missing audio in Blue's Clues : Blue's Big Musical. (Should also fix Taxi 2)
1176 * TODO : Check if this is the proper behaviour.
1177 * */
1178 if((cdr.Transfer[4 + 2] & 0x4) &&
1179 (cdr.Transfer[4 + 1] == cdr.Channel) &&
1180 (cdr.Transfer[4 + 0] == cdr.File) && cdr.Channel != 255) {
1181 int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector);
1182 if (!ret) {
1183 cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo);
1184 /*
1185 * Gameblabla -
1186 * This is a hack for Megaman X4, Castlevania etc...
1187 * that regressed from the new m_locationChanged and CDROM timings changes.
1188 * It is mostly noticeable in Castevania however and the stuttering can be very jarring.
1189 *
1190 * According to PCSX redux authors, we shouldn't cause a location change if
1191 * the sector difference is too small.
1192 * I attempted to go with that approach but came empty handed.
1193 * So for now, let's just set cdr.m_locationChanged to false when playing back any ADPCM samples.
1194 * This does not regress Crash Team Racing's intro at least.
1195 */
1196 cdr.m_locationChanged = FALSE;
1197 SPU_playADPCMchannel(&cdr.Xa);
1198 cdr.FirstSector = 0;
1199 }
1200 else cdr.FirstSector = -1;
1201 }
1202 }
1203
1204 cdr.SetSectorPlay[2]++;
1205 if (cdr.SetSectorPlay[2] == 75) {
1206 cdr.SetSectorPlay[2] = 0;
1207 cdr.SetSectorPlay[1]++;
1208 if (cdr.SetSectorPlay[1] == 60) {
1209 cdr.SetSectorPlay[1] = 0;
1210 cdr.SetSectorPlay[0]++;
1211 }
1212 }
1213
1214 cdr.Readed = 0;
1215
1216 uint32_t delay = (cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime;
1217 if (cdr.m_locationChanged) {
1218 CDREAD_INT(delay * 30);
1219 cdr.m_locationChanged = FALSE;
1220 } else {
1221 CDREAD_INT(delay);
1222 }
1223
1224 /*
1225 Croc 2: $40 - only FORM1 (*)
1226 Judge Dredd: $C8 - only FORM1 (*)
1227 Sim Theme Park - no adpcm at all (zero)
1228 */
1229
1230 if (!(cdr.Mode & MODE_STRSND) || !(cdr.Transfer[4+2] & 0x4)) {
1231 cdr.Stat = DataReady;
1232 setIrq();
1233 }
1234
1235 // update for CdlGetlocP
1236 ReadTrack(cdr.SetSectorPlay);
1237}
1238
1239/*
1240cdrRead0:
1241 bit 0,1 - mode
1242 bit 2 - unknown
1243 bit 3 - unknown
1244 bit 4 - unknown
1245 bit 5 - 1 result ready
1246 bit 6 - 1 dma ready
1247 bit 7 - 1 command being processed
1248*/
1249
1250unsigned char cdrRead0(void) {
1251 if (cdr.ResultReady)
1252 cdr.Ctrl |= 0x20;
1253 else
1254 cdr.Ctrl &= ~0x20;
1255
1256 if (cdr.OCUP)
1257 cdr.Ctrl |= 0x40;
1258// else
1259// cdr.Ctrl &= ~0x40;
1260
1261 // What means the 0x10 and the 0x08 bits? I only saw it used by the bios
1262 cdr.Ctrl |= 0x18;
1263
1264 CDR_LOG_IO("cdr r0: %02x\n", cdr.Ctrl);
1265
1266 return psxHu8(0x1800) = cdr.Ctrl;
1267}
1268
1269void cdrWrite0(unsigned char rt) {
1270 CDR_LOG_IO("cdr w0: %02x\n", rt);
1271
1272 cdr.Ctrl = (rt & 3) | (cdr.Ctrl & ~3);
1273}
1274
1275unsigned char cdrRead1(void) {
1276 if ((cdr.ResultP & 0xf) < cdr.ResultC)
1277 psxHu8(0x1801) = cdr.Result[cdr.ResultP & 0xf];
1278 else
1279 psxHu8(0x1801) = 0;
1280 cdr.ResultP++;
1281 if (cdr.ResultP == cdr.ResultC)
1282 cdr.ResultReady = 0;
1283
1284 CDR_LOG_IO("cdr r1: %02x\n", psxHu8(0x1801));
1285
1286 return psxHu8(0x1801);
1287}
1288
1289void cdrWrite1(unsigned char rt) {
1290 u8 set_loc[3];
1291 int i;
1292
1293 CDR_LOG_IO("cdr w1: %02x\n", rt);
1294
1295 switch (cdr.Ctrl & 3) {
1296 case 0:
1297 break;
1298 case 3:
1299 cdr.AttenuatorRightToRightT = rt;
1300 return;
1301 default:
1302 return;
1303 }
1304
1305 cdr.Cmd = rt;
1306 cdr.OCUP = 0;
1307
1308#ifdef CDR_LOG_CMD_IRQ
1309 SysPrintf("CD1 write: %x (%s)", rt, CmdName[rt]);
1310 if (cdr.ParamC) {
1311 SysPrintf(" Param[%d] = {", cdr.ParamC);
1312 for (i = 0; i < cdr.ParamC; i++)
1313 SysPrintf(" %x,", cdr.Param[i]);
1314 SysPrintf("}\n");
1315 } else {
1316 SysPrintf("\n");
1317 }
1318#endif
1319
1320 cdr.ResultReady = 0;
1321 cdr.Ctrl |= 0x80;
1322 // cdr.Stat = NoIntr;
1323 AddIrqQueue(cdr.Cmd, 0x800);
1324
1325 switch (cdr.Cmd) {
1326 case CdlSetloc:
1327 CDR_LOG("CDROM setloc command (%02X, %02X, %02X)\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
1328
1329 // MM must be BCD, SS must be BCD and <0x60, FF must be BCD and <0x75
1330 if (((cdr.Param[0] & 0x0F) > 0x09) || (cdr.Param[0] > 0x99) || ((cdr.Param[1] & 0x0F) > 0x09) || (cdr.Param[1] >= 0x60) || ((cdr.Param[2] & 0x0F) > 0x09) || (cdr.Param[2] >= 0x75))
1331 {
1332 CDR_LOG("Invalid/out of range seek to %02X:%02X:%02X\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
1333 }
1334 else
1335 {
1336 for (i = 0; i < 3; i++)
1337 {
1338 set_loc[i] = btoi(cdr.Param[i]);
1339 }
1340
1341 i = msf2sec(cdr.SetSectorPlay);
1342 i = abs(i - msf2sec(set_loc));
1343 if (i > 16)
1344 cdr.Seeked = SEEK_PENDING;
1345
1346 memcpy(cdr.SetSector, set_loc, 3);
1347 cdr.SetSector[3] = 0;
1348 cdr.SetlocPending = 1;
1349 }
1350 break;
1351
1352 case CdlReadN:
1353 case CdlReadS:
1354 case CdlPause:
1355 StopCdda();
1356 StopReading();
1357 break;
1358
1359 case CdlInit:
1360 case CdlReset:
1361 cdr.Seeked = SEEK_DONE;
1362 StopCdda();
1363 StopReading();
1364 break;
1365
1366 case CdlSetmode:
1367 CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]);
1368
1369 cdr.Mode = cdr.Param[0];
1370
1371 // Squaresoft on PlayStation 1998 Collector's CD Vol. 1
1372 // - fixes choppy movie sound
1373 if( cdr.Play && (cdr.Mode & MODE_CDDA) == 0 )
1374 StopCdda();
1375 break;
1376 }
1377}
1378
1379unsigned char cdrRead2(void) {
1380 unsigned char ret;
1381
1382 if (cdr.Readed == 0) {
1383 ret = 0;
1384 } else {
1385 ret = *pTransfer++;
1386 }
1387
1388 CDR_LOG_IO("cdr r2: %02x\n", ret);
1389 return ret;
1390}
1391
1392void cdrWrite2(unsigned char rt) {
1393 CDR_LOG_IO("cdr w2: %02x\n", rt);
1394
1395 switch (cdr.Ctrl & 3) {
1396 case 0:
1397 if (cdr.ParamC < 8) // FIXME: size and wrapping
1398 cdr.Param[cdr.ParamC++] = rt;
1399 return;
1400 case 1:
1401 cdr.Reg2 = rt;
1402 setIrq();
1403 return;
1404 case 2:
1405 cdr.AttenuatorLeftToLeftT = rt;
1406 return;
1407 case 3:
1408 cdr.AttenuatorRightToLeftT = rt;
1409 return;
1410 }
1411}
1412
1413unsigned char cdrRead3(void) {
1414 if (cdr.Ctrl & 0x1)
1415 psxHu8(0x1803) = cdr.Stat | 0xE0;
1416 else
1417 psxHu8(0x1803) = cdr.Reg2 | 0xE0;
1418
1419 CDR_LOG_IO("cdr r3: %02x\n", psxHu8(0x1803));
1420 return psxHu8(0x1803);
1421}
1422
1423void cdrWrite3(unsigned char rt) {
1424 CDR_LOG_IO("cdr w3: %02x\n", rt);
1425
1426 switch (cdr.Ctrl & 3) {
1427 case 0:
1428 break; // transfer
1429 case 1:
1430 cdr.Stat &= ~rt;
1431
1432 if (rt & 0x40)
1433 cdr.ParamC = 0;
1434 return;
1435 case 2:
1436 cdr.AttenuatorLeftToRightT = rt;
1437 return;
1438 case 3:
1439 if (rt & 0x20) {
1440 memcpy(&cdr.AttenuatorLeftToLeft, &cdr.AttenuatorLeftToLeftT, 4);
1441 CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n",
1442 cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
1443 cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight);
1444 }
1445 return;
1446 }
1447
1448 if ((rt & 0x80) && cdr.Readed == 0) {
1449 cdr.Readed = 1;
1450 pTransfer = cdr.Transfer;
1451
1452 switch (cdr.Mode & 0x30) {
1453 case MODE_SIZE_2328:
1454 case 0x00:
1455 pTransfer += 12;
1456 break;
1457
1458 case MODE_SIZE_2340:
1459 pTransfer += 0;
1460 break;
1461
1462 default:
1463 break;
1464 }
1465 }
1466}
1467
1468void psxDma3(u32 madr, u32 bcr, u32 chcr) {
1469 u32 cdsize;
1470 int size;
1471 u8 *ptr;
1472
1473 CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr);
1474
1475 switch (chcr) {
1476 case 0x11000000:
1477 case 0x11400100:
1478 if (cdr.Readed == 0) {
1479 CDR_LOG("psxDma3() Log: *** DMA 3 *** NOT READY\n");
1480 break;
1481 }
1482
1483 cdsize = (bcr & 0xffff) * 4;
1484
1485 // Ape Escape: bcr = 0001 / 0000
1486 // - fix boot
1487 if( cdsize == 0 )
1488 {
1489 switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {
1490 case MODE_SIZE_2340: cdsize = 2340; break;
1491 case MODE_SIZE_2328: cdsize = 2328; break;
1492 default:
1493 case MODE_SIZE_2048: cdsize = 2048; break;
1494 }
1495 }
1496
1497
1498 ptr = (u8 *)PSXM(madr);
1499 if (ptr == NULL) {
1500 CDR_LOG("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n");
1501 break;
1502 }
1503
1504 /*
1505 GS CDX: Enhancement CD crash
1506 - Setloc 0:0:0
1507 - CdlPlay
1508 - Spams DMA3 and gets buffer overrun
1509 */
1510 size = CD_FRAMESIZE_RAW - (pTransfer - cdr.Transfer);
1511 if (size > cdsize)
1512 size = cdsize;
1513 if (size > 0)
1514 {
1515 memcpy(ptr, pTransfer, size);
1516 }
1517
1518 psxCpu->Clear(madr, cdsize / 4);
1519 pTransfer += cdsize;
1520
1521 if( chcr == 0x11400100 ) {
1522 HW_DMA3_MADR = SWAPu32(madr + cdsize);
1523 CDRDMA_INT( (cdsize/4) / 4 );
1524 }
1525 else if( chcr == 0x11000000 ) {
1526 // CDRDMA_INT( (cdsize/4) * 1 );
1527 // halted
1528 psxRegs.cycle += (cdsize/4) * 24/2;
1529 CDRDMA_INT(16);
1530 }
1531 return;
1532
1533 default:
1534 CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr);
1535 break;
1536 }
1537
1538 HW_DMA3_CHCR &= SWAP32(~0x01000000);
1539 DMA_INTERRUPT(3);
1540}
1541
1542void cdrDmaInterrupt()
1543{
1544 if (HW_DMA3_CHCR & SWAP32(0x01000000))
1545 {
1546 HW_DMA3_CHCR &= SWAP32(~0x01000000);
1547 DMA_INTERRUPT(3);
1548 }
1549}
1550
1551static void getCdInfo(void)
1552{
1553 u8 tmp;
1554
1555 CDR_getTN(cdr.ResultTN);
1556 CDR_getTD(0, cdr.SetSectorEnd);
1557 tmp = cdr.SetSectorEnd[0];
1558 cdr.SetSectorEnd[0] = cdr.SetSectorEnd[2];
1559 cdr.SetSectorEnd[2] = tmp;
1560}
1561
1562void cdrReset() {
1563 memset(&cdr, 0, sizeof(cdr));
1564 cdr.CurTrack = 1;
1565 cdr.File = 1;
1566 cdr.Channel = 1;
1567 cdr.Reg2 = 0x1f;
1568 cdr.Stat = NoIntr;
1569 cdr.DriveState = DRIVESTATE_STANDBY;
1570 cdr.StatP = STATUS_ROTATING;
1571 pTransfer = cdr.Transfer;
1572 cdr.SetlocPending = 0;
1573 cdr.m_locationChanged = FALSE;
1574
1575 // BIOS player - default values
1576 cdr.AttenuatorLeftToLeft = 0x80;
1577 cdr.AttenuatorLeftToRight = 0x00;
1578 cdr.AttenuatorRightToLeft = 0x00;
1579 cdr.AttenuatorRightToRight = 0x80;
1580
1581 getCdInfo();
1582}
1583
1584int cdrFreeze(void *f, int Mode) {
1585 u32 tmp;
1586 u8 tmpp[3];
1587
1588 if (Mode == 0 && !Config.Cdda)
1589 CDR_stop();
1590
1591 cdr.freeze_ver = 0x63647202;
1592 gzfreeze(&cdr, sizeof(cdr));
1593
1594 if (Mode == 1) {
1595 cdr.ParamP = cdr.ParamC;
1596 tmp = pTransfer - cdr.Transfer;
1597 }
1598
1599 gzfreeze(&tmp, sizeof(tmp));
1600
1601 if (Mode == 0) {
1602 getCdInfo();
1603
1604 pTransfer = cdr.Transfer + tmp;
1605
1606 // read right sub data
1607 tmpp[0] = btoi(cdr.Prev[0]);
1608 tmpp[1] = btoi(cdr.Prev[1]);
1609 tmpp[2] = btoi(cdr.Prev[2]);
1610 cdr.Prev[0]++;
1611 ReadTrack(tmpp);
1612
1613 if (cdr.Play) {
1614 if (cdr.freeze_ver < 0x63647202)
1615 memcpy(cdr.SetSectorPlay, cdr.SetSector, 3);
1616
1617 Find_CurTrack(cdr.SetSectorPlay);
1618 if (!Config.Cdda)
1619 CDR_play();
1620 }
1621
1622 if ((cdr.freeze_ver & 0xffffff00) != 0x63647200) {
1623 // old versions did not latch Reg2, have to fixup..
1624 if (cdr.Reg2 == 0) {
1625 SysPrintf("cdrom: fixing up old savestate\n");
1626 cdr.Reg2 = 7;
1627 }
1628 // also did not save Attenuator..
1629 if ((cdr.AttenuatorLeftToLeft | cdr.AttenuatorLeftToRight
1630 | cdr.AttenuatorRightToLeft | cdr.AttenuatorRightToRight) == 0)
1631 {
1632 cdr.AttenuatorLeftToLeft = cdr.AttenuatorRightToRight = 0x80;
1633 }
1634 }
1635 }
1636
1637 return 0;
1638}
1639
1640void LidInterrupt() {
1641 getCdInfo();
1642 StopCdda();
1643 cdrLidSeekInterrupt();
1644}
ARM optimized PCSX fork