Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-26 22:29:10 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

(MESS) consolidation + cleanup, part1. nw.

Browse Source
This commit is contained in:
Fabio Priuli 2014-09-28 15:28:57 +00:00
parent 108544f677
commit ca3deae576
38 changed files with 539 additions and 476 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
src/emu/bus/a7800/a78_slot.c
View File

@ -42,6 +42,8 @@ const device_type A78_CART_SLOT = &device_creator<a78_cart_slot_device>;
device_a78_cart_interface::device_a78_cart_interface (const machine_config &mconfig, device_t &device) device_a78_cart_interface::device_a78_cart_interface (const machine_config &mconfig, device_t &device)
: device_slot_card_interface(mconfig, device), : device_slot_card_interface(mconfig, device),
m_rom(NULL),
m_rom_size(0),
m_base_rom(0x8000), m_base_rom(0x8000),
m_bank_mask(0) m_bank_mask(0)
{ {
@ -60,20 +62,26 @@ device_a78_cart_interface::~device_a78_cart_interface ()
// rom_alloc - alloc the space for the cart // rom_alloc - alloc the space for the cart
//------------------------------------------------- //-------------------------------------------------
void device_a78_cart_interface::rom_alloc(UINT32 size) void device_a78_cart_interface::rom_alloc(UINT32 size, const char *tag)
{ {
m_rom.resize(size); if (m_rom == NULL)
{
astring tempstring(tag);
tempstring.cat(A78SLOT_ROM_REGION_TAG);
m_rom = device().machine().memory().region_alloc(tempstring, size, 1, ENDIANNESS_LITTLE)->base();
m_rom_size = size;
// setup other helpers // setup other helpers
if ((size / 0x4000) & 1) // compensate for SuperGame carts with 9 x 16K banks (to my knowledge no other cart has m_bank_mask != power of 2) if ((size / 0x4000) & 1) // compensate for SuperGame carts with 9 x 16K banks (to my knowledge no other cart has m_bank_mask != power of 2)
m_bank_mask = (size / 0x4000) - 2; m_bank_mask = (size / 0x4000) - 2;
else else
m_bank_mask = (size / 0x4000) - 1; m_bank_mask = (size / 0x4000) - 1;
// the rom is mapped to the top of the memory area // the rom is mapped to the top of the memory area
// so we store the starting point of data to simplify // so we store the starting point of data to simplify
// the access handling // the access handling
m_base_rom = 0x10000 - size; m_base_rom = 0x10000 - size;
}
} }
//------------------------------------------------- //-------------------------------------------------
@ -340,7 +348,6 @@ bool a78_cart_slot_device::call_load()
{ {
if (m_cart) if (m_cart)
{ {
UINT8 *ROM;
UINT32 len; UINT32 len;
if (software_entry() != NULL) if (software_entry() != NULL)
@ -350,9 +357,8 @@ bool a78_cart_slot_device::call_load()
bool has_nvram = get_software_region("nvram") ? TRUE : FALSE; bool has_nvram = get_software_region("nvram") ? TRUE : FALSE;
len = get_software_region_length("rom"); len = get_software_region_length("rom");
m_cart->rom_alloc(len); m_cart->rom_alloc(len, tag());
ROM = m_cart->get_rom_base(); memcpy(m_cart->get_rom_base(), get_software_region("rom"), len);
memcpy(ROM, get_software_region("rom"), len);
if ((pcb_name = get_feature("slot")) != NULL) if ((pcb_name = get_feature("slot")) != NULL)
m_type = a78_get_pcb_id(pcb_name); m_type = a78_get_pcb_id(pcb_name);
@ -447,9 +453,8 @@ bool a78_cart_slot_device::call_load()
internal_header_logging((UINT8 *)head, length()); internal_header_logging((UINT8 *)head, length());
m_cart->rom_alloc(len); m_cart->rom_alloc(len, tag());
ROM = m_cart->get_rom_base(); fread(m_cart->get_rom_base(), len);
fread(ROM, len);
if (m_type == A78_TYPE6) if (m_type == A78_TYPE6)
m_cart->ram_alloc(0x4000); m_cart->ram_alloc(0x4000);

9
src/emu/bus/a7800/a78_slot.h
View File

@ -53,19 +53,20 @@ public:
virtual DECLARE_WRITE8_MEMBER(write_30xx) {} virtual DECLARE_WRITE8_MEMBER(write_30xx) {}
virtual DECLARE_WRITE8_MEMBER(write_40xx) {} virtual DECLARE_WRITE8_MEMBER(write_40xx) {}
void rom_alloc(UINT32 size); void rom_alloc(UINT32 size, const char *tag);
void ram_alloc(UINT32 size); void ram_alloc(UINT32 size);
void nvram_alloc(UINT32 size); void nvram_alloc(UINT32 size);
UINT8* get_rom_base() { return m_rom; } UINT8* get_rom_base() { return m_rom; }
UINT8* get_ram_base() { return m_ram; } UINT8* get_ram_base() { return m_ram; }
UINT8* get_nvram_base() { return m_nvram; } UINT8* get_nvram_base() { return m_nvram; }
UINT32 get_rom_size() { return m_rom.bytes(); } UINT32 get_rom_size() { return m_rom_size; }
UINT32 get_ram_size() { return m_ram.bytes(); } UINT32 get_ram_size() { return m_ram.bytes(); }
UINT32 get_nvram_size() { return m_nvram.bytes(); } UINT32 get_nvram_size() { return m_nvram.bytes(); }
protected: protected:
// internal state // internal state
dynamic_buffer m_rom; UINT8 *m_rom;
UINT32 m_rom_size;
dynamic_buffer m_ram; dynamic_buffer m_ram;
dynamic_buffer m_nvram; // HiScore cart can save scores! dynamic_buffer m_nvram; // HiScore cart can save scores!
// helpers // helpers
@ -144,6 +145,8 @@ extern const device_type A78_CART_SLOT;
DEVICE CONFIGURATION MACROS DEVICE CONFIGURATION MACROS
***************************************************************************/ ***************************************************************************/
#define A78SLOT_ROM_REGION_TAG ":cart:rom"
#define MCFG_A78_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \ #define MCFG_A78_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
MCFG_DEVICE_ADD(_tag, A78_CART_SLOT, 0) \ MCFG_DEVICE_ADD(_tag, A78_CART_SLOT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false) MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

27
src/emu/bus/a800/a800_slot.c
View File

@ -40,6 +40,8 @@ const device_type XEGS_CART_SLOT = &device_creator<xegs_cart_slot_device>;
device_a800_cart_interface::device_a800_cart_interface (const machine_config &mconfig, device_t &device) device_a800_cart_interface::device_a800_cart_interface (const machine_config &mconfig, device_t &device)
: device_slot_card_interface(mconfig, device), : device_slot_card_interface(mconfig, device),
m_rom(NULL),
m_rom_size(0),
m_bank_mask(0) m_bank_mask(0)
{ {
} }
@ -57,12 +59,18 @@ device_a800_cart_interface::~device_a800_cart_interface ()
// rom_alloc - alloc the space for the cart // rom_alloc - alloc the space for the cart
//------------------------------------------------- //-------------------------------------------------
void device_a800_cart_interface::rom_alloc(UINT32 size) void device_a800_cart_interface::rom_alloc(UINT32 size, const char *tag)
{ {
m_rom.resize(size); if (m_rom == NULL)
{
astring tempstring(tag);
tempstring.cat(A800SLOT_ROM_REGION_TAG);
m_rom = device().machine().memory().region_alloc(tempstring, size, 1, ENDIANNESS_LITTLE)->base();
m_rom_size = size;
// setup other helpers // setup other helpers
m_bank_mask = (size / 0x2000) - 1; // code for XEGS carts makes use of this to simplify banking m_bank_mask = (size / 0x2000) - 1; // code for XEGS carts makes use of this to simplify banking
}
} }
//------------------------------------------------- //-------------------------------------------------
@ -234,7 +242,6 @@ bool a800_cart_slot_device::call_load()
{ {
if (m_cart) if (m_cart)
{ {
UINT8 *ROM;
UINT32 len; UINT32 len;
if (software_entry() != NULL) if (software_entry() != NULL)
@ -242,9 +249,8 @@ bool a800_cart_slot_device::call_load()
const char *pcb_name; const char *pcb_name;
len = get_software_region_length("rom"); len = get_software_region_length("rom");
m_cart->rom_alloc(len); m_cart->rom_alloc(len, tag());
ROM = m_cart->get_rom_base(); memcpy(m_cart->get_rom_base(), get_software_region("rom"), len);
memcpy(ROM, get_software_region("rom"), len);
if ((pcb_name = get_feature("slot")) != NULL) if ((pcb_name = get_feature("slot")) != NULL)
m_type = a800_get_pcb_id(pcb_name); m_type = a800_get_pcb_id(pcb_name);
@ -275,9 +281,8 @@ bool a800_cart_slot_device::call_load()
m_type = A5200_4K; m_type = A5200_4K;
} }
m_cart->rom_alloc(len); m_cart->rom_alloc(len, tag());
ROM = m_cart->get_rom_base(); fread(m_cart->get_rom_base(), len);
fread(ROM, len);
} }
if (m_type == A800_TELELINK2) if (m_type == A800_TELELINK2)
m_cart->nvram_alloc(0x100); m_cart->nvram_alloc(0x100);

9
src/emu/bus/a800/a800_slot.h
View File

@ -56,19 +56,20 @@ public:
virtual DECLARE_WRITE8_MEMBER(write_80xx) {} virtual DECLARE_WRITE8_MEMBER(write_80xx) {}
virtual DECLARE_WRITE8_MEMBER(write_d5xx) {} virtual DECLARE_WRITE8_MEMBER(write_d5xx) {}
void rom_alloc(UINT32 size); void rom_alloc(UINT32 size, const char *tag);
void ram_alloc(UINT32 size); void ram_alloc(UINT32 size);
void nvram_alloc(UINT32 size); void nvram_alloc(UINT32 size);
UINT8* get_rom_base() { return m_rom; } UINT8* get_rom_base() { return m_rom; }
UINT8* get_ram_base() { return m_ram; } UINT8* get_ram_base() { return m_ram; }
UINT8* get_nvram_base() { return m_nvram; } UINT8* get_nvram_base() { return m_nvram; }
UINT32 get_rom_size() { return m_rom.bytes(); } UINT32 get_rom_size() { return m_rom_size; }
UINT32 get_ram_size() { return m_ram.bytes(); } UINT32 get_ram_size() { return m_ram.bytes(); }
UINT32 get_nvram_size() { return m_nvram.bytes(); } UINT32 get_nvram_size() { return m_nvram.bytes(); }
protected: protected:
// internal state // internal state
dynamic_buffer m_rom; UINT8 *m_rom;
UINT32 m_rom_size;
dynamic_buffer m_ram; dynamic_buffer m_ram;
dynamic_buffer m_nvram; // HiScore cart can save scores! dynamic_buffer m_nvram; // HiScore cart can save scores!
// helpers // helpers
@ -169,6 +170,8 @@ extern const device_type XEGS_CART_SLOT;
DEVICE CONFIGURATION MACROS DEVICE CONFIGURATION MACROS
***************************************************************************/ ***************************************************************************/
#define A800SLOT_ROM_REGION_TAG ":cart:rom"
#define MCFG_A800_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \ #define MCFG_A800_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
MCFG_DEVICE_ADD(_tag, A800_CART_SLOT, 0) \ MCFG_DEVICE_ADD(_tag, A800_CART_SLOT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false) MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

2
src/emu/bus/a800/rom.c
View File

@ -204,7 +204,7 @@ void a5200_rom_bbsb_device::device_reset()
READ8_MEMBER(a800_rom_device::read_80xx) READ8_MEMBER(a800_rom_device::read_80xx)
{ {
return m_rom[offset & (m_rom.bytes() - 1)]; return m_rom[offset & (m_rom_size - 1)];
} }

22
src/emu/bus/gameboy/gb_slot.c
View File

@ -36,6 +36,8 @@ const device_type MEGADUCK_CART_SLOT = &device_creator<megaduck_cart_slot_device
device_gb_cart_interface::device_gb_cart_interface(const machine_config &mconfig, device_t &device) device_gb_cart_interface::device_gb_cart_interface(const machine_config &mconfig, device_t &device)
: device_slot_card_interface(mconfig, device), : device_slot_card_interface(mconfig, device),
m_rom(NULL),
m_rom_size(0),
has_rumble(false), has_rumble(false),
has_timer(false), has_timer(false),
has_battery(false) has_battery(false)
@ -55,9 +57,15 @@ device_gb_cart_interface::~device_gb_cart_interface()
// rom_alloc - alloc the space for the cart // rom_alloc - alloc the space for the cart
//------------------------------------------------- //-------------------------------------------------
void device_gb_cart_interface::rom_alloc(UINT32 size) void device_gb_cart_interface::rom_alloc(UINT32 size, const char *tag)
{ {
m_rom.resize(size); if (m_rom == NULL)
{
astring tempstring(tag);
tempstring.cat(GBSLOT_ROM_REGION_TAG);
m_rom = device().machine().memory().region_alloc(tempstring, size, 1, ENDIANNESS_LITTLE)->base();
m_rom_size = size;
}
} }
@ -274,7 +282,7 @@ bool base_gb_cart_slot_device::call_load()
} }
} }
m_cart->rom_alloc(len); m_cart->rom_alloc(len, tag());
ROM = m_cart->get_rom_base(); ROM = m_cart->get_rom_base();
if (software_entry() == NULL) if (software_entry() == NULL)
@ -397,15 +405,13 @@ bool megaduck_cart_slot_device::call_load()
if (m_cart) if (m_cart)
{ {
UINT32 len = (software_entry() == NULL) ? length() : get_software_region_length("rom"); UINT32 len = (software_entry() == NULL) ? length() : get_software_region_length("rom");
UINT8 *ROM;
m_cart->rom_alloc(len); m_cart->rom_alloc(len, tag());
ROM = m_cart->get_rom_base();
if (software_entry() == NULL) if (software_entry() == NULL)
fread(ROM, len); fread(m_cart->get_rom_base(), len);
else else
memcpy(ROM, get_software_region("rom"), len); memcpy(m_cart->get_rom_base(), get_software_region("rom"), len);
// setup rom bank map based on real length, not header value // setup rom bank map based on real length, not header value
m_cart->rom_map_setup(len); m_cart->rom_map_setup(len);

9
src/emu/bus/gameboy/gb_slot.h
View File

@ -56,11 +56,11 @@ public:
virtual DECLARE_READ8_MEMBER(read_ram) { return 0xff; } virtual DECLARE_READ8_MEMBER(read_ram) { return 0xff; }
virtual DECLARE_WRITE8_MEMBER(write_ram) {} virtual DECLARE_WRITE8_MEMBER(write_ram) {}
void rom_alloc(UINT32 size); void rom_alloc(UINT32 size, const char *tag);
void ram_alloc(UINT32 size); void ram_alloc(UINT32 size);
UINT8* get_rom_base() { return m_rom; } UINT8* get_rom_base() { return m_rom; }
UINT8* get_ram_base() { return m_ram; } UINT8* get_ram_base() { return m_ram; }
UINT32 get_rom_size() { return m_rom.count(); } UINT32 get_rom_size() { return m_rom_size; }
UINT32 get_ram_size() { return m_ram.count(); } UINT32 get_ram_size() { return m_ram.count(); }
void rom_map_setup(UINT32 size); void rom_map_setup(UINT32 size);
@ -74,7 +74,8 @@ public:
void save_ram() { device().save_item(NAME(m_ram)); } void save_ram() { device().save_item(NAME(m_ram)); }
// internal state // internal state
dynamic_buffer m_rom; UINT8 *m_rom;
UINT32 m_rom_size;
dynamic_buffer m_ram; dynamic_buffer m_ram;
// bankswitch variables // bankswitch variables
@ -190,6 +191,8 @@ extern const device_type MEGADUCK_CART_SLOT;
DEVICE CONFIGURATION MACROS DEVICE CONFIGURATION MACROS
***************************************************************************/ ***************************************************************************/
#define GBSLOT_ROM_REGION_TAG ":cart:rom"
#define MCFG_GB_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \ #define MCFG_GB_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
MCFG_DEVICE_ADD(_tag, GB_CART_SLOT, 0) \ MCFG_DEVICE_ADD(_tag, GB_CART_SLOT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false) MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

2
src/emu/bus/gameboy/mbc.c
View File

@ -677,7 +677,7 @@ WRITE8_MEMBER(gb_rom_mmm01_device::write_bank)
} }
else if (offset < 0x4000) else if (offset < 0x4000)
{ {
m_reg = data & ((m_rom.count() / 0x4000) - 1); m_reg = data & ((m_rom_size / 0x4000) - 1);
m_bank = m_reg & m_bank_mask; m_bank = m_reg & m_bank_mask;
if (m_bank == 0) if (m_bank == 0)
m_bank = 1; m_bank = 1;

74
src/emu/bus/gba/gba_slot.c
View File

@ -40,6 +40,23 @@ device_gba_cart_interface::~device_gba_cart_interface()
{ {
} }
//-------------------------------------------------
// rom_alloc - alloc the space for the cart
//-------------------------------------------------
void device_gba_cart_interface::rom_alloc(UINT32 size, const char *tag)
{
if (m_rom == NULL)
{
astring tempstring(tag);
tempstring.cat(GBASLOT_ROM_REGION_TAG);
// we always alloc 32MB of rom region!
m_rom = (UINT32 *)device().machine().memory().region_alloc(tempstring, 0x2000000, 4, ENDIANNESS_LITTLE)->base();
m_rom_size = size;
}
}
//------------------------------------------------- //-------------------------------------------------
// nvram_alloc - alloc the space for the ram // nvram_alloc - alloc the space for the ram
//------------------------------------------------- //-------------------------------------------------
@ -150,34 +167,27 @@ bool gba_cart_slot_device::call_load()
{ {
if (m_cart) if (m_cart)
{ {
UINT8 *ROM = (UINT8 *)m_cart->get_rom_base(); UINT8 *ROM;
UINT32 cart_size; UINT32 size = (software_entry() != NULL) ? get_software_region_length("rom") : length();
if (size > 0x2000000)
{
seterror(IMAGE_ERROR_UNSPECIFIED, "Attempted loading a cart larger than 32MB");
return IMAGE_INIT_FAIL;
}
m_cart->rom_alloc(size, tag());
ROM = (UINT8 *)m_cart->get_rom_base();
if (software_entry() == NULL) if (software_entry() == NULL)
{ {
cart_size = length(); fread(ROM, size);
if (cart_size > 0x2000000) m_type = get_cart_type(ROM, size);
{
seterror(IMAGE_ERROR_UNSPECIFIED, "Attempted loading a cart larger than 32MB");
return IMAGE_INIT_FAIL;
}
fread(ROM, cart_size);
m_cart->set_rom_size(cart_size); // we store the actual game size...
m_type = get_cart_type(ROM, cart_size);
} }
else else
{ {
const char *pcb_name = get_feature("slot"); const char *pcb_name = get_feature("slot");
cart_size = get_software_region_length("rom"); memcpy(ROM, get_software_region("rom"), size);
if (cart_size > 0x2000000)
{
seterror(IMAGE_ERROR_UNSPECIFIED, "Attempted loading a cart larger than 32MB");
return IMAGE_INIT_FAIL;
}
memcpy(ROM, get_software_region("rom"), cart_size);
m_cart->set_rom_size(cart_size); // we store the actual game size...
if (pcb_name) if (pcb_name)
m_type = gba_get_pcb_id(pcb_name); m_type = gba_get_pcb_id(pcb_name);
@ -191,7 +201,7 @@ bool gba_cart_slot_device::call_load()
m_cart->nvram_alloc(0x10000); m_cart->nvram_alloc(0x10000);
// mirror the ROM // mirror the ROM
switch (cart_size) switch (size)
{ {
case 2 * 1024 * 1024: case 2 * 1024 * 1024:
memcpy(ROM + 0x200000, ROM, 0x200000); memcpy(ROM + 0x200000, ROM, 0x200000);
@ -452,25 +462,3 @@ WRITE32_MEMBER(gba_cart_slot_device::write_ram)
void gba_cart_slot_device::internal_header_logging(UINT8 *ROM, UINT32 len) void gba_cart_slot_device::internal_header_logging(UINT8 *ROM, UINT32 len)
{ {
} }
/*-------------------------------------------------
Install ROM - directly point system address map
to the cart ROM region so to avoid the memory
system additional load
-------------------------------------------------*/
void gba_cart_slot_device::install_rom()
{
if (m_cart)
{
astring tempstring;
address_space &space = machine().device<cpu_device>("maincpu")->space(AS_PROGRAM);
space.install_read_bank(0x08000000, 0x09ffffff, 0, 0, "rom1");
space.install_read_bank(0x0a000000, 0x0bffffff, 0, 0, "rom2");
space.install_read_bank(0x0c000000, 0x0cffffff, 0, 0, "rom3");
machine().root_device().membank("rom1")->set_base(machine().root_device().memregion(m_cart->device().subtag(tempstring, "cartridge"))->base());
machine().root_device().membank("rom2")->set_base(machine().root_device().memregion(m_cart->device().subtag(tempstring, "cartridge"))->base());
machine().root_device().membank("rom3")->set_base(machine().root_device().memregion(m_cart->device().subtag(tempstring, "cartridge"))->base());
}
}

7
src/emu/bus/gba/gba_slot.h
View File

@ -34,6 +34,7 @@ public:
virtual DECLARE_READ32_MEMBER(read_ram) { return 0xffffffff; } virtual DECLARE_READ32_MEMBER(read_ram) { return 0xffffffff; }
virtual DECLARE_WRITE32_MEMBER(write_ram) {}; virtual DECLARE_WRITE32_MEMBER(write_ram) {};
void rom_alloc(UINT32 size, const char *tag);
void nvram_alloc(UINT32 size); void nvram_alloc(UINT32 size);
UINT32* get_rom_base() { return m_rom; } UINT32* get_rom_base() { return m_rom; }
UINT32* get_nvram_base() { return m_nvram; } UINT32* get_nvram_base() { return m_nvram; }
@ -45,8 +46,8 @@ public:
// internal state // internal state
UINT32 *m_rom; // this points to the cart rom region UINT32 *m_rom; // this points to the cart rom region
dynamic_array<UINT32> m_nvram;
UINT32 m_rom_size; // this is the actual game size, not the rom region size! UINT32 m_rom_size; // this is the actual game size, not the rom region size!
dynamic_array<UINT32> m_nvram;
}; };
@ -70,8 +71,6 @@ public:
virtual void call_unload(); virtual void call_unload();
virtual bool call_softlist_load(software_list_device &swlist, const char *swname, const rom_entry *start_entry); virtual bool call_softlist_load(software_list_device &swlist, const char *swname, const rom_entry *start_entry);
void install_rom();
int get_type() { return m_type; } int get_type() { return m_type; }
int get_cart_type(UINT8 *ROM, UINT32 len); int get_cart_type(UINT8 *ROM, UINT32 len);
@ -115,6 +114,8 @@ extern const device_type GBA_CART_SLOT;
DEVICE CONFIGURATION MACROS DEVICE CONFIGURATION MACROS
***************************************************************************/ ***************************************************************************/
#define GBASLOT_ROM_REGION_TAG ":cart:rom"
#define MCFG_GBA_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \ #define MCFG_GBA_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
MCFG_DEVICE_ADD(_tag, GBA_CART_SLOT, 0) \ MCFG_DEVICE_ADD(_tag, GBA_CART_SLOT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false) MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

22
src/emu/bus/gba/rom.c
View File

@ -67,28 +67,12 @@ gba_rom_flash1m_device::gba_rom_flash1m_device(const machine_config &mconfig, co
} }
//-------------------------------------------------
// ROM Region to allow faster access to cart data
//-------------------------------------------------
ROM_START( gba_cart )
// cartridge region - 32 MBytes (128 Mbit)
ROM_REGION( 0x2000000, "cartridge", ROMREGION_ERASEFF )
ROM_END
const rom_entry *gba_rom_device::device_rom_region() const
{
return ROM_NAME( gba_cart );
}
//------------------------------------------------- //-------------------------------------------------
// mapper specific start/reset // mapper specific start/reset
//------------------------------------------------- //-------------------------------------------------
void gba_rom_device::device_start() void gba_rom_device::device_start()
{ {
astring tempstring;
m_rom = (UINT32 *)memregion(this->subtag(tempstring, "cartridge"))->base();
} }
void gba_rom_device::device_reset() void gba_rom_device::device_reset()
@ -108,9 +92,6 @@ void gba_rom_flash1m_device::device_reset()
void gba_rom_eeprom_device::device_start() void gba_rom_eeprom_device::device_start()
{ {
astring tempstring;
m_rom = (UINT32 *)memregion(this->subtag(tempstring, "cartridge"))->base();
// for the moment we use a custom eeprom implementation, so we alloc/save it as nvram // for the moment we use a custom eeprom implementation, so we alloc/save it as nvram
nvram_alloc(0x200); nvram_alloc(0x200);
m_eeprom.reset(global_alloc(gba_eeprom_device(machine(), (UINT8*)get_nvram_base(), get_nvram_size(), 6))); m_eeprom.reset(global_alloc(gba_eeprom_device(machine(), (UINT8*)get_nvram_base(), get_nvram_size(), 6)));
@ -118,9 +99,6 @@ void gba_rom_eeprom_device::device_start()
void gba_rom_eeprom64_device::device_start() void gba_rom_eeprom64_device::device_start()
{ {
astring tempstring;
m_rom = (UINT32 *)memregion(this->subtag(tempstring, "cartridge"))->base();
// for the moment we use a custom eeprom implementation, so we alloc/save it as nvram // for the moment we use a custom eeprom implementation, so we alloc/save it as nvram
nvram_alloc(0x2000); nvram_alloc(0x2000);
m_eeprom.reset(global_alloc(gba_eeprom_device(machine(), (UINT8*)get_nvram_base(), get_nvram_size(), 14))); m_eeprom.reset(global_alloc(gba_eeprom_device(machine(), (UINT8*)get_nvram_base(), get_nvram_size(), 14)));

1
src/emu/bus/gba/rom.h
View File

@ -17,7 +17,6 @@ public:
// device-level overrides // device-level overrides
virtual void device_start(); virtual void device_start();
virtual const rom_entry *device_rom_region() const;
virtual void device_reset(); virtual void device_reset();
// reading and writing // reading and writing

11
src/emu/bus/megadrive/md_slot.c
View File

@ -86,6 +86,7 @@ void device_md_cart_interface::rom_alloc(size_t size, const char *tag)
if (m_rom == NULL) if (m_rom == NULL)
{ {
astring tempstring(tag); astring tempstring(tag);
tempstring.cat(MDSLOT_ROM_REGION_TAG);
m_rom = (UINT16 *)device().machine().memory().region_alloc(tempstring, size, 2, ENDIANNESS_LITTLE)->base(); m_rom = (UINT16 *)device().machine().memory().region_alloc(tempstring, size, 2, ENDIANNESS_LITTLE)->base();
m_rom_size = size; m_rom_size = size;
} }
@ -369,9 +370,7 @@ int base_md_cart_slot_device::load_list()
// if cart size is not (2^n * 64K), the system will see anyway that size so we need to alloc a bit more space // if cart size is not (2^n * 64K), the system will see anyway that size so we need to alloc a bit more space
length = m_cart->get_padded_size(length); length = m_cart->get_padded_size(length);
astring cart_string(tag()); m_cart->rom_alloc(length, tag());
cart_string.cat(":cart:rom");
m_cart->rom_alloc(length, cart_string.cstr());
ROM = m_cart->get_rom_base(); ROM = m_cart->get_rom_base();
memcpy((UINT8 *)ROM, get_software_region("rom"), get_software_region_length("rom")); memcpy((UINT8 *)ROM, get_software_region("rom"), get_software_region_length("rom"));
@ -482,11 +481,9 @@ int base_md_cart_slot_device::load_nonlist()
// STEP 2: allocate space for the real copy of the game // STEP 2: allocate space for the real copy of the game
// if cart size is not (2^n * 64K), the system will see anyway that size so we need to alloc a bit more space // if cart size is not (2^n * 64K), the system will see anyway that size so we need to alloc a bit more space
len = m_cart->get_padded_size(tmplen - offset); len = m_cart->get_padded_size(tmplen - offset);
// this contains an hack for SSF2: its current bankswitch code needs larger rom space to work
astring cart_string(tag());
cart_string.cat(":cart:rom");
m_cart->rom_alloc((len == 0x500000) ? 0x900000 : len, cart_string.cstr());
// this contains an hack for SSF2: its current bankswitch code needs larger rom space to work
m_cart->rom_alloc((len == 0x500000) ? 0x900000 : len, tag());
// STEP 3: copy the game data in the appropriate way // STEP 3: copy the game data in the appropriate way
ROM = (unsigned char *)m_cart->get_rom_base(); ROM = (unsigned char *)m_cart->get_rom_base();

2
src/emu/bus/megadrive/md_slot.h
View File

@ -237,6 +237,8 @@ extern const device_type COPERA_CART_SLOT;
DEVICE CONFIGURATION MACROS DEVICE CONFIGURATION MACROS
***************************************************************************/ ***************************************************************************/
#define MDSLOT_ROM_REGION_TAG ":cart:rom"
#define MCFG_MD_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \ #define MCFG_MD_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
MCFG_DEVICE_ADD(_tag, MD_CART_SLOT, 0) \ MCFG_DEVICE_ADD(_tag, MD_CART_SLOT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false) MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

16
src/emu/bus/pce/pce_slot.c
View File

@ -25,7 +25,9 @@ const device_type PCE_CART_SLOT = &device_creator<pce_cart_slot_device>;
//------------------------------------------------- //-------------------------------------------------
device_pce_cart_interface::device_pce_cart_interface(const machine_config &mconfig, device_t &device) device_pce_cart_interface::device_pce_cart_interface(const machine_config &mconfig, device_t &device)
: device_slot_card_interface(mconfig, device) : device_slot_card_interface(mconfig, device),
m_rom(NULL),
m_rom_size(0)
{ {
} }
@ -42,9 +44,15 @@ device_pce_cart_interface::~device_pce_cart_interface()
// rom_alloc - alloc the space for the cart // rom_alloc - alloc the space for the cart
//------------------------------------------------- //-------------------------------------------------
void device_pce_cart_interface::rom_alloc(UINT32 size) void device_pce_cart_interface::rom_alloc(UINT32 size, const char *tag)
{ {
m_rom.resize(size); if (m_rom == NULL)
{
astring tempstring(tag);
tempstring.cat(PCESLOT_ROM_REGION_TAG);
m_rom = device().machine().memory().region_alloc(tempstring, size, 1, ENDIANNESS_LITTLE)->base();
m_rom_size = size;
}
} }
@ -216,7 +224,7 @@ bool pce_cart_slot_device::call_load()
fseek(offset, SEEK_SET); fseek(offset, SEEK_SET);
} }
m_cart->rom_alloc(len); m_cart->rom_alloc(len, tag());
ROM = m_cart->get_rom_base(); ROM = m_cart->get_rom_base();
if (software_entry() == NULL) if (software_entry() == NULL)

9
src/emu/bus/pce/pce_slot.h
View File

@ -30,15 +30,16 @@ public:
virtual DECLARE_READ8_MEMBER(read_cart) { return 0xff; } virtual DECLARE_READ8_MEMBER(read_cart) { return 0xff; }
virtual DECLARE_WRITE8_MEMBER(write_cart) {}; virtual DECLARE_WRITE8_MEMBER(write_cart) {};
void rom_alloc(UINT32 size); void rom_alloc(UINT32 size, const char *tag);
void ram_alloc(UINT32 size); void ram_alloc(UINT32 size);
UINT8* get_rom_base() { return m_rom; } UINT8* get_rom_base() { return m_rom; }
UINT8* get_ram_base() { return m_ram; } UINT8* get_ram_base() { return m_ram; }
UINT32 get_rom_size() { return m_rom.count(); } UINT32 get_rom_size() { return m_rom_size; }
UINT32 get_ram_size() { return m_ram.count(); } UINT32 get_ram_size() { return m_ram.count(); }
// internal state // internal state
dynamic_buffer m_rom; UINT8 *m_rom;
UINT32 m_rom_size;
dynamic_buffer m_ram; dynamic_buffer m_ram;
void rom_map_setup(UINT32 size); void rom_map_setup(UINT32 size);
@ -110,6 +111,8 @@ extern const device_type PCE_CART_SLOT;
DEVICE CONFIGURATION MACROS DEVICE CONFIGURATION MACROS
***************************************************************************/ ***************************************************************************/
#define PCESLOT_ROM_REGION_TAG ":cart:rom"
#define MCFG_PCE_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \ #define MCFG_PCE_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
MCFG_DEVICE_ADD(_tag, PCE_CART_SLOT, 0) \ MCFG_DEVICE_ADD(_tag, PCE_CART_SLOT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false) \ MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false) \

2
src/emu/bus/saturn/rom.c
View File

@ -49,5 +49,5 @@ void saturn_rom_device::device_reset()
READ32_MEMBER(saturn_rom_device::read_rom) READ32_MEMBER(saturn_rom_device::read_rom)
{ {
return m_rom[offset & (m_rom.count() - 1)]; return m_rom[offset & (m_rom_size/4 - 1)];
} }

16
src/emu/bus/saturn/sat_slot.c
View File

@ -35,7 +35,9 @@ const device_type SATURN_CART_SLOT = &device_creator<sat_cart_slot_device>;
//------------------------------------------------- //-------------------------------------------------
device_sat_cart_interface::device_sat_cart_interface(const machine_config &mconfig, device_t &device) device_sat_cart_interface::device_sat_cart_interface(const machine_config &mconfig, device_t &device)
: device_slot_card_interface(mconfig, device) : device_slot_card_interface(mconfig, device),
m_rom(NULL),
m_rom_size(0)
{ {
} }
@ -52,9 +54,15 @@ device_sat_cart_interface::~device_sat_cart_interface()
// rom_alloc - alloc the space for the cart // rom_alloc - alloc the space for the cart
//------------------------------------------------- //-------------------------------------------------
void device_sat_cart_interface::rom_alloc(UINT32 size) void device_sat_cart_interface::rom_alloc(UINT32 size, const char *tag)
{ {
m_rom.resize(size/sizeof(UINT32)); if (m_rom == NULL)
{
astring tempstring(tag);
tempstring.cat(SATSLOT_ROM_REGION_TAG);
m_rom = (UINT32 *)device().machine().memory().region_alloc(tempstring, size, 4, ENDIANNESS_LITTLE)->base();
m_rom_size = size;
}
} }
@ -122,7 +130,7 @@ bool sat_cart_slot_device::call_load()
else else
len = length(); len = length();
m_cart->rom_alloc(len); m_cart->rom_alloc(len, tag());
ROM = m_cart->get_rom_base(); ROM = m_cart->get_rom_base();
if (software_entry() != NULL) if (software_entry() != NULL)

9
src/emu/bus/saturn/sat_slot.h
View File

@ -29,12 +29,12 @@ public:
virtual int get_cart_type() { return m_cart_type; }; virtual int get_cart_type() { return m_cart_type; };
void rom_alloc(UINT32 size); void rom_alloc(UINT32 size, const char *tag);
UINT32* get_rom_base() { return m_rom; } UINT32* get_rom_base() { return m_rom; }
UINT32* get_ext_dram0_base() { return m_ext_dram0; } UINT32* get_ext_dram0_base() { return m_ext_dram0; }
UINT32* get_ext_dram1_base() { return m_ext_dram1; } UINT32* get_ext_dram1_base() { return m_ext_dram1; }
UINT8* get_ext_bram_base() { return m_ext_bram; } UINT8* get_ext_bram_base() { return m_ext_bram; }
UINT32 get_rom_size() { return m_rom.bytes(); } UINT32 get_rom_size() { return m_rom_size; }
UINT32 get_ext_dram0_size() { return m_ext_dram0.bytes(); } UINT32 get_ext_dram0_size() { return m_ext_dram0.bytes(); }
UINT32 get_ext_dram1_size() { return m_ext_dram1.bytes(); } UINT32 get_ext_dram1_size() { return m_ext_dram1.bytes(); }
UINT32 get_ext_bram_size() { return m_ext_bram.bytes(); } UINT32 get_ext_bram_size() { return m_ext_bram.bytes(); }
@ -43,7 +43,8 @@ protected:
int m_cart_type; int m_cart_type;
// internal state // internal state
dynamic_array<UINT32> m_rom; UINT32 *m_rom;
UINT32 m_rom_size;
dynamic_array<UINT32> m_ext_dram0; dynamic_array<UINT32> m_ext_dram0;
dynamic_array<UINT32> m_ext_dram1; dynamic_array<UINT32> m_ext_dram1;
dynamic_buffer m_ext_bram; dynamic_buffer m_ext_bram;
@ -107,6 +108,8 @@ extern const device_type SATURN_CART_SLOT;
DEVICE CONFIGURATION MACROS DEVICE CONFIGURATION MACROS
***************************************************************************/ ***************************************************************************/
#define SATSLOT_ROM_REGION_TAG ":cart:rom"
#define MCFG_SATURN_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \ #define MCFG_SATURN_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
MCFG_DEVICE_ADD(_tag, SATURN_CART_SLOT, 0) \ MCFG_DEVICE_ADD(_tag, SATURN_CART_SLOT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false) MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

12
src/emu/bus/sega8/rom.c
View File

@ -422,7 +422,7 @@ READ8_MEMBER(sega8_othello_device::read_cart)
if (offset >= 0x8000 && offset < 0xa000) if (offset >= 0x8000 && offset < 0xa000)
return m_ram[offset & 0x7ff]; return m_ram[offset & 0x7ff];
return m_rom[offset % m_rom.count()]; return m_rom[offset % m_rom_size];
} }
WRITE8_MEMBER(sega8_othello_device::write_cart) WRITE8_MEMBER(sega8_othello_device::write_cart)
@ -446,7 +446,7 @@ READ8_MEMBER(sega8_castle_device::read_cart)
if (offset >= 0x8000 && offset < 0xa000) if (offset >= 0x8000 && offset < 0xa000)
return m_ram[offset & 0x1fff]; return m_ram[offset & 0x1fff];
return m_rom[offset % m_rom.count()]; return m_rom[offset % m_rom_size];
} }
WRITE8_MEMBER(sega8_castle_device::write_cart) WRITE8_MEMBER(sega8_castle_device::write_cart)
@ -470,7 +470,7 @@ READ8_MEMBER(sega8_basic_l3_device::read_cart)
if (offset >= 0x8000) if (offset >= 0x8000)
return m_ram[offset & 0x3fff]; return m_ram[offset & 0x3fff];
return m_rom[offset % m_rom.count()]; return m_rom[offset % m_rom_size];
} }
WRITE8_MEMBER(sega8_basic_l3_device::write_cart) WRITE8_MEMBER(sega8_basic_l3_device::write_cart)
@ -504,7 +504,7 @@ READ8_MEMBER(sega8_music_editor_device::read_cart)
if (offset >= 0x8000 && offset < 0xa000) if (offset >= 0x8000 && offset < 0xa000)
return m_ram[offset & 0x1fff]; return m_ram[offset & 0x1fff];
return m_rom[offset % m_rom.count()]; return m_rom[offset % m_rom_size];
} }
WRITE8_MEMBER(sega8_music_editor_device::write_cart) WRITE8_MEMBER(sega8_music_editor_device::write_cart)
@ -623,7 +623,7 @@ READ8_MEMBER(sega8_dahjee_typea_device::read_cart)
if (offset >= 0x2000 && offset < 0x4000) if (offset >= 0x2000 && offset < 0x4000)
return m_ram[offset & 0x1fff]; return m_ram[offset & 0x1fff];
return m_rom[offset % m_rom.count()]; return m_rom[offset % m_rom_size];
} }
WRITE8_MEMBER(sega8_dahjee_typea_device::write_cart) WRITE8_MEMBER(sega8_dahjee_typea_device::write_cart)
@ -651,7 +651,7 @@ WRITE8_MEMBER(sega8_dahjee_typea_device::write_ram)
// TYPE B // TYPE B
READ8_MEMBER(sega8_dahjee_typeb_device::read_cart) READ8_MEMBER(sega8_dahjee_typeb_device::read_cart)
{ {
return m_rom[offset % m_rom.count()]; return m_rom[offset % m_rom_size];
} }
READ8_MEMBER(sega8_dahjee_typeb_device::read_ram) READ8_MEMBER(sega8_dahjee_typeb_device::read_ram)

22
src/emu/bus/sega8/sega8_slot.c
View File

@ -49,6 +49,8 @@ const device_type SEGA8_CARD_SLOT = &device_creator<sega8_card_slot_device>;
device_sega8_cart_interface::device_sega8_cart_interface(const machine_config &mconfig, device_t &device) device_sega8_cart_interface::device_sega8_cart_interface(const machine_config &mconfig, device_t &device)
: device_slot_card_interface(mconfig, device), : device_slot_card_interface(mconfig, device),
m_rom(NULL),
m_rom_size(0),
m_rom_page_count(0), m_rom_page_count(0),
has_battery(FALSE), has_battery(FALSE),
m_late_battery_enable(FALSE), m_late_battery_enable(FALSE),
@ -70,13 +72,19 @@ device_sega8_cart_interface::~device_sega8_cart_interface()
// rom_alloc - alloc the space for the cart // rom_alloc - alloc the space for the cart
//------------------------------------------------- //-------------------------------------------------
void device_sega8_cart_interface::rom_alloc(UINT32 size) void device_sega8_cart_interface::rom_alloc(UINT32 size, const char *tag)
{ {
m_rom.resize(size); if (m_rom == NULL)
m_rom_page_count = size / 0x4000; {
if (!m_rom_page_count) astring tempstring(tag);
m_rom_page_count = 1; // we compute rom pages through (XXX % m_rom_page_count)! tempstring.cat(S8SLOT_ROM_REGION_TAG);
late_bank_setup(); m_rom = device().machine().memory().region_alloc(tempstring, size, 1, ENDIANNESS_LITTLE)->base();
m_rom_size = size;
m_rom_page_count = size / 0x4000;
if (!m_rom_page_count)
m_rom_page_count = 1; // we compute rom pages through (XXX % m_rom_page_count)!
late_bank_setup();
}
} }
@ -353,7 +361,7 @@ bool sega8_cart_slot_device::call_load()
if (len & 0x3fff) if (len & 0x3fff)
len = ((len >> 14) + 1) << 14; len = ((len >> 14) + 1) << 14;
m_cart->rom_alloc(len); m_cart->rom_alloc(len, tag());
ROM = m_cart->get_rom_base(); ROM = m_cart->get_rom_base();
if (software_entry() == NULL) if (software_entry() == NULL)

10
src/emu/bus/sega8/sega8_slot.h
View File

@ -49,7 +49,7 @@ public:
virtual DECLARE_READ8_MEMBER(read_ram) { return 0xff; } virtual DECLARE_READ8_MEMBER(read_ram) { return 0xff; }
virtual DECLARE_WRITE8_MEMBER(write_ram) {} virtual DECLARE_WRITE8_MEMBER(write_ram) {}
void rom_alloc(UINT32 size); void rom_alloc(UINT32 size, const char *tag);
void ram_alloc(UINT32 size); void ram_alloc(UINT32 size);
virtual void late_bank_setup() {} virtual void late_bank_setup() {}
@ -66,7 +66,7 @@ public:
//protected: //protected:
UINT8* get_rom_base() { return m_rom; } UINT8* get_rom_base() { return m_rom; }
UINT8* get_ram_base() { return m_ram; } UINT8* get_ram_base() { return m_ram; }
UINT32 get_rom_size() { return m_rom.count(); } UINT32 get_rom_size() { return m_rom_size; }
UINT32 get_ram_size() { return m_ram.count(); } UINT32 get_ram_size() { return m_ram.count(); }
void rom_map_setup(UINT32 size); void rom_map_setup(UINT32 size);
@ -76,7 +76,8 @@ public:
//private: //private:
// internal state // internal state
dynamic_buffer m_rom; UINT8 *m_rom;
UINT32 m_rom_size;
dynamic_buffer m_ram; dynamic_buffer m_ram;
int m_rom_page_count; int m_rom_page_count;
@ -171,6 +172,9 @@ public:
DEVICE CONFIGURATION MACROS DEVICE CONFIGURATION MACROS
***************************************************************************/ ***************************************************************************/
#define S8SLOT_ROM_REGION_TAG ":cart:rom"
#define MCFG_SG1000_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \ #define MCFG_SG1000_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
MCFG_DEVICE_ADD(_tag, SEGA8_CART_SLOT, 0) \ MCFG_DEVICE_ADD(_tag, SEGA8_CART_SLOT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false) \ MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false) \

17
src/emu/bus/snes/snes_slot.c
View File

@ -67,7 +67,9 @@ const device_type SNS_BSX_CART_SLOT = &device_creator<sns_bsx_cart_slot_device>;
//------------------------------------------------- //-------------------------------------------------
device_sns_cart_interface::device_sns_cart_interface(const machine_config &mconfig, device_t &device) device_sns_cart_interface::device_sns_cart_interface(const machine_config &mconfig, device_t &device)
: device_slot_card_interface(mconfig, device) : device_slot_card_interface(mconfig, device),
m_rom(NULL),
m_rom_size(0)
{ {
} }
@ -84,9 +86,15 @@ device_sns_cart_interface::~device_sns_cart_interface()
// rom_alloc - alloc the space for the cart // rom_alloc - alloc the space for the cart
//------------------------------------------------- //-------------------------------------------------
void device_sns_cart_interface::rom_alloc(UINT32 size) void device_sns_cart_interface::rom_alloc(UINT32 size, const char *tag)
{ {
m_rom.resize(size); if (m_rom == NULL)
{
astring tempstring(tag);
tempstring.cat(SNSSLOT_ROM_REGION_TAG);
m_rom = device().machine().memory().region_alloc(tempstring, size, 1, ENDIANNESS_LITTLE)->base();
m_rom_size = size;
}
} }
@ -612,7 +620,7 @@ bool base_sns_cart_slot_device::call_load()
len = (software_entry() == NULL) ? (length() - offset) : get_software_region_length("rom"); len = (software_entry() == NULL) ? (length() - offset) : get_software_region_length("rom");
m_cart->rom_alloc(len); m_cart->rom_alloc(len, tag());
ROM = m_cart->get_rom_base(); ROM = m_cart->get_rom_base();
if (software_entry() == NULL) if (software_entry() == NULL)
fread(ROM, len); fread(ROM, len);
@ -652,7 +660,6 @@ bool base_sns_cart_slot_device::call_load()
// by installing read_bank in address space and mapping m_bios there // by installing read_bank in address space and mapping m_bios there
m_cart->speedup_addon_bios_access(); m_cart->speedup_addon_bios_access();
setup_nvram(); setup_nvram();
if (m_cart->get_nvram_size() || m_cart->get_rtc_ram_size()) if (m_cart->get_nvram_size() || m_cart->get_rtc_ram_size())

10
src/emu/bus/snes/snes_slot.h
View File

@ -111,7 +111,7 @@ public:
virtual DECLARE_WRITE8_MEMBER(chip_write) {} virtual DECLARE_WRITE8_MEMBER(chip_write) {}
virtual void speedup_addon_bios_access() {}; virtual void speedup_addon_bios_access() {};
void rom_alloc(UINT32 size); void rom_alloc(UINT32 size, const char *tag);
void nvram_alloc(UINT32 size); void nvram_alloc(UINT32 size);
void rtc_ram_alloc(UINT32 size); void rtc_ram_alloc(UINT32 size);
void addon_bios_alloc(UINT32 size); void addon_bios_alloc(UINT32 size);
@ -119,7 +119,7 @@ public:
UINT8* get_nvram_base() { return m_nvram; }; UINT8* get_nvram_base() { return m_nvram; };
UINT8* get_addon_bios_base() { return m_bios; }; UINT8* get_addon_bios_base() { return m_bios; };
UINT8* get_rtc_ram_base() { return m_rtc_ram; }; UINT8* get_rtc_ram_base() { return m_rtc_ram; };
UINT32 get_rom_size() { return m_rom.count(); }; UINT32 get_rom_size() { return m_rom_size; };
UINT32 get_nvram_size() { return m_nvram.count(); }; UINT32 get_nvram_size() { return m_nvram.count(); };
UINT32 get_addon_bios_size() { return m_bios.count(); }; UINT32 get_addon_bios_size() { return m_bios.count(); };
UINT32 get_rtc_ram_size() { return m_rtc_ram.count(); }; UINT32 get_rtc_ram_size() { return m_rtc_ram.count(); };
@ -129,7 +129,8 @@ public:
void save_rtc_ram() { device().save_item(NAME(m_rtc_ram)); } void save_rtc_ram() { device().save_item(NAME(m_rtc_ram)); }
// internal state // internal state
dynamic_buffer m_rom; UINT8 *m_rom;
UINT32 m_rom_size;
dynamic_buffer m_nvram; dynamic_buffer m_nvram;
dynamic_buffer m_bios; dynamic_buffer m_bios;
dynamic_buffer m_rtc_ram; // temp pointer to save RTC ram to nvram (will disappear when RTCs become devices) dynamic_buffer m_rtc_ram; // temp pointer to save RTC ram to nvram (will disappear when RTCs become devices)
@ -252,6 +253,9 @@ extern const device_type SNS_BSX_CART_SLOT;
DEVICE CONFIGURATION MACROS DEVICE CONFIGURATION MACROS
***************************************************************************/ ***************************************************************************/
#define SNSSLOT_ROM_REGION_TAG ":cart:rom"
#define MCFG_SNS_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \ #define MCFG_SNS_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
MCFG_DEVICE_ADD(_tag, SNS_CART_SLOT, 0) \ MCFG_DEVICE_ADD(_tag, SNS_CART_SLOT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false) MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

8
src/emu/bus/vcs/rom.c
View File

@ -228,7 +228,7 @@ void a26_rom_3e_device::device_start()
void a26_rom_3e_device::device_reset() void a26_rom_3e_device::device_reset()
{ {
m_num_bank = m_rom.count() / 0x800; m_num_bank = m_rom_size / 0x800;
m_base_bank = m_num_bank - 1; m_base_bank = m_num_bank - 1;
m_ram_bank = 0; m_ram_bank = 0;
m_ram_enable = 0; m_ram_enable = 0;
@ -236,7 +236,7 @@ void a26_rom_3e_device::device_reset()
void a26_rom_3f_device::device_reset() void a26_rom_3f_device::device_reset()
{ {
m_num_bank = m_rom.count() / 0x800; m_num_bank = m_rom_size / 0x800;
m_base_bank = m_num_bank - 1; m_base_bank = m_num_bank - 1;
} }
@ -332,7 +332,7 @@ READ8_MEMBER(a26_rom_2k_device::read_rom)
return m_ram[offset & (m_ram.count() - 1)]; return m_ram[offset & (m_ram.count() - 1)];
} }
return m_rom[offset & (m_rom.count() - 1)]; return m_rom[offset & (m_rom_size - 1)];
} }
/*------------------------------------------------- /*-------------------------------------------------
@ -845,7 +845,7 @@ WRITE8_MEMBER(a26_rom_e7_device::write_bank)
READ8_MEMBER(a26_rom_ua_device::read_rom) READ8_MEMBER(a26_rom_ua_device::read_rom)
{ {
return m_rom[(offset + (m_base_bank * 0x1000)) & (m_rom.count() - 1)]; return m_rom[(offset + (m_base_bank * 0x1000)) & (m_rom_size - 1)];
} }
READ8_MEMBER(a26_rom_ua_device::read_bank) READ8_MEMBER(a26_rom_ua_device::read_bank)

16
src/emu/bus/vcs/vcs_slot.c
View File

@ -28,7 +28,9 @@ const device_type VCS_CART_SLOT = &device_creator<vcs_cart_slot_device>;
//------------------------------------------------- //-------------------------------------------------
device_vcs_cart_interface::device_vcs_cart_interface(const machine_config &mconfig, device_t &device) device_vcs_cart_interface::device_vcs_cart_interface(const machine_config &mconfig, device_t &device)
: device_slot_card_interface(mconfig, device) : device_slot_card_interface(mconfig, device),
m_rom(NULL),
m_rom_size(0)
{ {
} }
@ -45,9 +47,15 @@ device_vcs_cart_interface::~device_vcs_cart_interface()
// rom_alloc - alloc the space for the cart // rom_alloc - alloc the space for the cart
//------------------------------------------------- //-------------------------------------------------
void device_vcs_cart_interface::rom_alloc(UINT32 size) void device_vcs_cart_interface::rom_alloc(UINT32 size, const char *tag)
{ {
m_rom.resize(size); if (m_rom == NULL)
{
astring tempstring(tag);
tempstring.cat(A26SLOT_ROM_REGION_TAG);
m_rom = device().machine().memory().region_alloc(tempstring, size, 1, ENDIANNESS_LITTLE)->base();
m_rom_size = size;
}
} }
//------------------------------------------------- //-------------------------------------------------
@ -206,7 +214,7 @@ bool vcs_cart_slot_device::call_load()
return IMAGE_INIT_FAIL; return IMAGE_INIT_FAIL;
} }
m_cart->rom_alloc(len); m_cart->rom_alloc(len, tag());
ROM = m_cart->get_rom_base(); ROM = m_cart->get_rom_base();
if (software_entry() != NULL) if (software_entry() != NULL)

10
src/emu/bus/vcs/vcs_slot.h
View File

@ -59,16 +59,17 @@ public:
virtual void setup_addon_ptr(UINT8 *ptr) {} virtual void setup_addon_ptr(UINT8 *ptr) {}
void rom_alloc(UINT32 size); void rom_alloc(UINT32 size, const char *tag);
void ram_alloc(UINT32 size); void ram_alloc(UINT32 size);
UINT8* get_rom_base() { return m_rom; } UINT8* get_rom_base() { return m_rom; }
UINT8* get_ram_base() { return m_ram; } UINT8* get_ram_base() { return m_ram; }
UINT32 get_rom_size() { return m_rom.bytes(); } UINT32 get_rom_size() { return m_rom_size; }
UINT32 get_ram_size() { return m_ram.bytes(); } UINT32 get_ram_size() { return m_ram.bytes(); }
protected: protected:
// internal state // internal state
dynamic_buffer m_rom; UINT8 *m_rom;
UINT32 m_rom_size;
dynamic_buffer m_ram; dynamic_buffer m_ram;
}; };
@ -146,6 +147,9 @@ extern const device_type VCS_CART_SLOT;
DEVICE CONFIGURATION MACROS DEVICE CONFIGURATION MACROS
***************************************************************************/ ***************************************************************************/
#define A26SLOT_ROM_REGION_TAG ":cart:rom"
#define MCFG_VCS_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \ #define MCFG_VCS_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
MCFG_DEVICE_ADD(_tag, VCS_CART_SLOT, 0) \ MCFG_DEVICE_ADD(_tag, VCS_CART_SLOT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false) MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)

44
src/mess/drivers/a2600.c
View File

@ -32,7 +32,7 @@ public:
m_riot_ram(*this, "riot_ram"), m_riot_ram(*this, "riot_ram"),
m_joy1(*this, CONTROL1_TAG), m_joy1(*this, CONTROL1_TAG),
m_joy2(*this, CONTROL2_TAG) , m_joy2(*this, CONTROL2_TAG) ,
m_cartslot(*this, "cartslot"), m_cart(*this, "cartslot"),
m_tia(*this, "tia_video"), m_tia(*this, "tia_video"),
m_maincpu(*this, "maincpu"), m_maincpu(*this, "maincpu"),
m_screen(*this, "screen") { } m_screen(*this, "screen") { }
@ -58,7 +58,7 @@ public:
protected: protected:
required_device<vcs_control_port_device> m_joy1; required_device<vcs_control_port_device> m_joy1;
required_device<vcs_control_port_device> m_joy2; required_device<vcs_control_port_device> m_joy2;
required_device<vcs_cart_slot_device> m_cartslot; required_device<vcs_cart_slot_device> m_cart;
required_device<tia_video_device> m_tia; required_device<tia_video_device> m_tia;
unsigned long detect_2600controllers(); unsigned long detect_2600controllers();
@ -236,15 +236,13 @@ WRITE16_MEMBER(a2600_state::a2600_tia_vsync_callback_pal)
READ8_MEMBER(a2600_state::cart_over_riot_r) READ8_MEMBER(a2600_state::cart_over_riot_r)
{ {
if (!space.debugger_access()) if (!space.debugger_access())
if (m_cartslot) m_cart->write_bank(space, offset, 0);
m_cartslot->write_bank(space, offset, 0);
return m_riot_ram[0x20 + offset]; return m_riot_ram[0x20 + offset];
} }
WRITE8_MEMBER(a2600_state::cart_over_riot_w) WRITE8_MEMBER(a2600_state::cart_over_riot_w)
{ {
if (m_cartslot) m_cart->write_bank(space, offset, 0);
m_cartslot->write_bank(space, offset, 0);
m_riot_ram[0x20 + offset] = data; m_riot_ram[0x20 + offset] = data;
} }
@ -252,9 +250,7 @@ WRITE8_MEMBER(a2600_state::cart_over_riot_w)
WRITE8_MEMBER(a2600_state::cart_over_tia_w) WRITE8_MEMBER(a2600_state::cart_over_tia_w)
{ {
// Both Cart & TIA see these addresses // Both Cart & TIA see these addresses
if (m_cartslot) m_cart->write_bank(space, offset, data);
m_cartslot->write_bank(space, offset, data);
m_tia->write(space, offset, data); m_tia->write(space, offset, data);
} }
@ -263,7 +259,7 @@ MACHINE_START_MEMBER(a2600_state,a2600)
m_current_screen_height = m_screen->height(); m_current_screen_height = m_screen->height();
memset(m_riot_ram, 0x00, 0x80); memset(m_riot_ram, 0x00, 0x80);
switch (m_cartslot->get_cart_type()) switch (m_cart->get_cart_type())
{ {
case A26_2K: case A26_2K:
case A26_4K: case A26_4K:
@ -277,44 +273,44 @@ MACHINE_START_MEMBER(a2600_state,a2600)
case A26_DC: case A26_DC:
case A26_FV: case A26_FV:
case A26_8IN1: case A26_8IN1:
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cart));
break; break;
case A26_F6: case A26_F6:
case A26_DPC: case A26_DPC:
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(vcs_cart_slot_device::cart_opbase),(vcs_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).set_direct_update_handler(direct_update_delegate(FUNC(vcs_cart_slot_device::cart_opbase),(vcs_cart_slot_device*)m_cart));
break; break;
case A26_FE: case A26_FE:
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot), write8_delegate(FUNC(vcs_cart_slot_device::write_ram),(vcs_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart), write8_delegate(FUNC(vcs_cart_slot_device::write_ram),(vcs_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x01fe, 0x01ff, read8_delegate(FUNC(vcs_cart_slot_device::read_bank),(vcs_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x01fe, 0x01ff, read8_delegate(FUNC(vcs_cart_slot_device::read_bank),(vcs_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_write_handler(0x01fe, 0x01fe, write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_write_handler(0x01fe, 0x01fe, write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cart));
break; break;
case A26_3E: case A26_3E:
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot), write8_delegate(FUNC(vcs_cart_slot_device::write_ram),(vcs_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart), write8_delegate(FUNC(vcs_cart_slot_device::write_ram),(vcs_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_write_handler(0x00, 0x3f, write8_delegate(FUNC(a2600_state::cart_over_tia_w), this)); m_maincpu->space(AS_PROGRAM).install_write_handler(0x00, 0x3f, write8_delegate(FUNC(a2600_state::cart_over_tia_w), this));
break; break;
case A26_3F: case A26_3F:
m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_write_handler(0x00, 0x3f, write8_delegate(FUNC(a2600_state::cart_over_tia_w), this)); m_maincpu->space(AS_PROGRAM).install_write_handler(0x00, 0x3f, write8_delegate(FUNC(a2600_state::cart_over_tia_w), this));
break; break;
case A26_UA: case A26_UA:
m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x200, 0x27f, read8_delegate(FUNC(vcs_cart_slot_device::read_bank),(vcs_cart_slot_device*)m_cartslot), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x200, 0x27f, read8_delegate(FUNC(vcs_cart_slot_device::read_bank),(vcs_cart_slot_device*)m_cart), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cart));
break; break;
case A26_JVP: case A26_JVP:
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart), write8_delegate(FUNC(vcs_cart_slot_device::write_bank),(vcs_cart_slot_device*)m_cart));
// to verify the actual behavior... // to verify the actual behavior...
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xfa0, 0xfc0, read8_delegate(FUNC(a2600_state::cart_over_riot_r), this), write8_delegate(FUNC(a2600_state::cart_over_riot_w), this)); m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xfa0, 0xfc0, read8_delegate(FUNC(a2600_state::cart_over_riot_r), this), write8_delegate(FUNC(a2600_state::cart_over_riot_w), this));
break; break;
case A26_4IN1: case A26_4IN1:
case A26_32IN1: case A26_32IN1:
m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart));
break; break;
case A26_SS: case A26_SS:
m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart));
break; break;
case A26_CM: case A26_CM:
m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(vcs_cart_slot_device::read_rom),(vcs_cart_slot_device*)m_cart));
break; break;
} }

54
src/mess/drivers/a7800.c
View File

@ -119,7 +119,7 @@ public:
m_io_buttons(*this, "buttons"), m_io_buttons(*this, "buttons"),
m_io_vblank(*this, "vblank"), m_io_vblank(*this, "vblank"),
m_io_console_buttons(*this, "console_buttons"), m_io_console_buttons(*this, "console_buttons"),
m_cartslot(*this, "cartslot"), m_cart(*this, "cartslot"),
m_screen(*this, "screen") { } m_screen(*this, "screen") { }
int m_lines; int m_lines;
@ -160,7 +160,7 @@ protected:
required_ioport m_io_buttons; required_ioport m_io_buttons;
required_ioport m_io_vblank; required_ioport m_io_vblank;
required_ioport m_io_console_buttons; required_ioport m_io_console_buttons;
required_device<a78_cart_slot_device> m_cartslot; required_device<a78_cart_slot_device> m_cart;
required_device<screen_device> m_screen; required_device<screen_device> m_screen;
}; };
@ -272,7 +272,7 @@ READ8_MEMBER(a7800_state::bios_or_cart_r)
if (!(m_ctrl_reg & 0x04)) if (!(m_ctrl_reg & 0x04))
return m_bios[offset]; return m_bios[offset];
else else
return m_cartslot->read_40xx(space, offset + 0x8000); return m_cart->read_40xx(space, offset + 0x8000);
} }
/*************************************************************************** /***************************************************************************
@ -1315,30 +1315,32 @@ void a7800_state::machine_start()
save_item(NAME(m_maria_flag)); save_item(NAME(m_maria_flag));
// install additional handlers, if needed // install additional handlers, if needed
if (m_cartslot->exists()) if (m_cart->exists())
switch (m_cartslot->get_cart_type())
{ {
case A78_HSC: switch (m_cart->get_cart_type())
// ROM+NVRAM accesses for HiScore {
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x17ff, read8_delegate(FUNC(a78_cart_slot_device::read_10xx),(a78_cart_slot_device*)m_cartslot), write8_delegate(FUNC(a78_cart_slot_device::write_10xx),(a78_cart_slot_device*)m_cartslot)); case A78_HSC:
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x3000, 0x3fff, read8_delegate(FUNC(a78_cart_slot_device::read_30xx),(a78_cart_slot_device*)m_cartslot), write8_delegate(FUNC(a78_cart_slot_device::write_30xx),(a78_cart_slot_device*)m_cartslot)); // ROM+NVRAM accesses for HiScore
break; m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x17ff, read8_delegate(FUNC(a78_cart_slot_device::read_10xx),(a78_cart_slot_device*)m_cart), write8_delegate(FUNC(a78_cart_slot_device::write_10xx),(a78_cart_slot_device*)m_cart));
case A78_XB_BOARD: m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x3000, 0x3fff, read8_delegate(FUNC(a78_cart_slot_device::read_30xx),(a78_cart_slot_device*)m_cart), write8_delegate(FUNC(a78_cart_slot_device::write_30xx),(a78_cart_slot_device*)m_cart));
case A78_TYPE0_POK450: break;
case A78_TYPE1_POK450: case A78_XB_BOARD:
case A78_TYPE6_POK450: case A78_TYPE0_POK450:
case A78_TYPEA_POK450: case A78_TYPE1_POK450:
case A78_VERSA_POK450: case A78_TYPE6_POK450:
// POKEY and RAM regs at 0x400-0x47f case A78_TYPEA_POK450:
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x0400, 0x047f, read8_delegate(FUNC(a78_cart_slot_device::read_04xx),(a78_cart_slot_device*)m_cartslot), write8_delegate(FUNC(a78_cart_slot_device::write_04xx),(a78_cart_slot_device*)m_cartslot)); case A78_VERSA_POK450:
break; // POKEY and RAM regs at 0x400-0x47f
case A78_XM_BOARD: m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x0400, 0x047f, read8_delegate(FUNC(a78_cart_slot_device::read_04xx),(a78_cart_slot_device*)m_cart), write8_delegate(FUNC(a78_cart_slot_device::write_04xx),(a78_cart_slot_device*)m_cart));
// POKEY and RAM and YM regs at 0x400-0x47f break;
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x0400, 0x047f, read8_delegate(FUNC(a78_cart_slot_device::read_04xx),(a78_cart_slot_device*)m_cartslot), write8_delegate(FUNC(a78_cart_slot_device::write_04xx),(a78_cart_slot_device*)m_cartslot)); case A78_XM_BOARD:
// ROM+NVRAM accesses for HiScore // POKEY and RAM and YM regs at 0x400-0x47f
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x17ff, read8_delegate(FUNC(a78_cart_slot_device::read_10xx),(a78_cart_slot_device*)m_cartslot), write8_delegate(FUNC(a78_cart_slot_device::write_10xx),(a78_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x0400, 0x047f, read8_delegate(FUNC(a78_cart_slot_device::read_04xx),(a78_cart_slot_device*)m_cart), write8_delegate(FUNC(a78_cart_slot_device::write_04xx),(a78_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x3000, 0x3fff, read8_delegate(FUNC(a78_cart_slot_device::read_30xx),(a78_cart_slot_device*)m_cartslot), write8_delegate(FUNC(a78_cart_slot_device::write_30xx),(a78_cart_slot_device*)m_cartslot)); // ROM+NVRAM accesses for HiScore
break; m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x17ff, read8_delegate(FUNC(a78_cart_slot_device::read_10xx),(a78_cart_slot_device*)m_cart), write8_delegate(FUNC(a78_cart_slot_device::write_10xx),(a78_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x3000, 0x3fff, read8_delegate(FUNC(a78_cart_slot_device::read_30xx),(a78_cart_slot_device*)m_cart), write8_delegate(FUNC(a78_cart_slot_device::write_30xx),(a78_cart_slot_device*)m_cart));
break;
}
} }
} }

366
src/mess/drivers/atari400.c
View File

@ -251,8 +251,8 @@ public:
m_0000(*this, "0000"), m_0000(*this, "0000"),
m_8000(*this, "8000"), m_8000(*this, "8000"),
m_a000(*this, "a000"), m_a000(*this, "a000"),
m_cartslot(*this, "cartleft"), m_cart(*this, "cartleft"),
m_cartslot2(*this, "cartright") { } m_cart2(*this, "cartright") { }
DECLARE_MACHINE_START(a400); DECLARE_MACHINE_START(a400);
DECLARE_MACHINE_START(a800); DECLARE_MACHINE_START(a800);
@ -296,8 +296,8 @@ protected:
optional_memory_bank m_0000; optional_memory_bank m_0000;
optional_memory_bank m_8000; optional_memory_bank m_8000;
optional_memory_bank m_a000; optional_memory_bank m_a000;
optional_device<a800_cart_slot_device> m_cartslot; optional_device<a800_cart_slot_device> m_cart;
optional_device<a800_cart_slot_device> m_cartslot2; optional_device<a800_cart_slot_device> m_cart2;
int m_cart_disabled; int m_cart_disabled;
int m_last_offs; int m_last_offs;
@ -1735,98 +1735,100 @@ READ8_MEMBER(a400_state::read_d5xx)
WRITE8_MEMBER(a400_state::disable_cart) WRITE8_MEMBER(a400_state::disable_cart)
{ {
if (m_cartslot->exists()) if (m_cart->exists())
switch (m_cartslot->get_cart_type())
{ {
case A800_PHOENIX: switch (m_cart->get_cart_type())
case A800_BLIZZARD: {
if (!m_cart_disabled) case A800_PHOENIX:
{ case A800_BLIZZARD:
m_cart_disabled = 1; if (!m_cart_disabled)
setup_ram(2, m_ram->size());
}
break;
case A800_OSS034M:
case A800_OSS043M:
case A800_EXPRESS:
case A800_DIAMOND:
case A800_WILLIAMS:
// use m_cart_disabled & m_last_offs to avoid continuous remapping of
// the memory space in some games (e.g. dropzone)
if (offset & 0x8 && !m_cart_disabled)
{
m_cart_disabled = 1;
setup_ram(2, m_ram->size());
}
else if (!(offset & 0x8))
{
if (m_cart_disabled)
{ {
m_cart_disabled = 0; m_cart_disabled = 1;
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cartslot)); setup_ram(2, m_ram->size());
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
} }
break;
case A800_OSS034M:
case A800_OSS043M:
case A800_EXPRESS:
case A800_DIAMOND:
case A800_WILLIAMS:
// use m_cart_disabled & m_last_offs to avoid continuous remapping of
// the memory space in some games (e.g. dropzone)
if (offset & 0x8 && !m_cart_disabled)
{
m_cart_disabled = 1;
setup_ram(2, m_ram->size());
}
else if (!(offset & 0x8))
{
if (m_cart_disabled)
{
m_cart_disabled = 0;
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
}
if ((offset & 0x7) != m_last_offs) if ((offset & 0x7) != m_last_offs)
{ {
// we enter here only if we are writing to a different offset than last time // we enter here only if we are writing to a different offset than last time
m_last_offs = offset & 0x7; m_last_offs = offset & 0x7;
m_cartslot->write_d5xx(space, offset, data); m_cart->write_d5xx(space, offset, data);
}
} }
} break;
break; case A800_TURBO64:
case A800_TURBO64: case A800_TURBO128:
case A800_TURBO128: if (offset & 0x10 && !m_cart_disabled)
if (offset & 0x10 && !m_cart_disabled)
{
m_cart_disabled = 1;
setup_ram(2, m_ram->size());
}
else if (!(offset & 0x10))
{
if (m_cart_disabled)
{ {
m_cart_disabled = 0; m_cart_disabled = 1;
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cartslot)); setup_ram(2, m_ram->size());
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
} }
else if (!(offset & 0x10))
{
if (m_cart_disabled)
{
m_cart_disabled = 0;
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
}
if ((offset & 0x0f) != m_last_offs) if ((offset & 0x0f) != m_last_offs)
{ {
// we enter here only if we are writing to a different offset than last time // we enter here only if we are writing to a different offset than last time
m_last_offs = offset & 0x0f; m_last_offs = offset & 0x0f;
m_cartslot->write_d5xx(space, offset & 0x0f, data); m_cart->write_d5xx(space, offset & 0x0f, data);
}
} }
} break;
break; case A800_SPARTADOS:
case A800_SPARTADOS: // writes with offset & 8 are also used to enable/disable the subcart, so they go through!
// writes with offset & 8 are also used to enable/disable the subcart, so they go through! m_cart->write_d5xx(space, offset, data);
m_cartslot->write_d5xx(space, offset, data); break;
break; case A800_OSSM091:
case A800_OSSM091: case A800_OSS8K:
case A800_OSS8K: if ((offset & 0x9) == 0x08)
if ((offset & 0x9) == 0x08) setup_ram(2, m_ram->size());
setup_ram(2, m_ram->size()); else
else {
{ m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff); m_cart->write_d5xx(space, offset, data);
m_cartslot->write_d5xx(space, offset, data); }
} break;
break; case A800_MICROCALC:
case A800_MICROCALC: m_cart_disabled = (m_cart_disabled + 1) % 5;
m_cart_disabled = (m_cart_disabled + 1) % 5; if (m_cart_disabled == 4)
if (m_cart_disabled == 4) setup_ram(2, m_ram->size());
setup_ram(2, m_ram->size()); else
else {
{ m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff); m_cart->write_d5xx(space, offset, m_cart_disabled);
m_cartslot->write_d5xx(space, offset, m_cart_disabled); }
} break;
break; default:
default: break;
break; }
} }
} }
@ -1836,96 +1838,98 @@ void a400_state::setup_cart(a800_cart_slot_device *slot)
m_last_offs = -1; m_last_offs = -1;
if (slot->exists()) if (slot->exists())
switch (slot->get_cart_type())
{ {
case A800_8K: switch (slot->get_cart_type())
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); {
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff); case A800_8K:
break; m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
case A800_8K_RIGHT: m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0x9fff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); break;
m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0x9fff); case A800_8K_RIGHT:
break; m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0x9fff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
case A800_16K: m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0x9fff);
m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); break;
m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0xbfff); case A800_16K:
break; m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
case A800_PHOENIX: m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0xbfff);
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); break;
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff); case A800_PHOENIX:
m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a400_state::disable_cart), this)); m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
break; m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
case A800_BBSB: m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a400_state::disable_cart), this));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); break;
m_maincpu->space(AS_PROGRAM).install_write_handler(0x8000, 0x9fff, write8_delegate(FUNC(a800_cart_slot_device::write_80xx),(a800_cart_slot_device*)slot)); case A800_BBSB:
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff); m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
break; m_maincpu->space(AS_PROGRAM).install_write_handler(0x8000, 0x9fff, write8_delegate(FUNC(a800_cart_slot_device::write_80xx),(a800_cart_slot_device*)slot));
case A800_OSS034M: m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
case A800_OSS043M: break;
case A800_OSSM091: case A800_OSS034M:
case A800_OSS8K: case A800_OSS043M:
case A800_TURBO64: case A800_OSSM091:
case A800_TURBO128: case A800_OSS8K:
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); case A800_TURBO64:
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff); case A800_TURBO128:
m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a400_state::disable_cart), this)); m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
break; m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
case A800_MICROCALC: m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a400_state::disable_cart), this));
// this can also disable ROM when reading in 0xd500-0xd5ff break;
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); case A800_MICROCALC:
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff); // this can also disable ROM when reading in 0xd500-0xd5ff
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xd500, 0xd5ff, read8_delegate(FUNC(a400_state::read_d5xx), this), write8_delegate(FUNC(a400_state::disable_cart), this)); m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
break; m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
case A800_EXPRESS: m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xd500, 0xd5ff, read8_delegate(FUNC(a400_state::read_d5xx), this), write8_delegate(FUNC(a400_state::disable_cart), this));
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); break;
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff); case A800_EXPRESS:
m_maincpu->space(AS_PROGRAM).install_write_handler(0xd570, 0xd57f, write8_delegate(FUNC(a400_state::disable_cart), this)); m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
break; m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
case A800_DIAMOND: m_maincpu->space(AS_PROGRAM).install_write_handler(0xd570, 0xd57f, write8_delegate(FUNC(a400_state::disable_cart), this));
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); break;
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff); case A800_DIAMOND:
m_maincpu->space(AS_PROGRAM).install_write_handler(0xd5d0, 0xd5df, write8_delegate(FUNC(a400_state::disable_cart), this)); m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
break; m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
case A800_WILLIAMS: m_maincpu->space(AS_PROGRAM).install_write_handler(0xd5d0, 0xd5df, write8_delegate(FUNC(a400_state::disable_cart), this));
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); break;
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff); case A800_WILLIAMS:
m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd50f, write8_delegate(FUNC(a400_state::disable_cart), this)); m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
break; m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
case A800_SPARTADOS: m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd50f, write8_delegate(FUNC(a400_state::disable_cart), this));
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); break;
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff); case A800_SPARTADOS:
m_maincpu->space(AS_PROGRAM).install_write_handler(0xd5e0, 0xd5ef, write8_delegate(FUNC(a400_state::disable_cart), this)); m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
break; m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
case A800_TELELINK2: m_maincpu->space(AS_PROGRAM).install_write_handler(0xd5e0, 0xd5ef, write8_delegate(FUNC(a400_state::disable_cart), this));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); break;
m_maincpu->space(AS_PROGRAM).install_write_handler(0x9000, 0x90ff, write8_delegate(FUNC(a800_cart_slot_device::write_80xx),(a800_cart_slot_device*)slot)); case A800_TELELINK2:
m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff); m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
m_maincpu->space(AS_PROGRAM).install_read_handler(0xd501, 0xd501, read8_delegate(FUNC(a800_cart_slot_device::read_d5xx),(a800_cart_slot_device*)slot)); m_maincpu->space(AS_PROGRAM).install_write_handler(0x9000, 0x90ff, write8_delegate(FUNC(a800_cart_slot_device::write_80xx),(a800_cart_slot_device*)slot));
m_maincpu->space(AS_PROGRAM).install_write_handler(0xd502, 0xd502, write8_delegate(FUNC(a800_cart_slot_device::write_d5xx),(a800_cart_slot_device*)slot)); m_maincpu->space(AS_PROGRAM).unmap_write(0xa000, 0xbfff);
break; m_maincpu->space(AS_PROGRAM).install_read_handler(0xd501, 0xd501, read8_delegate(FUNC(a800_cart_slot_device::read_d5xx),(a800_cart_slot_device*)slot));
case A800_BLIZZARD: m_maincpu->space(AS_PROGRAM).install_write_handler(0xd502, 0xd502, write8_delegate(FUNC(a800_cart_slot_device::write_d5xx),(a800_cart_slot_device*)slot));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); break;
m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0xbfff); case A800_BLIZZARD:
m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a400_state::disable_cart), this)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
break; m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0xbfff);
case A800_XEGS: m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a400_state::disable_cart), this));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); break;
m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0xbfff); case A800_XEGS:
m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a800_cart_slot_device::write_d5xx),(a800_cart_slot_device*)slot)); m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
break; m_maincpu->space(AS_PROGRAM).unmap_write(0x8000, 0xbfff);
case A5200_4K: m_maincpu->space(AS_PROGRAM).install_write_handler(0xd500, 0xd5ff, write8_delegate(FUNC(a800_cart_slot_device::write_d5xx),(a800_cart_slot_device*)slot));
case A5200_8K: break;
case A5200_16K: case A5200_4K:
case A5200_32K: case A5200_8K:
case A5200_16K_2CHIPS: case A5200_16K:
m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); case A5200_32K:
m_maincpu->space(AS_PROGRAM).unmap_write(0x4000, 0xbfff); case A5200_16K_2CHIPS:
break; m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
case A5200_BBSB: m_maincpu->space(AS_PROGRAM).unmap_write(0x4000, 0xbfff);
m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot)); break;
m_maincpu->space(AS_PROGRAM).install_write_handler(0x4000, 0x5fff, write8_delegate(FUNC(a800_cart_slot_device::write_80xx),(a800_cart_slot_device*)slot)); case A5200_BBSB:
m_maincpu->space(AS_PROGRAM).unmap_write(0x6000, 0xbfff); m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000, 0xbfff, read8_delegate(FUNC(a800_cart_slot_device::read_80xx),(a800_cart_slot_device*)slot));
break; m_maincpu->space(AS_PROGRAM).install_write_handler(0x4000, 0x5fff, write8_delegate(FUNC(a800_cart_slot_device::write_80xx),(a800_cart_slot_device*)slot));
m_maincpu->space(AS_PROGRAM).unmap_write(0x6000, 0xbfff);
break;
}
} }
} }
@ -1957,7 +1961,7 @@ MACHINE_START_MEMBER( a400_state, a400 )
setup_ram(0, m_ram->size()); setup_ram(0, m_ram->size());
setup_ram(1, m_ram->size()); setup_ram(1, m_ram->size());
setup_ram(2, m_ram->size()); setup_ram(2, m_ram->size());
setup_cart(m_cartslot); setup_cart(m_cart);
save_item(NAME(m_cart_disabled)); save_item(NAME(m_cart_disabled));
save_item(NAME(m_last_offs)); save_item(NAME(m_last_offs));
@ -1969,8 +1973,8 @@ MACHINE_START_MEMBER( a400_state, a800 )
setup_ram(0, m_ram->size()); setup_ram(0, m_ram->size());
setup_ram(1, m_ram->size()); setup_ram(1, m_ram->size());
setup_ram(2, m_ram->size()); setup_ram(2, m_ram->size());
setup_cart(m_cartslot); setup_cart(m_cart);
setup_cart(m_cartslot2); setup_cart(m_cart2);
save_item(NAME(m_cart_disabled)); save_item(NAME(m_cart_disabled));
save_item(NAME(m_last_offs)); save_item(NAME(m_last_offs));
@ -1980,7 +1984,7 @@ MACHINE_START_MEMBER( a400_state, a800xl )
{ {
m_mmu = 0xfd; m_mmu = 0xfd;
m_ext_bank = 0x03; // only used by a130xe m_ext_bank = 0x03; // only used by a130xe
setup_cart(m_cartslot); setup_cart(m_cart);
save_item(NAME(m_cart_disabled)); save_item(NAME(m_cart_disabled));
save_item(NAME(m_last_offs)); save_item(NAME(m_last_offs));
@ -1991,7 +1995,7 @@ MACHINE_START_MEMBER( a400_state, a800xl )
MACHINE_START_MEMBER( a400_state, a5200 ) MACHINE_START_MEMBER( a400_state, a5200 )
{ {
setup_cart(m_cartslot); setup_cart(m_cart);
save_item(NAME(m_cart_disabled)); save_item(NAME(m_cart_disabled));
save_item(NAME(m_last_offs)); save_item(NAME(m_last_offs));

66
src/mess/drivers/gba.c
View File

@ -2118,34 +2118,48 @@ void gba_state::machine_start()
m_irq_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(gba_state::handle_irq),this)); m_irq_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(gba_state::handle_irq),this));
m_irq_timer->adjust(attotime::never); m_irq_timer->adjust(attotime::never);
// install the cart ROM into the address map, if present // install the cart ROM & SRAM into the address map, if present
m_cartslot->install_rom(); if (m_cart->exists())
{
address_space &space = machine().device<cpu_device>("maincpu")->space(AS_PROGRAM);
space.install_read_bank(0x08000000, 0x09ffffff, 0, 0, "rom1");
space.install_read_bank(0x0a000000, 0x0bffffff, 0, 0, "rom2");
space.install_read_bank(0x0c000000, 0x0cffffff, 0, 0, "rom3");
// add nvram to save state astring region_tag;
m_cartslot->save_nvram(); memory_region *cart_rom = memregion(region_tag.cpy(m_cart->tag()).cat(GBASLOT_ROM_REGION_TAG));
// install the cart NVRAM handlers if necessary // install ROM accesses
if (m_cartslot->get_type() == GBA_SRAM) membank("rom1")->set_base(cart_rom->base());
{ membank("rom2")->set_base(cart_rom->base());
m_maincpu->space(AS_PROGRAM).install_read_handler(0xe000000, 0xe00ffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cartslot)); membank("rom3")->set_base(cart_rom->base());
m_maincpu->space(AS_PROGRAM).install_write_handler(0xe000000, 0xe00ffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cartslot));
} // add nvram to save state
if (m_cartslot->get_type() == GBA_EEPROM || m_cartslot->get_type() == GBA_EEPROM4 || m_cartslot->get_type() == GBA_EEPROM64) m_cart->save_nvram();
{
// for games larger than 16MB the actual range is smaller but read_ram/write_ram handles that! // install the cart NVRAM handlers if necessary
m_maincpu->space(AS_PROGRAM).install_read_handler(0xd000000, 0xdffffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cartslot)); if (m_cart->get_type() == GBA_SRAM)
m_maincpu->space(AS_PROGRAM).install_write_handler(0xd000000, 0xdffffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cartslot)); {
} m_maincpu->space(AS_PROGRAM).install_read_handler(0xe000000, 0xe00ffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cart));
// merge the two flash and mask accesses in read_ram?!? m_maincpu->space(AS_PROGRAM).install_write_handler(0xe000000, 0xe00ffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cart));
if (m_cartslot->get_type() == GBA_FLASH || m_cartslot->get_type() == GBA_FLASH512) }
{ if (m_cart->get_type() == GBA_EEPROM || m_cart->get_type() == GBA_EEPROM4 || m_cart->get_type() == GBA_EEPROM64)
m_maincpu->space(AS_PROGRAM).install_read_handler(0xe000000, 0xe00ffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cartslot)); {
m_maincpu->space(AS_PROGRAM).install_write_handler(0xe000000, 0xe00ffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cartslot)); // for games larger than 16MB the actual range is smaller but read_ram/write_ram handles that!
} m_maincpu->space(AS_PROGRAM).install_read_handler(0xd000000, 0xdffffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cart));
if (m_cartslot->get_type() == GBA_FLASH1M) m_maincpu->space(AS_PROGRAM).install_write_handler(0xd000000, 0xdffffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cart));
{ }
m_maincpu->space(AS_PROGRAM).install_read_handler(0xe000000, 0xe01ffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cartslot)); // merge the two flash and mask accesses in read_ram?!?
m_maincpu->space(AS_PROGRAM).install_write_handler(0xe000000, 0xe01ffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cartslot)); if (m_cart->get_type() == GBA_FLASH || m_cart->get_type() == GBA_FLASH512)
{
m_maincpu->space(AS_PROGRAM).install_read_handler(0xe000000, 0xe00ffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_write_handler(0xe000000, 0xe00ffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cart));
}
if (m_cart->get_type() == GBA_FLASH1M)
{
m_maincpu->space(AS_PROGRAM).install_read_handler(0xe000000, 0xe01ffff, read32_delegate(FUNC(gba_cart_slot_device::read_ram),(gba_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_write_handler(0xe000000, 0xe01ffff, write32_delegate(FUNC(gba_cart_slot_device::write_ram),(gba_cart_slot_device*)m_cart));
}
} }
save_item(NAME(m_DISPSTAT)); save_item(NAME(m_DISPSTAT));

18
src/mess/drivers/megadriv.c
View File

@ -91,8 +91,8 @@ READ8_MEMBER(md_cons_state::mess_md_io_read_data_port)
else else
{ {
UINT8 svp_test = 0; UINT8 svp_test = 0;
if (m_slotcart) if (m_cart)
svp_test = m_slotcart->read_test(); svp_test = m_cart->read_test();
// handle test input for SVP test // handle test input for SVP test
if (portnum == 0 && svp_test) if (portnum == 0 && svp_test)
@ -266,8 +266,8 @@ MACHINE_START_MEMBER(md_cons_state, md_common)
m_vdp->stop_timers(); m_vdp->stop_timers();
if (m_slotcart) if (m_cart)
m_slotcart->save_nvram(); m_cart->save_nvram();
} }
MACHINE_START_MEMBER(md_cons_state, ms_megadriv) MACHINE_START_MEMBER(md_cons_state, ms_megadriv)
@ -275,14 +275,14 @@ MACHINE_START_MEMBER(md_cons_state, ms_megadriv)
MACHINE_START_CALL_MEMBER( md_common ); MACHINE_START_CALL_MEMBER( md_common );
// the SVP introduces some kind of DMA 'lag', which we have to compensate for, this is obvious even on gfx DMAd from ROM (the Speedometer) // the SVP introduces some kind of DMA 'lag', which we have to compensate for, this is obvious even on gfx DMAd from ROM (the Speedometer)
if (m_slotcart->get_type() == SEGA_SVP) if (m_cart->get_type() == SEGA_SVP)
m_vdp->set_dma_delay(2); m_vdp->set_dma_delay(2);
// for now m_cartslot is only in MD and not 32x and SegaCD // for now m_cartslot is only in MD and not 32x and SegaCD
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x000000, 0x7fffff, read16_delegate(FUNC(base_md_cart_slot_device::read),(base_md_cart_slot_device*)m_slotcart), write16_delegate(FUNC(base_md_cart_slot_device::write),(base_md_cart_slot_device*)m_slotcart)); m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x000000, 0x7fffff, read16_delegate(FUNC(base_md_cart_slot_device::read),(base_md_cart_slot_device*)m_cart), write16_delegate(FUNC(base_md_cart_slot_device::write),(base_md_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xa13000, 0xa130ff, read16_delegate(FUNC(base_md_cart_slot_device::read_a13),(base_md_cart_slot_device*)m_slotcart), write16_delegate(FUNC(base_md_cart_slot_device::write_a13),(base_md_cart_slot_device*)m_slotcart)); m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xa13000, 0xa130ff, read16_delegate(FUNC(base_md_cart_slot_device::read_a13),(base_md_cart_slot_device*)m_cart), write16_delegate(FUNC(base_md_cart_slot_device::write_a13),(base_md_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xa15000, 0xa150ff, read16_delegate(FUNC(base_md_cart_slot_device::read_a15),(base_md_cart_slot_device*)m_slotcart), write16_delegate(FUNC(base_md_cart_slot_device::write_a15),(base_md_cart_slot_device*)m_slotcart)); m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0xa15000, 0xa150ff, read16_delegate(FUNC(base_md_cart_slot_device::read_a15),(base_md_cart_slot_device*)m_cart), write16_delegate(FUNC(base_md_cart_slot_device::write_a15),(base_md_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_write_handler(0xa14000, 0xa14003, write16_delegate(FUNC(base_md_cart_slot_device::write_tmss_bank),(base_md_cart_slot_device*)m_slotcart)); m_maincpu->space(AS_PROGRAM).install_write_handler(0xa14000, 0xa14003, write16_delegate(FUNC(base_md_cart_slot_device::write_tmss_bank),(base_md_cart_slot_device*)m_cart));
} }
MACHINE_START_MEMBER(md_cons_state, ms_megacd) MACHINE_START_MEMBER(md_cons_state, ms_megacd)

4
src/mess/drivers/segapico.c
View File

@ -156,7 +156,7 @@ public:
: pico_base_state(mconfig, type, tag), : pico_base_state(mconfig, type, tag),
m_picocart(*this, "picoslot") { } m_picocart(*this, "picoslot") { }
optional_device<pico_cart_slot_device> m_picocart; required_device<pico_cart_slot_device> m_picocart;
DECLARE_MACHINE_START(pico); DECLARE_MACHINE_START(pico);
}; };
@ -519,7 +519,7 @@ public:
: pico_base_state(mconfig, type, tag), : pico_base_state(mconfig, type, tag),
m_picocart(*this, "coperaslot") { } m_picocart(*this, "coperaslot") { }
optional_device<copera_cart_slot_device> m_picocart; required_device<copera_cart_slot_device> m_picocart;
DECLARE_MACHINE_START(copera); DECLARE_MACHINE_START(copera);
}; };

30
src/mess/drivers/sg1000.c
View File

@ -79,16 +79,16 @@ Notes:
// for the moment let assume the latter! // for the moment let assume the latter!
READ8_MEMBER( sg1000_state::omv_r ) READ8_MEMBER( sg1000_state::omv_r )
{ {
if (m_cartslot && m_cartslot->m_cart) if (m_cart && m_cart->exists())
return m_cartslot->m_cart->read_cart(space, offset); return m_cart->read_cart(space, offset);
else else
return m_rom->base()[offset]; return m_rom->base()[offset];
} }
WRITE8_MEMBER( sg1000_state::omv_w ) WRITE8_MEMBER( sg1000_state::omv_w )
{ {
if (m_cartslot && m_cartslot->m_cart) if (m_cart && m_cart->exists())
m_cartslot->m_cart->write_cart(space, offset, data); m_cart->write_cart(space, offset, data);
} }
/*------------------------------------------------- /*-------------------------------------------------
@ -633,14 +633,14 @@ SLOT_INTERFACE_END
void sg1000_state::machine_start() void sg1000_state::machine_start()
{ {
if (m_cartslot->get_type() == SEGA8_DAHJEE_TYPEA || m_cartslot->get_type() == SEGA8_DAHJEE_TYPEB) if (m_cart->get_type() == SEGA8_DAHJEE_TYPEA || m_cart->get_type() == SEGA8_DAHJEE_TYPEB)
{ {
m_maincpu->space(AS_PROGRAM).install_read_handler(0xc000, 0xffff, 0, 0, read8_delegate(FUNC(sega8_cart_slot_device::read_ram),(sega8_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_read_handler(0xc000, 0xffff, 0, 0, read8_delegate(FUNC(sega8_cart_slot_device::read_ram),(sega8_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_write_handler(0xc000, 0xffff, 0, 0, write8_delegate(FUNC(sega8_cart_slot_device::write_ram),(sega8_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_write_handler(0xc000, 0xffff, 0, 0, write8_delegate(FUNC(sega8_cart_slot_device::write_ram),(sega8_cart_slot_device*)m_cart));
} }
if (m_cartslot) if (m_cart)
m_cartslot->save_ram(); m_cart->save_ram();
} }
/*------------------------------------------------- /*-------------------------------------------------
@ -673,15 +673,15 @@ void sc3000_state::machine_start()
/* register for state saving */ /* register for state saving */
save_item(NAME(m_keylatch)); save_item(NAME(m_keylatch));
if (m_cartslot && (m_cartslot->get_type() == SEGA8_BASIC_L3 || m_cartslot->get_type() == SEGA8_MUSIC_EDITOR if (m_cart && m_cart->exists() && (m_cart->get_type() == SEGA8_BASIC_L3 || m_cart->get_type() == SEGA8_MUSIC_EDITOR
|| m_cartslot->get_type() == SEGA8_DAHJEE_TYPEA || m_cartslot->get_type() == SEGA8_DAHJEE_TYPEB)) || m_cart->get_type() == SEGA8_DAHJEE_TYPEA || m_cart->get_type() == SEGA8_DAHJEE_TYPEB))
{ {
m_maincpu->space(AS_PROGRAM).install_read_handler(0xc000, 0xffff, 0, 0, read8_delegate(FUNC(sega8_cart_slot_device::read_ram),(sega8_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_read_handler(0xc000, 0xffff, 0, 0, read8_delegate(FUNC(sega8_cart_slot_device::read_ram),(sega8_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_write_handler(0xc000, 0xffff, 0, 0, write8_delegate(FUNC(sega8_cart_slot_device::write_ram),(sega8_cart_slot_device*)m_cartslot)); m_maincpu->space(AS_PROGRAM).install_write_handler(0xc000, 0xffff, 0, 0, write8_delegate(FUNC(sega8_cart_slot_device::write_ram),(sega8_cart_slot_device*)m_cart));
} }
if (m_cartslot) if (m_cart)
m_cartslot->save_ram(); m_cart->save_ram();
} }

4
src/mess/includes/gba.h
View File

@ -138,7 +138,7 @@ public:
m_lbdac(*this, "direct_b_left"), m_lbdac(*this, "direct_b_left"),
m_rbdac(*this, "direct_b_right"), m_rbdac(*this, "direct_b_right"),
m_gbsound(*this, "custom"), m_gbsound(*this, "custom"),
m_cartslot(*this, "cartslot"), m_cart(*this, "cartslot"),
m_region_maincpu(*this, "maincpu"), m_region_maincpu(*this, "maincpu"),
m_io_in0(*this, "IN0") m_io_in0(*this, "IN0")
{ } { }
@ -152,7 +152,7 @@ public:
required_device<dac_device> m_lbdac; required_device<dac_device> m_lbdac;
required_device<dac_device> m_rbdac; required_device<dac_device> m_rbdac;
required_device<gameboy_sound_device> m_gbsound; required_device<gameboy_sound_device> m_gbsound;
required_device<gba_cart_slot_device> m_cartslot; required_device<gba_cart_slot_device> m_cart;
void request_irq(UINT32 int_type); void request_irq(UINT32 int_type);
void dma_exec(FPTR ch); void dma_exec(FPTR ch);

4
src/mess/includes/md_cons.h
View File

@ -13,7 +13,7 @@ public:
: md_base_state(mconfig, type, tag), : md_base_state(mconfig, type, tag),
m_32x(*this,"sega32x"), m_32x(*this,"sega32x"),
m_segacd(*this,"segacd"), m_segacd(*this,"segacd"),
m_slotcart(*this, "mdslot") m_cart(*this, "mdslot")
{ } { }
ioport_port *m_io_ctrlr; ioport_port *m_io_ctrlr;
@ -22,7 +22,7 @@ public:
optional_device<sega_32x_device> m_32x; optional_device<sega_32x_device> m_32x;
optional_device<sega_segacd_device> m_segacd; optional_device<sega_segacd_device> m_segacd;
optional_device<md_cart_slot_device> m_slotcart; optional_device<md_cart_slot_device> m_cart;
DECLARE_DRIVER_INIT(mess_md_common); DECLARE_DRIVER_INIT(mess_md_common);
DECLARE_DRIVER_INIT(genesis); DECLARE_DRIVER_INIT(genesis);

4
src/mess/includes/sg1000.h
View File

@ -49,13 +49,13 @@ public:
m_maincpu(*this, Z80_TAG), m_maincpu(*this, Z80_TAG),
m_ram(*this, RAM_TAG), m_ram(*this, RAM_TAG),
m_rom(*this, Z80_TAG), m_rom(*this, Z80_TAG),
m_cartslot(*this, CARTSLOT_TAG) m_cart(*this, CARTSLOT_TAG)
{ } { }
required_device<cpu_device> m_maincpu; required_device<cpu_device> m_maincpu;
required_device<ram_device> m_ram; required_device<ram_device> m_ram;
required_memory_region m_rom; required_memory_region m_rom;
optional_device<sega8_cart_slot_device> m_cartslot; optional_device<sega8_cart_slot_device> m_cart;
virtual void machine_start(); virtual void machine_start();

12
src/mess/machine/sms.c
View File

@ -206,7 +206,7 @@ READ8_MEMBER(sms_state::sms_count_r)
*/ */
WRITE_LINE_MEMBER(sms_state::sms_pause_callback) WRITE_LINE_MEMBER(sms_state::sms_pause_callback)
{ {
if (m_is_gamegear && m_cartslot->m_cart && !m_cartslot->m_cart->get_sms_mode()) if (m_is_gamegear && m_cartslot->exists() && !m_cartslot->m_cart->get_sms_mode())
return; return;
if ((m_is_gamegear && !(m_port_start->read() & 0x80)) || (!m_is_gamegear && !(m_port_pause->read() & 0x80))) if ((m_is_gamegear && !(m_port_start->read() & 0x80)) || (!m_is_gamegear && !(m_port_pause->read() & 0x80)))
@ -642,12 +642,12 @@ void sms_state::setup_enabled_slots()
// (/CART pin) that prioritizes the cartridge slot if it has media // (/CART pin) that prioritizes the cartridge slot if it has media
// inserted. Japanese 3-D cartridges do not connect the /CART pin, // inserted. Japanese 3-D cartridges do not connect the /CART pin,
// to not disable the card adaptor used by the 3-D glasses. // to not disable the card adaptor used by the 3-D glasses.
if (m_cartslot && m_cartslot->m_cart) if (m_cartslot && m_cartslot->exists())
{ {
m_mem_device_enabled |= ENABLE_CART; m_mem_device_enabled |= ENABLE_CART;
logerror("Cartridge ROM/RAM enabled.\n"); logerror("Cartridge ROM/RAM enabled.\n");
} }
else if (m_cardslot && m_cardslot->m_cart) else if (m_cardslot && m_cardslot->exists())
{ {
m_mem_device_enabled |= ENABLE_CARD; m_mem_device_enabled |= ENABLE_CARD;
logerror("Card ROM port enabled.\n"); logerror("Card ROM port enabled.\n");
@ -661,13 +661,13 @@ void sms_state::setup_enabled_slots()
logerror("Expansion port enabled.\n"); logerror("Expansion port enabled.\n");
} }
if (!(m_mem_ctrl_reg & IO_CARD) && m_cardslot && m_cardslot->m_cart) if (!(m_mem_ctrl_reg & IO_CARD) && m_cardslot && m_cardslot->exists())
{ {
m_mem_device_enabled |= ENABLE_CARD; m_mem_device_enabled |= ENABLE_CARD;
logerror("Card ROM port enabled.\n"); logerror("Card ROM port enabled.\n");
} }
if (!(m_mem_ctrl_reg & IO_CARTRIDGE) && m_cartslot && m_cartslot->m_cart) if (!(m_mem_ctrl_reg & IO_CARTRIDGE) && m_cartslot && m_cartslot->exists())
{ {
m_mem_device_enabled |= ENABLE_CART; m_mem_device_enabled |= ENABLE_CART;
logerror("Cartridge ROM/RAM enabled.\n"); logerror("Cartridge ROM/RAM enabled.\n");
@ -852,7 +852,7 @@ MACHINE_RESET_MEMBER(sms_state,sms)
if (m_is_gamegear) if (m_is_gamegear)
{ {
if (m_cartslot->m_cart && m_cartslot->m_cart->get_sms_mode()) if (m_cartslot->exists() && m_cartslot->m_cart->get_sms_mode())
m_vdp->set_sega315_5124_compatibility_mode(true); m_vdp->set_sega315_5124_compatibility_mode(true);
/* Initialize SIO stuff for GG */ /* Initialize SIO stuff for GG */