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 magicdesk_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(m, ®val) < 0)
|| (SMR_BA(m, roml_banks, 0x2000 * MAXBANKS) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
if (magicdesk_common_attach() == -1) {
return -1;
}
magicdesk_io1_store(0xde00, regval);
return 0;
}
int sfx_soundsampler_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(m, &sfx_soundsampler_sound_data) < 0)) {
snapshot_module_close(m);
return -1;
}
if (!sfx_soundsampler_sound_chip.chip_enabled) {
set_sfx_soundsampler_enabled(1, NULL);
}
sound_store(sfx_soundsampler_sound_chip_offset, sfx_soundsampler_sound_data, 0);
snapshot_module_close(m);
return 0;
}
int se5_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_BA(m, roml_banks, SE5_CART_SIZE) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return se5_common_attach();
}
int ds12c887rtc_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
int temp_ds12c887rtc_address;
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;
}
/* FIXME: Implement the RTC snapshot part */
if (0
|| (SMR_DW_INT(m, &temp_ds12c887rtc_address) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
/* HACK set address to an invalid value, then use the function */
ds12c887rtc_base_address = -1;
set_ds12c887rtc_base(temp_ds12c887rtc_address, NULL);
return ds12c887rtc_enable();
}
static int dtlbasic_read_snapshot(struct snapshot_s *s)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
/* enable device */
set_dtlbasic_dongle_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 (0
|| SMR_DW_INT(m, &dtlbasic_counter) < 0
|| SMR_DW_INT(m, &write_status) < 0
|| SMR_DW_INT(m, &sense_status) < 0
|| SMR_DW_INT(m, &dtlbasic_state) < 0) {
goto fail;
}
return snapshot_module_close(m);
fail:
snapshot_module_close(m);
return -1;
}
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 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 mmc_snapshot_read_module(snapshot_t *s)
{
return -1;
#if 0
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) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return 0;
#endif
}
static int userport_digimax_read_snapshot_module(snapshot_t *s)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
/* enable device */
set_digimax_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 (0
|| (SMR_B(m, &userport_digimax_address) < 0)
|| (SMR_BA(m, digimax_sound_data, 4) < 0)
|| (SMR_B(m, &snd.voice0) < 0)
|| (SMR_B(m, &snd.voice1) < 0)
|| (SMR_B(m, &snd.voice2) < 0)
|| (SMR_B(m, &snd.voice3) < 0)) {
goto fail;
}
return snapshot_module_close(m);
fail:
snapshot_module_close(m);
return -1;
}
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();
}
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 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 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;
}
if ((vmajor != CART_DUMP_VER_MAJOR) || (vminor != CART_DUMP_VER_MINOR)) {
snapshot_module_close(m);
return -1;
}
if (0
|| (SMR_BA(m, roml_banks, FREEZE_FRAME_CART_SIZE) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
memcpy(romh_banks, roml_banks, FREEZE_FRAME_CART_SIZE);
return freezeframe_common_attach();
}
static int mem_read_rom_snapshot_module(snapshot_t *s)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
int trapfl;
/* Main memory module. */
m = snapshot_module_open(s, snap_rom_module_name,
&major_version, &minor_version);
/* This module is optional. */
if (m == NULL)
return 0;
/* disable traps before loading the ROM */
resources_get_int("VirtualDevices", &trapfl);
resources_set_int("VirtualDevices", 0);
if (major_version > SNAP_ROM_MAJOR || minor_version > SNAP_ROM_MINOR) {
log_error(c128_snapshot_log,
"MEM: Snapshot module version (%d.%d) newer than %d.%d.",
major_version, minor_version,
SNAP_ROM_MAJOR, SNAP_ROM_MINOR);
goto fail;
}
if (0
|| SMR_BA(m, c128memrom_kernal_rom, C128_KERNAL_ROM_SIZE) < 0
|| SMR_BA(m, c128memrom_basic_rom, C128_BASIC_ROM_SIZE) < 0
|| SMR_BA(m, c128memrom_basic_rom + C128_BASIC_ROM_SIZE,
C128_EDITOR_ROM_SIZE) < 0
|| SMR_BA(m, mem_chargen_rom, C128_CHARGEN_ROM_SIZE) < 0)
goto fail;
log_warning(c128_snapshot_log,"Dumped Romset files and saved settings will " "represent\nthe state before loading the snapshot!");
memcpy(c128memrom_kernal_trap_rom, c128memrom_kernal_rom,
C128_KERNAL_ROM_SIZE);
c128rom_basic_checksum();
c128rom_kernal_checksum();
/* enable traps again when necessary */
resources_set_int("VirtualDevices", trapfl);
/* to get all the checkmarks right */
ui_update_menus();
return 0;
fail:
/* enable traps again when necessary */
resources_set_int("VirtualDevices", trapfl);
if (m != NULL)
snapshot_module_close(m);
return -1;
}
int fdc_snapshot_read_module(snapshot_t *p, int fnum)
{
BYTE vmajor, vminor;
BYTE byte, ndrv;
DWORD dword;
snapshot_module_t *m;
char *name;
name = lib_msprintf("FDC%d", fnum);
m = snapshot_module_open(p, name, &vmajor, &vminor);
lib_free(name);
if (m == NULL) {
log_message(fdc_log, "Could not find snapshot module %s", name);
return -1;
}
if (vmajor != FDC_DUMP_VER_MAJOR) {
log_error(fdc_log,
"Snapshot module version (%d.%d) newer than %d.%d.",
vmajor, vminor, FDC_DUMP_VER_MAJOR, FDC_DUMP_VER_MINOR);
snapshot_module_close(m);
return -1;
}
SMR_B(m, &byte);
if (byte > FDC_LAST_STATE) {
snapshot_module_close(m);
return -1;
}
fdc[fnum].fdc_state = byte;
/* clk till next invocation */
SMR_DW(m, &dword);
fdc[fnum].alarm_clk = drive_clk[fnum] + dword;
alarm_set(fdc[fnum].fdc_alarm, fdc[fnum].alarm_clk);
/* number of drives - so far 1 only */
SMR_B(m, &ndrv);
/* last accessed track/sector */
SMR_B(m, &byte);
fdc[fnum].last_track = byte;
SMR_B(m, &byte);
fdc[fnum].last_sector = byte;
if (ndrv > 1) {
/* ignore drv 0 values */
SMR_B(m, &byte);
SMR_B(m, &byte);
}
if (snapshot_module_close(m) < 0)
return -1;
return 0;
}
int finalexpansion_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
BYTE *cart_flash = NULL;
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_flash) {
cart_flash = lib_malloc(CART_ROM_SIZE);
}
flash040core_init(&flash_state, maincpu_alarm_context, FLASH040_TYPE_B, cart_flash);
if (0
|| (SMR_B(m, ®ister_a) < 0)
|| (SMR_B(m, ®ister_b) < 0)
|| (SMR_B(m, &lock_bit) < 0)
|| (SMR_BA(m, cart_ram, CART_RAM_SIZE) < 0)
|| (SMR_BA(m, flash_state.flash_data, CART_ROM_SIZE) < 0)) {
snapshot_module_close(m);
flash040core_shutdown(&flash_state);
lib_free(cart_ram);
lib_free(cart_flash);
cart_ram = NULL;
cart_flash = NULL;
return -1;
}
snapshot_module_close(m);
if ((flash040core_snapshot_read_module(s, &flash_state, FLASH_SNAP_MODULE_NAME) < 0)) {
flash040core_shutdown(&flash_state);
lib_free(cart_ram);
lib_free(cart_flash);
cart_ram = NULL;
cart_flash = NULL;
return -1;
}
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;
}
static int sid_snapshot_read_module_simple(snapshot_t *s)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
BYTE tmp[34];
m = snapshot_module_open(s, snap_module_name_simple,
&major_version, &minor_version);
if (m == NULL) {
goto fail;
}
if (major_version > SNAP_MAJOR_SIMPLE
|| minor_version > SNAP_MINOR_SIMPLE) {
log_error(LOG_DEFAULT,
"SID: Snapshot module version (%d.%d) newer than %d.%d.\n",
major_version, minor_version,
SNAP_MAJOR_SIMPLE, SNAP_MINOR_SIMPLE);
snapshot_module_close(m);
goto fail;
}
/* If more than 32 bytes are present then the resource "Sound" and
"SidEngine" come first! If there is only one byte present, then
sound is disabled. */
if (SMR_BA(m, tmp, 34) < 0) {
if (SMR_BA(m, tmp, 32) < 0) {
if (SMR_BA(m, tmp, 1) < 0) {
snapshot_module_close(m);
goto fail;
} else {
sound_close();
}
} else {
memcpy(sid_get_siddata(0), &tmp[0], 32);
}
} else {
int res_sound = (int)(tmp[0]);
int res_engine = (int)(tmp[1]);
screenshot_prepare_reopen();
sound_close();
screenshot_try_reopen();
resources_set_int("Sound", res_sound);
if (res_sound) {
resources_set_int("SidEngine", res_engine);
/* FIXME: Only data for first SID read. */
memcpy(sid_get_siddata(0), &tmp[2], 32);
sound_open();
}
}
return snapshot_module_close(m);
fail:
log_error(LOG_DEFAULT, "Failed reading SID snapshot");
return -1;
}
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 vic_fp_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_rom) {
cart_rom = lib_malloc(CART_ROM_SIZE);
}
flash040core_init(&flash_state, maincpu_alarm_context, FLASH040_TYPE_032B_A0_1_SWAP, cart_rom);
if (0
|| (SMR_B(m, &cart_bank_reg) < 0)
|| (SMR_B(m, &cart_cfg_reg) < 0)
|| (SMR_BA(m, cart_ram, CART_RAM_SIZE) < 0)
|| (SMR_BA(m, cart_rom, CART_ROM_SIZE) < 0)) {
snapshot_module_close(m);
lib_free(cart_ram);
lib_free(cart_rom);
cart_ram = NULL;
cart_rom = NULL;
return -1;
}
snapshot_module_close(m);
if ((flash040core_snapshot_read_module(s, &flash_state, FLASH_SNAP_MODULE_NAME) < 0)) {
flash040core_shutdown(&flash_state);
lib_free(cart_ram);
lib_free(cart_rom);
cart_ram = NULL;
cart_rom = NULL;
return -1;
}
CART_CFG_INIT(cart_cfg_reg);
mem_cart_blocks = VIC_CART_RAM123 |
VIC_CART_BLK1 | VIC_CART_BLK2 | VIC_CART_BLK3 | VIC_CART_BLK5 |
VIC_CART_IO2;
mem_initialize_memory();
return 0;
}
static int tape_snapshot_read_tapimage_module(snapshot_t *s)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
char *filename = NULL;
FILE *ftap;
BYTE *buffer;
long tap_size;
m = snapshot_module_open(s, "TAPIMAGE",
&major_version, &minor_version);
if (m == NULL)
return 0;
if (major_version > TAPIMAGE_SNAP_MAJOR
|| minor_version > TAPIMAGE_SNAP_MINOR) {
log_error(tape_snapshot_log,
"Snapshot module version (%d.%d) newer than %d.%d.",
major_version, minor_version,
TAPIMAGE_SNAP_MAJOR, TAPIMAGE_SNAP_MINOR);
}
/* create temporary file */
/* FIXME: Were is this file deleted? */
ftap = archdep_mkstemp_fd(&filename, MODE_WRITE);
if (ftap == NULL) {
log_error(tape_snapshot_log, "Could not create temporary file!");
snapshot_module_close(m);
goto fail;
}
SMR_DW_UL(m, (unsigned long *)&tap_size);
buffer = lib_malloc(tap_size);
SMR_BA(m, buffer, tap_size);
if (fwrite(buffer, tap_size, 1, ftap) != 1) {
log_error(tape_snapshot_log, "Could not create temporary file");
log_error(tape_snapshot_log, "filename=%s", filename);
snapshot_module_close(m);
fclose(ftap);
goto fail;
}
lib_free(buffer);
fclose(ftap);
tape_image_attach(1, filename);
lib_free(filename);
snapshot_module_close(m);
return 0;
fail:
lib_free(filename);
return -1;
}
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 c128_snapshot_read_module(snapshot_t *s)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
WORD i;
BYTE byte;
/* Main memory module. */
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(c128_snapshot_log,
"MEM: Snapshot module version (%d.%d) newer than %d.%d.",
major_version, minor_version,
SNAP_MAJOR, SNAP_MINOR);
goto fail;
}
for (i = 0; i < 11; i++) {
if (SMR_B(m, &byte) < 0)
goto fail;
mmu_store(i, byte); /* Assuming no side-effects */
}
if (0
|| SMR_BA(m, mem_ram, C128_RAM_SIZE) < 0)
goto fail;
/* pla_config_changed(); */
if (snapshot_module_close(m) < 0)
goto fail;
m = NULL;
if (mem_read_rom_snapshot_module(s) < 0)
goto fail;
if (cartridge_snapshot_read_modules(s) < 0) {
goto fail;
}
ui_update_menus();
return 0;
fail:
if (m != NULL)
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 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 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;
}
static int mem_read_ram_snapshot_module(snapshot_t *p)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
BYTE config;
m = snapshot_module_open(p, SNAP_MEM_MODULE_NAME, &vmajor, &vminor);
if (m == NULL) {
return -1;
}
if (vmajor != VIC20MEM_DUMP_VER_MAJOR) {
snapshot_module_close(m);
return -1;
}
SMR_B(m, &config);
SMR_B(m, &vic20_cpu_last_data);
SMR_B(m, &vic20_v_bus_last_data);
SMR_B(m, &vic20_v_bus_last_high);
SMR_BA(m, mem_ram, 0x0400);
SMR_BA(m, mem_ram + 0x1000, 0x1000);
resources_set_int("RAMBlock0", (config & 1) ? 1 : 0 );
if (config & 1) {
SMR_BA(m, mem_ram + 0x0400, 0x0c00);
}
resources_set_int("RAMBlock1", (config & 2) ? 1 : 0 );
if (config & 2) {
SMR_BA(m, mem_ram + 0x2000, 0x2000);
}
resources_set_int("RAMBlock2", (config & 4) ? 1 : 0 );
if (config & 4) {
SMR_BA(m, mem_ram + 0x4000, 0x2000);
}
resources_set_int("RAMBlock3", (config & 8) ? 1 : 0 );
if (config & 8) {
SMR_BA(m, mem_ram + 0x6000, 0x2000);
}
resources_set_int("RAMBlock5", (config & 32) ? 1 : 0 );
if (config & 32) {
SMR_BA(m, mem_ram + 0xA000, 0x2000);
}
snapshot_module_close(m);
mem_initialize_memory();
return 0;
}
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 mypia_snapshot_read_module(snapshot_t * p)
{
BYTE vmajor, vminor;
BYTE byte;
snapshot_module_t *m;
my_restore_int(pia_int_num, 0); /* just in case */
m = snapshot_module_open(p, snap_module_name, &vmajor, &vminor);
if (m == NULL)
return -1;
if (vmajor != PIA_DUMP_VER_MAJOR) {
snapshot_module_close(m);
return -1;
}
SMR_B(m, &mypia.port_a);
SMR_B(m, &mypia.ddr_a);
SMR_B(m, &mypia.ctrl_a);
SMR_B(m, &mypia.port_b);
SMR_B(m, &mypia.ddr_b);
SMR_B(m, &mypia.ctrl_b);
SMR_B(m, &byte);
mypia.ca_state = (byte & 0x80) ? 1 : 0;
mypia.cb_state = (byte & 0x80) ? 1 : 0;
pia_set_ca2(mypia.ca_state);
pia_set_cb2(mypia.cb_state);
byte = mypia.port_a | ~mypia.ddr_a;
undump_pa(byte);
byte = mypia.port_b | ~mypia.ddr_b;
undump_pb(byte);
if (0
|| ((mypia.ctrl_a & 0x81) == 0x81)
|| ((mypia.ctrl_a & 0x68) == 0x48)
|| ((mypia.ctrl_b & 0x81) == 0x81)
|| ((mypia.ctrl_b & 0x68) == 0x48)
) {
my_restore_int(pia_int_num, 1);
}
return snapshot_module_close(m);
}
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;
}
