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