int interrupt_read_sc_snapshot(interrupt_cpu_status_t *cs, snapshot_module_t *m)
{
if (SMR_DW_UINT(m, &cs->irq_delay_cycles) < 0
|| SMR_DW_UINT(m, &cs->nmi_delay_cycles) < 0) {
return -1;
}
return 0;
}
int interrupt_read_new_snapshot(interrupt_cpu_status_t *cs, snapshot_module_t *m)
{
if (SMR_DW_INT(m, &cs->nirq) < 0
|| SMR_DW_INT(m, &cs->nnmi) < 0
|| SMR_DW_UINT(m, &cs->global_pending_int) < 0) {
return -1;
}
return 0;
}
int maincpu_snapshot_read_module(snapshot_t *s)
{
BYTE a, x, y, sp, status;
WORD pc;
BYTE major, minor;
snapshot_module_t *m;
m = snapshot_module_open(s, snap_module_name, &major, &minor);
if (m == NULL) {
return -1;
}
/* FIXME: This is a mighty kludge to prevent VIC-II from stealing the
wrong number of cycles. */
maincpu_rmw_flag = 0;
/* XXX: Assumes `CLOCK' is the same size as a `DWORD'. */
if (0
|| SMR_DW(m, &maincpu_clk) < 0
|| SMR_B(m, &a) < 0
|| SMR_B(m, &x) < 0
|| SMR_B(m, &y) < 0
|| SMR_B(m, &sp) < 0
|| SMR_W(m, &pc) < 0
|| SMR_B(m, &status) < 0
|| SMR_DW_UINT(m, &last_opcode_info) < 0) {
goto fail;
}
MOS6510_REGS_SET_A(&maincpu_regs, a);
MOS6510_REGS_SET_X(&maincpu_regs, x);
MOS6510_REGS_SET_Y(&maincpu_regs, y);
MOS6510_REGS_SET_SP(&maincpu_regs, sp);
MOS6510_REGS_SET_PC(&maincpu_regs, pc);
MOS6510_REGS_SET_STATUS(&maincpu_regs, status);
if (interrupt_read_snapshot(maincpu_int_status, m) < 0) {
goto fail;
}
if (interrupt_read_new_snapshot(maincpu_int_status, m) < 0) {
goto fail;
}
return snapshot_module_close(m);
fail:
if (m != NULL) {
snapshot_module_close(m);
}
return -1;
}
int vic_snapshot_read_module(snapshot_t *s)
{
WORD i;
snapshot_module_t *m;
BYTE major_version, minor_version;
WORD w;
BYTE b;
sound_close();
m = snapshot_module_open(s, snap_module_name,
&major_version, &minor_version);
if (m == NULL) {
return -1;
}
if (major_version > SNAP_MAJOR || minor_version > SNAP_MINOR) {
log_error(vic.log, "Snapshot module version (%d.%d) newer than %d.%d.",
major_version, minor_version,
SNAP_MAJOR, SNAP_MINOR);
goto fail;
}
if (SMR_B(m, &b) < 0) {
goto fail;
}
if (b != VIC_RASTER_CYCLE(maincpu_clk)) {
log_error(vic.log, "Cycle value (%d) incorrect; should be %d.",
(int)b, VIC_RASTER_CYCLE(maincpu_clk));
goto fail;
}
vic.raster_cycle = (unsigned int)b;
if (SMR_W(m, &w) < 0) {
goto fail;
}
if (w != VIC_RASTER_Y(maincpu_clk)) {
log_error(vic.log, "Raster line value (%d) incorrect; should be %d.",
(int)w, VIC_RASTER_Y(maincpu_clk));
goto fail;
}
if (SMR_W(m, &w) < 0) {
goto fail;
}
vic.area = (vic_area_state_t)w;
if (SMR_W(m, &w) < 0) {
goto fail;
}
vic.fetch_state = (vic_fetch_state_t)w;
if (0
|| (SMR_DW_UINT(m, &vic.raster_line) < 0)
|| (SMR_DW_UINT(m, &vic.text_cols) < 0)
|| (SMR_DW_UINT(m, &vic.text_lines) < 0)
|| (SMR_DW_UINT(m, &vic.pending_text_cols) < 0)
|| (SMR_DW_UINT(m, &vic.line_was_blank) < 0)
|| (SMR_DW_UINT(m, &vic.memptr) < 0)
|| (SMR_DW_UINT(m, &vic.memptr_inc) < 0)
|| (SMR_DW_UINT(m, &vic.row_counter) < 0)
|| (SMR_DW_UINT(m, &vic.buf_offset) < 0)
|| SMR_B_INT(m, &vic.light_pen.state) < 0
|| SMR_B_INT(m, &vic.light_pen.triggered) < 0
|| SMR_DW_INT(m, &vic.light_pen.x) < 0
|| SMR_DW_INT(m, &vic.light_pen.y) < 0
|| SMR_DW_INT(m, &vic.light_pen.x_extra_bits) < 0
|| SMR_DW(m, &vic.light_pen.trigger_cycle) < 0
|| (SMR_B(m, &vic.vbuf) < 0)) {
goto fail;
}
/* Color RAM. */
if (SMR_BA(m, mem_ram + 0x9400, 0x400) < 0) {
goto fail;
}
for (i = 0; i < 0x10; i++) {
if (SMR_B(m, &b) < 0) {
goto fail;
}
/* XXX: This assumes that there are no side effects. */
vic_store(i, b);
}
raster_force_repaint(&vic.raster);
return snapshot_module_close(m);
fail:
if (m != NULL)
snapshot_module_close(m);
return -1;
}
int sfx_soundexpander_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
int temp_chip;
FM_OPL *chip = NULL;
int temp_connect1;
int x, y;
m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor);
if (m == NULL) {
return -1;
}
if ((vmajor != CART_DUMP_VER_MAJOR) || (vminor != CART_DUMP_VER_MINOR)) {
snapshot_module_close(m);
return -1;
}
if (0 || (SMR_DW_INT(m, &temp_chip) < 0)) {
snapshot_module_close(m);
return -1;
}
if (sfx_soundexpander_sound_chip.chip_enabled) {
set_sfx_soundexpander_enabled(0, NULL);
}
set_sfx_soundexpander_chip(temp_chip, NULL);
set_sfx_soundexpander_enabled(1, NULL);
chip = (temp_chip == 3526) ? YM3526_chip : YM3812_chip;
if (0 || (SMR_B(m, &snd.command) < 0)) {
snapshot_module_close(m);
return -1;
}
for (x = 0; x < 9; x++) {
for (y = 0; y < 2; y++) {
if (0
|| (SMR_DW_UINT(m, &chip->P_CH[x].SLOT[y].ar) < 0)
|| (SMR_DW_UINT(m, &chip->P_CH[x].SLOT[y].dr) < 0)
|| (SMR_DW_UINT(m, &chip->P_CH[x].SLOT[y].rr) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].KSR) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].ksl) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].ksr) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].mul) < 0)
|| (SMR_DW_UINT(m, &chip->P_CH[x].SLOT[y].Cnt) < 0)
|| (SMR_DW_UINT(m, &chip->P_CH[x].SLOT[y].Incr) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].FB) < 0)
|| (SMR_DW_INT(m, &temp_connect1) < 0)
|| (SMR_DW_INT(m, &chip->P_CH[x].SLOT[y].op1_out[0]) < 0)
|| (SMR_DW_INT(m, &chip->P_CH[x].SLOT[y].op1_out[1]) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].CON) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].eg_type) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].state) < 0)
|| (SMR_DW_UINT(m, &chip->P_CH[x].SLOT[y].TL) < 0)
|| (SMR_DW_INT(m, &chip->P_CH[x].SLOT[y].TLL) < 0)
|| (SMR_DW_INT(m, &chip->P_CH[x].SLOT[y].volume) < 0)
|| (SMR_DW_UINT(m, &chip->P_CH[x].SLOT[y].sl) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].eg_sh_ar) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].eg_sel_ar) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].eg_sh_dr) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].eg_sel_dr) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].eg_sh_rr) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].eg_sel_rr) < 0)
|| (SMR_DW_UINT(m, &chip->P_CH[x].SLOT[y].key) < 0)
|| (SMR_DW_UINT(m, &chip->P_CH[x].SLOT[y].AMmask) < 0)
|| (SMR_B(m, &chip->P_CH[x].SLOT[y].vib) < 0)
|| (SMR_W(m, &chip->P_CH[x].SLOT[y].wavetable) < 0)) {
snapshot_module_close(m);
return -1;
}
set_connect1(chip->P_CH[x].SLOT[y].connect1, temp_connect1);
}
if (0
|| (SMR_DW_UINT(m, &chip->P_CH[x].block_fnum) < 0)
|| (SMR_DW_UINT(m, &chip->P_CH[x].fc) < 0)
|| (SMR_DW_UINT(m, &chip->P_CH[x].ksl_base) < 0)
|| (SMR_B(m, &chip->P_CH[x].kcode) < 0)) {
snapshot_module_close(m);
return -1;
}
}
if (0
|| (SMR_DW_UINT(m, &chip->eg_cnt) < 0)
|| (SMR_DW_UINT(m, &chip->eg_timer) < 0)
|| (SMR_DW_UINT(m, &chip->eg_timer_add) < 0)
|| (SMR_DW_UINT(m, &chip->eg_timer_overflow) < 0)
|| (SMR_B(m, &chip->rhythm) < 0)) {
snapshot_module_close(m);
return -1;
}
for (x = 0; x < 1024; x++) {
if (0
|| (SMR_DW_UINT(m, &chip->fn_tab[x]) < 0)) {
snapshot_module_close(m);
return -1;
}
}
if (0
|| (SMR_B(m, &chip->lfo_am_depth) < 0)
|| (SMR_B(m, &chip->lfo_pm_depth_range) < 0)
|| (SMR_DW_UINT(m, &chip->lfo_am_cnt) < 0)
|| (SMR_DW_UINT(m, &chip->lfo_am_inc) < 0)
|| (SMR_DW_UINT(m, &chip->lfo_pm_cnt) < 0)
|| (SMR_DW_UINT(m, &chip->lfo_pm_inc) < 0)
|| (SMR_DW_UINT(m, &chip->noise_rng) < 0)
|| (SMR_DW_UINT(m, &chip->noise_p) < 0)
|| (SMR_DW_UINT(m, &chip->noise_f) < 0)
|| (SMR_B(m, &chip->wavesel) < 0)
|| (SMR_DW_UINT(m, &chip->T[0]) < 0)
|| (SMR_DW_UINT(m, &chip->T[1]) < 0)
|| (SMR_B(m, &chip->st[0]) < 0)
|| (SMR_B(m, &chip->st[1]) < 0)
|| (SMR_B(m, &chip->type) < 0)
|| (SMR_B(m, &chip->address) < 0)
|| (SMR_B(m, &chip->status) < 0)
|| (SMR_B(m, &chip->statusmask) < 0)
|| (SMR_B(m, &chip->mode) < 0)
|| (SMR_DW_UINT(m, &chip->clock) < 0)
|| (SMR_DW_UINT(m, &chip->rate) < 0)
|| (SMR_DB(m, &chip->freqbase) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return 0;
}
int drive_snapshot_read_module(snapshot_t *s)
{
BYTE major_version, minor_version;
int i;
snapshot_module_t *m;
char snap_module_name[] = "DRIVE";
DWORD rotation_table_ptr[DRIVE_NUM];
CLOCK attach_clk[DRIVE_NUM];
CLOCK detach_clk[DRIVE_NUM];
CLOCK attach_detach_clk[DRIVE_NUM];
int drive_true_emulation;
int sync_factor;
drive_t *drive;
int dummy;
int half_track[DRIVE_NUM];
m = snapshot_module_open(s, snap_module_name,
&major_version, &minor_version);
if (m == NULL) {
/* If this module is not found true emulation is off. */
resources_set_int("DriveTrueEmulation", 0);
return 0;
}
drive_gcr_data_writeback_all();
if (major_version > DRIVE_SNAP_MAJOR || minor_version > DRIVE_SNAP_MINOR) {
log_error(drive_snapshot_log,
"Snapshot module version (%d.%d) newer than %d.%d.",
major_version, minor_version,
DRIVE_SNAP_MAJOR, DRIVE_SNAP_MINOR);
}
/* If this module exists true emulation is enabled. */
/* XXX drive_true_emulation = 1 */
resources_set_int("DriveTrueEmulation", 1);
if (SMR_DW_INT(m, &sync_factor) < 0) {
snapshot_module_close(m);
return -1;
}
/* TODO: NUM_DRIVES drives instead of 2 */
for (i = 0; i < 2; i++) {
drive = drive_context[i]->drive;
/* Partially read 1.0 snapshots */
if (major_version == 1 && minor_version == 0) {
if (0
|| SMR_DW_UL(m, &(drive->snap_accum)) < 0
|| SMR_DW(m, &(attach_clk[i])) < 0
|| SMR_DW_INT(m, &dummy) < 0
|| SMR_B_INT(m, (int *)&(drive->byte_ready_level)) < 0
|| SMR_B_INT(m, &(drive->clock_frequency)) < 0
|| SMR_W_INT(m, &half_track[i]) < 0
|| SMR_DW(m, &(detach_clk[i])) < 0
|| SMR_B(m, (BYTE *)&dummy) < 0
|| SMR_B(m, (BYTE *)&dummy) < 0
|| SMR_B_INT(m, &(drive->extend_image_policy)) < 0
|| SMR_B_INT(m, &dummy) < 0
|| SMR_DW_UINT(m, &(drive->GCR_head_offset)) < 0
|| SMR_B(m, &(drive->GCR_read)) < 0
|| SMR_B(m, &(drive->GCR_write_value)) < 0
|| SMR_B_INT(m, &(drive->idling_method)) < 0
|| SMR_B_INT(m, &dummy) < 0
|| SMR_B_INT(m, &(drive->parallel_cable)) < 0
|| SMR_B_INT(m, &(drive->read_only)) < 0
|| SMR_DW(m, &(drive->snap_rotation_last_clk)) < 0
|| SMR_DW(m, &rotation_table_ptr[i]) < 0
|| SMR_DW_UINT(m, &(drive->type)) < 0
) {
snapshot_module_close(m);
return -1;
}
/* Partially read 1.1 snapshots */
} else if (major_version == 1 && minor_version == 1) {
if (0
|| SMR_DW(m, &(attach_clk[i])) < 0
|| SMR_B_INT(m, (int *)&(drive->byte_ready_level)) < 0
|| SMR_B_INT(m, &(drive->clock_frequency)) < 0
|| SMR_W_INT(m, &half_track[i]) < 0
|| SMR_DW(m, &(detach_clk[i])) < 0
|| SMR_B(m, (BYTE *)&dummy) < 0
|| SMR_B(m, (BYTE *)&dummy) < 0
|| SMR_B_INT(m, &(drive->extend_image_policy)) < 0
|| SMR_DW_UINT(m, &(drive->GCR_head_offset)) < 0
|| SMR_B(m, &(drive->GCR_read)) < 0
|| SMR_B(m, &(drive->GCR_write_value)) < 0
|| SMR_B_INT(m, &(drive->idling_method)) < 0
|| SMR_B_INT(m, &(drive->parallel_cable)) < 0
|| SMR_B_INT(m, &(drive->read_only)) < 0
|| SMR_DW(m, &rotation_table_ptr[i]) < 0
|| SMR_DW_UINT(m, &(drive->type)) < 0
|| SMR_DW_UL(m, &(drive->snap_accum)) < 0
|| SMR_DW(m, &(drive->snap_rotation_last_clk)) < 0
|| SMR_DW_INT(m, &(drive->snap_bit_counter)) < 0
|| SMR_DW_INT(m, &(drive->snap_zero_count)) < 0
|| SMR_W_INT(m, &(drive->snap_last_read_data)) < 0
|| SMR_B(m, &(drive->snap_last_write_data)) < 0
|| SMR_DW_INT(m, &(drive->snap_seed)) < 0
) {
snapshot_module_close(m);
return -1;
}
/* Partially read 1.2 snapshots */
} else if (major_version == 1 && minor_version == 2) {
if (0
|| SMR_DW(m, &(attach_clk[i])) < 0
|| SMR_B_INT(m, (int *)&(drive->byte_ready_level)) < 0
|| SMR_B_INT(m, &(drive->clock_frequency)) < 0
|| SMR_W_INT(m, &half_track[i]) < 0
|| SMR_DW(m, &(detach_clk[i])) < 0
|| SMR_B(m, (BYTE *)&dummy) < 0
|| SMR_B(m, (BYTE *)&dummy) < 0
|| SMR_B_INT(m, &(drive->extend_image_policy)) < 0
|| SMR_DW_UINT(m, &(drive->GCR_head_offset)) < 0
|| SMR_B(m, &(drive->GCR_read)) < 0
|| SMR_B(m, &(drive->GCR_write_value)) < 0
|| SMR_B_INT(m, &(drive->idling_method)) < 0
|| SMR_B_INT(m, &(drive->parallel_cable)) < 0
|| SMR_B_INT(m, &(drive->read_only)) < 0
|| SMR_DW(m, &rotation_table_ptr[i]) < 0
|| SMR_DW_UINT(m, &(drive->type)) < 0
|| SMR_DW_UL(m, &(drive->snap_accum)) < 0
|| SMR_DW(m, &(drive->snap_rotation_last_clk)) < 0
|| SMR_DW_INT(m, &(drive->snap_bit_counter)) < 0
|| SMR_DW_INT(m, &(drive->snap_zero_count)) < 0
|| SMR_W_INT(m, &(drive->snap_last_read_data)) < 0
|| SMR_B(m, &(drive->snap_last_write_data)) < 0
|| SMR_DW_INT(m, &(drive->snap_seed)) < 0
|| SMR_DW(m, &(drive->snap_speed_zone)) < 0
|| SMR_DW(m, &(drive->snap_ue7_dcba)) < 0
|| SMR_DW(m, &(drive->snap_ue7_counter)) < 0
|| SMR_DW(m, &(drive->snap_uf4_counter)) < 0
|| SMR_DW(m, &(drive->snap_fr_randcount)) < 0
|| SMR_DW(m, &(drive->snap_filter_counter)) < 0
|| SMR_DW(m, &(drive->snap_filter_state)) < 0
|| SMR_DW(m, &(drive->snap_filter_last_state)) < 0
|| SMR_DW(m, &(drive->snap_write_flux)) < 0
|| SMR_DW(m, &(drive->snap_PulseHeadPosition)) < 0
|| SMR_DW(m, &(drive->snap_xorShift32)) < 0
) {
snapshot_module_close(m);
return -1;
}
} else if (major_version == 1 && minor_version == 3) {
if (0
|| SMR_DW(m, &(attach_clk[i])) < 0
|| SMR_B_INT(m, (int *)&(drive->byte_ready_level)) < 0
|| SMR_B_INT(m, &(drive->clock_frequency)) < 0
|| SMR_W_INT(m, &half_track[i]) < 0
|| SMR_DW(m, &(detach_clk[i])) < 0
|| SMR_B(m, (BYTE *)&dummy) < 0
|| SMR_B(m, (BYTE *)&dummy) < 0
|| SMR_B_INT(m, &(drive->extend_image_policy)) < 0
|| SMR_DW_UINT(m, &(drive->GCR_head_offset)) < 0
|| SMR_B(m, &(drive->GCR_read)) < 0
|| SMR_B(m, &(drive->GCR_write_value)) < 0
|| SMR_B_INT(m, &(drive->idling_method)) < 0
|| SMR_B_INT(m, &(drive->parallel_cable)) < 0
|| SMR_B_INT(m, &(drive->read_only)) < 0
|| SMR_DW(m, &rotation_table_ptr[i]) < 0
|| SMR_DW_UINT(m, &(drive->type)) < 0
|| SMR_DW_UL(m, &(drive->snap_accum)) < 0
|| SMR_DW(m, &(drive->snap_rotation_last_clk)) < 0
|| SMR_DW_INT(m, &(drive->snap_bit_counter)) < 0
|| SMR_DW_INT(m, &(drive->snap_zero_count)) < 0
|| SMR_W_INT(m, &(drive->snap_last_read_data)) < 0
|| SMR_B(m, &(drive->snap_last_write_data)) < 0
|| SMR_DW_INT(m, &(drive->snap_seed)) < 0
|| SMR_DW(m, &(drive->snap_speed_zone)) < 0
|| SMR_DW(m, &(drive->snap_ue7_dcba)) < 0
|| SMR_DW(m, &(drive->snap_ue7_counter)) < 0
|| SMR_DW(m, &(drive->snap_uf4_counter)) < 0
|| SMR_DW(m, &(drive->snap_fr_randcount)) < 0
|| SMR_DW(m, &(drive->snap_filter_counter)) < 0
|| SMR_DW(m, &(drive->snap_filter_state)) < 0
|| SMR_DW(m, &(drive->snap_filter_last_state)) < 0
|| SMR_DW(m, &(drive->snap_write_flux)) < 0
|| SMR_DW(m, &(drive->snap_PulseHeadPosition)) < 0
|| SMR_DW(m, &(drive->snap_xorShift32)) < 0
|| SMR_DW(m, &(drive->snap_so_delay)) < 0
) {
snapshot_module_close(m);
return -1;
}
} else {
if (0
|| SMR_DW(m, &(attach_clk[i])) < 0
|| SMR_B_INT(m, (int *)&(drive->byte_ready_level)) < 0
|| SMR_B_INT(m, &(drive->clock_frequency)) < 0
|| SMR_W_INT(m, &half_track[i]) < 0
|| SMR_DW(m, &(detach_clk[i])) < 0
|| SMR_B(m, (BYTE *)&dummy) < 0
|| SMR_B(m, (BYTE *)&dummy) < 0
|| SMR_B_INT(m, &(drive->extend_image_policy)) < 0
|| SMR_DW_UINT(m, &(drive->GCR_head_offset)) < 0
|| SMR_B(m, &(drive->GCR_read)) < 0
|| SMR_B(m, &(drive->GCR_write_value)) < 0
|| SMR_B_INT(m, &(drive->idling_method)) < 0
|| SMR_B_INT(m, &(drive->parallel_cable)) < 0
|| SMR_B_INT(m, &(drive->read_only)) < 0
|| SMR_DW(m, &rotation_table_ptr[i]) < 0
|| SMR_DW_UINT(m, &(drive->type)) < 0
|| SMR_DW_UL(m, &(drive->snap_accum)) < 0
|| SMR_DW(m, &(drive->snap_rotation_last_clk)) < 0
|| SMR_DW_INT(m, &(drive->snap_bit_counter)) < 0
|| SMR_DW_INT(m, &(drive->snap_zero_count)) < 0
|| SMR_W_INT(m, &(drive->snap_last_read_data)) < 0
|| SMR_B(m, &(drive->snap_last_write_data)) < 0
|| SMR_DW_INT(m, &(drive->snap_seed)) < 0
|| SMR_DW(m, &(drive->snap_speed_zone)) < 0
|| SMR_DW(m, &(drive->snap_ue7_dcba)) < 0
|| SMR_DW(m, &(drive->snap_ue7_counter)) < 0
|| SMR_DW(m, &(drive->snap_uf4_counter)) < 0
|| SMR_DW(m, &(drive->snap_fr_randcount)) < 0
|| SMR_DW(m, &(drive->snap_filter_counter)) < 0
|| SMR_DW(m, &(drive->snap_filter_state)) < 0
|| SMR_DW(m, &(drive->snap_filter_last_state)) < 0
|| SMR_DW(m, &(drive->snap_write_flux)) < 0
|| SMR_DW(m, &(drive->snap_PulseHeadPosition)) < 0
|| SMR_DW(m, &(drive->snap_xorShift32)) < 0
|| SMR_DW(m, &(drive->snap_so_delay)) < 0
|| SMR_DW(m, &(drive->snap_cycle_index)) < 0
|| SMR_DW(m, &(drive->snap_ref_advance)) < 0
|| SMR_DW(m, &(drive->snap_req_ref_cycles)) < 0
) {
snapshot_module_close(m);
return -1;
}
}
}
/* this one is new, so don't test so stay compatible with old snapshots */
for (i = 0; i < 2; i++) {
drive = drive_context[i]->drive;
SMR_DW(m, &(attach_detach_clk[i]));
}
/* these are even newer */
for (i = 0; i < 2; i++) {
drive = drive_context[i]->drive;
SMR_B_INT(m, (int *)&(drive->byte_ready_edge));
SMR_B_INT(m, (int *)&(drive->byte_ready_active));
}
snapshot_module_close(m);
m = NULL;
rotation_table_set(rotation_table_ptr);
drive = drive_context[0]->drive;
switch (drive->type) {
case DRIVE_TYPE_1540:
case DRIVE_TYPE_1541:
case DRIVE_TYPE_1541II:
case DRIVE_TYPE_1551:
case DRIVE_TYPE_1570:
case DRIVE_TYPE_1571:
case DRIVE_TYPE_1571CR:
case DRIVE_TYPE_1581:
case DRIVE_TYPE_2000:
case DRIVE_TYPE_4000:
case DRIVE_TYPE_2031:
case DRIVE_TYPE_1001:
case DRIVE_TYPE_2040:
case DRIVE_TYPE_3040:
case DRIVE_TYPE_4040:
case DRIVE_TYPE_8050:
case DRIVE_TYPE_8250:
drive->enable = 1;
machine_drive_rom_setup_image(0);
drivemem_init(drive_context[0], drive->type);
resources_set_int("Drive8IdleMethod", drive->idling_method);
driverom_initialize_traps(drive);
drive_set_active_led_color(drive->type, 0);
machine_bus_status_drivetype_set(8, 1);
break;
case DRIVE_TYPE_NONE:
drive_disable(drive_context[0]);
machine_bus_status_drivetype_set(8, 0);
break;
default:
return -1;
}
drive = drive_context[1]->drive;
switch (drive->type) {
case DRIVE_TYPE_1540:
case DRIVE_TYPE_1541:
case DRIVE_TYPE_1541II:
case DRIVE_TYPE_1551:
case DRIVE_TYPE_1570:
case DRIVE_TYPE_1571:
case DRIVE_TYPE_1581:
case DRIVE_TYPE_2000:
case DRIVE_TYPE_4000:
case DRIVE_TYPE_2031:
case DRIVE_TYPE_1001:
/* drive 1 does not allow dual disk drive */
drive->enable = 1;
machine_drive_rom_setup_image(1);
drivemem_init(drive_context[1], drive->type);
resources_set_int("Drive9IdleMethod", drive->idling_method);
driverom_initialize_traps(drive);
drive_set_active_led_color(drive->type, 1);
machine_bus_status_drivetype_set(9, 1);
break;
case DRIVE_TYPE_NONE:
case DRIVE_TYPE_8050:
case DRIVE_TYPE_8250:
drive_disable(drive_context[1]);
machine_bus_status_drivetype_set(9, 0);
break;
default:
return -1;
}
/* Clear parallel cable before undumping parallel port values. */
for (i = 0; i < DRIVE_PC_NUM; i++) {
parallel_cable_drive_write(i, 0xff, PARALLEL_WRITE, 0);
parallel_cable_drive_write(i, 0xff, PARALLEL_WRITE, 1);
}
for (i = 0; i < 2; i++) {
drive = drive_context[i]->drive;
if (drive->enable) {
if (drive->type == DRIVE_TYPE_2000 || drive->type == DRIVE_TYPE_4000) {
if (drivecpu65c02_snapshot_read_module(drive_context[i], s) < 0) {
return -1;
}
} else {
if (drivecpu_snapshot_read_module(drive_context[i], s) < 0) {
return -1;
}
}
if (machine_drive_snapshot_read(drive_context[i], s) < 0) {
return -1;
}
}
}
if (drive_snapshot_read_image_module(s, 0) < 0
|| drive_snapshot_read_gcrimage_module(s, 0) < 0
|| drive_snapshot_read_p64image_module(s, 0) < 0) {
return -1;
}
if (drive_snapshot_read_image_module(s, 1) < 0
|| drive_snapshot_read_gcrimage_module(s, 1) < 0
|| drive_snapshot_read_p64image_module(s, 1) < 0) {
return -1;
}
if (driverom_snapshot_read(s, drive_context[0]->drive) < 0) {
return -1;
}
if (driverom_snapshot_read(s, drive_context[1]->drive) < 0) {
return -1;
}
for (i = 0; i < 2; i++) {
drive = drive_context[i]->drive;
if (drive->type != DRIVE_TYPE_NONE) {
drive_enable(drive_context[i]);
drive->attach_clk = attach_clk[i];
drive->detach_clk = detach_clk[i];
drive->attach_detach_clk = attach_detach_clk[i];
}
}
for (i = 0; i < 2; i++) {
int side = 0;
drive = drive_context[i]->drive;
if (drive->type == DRIVE_TYPE_1570
|| drive->type == DRIVE_TYPE_1571
|| drive->type == DRIVE_TYPE_1571CR) {
if (half_track[i] > (DRIVE_HALFTRACKS_1571 + 1)) {
side = 1;
half_track[i] -= DRIVE_HALFTRACKS_1571;
}
}
drive_set_half_track(half_track[i], side, drive);
resources_set_int("MachineVideoStandard", sync_factor);
}
/* stop currently active drive sounds (bug #3539422)
* FIXME: when the drive sound emulation becomes more precise, we might
* want/need to save a snapshot of its current state too
*/
drive_sound_stop();
iec_update_ports_embedded();
drive_update_ui_status();
resources_get_int("DriveTrueEmulation", &drive_true_emulation);
if (vdrive_snapshot_module_read(s, drive_true_emulation ? 10 : 8) < 0) {
return -1;
}
return 0;
}
int drivecpu_snapshot_read_module(drive_context_t *drv, snapshot_t *s)
{
BYTE major, minor;
snapshot_module_t *m;
BYTE a, x, y, sp, status;
WORD pc;
drivecpu_context_t *cpu;
cpu = drv->cpu;
m = snapshot_module_open(s, drv->cpu->snap_module_name, &major, &minor);
if (m == NULL) {
return -1;
}
/* Before we start make sure all devices are reset. */
drivecpu_reset(drv);
/* XXX: Assumes `CLOCK' is the same size as a `DWORD'. */
if (0
|| SMR_DW(m, drv->clk_ptr) < 0
|| SMR_B(m, &a) < 0
|| SMR_B(m, &x) < 0
|| SMR_B(m, &y) < 0
|| SMR_B(m, &sp) < 0
|| SMR_W(m, &pc) < 0
|| SMR_B(m, &status) < 0
|| SMR_DW_UINT(m, &(cpu->last_opcode_info)) < 0
|| SMR_DW(m, &(cpu->last_clk)) < 0
|| SMR_DW(m, &(cpu->cycle_accum)) < 0
|| SMR_DW(m, &(cpu->last_exc_cycles)) < 0
|| SMR_DW(m, &(cpu->stop_clk)) < 0
) {
goto fail;
}
MOS6510_REGS_SET_A(&(cpu->cpu_regs), a);
MOS6510_REGS_SET_X(&(cpu->cpu_regs), x);
MOS6510_REGS_SET_Y(&(cpu->cpu_regs), y);
MOS6510_REGS_SET_SP(&(cpu->cpu_regs), sp);
MOS6510_REGS_SET_PC(&(cpu->cpu_regs), pc);
MOS6510_REGS_SET_STATUS(&(cpu->cpu_regs), status);
log_message(drv->drive->log, "RESET (For undump).");
interrupt_cpu_status_reset(cpu->int_status);
machine_drive_reset(drv);
if (interrupt_read_snapshot(cpu->int_status, m) < 0) {
goto fail;
}
if (drv->drive->type == DRIVE_TYPE_1540
|| drv->drive->type == DRIVE_TYPE_1541
|| drv->drive->type == DRIVE_TYPE_1541II
|| drv->drive->type == DRIVE_TYPE_1551
|| drv->drive->type == DRIVE_TYPE_1570
|| drv->drive->type == DRIVE_TYPE_1571
|| drv->drive->type == DRIVE_TYPE_1571CR
|| drv->drive->type == DRIVE_TYPE_2031) {
if (SMR_BA(m, drv->drive->drive_ram, 0x800) < 0) {
goto fail;
}
}
if (drv->drive->type == DRIVE_TYPE_1581
|| drv->drive->type == DRIVE_TYPE_2000
|| drv->drive->type == DRIVE_TYPE_4000) {
if (SMR_BA(m, drv->drive->drive_ram, 0x2000) < 0) {
goto fail;
}
}
if (drive_check_old(drv->drive->type)) {
if (SMR_BA(m, drv->drive->drive_ram, 0x1100) < 0) {
goto fail;
}
}
/* Update `*bank_base'. */
JUMP(reg_pc);
if (interrupt_read_new_snapshot(drv->cpu->int_status, m) < 0) {
goto fail;
}
return snapshot_module_close(m);
fail:
if (m != NULL) {
snapshot_module_close(m);
}
return -1;
}
static int tapelog_read_snapshot(struct snapshot_s *s)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
/* enable device */
set_tapelog_enabled(1, NULL);
m = snapshot_module_open(s, snap_module_name, &major_version, &minor_version);
if (m == NULL) {
return -1;
}
/* Do not accept versions higher than current */
if (major_version > SNAP_MAJOR || minor_version > SNAP_MINOR) {
snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION);
goto fail;
}
if (SMR_B(m, &tapelog_motor_out) < 0) {
goto fail;
}
/* new in 0.1 */
if (SNAPVAL(major_version, minor_version, 0, 1)) {
if (SMR_B(m, &tapelog_motor_in) < 0) {
goto fail;
}
} else {
tapelog_motor_in = 2;
}
if (0
|| SMR_B(m, &tapelog_sense_in) < 0
|| SMR_B(m, &tapelog_sense_out) < 0
|| SMR_B(m, &tapelog_write_out) < 0) {
goto fail;
}
/* new in 0.1 */
if (SNAPVAL(major_version, minor_version, 0, 1)) {
if (0
|| SMR_B(m, &tapelog_write_in) < 0
|| SMR_B(m, &tapelog_read_out) < 0) {
goto fail;
}
} else {
tapelog_write_in = 2;
tapelog_read_out = 2;
}
if (SMR_DW_UINT(m, &tapelog_read_in) < 0) {
goto fail;
}
return snapshot_module_close(m);
fail:
snapshot_module_close(m);
return -1;
}
