void megacart_detach(void)
{
/* try to write back NvRAM contents if write back is enabled
and cartridge is not from a snapshot */
if (nvram_writeback && !cartridge_is_from_snapshot) {
try_nvram_save(nvram_filename);
}
mem_cart_blocks = 0;
mem_initialize_memory();
lib_free(cart_ram);
lib_free(cart_nvram);
lib_free(cart_rom);
cart_ram = NULL;
cart_nvram = NULL;
cart_rom = NULL;
if (megacart_io2_list_item != NULL) {
io_source_unregister(megacart_io2_list_item);
megacart_io2_list_item = NULL;
}
if (megacart_io3_list_item != NULL) {
io_source_unregister(megacart_io3_list_item);
megacart_io3_list_item = NULL;
}
}
static int set_ramsize(int size, void *param)
{
int i;
const int sizes[] = { 4, 8, 16, 32, 96, 128 };
for (i = 0; i < util_arraysize(sizes); i++) {
if (size <= sizes[i])
break;
}
if (i > util_arraysize(sizes) - 1)
i = util_arraysize(sizes) - 1;
size = sizes[i];
if (petres.ramSize != size) {
petres.ramSize = size;
petres.map = PET_MAP_LINEAR;
if (size == 96) {
petres.map = PET_MAP_8096; /* 8096 mapping */
set_superpet_enabled(0, NULL);
} else if (size == 128) {
petres.map = PET_MAP_8296; /* 8296 mapping */
set_superpet_enabled(0, NULL);
}
petmem_check_info(&petres);
mem_initialize_memory();
}
return 0;
}
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;
}
int finalexpansion_bin_attach(const char *filename)
{
BYTE *cart_flash;
if (!cart_ram) {
cart_ram = lib_malloc(CART_RAM_SIZE);
}
cart_flash = lib_malloc(CART_ROM_SIZE);
if (cart_flash == NULL) {
return -1;
}
/* flash040core_init() does not clear the flash */
memset(cart_flash, 0xff, CART_ROM_SIZE);
flash040core_init(&flash_state, maincpu_alarm_context, FLASH040_TYPE_B, cart_flash);
util_string_set(&cartfile, filename);
if (zfile_load(filename, flash_state.flash_data) < 0) {
finalexpansion_detach();
return -1;
}
mem_cart_blocks = VIC_CART_RAM123 |
VIC_CART_BLK1 | VIC_CART_BLK2 | VIC_CART_BLK3 | VIC_CART_BLK5 |
VIC_CART_IO3;
mem_initialize_memory();
finalexpansion_list_item = io_source_register(&finalexpansion_device);
return 0;
}
int vic_fp_bin_attach(const char *filename)
{
if (!cart_ram) {
cart_ram = lib_malloc(CART_RAM_SIZE);
}
if (!cart_rom) {
cart_rom = lib_malloc(CART_ROM_SIZE);
}
util_string_set(&cartfile, filename);
if (zfile_load(filename, cart_rom, (size_t)CART_ROM_SIZE) < 0) {
vic_fp_detach();
return -1;
}
if (export_add(&export_res) < 0) {
return -1;
}
flash040core_init(&flash_state, maincpu_alarm_context, FLASH040_TYPE_032B_A0_1_SWAP, cart_rom);
mem_cart_blocks = VIC_CART_RAM123 |
VIC_CART_BLK1 | VIC_CART_BLK2 | VIC_CART_BLK3 | VIC_CART_BLK5 |
VIC_CART_IO2;
mem_initialize_memory();
vfp_list_item = io_source_register(&vfp_device);
return 0;
}
static int set_ramsize(int size, void *param)
{
int i;
const int sizes[] = { 4, 8, 16, 32, 96, 128 };
for (i = 0; i < 6; i++) {
if (size <= sizes[i])
break;
}
if (i > 5)
i = 5;
size = sizes[i];
petres.ramSize = size;
petres.map = 0;
if (size == 96) {
petres.map = 1; /* 8096 mapping */
} else if (size == 128) {
petres.map = 2; /* 8296 mapping */
}
petmem_check_info(&petres);
mem_initialize_memory();
return 0;
}
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);
}
}
int megacart_bin_attach(const char *filename)
{
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 (zfile_load(filename, cart_rom, (size_t)CART_ROM_SIZE) < 0) {
megacart_detach();
return -1;
}
try_nvram_load(nvram_filename);
cart_rom_low = cart_rom;
cart_rom_high = cart_rom + 0x100000;
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();
megacart_io2_list_item = io_source_register(&megacart_io2_device);
megacart_io3_list_item = io_source_register(&megacart_io3_device);
return 0;
}
static int set_iosize(int val, void *param)
{
petres.IOSize = val;
mem_initialize_memory();
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;
}
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 set_ram_a_enabled(int val, void *param)
{
if (val < 2)
petres.memA = (unsigned int)val;
mem_initialize_memory();
return 0;
}
int machine_init(void)
{
machine_video_init();
fsdevice_init();
file_system_init();
mem_initialize_memory();
return machine_specific_init();
}
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;
}
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;
}
void behrbonz_detach(void)
{
mem_cart_blocks = 0;
mem_initialize_memory();
lib_free(cart_rom);
cart_rom = NULL;
export_remove(&export_res);
if (behrbonz_io3_list_item != NULL) {
io_source_unregister(behrbonz_io3_list_item);
behrbonz_io3_list_item = NULL;
}
}
void machine_reset(void)
{
log_message(LOG_DEFAULT, "Main CPU: RESET.");
/* Do machine-specific initialization. */
machine_specific_reset();
autostart_reset();
mem_initialize_memory();
event_reset_ack();
vsync_suspend_speed_eval();
}
static int set_superpet_enabled(int val, void *param)
{
if (petres.superpet != val) {
if (val < 2)
petres.superpet = (unsigned int)val;
if (petres.superpet && petres.ramSize > 32) {
set_ramsize(32, NULL); /* disable 8x96 */
}
mem_initialize_memory();
}
return 0;
}
static int mem_read_rom_snapshot_module(snapshot_t *p)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
BYTE config;
int trapfl;
m = snapshot_module_open(p, SNAP_ROM_MODULE_NAME, &vmajor, &vminor);
if (m == NULL) {
return 0; /* optional */
}
if (vmajor != VIC20ROM_DUMP_VER_MAJOR) {
snapshot_module_close(m);
return -1;
}
/* disable traps before loading the ROM */
resources_get_int("VirtualDevices", &trapfl);
resources_set_int("VirtualDevices", 0);
/* old cart system ROMs (ignored) */
SMR_B(m, &config);
/* read kernal */
SMR_BA(m, vic20memrom_kernal_rom, 0x2000);
/* read basic */
SMR_BA(m, vic20memrom_basic_rom, 0x2000);
SMR_BA(m, vic20memrom_chargen_rom, 0x1000);
vic20rom_kernal_checksum();
vic20rom_basic_checksum();
log_warning(vic20_snapshot_log,
"Dumped Romset files and saved settings will "
"represent\nthe state before loading the snapshot!");
/* enable traps again when necessary */
resources_set_int("VirtualDevices", trapfl);
snapshot_module_close(m);
mem_initialize_memory();
return 0;
}
void vic_fp_detach(void)
{
/* try to write back cartridge contents if write back is enabled
and cartridge wasn't from a snapshot */
if (vic_fp_writeback && !cartridge_is_from_snapshot) {
if (flash_state.flash_dirty) {
int n;
FILE *fd;
n = 0;
log_message(fp_log, "Flash dirty, trying to write back...");
fd = fopen(cartfile, "wb");
if (fd) {
n = fwrite(flash_state.flash_data, (size_t)CART_ROM_SIZE, 1, fd);
fclose(fd);
}
if (n < 1) {
log_message(fp_log, "Failed to write back image `%s'!",
cartfile);
} else {
log_message(fp_log, "Wrote back image `%s'.",
cartfile);
}
} else {
log_message(fp_log, "Flash clean, skipping write back.");
}
}
mem_cart_blocks = 0;
mem_initialize_memory();
lib_free(cart_ram);
lib_free(cart_rom);
lib_free(cartfile);
cart_ram = NULL;
cart_rom = NULL;
cartfile = NULL;
if (vfp_list_item != NULL) {
export_remove(&export_res);
io_source_unregister(vfp_list_item);
vfp_list_item = NULL;
}
}
static int set_ram_size_plus4(int rs, void *param)
{
if ((rs != 64) && (rs != 32) && (rs != 16) && (rs != 256) && (rs != 1024)
&& (rs != 4096)) {
return -1;
}
ram_size_plus4 = rs;
if (ram_size_plus4 < 256) {
resources_set_int("H256K", 0);
resources_set_int("CS256K", 0);
}
vsync_suspend_speed_eval();
mem_initialize_memory();
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
return 0;
}
static int set_ramsize(int rs, void *param)
{
switch (rs) {
case 64:
case 128:
case 256:
case 512:
case 1024:
break;
default:
return -1;
}
ramsize = rs;
vsync_suspend_speed_eval();
mem_initialize_memory();
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
return 0;
}
int behrbonz_bin_attach(const char *filename)
{
if (!cart_rom) {
cart_rom = lib_malloc(CART_ROM_SIZE);
}
if (zfile_load(filename, cart_rom, (size_t)CART_ROM_SIZE) < 0) {
behrbonz_detach();
return -1;
}
if (export_add(&export_res) < 0) {
return -1;
}
mem_cart_blocks = VIC_CART_BLK1 | VIC_CART_BLK2 | VIC_CART_BLK3 | VIC_CART_BLK5 | VIC_CART_IO3;
mem_initialize_memory();
behrbonz_io3_list_item = io_source_register(&behrbonz_io3_device);
return 0;
}
int behrbonz_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_rom) {
cart_rom = lib_malloc(CART_ROM_SIZE);
}
if (0
|| (SMR_B(m, &bank_reg) < 0)
|| (SMR_B(m, &reset_mode) < 0)
|| (SMR_B(m, &write_once) < 0)
|| (SMR_BA(m, cart_rom, CART_ROM_SIZE) < 0)) {
snapshot_module_close(m);
lib_free(cart_rom);
cart_rom = NULL;
return -1;
}
snapshot_module_close(m);
mem_cart_blocks = VIC_CART_BLK1 | VIC_CART_BLK2 | VIC_CART_BLK3 | VIC_CART_BLK5 | VIC_CART_IO3;
mem_initialize_memory();
return 0;
}
static int set_ram_block_0_enabled(int value, void *param)
{
ram_block_0_enabled = value;
mem_initialize_memory();
return 0;
}
static int mem_read_ram_snapshot_module(snapshot_t *p)
{
BYTE byte, vmajor, vminor;
snapshot_module_t *m;
BYTE config, hwconfig;
int memsize;
int effective_ramsize, effective_start;
int bank0;
m = snapshot_module_open(p, module_name, &vmajor, &vminor);
if (m == NULL)
return -1;
if (vmajor != CBM2MEM_DUMP_VER_MAJOR) {
snapshot_module_close(m);
return -1;
}
SMR_B(m, &byte);
memsize = ((int)byte) & 0xff;
SMR_B(m, &config);
SMR_B(m, &hwconfig);
resources_set_int("ModelLine", hwconfig & 3);
SMR_B(m, &byte);
cbm2mem_set_bank_exec(byte);
SMR_B(m, &byte);
cbm2mem_set_bank_ind(byte);
SMR_BA(m, mem_ram + 0xf0000, 0x0800);
SMR_BA(m, mem_rom + 0xd000, 0x0800);
/* calculate start and size of RAM to load */
/* ramsize starts counting at 0x10000 if less than 512k */
bank0 = config & 64;
effective_ramsize = memsize << 7;
effective_start = 0x10000;
if (bank0 || effective_ramsize >= 512) {
effective_start = 0;
}
if (bank0 && effective_ramsize < 512) {
effective_ramsize -= 64;
}
SMR_BA(m, mem_ram + effective_start, memsize << 17);
ramsize = effective_ramsize;
cart08_ram = config & 1;
cart1_ram = config & 2;
cart2_ram = config & 4;
cart4_ram = config & 8;
cart6_ram = config & 16;
cartC_ram = config & 32;
if (memsize < 4) {
SMR_BA(m, mem_ram + 0x10000, memsize << 17);
} else {
SMR_BA(m, mem_ram, memsize << 17);
}
if (memsize < 4) { /* if 1M memory, bank 15 is included */
if (config & 1) {
SMR_BA(m, mem_ram + 0xf0800, 0x0800);
}
if (config & 2) {
SMR_BA(m, mem_ram + 0xf1000, 0x1000);
}
if (config & 4) {
SMR_BA(m, mem_ram + 0xf2000, 0x2000);
}
if (config & 8) {
SMR_BA(m, mem_ram + 0xf4000, 0x2000);
}
if (config & 16) {
SMR_BA(m, mem_ram + 0xf6000, 0x2000);
}
if (config & 32) {
SMR_BA(m, mem_ram + 0xfc000, 0x1000);
}
}
mem_initialize_memory();
snapshot_module_close(m);
return 0;
}
