int freezemachine_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
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_B_INT(m, &rom_A14) < 0)
|| (SMR_B_INT(m, &roml_toggle) < 0)
|| (SMR_B_INT(m, &allow_toggle) < 0)
|| (SMR_BA(m, roml_banks, 0x4000) < 0)
|| (SMR_BA(m, romh_banks, 0x4000) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return freezemachine_common_attach();
}
int kcs_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
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_B_INT(m, &freeze_flag) < 0)
|| (SMR_B_INT(m, &config) < 0)
|| (SMR_BA(m, roml_banks, 0x2000) < 0)
|| (SMR_BA(m, romh_banks, 0x2000) < 0)
|| (SMR_BA(m, export_ram0, 0x2000) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return kcs_common_attach();
}
int megacart_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor);
if (m == NULL) {
return -1;
}
if (vmajor != VIC20CART_DUMP_VER_MAJOR) {
snapshot_module_close(m);
return -1;
}
if (!cart_ram) {
cart_ram = lib_malloc(CART_RAM_SIZE);
}
if (!cart_nvram) {
cart_nvram = lib_malloc(CART_NVRAM_SIZE);
}
if (!cart_rom) {
cart_rom = lib_malloc(CART_ROM_SIZE);
}
if (0
|| (SMR_B(m, &bank_low_reg) < 0)
|| (SMR_B(m, &bank_high_reg) < 0)
|| (SMR_B_INT(m, &oe_flop) < 0)
|| (SMR_B_INT(m, &nvram_en_flop) < 0)
|| (SMR_BA(m, cart_ram, CART_RAM_SIZE) < 0)
|| (SMR_BA(m, cart_rom, CART_ROM_SIZE) < 0)
|| (SMR_BA(m, cart_nvram, CART_NVRAM_SIZE) < 0)) {
snapshot_module_close(m);
lib_free(cart_ram);
lib_free(cart_nvram);
lib_free(cart_rom);
cart_ram = NULL;
cart_nvram = NULL;
cart_rom = NULL;
return -1;
}
snapshot_module_close(m);
cart_rom_low = cart_rom;
cart_rom_high = cart_rom + 0x100000;
reset_mode = BUTTON_RESET;
mem_cart_blocks = VIC_CART_RAM123 |
VIC_CART_BLK1 | VIC_CART_BLK2 | VIC_CART_BLK3 | VIC_CART_BLK5 |
VIC_CART_IO2 | VIC_CART_IO3;
mem_initialize_memory();
return 0;
}
int rtc72421_read_snapshot(rtc_72421_t *context, snapshot_t *s)
{
DWORD latch_lo = 0;
DWORD latch_hi = 0;
DWORD offset_lo = 0;
DWORD offset_hi = 0;
DWORD old_offset_lo = 0;
DWORD old_offset_hi = 0;
BYTE vmajor, vminor;
snapshot_module_t *m;
m = snapshot_module_open(s, snap_module_name, &vmajor, &vminor);
if (m == NULL) {
return -1;
}
/* Do not accept versions higher than current */
if (vmajor > SNAP_MAJOR || vminor > SNAP_MINOR) {
snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION);
goto fail;
}
if (0
|| SMR_B_INT(m, &context->stop) < 0
|| SMR_B_INT(m, &context->hour24) < 0
|| SMR_DW(m, &latch_hi) < 0
|| SMR_DW(m, &latch_lo) < 0
|| SMR_DW(m, &offset_hi) < 0
|| SMR_DW(m, &offset_lo) < 0
|| SMR_DW(m, &old_offset_hi) < 0
|| SMR_DW(m, &old_offset_lo) < 0
|| SMR_STR(m, &context->device) < 0) {
goto fail;
}
#if (SIZE_OF_TIME_T == 8)
context->latch = (time_t)(latch_hi) << 32;
context->latch |= latch_lo;
context->offset = (time_t)(offset_hi) << 32;
context->offset |= offset_lo;
context->old_offset = (time_t)(old_offset_hi) << 32;
context->old_offset |= old_offset_lo;
#else
context->latch = latch_lo;
context->offset = offset_lo;
context->old_offset = old_offset_lo;
#endif
return snapshot_module_close(m);
fail:
snapshot_module_close(m);
return -1;
}
int c64_glue_snapshot_read_module(snapshot_t *s)
{
BYTE major_version, minor_version;
int snap_type, snap_alarm_active;
snapshot_module_t *m;
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(LOG_ERR,
"GlueLogic: Snapshot module version (%d.%d) newer than %d.%d.",
major_version, minor_version,
SNAP_MAJOR, SNAP_MINOR);
goto fail;
}
if (0
|| SMR_B_INT(m, &snap_type) < 0
|| SMR_B_INT(m, &old_vbank) < 0
|| SMR_B_INT(m, &snap_alarm_active) < 0) {
goto fail;
}
if (snap_type != glue_logic_type) {
log_warning(LOG_DEFAULT,
"GlueLogic: Snapshot type %i differs from selected type %i, changing.",
snap_type, glue_logic_type);
glue_logic_type = snap_type;
}
if (glue_alarm_active) {
glue_alarm_unset();
}
glue_alarm_active = snap_alarm_active;
if (glue_alarm_active && (glue_logic_type == 1)) {
glue_alarm_set();
}
snapshot_module_close(m);
return 0;
fail:
if (m != NULL) {
snapshot_module_close(m);
}
return -1;
}
int c64_glue_snapshot_read_module(snapshot_t *s)
{
BYTE major_version, minor_version;
int snap_type, snap_alarm_active;
snapshot_module_t *m;
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 (0
|| SMR_B_INT(m, &snap_type) < 0
|| SMR_B_INT(m, &old_vbank) < 0
|| SMR_B_INT(m, &snap_alarm_active) < 0) {
goto fail;
}
if (snap_type != glue_logic_type) {
log_warning(LOG_DEFAULT,
"GlueLogic: Snapshot type %i differs from selected type %i, changing.",
snap_type, glue_logic_type);
glue_logic_type = snap_type;
}
if (glue_alarm_active) {
glue_alarm_unset();
}
glue_alarm_active = snap_alarm_active;
if (glue_alarm_active && (glue_logic_type == 1)) {
glue_alarm_set();
}
snapshot_module_close(m);
return 0;
fail:
if (m != NULL) {
snapshot_module_close(m);
}
return -1;
}
int expert_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
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;
}
expert_ram = lib_malloc(EXPERT_RAM_SIZE);
if (0
|| (SMR_B_INT(m, &cartmode) < 0)
|| (SMR_B_INT(m, &expert_register_enabled) < 0)
|| (SMR_B_INT(m, &expert_ram_writeable) < 0)
|| (SMR_B_INT(m, &expert_ramh_enabled) < 0)
|| (SMR_BA(m, expert_ram, EXPERT_RAM_SIZE) < 0)) {
snapshot_module_close(m);
lib_free(expert_ram);
expert_ram = NULL;
return -1;
}
snapshot_module_close(m);
expert_filetype = 0;
expert_write_image = 0;
expert_enabled = 1;
/* FIXME: ugly code duplication to avoid cart_config_changed calls */
expert_io1_list_item = io_source_register(&expert_io1_device);
if (c64export_add(&export_res) < 0) {
lib_free(expert_ram);
expert_ram = NULL;
io_source_unregister(expert_io1_list_item);
expert_io1_list_item = NULL;
expert_enabled = 0;
return -1;
}
return 0;
}
static int userport_rtc_read_snapshot_module(snapshot_t *s)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
/* enable device */
set_userport_rtc_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_INT(m, &read_line_active) < 0) {
goto fail;
}
snapshot_module_close(m);
return rtc58321a_read_snapshot(rtc58321a_context, s);
fail:
snapshot_module_close(m);
return -1;
}
int dinamic_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
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_B_INT(m, &currbank) < 0)
|| (SMR_BA(m, roml_banks, 0x2000 * 16) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return dinamic_common_attach();
}
int actionreplay2_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
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_B_INT(m, &ar_enabled) < 0)
|| (SMR_DW_INT(m, &ar_cap_enable) < 0)
|| (SMR_DW_INT(m, &ar_cap_disable) < 0)
|| (SMR_BA(m, roml_banks, 0x4000) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return actionreplay2_common_attach();
}
static int paperclip64_read_snapshot(struct snapshot_s *s, int port)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
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 (0
|| SMR_DW_INT(m, &counter) < 0
|| SMR_B(m, &command) < 0
|| SMR_B_INT(m, &state) < 0) {
goto fail;
}
return snapshot_module_close(m);
fail:
snapshot_module_close(m);
return -1;
}
int freezemachine_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
m = snapshot_module_open(s, snap_module_name, &vmajor, &vminor);
if (m == NULL) {
return -1;
}
/* Do not accept versions higher than current */
if (vmajor > SNAP_MAJOR || vminor > SNAP_MINOR) {
snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION);
goto fail;
}
if (0
|| SMR_B_INT(m, &rom_A14) < 0
|| SMR_B_INT(m, &roml_toggle) < 0) {
goto fail;
}
/* new in 0.1 */
if (SNAPVAL(vmajor, vminor, 0, 1)) {
if (SMR_B_INT(m, &allow_toggle) < 0) {
goto fail;
}
} else {
allow_toggle = 0;
}
if (0
|| SMR_BA(m, roml_banks, 0x4000) < 0
|| SMR_BA(m, romh_banks, 0x4000) < 0) {
goto fail;
}
snapshot_module_close(m);
return freezemachine_common_attach();
fail:
snapshot_module_close(m);
return -1;
}
int freezeframe_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
m = snapshot_module_open(s, snap_module_name, &vmajor, &vminor);
if (m == NULL) {
return -1;
}
/* Do not accept versions higher than current */
if (vmajor > SNAP_MAJOR || vminor > SNAP_MINOR) {
snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION);
goto fail;
}
/* new in 0.1 */
if (SNAPVAL(vmajor, vminor, 0, 1)) {
if (0
|| SMR_B_INT(m, &freezeframe_rom_8000) < 0
|| SMR_B_INT(m, &freezeframe_rom_e000) < 0) {
goto fail;
}
} else {
freezeframe_rom_8000 = 0;
freezeframe_rom_e000 = 0;
}
if (SMR_BA(m, roml_banks, FREEZE_FRAME_CART_SIZE) < 0) {
goto fail;
}
snapshot_module_close(m);
memcpy(romh_banks, roml_banks, FREEZE_FRAME_CART_SIZE);
return freezeframe_common_attach();
fail:
snapshot_module_close(m);
return -1;
}
int easyflash_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
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_B_INT(m, &easyflash_jumper) < 0)
|| (SMR_B(m, &easyflash_register_00) < 0)
|| (SMR_B(m, &easyflash_register_02) < 0)
|| (SMR_BA(m, easyflash_ram, 256) < 0)
|| (SMR_BA(m, roml_banks, 0x80000) < 0)
|| (SMR_BA(m, romh_banks, 0x80000) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
easyflash_state_low = lib_malloc(sizeof(flash040_context_t));
easyflash_state_high = lib_malloc(sizeof(flash040_context_t));
flash040core_init(easyflash_state_low, maincpu_alarm_context, FLASH040_TYPE_B, roml_banks);
flash040core_init(easyflash_state_high, maincpu_alarm_context, FLASH040_TYPE_B, romh_banks);
if (0
|| (flash040core_snapshot_read_module(s, easyflash_state_low, FLASH_SNAP_MODULE_NAME) < 0)
|| (flash040core_snapshot_read_module(s, easyflash_state_low, FLASH_SNAP_MODULE_NAME) < 0)) {
flash040core_shutdown(easyflash_state_low);
flash040core_shutdown(easyflash_state_high);
lib_free(easyflash_state_low);
lib_free(easyflash_state_high);
return -1;
}
easyflash_common_attach("dummy");
/* remove dummy filename, set filetype to none */
lib_free(easyflash_filename);
easyflash_filename = NULL;
easyflash_filetype = 0;
return 0;
}
int mc6821core_snapshot_read_data(mc6821_state *ctx, snapshot_module_t *m)
{
if (m == NULL) {
return -1;
}
if (0
|| (SMR_B(m, &ctx->ctrlA) < 0)
|| (SMR_B(m, &ctx->ctrlB) < 0)
|| (SMR_B(m, &ctx->dataA) < 0)
|| (SMR_B(m, &ctx->dataB) < 0)
|| (SMR_B(m, &ctx->ddrA) < 0)
|| (SMR_B(m, &ctx->ddrB) < 0)
|| (SMR_B_INT(m, &ctx->CA2) < 0)
|| (SMR_B_INT(m, &ctx->CA2state) < 0)
|| (SMR_B_INT(m, &ctx->CB2) < 0)
|| (SMR_B_INT(m, &ctx->CB2state) < 0)) {
snapshot_module_close(m);
return -1;
}
return 0;
}
int joyport_snapshot_read_module(struct snapshot_s *s, int port)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
int temp_joy_port;
char snapshot_name[16];
sprintf(snapshot_name, "JOYPORT%d", port);
m = snapshot_module_open(s, snapshot_name, &major_version, &minor_version);
if (m == NULL) {
return -1;
}
if (major_version != DUMP_VER_MAJOR || minor_version != DUMP_VER_MINOR) {
snapshot_module_close(m);
return -1;
}
/* load device id */
if (SMR_B_INT(m, &temp_joy_port) < 0) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
/* enable device */
joyport_set_device(port, temp_joy_port);
/* load device snapshot */
switch (joy_port[port]) {
case JOYPORT_ID_NONE:
break;
default:
if (joyport_device[joy_port[port]].read_snapshot) {
if (joyport_device[joy_port[port]].read_snapshot(s, port) < 0) {
return -1;
}
}
break;
}
return 0;
}
int sidcart_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
int tmp_address;
int tmp_clock;
m = snapshot_module_open(s, snap_module_name, &vmajor, &vminor);
if (m == NULL) {
return -1;
}
/* Do not allow versions higher than current */
if (vmajor > SNAP_MAJOR || vminor > SNAP_MINOR) {
snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION);
goto fail;
}
set_sidcart_enabled(0, NULL);
if (0
|| SMR_W_INT(m, &tmp_address) < 0
|| SMR_B_INT(m, &tmp_clock) < 0) {
goto fail;
}
snapshot_module_close(m);
set_sid_address(tmp_address, NULL);
set_sid_clock(tmp_clock, NULL);
set_sidcart_enabled(1, NULL);
return sid_snapshot_read_module(s);
fail:
snapshot_module_close(m);
return -1;
}
int rex_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
m = snapshot_module_open(s, snap_module_name, &vmajor, &vminor);
if (m == NULL) {
return -1;
}
/* Do not accept versions higher than current */
if ((vmajor != SNAP_MAJOR) || (vminor != SNAP_MINOR)) {
snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION);
goto fail;
}
/* new in 0.1 */
if (SNAPVAL(vmajor, vminor, 0, 1)) {
if (SMR_B_INT(m, &rex_active) < 0) {
goto fail;
}
} else {
rex_active = 0;
}
if (SMR_BA(m, roml_banks, 0x2000 * 64) < 0) {
goto fail;
}
snapshot_module_close(m);
return rex_common_attach();
fail:
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 tape_snapshot_read_module(snapshot_t *s)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
unsigned int snap_type;
char snap_module_name[] = "TAPE";
tap_t *tap;
t64_t *t64;
if (tape_snapshot_read_tapimage_module(s) < 0
|| tape_snapshot_read_t64image_module(s) < 0)
return -1;
m = snapshot_module_open(s, snap_module_name,
&major_version, &minor_version);
if (m == NULL) {
/* no tape attached */
tape_image_detach_internal(1);
return 0;
}
if (0
|| SMR_B_INT(m, (int *)&tape_image_dev1->read_only) < 0
|| SMR_B_INT(m, (int *)&snap_type) < 0)
{
snapshot_module_close(m);
return -1;
}
if (snap_type != tape_image_dev1->type) {
/* attached image type is not correct */
log_error(tape_snapshot_log,
"No tape image attached or type not correct.");
snapshot_module_close(m);
return -1;
}
switch (tape_image_dev1->type) {
case TAPE_TYPE_T64:
t64 = (t64_t*)tape_image_dev1->data;
break;
case TAPE_TYPE_TAP:
tap = (tap_t*)tape_image_dev1->data;
if (tap == NULL
|| SMR_DW(m, (DWORD*)&tap->size) < 0
|| SMR_B(m, &tap->version) < 0
|| SMR_B(m, &tap->system) < 0
|| SMR_DW(m, (DWORD*)&tap->current_file_seek_position) < 0
|| SMR_DW(m, (DWORD*)&tap->offset) < 0
|| SMR_DW(m, (DWORD*)&tap->cycle_counter) < 0
|| SMR_DW(m, (DWORD*)&tap->cycle_counter_total) < 0
|| SMR_DW(m, (DWORD*)&tap->counter) < 0
|| SMR_DW(m, (DWORD*)&tap->mode) < 0
|| SMR_DW(m, (DWORD*)&tap->read_only) < 0
|| SMR_DW(m, (DWORD*)&tap->has_changed) < 0)
{
snapshot_module_close(m);
return -1;
}
break;
default:
break;
}
snapshot_module_close(m);
if (datasette_read_snapshot(s) < 0)
return -1;
return 0;
}
int vicii_snapshot_read_module(snapshot_t *s)
{
BYTE major_version, minor_version;
int i;
snapshot_module_t *m;
BYTE color_ram[0x400];
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(vicii.log,
"Snapshot module version (%d.%d) newer than %d.%d.",
major_version, minor_version,
SNAP_MAJOR, SNAP_MINOR);
goto fail;
}
/* FIXME: initialize changes? */
if (0
/* AllowBadLines */
|| SMR_B_INT(m, &vicii.allow_bad_lines) < 0
/* BadLine */
|| SMR_B_INT(m, &vicii.bad_line) < 0
/* Blank */
|| SMR_B_INT(m, &vicii.raster.blank_enabled) < 0
/* ColorBuf */
|| SMR_BA(m, vicii.cbuf, 40) < 0
/* ColorRam */
|| SMR_BA(m, color_ram, 1024) < 0
/* IdleState */
|| SMR_B_INT(m, &vicii.idle_state) < 0
/* LPTrigger */
|| SMR_B_INT(m, &vicii.light_pen.triggered) < 0
/* LPX */
|| SMR_B_INT(m, &vicii.light_pen.x) < 0
/* LPY */
|| SMR_B_INT(m, &vicii.light_pen.y) < 0
/* MatrixBuf */
|| SMR_BA(m, vicii.vbuf, 40) < 0
/* NewSpriteDmaMask */
|| SMR_B(m, &vicii.raster.sprite_status->new_dma_msk) < 0) {
goto fail;
}
mem_color_ram_from_snapshot(color_ram);
{
DWORD RamBase;
if (SMR_DW(m, &RamBase) < 0) {
goto fail;
}
vicii.ram_base_phi1 = mem_ram + RamBase;
}
/* Read the current raster line and the current raster cycle. As they
are a function of `clk', this is just a sanity check. */
{
WORD RasterLine;
BYTE RasterCycle;
if (SMR_B(m, &RasterCycle) < 0
|| SMR_W(m, &RasterLine) < 0) {
goto fail;
}
if (RasterCycle != (BYTE)VICII_RASTER_CYCLE(maincpu_clk)) {
log_error(vicii.log,
"Not matching raster cycle (%d) in snapshot; should be %d.",
RasterCycle, VICII_RASTER_CYCLE(maincpu_clk));
goto fail;
}
if (RasterLine != (WORD)VICII_RASTER_Y(maincpu_clk)) {
log_error(vicii.log,
"VIC-II: Not matching raster line (%d) in snapshot; should be %d.",
RasterLine, VICII_RASTER_Y(maincpu_clk));
goto fail;
}
}
for (i = 0; i < 0x40; i++) {
if (SMR_B(m, &vicii.regs[i]) < 0 /* Registers */) {
goto fail;
}
}
if (0
/* SbCollMask */
|| SMR_B(m, &vicii.sprite_background_collisions) < 0
/* SpriteDmaMask */
|| SMR_B(m, &vicii.raster.sprite_status->dma_msk) < 0
/* SsCollMask */
|| SMR_B(m, &vicii.sprite_sprite_collisions) < 0
/* VBank */
|| SMR_W_INT(m, &vicii.vbank_phi1) < 0
/* Vc */
|| SMR_W_INT(m, &vicii.mem_counter) < 0
/* VcInc */
|| SMR_B_INT(m, &vicii.mem_counter_inc) < 0
/* VcBase */
|| SMR_W_INT(m, &vicii.memptr) < 0
/* VideoInt */
|| SMR_B_INT(m, &vicii.irq_status) < 0) {
goto fail;
}
for (i = 0; i < 8; i++) {
if (0
/* SpriteXMemPtr */
|| SMR_B_INT(m, &vicii.raster.sprite_status->sprites[i].memptr) < 0
/* SpriteXMemPtrInc */
|| SMR_B_INT(m, &vicii.raster.sprite_status->sprites[i].memptr_inc) < 0
/* SpriteXExpFlipFlop */
|| SMR_B_INT(m, &vicii.raster.sprite_status->sprites[i].exp_flag) < 0
) {
goto fail;
}
}
/* FIXME: Recalculate alarms and derived values. */
#if 1
{
/*
We cannot use vicii_irq_set_raster_line as this would delay
an alarm on line 0 for one frame
*/
unsigned int line = vicii.regs[0x12] | ((vicii.regs[0x11] & 0x80) << 1);
if (line < (unsigned int)vicii.screen_height) {
vicii.raster_irq_clk = (VICII_LINE_START_CLK(maincpu_clk)
+ VICII_RASTER_IRQ_DELAY - INTERRUPT_DELAY
+ (vicii.cycles_per_line * line));
/* Raster interrupts on line 0 are delayed by 1 cycle. */
if (line == 0) {
vicii.raster_irq_clk++;
}
alarm_set(vicii.raster_irq_alarm, vicii.raster_irq_clk);
} else {
vicii.raster_irq_clk = CLOCK_MAX;
alarm_unset(vicii.raster_irq_alarm);
}
vicii.raster_irq_line = line;
}
#else
vicii_irq_set_raster_line(vicii.regs[0x12]
| ((vicii.regs[0x11] & 0x80) << 1));
#endif
/* compatibility with older versions */
vicii.ram_base_phi2 = vicii.ram_base_phi1;
vicii.vbank_phi2 = vicii.vbank_phi1;
vicii_update_memory_ptrs(VICII_RASTER_CYCLE(maincpu_clk));
/* Update sprite parameters. We had better do this manually, or the
VIC-II emulation could be quite upset. */
{
BYTE msk;
for (i = 0, msk = 0x1; i < 8; i++, msk <<= 1) {
raster_sprite_t *sprite;
int tmp;
sprite = vicii.raster.sprite_status->sprites + i;
/* X/Y coordinates. */
tmp = vicii.regs[i * 2] + ((vicii.regs[0x10] & msk) ? 0x100 : 0);
/* (-0xffff makes sure it's updated NOW.) */
vicii_sprites_set_x_position(i, tmp, -0xffff);
sprite->y = (int)vicii.regs[i * 2 + 1];
sprite->x_expanded = (int)(vicii.regs[0x1d] & msk);
sprite->y_expanded = (int)(vicii.regs[0x17] & msk);
sprite->multicolor = (int)(vicii.regs[0x1c] & msk);
sprite->in_background = (int)(vicii.regs[0x1b] & msk);
sprite->color = (int) vicii.regs[0x27 + i] & 0xf;
sprite->dma_flag = (int)(vicii.raster.sprite_status->new_dma_msk & msk);
}
}
vicii.sprite_fetch_msk = vicii.raster.sprite_status->new_dma_msk;
vicii.sprite_fetch_clk = VICII_LINE_START_CLK(maincpu_clk)
+ vicii.sprite_fetch_cycle
- vicii.cycles_per_line;
/* calculate the sprite_fetch_idx */
{
const vicii_sprites_fetch_t *sf;
sf = vicii_sprites_fetch_table[vicii.sprite_fetch_msk];
i = 0;
while (sf[i].cycle >= 0 && sf[i].cycle + vicii.sprite_fetch_cycle <= vicii.cycles_per_line) {
i++;
}
vicii.sprite_fetch_idx = i;
}
vicii.raster.xsmooth = vicii.regs[0x16] & 0x7;
vicii.raster.sprite_xsmooth = vicii.regs[0x16] & 0x7;
vicii.raster.ysmooth = vicii.regs[0x11] & 0x7;
vicii.raster.current_line = VICII_RASTER_Y(maincpu_clk); /* FIXME? */
vicii.raster.sprite_status->visible_msk = vicii.regs[0x15];
/* Update colors. */
vicii.raster.border_color = vicii.regs[0x20] & 0xf;
vicii.raster.background_color = vicii.regs[0x21] & 0xf;
vicii.ext_background_color[0] = vicii.regs[0x22] & 0xf;
vicii.ext_background_color[1] = vicii.regs[0x23] & 0xf;
vicii.ext_background_color[2] = vicii.regs[0x24] & 0xf;
vicii.raster.sprite_status->mc_sprite_color_1 = vicii.regs[0x25] & 0xf;
vicii.raster.sprite_status->mc_sprite_color_2 = vicii.regs[0x26] & 0xf;
vicii.raster.blank = !(vicii.regs[0x11] & 0x10);
if (VICII_IS_ILLEGAL_MODE(vicii.raster.video_mode)) {
vicii.raster.idle_background_color = 0;
vicii.force_black_overscan_background_color = 1;
} else {
vicii.raster.idle_background_color
= vicii.raster.background_color;
vicii.force_black_overscan_background_color = 0;
}
if (vicii.regs[0x11] & 0x8) {
vicii.raster.display_ystart = vicii.row_25_start_line;
vicii.raster.display_ystop = vicii.row_25_stop_line;
} else {
vicii.raster.display_ystart = vicii.row_24_start_line;
vicii.raster.display_ystop = vicii.row_24_stop_line;
}
if (vicii.regs[0x16] & 0x8) {
vicii.raster.display_xstart = VICII_40COL_START_PIXEL;
vicii.raster.display_xstop = VICII_40COL_STOP_PIXEL;
} else {
vicii.raster.display_xstart = VICII_38COL_START_PIXEL;
vicii.raster.display_xstop = VICII_38COL_STOP_PIXEL;
}
/* `vicii.raster.draw_idle_state', `vicii.raster.open_right_border' and
`vicii.raster.open_left_border' should be needed, but they would only
affect the current vicii.raster line, and would not cause any
difference in timing. So who cares. */
/* FIXME: `vicii.ycounter_reset_checked'? */
/* FIXME: `vicii.force_display_state'? */
vicii.memory_fetch_done = 0; /* FIXME? */
vicii_update_video_mode(VICII_RASTER_CYCLE(maincpu_clk));
vicii.draw_clk = maincpu_clk + (vicii.draw_cycle - VICII_RASTER_CYCLE(maincpu_clk));
vicii.last_emulate_line_clk = vicii.draw_clk - vicii.cycles_per_line;
alarm_set(vicii.raster_draw_alarm, vicii.draw_clk);
{
DWORD dw;
BYTE b;
if (0
|| SMR_DW(m, &dw) < 0 /* FetchEventTick */
|| SMR_B(m, &b) < 0 /* FetchEventType */
) {
goto fail;
}
vicii.fetch_clk = maincpu_clk + dw;
vicii.fetch_idx = b;
alarm_set(vicii.raster_fetch_alarm, vicii.fetch_clk);
}
if (vicii.irq_status & 0x80) {
interrupt_restore_irq(maincpu_int_status, vicii.int_num, 1);
}
/* added in version 1.1 of snapshot format */
if (minor_version > 0) {
DWORD RamBase;
if (0
|| SMR_DW(m, &RamBase) < 0
|| SMR_W_INT(m, &vicii.vbank_phi2) < 0 /* VBank */
) {
goto fail;
}
vicii.ram_base_phi2 = mem_ram + RamBase;
vicii_update_memory_ptrs(VICII_RASTER_CYCLE(maincpu_clk));
}
raster_force_repaint(&vicii.raster);
snapshot_module_close(m);
return 0;
fail:
if (m != NULL) {
snapshot_module_close(m);
}
return -1;
}
int tapeport_snapshot_read_module(snapshot_t *s)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
int amount = 0;
char **detach_resource_list = NULL;
tapeport_device_list_t *current = tapeport_head.next;
int *devices = NULL;
tapeport_snapshot_list_t *c = NULL;
int i = 0;
/* detach all tapeport devices */
while (current) {
++amount;
current = current->next;
}
if (amount) {
detach_resource_list = lib_malloc(sizeof(char *) * (amount + 1));
memset(detach_resource_list, 0, sizeof(char *) * (amount + 1));
current = tapeport_head.next;
while (current) {
detach_resource_list[i++] = current->device->resource;
current = current->next;
}
for (i = 0; i < amount; ++i) {
resources_set_int(detach_resource_list[i], 0);
}
lib_free(detach_resource_list);
}
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 (0
|| SMR_B_INT(m, &tapeport_active) < 0
|| SMR_B_INT(m, &amount) < 0) {
goto fail;
}
if (amount) {
devices = lib_malloc(sizeof(int) * (amount + 1));
for (i = 0; i < amount; ++i) {
if (SMR_B_INT(m, &devices[i]) < 0) {
lib_free(devices);
goto fail;
}
}
snapshot_module_close(m);
for (i = 0; i < amount; ++i) {
c = tapeport_snapshot_head.next;
while (c) {
if (c->snapshot->id == devices[i]) {
if (c->snapshot->read_snapshot) {
if (c->snapshot->read_snapshot(s) < 0) {
lib_free(devices);
return -1;
}
}
}
c = c->next;
}
}
return 0;
}
return snapshot_module_close(m);
fail:
snapshot_module_close(m);
return -1;
}
int ted_snapshot_read_module(snapshot_t *s)
{
BYTE major_version, minor_version;
int i;
snapshot_module_t *m;
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(ted.log,
"Snapshot module version (%d.%d) newer than %d.%d.",
major_version, minor_version,
SNAP_MAJOR, SNAP_MINOR);
goto fail;
}
/* FIXME: initialize changes? */
if (0
|| SMR_DW(m, &ted.last_emulate_line_clk) < 0
/* AllowBadLines */
|| SMR_B_INT(m, &ted.allow_bad_lines) < 0
/* BadLine */
|| SMR_B_INT(m, &ted.bad_line) < 0
/* Blank */
|| SMR_B_INT(m, &ted.raster.blank_enabled) < 0
/* ColorBuf */
|| SMR_BA(m, ted.cbuf, 40) < 0
/* IdleState */
|| SMR_B_INT(m, &ted.idle_state) < 0
/* MatrixBuf */
|| SMR_BA(m, ted.vbuf, 40) < 0
) {
goto fail;
}
/* Read the current raster line and the current raster cycle. As they
are a function of `clk', this is just a sanity check. */
{
WORD RasterLine;
BYTE RasterCycle;
if (SMR_B(m, &RasterCycle) < 0 || SMR_W(m, &RasterLine) < 0) {
goto fail;
}
DBG(("TED read snapshot at clock: %d cycle: %d (%d) tedline: %d (%d) rasterline: %d\n",
maincpu_clk, TED_RASTER_CYCLE(maincpu_clk), RasterCycle, TED_RASTER_Y(maincpu_clk),
RasterLine, ted.raster.current_line));
if (RasterCycle != (BYTE)TED_RASTER_CYCLE(maincpu_clk)) {
log_error(ted.log,
"Not matching raster cycle (%d) in snapshot; should be %d.",
RasterCycle, TED_RASTER_CYCLE(maincpu_clk));
goto fail;
}
if (RasterLine != (WORD)TED_RASTER_Y(maincpu_clk)) {
log_error(ted.log,
"Not matching raster line (%d) in snapshot; should be %d.",
RasterLine, TED_RASTER_Y(maincpu_clk));
goto fail;
}
}
for (i = 0; i < 0x40; i++) {
if (SMR_B(m, &ted.regs[i]) < 0 /* Registers */) {
goto fail;
}
}
if (0
|| SMR_DW_INT(m, (int*)&ted.ted_raster_counter) < 0
/* Vc */
|| SMR_W_INT(m, &ted.mem_counter) < 0
/* VcInc */
|| SMR_B_INT(m, &ted.mem_counter_inc) < 0
/* VcBase */
|| SMR_W_INT(m, &ted.memptr) < 0
/* VideoInt */
|| SMR_B_INT(m, &ted.irq_status) < 0) {
goto fail;
}
/* FIXME: Recalculate alarms and derived values. */
ted_irq_set_raster_line(ted.regs[0x0b] | ((ted.regs[0x0a] & 1) << 8));
ted_update_memory_ptrs(TED_RASTER_CYCLE(maincpu_clk));
ted.raster.xsmooth = ted.regs[0x07] & 0x7;
ted.raster.ysmooth = ted.regs[0x06] & 0x7;
ted.raster.current_line = TED_RASTER_Y(maincpu_clk); /* FIXME? */
/* Update colors. */
ted.raster.border_color = ted.regs[0x19];
ted.raster.background_color = ted.regs[0x15];
ted.ext_background_color[0] = ted.regs[0x16];
ted.ext_background_color[1] = ted.regs[0x17];
ted.ext_background_color[2] = ted.regs[0x18];
ted.raster.blank = !(ted.regs[0x06] & 0x10);
if (TED_IS_ILLEGAL_MODE (ted.raster.video_mode)) {
ted.raster.idle_background_color = 0;
ted.force_black_overscan_background_color = 1;
} else {
ted.raster.idle_background_color = ted.raster.background_color;
ted.force_black_overscan_background_color = 0;
}
if (ted.regs[0x06] & 0x8) {
ted.raster.display_ystart = ted.row_25_start_line;
ted.raster.display_ystop = ted.row_25_stop_line;
} else {
ted.raster.display_ystart = ted.row_24_start_line;
ted.raster.display_ystop = ted.row_24_stop_line;
}
if (ted.regs[0x07] & 0x8) {
ted.raster.display_xstart = TED_40COL_START_PIXEL;
ted.raster.display_xstop = TED_40COL_STOP_PIXEL;
} else {
ted.raster.display_xstart = TED_38COL_START_PIXEL;
ted.raster.display_xstop = TED_38COL_STOP_PIXEL;
}
/* `ted.raster.draw_idle_state', `ted.raster.open_right_border' and
`ted.raster.open_left_border' should be needed, but they would only
affect the current ted.raster line, and would not cause any
difference in timing. So who cares. */
/* FIXME: `ted.ycounter_reset_checked'? */
/* FIXME: `ted.force_display_state'? */
ted.memory_fetch_done = 0; /* FIXME? */
ted_update_video_mode(TED_RASTER_CYCLE(maincpu_clk));
ted.draw_clk = maincpu_clk + (ted.draw_cycle - TED_RASTER_CYCLE(maincpu_clk));
ted.last_emulate_line_clk = ted.draw_clk - ted.cycles_per_line;
alarm_set(ted.raster_draw_alarm, ted.draw_clk);
{
DWORD dw;
if (SMR_DW(m, &dw) < 0) { /* FetchEventTick */
goto fail;
}
ted.fetch_clk = maincpu_clk + dw;
alarm_set(ted.raster_fetch_alarm, ted.fetch_clk);
}
if (ted.irq_status & 0x80) {
interrupt_restore_irq(maincpu_int_status, ted.int_num, 1);
}
raster_force_repaint(&ted.raster);
DBG(("TED: snapshot loaded.\n"));
return 0;
fail:
if (m != NULL) {
snapshot_module_close(m);
}
log_error(ted.log, "could not load TED snapshot.");
return -1;
}
int shortbus_read_snapshot_module(snapshot_t *s)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
int active_devices;
int devices[4];
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 (0
|| SMR_B_INT(m, &active_devices) < 0
|| SMR_B_INT(m, &devices[0]) < 0
|| SMR_B_INT(m, &devices[1]) < 0
|| SMR_B_INT(m, &devices[2]) < 0
|| SMR_B_INT(m, &devices[3]) < 0) {
goto fail;
}
snapshot_module_close(m);
if (active_devices) {
if (devices[0]) {
if (shortbus_digimax_read_snapshot_module(s) < 0) {
return -1;
}
}
#ifdef HAVE_PCAP
if (devices[2]) {
if (shortbus_etfe_read_snapshot_module(s) < 0) {
return -1;
}
}
#endif
/* TODO */
#if 0
if (devices[1]) {
if (shortbus_duart_read_snapshot_module(s) < 0) {
return -1;
}
}
if (devices[3]) {
if (shortbus_eth64_read_snapshot_module(s) < 0) {
return -1;
}
}
#endif
}
return 0;
fail:
snapshot_module_close(m);
return -1;
}
int ds1216e_read_snapshot(rtc_ds1216e_t *context, snapshot_t *s)
{
DWORD latch_lo = 0;
DWORD latch_hi = 0;
DWORD offset_lo = 0;
DWORD offset_hi = 0;
DWORD old_offset_lo = 0;
DWORD old_offset_hi = 0;
BYTE vmajor, vminor;
snapshot_module_t *m;
m = snapshot_module_open(s, snap_module_name, &vmajor, &vminor);
if (m == NULL) {
return -1;
}
/* Do not accept versions higher than current */
if (vmajor > SNAP_MAJOR || vminor > SNAP_MINOR) {
snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION);
goto fail;
}
if (0
|| SMR_B_INT(m, &context->reset) < 0
|| SMR_B_INT(m, &context->inactive) < 0
|| SMR_B_INT(m, &context->hours12) < 0
|| SMR_B_INT(m, &context->pattern_pos) < 0
|| SMR_B_INT(m, &context->pattern_ignore) < 0
|| SMR_B_INT(m, &context->output) < 0
|| SMR_B_INT(m, &context->output_pos) < 0
|| SMR_DW(m, &latch_hi) < 0
|| SMR_DW(m, &latch_lo) < 0
|| SMR_DW(m, &offset_hi) < 0
|| SMR_DW(m, &offset_lo) < 0
|| SMR_DW(m, &old_offset_hi) < 0
|| SMR_DW(m, &old_offset_lo) < 0
|| SMR_BA(m, context->clock_regs, DS1216E_REG_SIZE) < 0
|| SMR_BA(m, context->old_clock_regs, DS1216E_REG_SIZE) < 0
|| SMR_BA(m, context->clock_regs_changed, DS1216E_REG_SIZE) < 0
|| SMR_STR(m, &context->device) < 0) {
goto fail;
}
#if (SIZE_OF_TIME_T == 8)
context->latch = (time_t)(latch_hi) << 32;
context->latch |= latch_lo;
context->offset = (time_t)(offset_hi) << 32;
context->offset |= offset_lo;
context->old_offset = (time_t)(old_offset_hi) << 32;
context->old_offset |= old_offset_lo;
#else
context->latch = latch_lo;
context->offset = offset_lo;
context->old_offset = old_offset_lo;
#endif
return snapshot_module_close(m);
fail:
snapshot_module_close(m);
return -1;
}
int ramcart_snapshot_read_module(snapshot_t *s)
{
uint8_t vmajor, vminor;
snapshot_module_t *m;
m = snapshot_module_open(s, snap_module_name, &vmajor, &vminor);
if (m == NULL) {
return -1;
}
/* Do not accept versions higher than current */
if (vmajor > SNAP_MAJOR || vminor > SNAP_MINOR) {
snapshot_set_error(SNAPSHOT_MODULE_HIGHER_VERSION);
goto fail;
}
if (0
|| (SMR_B_INT(m, &ramcart_enabled) < 0)
|| (SMR_B_INT(m, &ramcart_readonly) < 0)
|| (SMR_DW_INT(m, &ramcart_size) < 0)
|| (SMR_B_INT(m, &ramcart_size_kb) < 0)
|| (SMR_BA(m, ramcart, 2) < 0)) {
goto fail;
}
ramcart_ram = lib_malloc(ramcart_size);
if (SMR_BA(m, ramcart_ram, ramcart_size) < 0) {
snapshot_module_close(m);
lib_free(ramcart_ram);
ramcart_ram = NULL;
return -1;
}
snapshot_module_close(m);
/* ramcart_filetype = 0; */
ramcart_write_image = 0;
ramcart_enabled = 1;
/* FIXME: ugly code duplication to avoid cart_config_changed calls */
ramcart_io1_list_item = io_source_register(&ramcart_io1_device);
ramcart_io2_list_item = io_source_register(&ramcart_io2_device);
if (export_add(&export_res) < 0) {
lib_free(ramcart_ram);
ramcart_ram = NULL;
io_source_unregister(ramcart_io1_list_item);
io_source_unregister(ramcart_io2_list_item);
ramcart_io1_list_item = NULL;
ramcart_io2_list_item = NULL;
ramcart_enabled = 0;
return -1;
}
return 0;
fail:
snapshot_module_close(m);
return -1;
}
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;
}
