Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-05 00:38:58 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

bus/generic, bus/vc4000: Eliminate address_space argument from handlers (nw)

Browse Source
This commit is contained in:
AJR 2019-02-19 06:43:20 -05:00
parent 7e9c4475e8
commit f45a9bdac1
69 changed files with 178 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/devices/bus/c64/16kb.cpp
View File

@ -102,11 +102,11 @@ uint8_t c64_16kb_cartridge_device::c64_cd_r(address_space &space, offs_t offset,
{
if (!roml)
{
data = m_low->read_rom(space, offset & 0x1fff);
data = m_low->read_rom(offset & 0x1fff);
}
else if (!romh)
{
data = m_high->read_rom(space, offset & 0x1fff);
data = m_high->read_rom(offset & 0x1fff);
}
return data;

2
src/devices/bus/c64/dela_ep256.cpp
View File

@ -98,7 +98,7 @@ uint8_t c64_dela_ep256_cartridge_device::c64_cd_r(address_space &space, offs_t o
else
{
offs_t addr = (m_bank << 13) | (offset & 0x1fff);
data = m_eproms[m_socket]->read_rom(space, addr);
data = m_eproms[m_socket]->read_rom(addr);
}
}

4
src/devices/bus/c64/dela_ep64.cpp
View File

@ -90,8 +90,8 @@ uint8_t c64_dela_ep64_cartridge_device::c64_cd_r(address_space &space, offs_t of
offs_t addr = (m_bank << 13) | (offset & 0x1fff);
if (!m_rom0_ce) data |= m_roml[offset & 0x1fff];
if (!m_rom1_ce) data |= m_eprom1->read_rom(space, addr);
if (!m_rom2_ce) data |= m_eprom2->read_rom(space, addr);
if (!m_rom1_ce) data |= m_eprom1->read_rom(addr);
if (!m_rom2_ce) data |= m_eprom2->read_rom(addr);
}
}

14
src/devices/bus/c64/dela_ep7x8.cpp
View File

@ -83,13 +83,13 @@ uint8_t c64_dela_ep7x8_cartridge_device::c64_cd_r(address_space &space, offs_t o
offs_t addr = offset & 0x1fff;
if (!BIT(m_bank, 0)) data |= m_roml[addr];
if (!BIT(m_bank, 1)) data |= m_eprom[0]->read_rom(space, addr);
if (!BIT(m_bank, 2)) data |= m_eprom[1]->read_rom(space, addr);
if (!BIT(m_bank, 3)) data |= m_eprom[2]->read_rom(space, addr);
if (!BIT(m_bank, 4)) data |= m_eprom[3]->read_rom(space, addr);
if (!BIT(m_bank, 5)) data |= m_eprom[4]->read_rom(space, addr);
if (!BIT(m_bank, 6)) data |= m_eprom[5]->read_rom(space, addr);
if (!BIT(m_bank, 7)) data |= m_eprom[6]->read_rom(space, addr);
if (!BIT(m_bank, 1)) data |= m_eprom[0]->read_rom(addr);
if (!BIT(m_bank, 2)) data |= m_eprom[1]->read_rom(addr);
if (!BIT(m_bank, 3)) data |= m_eprom[2]->read_rom(addr);
if (!BIT(m_bank, 4)) data |= m_eprom[3]->read_rom(addr);
if (!BIT(m_bank, 5)) data |= m_eprom[4]->read_rom(addr);
if (!BIT(m_bank, 6)) data |= m_eprom[5]->read_rom(addr);
if (!BIT(m_bank, 7)) data |= m_eprom[6]->read_rom(addr);
}
return data;

2
src/devices/bus/c64/reu.cpp
View File

@ -103,7 +103,7 @@ uint8_t c64_reu_cartridge_device::c64_cd_r(address_space &space, offs_t offset,
{
if (!m_dmac->romsel_r(roml, romh))
{
data = m_eprom->read_rom(space, offset & 0x7fff);
data = m_eprom->read_rom(offset & 0x7fff);
}
else if (!io2)
{

2
src/devices/bus/c64/rex_ep256.cpp
View File

@ -98,7 +98,7 @@ uint8_t c64_rex_ep256_cartridge_device::c64_cd_r(address_space &space, offs_t of
else
{
offs_t addr = (m_bank << 13) | (offset & 0x1fff);
data = m_eproms[m_socket]->read_rom(space, addr);
data = m_eproms[m_socket]->read_rom(addr);
}
}
else if (!io2)

2
src/devices/bus/cgenie/expansion/floppy.cpp
View File

@ -137,7 +137,7 @@ void cgenie_fdc_device::device_reset()
// map extra socket
if (m_socket->exists())
{
m_slot->m_program->install_read_handler(0xe000, 0xefff, read8_delegate(FUNC(generic_slot_device::read_rom), (generic_slot_device *) m_socket));
m_slot->m_program->install_read_handler(0xe000, 0xefff, read8sm_delegate(FUNC(generic_slot_device::read_rom), (generic_slot_device *) m_socket));
}
}

2
src/devices/bus/electron/cart/ap5.cpp
View File

@ -107,7 +107,7 @@ uint8_t electron_ap5_device::read(address_space &space, offs_t offset, int infc,
}
else if (oe)
{
data = m_romslot[romqa]->read_rom(space, offset & 0x3fff);
data = m_romslot[romqa]->read_rom(offset & 0x3fff);
}
else if (oe2)
{

2
src/devices/bus/electron/plus2.cpp
View File

@ -123,7 +123,7 @@ uint8_t electron_plus2_device::expbus_r(address_space &space, offs_t offset)
data &= m_cart[1]->read(space, offset & 0x3fff, 0, 0, m_romsel & 0x01, 0, 1);
case 14:
case 15:
data &= m_rom[m_romsel - 13]->read_rom(space, offset & 0x3fff);
data &= m_rom[m_romsel - 13]->read_rom(offset & 0x3fff);
break;
}
break;

6
src/devices/bus/electron/rombox.cpp
View File

@ -131,7 +131,7 @@ uint8_t electron_rombox_device::expbus_r(address_space &space, offs_t offset)
case 3:
if (m_rom_base == 0 && m_rom[m_romsel + 4]->exists())
{
data = m_rom[m_romsel + 4]->read_rom(space, offset & 0x3fff);
data = m_rom[m_romsel + 4]->read_rom(offset & 0x3fff);
}
break;
case 4:
@ -140,7 +140,7 @@ uint8_t electron_rombox_device::expbus_r(address_space &space, offs_t offset)
case 7:
if (m_rom[m_romsel - 4]->exists())
{
data = m_rom[m_romsel - 4]->read_rom(space, offset & 0x3fff);
data = m_rom[m_romsel - 4]->read_rom(offset & 0x3fff);
}
break;
case 12:
@ -149,7 +149,7 @@ uint8_t electron_rombox_device::expbus_r(address_space &space, offs_t offset)
case 15:
if (m_rom_base == 12 && m_rom[m_romsel - 8]->exists())
{
data = m_rom[m_romsel - 8]->read_rom(space, offset & 0x3fff);
data = m_rom[m_romsel - 8]->read_rom(offset & 0x3fff);
}
break;
}

4
src/devices/bus/electron/romboxp.cpp
View File

@ -186,7 +186,7 @@ uint8_t electron_romboxp_device::expbus_r(address_space &space, offs_t offset)
case 7:
if (m_rom_base == 4)
{
data = m_rom[m_romsel - 4]->read_rom(space, offset & 0x3fff);
data = m_rom[m_romsel - 4]->read_rom(offset & 0x3fff);
}
break;
case 12:
@ -199,7 +199,7 @@ uint8_t electron_romboxp_device::expbus_r(address_space &space, offs_t offset)
case 15:
if (m_rom_base == 12)
{
data = m_rom[m_romsel - 12]->read_rom(space, offset & 0x3fff);
data = m_rom[m_romsel - 12]->read_rom(offset & 0x3fff);
}
break;
}

8
src/devices/bus/generic/ram.cpp
View File

@ -97,7 +97,7 @@ void generic_ram_linear_device::device_start()
mapper specific handlers
-------------------------------------------------*/
READ8_MEMBER(generic_ram_plain_device::read_ram)
uint8_t generic_ram_plain_device::read_ram(offs_t offset)
{
if (offset < m_ram.size())
return m_ram[offset];
@ -105,19 +105,19 @@ READ8_MEMBER(generic_ram_plain_device::read_ram)
return 0xff;
}
WRITE8_MEMBER(generic_ram_plain_device::write_ram)
void generic_ram_plain_device::write_ram(offs_t offset, uint8_t data)
{
if (offset < m_ram.size())
m_ram[offset] = data;
}
READ8_MEMBER(generic_ram_linear_device::read_ram)
uint8_t generic_ram_linear_device::read_ram(offs_t offset)
{
return m_ram[offset % m_ram.size()];
}
WRITE8_MEMBER(generic_ram_linear_device::write_ram)
void generic_ram_linear_device::write_ram(offs_t offset, uint8_t data)
{
m_ram[offset % m_ram.size()] = data;
}

8
src/devices/bus/generic/ram.h
View File

@ -14,8 +14,8 @@ class generic_ram_plain_device : public device_t, public device_generic_cart_int
{
public:
// reading and writing
virtual DECLARE_READ8_MEMBER(read_ram) override;
virtual DECLARE_WRITE8_MEMBER(write_ram) override;
virtual uint8_t read_ram(offs_t offset) override;
virtual void write_ram(offs_t offset, uint8_t data) override;
protected:
// construction/destruction
@ -35,8 +35,8 @@ class generic_ram_linear_device : public device_t, public device_generic_cart_in
{
public:
// reading and writing
virtual DECLARE_READ8_MEMBER(read_ram) override;
virtual DECLARE_WRITE8_MEMBER(write_ram) override;
virtual uint8_t read_ram(offs_t offset) override;
virtual void write_ram(offs_t offset, uint8_t data) override;
protected:
// construction/destruction

16
src/devices/bus/generic/rom.cpp
View File

@ -61,7 +61,7 @@ generic_romram_plain_device::generic_romram_plain_device(const machine_config &m
mapper specific handlers
-------------------------------------------------*/
READ8_MEMBER(generic_rom_plain_device::read_rom)
uint8_t generic_rom_plain_device::read_rom(offs_t offset)
{
if (offset < m_rom_size)
return m_rom[offset];
@ -69,7 +69,7 @@ READ8_MEMBER(generic_rom_plain_device::read_rom)
return 0xff;
}
READ16_MEMBER(generic_rom_plain_device::read16_rom)
uint16_t generic_rom_plain_device::read16_rom(offs_t offset, uint16_t mem_mask)
{
uint16_t *ROM = (uint16_t *)m_rom;
if (offset < m_rom_size/2)
@ -78,7 +78,7 @@ READ16_MEMBER(generic_rom_plain_device::read16_rom)
return 0xffff;
}
READ32_MEMBER(generic_rom_plain_device::read32_rom)
uint32_t generic_rom_plain_device::read32_rom(offs_t offset, uint32_t mem_mask)
{
uint32_t *ROM = (uint32_t *)m_rom;
if (offset < m_rom_size/4)
@ -88,25 +88,25 @@ READ32_MEMBER(generic_rom_plain_device::read32_rom)
}
READ8_MEMBER(generic_rom_linear_device::read_rom)
uint8_t generic_rom_linear_device::read_rom(offs_t offset)
{
return m_rom[offset % m_rom_size];
}
READ16_MEMBER(generic_rom_linear_device::read16_rom)
uint16_t generic_rom_linear_device::read16_rom(offs_t offset, uint16_t mem_mask)
{
uint16_t *ROM = (uint16_t *)m_rom;
return ROM[offset % (m_rom_size/2)];
}
READ32_MEMBER(generic_rom_linear_device::read32_rom)
uint32_t generic_rom_linear_device::read32_rom(offs_t offset, uint32_t mem_mask)
{
uint32_t *ROM = (uint32_t *)m_rom;
return ROM[offset % (m_rom_size/4)];
}
READ8_MEMBER(generic_romram_plain_device::read_ram)
uint8_t generic_romram_plain_device::read_ram(offs_t offset)
{
if (offset < m_ram.size())
return m_ram[offset];
@ -114,7 +114,7 @@ READ8_MEMBER(generic_romram_plain_device::read_ram)
return 0xff;
}
WRITE8_MEMBER(generic_romram_plain_device::write_ram)
void generic_romram_plain_device::write_ram(offs_t offset, uint8_t data)
{
if (offset < m_ram.size())
m_ram[offset] = data;

16
src/devices/bus/generic/rom.h
View File

@ -30,9 +30,9 @@ public:
generic_rom_plain_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// reading and writing
virtual DECLARE_READ8_MEMBER(read_rom) override;
virtual DECLARE_READ16_MEMBER(read16_rom) override;
virtual DECLARE_READ32_MEMBER(read32_rom) override;
virtual uint8_t read_rom(offs_t offset) override;
virtual uint16_t read16_rom(offs_t offset, uint16_t mem_mask) override;
virtual uint32_t read32_rom(offs_t offset, uint32_t mem_mask) override;
protected:
generic_rom_plain_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock);
@ -48,8 +48,8 @@ public:
generic_romram_plain_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// reading and writing
virtual DECLARE_READ8_MEMBER(read_ram) override;
virtual DECLARE_WRITE8_MEMBER(write_ram) override;
virtual uint8_t read_ram(offs_t offset) override;
virtual void write_ram(offs_t offset, uint8_t data) override;
};
@ -62,9 +62,9 @@ public:
generic_rom_linear_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// reading and writing
virtual DECLARE_READ8_MEMBER(read_rom) override;
virtual DECLARE_READ16_MEMBER(read16_rom) override;
virtual DECLARE_READ32_MEMBER(read32_rom) override;
virtual uint8_t read_rom(offs_t offset) override;
virtual uint16_t read16_rom(offs_t offset, uint16_t mem_mask) override;
virtual uint32_t read32_rom(offs_t offset, uint32_t mem_mask) override;
};

20
src/devices/bus/generic/slot.cpp
View File

@ -216,10 +216,10 @@ void generic_slot_device::common_load_rom(uint8_t *ROM, uint32_t len, const char
read_rom
-------------------------------------------------*/
READ8_MEMBER(generic_slot_device::read_rom)
uint8_t generic_slot_device::read_rom(offs_t offset)
{
if (m_cart)
return m_cart->read_rom(space, offset);
return m_cart->read_rom(offset);
else
return 0xff;
}
@ -228,10 +228,10 @@ READ8_MEMBER(generic_slot_device::read_rom)
read16_rom
-------------------------------------------------*/
READ16_MEMBER(generic_slot_device::read16_rom)
uint16_t generic_slot_device::read16_rom(offs_t offset, uint16_t mem_mask)
{
if (m_cart)
return m_cart->read16_rom(space, offset, mem_mask);
return m_cart->read16_rom(offset, mem_mask);
else
return 0xffff;
}
@ -240,10 +240,10 @@ READ16_MEMBER(generic_slot_device::read16_rom)
read32_rom
-------------------------------------------------*/
READ32_MEMBER(generic_slot_device::read32_rom)
uint32_t generic_slot_device::read32_rom(offs_t offset, uint32_t mem_mask)
{
if (m_cart)
return m_cart->read32_rom(space, offset, mem_mask);
return m_cart->read32_rom(offset, mem_mask);
else
return 0xffffffff;
}
@ -252,10 +252,10 @@ READ32_MEMBER(generic_slot_device::read32_rom)
read_ram
-------------------------------------------------*/
READ8_MEMBER(generic_slot_device::read_ram)
uint8_t generic_slot_device::read_ram(offs_t offset)
{
if (m_cart)
return m_cart->read_ram(space, offset);
return m_cart->read_ram(offset);
else
return 0xff;
}
@ -264,8 +264,8 @@ READ8_MEMBER(generic_slot_device::read_ram)
write_ram
-------------------------------------------------*/
WRITE8_MEMBER(generic_slot_device::write_ram)
void generic_slot_device::write_ram(offs_t offset, uint8_t data)
{
if (m_cart)
m_cart->write_ram(space, offset, data);
m_cart->write_ram(offset, data);
}

20
src/devices/bus/generic/slot.h
View File

@ -22,12 +22,12 @@ public:
virtual ~device_generic_cart_interface();
// reading and writing
virtual DECLARE_READ8_MEMBER(read_rom) { return 0xff; }
virtual DECLARE_READ16_MEMBER(read16_rom) { return 0xffff; }
virtual DECLARE_READ32_MEMBER(read32_rom) { return 0xffffffff; }
virtual uint8_t read_rom(offs_t offset) { return 0xff; }
virtual uint16_t read16_rom(offs_t offset, uint16_t mem_mask) { return 0xffff; }
virtual uint32_t read32_rom(offs_t offset, uint32_t mem_mask) { return 0xffffffff; }
virtual DECLARE_READ8_MEMBER(read_ram) { return 0xff; }
virtual DECLARE_WRITE8_MEMBER(write_ram) {};
virtual uint8_t read_ram(offs_t offset) { return 0xff; }
virtual void write_ram(offs_t offset, uint8_t data) {}
virtual void rom_alloc(size_t size, int width, endianness_t end, const char *tag);
virtual void ram_alloc(uint32_t size);
@ -138,12 +138,12 @@ public:
virtual std::string get_default_card_software(get_default_card_software_hook &hook) const override;
// reading and writing
virtual DECLARE_READ8_MEMBER(read_rom);
virtual DECLARE_READ16_MEMBER(read16_rom);
virtual DECLARE_READ32_MEMBER(read32_rom);
virtual uint8_t read_rom(offs_t offset);
virtual uint16_t read16_rom(offs_t offset, uint16_t mem_mask = 0xffff);
virtual uint32_t read32_rom(offs_t offset, uint32_t mem_mask = 0xffffffff);
virtual DECLARE_READ8_MEMBER(read_ram);
virtual DECLARE_WRITE8_MEMBER(write_ram);
virtual uint8_t read_ram(offs_t offset);
virtual void write_ram(offs_t offset, uint8_t data);
virtual void rom_alloc(size_t size, int width, endianness_t end) { if (m_cart) m_cart->rom_alloc(size, width, end, tag()); }
virtual void ram_alloc(uint32_t size) { if (m_cart) m_cart->ram_alloc(size); }

2
src/devices/bus/svi3x8/expander/sv603.cpp
View File

@ -109,7 +109,7 @@ READ8_MEMBER( sv603_device::mreq_r )
m_expander->romdis_w(0);
if (offset < 0x8000)
return m_cart_rom->read_rom(space, offset);
return m_cart_rom->read_rom(offset);
if (offset >= 0x8000 && offset < 0xa000)
{

12
src/devices/bus/vc4000/rom.cpp
View File

@ -228,7 +228,7 @@ vc4000_chess2_device::vc4000_chess2_device(const machine_config &mconfig, const
mapper specific handlers
-------------------------------------------------*/
READ8_MEMBER(vc4000_rom_device::read_rom)
uint8_t vc4000_rom_device::read_rom(offs_t offset)
{
if (offset < m_rom_size)
return m_rom[offset];
@ -237,18 +237,18 @@ READ8_MEMBER(vc4000_rom_device::read_rom)
}
READ8_MEMBER(vc4000_ram1k_device::read_ram)
uint8_t vc4000_ram1k_device::read_ram(offs_t offset)
{
return m_ram[offset & (m_ram.size() - 1)];
}
WRITE8_MEMBER(vc4000_ram1k_device::write_ram)
void vc4000_ram1k_device::write_ram(offs_t offset, uint8_t data)
{
m_ram[offset & (m_ram.size() - 1)] = data;
}
READ8_MEMBER(vc4000_chess2_device::extra_rom)
uint8_t vc4000_chess2_device::extra_rom(offs_t offset)
{
if (offset < (m_rom_size - 0x2000))
return m_rom[offset + 0x2000];
@ -256,12 +256,12 @@ READ8_MEMBER(vc4000_chess2_device::extra_rom)
return 0xff;
}
READ8_MEMBER(vc4000_chess2_device::read_ram)
uint8_t vc4000_chess2_device::read_ram(offs_t offset)
{
return m_ram[offset & (m_ram.size() - 1)];
}
WRITE8_MEMBER(vc4000_chess2_device::write_ram)
void vc4000_chess2_device::write_ram(offs_t offset, uint8_t data)
{
m_ram[offset & (m_ram.size() - 1)] = data;
}

12
src/devices/bus/vc4000/rom.h
View File

@ -16,7 +16,7 @@ public:
vc4000_rom_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// reading and writing
virtual DECLARE_READ8_MEMBER(read_rom) override;
virtual uint8_t read_rom(offs_t offset) override;
protected:
vc4000_rom_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock);
@ -44,8 +44,8 @@ public:
vc4000_ram1k_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// reading and writing
virtual DECLARE_READ8_MEMBER(read_ram) override;
virtual DECLARE_WRITE8_MEMBER(write_ram) override;
virtual uint8_t read_ram(offs_t offset) override;
virtual void write_ram(offs_t offset, uint8_t data) override;
};
// ======================> vc4000_chess2_device
@ -57,9 +57,9 @@ public:
vc4000_chess2_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// reading and writing
virtual DECLARE_READ8_MEMBER(extra_rom) override;
virtual DECLARE_READ8_MEMBER(read_ram) override;
virtual DECLARE_WRITE8_MEMBER(write_ram) override;
virtual uint8_t extra_rom(offs_t offset) override;
virtual uint8_t read_ram(offs_t offset) override;
virtual void write_ram(offs_t offset, uint8_t data) override;
};

16
src/devices/bus/vc4000/slot.cpp
View File

@ -251,10 +251,10 @@ std::string vc4000_cart_slot_device::get_default_card_software(get_default_card_
read
-------------------------------------------------*/
READ8_MEMBER(vc4000_cart_slot_device::read_rom)
uint8_t vc4000_cart_slot_device::read_rom(offs_t offset)
{
if (m_cart)
return m_cart->read_rom(space, offset);
return m_cart->read_rom(offset);
else
return 0xff;
}
@ -263,10 +263,10 @@ READ8_MEMBER(vc4000_cart_slot_device::read_rom)
read
-------------------------------------------------*/
READ8_MEMBER(vc4000_cart_slot_device::extra_rom)
uint8_t vc4000_cart_slot_device::extra_rom(offs_t offset)
{
if (m_cart)
return m_cart->extra_rom(space, offset);
return m_cart->extra_rom(offset);
else
return 0xff;
}
@ -275,10 +275,10 @@ READ8_MEMBER(vc4000_cart_slot_device::extra_rom)
read
-------------------------------------------------*/
READ8_MEMBER(vc4000_cart_slot_device::read_ram)
uint8_t vc4000_cart_slot_device::read_ram(offs_t offset)
{
if (m_cart)
return m_cart->read_ram(space, offset);
return m_cart->read_ram(offset);
else
return 0xff;
}
@ -287,8 +287,8 @@ READ8_MEMBER(vc4000_cart_slot_device::read_ram)
write
-------------------------------------------------*/
WRITE8_MEMBER(vc4000_cart_slot_device::write_ram)
void vc4000_cart_slot_device::write_ram(offs_t offset, uint8_t data)
{
if (m_cart)
m_cart->write_ram(space, offset, data);
m_cart->write_ram(offset, data);
}

16
src/devices/bus/vc4000/slot.h
View File

@ -27,10 +27,10 @@ public:
virtual ~device_vc4000_cart_interface();
// reading and writing
virtual DECLARE_READ8_MEMBER(read_rom) { return 0xff; }
virtual DECLARE_READ8_MEMBER(extra_rom) { return 0xff; }
virtual DECLARE_READ8_MEMBER(read_ram) { return 0xff; }
virtual DECLARE_WRITE8_MEMBER(write_ram) {}
virtual uint8_t read_rom(offs_t offset) { return 0xff; }
virtual uint8_t extra_rom(offs_t offset) { return 0xff; }
virtual uint8_t read_ram(offs_t offset) { return 0xff; }
virtual void write_ram(offs_t offset, uint8_t data) {}
void rom_alloc(uint32_t size, const char *tag);
void ram_alloc(uint32_t size);
@ -93,10 +93,10 @@ public:
virtual std::string get_default_card_software(get_default_card_software_hook &hook) const override;
// reading and writing
virtual DECLARE_READ8_MEMBER(read_rom);
virtual DECLARE_READ8_MEMBER(extra_rom);
virtual DECLARE_READ8_MEMBER(read_ram);
virtual DECLARE_WRITE8_MEMBER(write_ram);
virtual uint8_t read_rom(offs_t offset);
virtual uint8_t extra_rom(offs_t offset);
virtual uint8_t read_ram(offs_t offset);
virtual void write_ram(offs_t offset, uint8_t data);
protected:
// device-level overrides

2
src/mame/drivers/advision.cpp
View File

@ -31,7 +31,7 @@
READ8_MEMBER( advision_state::rom_r )
{
offset += 0x400;
return m_cart->read_rom(space, offset & 0xfff);
return m_cart->read_rom(offset & 0xfff);
}
void advision_state::program_map(address_map &map)

2
src/mame/drivers/aquarius.cpp
View File

@ -180,7 +180,7 @@ READ8_MEMBER(aquarius_state::cartridge_r)
{
uint8_t data = 0;
if (m_cart->exists())
data = m_cart->read_rom(space, offset);
data = m_cart->read_rom(offset);
return data ^ m_scrambler;
}

6
src/mame/drivers/atarist.cpp
View File

@ -1867,7 +1867,7 @@ void st_state::machine_start()
configure_memory();
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0xfa0000, 0xfbffff, read16_delegate(FUNC(generic_slot_device::read16_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0xfa0000, 0xfbffff, read16s_delegate(FUNC(generic_slot_device::read16_rom),(generic_slot_device*)m_cart));
// allocate timers
if (m_mousex.found())
@ -1922,7 +1922,7 @@ void ste_state::machine_start()
configure_memory();
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0xfa0000, 0xfbffff, read16_delegate(FUNC(generic_slot_device::read16_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0xfa0000, 0xfbffff, read16s_delegate(FUNC(generic_slot_device::read16_rom),(generic_slot_device*)m_cart));
/* allocate timers */
m_dmasound_timer = timer_alloc(TIMER_DMASOUND_TICK);
@ -1969,7 +1969,7 @@ void stbook_state::machine_start()
}
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0xfa0000, 0xfbffff, read16_delegate(FUNC(generic_slot_device::read16_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0xfa0000, 0xfbffff, read16s_delegate(FUNC(generic_slot_device::read16_rom),(generic_slot_device*)m_cart));
/* register for state saving */
ste_state::state_save();

8
src/mame/drivers/atom.cpp
View File

@ -220,7 +220,7 @@ WRITE8_MEMBER( atomeb_state::eprom_w )
READ8_MEMBER( atomeb_state::ext_r )
{
if (m_ext[m_eprom & 0x0f]->exists())
return m_ext[m_eprom & 0x0f]->read_rom(space, offset);
return m_ext[m_eprom & 0x0f]->read_rom(offset);
else
return 0xff;
}
@ -232,9 +232,9 @@ READ8_MEMBER( atomeb_state::ext_r )
READ8_MEMBER( atomeb_state::dos_r )
{
if (m_e0->exists() && !BIT(m_eprom, 7))
return m_e0->read_rom(space, offset);
return m_e0->read_rom(offset);
else if (m_e1->exists() && BIT(m_eprom, 7))
return m_e1->read_rom(space, offset);
return m_e1->read_rom(offset);
else
return 0xff;
}
@ -663,7 +663,7 @@ void atom_state::machine_start()
m_baseram[0x0b] = machine().rand() & 0x0ff;
if (m_cart.found() && m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xafff, read8_delegate(FUNC(generic_slot_device::read_rom), &*m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0xa000, 0xafff, read8sm_delegate(FUNC(generic_slot_device::read_rom), &*m_cart));
}
/*-------------------------------------------------

2
src/mame/drivers/c128.cpp
View File

@ -410,7 +410,7 @@ uint8_t c128_state::read_memory(address_space &space, offs_t offset, offs_t vma,
}
if (!BIT(plaout, PLA_OUT_FROM1) && m_from->exists())
{
data = m_from->read_rom(space, offset & 0x7fff);
data = m_from->read_rom(offset & 0x7fff);
}
if (!BIT(plaout, PLA_OUT_IOCS) && BIT(offset, 10))
{

2
src/mame/drivers/casloopy.cpp
View File

@ -421,7 +421,7 @@ WRITE8_MEMBER(casloopy_state::bitmap_w)
READ32_MEMBER(casloopy_state::cart_r)
{
return m_cart->read32_rom(space, offset, mem_mask);
return m_cart->read32_rom(offset, mem_mask);
}

2
src/mame/drivers/ep64.cpp
View File

@ -543,7 +543,7 @@ INPUT_PORTS_END
void ep64_state::machine_start()
{
if (m_cart->exists())
m_dave->space(AS_PROGRAM).install_read_handler(0x010000, 0x01ffff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
m_dave->space(AS_PROGRAM).install_read_handler(0x010000, 0x01ffff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
// state saving
save_item(NAME(m_key));

2
src/mame/drivers/exelv.cpp
View File

@ -380,7 +380,7 @@ WRITE8_MEMBER(exelv_state::tms7041_portd_w)
READ8_MEMBER(exelv_state::rom_r)
{
if (m_cart && m_cart->exists())
return m_cart->read_rom(space, offset + 0x200);
return m_cart->read_rom(offset + 0x200);
return 0;
}

2
src/mame/drivers/fc100.cpp
View File

@ -472,7 +472,7 @@ void fc100_state::machine_start()
m_inv = 0;
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0x6000, 0x6fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x6000, 0x6fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
save_item(NAME(m_ag));
save_item(NAME(m_gm2));

2
src/mame/drivers/fidelbase.cpp
View File

@ -884,7 +884,7 @@ DEVICE_IMAGE_LOAD_MEMBER(fidelbase_state, scc_cartridge)
READ8_MEMBER(fidelbase_state::cartridge_r)
{
if (m_cart->exists())
return m_cart->read_rom(space, offset);
return m_cart->read_rom(offset);
else
return 0;
}

2
src/mame/drivers/gmaster.cpp
View File

@ -313,7 +313,7 @@ uint32_t gmaster_state::screen_update_gmaster(screen_device &screen, bitmap_ind1
void gmaster_state::machine_start()
{
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xfeff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xfeff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
save_item(NAME(m_video.data));
save_item(NAME(m_video.index));

2
src/mame/drivers/hx20.cpp
View File

@ -801,7 +801,7 @@ DEVICE_IMAGE_LOAD_MEMBER(hx20_state, optrom_load)
READ8_MEMBER(hx20_state::optrom_r)
{
if (m_optrom->exists())
return m_optrom->read_rom(space, offset);
return m_optrom->read_rom(offset);
else
return 0;
}

2
src/mame/drivers/i7000.cpp
View File

@ -237,7 +237,7 @@ void i7000_state::machine_start()
if (m_card->exists())
{
// 0x4000 - 0xbfff 32KB ROM
program.install_read_handler(0x4000, 0xbfff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_card));
program.install_read_handler(0x4000, 0xbfff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_card));
}
}

2
src/mame/drivers/kyocera.cpp
View File

@ -383,7 +383,7 @@ READ8_MEMBER( pc8201_state::romrd_r )
uint8_t data = 0xff;
if (m_rom_sel)
data = m_cas_cart->read_rom(space, m_rom_addr & 0x1ffff);
data = m_cas_cart->read_rom(m_rom_addr & 0x1ffff);
return data;
}

2
src/mame/drivers/mikrosha.cpp
View File

@ -45,7 +45,7 @@ private:
void mikrosha_state::machine_reset()
{
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0x8000+m_cart->get_rom_size()-1, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0x8000+m_cart->get_rom_size()-1, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
radio86_state::machine_reset();
}

2
src/mame/drivers/myvision.cpp
View File

@ -140,7 +140,7 @@ INPUT_PORTS_END
void myvision_state::machine_start()
{
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x5fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x5fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
save_item(NAME(m_column));
}

5
src/mame/drivers/pc6001.cpp
View File

@ -1287,8 +1287,7 @@ TIMER_DEVICE_CALLBACK_MEMBER(pc6001_state::cassette_callback)
else
cas_data_i>>=1;
#else
address_space &space = m_maincpu->space(AS_PROGRAM);
m_cur_keycode = m_cas_hack->read_rom(space, m_cas_offset++);
m_cur_keycode = m_cas_hack->read_rom(m_cas_offset++);
popmessage("%04x %04x", m_cas_offset, m_cas_maxsize);
if(m_cas_offset > m_cas_maxsize)
{
@ -1350,7 +1349,7 @@ void pc6001_state::machine_reset()
set_videoram_bank(0xc000);
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000, 0x5fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000, 0x5fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
std::string region_tag;
m_cart_rom = memregion(region_tag.assign(m_cart->tag()).append(GENERIC_ROM_REGION_TAG).c_str());

2
src/mame/drivers/pc8401a.cpp
View File

@ -267,7 +267,7 @@ WRITE8_MEMBER( pc8401a_state::rtc_ctrl_w )
READ8_MEMBER( pc8401a_state::io_rom_data_r )
{
//logerror("I/O ROM read from %05x\n", m_io_addr);
return m_io_cart->read_rom(space, m_io_addr);
return m_io_cart->read_rom(m_io_addr);
}
WRITE8_MEMBER( pc8401a_state::io_rom_addr_w )

10
src/mame/drivers/pegasus.cpp
View File

@ -463,15 +463,15 @@ image_init_result pegasus_state::load_cart(device_image_interface &image, generi
void pegasus_state::machine_start()
{
if (m_exp_00->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x0fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_00));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x0fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_00));
if (m_exp_01->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_01));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x1fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_01));
if (m_exp_02->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0x2000, 0x2fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_02));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x2000, 0x2fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_02));
if (m_exp_0c->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0xc000, 0xcfff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_0c));
m_maincpu->space(AS_PROGRAM).install_read_handler(0xc000, 0xcfff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_0c));
if (m_exp_0d->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0xd000, 0xdfff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_0d));
m_maincpu->space(AS_PROGRAM).install_read_handler(0xd000, 0xdfff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_exp_0d));
}
void pegasus_state::machine_reset()

2
src/mame/drivers/pencil2.cpp
View File

@ -308,7 +308,7 @@ INPUT_PORTS_END
void pencil2_state::machine_start()
{
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xffff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x8000, 0xffff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
}
void pencil2_state::pencil2(machine_config &config)

10
src/mame/drivers/pet.cpp
View File

@ -555,7 +555,7 @@ READ8_MEMBER( pet_state::read )
if (norom)
{
if (m_cart_9000 && m_cart_9000->exists())
data = m_cart_9000->read_rom(space, offset & 0xfff);
data = m_cart_9000->read_rom(offset & 0xfff);
else
data = m_rom->base()[offset - 0x9000];
}
@ -565,7 +565,7 @@ READ8_MEMBER( pet_state::read )
if (norom)
{
if (m_cart_a000 && m_cart_a000->exists())
data = m_cart_a000->read_rom(space, offset & 0xfff);
data = m_cart_a000->read_rom(offset & 0xfff);
else
data = m_rom->base()[offset - 0x9000];
}
@ -575,7 +575,7 @@ READ8_MEMBER( pet_state::read )
if (norom)
{
if (m_cart_b000 && m_cart_b000->exists())
data = m_cart_b000->read_rom(space, offset & 0xfff);
data = m_cart_b000->read_rom(offset & 0xfff);
else
data = m_rom->base()[offset - 0x9000];
}
@ -788,14 +788,14 @@ READ8_MEMBER( cbm8296_state::read )
if (!cs9)
{
if (m_cart_9000 && m_cart_9000->exists())
data = m_cart_9000->read_rom(space, offset & 0xfff);
data = m_cart_9000->read_rom(offset & 0xfff);
else
data = m_rom->base()[offset & 0xfff];
}
if (!csa)
{
if (m_cart_a000 && m_cart_a000->exists())
data = m_cart_a000->read_rom(space, offset & 0xfff);
data = m_cart_a000->read_rom(offset & 0xfff);
else
data = m_rom->base()[0x1000 | (offset & 0xfff)];
}

2
src/mame/drivers/pockchal.cpp
View File

@ -92,7 +92,7 @@ void pockchalv1_state::machine_start()
{
address_space &space = m_maincpu->space(AS_PROGRAM);
if (m_cart->exists())
space.install_read_handler(0x0000, 0x7fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
space.install_read_handler(0x0000, 0x7fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
}
void pockchalv1_state::machine_reset()

6
src/mame/drivers/pockstat.cpp
View File

@ -795,11 +795,11 @@ READ32_MEMBER(pockstat_state::ps_rombank_r)
if (m_ftlb_regs.entry[index] == bank)
{
//printf( "Address %08x is assigned to %08x in entry %d\n", 0x02000000 + (offset << 2), index * 0x2000 + ((offset << 2) & 0x1fff), index );
return m_cart->read32_rom(space, index * (0x2000/4) + (offset & (0x1fff/4)), mem_mask);
return m_cart->read32_rom(index * (0x2000/4) + (offset & (0x1fff/4)), mem_mask);
}
}
}
return m_cart->read32_rom(space, offset & 0x7fff, mem_mask);
return m_cart->read32_rom(offset & 0x7fff, mem_mask);
}
@ -831,7 +831,7 @@ WRITE32_MEMBER(pockstat_state::ps_flash_w)
READ32_MEMBER(pockstat_state::ps_flash_r)
{
return m_cart->read32_rom(space, offset, mem_mask);
return m_cart->read32_rom(offset, mem_mask);
}
READ32_MEMBER(pockstat_state::ps_audio_r)

2
src/mame/drivers/pokemini.cpp
View File

@ -126,7 +126,7 @@ private:
READ8_MEMBER( pokemini_state::rom_r )
{
offset += 0x2100;
return m_cart->read_rom(space, offset & 0x1fffff);
return m_cart->read_rom(offset & 0x1fffff);
}
void pokemini_state::pokemini_mem_map(address_map &map)

2
src/mame/drivers/pv1000.cpp
View File

@ -395,7 +395,7 @@ void pv1000_state::machine_start()
if (m_cart->exists())
{
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x7fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x7fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
// FIXME: this is needed for gfx decoding, but there is probably a cleaner solution!
std::string region_tag;

2
src/mame/drivers/pv2000.cpp
View File

@ -356,7 +356,7 @@ WRITE_LINE_MEMBER( pv2000_state::pv2000_vdp_interrupt )
void pv2000_state::machine_start()
{
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0xc000, 0xffff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0xc000, 0xffff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
}
void pv2000_state::machine_reset()

2
src/mame/drivers/px4.cpp
View File

@ -1146,7 +1146,7 @@ READ8_MEMBER( px4p_state::ramdisk_data_r )
else if (m_ramdisk_address < 0x40000)
{
// read from rom
ret = m_rdsocket->read_rom(space, m_ramdisk_address);
ret = m_rdsocket->read_rom(m_ramdisk_address);
}
m_ramdisk_address = (m_ramdisk_address & 0xffff00) | ((m_ramdisk_address & 0xff) + 1);

2
src/mame/drivers/rx78.cpp
View File

@ -432,7 +432,7 @@ void rx78_state::machine_reset()
{
address_space &prg = m_maincpu->space(AS_PROGRAM);
if (m_cart->exists())
prg.install_read_handler(0x2000, 0x5fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
prg.install_read_handler(0x2000, 0x5fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
}
DEVICE_IMAGE_LOAD_MEMBER( rx78_state, rx78_cart )

8
src/mame/drivers/studio2.cpp
View File

@ -514,10 +514,10 @@ WRITE8_MEMBER( mpt02_state::dma_w )
/* Machine Initialization */
// trampolines to cartridge
READ8_MEMBER( studio2_state::cart_400 ) { return m_cart->read_rom(space, offset); }
READ8_MEMBER( studio2_state::cart_a00 ) { return m_cart->read_rom(space, offset + 0x600); }
READ8_MEMBER( studio2_state::cart_e00 ) { return m_cart->read_rom(space, offset + 0xa00); }
READ8_MEMBER( mpt02_state::cart_c00 ) { return m_cart->read_rom(space, offset + 0x800); }
READ8_MEMBER( studio2_state::cart_400 ) { return m_cart->read_rom(offset); }
READ8_MEMBER( studio2_state::cart_a00 ) { return m_cart->read_rom(offset + 0x600); }
READ8_MEMBER( studio2_state::cart_e00 ) { return m_cart->read_rom(offset + 0xa00); }
READ8_MEMBER( mpt02_state::cart_c00 ) { return m_cart->read_rom(offset + 0x800); }
void studio2_state::machine_start()
{

2
src/mame/drivers/supracan.cpp
View File

@ -1762,7 +1762,7 @@ void supracan_state::machine_start()
m_line_off_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(supracan_state::supracan_line_off_callback),this));
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0x000000, 0x3fffff, read16_delegate(FUNC(generic_slot_device::read16_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x000000, 0x3fffff, read16s_delegate(FUNC(generic_slot_device::read16_rom),(generic_slot_device*)m_cart));
}

2
src/mame/drivers/sv8000.cpp
View File

@ -182,7 +182,7 @@ void sv8000_state::machine_start()
m_inv = 0;
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x0fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x0fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
save_item(NAME(m_column));
save_item(NAME(m_ag));

2
src/mame/drivers/svi318.cpp
View File

@ -378,7 +378,7 @@ READ8_MEMBER( svi3x8_state::mreq_r )
offset ^= 0x8000;
if (CCS1 || CCS2 || CCS3 || CCS4)
return m_cart_rom->read_rom(space, offset);
return m_cart_rom->read_rom(offset);
uint8_t data = m_expander->mreq_r(space, offset);

2
src/mame/drivers/ti74.cpp
View File

@ -504,7 +504,7 @@ void ti74_state::machine_start()
m_lamps.resolve();
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000, 0xbfff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000, 0xbfff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
membank("sysbank")->configure_entries(0, 4, memregion("system")->base(), 0x2000);
membank("sysbank")->set_entry(0);

2
src/mame/drivers/unichamp.cpp
View File

@ -186,7 +186,7 @@ void unichamp_state::machine_start()
ptr[i+1] = TEMP;
}
m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x17ff,
read16_delegate(FUNC(generic_slot_device::read16_rom),(generic_slot_device*)m_cart));
read16s_delegate(FUNC(generic_slot_device::read16_rom),(generic_slot_device*)m_cart));
} else
m_maincpu->space(AS_PROGRAM).install_read_handler(0x1000, 0x17ff,
read16_delegate(FUNC(unichamp_state::read_ff), this));

2
src/mame/drivers/uzebox.cpp
View File

@ -87,7 +87,7 @@ void uzebox_state::machine_start()
m_screen->register_screen_bitmap(m_bitmap);
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0xffff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0xffff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
}
void uzebox_state::machine_reset()

16
src/mame/drivers/vc4000.cpp
View File

@ -370,23 +370,23 @@ void vc4000_state::machine_start()
switch (m_cart->get_type())
{
case VC4000_STD:
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x07ff, read8_delegate(FUNC(vc4000_cart_slot_device::read_rom),(vc4000_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x07ff, read8sm_delegate(FUNC(vc4000_cart_slot_device::read_rom),(vc4000_cart_slot_device*)m_cart));
break;
case VC4000_ROM4K:
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x0fff, read8_delegate(FUNC(vc4000_cart_slot_device::read_rom),(vc4000_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x0fff, read8sm_delegate(FUNC(vc4000_cart_slot_device::read_rom),(vc4000_cart_slot_device*)m_cart));
break;
case VC4000_RAM1K:
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x0fff, read8_delegate(FUNC(vc4000_cart_slot_device::read_rom),(vc4000_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x15ff, read8_delegate(FUNC(vc4000_cart_slot_device::read_ram),(vc4000_cart_slot_device*)m_cart), write8_delegate(FUNC(vc4000_cart_slot_device::write_ram),(vc4000_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x0fff, read8sm_delegate(FUNC(vc4000_cart_slot_device::read_rom),(vc4000_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1000, 0x15ff, read8sm_delegate(FUNC(vc4000_cart_slot_device::read_ram),(vc4000_cart_slot_device*)m_cart), write8sm_delegate(FUNC(vc4000_cart_slot_device::write_ram),(vc4000_cart_slot_device*)m_cart));
break;
case VC4000_CHESS2:
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x15ff, read8_delegate(FUNC(vc4000_cart_slot_device::read_rom),(vc4000_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1800, 0x1bff, read8_delegate(FUNC(vc4000_cart_slot_device::read_ram),(vc4000_cart_slot_device*)m_cart), write8_delegate(FUNC(vc4000_cart_slot_device::write_ram),(vc4000_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x15ff, read8sm_delegate(FUNC(vc4000_cart_slot_device::read_rom),(vc4000_cart_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x1800, 0x1bff, read8sm_delegate(FUNC(vc4000_cart_slot_device::read_ram),(vc4000_cart_slot_device*)m_cart), write8sm_delegate(FUNC(vc4000_cart_slot_device::write_ram),(vc4000_cart_slot_device*)m_cart));
break;
// undumped Radofin Hobby Module
// case VC4000_HOBBY:
// m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x07ff, read8_delegate(FUNC(vc4000_cart_slot_device::read_rom),(vc4000_cart_slot_device*)m_cart));
// m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x0800, 0x0fff, read8_delegate(FUNC(vc4000_cart_slot_device::read_ram),(vc4000_cart_slot_device*)m_cart), write8_delegate(FUNC(vc4000_cart_slot_device::write_ram),(vc4000_cart_slot_device*)m_cart));
// m_maincpu->space(AS_PROGRAM).install_read_handler(0x0000, 0x07ff, read8sm_delegate(FUNC(vc4000_cart_slot_device::read_rom),(vc4000_cart_slot_device*)m_cart));
// m_maincpu->space(AS_PROGRAM).install_readwrite_handler(0x0800, 0x0fff, read8sm_delegate(FUNC(vc4000_cart_slot_device::read_ram),(vc4000_cart_slot_device*)m_cart), write8sm_delegate(FUNC(vc4000_cart_slot_device::write_ram),(vc4000_cart_slot_device*)m_cart));
// break;
}

6
src/mame/drivers/x07.cpp
View File

@ -1437,9 +1437,9 @@ void x07_state::machine_start()
{
// 0x4000 - 0x4fff 4KB RAM
// 0x6000 - 0x7fff 8KB ROM
program.install_read_handler(ram_size, ram_size + 0xfff, read8_delegate(FUNC(generic_slot_device::read_ram),(generic_slot_device*)m_card));
program.install_write_handler(ram_size, ram_size + 0xfff, write8_delegate(FUNC(generic_slot_device::write_ram),(generic_slot_device*)m_card));
program.install_read_handler(0x6000, 0x7fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_card));
program.install_read_handler(ram_size, ram_size + 0xfff, read8sm_delegate(FUNC(generic_slot_device::read_ram),(generic_slot_device*)m_card));
program.install_write_handler(ram_size, ram_size + 0xfff, write8sm_delegate(FUNC(generic_slot_device::write_ram),(generic_slot_device*)m_card));
program.install_read_handler(0x6000, 0x7fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_card));
m_card->save_ram();
}

2
src/mame/drivers/x1.cpp
View File

@ -700,7 +700,7 @@ READ8_MEMBER( x1_state::x1_rom_r )
{
// logerror("%06x\n",m_rom_index[0]<<16|m_rom_index[1]<<8|m_rom_index[2]<<0);
if (m_cart->exists())
return m_cart->read_rom(space, (m_rom_index[0] << 16) | (m_rom_index[1] << 8) | (m_rom_index[2] << 0));
return m_cart->read_rom((m_rom_index[0] << 16) | (m_rom_index[1] << 8) | (m_rom_index[2] << 0));
else
return 0;
}

14
src/mame/machine/aim65.cpp
View File

@ -128,21 +128,21 @@ void aim65_state::machine_start()
// Init ROM sockets
if (m_z24->exists())
space.install_read_handler(0xd000, 0xdfff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_z24));
space.install_read_handler(0xd000, 0xdfff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_z24));
if (m_z25->exists())
space.install_read_handler(0xc000, 0xcfff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_z25));
space.install_read_handler(0xc000, 0xcfff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_z25));
if (m_z26->exists())
space.install_read_handler(0xb000, 0xbfff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_z26));
space.install_read_handler(0xb000, 0xbfff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_z26));
// Init PROM/ROM module sockets
if (m_z12->exists())
space.install_read_handler(0x4000, 0x4fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_z12));
space.install_read_handler(0x4000, 0x4fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_z12));
if (m_z13->exists())
space.install_read_handler(0x5000, 0x5fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_z13));
space.install_read_handler(0x5000, 0x5fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_z13));
if (m_z14->exists())
space.install_read_handler(0x6000, 0x6fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_z14));
space.install_read_handler(0x6000, 0x6fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_z14));
if (m_z15->exists())
space.install_read_handler(0x7000, 0x7fff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_z15));
space.install_read_handler(0x7000, 0x7fff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_z15));
// Init RAM
space.install_ram(0x0000, m_ram->size() - 1, m_ram->pointer());

2
src/mame/machine/gamepock.cpp
View File

@ -140,7 +140,7 @@ void gamepock_state::machine_reset()
hd44102ch_init( 2 );
if (m_cart->exists())
m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000,0xbfff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
m_maincpu->space(AS_PROGRAM).install_read_handler(0x4000,0xbfff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
}

4
src/mame/machine/intv.cpp
View File

@ -539,9 +539,9 @@ WRITE16_MEMBER( intv_state::intv_ram16_w )
READ8_MEMBER( intv_state::intvkb_iocart_r )
{
if (m_iocart1->exists())
return m_iocart1->read_rom(space, offset, mem_mask);
return m_iocart1->read_rom(offset);
else if (m_iocart2->exists())
return m_iocart2->read_rom(space, offset, mem_mask);
return m_iocart2->read_rom(offset);
else
return m_region_keyboard->as_u8(offset + 0xe000);
}

2
src/mame/machine/lynx.cpp
View File

@ -1020,7 +1020,7 @@ READ8_MEMBER(lynx_state::suzy_read)
break;
case RCART:
if (m_cart->exists())
value = m_cart->read_rom(space, (m_suzy.high * m_granularity) + m_suzy.low);
value = m_cart->read_rom((m_suzy.high * m_granularity) + m_suzy.low);
else
value = 0;
m_suzy.low = (m_suzy.low + 1) & (m_granularity - 1);

2
src/mame/machine/orion.cpp
View File

@ -27,7 +27,7 @@ READ8_MEMBER(orion_state::orion_romdisk_porta_r)
{
uint16_t addr = (m_romdisk_msb << 8) | m_romdisk_lsb;
if (m_cart->exists() && addr < m_cart->get_rom_size())
return m_cart->read_rom(space, addr);
return m_cart->read_rom(addr);
else
return 0xff;
}

2
src/mame/machine/radio86.cpp
View File

@ -177,7 +177,7 @@ READ8_MEMBER(radio86_state::radio86rom_romdisk_porta_r)
{
uint16_t addr = (m_romdisk_msb << 8) | m_romdisk_lsb;
if (m_cart->exists() && addr < m_cart->get_rom_size())
return m_cart->read_rom(space, addr);
return m_cart->read_rom(addr);
else
return 0xff;
}

4
src/mame/machine/sorcerer.cpp
View File

@ -417,7 +417,7 @@ void sorcerer_state::machine_start()
}
if (m_cart->exists())
space.install_read_handler(0xc000, 0xdfff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
space.install_read_handler(0xc000, 0xdfff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
}
MACHINE_START_MEMBER(sorcerer_state,sorcererd)
@ -445,7 +445,7 @@ MACHINE_START_MEMBER(sorcerer_state,sorcererd)
}
if (m_cart->exists())
space.install_read_handler(0xc000, 0xdfff, read8_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
space.install_read_handler(0xc000, 0xdfff, read8sm_delegate(FUNC(generic_slot_device::read_rom),(generic_slot_device*)m_cart));
}
void sorcerer_state::machine_reset()

2
src/mame/machine/vector06.cpp
View File

@ -72,7 +72,7 @@ READ8_MEMBER( vector06_state::vector06_romdisk_portb_r )
{
uint16_t addr = ((m_romdisk_msb & 0x7f) << 8) | m_romdisk_lsb;
if ((m_romdisk_msb & 0x80) && m_cart->exists() && addr < m_cart->get_rom_size())
return m_cart->read_rom(space, addr);
return m_cart->read_rom(addr);
else
return m_ay->data_r();
}

2
src/mame/machine/vtech2.cpp
View File

@ -76,7 +76,7 @@ READ8_MEMBER( vtech2_state::cart_r )
{
if (offset >= m_cart_size)
return 0xff;
return m_cart->read_rom(space, offset);
return m_cart->read_rom(offset);
}