mirror/psxrecomp
1
0
Fork 0
mirror of https://github.com/RetroPortingToolKit/psxrecomp synced 2026-10-28 10:59:16 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
8b59da8202013c41750e23cb10bdba6e14dbe64f
psxrecomp/runtime/src/cdrom.c
T
Matthew Stanley 8b59da8202 Disc speed: post-BIOS switch via entry_pc, XA guard for FMVs 
Boot stays at authentic 1x. Speed switch fires once when the game's
entry_pc is first dispatched — safely after the BIOS disc init and
Sony/PlayStation logo sequences complete. Uses entry_pc exact-match
rather than text range to avoid false-triggering on the BIOS shell
(RAM 0x30000-0x5B000 overlaps the game text range).

XA guard in apply_speed(): reverts to 1x whenever xa_stream_active,
protecting FMV playback from speed-up regardless of disc_speed setting.

CDROM_MIN_DELAY floor of 500 cycles prevents instant mode from firing
IRQs faster than the interrupt handler can process them.

Tomba game.toml: disc_speed = "4x" (instant proved too aggressive
for early game disc reads; 4x safe with XA guard protecting FMVs).

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>
2026-05-29 23:59:35 -07:00

900 lines
25 KiB
C
Raw Blame History

/*
* cdrom.c — PS1 CD-ROM controller (adapted from psxrecomp-v3)
*
* Registers at 0x1F801800-0x1F801803 with index-based register banking.
* Reference: nocash PSX specs — CDROM Controller section
*
* v4 adaptation: removed event_deliver (HLE), removed CPUState dependency,
* removed hard-coded RAM writes, removed fprintf. IRQ delivery is via
* i_stat bit 2 (IRQ_CDROM); the recompiled BIOS exception handler
* processes events natively.
*/
#include "cdrom.h"
#include "spu.h"
#include <string.h>
#include <stdlib.h>
/* C wrappers for the C++ ISOReader (defined in iso_reader_c.cpp) */
extern void* iso_open(const char* path);
extern int iso_read_sector(void* handle, uint32_t lba, uint8_t* buffer, int size);
extern int iso_read_raw_sector(void* handle, uint32_t lba, uint8_t* buffer, int size);
extern void iso_close(void* handle);
/* I_STAT owned by memory.c — set bit 2 for CDROM IRQ */
extern uint32_t i_stat;
extern uint32_t g_debug_current_func_addr;
extern uint32_t g_debug_last_store_pc;
extern uint64_t s_frame_count;
/* CD-ROM state */
static uint8_t index_reg;
static uint8_t stat_reg;
static uint8_t irq_enable;
static uint8_t irq_flag;
/* Parameter FIFO */
#define PARAM_FIFO_SIZE 16
static uint8_t param_fifo[PARAM_FIFO_SIZE];
static int param_count;
/* Response FIFO */
#define RESPONSE_FIFO_SIZE 16
static uint8_t response_fifo[RESPONSE_FIFO_SIZE];
static int response_read;
static int response_count;
/* Data buffer. Whole-sector mode transfers 0x924 bytes starting after
* the 12 sync bytes: header, subheader, and sector payload. */
#define SECTOR_SIZE 2048
#define RAW_SECTOR_SIZE 2352
#define RAW_USER_DATA_OFFSET 24
#define WHOLE_SECTOR_OFFSET 12
#define WHOLE_SECTOR_SIZE (RAW_SECTOR_SIZE - WHOLE_SECTOR_OFFSET)
#define FALLBACK_SECTOR_HEADER_SIZE 12
#define FALLBACK_WHOLE_SECTOR_SIZE (FALLBACK_SECTOR_HEADER_SIZE + SECTOR_SIZE)
#define SECTOR_BUFFER_SIZE WHOLE_SECTOR_SIZE
static uint8_t sector_buffer[SECTOR_BUFFER_SIZE];
static int sector_read_pos;
static int sector_available;
static int sector_size;
/* Seek target */
static uint8_t seek_min, seek_sec, seek_sect;
/* Read state */
static int reading;
static int read_min, read_sec, read_sect;
static uint8_t mode_reg;
static uint8_t read_cmd;
static int read_delay;
static uint8_t filter_file;
static uint8_t filter_channel;
static uint8_t cd_muted;
#define XA_SUBHEADER_OFFSET 16
#define XA_DATA_OFFSET 24
#define XA_SOUND_GROUPS 18
#define XA_NATIVE_FRAMES (XA_SOUND_GROUPS * 4 * 28)
#define XA_MAX_44100_FRAMES 4704
#define XA_SUBMODE_AUDIO 0x04
static int32_t xa_hist_l[2];
static int32_t xa_hist_r[2];
static uint8_t xa_stream_file;
static uint8_t xa_stream_channel;
static int xa_stream_active;
/* Operating divisor: 1x during BIOS boot, switches to g_game_divisor
* when the game's entry point first fires (via cdrom_notify_game_started). */
static int g_disc_speed_divisor = 1;
/* Configured target speed — applied post-BIOS. */
static int g_game_divisor = 1;
void cdrom_set_speed(int divisor) {
g_disc_speed_divisor = divisor;
}
/* Store the configured speed for post-BIOS application. Boot stays at 1x. */
void cdrom_set_game_speed(int divisor) {
g_game_divisor = divisor;
}
/* Called by fntrace_record on first game-range dispatch. */
void cdrom_notify_game_started(void) {
g_disc_speed_divisor = g_game_divisor;
}
/* Minimum cycles between CD-ROM IRQs in fast modes. Must be enough for the
* interrupt handler to save state, check the IRQ flag, process data, and
* return. Too low → interrupt fires before the previous one is processed →
* game hangs. 500 cycles ≈ 15µs at 33MHz, still ~900x faster than authentic. */
#define CDROM_MIN_DELAY 500
static int apply_speed(int delay) {
/* XA streaming (FMV / CDDA background music): preserve authentic timing.
* FMVs interleave XA audio + MDEC video — speeding up sector delivery
* would cause both to play faster than the display refresh rate. */
if (xa_stream_active) return delay;
if (g_disc_speed_divisor == 0) return CDROM_MIN_DELAY;
int d = delay / g_disc_speed_divisor;
return d < CDROM_MIN_DELAY ? CDROM_MIN_DELAY : d;
}
static int sector_delay_cycles(void) {
/* PS1 CPU is 33.8688 MHz. CD-ROM sectors arrive at 75 Hz in 1x
* mode, or twice that rate when SetMode bit 7 enables double speed. */
int base = (mode_reg & 0x80) ? 225792 : 451584;
return apply_speed(base);
}
/* Pending command */
typedef struct {
uint8_t cmd;
int pending;
int delay;
int phase;
} PendingCmd;
static PendingCmd pending;
/* ISO reader */
static void* iso_handle = NULL;
static CDROMTraceEntry cdrom_trace[CDROM_TRACE_CAP];
static uint64_t cdrom_trace_seq;
static void trace_cdrom(uint8_t kind, uint32_t addr, uint32_t val, uint8_t width) {
CDROMTraceEntry *e = &cdrom_trace[cdrom_trace_seq % CDROM_TRACE_CAP];
e->seq = cdrom_trace_seq++;
e->kind = kind;
e->addr = addr;
e->val = val;
e->width = width;
e->func = g_debug_current_func_addr;
e->pc = g_debug_last_store_pc;
e->frame = (uint32_t)s_frame_count;
e->i_stat = i_stat;
e->index_reg = index_reg;
e->stat_reg = stat_reg;
e->irq_enable = irq_enable;
e->irq_flag = irq_flag;
e->mode_reg = mode_reg;
e->param_count = (uint8_t)param_count;
e->response_read = (uint8_t)response_read;
e->response_count = (uint8_t)response_count;
e->sector_available = (uint8_t)sector_available;
e->sector_read_pos = sector_read_pos;
e->sector_size = sector_size;
e->pending_cmd = pending.cmd;
e->pending_pending = (uint8_t)pending.pending;
e->pending_delay = pending.delay;
e->reading = (uint8_t)reading;
e->read_cmd = read_cmd;
e->read_delay = read_delay;
}
static int has_disc(void) {
return iso_handle != NULL;
}
/* CD status bits */
#define CDSTAT_ERROR 0x01
#define CDSTAT_MOTOR 0x02
#define CDSTAT_SEEKERR 0x04
#define CDSTAT_IDERROR 0x08
#define CDSTAT_SHELL 0x10
#define CDSTAT_READ 0x20
#define CDSTAT_SEEK 0x40
#define CDSTAT_PLAY 0x80
/* IRQ types */
#define CDIRQ_DATA_READY 1
#define CDIRQ_COMPLETE 2
#define CDIRQ_ACK 3
#define CDIRQ_DATA_END 4
#define CDIRQ_ERROR 5
static void response_clear(void) {
response_read = 0;
response_count = 0;
}
static void response_push(uint8_t val) {
if (response_count < RESPONSE_FIFO_SIZE) {
response_fifo[response_count++] = val;
}
}
static void set_irq(int type) {
irq_flag = (uint8_t)type;
trace_cdrom('I', 0, (uint32_t)type, 0);
}
/* Fire CDROM IRQ into the interrupt controller */
static void fire_cdrom_irq(void) {
if (irq_flag && (irq_enable & (1 << (irq_flag - 1)))) {
i_stat |= (1u << 2); /* IRQ_CDROM */
trace_cdrom('F', 0, irq_flag, 0);
} else {
trace_cdrom('f', 0, irq_flag, 0);
}
}
static int bcd_to_bin(uint8_t bcd) {
return (bcd >> 4) * 10 + (bcd & 0x0F);
}
static int msf_to_lba(int m, int s, int f) {
return (m * 60 + s) * 75 + f - 150;
}
static uint8_t bin_to_bcd(int val) {
return (uint8_t)(((val / 10) << 4) | (val % 10));
}
static int16_t clamp16_cd(int32_t v) {
if (v > 32767) return 32767;
if (v < -32768) return -32768;
return (int16_t)v;
}
static void xa_reset_decode(void) {
xa_hist_l[0] = xa_hist_l[1] = 0;
xa_hist_r[0] = xa_hist_r[1] = 0;
xa_stream_file = 0xFF;
xa_stream_channel = 0xFF;
xa_stream_active = 0;
}
static int xa_decode_sector_4bit_stereo(const uint8_t* data, int16_t* out) {
static const int k0[5] = { 0, 60, 115, 98, 122 };
static const int k1[5] = { 0, 0, -52, -55, -60 };
int pair = 0;
for (int g = 0; g < XA_SOUND_GROUPS; g++) {
const uint8_t* grp = data + g * 128;
for (int blk = 0; blk < 4; blk++) {
uint8_t hdr_l = grp[4 + blk * 2];
uint8_t hdr_r = grp[4 + blk * 2 + 1];
int shift_l = 12 - (int)(hdr_l & 0x0F);
int shift_r = 12 - (int)(hdr_r & 0x0F);
int filter_l = (hdr_l >> 4) & 0x03;
int filter_r = (hdr_r >> 4) & 0x03;
if (shift_l < 0) shift_l = 0;
if (shift_r < 0) shift_r = 0;
for (int i = 0; i < 28; i++) {
uint8_t b = grp[16 + blk + i * 4];
int32_t nib_l = b & 0x0F;
int32_t nib_r = (b >> 4) & 0x0F;
if (nib_l >= 8) nib_l -= 16;
if (nib_r >= 8) nib_r -= 16;
int32_t sample_l = (nib_l << shift_l)
+ ((k0[filter_l] * xa_hist_l[0] + k1[filter_l] * xa_hist_l[1] + 32) >> 6);
int32_t sample_r = (nib_r << shift_r)
+ ((k0[filter_r] * xa_hist_r[0] + k1[filter_r] * xa_hist_r[1] + 32) >> 6);
sample_l = clamp16_cd(sample_l);
sample_r = clamp16_cd(sample_r);
xa_hist_l[1] = xa_hist_l[0];
xa_hist_l[0] = sample_l;
xa_hist_r[1] = xa_hist_r[0];
xa_hist_r[0] = sample_r;
out[pair * 2 + 0] = (int16_t)sample_l;
out[pair * 2 + 1] = (int16_t)sample_r;
pair++;
}
}
}
return pair;
}
static int xa_resample_to_44100(const int16_t* in, int in_frames,
int sample_rate, int16_t* out, int max_frames) {
if (!in || !out || in_frames <= 0 || sample_rate <= 0 || max_frames <= 0) return 0;
int out_frames = 0;
int in_pos = 0;
int phase = 0;
while (in_pos < in_frames && out_frames < max_frames) {
int next_pos = (in_pos + 1 < in_frames) ? in_pos + 1 : in_pos;
int32_t cur_l = in[in_pos * 2 + 0];
int32_t cur_r = in[in_pos * 2 + 1];
int32_t next_l = in[next_pos * 2 + 0];
int32_t next_r = in[next_pos * 2 + 1];
out[out_frames * 2 + 0] = (int16_t)(cur_l + ((next_l - cur_l) * phase) / 44100);
out[out_frames * 2 + 1] = (int16_t)(cur_r + ((next_r - cur_r) * phase) / 44100);
out_frames++;
phase += sample_rate;
while (phase >= 44100) {
phase -= 44100;
in_pos++;
}
}
return out_frames;
}
static void maybe_deliver_xa_audio(const uint8_t* raw_data) {
if (!(mode_reg & 0x40u) || !raw_data || cd_muted) return;
uint8_t file = raw_data[XA_SUBHEADER_OFFSET + 0];
uint8_t channel = raw_data[XA_SUBHEADER_OFFSET + 1];
uint8_t submode = raw_data[XA_SUBHEADER_OFFSET + 2];
uint8_t coding = raw_data[XA_SUBHEADER_OFFSET + 3];
if (!(submode & XA_SUBMODE_AUDIO)) return;
if ((mode_reg & 0x08u) &&
(file != filter_file || channel != filter_channel)) {
trace_cdrom('a', 0, ((uint32_t)file << 16) | ((uint32_t)channel << 8) | coding, 0);
return;
}
int stereo = (coding & 0x01u) != 0;
int rate_code = (coding >> 2) & 0x03;
int depth_code = (coding >> 4) & 0x03;
int sample_rate = (rate_code == 0) ? 37800 : ((rate_code == 1) ? 18900 : 0);
if (!stereo || depth_code != 0 || sample_rate == 0) {
trace_cdrom('X', 0, ((uint32_t)file << 16) | ((uint32_t)channel << 8) | coding, 0);
return;
}
if (!xa_stream_active || xa_stream_file != file || xa_stream_channel != channel) {
xa_reset_decode();
xa_stream_file = file;
xa_stream_channel = channel;
xa_stream_active = 1;
}
int16_t native[XA_NATIVE_FRAMES * 2];
int16_t pcm_44100[XA_MAX_44100_FRAMES * 2];
int native_frames = xa_decode_sector_4bit_stereo(raw_data + XA_DATA_OFFSET, native);
int out_frames = xa_resample_to_44100(native, native_frames, sample_rate,
pcm_44100, XA_MAX_44100_FRAMES);
spu_cd_audio_push(pcm_44100, out_frames);
trace_cdrom('A', 0,
((uint32_t)file << 24) | ((uint32_t)channel << 16) |
((uint32_t)coding << 8) | ((uint32_t)(out_frames / 32) & 0xFFu),
0);
}
static void read_sector_at(int min, int sec, int sect) {
int lba = msf_to_lba(min, sec, sect);
uint8_t user_data[SECTOR_SIZE];
uint8_t raw_data[RAW_SECTOR_SIZE];
int have_raw = 0;
if (iso_handle) {
have_raw = iso_read_raw_sector(iso_handle, lba, raw_data, RAW_SECTOR_SIZE);
if (have_raw) {
maybe_deliver_xa_audio(raw_data);
memcpy(user_data, raw_data + RAW_USER_DATA_OFFSET, SECTOR_SIZE);
} else if (!iso_read_sector(iso_handle, lba, user_data, SECTOR_SIZE)) {
memset(user_data, 0, sizeof(user_data));
}
} else {
memset(user_data, 0, sizeof(user_data));
}
memset(sector_buffer, 0, sizeof(sector_buffer));
if (mode_reg & 0x20) {
if (have_raw) {
memcpy(sector_buffer, raw_data + WHOLE_SECTOR_OFFSET, WHOLE_SECTOR_SIZE);
sector_size = WHOLE_SECTOR_SIZE;
} else {
sector_buffer[0] = bin_to_bcd(min);
sector_buffer[1] = bin_to_bcd(sec);
sector_buffer[2] = bin_to_bcd(sect);
sector_buffer[3] = 0x02; /* Mode 2 sector. */
memcpy(sector_buffer + FALLBACK_SECTOR_HEADER_SIZE, user_data, SECTOR_SIZE);
sector_size = FALLBACK_WHOLE_SECTOR_SIZE;
}
} else {
memcpy(sector_buffer, user_data, SECTOR_SIZE);
sector_size = SECTOR_SIZE;
}
sector_read_pos = 0;
sector_available = 1;
trace_cdrom('S', 0, (uint32_t)lba, 0);
}
static void advance_msf(int* m, int* s, int* f) {
(*f)++;
if (*f >= 75) { *f = 0; (*s)++; }
if (*s >= 60) { *s = 0; (*m)++; }
}
static void clear_sector_buffer(void) {
sector_read_pos = 0;
sector_size = 0;
sector_available = 0;
}
static void start_read_stream(uint8_t cmd) {
clear_sector_buffer();
if (mode_reg & 0x40u) {
xa_reset_decode();
spu_cd_audio_reset();
}
read_min = seek_min;
read_sec = seek_sec;
read_sect = seek_sect;
read_cmd = cmd;
read_delay = sector_delay_cycles();
reading = 1;
stat_reg |= CDSTAT_READ;
}
static void stop_read_stream(void) {
reading = 0;
read_cmd = 0;
read_delay = 0;
}
static void deliver_read_sector(void) {
read_sector_at(read_min, read_sec, read_sect);
advance_msf(&read_min, &read_sec, &read_sect);
response_clear();
response_push(stat_reg);
set_irq(CDIRQ_DATA_READY);
fire_cdrom_irq();
}
static void exec_command(uint8_t cmd) {
trace_cdrom('C', 0, cmd, 0);
response_clear();
switch (cmd) {
case 0x01: /* GetStat */
if (has_disc()) {
stat_reg |= CDSTAT_MOTOR;
} else {
stat_reg |= CDSTAT_SHELL;
}
response_push(stat_reg);
set_irq(CDIRQ_ACK);
break;
case 0x02: /* SetLoc */
if (param_count >= 3) {
seek_min = bcd_to_bin(param_fifo[0]);
seek_sec = bcd_to_bin(param_fifo[1]);
seek_sect = bcd_to_bin(param_fifo[2]);
}
response_push(stat_reg);
set_irq(CDIRQ_ACK);
break;
case 0x06: /* ReadN */
if (!has_disc()) {
response_push(stat_reg | CDSTAT_ERROR);
set_irq(CDIRQ_ERROR);
break;
}
start_read_stream(cmd);
response_push(stat_reg);
set_irq(CDIRQ_ACK);
break;
case 0x09: /* Pause */
stop_read_stream();
xa_reset_decode();
spu_cd_audio_reset();
stat_reg &= ~CDSTAT_READ;
response_push(stat_reg);
set_irq(CDIRQ_ACK);
pending.cmd = 0x09;
pending.pending = 1;
pending.delay = apply_speed(10000);
pending.phase = 1;
break;
case 0x0A: /* Init */
stop_read_stream();
spu_cd_audio_reset();
xa_reset_decode();
stat_reg = has_disc() ? CDSTAT_MOTOR : CDSTAT_SHELL;
response_push(stat_reg);
set_irq(CDIRQ_ACK);
pending.cmd = 0x0A;
pending.pending = 1;
pending.delay = apply_speed(50000);
pending.phase = 1;
break;
case 0x0B: /* Mute */
cd_muted = 1;
response_push(stat_reg);
set_irq(CDIRQ_ACK);
break;
case 0x0C: /* Demute */
cd_muted = 0;
response_push(stat_reg);
set_irq(CDIRQ_ACK);
break;
case 0x0D: /* SetFilter */
if (param_count >= 2) {
filter_file = param_fifo[0];
filter_channel = param_fifo[1];
xa_reset_decode();
}
response_push(stat_reg);
set_irq(CDIRQ_ACK);
break;
case 0x0E: /* SetMode */
if (param_count >= 1) {
mode_reg = param_fifo[0];
if (!(mode_reg & 0x40u)) {
xa_reset_decode();
spu_cd_audio_reset();
}
}
response_push(stat_reg);
set_irq(CDIRQ_ACK);
break;
case 0x15: /* SeekL */
if (!has_disc()) {
response_push(stat_reg | CDSTAT_ERROR | CDSTAT_SEEKERR);
set_irq(CDIRQ_ERROR);
break;
}
xa_reset_decode();
spu_cd_audio_reset();
stat_reg |= CDSTAT_SEEK;
response_push(stat_reg);
set_irq(CDIRQ_ACK);
pending.cmd = 0x15;
pending.pending = 1;
pending.delay = apply_speed(20000);
pending.phase = 1;
break;
case 0x1A: /* GetID */
/* GetID always sends INT3 (ACK) first, then a pending
* second response: INT2 (COMPLETE) with disc ID if present,
* or INT5 (ERROR) if no disc / lid open. */
response_push(stat_reg);
set_irq(CDIRQ_ACK);
pending.cmd = 0x1A;
pending.pending = 1;
pending.delay = apply_speed(30000);
pending.phase = 1;
break;
case 0x1B: /* ReadS */
if (!has_disc()) {
response_push(stat_reg | CDSTAT_ERROR);
set_irq(CDIRQ_ERROR);
break;
}
start_read_stream(cmd);
response_push(stat_reg);
set_irq(CDIRQ_ACK);
break;
case 0x1E: /* ReadTOC */
response_push(stat_reg);
set_irq(CDIRQ_ACK);
pending.cmd = 0x1E;
pending.pending = 1;
pending.delay = apply_speed(100000);
pending.phase = 1;
break;
case 0x19: /* Test */
if (param_count >= 1 && param_fifo[0] == 0x20) {
response_push(0x97);
response_push(0x01);
response_push(0x10);
response_push(0xC2);
set_irq(CDIRQ_ACK);
} else {
response_push(stat_reg);
set_irq(CDIRQ_ACK);
}
break;
default:
response_push(stat_reg | CDSTAT_ERROR);
set_irq(CDIRQ_ERROR);
break;
}
param_count = 0;
/* Fire the CDROM IRQ for the immediate response.
* Delayed responses (pending) fire from process_pending(). */
fire_cdrom_irq();
}
static void process_pending(uint32_t cycles) {
if (!pending.pending) return;
if (cycles == 0) return;
pending.delay -= (int)cycles;
if (pending.delay > 0) return;
pending.pending = 0;
response_clear();
switch (pending.cmd) {
case 0x06: /* ReadN data ready */
case 0x1B: /* ReadS data ready */
if (reading) {
read_sector_at(read_min, read_sec, read_sect);
advance_msf(&read_min, &read_sec, &read_sect);
response_push(stat_reg);
set_irq(CDIRQ_DATA_READY);
fire_cdrom_irq();
}
break;
case 0x09: /* Pause complete */
stat_reg &= ~CDSTAT_READ;
response_push(stat_reg);
set_irq(CDIRQ_COMPLETE);
fire_cdrom_irq();
break;
case 0x0A: /* Init complete */
response_push(stat_reg);
set_irq(CDIRQ_COMPLETE);
fire_cdrom_irq();
break;
case 0x15: /* SeekL complete */
stat_reg &= ~CDSTAT_SEEK;
response_push(stat_reg);
set_irq(CDIRQ_COMPLETE);
fire_cdrom_irq();
break;
case 0x1A: { /* GetID result */
if (!has_disc()) {
response_push(stat_reg | CDSTAT_IDERROR);
response_push(0x80);
set_irq(CDIRQ_ERROR);
} else {
response_push(stat_reg);
response_push(0x00);
response_push(0x20);
response_push(0x00);
response_push('S');
response_push('C');
response_push('E');
response_push('I');
set_irq(CDIRQ_COMPLETE);
}
fire_cdrom_irq();
break;
}
case 0x1E: /* ReadTOC complete */
response_push(stat_reg);
set_irq(CDIRQ_COMPLETE);
fire_cdrom_irq();
break;
default:
break;
}
}
static void process_read_stream(uint32_t cycles) {
if (!reading) return;
if (cycles > 0) {
read_delay -= (int)cycles;
}
if (sector_available && irq_flag != 0) {
return;
}
if (read_delay <= 0) {
if (sector_available) {
trace_cdrom('O', 0, (uint32_t)sector_read_pos, 0);
}
deliver_read_sector();
read_delay += sector_delay_cycles();
}
}
void cdrom_init(const char* cue_path) {
memset(param_fifo, 0, sizeof(param_fifo));
memset(response_fifo, 0, sizeof(response_fifo));
memset(sector_buffer, 0, sizeof(sector_buffer));
index_reg = 0;
irq_enable = 0x1F;
irq_flag = 0;
param_count = 0;
response_read = 0;
response_count = 0;
sector_read_pos = 0;
sector_size = 0;
sector_available = 0;
stop_read_stream();
mode_reg = 0;
filter_file = 0;
filter_channel = 0;
cd_muted = 0;
xa_reset_decode();
spu_cd_audio_reset();
pending.pending = 0;
seek_min = seek_sec = seek_sect = 0;
if (cue_path) {
iso_handle = iso_open(cue_path);
}
stat_reg = has_disc() ? CDSTAT_MOTOR : CDSTAT_SHELL;
cdrom_debug_clear_trace();
trace_cdrom('N', 0, has_disc() ? 1u : 0u, 0);
}
uint32_t cdrom_read(uint32_t addr) {
uint32_t ret = 0;
switch (addr) {
case 0x1F801800: {
uint8_t s = index_reg & 0x03;
s |= (1 << 2); /* ADPCM empty */
if (param_count == 0) s |= (1 << 3);
if (param_count < PARAM_FIFO_SIZE) s |= (1 << 4);
if (response_read < response_count) s |= (1 << 5);
if (sector_available) s |= (1 << 6);
ret = s;
break;
}
case 0x1F801801:
if (response_read < response_count) {
ret = response_fifo[response_read++];
}
break;
case 0x1F801802:
if (sector_available && sector_read_pos < sector_size) {
ret = sector_buffer[sector_read_pos++];
if (sector_read_pos >= sector_size) {
sector_available = 0;
}
}
break;
case 0x1F801803:
if (index_reg == 0 || index_reg == 2) {
ret = irq_enable;
} else {
ret = irq_flag | 0xE0;
}
break;
default:
ret = 0;
break;
}
trace_cdrom('R', addr, ret, 1);
return ret;
}
void cdrom_write(uint32_t addr, uint32_t value) {
uint8_t val = (uint8_t)value;
trace_cdrom('W', addr, val, 1);
switch (addr) {
case 0x1F801800:
index_reg = val & 0x03;
break;
case 0x1F801801:
if (index_reg == 0) {
exec_command(val);
fire_cdrom_irq();
}
break;
case 0x1F801802:
if (index_reg == 0) {
if (param_count < PARAM_FIFO_SIZE) {
param_fifo[param_count++] = val;
}
} else if (index_reg == 1) {
irq_enable = val & 0x1F;
}
break;
case 0x1F801803:
if (index_reg == 1) {
irq_flag &= ~(val & 0x1F);
if (val & 0x40) {
param_count = 0;
}
}
break;
default:
break;
}
}
void cdrom_advance(uint32_t cycles) {
process_pending(cycles);
process_read_stream(cycles);
}
void cdrom_tick(void) {
cdrom_advance(33868u);
}
uint32_t cdrom_dma_read(void) {
uint32_t val = 0;
if (sector_available && sector_read_pos + 4 <= sector_size) {
memcpy(&val, sector_buffer + sector_read_pos, 4);
sector_read_pos += 4;
if (sector_read_pos >= sector_size) {
sector_available = 0;
}
}
trace_cdrom('D', 0, val, 4);
return val;
}
int cdrom_dma_ready(void) {
return sector_available && (sector_read_pos < sector_size);
}
void cdrom_debug_snapshot(CDROMDebugState* out) {
if (!out) return;
memset(out, 0, sizeof(*out));
out->seq = cdrom_trace_seq;
out->index_reg = index_reg;
out->stat_reg = stat_reg;
out->irq_enable = irq_enable;
out->irq_flag = irq_flag;
out->mode_reg = mode_reg;
out->seek_min = seek_min;
out->seek_sec = seek_sec;
out->seek_sect = seek_sect;
out->pending_cmd = pending.cmd;
out->has_disc = has_disc();
out->param_count = param_count;
out->response_read = response_read;
out->response_count = response_count;
out->sector_read_pos = sector_read_pos;
out->sector_available = sector_available;
out->sector_size = sector_size;
out->reading = reading;
out->read_min = read_min;
out->read_sec = read_sec;
out->read_sect = read_sect;
out->read_cmd = read_cmd;
out->filter_file = filter_file;
out->filter_channel = filter_channel;
out->muted = cd_muted;
out->read_delay = read_delay;
out->pending_pending = pending.pending;
out->pending_delay = pending.delay;
out->pending_phase = pending.phase;
out->i_stat = i_stat;
}
uint64_t cdrom_debug_get_trace(const CDROMTraceEntry** out_entries) {
if (out_entries) *out_entries = cdrom_trace;
return cdrom_trace_seq;
}
void cdrom_debug_clear_trace(void) {
memset(cdrom_trace, 0, sizeof(cdrom_trace));
cdrom_trace_seq = 0;
}
Reference in New Issue View Git Blame Copy Permalink