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_INT(m, &currbank) < 0)
|| (SMR_BA(m, roml_banks, 0x2000 * 64) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return magicdesk_common_attach();
}
int riotcore_snapshot_write_module(riot_context_t *riot_context, snapshot_t *p)
{
snapshot_module_t *m;
m = snapshot_module_create(p, riot_context->myname, RIOT_DUMP_VER_MAJOR, RIOT_DUMP_VER_MINOR);
if (m == NULL) {
return -1;
}
update_timer(riot_context);
if (0
|| SMW_B(m, riot_context->riot_io[0]) < 0
|| SMW_B(m, riot_context->riot_io[1]) < 0
|| SMW_B(m, riot_context->riot_io[2]) < 0
|| SMW_B(m, riot_context->riot_io[3]) < 0
|| SMW_B(m, riot_context->r_edgectrl) < 0
|| SMW_B(m, (BYTE)(riot_context->r_irqfl | (riot_context->r_irqline ? 1 : 0))) < 0
|| SMW_B(m, (BYTE)(riot_context->r_N - (*(riot_context->clk_ptr) - riot_context->r_write_clk) / riot_context->r_divider)) < 0
|| SMW_W(m, (WORD)(riot_context->r_divider)) < 0
|| SMW_W(m, (BYTE)((*(riot_context->clk_ptr) - riot_context->r_write_clk) % riot_context->r_divider)) < 0
|| SMW_B(m, (BYTE)(riot_context->r_irqen ? 1 : 0)) < 0) {
snapshot_module_close(m);
return -1;
}
return snapshot_module_close(m);
}
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 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 sid_snapshot_write_module_simple(snapshot_t *s)
{
int sound, sid_engine;
snapshot_module_t *m;
m = snapshot_module_create(s, snap_module_name_simple, SNAP_MAJOR_SIMPLE,
SNAP_MINOR_SIMPLE);
if (m == NULL) {
return -1;
}
resources_get_int("Sound", &sound);
if (SMW_B(m, (BYTE)sound) < 0) {
snapshot_module_close(m);
return -1;
}
if (sound) {
resources_get_int("SidEngine", &sid_engine);
if (SMW_B(m, (BYTE)sid_engine) < 0) {
snapshot_module_close(m);
return -1;
}
/* FIXME: Only data for first SID stored. */
if (SMW_BA(m, sid_get_siddata(0), 32) < 0) {
snapshot_module_close(m);
return -1;
}
}
snapshot_module_close(m);
return 0;
}
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();
}
int easyflash_snapshot_write_module(snapshot_t *s)
{
snapshot_module_t *m;
m = snapshot_module_create(s, SNAP_MODULE_NAME,
CART_DUMP_VER_MAJOR, CART_DUMP_VER_MINOR);
if (m == NULL) {
return -1;
}
if (0
|| (SMW_B(m, (BYTE)easyflash_jumper) < 0)
|| (SMW_B(m, easyflash_register_00) < 0)
|| (SMW_B(m, easyflash_register_02) < 0)
|| (SMW_BA(m, easyflash_ram, 256) < 0)
|| (SMW_BA(m, roml_banks, 0x80000) < 0)
|| (SMW_BA(m, romh_banks, 0x80000) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
if (0
|| (flash040core_snapshot_write_module(s, easyflash_state_low, FLASH_SNAP_MODULE_NAME) < 0)
|| (flash040core_snapshot_write_module(s, easyflash_state_high, FLASH_SNAP_MODULE_NAME) < 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 finalexpansion_snapshot_write_module(snapshot_t *s)
{
snapshot_module_t *m;
m = snapshot_module_create(s, SNAP_MODULE_NAME, VIC20CART_DUMP_VER_MAJOR, VIC20CART_DUMP_VER_MINOR);
if (m == NULL) {
return -1;
}
if (0
|| (SMW_B(m, register_a) < 0)
|| (SMW_B(m, register_b) < 0)
|| (SMW_B(m, lock_bit) < 0)
|| (SMW_BA(m, cart_ram, CART_RAM_SIZE) < 0)
|| (SMW_BA(m, flash_state.flash_data, CART_ROM_SIZE) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
if ((flash040core_snapshot_write_module(s, &flash_state, FLASH_SNAP_MODULE_NAME) < 0)) {
return -1;
}
return 0;
}
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 vic_fp_snapshot_write_module(snapshot_t *s)
{
snapshot_module_t *m;
m = snapshot_module_create(s, SNAP_MODULE_NAME,
VIC20CART_DUMP_VER_MAJOR,
VIC20CART_DUMP_VER_MINOR);
if (m == NULL) {
return -1;
}
if (0
|| (SMW_B(m, cart_bank_reg) < 0)
|| (SMW_B(m, cart_cfg_reg) < 0)
|| (SMW_BA(m, cart_ram, CART_RAM_SIZE) < 0)
|| (SMW_BA(m, cart_rom, CART_ROM_SIZE) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
if ((flash040core_snapshot_write_module(s, &flash_state, FLASH_SNAP_MODULE_NAME) < 0)) {
return -1;
}
return 0;
}
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) {
goto fail;
}
return snapshot_module_close(m);
fail:
snapshot_module_close(m);
return -1;
}
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
}
int digimax_snapshot_write_module(snapshot_t *s)
{
snapshot_module_t *m;
m = snapshot_module_create(s, SNAP_MODULE_NAME,
CART_DUMP_VER_MAJOR, CART_DUMP_VER_MINOR);
if (m == NULL) {
return -1;
}
if (0
|| (SMW_DW(m, (DWORD)digimax_address) < 0)
/* FIXME: implement userport part in userport_digimax.c */
#if 0
|| (SMW_B(m, digimax_userport_address) < 0)
|| (SMW_B(m, digimax_userport_direction_A) < 0)
|| (SMW_B(m, digimax_userport_direction_B) < 0)
#endif
|| (SMW_BA(m, digimax_sound_data, 4) < 0)
|| (SMW_B(m, snd.voice0) < 0)
|| (SMW_B(m, snd.voice1) < 0)
|| (SMW_B(m, snd.voice2) < 0)
|| (SMW_B(m, snd.voice3) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return 0;
}
int warpspeed_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, 0x2000) < 0)
|| (SMR_BA(m, romh_banks, 0x2000) < 0)) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
return warpspeed_common_attach();
}
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;
}
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 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;
}
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 drive_snapshot_write_image_module(snapshot_t *s, unsigned int dnr)
{
char snap_module_name[10];
snapshot_module_t *m;
BYTE sector_data[0x100];
WORD word;
disk_addr_t dadr;
int rc;
drive_t *drive;
drive = drive_context[dnr]->drive;
if (drive->image == NULL) {
sprintf(snap_module_name, "NOIMAGE%i", dnr);
} else {
sprintf(snap_module_name, "IMAGE%i", dnr);
}
m = snapshot_module_create(s, snap_module_name, IMAGE_SNAP_MAJOR,
IMAGE_SNAP_MINOR);
if (m == NULL) {
return -1;
}
if (drive->image == NULL) {
if (snapshot_module_close(m) < 0) {
return -1;
}
return 0;
}
word = drive->image->type;
SMW_W(m, word);
/* we use the return code to step through the tracks. So we do not
need any geometry info. */
for (dadr.track = 1;; dadr.track++) {
rc = 0;
for (dadr.sector = 0;; dadr.sector++) {
rc = disk_image_read_sector(drive->image, sector_data, &dadr);
if (rc == 0) {
SMW_BA(m, sector_data, 0x100);
} else {
break;
}
}
if (dadr.sector == 0) {
break;
}
}
if (snapshot_module_close(m) < 0) {
return -1;
}
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 vic_snapshot_write_module(snapshot_t *s)
{
int i;
snapshot_module_t *m;
m = snapshot_module_create(s, snap_module_name, SNAP_MAJOR, SNAP_MINOR);
if (m == NULL) {
return -1;
}
if (SMW_B(m, (BYTE)VIC_RASTER_CYCLE(maincpu_clk)) < 0
|| SMW_W(m, (WORD)VIC_RASTER_Y(maincpu_clk)) < 0) {
goto fail;
}
if (0
|| (SMW_W(m, (WORD)vic.area) < 0)
|| (SMW_W(m, (WORD)vic.fetch_state) < 0)
|| (SMW_DW(m, (DWORD)vic.raster_line) < 0)
|| (SMW_DW(m, (DWORD)vic.text_cols) < 0)
|| (SMW_DW(m, (DWORD)vic.text_lines) < 0)
|| (SMW_DW(m, (DWORD)vic.pending_text_cols) < 0)
|| (SMW_DW(m, (DWORD)vic.line_was_blank) < 0)
|| (SMW_DW(m, (DWORD)vic.memptr) < 0)
|| (SMW_DW(m, (DWORD)vic.memptr_inc) < 0)
|| (SMW_DW(m, (DWORD)vic.row_counter) < 0)
|| (SMW_DW(m, (DWORD)vic.buf_offset) < 0)
|| SMW_B(m, (BYTE)vic.light_pen.state) < 0
|| SMW_B(m, (BYTE)vic.light_pen.triggered) < 0
|| SMW_DW(m, (DWORD)vic.light_pen.x) < 0
|| SMW_DW(m, (DWORD)vic.light_pen.y) < 0
|| SMW_DW(m, (DWORD)vic.light_pen.x_extra_bits) < 0
|| SMW_DW(m, (DWORD)vic.light_pen.trigger_cycle) < 0
|| (SMW_B(m, vic.vbuf) < 0)) {
goto fail;
}
/* Color RAM. */
if (SMW_BA(m, mem_ram + 0x9400, 0x400) < 0) {
goto fail;
}
for (i = 0; i < 0x10; i++) {
if (SMW_B(m, (BYTE)vic.regs[i]) < 0) {
goto fail;
}
}
return snapshot_module_close(m);
fail:
if (m != NULL)
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 ds1216e_write_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;
snapshot_module_t *m;
/* time_t can be either 32bit or 64bit, so we save as 64bit */
#if (SIZE_OF_TIME_T == 8)
latch_hi = (DWORD)(context->latch >> 32);
latch_lo = (DWORD)(context->latch & 0xffffffff);
offset_hi = (DWORD)(context->offset >> 32);
offset_lo = (DWORD)(context->offset & 0xffffffff);
old_offset_hi = (DWORD)(context->old_offset >> 32);
old_offset_lo = (DWORD)(context->old_offset & 0xffffffff);
#else
latch_lo = (DWORD)context->latch;
offset_lo = (DWORD)context->offset;
old_offset_lo = (DWORD)context->old_offset;
#endif
m = snapshot_module_create(s, snap_module_name, SNAP_MAJOR, SNAP_MINOR);
if (m == NULL) {
return -1;
}
if (0
|| SMW_B(m, (BYTE)context->reset) < 0
|| SMW_B(m, (BYTE)context->inactive) < 0
|| SMW_B(m, (BYTE)context->hours12) < 0
|| SMW_B(m, (BYTE)context->pattern_pos) < 0
|| SMW_B(m, (BYTE)context->pattern_ignore) < 0
|| SMW_B(m, (BYTE)context->output) < 0
|| SMW_B(m, (BYTE)context->output_pos) < 0
|| SMW_DW(m, latch_hi) < 0
|| SMW_DW(m, latch_lo) < 0
|| SMW_DW(m, offset_hi) < 0
|| SMW_DW(m, offset_lo) < 0
|| SMW_DW(m, old_offset_hi) < 0
|| SMW_DW(m, old_offset_lo) < 0
|| SMW_BA(m, context->clock_regs, DS1216E_REG_SIZE) < 0
|| SMW_BA(m, context->old_clock_regs, DS1216E_REG_SIZE) < 0
|| SMW_BA(m, context->clock_regs_changed, DS1216E_REG_SIZE) < 0
|| SMW_STR(m, context->device) < 0) {
snapshot_module_close(m);
return -1;
}
return snapshot_module_close(m);
}
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;
}
