static int set_c64_256k_enabled(int val, void *param)
{
if (val == c64_256k_enabled)
return 0;
if (!val) {
if (c64_256k_deactivate() < 0) {
return -1;
}
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
c64_256k_enabled = 0;
return 0;
} else {
if (plus60k_enabled || plus256k_enabled) {
#ifdef HAS_TRANSLATION
ui_error(translate_text(IDGS_RESOURCE_S_BLOCKED_BY_S),"CPU-LINES", (plus60k_enabled) ? "PLUS60K" : "PLUS256K");
#else
ui_error(_("Resource %s blocked by %s."),"CPU-LINES", (plus60k_enabled) ? "PLUS60K" : "PLUS256K");
#endif
return -1;
} else {
if (c64_256k_activate() < 0) {
return -1;
}
}
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
c64_256k_enabled = 1;
return 0;
}
}
static int set_plus60k_enabled(int val, void *param)
{
if (val == plus60k_enabled) {
return 0;
}
if (!val) {
if (plus60k_deactivate() < 0) {
return -1;
}
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
plus60k_enabled = 0;
return 0;
} else {
if (get_cpu_lines_lock() != 0) {
ui_error(translate_text(IDGS_RESOURCE_S_BLOCKED_BY_S), "CPU-LINES", get_cpu_lines_lock_name());
return -1;
} else {
if (plus60k_activate() < 0) {
return -1;
}
}
plus60k_enabled = 1;
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
return 0;
}
}
static int cbm2_set_model(const char *model, void *extra)
{
int i;
/* vsync_suspend_speed_eval(); */
for (i = 0; modtab[i].model; i++) {
if (machine_class != modtab[i].modelline) {
continue;
}
if (strcmp(modtab[i].model, model)) {
continue;
}
cbm2model_set(modtab[i].modelid);
cbm2_model = i;
/* we have to wait until we did enough initialization */
if (!cbm2_init_ok) {
return 0;
}
mem_powerup();
mem_load();
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
return 0;
}
return -1;
}
void cartridge_detach(int type)
{
int cartridge_reset;
switch (type) {
case CARTRIDGE_VIC20_GENERIC:
generic_detach();
break;
case CARTRIDGE_VIC20_FP:
vic_fp_detach();
break;
case CARTRIDGE_VIC20_MEGACART:
megacart_detach();
break;
case CARTRIDGE_VIC20_FINAL_EXPANSION:
finalexpansion_detach();
break;
}
mem_cartridge_type = CARTRIDGE_NONE;
/* this is probably redundant as it is also performed by the
local detach functions. */
mem_cart_blocks = 0;
mem_initialize_memory();
resources_get_int("CartridgeReset", &cartridge_reset);
if (cartridge_reset != 0) {
/* "Turn off machine before removing cartridge" */
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
}
}
/* Clean memory and reboot for autostart. */
static void reboot_for_autostart(const char *program_name, unsigned int mode, unsigned int runmode)
{
if (!autostart_enabled)
return;
//log_message(autostart_log, "Resetting the machine to autostart '%s'", program_name ? program_name : "*");
mem_powerup();
autostart_ignore_reset = 1;
deallocate_program_name();
if (program_name && program_name[0]) {
autostart_program_name = lib_stralloc(program_name);
}
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
/* The autostartmode must be set AFTER the shutdown to make the autostart
threadsafe for OS/2 */
autostartmode = mode;
autostart_run_mode = runmode;
autostart_wait_for_reset = 1;
/* enable warp before reset */
if (mode != AUTOSTART_HASSNAPSHOT) {
enable_warp_if_requested();
}
}
static void REGPARM2 store_super_io(WORD addr, BYTE value)
{
if (addr >= 0xeffe) { /* RAM/ROM switch */
spet_ramen = !(value & 1);
} else
if (addr >= 0xeffc) { /* Bank select */
spet_bank = value & 0x0f;
spet_ctrlwp = !(value & 0x80);
} else {
if (addr >= 0xeff8) {
if (!spet_ctrlwp) {
if (!(value & 1)) {
log_error(pet_mem_log, "SuperPET: 6809 not emulated!");
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
}
spet_ramwp = !(value & 0x2);
spet_diag = (value & 0x8);
}
} else
if (addr >= 0xeff4) { /* unused */
} else
if (addr >= 0xeff0) { /* ACIA */
acia1_store((WORD)(addr & 0x03), value);
} else
if (addr >= 0xefe4) { /* unused */
} else
if (addr >= 0xefe0) { /* dongle? */
}
}
}
int cbm2_set_model(const char *model, void *extra)
{
int i;
vsync_suspend_speed_eval();
for (i = 0; modtab[i].model; i++) {
if (strcmp(modtab[i].model, model))
continue;
resources_set_int("UseVicII", modtab[i].usevicii);
resources_set_int("RamSize", modtab[i].ramsize);
resources_set_string("BasicName", modtab[i].basic);
resources_set_string("ChargenName", modtab[i].charrom);
resources_set_string("KernalName", modtab[i].kernal);
resources_set_int("ModelLine", modtab[i].line);
cbm2_model = i;
/* we have to wait until we did enough initialization */
if (!cbm2_init_ok)
return 0;
mem_powerup();
mem_load();
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
return 0;
}
return -1;
}
void machine_change_timing(int timeval)
{
switch (timeval) {
case MACHINE_SYNC_PAL:
machine_timing.cycles_per_sec = PET_PAL_CYCLES_PER_SEC;
machine_timing.cycles_per_rfsh = PET_PAL_CYCLES_PER_RFSH;
machine_timing.rfsh_per_sec = PET_PAL_RFSH_PER_SEC;
machine_timing.cycles_per_line = PET_PAL_CYCLES_PER_LINE;
machine_timing.screen_lines = PET_PAL_SCREEN_LINES;
break;
case MACHINE_SYNC_NTSC:
machine_timing.cycles_per_sec = PET_NTSC_CYCLES_PER_SEC;
machine_timing.cycles_per_rfsh = PET_NTSC_CYCLES_PER_RFSH;
machine_timing.rfsh_per_sec = PET_NTSC_RFSH_PER_SEC;
machine_timing.cycles_per_line = PET_NTSC_CYCLES_PER_LINE;
machine_timing.screen_lines = PET_NTSC_SCREEN_LINES;
break;
default:
log_error(pet_log, "Unknown machine timing.");
}
debug_set_machine_parameter(machine_timing.cycles_per_line, machine_timing.screen_lines);
drive_set_machine_parameter(machine_timing.cycles_per_sec);
/* Should these be called also?
//vsync_set_machine_parameter(machine_timing.rfsh_per_sec, machine_timing.cycles_per_sec);
sound_set_machine_parameter(machine_timing.cycles_per_sec, machine_timing.cycles_per_rfsh);
sid_set_machine_parameter(machine_timing.cycles_per_sec);
clk_guard_set_clk_base(maincpu_clk_guard, machine_timing.cycles_per_rfsh);
*/
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
}
/* store 0x9c00-0x9fff */
static void megacart_io3_store(WORD addr, BYTE value)
{
if (nvram_en_flop) {
cart_nvram[addr & 0x1fff] = value;
}
if ((addr & 0x180) == 0x080) { /* $9c80 */
bank_high_reg = value;
}
if ((addr & 0x180) == 0x100) { /* $9d00 */
bank_low_reg = value;
}
if ((addr & 0x180) == 0x180) { /* $9d80 */
nvram_en_flop = (value & 0x1) ? 0 : 1;
bank_high_reg = value;
bank_low_reg = value;
}
if ((addr & 0x200) == 0x200) { /* $9e00 */
/* perform reset */
reset_mode = SOFTWARE_RESET;
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
}
}
static int set_kernal_revision(int val, void *param)
{
int trapfl;
log_verbose("set_kernal_revision val:%d kernal_revision: %d", val, kernal_revision);
if(!c64rom_isloaded()) {
return 0;
}
/* disable device traps before kernal patching */
if (machine_class != VICE_MACHINE_VSID) {
resources_get_int("VirtualDevices", &trapfl);
resources_set_int("VirtualDevices", 0);
}
/* patch kernal to given revision */
if ((val != -1) && (patch_rom_idx(val) < 0)) {
val = -1;
}
memcpy(c64memrom_kernal64_trap_rom, c64memrom_kernal64_rom, C64_KERNAL_ROM_SIZE);
if (kernal_revision != val) {
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
}
/* restore traps */
if (machine_class != VICE_MACHINE_VSID) {
resources_set_int("VirtualDevices", trapfl);
}
kernal_revision = val;
log_verbose("set_kernal_revision new kernal_revision: %d", kernal_revision);
return 0;
}
void cart_power_off(void)
{
if (c64cartridge_reset) {
/* "Turn off machine before removing cartridge" */
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
}
}
void cartridge_attach(int type, BYTE *rawcart)
{
int cartridge_reset;
mem_cartridge_type = type;
#if 0
switch (type) {
case CARTRIDGE_VIC20_GENERIC:
generic_config_setup(rawcart);
break;
case CARTRIDGE_VIC20_FP:
vic_fp_config_setup(rawcart);
break;
case CARTRIDGE_VIC20_MEGACART:
megacart_config_setup(rawcart);
break;
case CARTRIDGE_VIC20_FINAL_EXPANSION:
finalexpansion_config_setup(rawcart);
break;
default:
mem_cartridge_type = CARTRIDGE_NONE;
}
#endif
resources_get_int("CartridgeReset", &cartridge_reset);
if (cartridge_reset != 0) {
/* "Turn off machine before inserting cartridge" */
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
}
}
static int set_ram_size_plus4(int rs, void *param)
{
int hack;
switch (rs) {
case 16:
case 32:
case 64:
case 256:
case 1024:
case 4096:
break;
}
ram_size_plus4 = rs;
if (ram_size_plus4 <= 64) {
resources_get_int("MemoryHack", &hack);
if (hack) {
resources_set_int("MemoryHack", 0);
}
}
vsync_suspend_speed_eval();
mem_initialize_memory();
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
return 0;
}
void machine_change_timing(int timeval)
{
switch (timeval) {
case MACHINE_SYNC_PAL:
machine_timing.cycles_per_sec = PLUS4_PAL_CYCLES_PER_SEC;
machine_timing.cycles_per_rfsh = PLUS4_PAL_CYCLES_PER_RFSH;
machine_timing.rfsh_per_sec = PLUS4_PAL_RFSH_PER_SEC;
machine_timing.cycles_per_line = PLUS4_PAL_CYCLES_PER_LINE;
machine_timing.screen_lines = PLUS4_PAL_SCREEN_LINES;
break;
case MACHINE_SYNC_NTSC:
machine_timing.cycles_per_sec = PLUS4_NTSC_CYCLES_PER_SEC;
machine_timing.cycles_per_rfsh = PLUS4_NTSC_CYCLES_PER_RFSH;
machine_timing.rfsh_per_sec = PLUS4_NTSC_RFSH_PER_SEC;
machine_timing.cycles_per_line = PLUS4_NTSC_CYCLES_PER_LINE;
machine_timing.screen_lines = PLUS4_NTSC_SCREEN_LINES;
break;
default:
log_error(plus4_log, "Unknown machine timing.");
}
vsync_set_machine_parameter(machine_timing.rfsh_per_sec,
machine_timing.cycles_per_sec);
sound_set_machine_parameter(machine_timing.cycles_per_sec,
machine_timing.cycles_per_rfsh);
debug_set_machine_parameter(machine_timing.cycles_per_line,
machine_timing.screen_lines);
drive_set_machine_parameter(machine_timing.cycles_per_sec);
serial_iec_device_set_machine_parameter(machine_timing.cycles_per_sec);
clk_guard_set_clk_base(maincpu_clk_guard, machine_timing.cycles_per_rfsh);
ted_change_timing(&machine_timing);
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
}
void softreset_dialog(HWND hwnd)
{
if (ResetDialog(hwnd, " Soft Reset:\n Do you really want to reset the emulated machine?"))
return;
vsync_suspend_speed_eval();
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
}
int vic20_snapshot_read(const char *name, int event_mode)
{
snapshot_t *s;
BYTE minor, major;
s = snapshot_open(name, &major, &minor, machine_name);
if (s == NULL) {
return -1;
}
if (major != SNAP_MAJOR || minor != SNAP_MINOR) {
log_error(LOG_DEFAULT,
"Snapshot version (%d.%d) not valid: expecting %d.%d.",
major, minor, SNAP_MAJOR, SNAP_MINOR);
goto fail;
}
joyport_clear_devices();
/* FIXME: Missing sound. */
if (maincpu_snapshot_read_module(s) < 0
|| vic20_snapshot_read_module(s) < 0
|| vic_snapshot_read_module(s) < 0
|| viacore_snapshot_read_module(machine_context.via1, s) < 0
|| viacore_snapshot_read_module(machine_context.via2, s) < 0
|| drive_snapshot_read_module(s) < 0
|| event_snapshot_read_module(s, event_mode) < 0
|| tapeport_snapshot_read_module(s) < 0
|| keyboard_snapshot_read_module(s) < 0
|| joyport_snapshot_read_module(s, JOYPORT_1) < 0
|| userport_snapshot_read_module(s) < 0) {
goto fail;
}
if (viacore_snapshot_read_module(machine_context.ieeevia1, s) < 0
|| viacore_snapshot_read_module(machine_context.ieeevia2, s) < 0) {
/* IEEE488 module not undumped */
resources_set_int("IEEE488", 0);
} else {
resources_set_int("IEEE488", 1);
}
snapshot_close(s);
sound_snapshot_finish();
return 0;
fail:
if (s != NULL) {
snapshot_close(s);
}
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
return -1;
}
static UI_MENU_CALLBACK(maincpu_soft_reset_callback)
{
if (activated) {
vsync_suspend_speed_eval();
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
return sdl_menu_text_exit_ui;
}
return NULL;
}
void machine_change_timing(int timeval)
{
int border_mode;
switch (timeval) {
default:
case MACHINE_SYNC_PAL ^ VICII_BORDER_MODE(VICII_NORMAL_BORDERS):
case MACHINE_SYNC_NTSC ^ VICII_BORDER_MODE(VICII_NORMAL_BORDERS):
timeval ^= VICII_BORDER_MODE(VICII_NORMAL_BORDERS);
border_mode = VICII_NORMAL_BORDERS;
break;
case MACHINE_SYNC_PAL ^ VICII_BORDER_MODE(VICII_FULL_BORDERS):
case MACHINE_SYNC_NTSC ^ VICII_BORDER_MODE(VICII_FULL_BORDERS):
timeval ^= VICII_BORDER_MODE(VICII_FULL_BORDERS);
border_mode = VICII_FULL_BORDERS;
break;
case MACHINE_SYNC_PAL ^ VICII_BORDER_MODE(VICII_DEBUG_BORDERS):
case MACHINE_SYNC_NTSC ^ VICII_BORDER_MODE(VICII_DEBUG_BORDERS):
timeval ^= VICII_BORDER_MODE(VICII_DEBUG_BORDERS);
border_mode = VICII_DEBUG_BORDERS;
break;
}
switch (timeval) {
case MACHINE_SYNC_PAL:
machine_timing.cycles_per_sec = C128_PAL_CYCLES_PER_SEC;
machine_timing.cycles_per_rfsh = C128_PAL_CYCLES_PER_RFSH;
machine_timing.rfsh_per_sec = C128_PAL_RFSH_PER_SEC;
machine_timing.cycles_per_line = C128_PAL_CYCLES_PER_LINE;
machine_timing.screen_lines = C128_PAL_SCREEN_LINES;
break;
case MACHINE_SYNC_NTSC:
machine_timing.cycles_per_sec = C128_NTSC_CYCLES_PER_SEC;
machine_timing.cycles_per_rfsh = C128_NTSC_CYCLES_PER_RFSH;
machine_timing.rfsh_per_sec = C128_NTSC_RFSH_PER_SEC;
machine_timing.cycles_per_line = C128_NTSC_CYCLES_PER_LINE;
machine_timing.screen_lines = C128_NTSC_SCREEN_LINES;
break;
default:
log_error(c128_log, "Unknown machine timing.");
}
vsync_set_machine_parameter(machine_timing.rfsh_per_sec, machine_timing.cycles_per_sec);
sound_set_machine_parameter(machine_timing.cycles_per_sec, machine_timing.cycles_per_rfsh);
debug_set_machine_parameter(machine_timing.cycles_per_line, machine_timing.screen_lines);
drive_set_machine_parameter(machine_timing.cycles_per_sec);
serial_iec_device_set_machine_parameter(machine_timing.cycles_per_sec);
sid_set_machine_parameter(machine_timing.cycles_per_sec);
clk_guard_set_clk_base(maincpu_clk_guard, machine_timing.cycles_per_rfsh);
vicii_change_timing(&machine_timing, border_mode);
cia1_set_timing(machine_context.cia1, machine_timing.cycles_per_rfsh);
cia2_set_timing(machine_context.cia2, machine_timing.cycles_per_rfsh);
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
}
static TUI_MENU_CALLBACK(hard_reset_callback)
{
if (been_activated) {
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
}
*become_default = 0;
return NULL;
}
static TUI_MENU_CALLBACK(soft_reset_callback)
{
if (been_activated) {
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
}
/* This way, the "Not Really!" item is always the default one. */
*become_default = 0;
return NULL;
}
int c64dtv_snapshot_read(const char *name, int event_mode)
{
snapshot_t *s;
BYTE minor, major;
s = snapshot_open(name, &major, &minor, machine_name);
if (s == NULL) {
return -1;
}
if (major != SNAP_MAJOR || minor != SNAP_MINOR) {
log_error(LOG_DEFAULT,
"Snapshot version (%d.%d) not valid: expecting %d.%d.",
major, minor, SNAP_MAJOR, SNAP_MINOR);
goto fail;
}
vicii_snapshot_prepare();
joyport_clear_devices();
if (maincpu_snapshot_read_module(s) < 0
|| c64dtv_snapshot_read_module(s) < 0
|| c64dtvdma_snapshot_read_module(s) < 0
|| c64dtvblitter_snapshot_read_module(s) < 0
|| c64dtvmisc_snapshot_read_module(s) < 0
|| ciacore_snapshot_read_module(machine_context.cia1, s) < 0
|| ciacore_snapshot_read_module(machine_context.cia2, s) < 0
|| sid_snapshot_read_module(s) < 0
|| drive_snapshot_read_module(s) < 0
|| vicii_snapshot_read_module(s) < 0
|| event_snapshot_read_module(s, event_mode) < 0
|| keyboard_snapshot_read_module(s) < 0
|| joyport_snapshot_read_module(s, JOYPORT_1) < 0
|| joyport_snapshot_read_module(s, JOYPORT_2) < 0
|| userport_snapshot_read_module(s) < 0) {
goto fail;
}
snapshot_close(s);
sound_snapshot_finish();
return 0;
fail:
if (s != NULL) {
snapshot_close(s);
}
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
return -1;
}
static int set_board_type(int val, void *param)
{
int old_board_type = board_type;
if ((val < 0) || (val > 1)) {
return -1;
}
board_type = val;
if (old_board_type != board_type) {
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
}
return 0;
}
static int set_ramsize(int rs, void *param)
{
if (rs!=64 && rs!=128 && rs!=256 && rs!=512 && rs!=1024)
return -1;
ramsize = rs;
vsync_suspend_speed_eval();
mem_initialize_memory();
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
return 0;
}
void machine_change_timing(int timeval, int border_mode)
{
switch (timeval) {
case MACHINE_SYNC_PAL:
machine_timing.cycles_per_sec = C64_PAL_CYCLES_PER_SEC;
machine_timing.cycles_per_rfsh = C64_PAL_CYCLES_PER_RFSH;
machine_timing.rfsh_per_sec = C64_PAL_RFSH_PER_SEC;
machine_timing.cycles_per_line = C64_PAL_CYCLES_PER_LINE;
machine_timing.screen_lines = C64_PAL_SCREEN_LINES;
machine_timing.power_freq = 50;
break;
case MACHINE_SYNC_NTSC:
machine_timing.cycles_per_sec = C64_NTSC_CYCLES_PER_SEC;
machine_timing.cycles_per_rfsh = C64_NTSC_CYCLES_PER_RFSH;
machine_timing.rfsh_per_sec = C64_NTSC_RFSH_PER_SEC;
machine_timing.cycles_per_line = C64_NTSC_CYCLES_PER_LINE;
machine_timing.screen_lines = C64_NTSC_SCREEN_LINES;
machine_timing.power_freq = 60;
break;
case MACHINE_SYNC_NTSCOLD:
machine_timing.cycles_per_sec = C64_NTSCOLD_CYCLES_PER_SEC;
machine_timing.cycles_per_rfsh = C64_NTSCOLD_CYCLES_PER_RFSH;
machine_timing.rfsh_per_sec = C64_NTSCOLD_RFSH_PER_SEC;
machine_timing.cycles_per_line = C64_NTSCOLD_CYCLES_PER_LINE;
machine_timing.screen_lines = C64_NTSCOLD_SCREEN_LINES;
machine_timing.power_freq = 60;
break;
case MACHINE_SYNC_PALN:
machine_timing.cycles_per_sec = C64_PALN_CYCLES_PER_SEC;
machine_timing.cycles_per_rfsh = C64_PALN_CYCLES_PER_RFSH;
machine_timing.rfsh_per_sec = C64_PALN_RFSH_PER_SEC;
machine_timing.cycles_per_line = C64_PALN_CYCLES_PER_LINE;
machine_timing.screen_lines = C64_PALN_SCREEN_LINES;
machine_timing.power_freq = 50;
break;
default:
log_error(c64_log, "Unknown machine timing.");
}
vsync_set_machine_parameter(machine_timing.rfsh_per_sec, machine_timing.cycles_per_sec);
sound_set_machine_parameter(machine_timing.cycles_per_sec, machine_timing.cycles_per_rfsh);
debug_set_machine_parameter(machine_timing.cycles_per_line, machine_timing.screen_lines);
sid_set_machine_parameter(machine_timing.cycles_per_sec);
clk_guard_set_clk_base(maincpu_clk_guard, machine_timing.cycles_per_rfsh);
vicii_change_timing(&machine_timing);
cia1_set_timing(machine_context.cia1, machine_timing.cycles_per_sec, machine_timing.power_freq);
cia2_set_timing(machine_context.cia2, machine_timing.cycles_per_sec, machine_timing.power_freq);
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
}
/* store 0x9c00-0x9fff */
static void behrbonz_io3_store(WORD addr, BYTE value)
{
/* with the original cartridge a write to the register changes the bank and
triggers a reset. also the bank can not be changed anymore until the next
power cycle */
DBG(("behrbonz_io3_store %04x,%02x\n", addr, value));
if (write_once) {
bank_reg = value & 0x7f;
reset_mode = SOFTWARE_RESET;
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
}
write_once = 0;
}
int cbm2_snapshot_read(const char *name, int event_mode)
{
snapshot_t *s;
BYTE minor, major;
s = snapshot_open(name, &major, &minor, machine_get_name());
if (s == NULL) {
return -1;
}
if (major != SNAP_MAJOR || minor != SNAP_MINOR) {
log_error(LOG_DEFAULT,
"Snapshot version (%d.%d) not valid: expecting %d.%d.",
major, minor, SNAP_MAJOR, SNAP_MINOR);
goto fail;
}
vicii_snapshot_prepare();
if (maincpu_snapshot_read_module(s) < 0
|| vicii_snapshot_read_module(s) < 0
|| cbm2_c500_snapshot_read_module(s) < 0
|| cbm2_snapshot_read_module(s) < 0
|| ciacore_snapshot_read_module(machine_context.cia1, s) < 0
|| tpicore_snapshot_read_module(machine_context.tpi1, s) < 0
|| tpicore_snapshot_read_module(machine_context.tpi2, s) < 0
|| acia1_snapshot_read_module(s) < 0
|| sid_snapshot_read_module(s) < 0
|| drive_snapshot_read_module(s) < 0
|| event_snapshot_read_module(s, event_mode) < 0
|| tape_snapshot_read_module(s) < 0
|| keyboard_snapshot_read_module(s) < 0
|| joystick_snapshot_read_module(s) < 0) {
goto fail;
}
sound_snapshot_finish();
return 0;
fail:
if (s != NULL) {
snapshot_close(s);
}
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
return -1;
}
int pet_snapshot_read(const char *name, int event_mode)
{
snapshot_t *s;
BYTE minor, major;
int ef = 0;
s = snapshot_open(name, &major, &minor, machine_name);
if (s == NULL) {
return -1;
}
if (major != SNAP_MAJOR || minor != SNAP_MINOR) {
log_error(LOG_DEFAULT,
"Snapshot version (%d.%d) not valid: expecting %d.%d.",
major, minor, SNAP_MAJOR, SNAP_MINOR);
ef = -1;
}
if (ef
|| maincpu_snapshot_read_module(s) < 0
|| cpu6809_snapshot_read_module(s) < 0
|| pet_snapshot_read_module(s) < 0
|| crtc_snapshot_read_module(s) < 0
|| pia1_snapshot_read_module(s) < 0
|| pia2_snapshot_read_module(s) < 0
|| petdww_snapshot_read_module(s) < 0
|| viacore_snapshot_read_module(machine_context.via, s) < 0
|| drive_snapshot_read_module(s) < 0
|| event_snapshot_read_module(s, event_mode) < 0
|| tape_snapshot_read_module(s) < 0
|| keyboard_snapshot_read_module(s) < 0
|| joystick_snapshot_read_module(s) < 0) {
ef = -1;
}
if (!ef) {
acia1_snapshot_read_module(s); /* optional, so no error check */
}
snapshot_close(s);
if (ef) {
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
}
sound_snapshot_finish();
return ef;
}
ui_jam_action_t ui_jam_dialog(const char *format, ...)
{
static char message[512];
va_list ap;
va_start (ap, format);
vsnprintf(message, sizeof(message) - 1, format, ap);
va_end (ap);
printf(message);
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
return UI_JAM_NONE;
}
static int set_basic_rom_name(const char *val, void *param)
{
int ret, changed = 1;
if ((val != NULL) && (basic_rom_name != NULL)) {
changed = (strcmp(val, basic_rom_name) != 0);
}
if (util_string_set(&basic_rom_name, val)) {
return 0;
}
ret = c64rom_load_basic(basic_rom_name);
if (changed) {
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
}
return ret;
}
void petmodel_set(int model)
{
if (model >= PETMODEL_NUM) {
return;
}
petres.video = -1; /* force reinitialization in pet-resources.c:set_video, see bug #3496413 */
pet_set_model_info(&pet_table[model].info);
/* we have to wait until we have done enough initialization */
if (pet_init_ok) {
/* mem_load(); - not needed as resources now load */
vsync_suspend_speed_eval();
machine_trigger_reset(MACHINE_RESET_MODE_SOFT);
}
}
