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