image_init_result nascom2_state::load_cart(device_image_interface &image, generic_slot_device *slot, int slot_id)
{
// loading directly from file
if (image.software_entry() == nullptr)
{
if (slot->length() > 0x1000)
{
image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported file size");
return image_init_result::FAIL;
}
slot->rom_alloc(slot->length(), GENERIC_ROM8_WIDTH, ENDIANNESS_LITTLE);
slot->fread(slot->get_rom_base(), slot->length());
// we just assume that socket1 should be loaded to 0xc000 and socket2 to 0xd000
switch (slot_id)
{
case 1:
m_maincpu->space(AS_PROGRAM).install_rom(0xc000, 0xc000 + slot->length() - 1, slot->get_rom_base());
break;
case 2:
m_maincpu->space(AS_PROGRAM).install_rom(0xd000, 0xd000 + slot->length() - 1, slot->get_rom_base());
break;
}
}
// loading from software list. this supports multiple regions to load to
else
{
UINT8 *region_b000 = image.get_software_region("b000");
UINT8 *region_c000 = image.get_software_region("c000");
UINT8 *region_d000 = image.get_software_region("d000");
if (region_b000 != nullptr)
{
UINT32 size = image.get_software_region_length("b000");
m_maincpu->space(AS_PROGRAM).install_rom(0xb000, 0xb000 + size - 1, region_b000);
}
if (region_c000 != nullptr)
{
UINT32 size = image.get_software_region_length("c000");
m_maincpu->space(AS_PROGRAM).install_rom(0xc000, 0xc000 + size - 1, region_c000);
}
if (region_d000 != nullptr)
{
UINT32 size = image.get_software_region_length("d000");
m_maincpu->space(AS_PROGRAM).install_rom(0xd000, 0xd000 + size - 1, region_d000);
}
}
return image_init_result::PASS;
}
static void load_vizawrite_cartridge(device_image_interface &image)
{
#define VW64_DECRYPT_ADDRESS(_offset) \
BITSWAP16(_offset,15,14,13,12,7,8,6,9,5,11,4,3,2,10,1,0)
#define VW64_DECRYPT_DATA(_data) \
BITSWAP8(_data,7,6,0,5,1,4,2,3)
UINT8 *roml = image.get_software_region("roml");
UINT8 *romh = image.get_software_region("romh");
UINT8 *decrypted = image.device().machine().root_device().memregion("user1")->base();
// decrypt ROMs
for (offs_t offset = 0; offset < 0x2000; offset++)
{
offs_t address = VW64_DECRYPT_ADDRESS(offset);
decrypted[address] = VW64_DECRYPT_DATA(roml[offset]);
decrypted[address + 0x2000] = VW64_DECRYPT_DATA(roml[offset + 0x2000]);
decrypted[address + 0x4000] = VW64_DECRYPT_DATA(romh[offset]);
}
// map cartridge ROMs
map_cartridge_roml(image.device().machine(), 0x0000);
map_cartridge_romh(image.device().machine(), 0x4000);
// allocate GAME changing timer
allocate_cartridge_timer(attotime::from_msec(1184), vizawrite_timer);
}
INPUT_PORTS_END
/***************************************************************************
MACHINE DRIVERS
***************************************************************************/
int aim65_state::load_cart(device_image_interface &image, generic_slot_device *slot, const char *slot_tag)
{
UINT32 size = slot->common_get_size(slot_tag);
if (size > 0x1000)
{
image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported cartridge size");
return IMAGE_INIT_FAIL;
}
if (image.software_entry() != NULL && image.get_software_region(slot_tag) == NULL)
{
astring errmsg;
errmsg.printf("Attempted to load file with wrong extension\nSocket '%s' only accepts files with '.%s' extension",
slot_tag, slot_tag);
image.seterror(IMAGE_ERROR_UNSPECIFIED, errmsg.c_str());
return IMAGE_INIT_FAIL;
}
slot->rom_alloc(size, GENERIC_ROM8_WIDTH, ENDIANNESS_LITTLE);
slot->common_load_rom(slot->get_rom_base(), size, slot_tag);
return IMAGE_INIT_PASS;
}
INPUT_PORTS_END
/***************************************************************************
MACHINE DRIVERS
***************************************************************************/
image_init_result aim65_state::load_cart(device_image_interface &image, generic_slot_device *slot, const char *slot_tag)
{
uint32_t size = slot->common_get_size(slot_tag);
if (size > 0x1000)
{
image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported ROM size");
return image_init_result::FAIL;
}
if (image.loaded_through_softlist() && image.get_software_region(slot_tag) == nullptr)
{
std::string errmsg = string_format(
"Attempted to load file with wrong extension\nSocket '%s' only accepts files with '.%s' extension",
slot_tag, slot_tag);
image.seterror(IMAGE_ERROR_UNSPECIFIED, errmsg.c_str());
return image_init_result::FAIL;
}
slot->rom_alloc(size, GENERIC_ROM8_WIDTH, ENDIANNESS_LITTLE);
slot->common_load_rom(slot->get_rom_base(), size, slot_tag);
return image_init_result::PASS;
}
static void plus4_software_list_cartridge_load(device_image_interface &image)
{
UINT8 *mem = image.device().machine().root_device().memregion("maincpu")->base();
size_t size = image.get_software_region_length("c1l");
if (size)
memcpy(mem + 0x20000, image.get_software_region("c1l"), size);
size = image.get_software_region_length("c1h");
if (size)
memcpy(mem + 0x24000, image.get_software_region("c1h"), size);
size = image.get_software_region_length("c2l");
if (size)
memcpy(mem + 0x28000, image.get_software_region("c2l"), size);
size = image.get_software_region_length("c2h");
if (size)
memcpy(mem + 0x2c000, image.get_software_region("c2h"), size);
}
static void load_standard_c64_cartridge(device_image_interface &image)
{
legacy_c64_state *state = image.device().machine().driver_data<legacy_c64_state>();
UINT32 size;
// is there anything to load at 0x8000?
size = image.get_software_region_length("roml");
if (size)
{
memcpy(state->m_roml, image.get_software_region("roml"), MIN(0x2000, size));
if (size == 0x4000)
{
// continue loading to ROMH region
memcpy(state->m_romh, image.get_software_region("roml") + 0x2000, 0x2000);
}
}
// is there anything to load at 0xa000?
size = image.get_software_region_length("romh");
if (size)
memcpy(state->m_romh, image.get_software_region("romh"), size);
}
static void load_hugo_cartridge(device_image_interface &image)
{
#define HUGO_DECRYPT_ADDRESS(_offset) \
BITSWAP16(_offset,15,14,13,12,7,6,5,4,3,2,1,0,8,9,11,10)
#define HUGO_DECRYPT_DATA(_data) \
BITSWAP8(_data,7,6,5,4,0,1,2,3)
UINT8 *roml = image.get_software_region("roml");
UINT8 *decrypted = image.device().machine().root_device().memregion("user1")->base();
// decrypt ROMs
for (offs_t offset = 0; offset < 0x20000; offset++)
{
offs_t address = (offset & 0x10000) | HUGO_DECRYPT_ADDRESS(offset);
decrypted[address] = HUGO_DECRYPT_DATA(roml[offset]);
}
// map cartridge ROMs
map_cartridge_roml(image.device().machine(), 0x0000);
// install bankswitch handler
install_io1_handler(hugo_bank_w);
}
INLINE void load_cartridge_region(device_image_interface &image, const char *name, offs_t offset, size_t size)
{
UINT8 *cart = image.device().machine().root_device().memregion("user1")->base();
UINT8 *rom = image.get_software_region(name);
memcpy(cart + offset, rom, size);
}
