notaz.gp2x.de / pcsx_rearmed.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
New, separate GPU plugin based on Unai. (#233)
[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(cdr.SetSectorPlay);
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
682 // GameShark CD Player: Calls 2x + Play 2x
683 cdr.FastForward = 1;
684 cdr.FastBackward = 0;
685 break;
686
687 case CdlBackward:
688 cdr.Stat = Complete;
689
690 // GameShark CD Player: Calls 2x + Play 2x
691 cdr.FastBackward = 1;
692 cdr.FastForward = 0;
693 break;
694
695 case CdlStandby:
696 if (cdr.DriveState != DRIVESTATE_STOPPED) {
697 error = ERROR_INVALIDARG;
698 goto set_error;
699 }
700 AddIrqQueue(CdlStandby + 0x100, cdReadTime * 125 / 2);
701 start_rotating = 1;
702 break;
703
704 case CdlStandby + 0x100:
705 cdr.Stat = Complete;
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 break;
734
735 case CdlPause:
736 /*
737 Gundam Battle Assault 2: much slower (*)
738 - Fixes boot, gameplay
739
740 Hokuto no Ken 2: slower
741 - Fixes intro + subtitles
742
743 InuYasha - Feudal Fairy Tale: slower
744 - Fixes battles
745 */
746 /* Gameblabla - Tightening the timings (as taken from Duckstation).
747 * The timings from Duckstation are based upon hardware tests.
748 * Mednafen's timing don't work for Gundam Battle Assault 2 in PAL/50hz mode,
749 * seems to be timing sensitive as it can depend on the CPU's clock speed.
750 * */
751 if (cdr.DriveState != DRIVESTATE_STANDBY)
752 {
753 delay = 7000;
754 }
755 else
756 {
757 delay = (((cdr.Mode & MODE_SPEED) ? 2 : 1) * (1000000));
758 CDRMISC_INT((cdr.Mode & MODE_SPEED) ? cdReadTime / 2 : cdReadTime);
759 }
760 AddIrqQueue(CdlPause + 0x100, delay);
761 cdr.Ctrl |= 0x80;
762 break;
763
764 case CdlPause + 0x100:
765 cdr.StatP &= ~STATUS_READ;
766 cdr.Result[0] = cdr.StatP;
767 cdr.Stat = Complete;
768 break;
769
770 case CdlReset:
771 cdr.Muted = FALSE;
772 cdr.Mode = 0x20; /* This fixes This is Football 2, Pooh's Party lockups */
773 AddIrqQueue(CdlReset + 0x100, 4100000);
774 no_busy_error = 1;
775 start_rotating = 1;
776 break;
777
778 case CdlReset + 0x100:
779 cdr.Stat = Complete;
780 break;
781
782 case CdlMute:
783 cdr.Muted = TRUE;
784 break;
785
786 case CdlDemute:
787 cdr.Muted = FALSE;
788 break;
789
790 case CdlSetfilter:
791 cdr.File = cdr.Param[0];
792 cdr.Channel = cdr.Param[1];
793 break;
794
795 case CdlSetmode:
796 no_busy_error = 1;
797 break;
798
799 case CdlGetparam:
800 /* Gameblabla : According to mednafen, Result size should be 5 and done this way. */
801 SetResultSize(5);
802 cdr.Result[1] = cdr.Mode;
803 cdr.Result[2] = 0;
804 cdr.Result[3] = cdr.File;
805 cdr.Result[4] = cdr.Channel;
806 no_busy_error = 1;
807 break;
808
809 case CdlGetlocL:
810 SetResultSize(8);
811 memcpy(cdr.Result, cdr.Transfer, 8);
812 break;
813
814 case CdlGetlocP:
815 SetResultSize(8);
816 memcpy(&cdr.Result, &cdr.subq, 8);
817
818 if (!cdr.Play && !cdr.Reading)
819 cdr.Result[1] = 0; // HACK?
820 break;
821
822 case CdlReadT: // SetSession?
823 // really long
824 AddIrqQueue(CdlReadT + 0x100, cdReadTime * 290 / 4);
825 start_rotating = 1;
826 break;
827
828 case CdlReadT + 0x100:
829 cdr.Stat = Complete;
830 break;
831
832 case CdlGetTN:
833 SetResultSize(3);
834 if (CDR_getTN(cdr.ResultTN) == -1) {
835 cdr.Stat = DiskError;
836 cdr.Result[0] |= STATUS_ERROR;
837 } else {
838 cdr.Stat = Acknowledge;
839 cdr.Result[1] = itob(cdr.ResultTN[0]);
840 cdr.Result[2] = itob(cdr.ResultTN[1]);
841 }
842 break;
843
844 case CdlGetTD:
845 cdr.Track = btoi(cdr.Param[0]);
846 SetResultSize(4);
847 if (CDR_getTD(cdr.Track, cdr.ResultTD) == -1) {
848 cdr.Stat = DiskError;
849 cdr.Result[0] |= STATUS_ERROR;
850 } else {
851 cdr.Stat = Acknowledge;
852 cdr.Result[0] = cdr.StatP;
853 cdr.Result[1] = itob(cdr.ResultTD[2]);
854 cdr.Result[2] = itob(cdr.ResultTD[1]);
855 /* According to Nocash's documentation, the function doesn't care about ff.
856 * This can be seen also in Mednafen's implementation. */
857 //cdr.Result[3] = itob(cdr.ResultTD[0]);
858 }
859 break;
860
861 case CdlSeekL:
862 case CdlSeekP:
863 StopCdda();
864 StopReading();
865 cdr.StatP |= STATUS_SEEK;
866
867 /*
868 Crusaders of Might and Magic = 0.5x-4x
869 - fix cutscene speech start
870
871 Eggs of Steel = 2x-?
872 - fix new game
873
874 Medievil = ?-4x
875 - fix cutscene speech
876
877 Rockman X5 = 0.5-4x
878 - fix capcom logo
879 */
880 CDRMISC_INT(cdr.Seeked == SEEK_DONE ? 0x800 : cdReadTime * 4);
881 cdr.Seeked = SEEK_PENDING;
882 start_rotating = 1;
883 break;
884
885 case CdlTest:
886 switch (cdr.Param[0]) {
887 case 0x20: // System Controller ROM Version
888 SetResultSize(4);
889 memcpy(cdr.Result, Test20, 4);
890 break;
891 case 0x22:
892 SetResultSize(8);
893 memcpy(cdr.Result, Test22, 4);
894 break;
895 case 0x23: case 0x24:
896 SetResultSize(8);
897 memcpy(cdr.Result, Test23, 4);
898 break;
899 }
900 no_busy_error = 1;
901 break;
902
903 case CdlID:
904 AddIrqQueue(CdlID + 0x100, 20480);
905 break;
906
907 case CdlID + 0x100:
908 SetResultSize(8);
909 cdr.Result[0] = cdr.StatP;
910 cdr.Result[1] = 0;
911 cdr.Result[2] = 0;
912 cdr.Result[3] = 0;
913
914 // 0x10 - audio | 0x40 - disk missing | 0x80 - unlicensed
915 if (CDR_getStatus(&stat) == -1 || stat.Type == 0 || stat.Type == 0xff) {
916 cdr.Result[1] = 0xc0;
917 }
918 else {
919 if (stat.Type == 2)
920 cdr.Result[1] |= 0x10;
921 if (CdromId[0] == '\0')
922 cdr.Result[1] |= 0x80;
923 }
924 cdr.Result[0] |= (cdr.Result[1] >> 4) & 0x08;
925
926 strncpy((char *)&cdr.Result[4], "PCSX", 4);
927 cdr.Stat = Complete;
928 break;
929
930 case CdlInit:
931 // yes, it really sets STATUS_SHELLOPEN
932 cdr.StatP |= STATUS_SHELLOPEN;
933 cdr.DriveState = DRIVESTATE_RESCAN_CD;
934 CDRLID_INT(20480);
935 no_busy_error = 1;
936 start_rotating = 1;
937 break;
938
939 case CdlGetQ:
940 no_busy_error = 1;
941 break;
942
943 case CdlReadToc:
944 AddIrqQueue(CdlReadToc + 0x100, cdReadTime * 180 / 4);
945 no_busy_error = 1;
946 start_rotating = 1;
947 break;
948
949 case CdlReadToc + 0x100:
950 cdr.Stat = Complete;
951 no_busy_error = 1;
952 break;
953
954 case CdlReadN:
955 case CdlReadS:
956 if (cdr.SetlocPending) {
957 seekTime = abs(msf2sec(cdr.SetSectorPlay) - msf2sec(cdr.SetSector)) * (cdReadTime / 200);
958 /*
959 * Gameblabla :
960 * It was originally set to 1000000 for Driver, however it is not high enough for Worms Pinball
961 * and was unreliable for that game.
962 * I also tested it against Mednafen and Driver's titlescreen music starts 25 frames later, not immediatly.
963 *
964 * Obviously, this isn't perfect but right now, it should be a bit better.
965 * Games to test this against if you change that setting :
966 * - Driver (titlescreen music delay and retry mission)
967 * - Worms Pinball (Will either not boot or crash in the memory card screen)
968 * - Viewpoint (short pauses if the delay in the ingame music is too long)
969 *
970 * It seems that 3386880 * 5 is too much for Driver's titlescreen and it starts skipping.
971 * However, 1000000 is not enough for Worms Pinball to reliably boot.
972 */
973 if(seekTime > 3386880 * 2) seekTime = 3386880 * 2;
974 memcpy(cdr.SetSectorPlay, cdr.SetSector, 4);
975 cdr.SetlocPending = 0;
976 cdr.m_locationChanged = TRUE;
977 }
978 Find_CurTrack(cdr.SetSectorPlay);
979
980 if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1)
981 // Read* acts as play for cdda tracks in cdda mode
982 goto do_CdlPlay;
983
984 cdr.Reading = 1;
985 cdr.FirstSector = 1;
986
987 // Fighting Force 2 - update subq time immediately
988 // - fixes new game
989 ReadTrack(cdr.SetSectorPlay);
990
991
992 // Crusaders of Might and Magic - update getlocl now
993 // - fixes cutscene speech
994 {
995 u8 *buf = CDR_getBuffer();
996 if (buf != NULL)
997 memcpy(cdr.Transfer, buf, 8);
998 }
999
1000 /*
1001 Duke Nukem: Land of the Babes - seek then delay read for one frame
1002 - fixes cutscenes
1003 C-12 - Final Resistance - doesn't like seek
1004 */
1005
1006 /*
1007 By nicolasnoble from PCSX Redux :
1008 "It LOOKS like this logic is wrong, therefore disabling it with `&& false` for now.
1009 For "PoPoLoCrois Monogatari II", the game logic will soft lock and will never issue GetLocP to detect
1010 the end of its XA streams, as it seems to assume ReadS will not return a status byte with the SEEK
1011 flag set. I think the reasonning is that since it's invalid to call GetLocP while seeking, the game
1012 tries to protect itself against errors by preventing from issuing a GetLocP while it knows the
1013 last status was "seek". But this makes the logic just softlock as it'll never get a notification
1014 about the fact the drive is done seeking and the read actually started.
1015
1016 In other words, this state machine here is probably wrong in assuming the response to ReadS/ReadN is
1017 done right away. It's rather when it's done seeking, and the read has actually started. This probably
1018 requires a bit more work to make sure seek delays are processed properly.
1019 Checked with a few games, this seems to work fine."
1020
1021 Gameblabla additional notes :
1022 This still needs the "+ seekTime" that PCSX Redux doesn't have for the Driver "retry" mission error.
1023 */
1024 cdr.StatP |= STATUS_READ;
1025 cdr.StatP &= ~STATUS_SEEK;
1026
1027 CDREAD_INT(((cdr.Mode & 0x80) ? (cdReadTime) : cdReadTime * 2) + seekTime);
1028
1029 cdr.Result[0] = cdr.StatP;
1030 start_rotating = 1;
1031 break;
1032 case CdlSync:
1033 default:
1034 CDR_LOG_I("Invalid command: %02x\n", Irq);
1035 error = ERROR_INVALIDCMD;
1036 // FALLTHROUGH
1037
1038 set_error:
1039 SetResultSize(2);
1040 cdr.Result[0] = cdr.StatP | STATUS_ERROR;
1041 cdr.Result[1] = error;
1042 cdr.Stat = DiskError;
1043 break;
1044 }
1045
1046 if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) {
1047 cdr.DriveState = DRIVESTATE_STANDBY;
1048 cdr.StatP |= STATUS_ROTATING;
1049 }
1050
1051 if (!no_busy_error) {
1052 switch (cdr.DriveState) {
1053 case DRIVESTATE_LID_OPEN:
1054 case DRIVESTATE_RESCAN_CD:
1055 case DRIVESTATE_PREPARE_CD:
1056 SetResultSize(2);
1057 cdr.Result[0] = cdr.StatP | STATUS_ERROR;
1058 cdr.Result[1] = ERROR_NOTREADY;
1059 cdr.Stat = DiskError;
1060 break;
1061 }
1062 }
1063
1064finish:
1065 setIrq();
1066 cdr.ParamC = 0;
1067
1068#ifdef CDR_LOG_CMD_IRQ
1069 {
1070 int i;
1071 SysPrintf("CDR IRQ %d cmd %02x stat %02x: ",
1072 !!(cdr.Stat & cdr.Reg2), Irq, cdr.Stat);
1073 for (i = 0; i < cdr.ResultC; i++)
1074 SysPrintf("%02x ", cdr.Result[i]);
1075 SysPrintf("\n");
1076 }
1077#endif
1078}
1079
1080#ifdef HAVE_ARMV7
1081 #define ssat32_to_16(v) \
1082 asm("ssat %0,#16,%1" : "=r" (v) : "r" (v))
1083#else
1084 #define ssat32_to_16(v) do { \
1085 if (v < -32768) v = -32768; \
1086 else if (v > 32767) v = 32767; \
1087 } while (0)
1088#endif
1089
1090void cdrAttenuate(s16 *buf, int samples, int stereo)
1091{
1092 int i, l, r;
1093 int ll = cdr.AttenuatorLeftToLeft;
1094 int lr = cdr.AttenuatorLeftToRight;
1095 int rl = cdr.AttenuatorRightToLeft;
1096 int rr = cdr.AttenuatorRightToRight;
1097
1098 if (lr == 0 && rl == 0 && 0x78 <= ll && ll <= 0x88 && 0x78 <= rr && rr <= 0x88)
1099 return;
1100
1101 if (!stereo && ll == 0x40 && lr == 0x40 && rl == 0x40 && rr == 0x40)
1102 return;
1103
1104 if (stereo) {
1105 for (i = 0; i < samples; i++) {
1106 l = buf[i * 2];
1107 r = buf[i * 2 + 1];
1108 l = (l * ll + r * rl) >> 7;
1109 r = (r * rr + l * lr) >> 7;
1110 ssat32_to_16(l);
1111 ssat32_to_16(r);
1112 buf[i * 2] = l;
1113 buf[i * 2 + 1] = r;
1114 }
1115 }
1116 else {
1117 for (i = 0; i < samples; i++) {
1118 l = buf[i];
1119 l = l * (ll + rl) >> 7;
1120 //r = r * (rr + lr) >> 7;
1121 ssat32_to_16(l);
1122 //ssat32_to_16(r);
1123 buf[i] = l;
1124 }
1125 }
1126}
1127
1128void cdrReadInterrupt() {
1129 u8 *buf;
1130
1131 if (!cdr.Reading)
1132 return;
1133
1134 if (cdr.Irq || cdr.Stat) {
1135 CDR_LOG_I("cdrom: read stat hack %02x %x\n", cdr.Irq, cdr.Stat);
1136 CDREAD_INT(0x1000);
1137 return;
1138 }
1139
1140 cdr.OCUP = 1;
1141 SetResultSize(1);
1142 cdr.StatP |= STATUS_READ|STATUS_ROTATING;
1143 cdr.StatP &= ~STATUS_SEEK;
1144 cdr.Result[0] = cdr.StatP;
1145 cdr.Seeked = SEEK_DONE;
1146
1147 ReadTrack(cdr.SetSectorPlay);
1148
1149 buf = CDR_getBuffer();
1150 if (buf == NULL)
1151 cdr.NoErr = 0;
1152
1153 if (!cdr.NoErr) {
1154 CDR_LOG_I("cdrReadInterrupt() Log: err\n");
1155 memset(cdr.Transfer, 0, DATA_SIZE);
1156 cdr.Stat = DiskError;
1157 cdr.Result[0] |= STATUS_ERROR;
1158 CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime);
1159 return;
1160 }
1161
1162 memcpy(cdr.Transfer, buf, DATA_SIZE);
1163 CheckPPFCache(cdr.Transfer, cdr.Prev[0], cdr.Prev[1], cdr.Prev[2]);
1164
1165
1166 CDR_LOG("cdrReadInterrupt() Log: cdr.Transfer %x:%x:%x\n", cdr.Transfer[0], cdr.Transfer[1], cdr.Transfer[2]);
1167
1168 if ((!cdr.Muted) && (cdr.Mode & MODE_STRSND) && (!Config.Xa) && (cdr.FirstSector != -1)) { // CD-XA
1169 // Firemen 2: Multi-XA files - briefings, cutscenes
1170 if( cdr.FirstSector == 1 && (cdr.Mode & MODE_SF)==0 ) {
1171 cdr.File = cdr.Transfer[4 + 0];
1172 cdr.Channel = cdr.Transfer[4 + 1];
1173 }
1174
1175 /* Gameblabla
1176 * Skips playing on channel 255.
1177 * Fixes missing audio in Blue's Clues : Blue's Big Musical. (Should also fix Taxi 2)
1178 * TODO : Check if this is the proper behaviour.
1179 * */
1180 if((cdr.Transfer[4 + 2] & 0x4) &&
1181 (cdr.Transfer[4 + 1] == cdr.Channel) &&
1182 (cdr.Transfer[4 + 0] == cdr.File) && cdr.Channel != 255) {
1183 int ret = xa_decode_sector(&cdr.Xa, cdr.Transfer+4, cdr.FirstSector);
1184 if (!ret) {
1185 cdrAttenuate(cdr.Xa.pcm, cdr.Xa.nsamples, cdr.Xa.stereo);
1186 /*
1187 * Gameblabla -
1188 * This is a hack for Megaman X4, Castlevania etc...
1189 * that regressed from the new m_locationChanged and CDROM timings changes.
1190 * It is mostly noticeable in Castevania however and the stuttering can be very jarring.
1191 *
1192 * According to PCSX redux authors, we shouldn't cause a location change if
1193 * the sector difference is too small.
1194 * I attempted to go with that approach but came empty handed.
1195 * So for now, let's just set cdr.m_locationChanged to false when playing back any ADPCM samples.
1196 * This does not regress Crash Team Racing's intro at least.
1197 */
1198 cdr.m_locationChanged = FALSE;
1199 SPU_playADPCMchannel(&cdr.Xa);
1200 cdr.FirstSector = 0;
1201 }
1202 else cdr.FirstSector = -1;
1203 }
1204 }
1205
1206 cdr.SetSectorPlay[2]++;
1207 if (cdr.SetSectorPlay[2] == 75) {
1208 cdr.SetSectorPlay[2] = 0;
1209 cdr.SetSectorPlay[1]++;
1210 if (cdr.SetSectorPlay[1] == 60) {
1211 cdr.SetSectorPlay[1] = 0;
1212 cdr.SetSectorPlay[0]++;
1213 }
1214 }
1215
1216 cdr.Readed = 0;
1217
1218 uint32_t delay = (cdr.Mode & MODE_SPEED) ? (cdReadTime / 2) : cdReadTime;
1219 if (cdr.m_locationChanged) {
1220 CDREAD_INT(delay * 30);
1221 cdr.m_locationChanged = FALSE;
1222 } else {
1223 CDREAD_INT(delay);
1224 }
1225
1226 /*
1227 Croc 2: $40 - only FORM1 (*)
1228 Judge Dredd: $C8 - only FORM1 (*)
1229 Sim Theme Park - no adpcm at all (zero)
1230 */
1231
1232 if (!(cdr.Mode & MODE_STRSND) || !(cdr.Transfer[4+2] & 0x4)) {
1233 cdr.Stat = DataReady;
1234 setIrq();
1235 }
1236
1237 // update for CdlGetlocP
1238 ReadTrack(cdr.SetSectorPlay);
1239}
1240
1241/*
1242cdrRead0:
1243 bit 0,1 - mode
1244 bit 2 - unknown
1245 bit 3 - unknown
1246 bit 4 - unknown
1247 bit 5 - 1 result ready
1248 bit 6 - 1 dma ready
1249 bit 7 - 1 command being processed
1250*/
1251
1252unsigned char cdrRead0(void) {
1253 if (cdr.ResultReady)
1254 cdr.Ctrl |= 0x20;
1255 else
1256 cdr.Ctrl &= ~0x20;
1257
1258 if (cdr.OCUP)
1259 cdr.Ctrl |= 0x40;
1260// else
1261// cdr.Ctrl &= ~0x40;
1262
1263 // What means the 0x10 and the 0x08 bits? I only saw it used by the bios
1264 cdr.Ctrl |= 0x18;
1265
1266 CDR_LOG_IO("cdr r0: %02x\n", cdr.Ctrl);
1267
1268 return psxHu8(0x1800) = cdr.Ctrl;
1269}
1270
1271void cdrWrite0(unsigned char rt) {
1272 CDR_LOG_IO("cdr w0: %02x\n", rt);
1273
1274 cdr.Ctrl = (rt & 3) | (cdr.Ctrl & ~3);
1275}
1276
1277unsigned char cdrRead1(void) {
1278 if ((cdr.ResultP & 0xf) < cdr.ResultC)
1279 psxHu8(0x1801) = cdr.Result[cdr.ResultP & 0xf];
1280 else
1281 psxHu8(0x1801) = 0;
1282 cdr.ResultP++;
1283 if (cdr.ResultP == cdr.ResultC)
1284 cdr.ResultReady = 0;
1285
1286 CDR_LOG_IO("cdr r1: %02x\n", psxHu8(0x1801));
1287
1288 return psxHu8(0x1801);
1289}
1290
1291void cdrWrite1(unsigned char rt) {
1292 u8 set_loc[3];
1293 int i;
1294
1295 CDR_LOG_IO("cdr w1: %02x\n", rt);
1296
1297 switch (cdr.Ctrl & 3) {
1298 case 0:
1299 break;
1300 case 3:
1301 cdr.AttenuatorRightToRightT = rt;
1302 return;
1303 default:
1304 return;
1305 }
1306
1307 cdr.Cmd = rt;
1308 cdr.OCUP = 0;
1309
1310#ifdef CDR_LOG_CMD_IRQ
1311 SysPrintf("CD1 write: %x (%s)", rt, CmdName[rt]);
1312 if (cdr.ParamC) {
1313 SysPrintf(" Param[%d] = {", cdr.ParamC);
1314 for (i = 0; i < cdr.ParamC; i++)
1315 SysPrintf(" %x,", cdr.Param[i]);
1316 SysPrintf("}\n");
1317 } else {
1318 SysPrintf("\n");
1319 }
1320#endif
1321
1322 cdr.ResultReady = 0;
1323 cdr.Ctrl |= 0x80;
1324 // cdr.Stat = NoIntr;
1325 AddIrqQueue(cdr.Cmd, 0x800);
1326
1327 switch (cdr.Cmd) {
1328 case CdlSetloc:
1329 CDR_LOG("CDROM setloc command (%02X, %02X, %02X)\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
1330
1331 // MM must be BCD, SS must be BCD and <0x60, FF must be BCD and <0x75
1332 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))
1333 {
1334 CDR_LOG("Invalid/out of range seek to %02X:%02X:%02X\n", cdr.Param[0], cdr.Param[1], cdr.Param[2]);
1335 }
1336 else
1337 {
1338 for (i = 0; i < 3; i++)
1339 {
1340 set_loc[i] = btoi(cdr.Param[i]);
1341 }
1342
1343 i = msf2sec(cdr.SetSectorPlay);
1344 i = abs(i - msf2sec(set_loc));
1345 if (i > 16)
1346 cdr.Seeked = SEEK_PENDING;
1347
1348 memcpy(cdr.SetSector, set_loc, 3);
1349 cdr.SetSector[3] = 0;
1350 cdr.SetlocPending = 1;
1351 }
1352 break;
1353
1354 case CdlReadN:
1355 case CdlReadS:
1356 case CdlPause:
1357 StopCdda();
1358 StopReading();
1359 break;
1360
1361 case CdlInit:
1362 case CdlReset:
1363 cdr.Seeked = SEEK_DONE;
1364 StopCdda();
1365 StopReading();
1366 break;
1367
1368 case CdlSetmode:
1369 CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]);
1370
1371 cdr.Mode = cdr.Param[0];
1372
1373 // Squaresoft on PlayStation 1998 Collector's CD Vol. 1
1374 // - fixes choppy movie sound
1375 if( cdr.Play && (cdr.Mode & MODE_CDDA) == 0 )
1376 StopCdda();
1377 break;
1378 }
1379}
1380
1381unsigned char cdrRead2(void) {
1382 unsigned char ret;
1383
1384 if (cdr.Readed == 0) {
1385 ret = 0;
1386 } else {
1387 ret = *pTransfer++;
1388 }
1389
1390 CDR_LOG_IO("cdr r2: %02x\n", ret);
1391 return ret;
1392}
1393
1394void cdrWrite2(unsigned char rt) {
1395 CDR_LOG_IO("cdr w2: %02x\n", rt);
1396
1397 switch (cdr.Ctrl & 3) {
1398 case 0:
1399 if (cdr.ParamC < 8) // FIXME: size and wrapping
1400 cdr.Param[cdr.ParamC++] = rt;
1401 return;
1402 case 1:
1403 cdr.Reg2 = rt;
1404 setIrq();
1405 return;
1406 case 2:
1407 cdr.AttenuatorLeftToLeftT = rt;
1408 return;
1409 case 3:
1410 cdr.AttenuatorRightToLeftT = rt;
1411 return;
1412 }
1413}
1414
1415unsigned char cdrRead3(void) {
1416 if (cdr.Ctrl & 0x1)
1417 psxHu8(0x1803) = cdr.Stat | 0xE0;
1418 else
1419 psxHu8(0x1803) = cdr.Reg2 | 0xE0;
1420
1421 CDR_LOG_IO("cdr r3: %02x\n", psxHu8(0x1803));
1422 return psxHu8(0x1803);
1423}
1424
1425void cdrWrite3(unsigned char rt) {
1426 CDR_LOG_IO("cdr w3: %02x\n", rt);
1427
1428 switch (cdr.Ctrl & 3) {
1429 case 0:
1430 break; // transfer
1431 case 1:
1432 cdr.Stat &= ~rt;
1433
1434 if (rt & 0x40)
1435 cdr.ParamC = 0;
1436 return;
1437 case 2:
1438 cdr.AttenuatorLeftToRightT = rt;
1439 return;
1440 case 3:
1441 if (rt & 0x20) {
1442 memcpy(&cdr.AttenuatorLeftToLeft, &cdr.AttenuatorLeftToLeftT, 4);
1443 CDR_LOG_I("CD-XA Volume: %02x %02x | %02x %02x\n",
1444 cdr.AttenuatorLeftToLeft, cdr.AttenuatorLeftToRight,
1445 cdr.AttenuatorRightToLeft, cdr.AttenuatorRightToRight);
1446 }
1447 return;
1448 }
1449
1450 if ((rt & 0x80) && cdr.Readed == 0) {
1451 cdr.Readed = 1;
1452 pTransfer = cdr.Transfer;
1453
1454 switch (cdr.Mode & 0x30) {
1455 case MODE_SIZE_2328:
1456 case 0x00:
1457 pTransfer += 12;
1458 break;
1459
1460 case MODE_SIZE_2340:
1461 pTransfer += 0;
1462 break;
1463
1464 default:
1465 break;
1466 }
1467 }
1468}
1469
1470void psxDma3(u32 madr, u32 bcr, u32 chcr) {
1471 u32 cdsize;
1472 int size;
1473 u8 *ptr;
1474
1475 CDR_LOG("psxDma3() Log: *** DMA 3 *** %x addr = %x size = %x\n", chcr, madr, bcr);
1476
1477 switch (chcr) {
1478 case 0x11000000:
1479 case 0x11400100:
1480 if (cdr.Readed == 0) {
1481 CDR_LOG("psxDma3() Log: *** DMA 3 *** NOT READY\n");
1482 break;
1483 }
1484
1485 cdsize = (bcr & 0xffff) * 4;
1486
1487 // Ape Escape: bcr = 0001 / 0000
1488 // - fix boot
1489 if( cdsize == 0 )
1490 {
1491 switch (cdr.Mode & (MODE_SIZE_2340|MODE_SIZE_2328)) {
1492 case MODE_SIZE_2340: cdsize = 2340; break;
1493 case MODE_SIZE_2328: cdsize = 2328; break;
1494 default:
1495 case MODE_SIZE_2048: cdsize = 2048; break;
1496 }
1497 }
1498
1499
1500 ptr = (u8 *)PSXM(madr);
1501 if (ptr == NULL) {
1502 CDR_LOG("psxDma3() Log: *** DMA 3 *** NULL Pointer!\n");
1503 break;
1504 }
1505
1506 /*
1507 GS CDX: Enhancement CD crash
1508 - Setloc 0:0:0
1509 - CdlPlay
1510 - Spams DMA3 and gets buffer overrun
1511 */
1512 size = CD_FRAMESIZE_RAW - (pTransfer - cdr.Transfer);
1513 if (size > cdsize)
1514 size = cdsize;
1515 if (size > 0)
1516 {
1517 memcpy(ptr, pTransfer, size);
1518 }
1519
1520 psxCpu->Clear(madr, cdsize / 4);
1521 pTransfer += cdsize;
1522
1523 if( chcr == 0x11400100 ) {
1524 HW_DMA3_MADR = SWAPu32(madr + cdsize);
1525 CDRDMA_INT( (cdsize/4) / 4 );
1526 }
1527 else if( chcr == 0x11000000 ) {
1528 // CDRDMA_INT( (cdsize/4) * 1 );
1529 // halted
1530 psxRegs.cycle += (cdsize/4) * 24/2;
1531 CDRDMA_INT(16);
1532 }
1533 return;
1534
1535 default:
1536 CDR_LOG("psxDma3() Log: Unknown cddma %x\n", chcr);
1537 break;
1538 }
1539
1540 HW_DMA3_CHCR &= SWAP32(~0x01000000);
1541 DMA_INTERRUPT(3);
1542}
1543
1544void cdrDmaInterrupt()
1545{
1546 if (HW_DMA3_CHCR & SWAP32(0x01000000))
1547 {
1548 HW_DMA3_CHCR &= SWAP32(~0x01000000);
1549 DMA_INTERRUPT(3);
1550 }
1551}
1552
1553static void getCdInfo(void)
1554{
1555 u8 tmp;
1556
1557 CDR_getTN(cdr.ResultTN);
1558 CDR_getTD(0, cdr.SetSectorEnd);
1559 tmp = cdr.SetSectorEnd[0];
1560 cdr.SetSectorEnd[0] = cdr.SetSectorEnd[2];
1561 cdr.SetSectorEnd[2] = tmp;
1562}
1563
1564void cdrReset() {
1565 memset(&cdr, 0, sizeof(cdr));
1566 cdr.CurTrack = 1;
1567 cdr.File = 1;
1568 cdr.Channel = 1;
1569 cdr.Reg2 = 0x1f;
1570 cdr.Stat = NoIntr;
1571 cdr.DriveState = DRIVESTATE_STANDBY;
1572 cdr.StatP = STATUS_ROTATING;
1573 pTransfer = cdr.Transfer;
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(cdr.SetSectorPlay);
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