Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-05 12:26:35 +03:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Address maps macros removal, pass 1 [O. Galibert]

Browse Source
This commit is contained in:
Olivier Galibert 2018-03-13 07:36:43 +01:00
parent f155992daa
commit 115bb9936c
2329 changed files with 88478 additions and 80365 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/devices/bus/a2bus/a2applicard.cpp
View File

@ -29,13 +29,15 @@ DEFINE_DEVICE_TYPE(A2BUS_APPLICARD, a2bus_applicard_device, "a2aplcrd", "PCPI Ap
#define Z80_TAG "z80"
#define Z80_ROM_REGION "z80_rom"
ADDRESS_MAP_START(a2bus_applicard_device::z80_mem)
AM_RANGE(0x0000, 0xffff) AM_READWRITE(dma_r, dma_w)
ADDRESS_MAP_END
void a2bus_applicard_device::z80_mem(address_map &map)
{
map(0x0000, 0xffff).rw(this, FUNC(a2bus_applicard_device::dma_r), FUNC(a2bus_applicard_device::dma_w));
}
ADDRESS_MAP_START(a2bus_applicard_device::z80_io)
AM_RANGE(0x00, 0x60) AM_MIRROR(0xff00) AM_READWRITE(z80_io_r, z80_io_w)
ADDRESS_MAP_END
void a2bus_applicard_device::z80_io(address_map &map)
{
map(0x00, 0x60).mirror(0xff00).rw(this, FUNC(a2bus_applicard_device::z80_io_r), FUNC(a2bus_applicard_device::z80_io_w));
}
ROM_START( a2applicard )
ROM_REGION(0x800, Z80_ROM_REGION, 0)

7
src/devices/bus/a2bus/a2softcard.cpp
View File

@ -24,9 +24,10 @@ DEFINE_DEVICE_TYPE(A2BUS_SOFTCARD, a2bus_softcard_device, "a2softcard", "Microso
#define Z80_TAG "z80"
ADDRESS_MAP_START(a2bus_softcard_device::z80_mem)
AM_RANGE(0x0000, 0xffff) AM_READWRITE(dma_r, dma_w)
ADDRESS_MAP_END
void a2bus_softcard_device::z80_mem(address_map &map)
{
map(0x0000, 0xffff).rw(this, FUNC(a2bus_softcard_device::dma_r), FUNC(a2bus_softcard_device::dma_w));
}
/***************************************************************************
FUNCTION PROTOTYPES

7
src/devices/bus/a2bus/a2themill.cpp
View File

@ -40,9 +40,10 @@ DEFINE_DEVICE_TYPE(A2BUS_THEMILL, a2bus_themill_device, "a2themill", "Stellation
#define M6809_TAG "m6809"
ADDRESS_MAP_START(a2bus_themill_device::m6809_mem)
AM_RANGE(0x0000, 0xffff) AM_READWRITE(dma_r, dma_w)
ADDRESS_MAP_END
void a2bus_themill_device::m6809_mem(address_map &map)
{
map(0x0000, 0xffff).rw(this, FUNC(a2bus_themill_device::dma_r), FUNC(a2bus_themill_device::dma_w));
}
/***************************************************************************
FUNCTION PROTOTYPES

26
src/devices/bus/a2bus/pc_xporter.cpp
View File

@ -91,19 +91,21 @@
DEFINE_DEVICE_TYPE(A2BUS_PCXPORTER, a2bus_pcxporter_device, "a2pcxport", "Applied Engineering PC Transporter")
ADDRESS_MAP_START(a2bus_pcxporter_device::pc_map)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_END
void a2bus_pcxporter_device::pc_map(address_map &map)
{
map.unmap_value_high();
}
ADDRESS_MAP_START(a2bus_pcxporter_device::pc_io)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x0000, 0x000f) AM_DEVREADWRITE8("dma8237", am9517a_device, read, write, 0xffff)
AM_RANGE(0x0020, 0x002f) AM_DEVREADWRITE8("pic8259", pic8259_device, read, write, 0xffff)
AM_RANGE(0x0040, 0x004f) AM_DEVREADWRITE8("pit8253", pit8253_device, read, write, 0xffff)
AM_RANGE(0x0060, 0x0065) AM_READWRITE8(kbd_6502_r, kbd_6502_w, 0xffff)
AM_RANGE(0x0080, 0x008f) AM_WRITE8(pc_page_w, 0xffff)
AM_RANGE(0x00a0, 0x00a1) AM_WRITE8(nmi_enable_w, 0xffff)
ADDRESS_MAP_END
void a2bus_pcxporter_device::pc_io(address_map &map)
{
map.unmap_value_high();
map(0x0000, 0x000f).rw("dma8237", FUNC(am9517a_device::read), FUNC(am9517a_device::write));
map(0x0020, 0x002f).rw("pic8259", FUNC(pic8259_device::read), FUNC(pic8259_device::write));
map(0x0040, 0x004f).rw("pit8253", FUNC(pit8253_device::read), FUNC(pit8253_device::write));
map(0x0060, 0x0065).rw(this, FUNC(a2bus_pcxporter_device::kbd_6502_r), FUNC(a2bus_pcxporter_device::kbd_6502_w));
map(0x0080, 0x008f).w(this, FUNC(a2bus_pcxporter_device::pc_page_w));
map(0x00a0, 0x00a1).w(this, FUNC(a2bus_pcxporter_device::nmi_enable_w));
}
/***************************************************************************
FUNCTION PROTOTYPES

7
src/devices/bus/a2bus/transwarp.cpp
View File

@ -31,9 +31,10 @@ DEFINE_DEVICE_TYPE(A2BUS_TRANSWARP, a2bus_transwarp_device, "a2twarp", "Applied
#define CPU_TAG "tw65c02"
ADDRESS_MAP_START(a2bus_transwarp_device::m65c02_mem)
AM_RANGE(0x0000, 0xffff) AM_READWRITE(dma_r, dma_w)
ADDRESS_MAP_END
void a2bus_transwarp_device::m65c02_mem(address_map &map)
{
map(0x0000, 0xffff).rw(this, FUNC(a2bus_transwarp_device::dma_r), FUNC(a2bus_transwarp_device::dma_w));
}
ROM_START( warprom )
ROM_REGION(0x1000, "twrom", 0)

16
src/devices/bus/abcbus/cadmouse.cpp
View File

@ -105,19 +105,21 @@ const tiny_rom_entry *abc_cadmouse_device::device_rom_region() const
// ADDRESS_MAP( abc_cadmouse_mem )
//-------------------------------------------------
ADDRESS_MAP_START( abc_cadmouse_device::abc_cadmouse_mem )
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_GLOBAL_MASK(0x3fff)
AM_RANGE(0x0000, 0x3fff) AM_ROM AM_REGION(Z80_TAG, 0)
ADDRESS_MAP_END
void abc_cadmouse_device::abc_cadmouse_mem(address_map &map)
{
map.unmap_value_high();
map.global_mask(0x3fff);
map(0x0000, 0x3fff).rom().region(Z80_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( abc_cadmouse_io )
//-------------------------------------------------
ADDRESS_MAP_START( abc_cadmouse_device::abc_cadmouse_io )
ADDRESS_MAP_END
void abc_cadmouse_device::abc_cadmouse_io(address_map &map)
{
}
//-------------------------------------------------
// device_add_mconfig - add device configuration

12
src/devices/bus/abcbus/db411223.cpp
View File

@ -49,17 +49,19 @@ const tiny_rom_entry *databoard_4112_23_t::device_rom_region() const
// ADDRESS_MAP( databoard_4112_23_mem )
//-------------------------------------------------
ADDRESS_MAP_START(databoard_4112_23_t::databoard_4112_23_mem)
AM_RANGE(0x0000, 0x1fff) AM_ROM AM_REGION(Z80_TAG, 0)
ADDRESS_MAP_END
void databoard_4112_23_t::databoard_4112_23_mem(address_map &map)
{
map(0x0000, 0x1fff).rom().region(Z80_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( databoard_4112_23_io )
//-------------------------------------------------
ADDRESS_MAP_START(databoard_4112_23_t::databoard_4112_23_io)
ADDRESS_MAP_END
void databoard_4112_23_t::databoard_4112_23_io(address_map &map)
{
}
//-------------------------------------------------

22
src/devices/bus/abcbus/fd2.cpp
View File

@ -114,22 +114,24 @@ WRITE8_MEMBER( abc_fd2_device::status_w )
// ADDRESS_MAP( abc_fd2_mem )
//-------------------------------------------------
ADDRESS_MAP_START(abc_fd2_device::abc_fd2_mem)
AM_RANGE(0x0000, 0x03ff) AM_ROM AM_REGION(Z80_TAG, 0)
AM_RANGE(0x0800, 0x0bff) AM_RAM
ADDRESS_MAP_END
void abc_fd2_device::abc_fd2_mem(address_map &map)
{
map(0x0000, 0x03ff).rom().region(Z80_TAG, 0);
map(0x0800, 0x0bff).ram();
}
//-------------------------------------------------
// ADDRESS_MAP( abc_fd2_io )
//-------------------------------------------------
ADDRESS_MAP_START(abc_fd2_device::abc_fd2_io)
ADDRESS_MAP_GLOBAL_MASK(0x73)
AM_RANGE(0x30, 0x33) AM_DEVREADWRITE(Z80PIO_TAG, z80pio_device, read_alt, write_alt)
AM_RANGE(0x50, 0x53) AM_DEVREADWRITE(FD1771_TAG, fd1771_device, read, write)
AM_RANGE(0x60, 0x60) AM_WRITE(status_w)
ADDRESS_MAP_END
void abc_fd2_device::abc_fd2_io(address_map &map)
{
map.global_mask(0x73);
map(0x30, 0x33).rw(Z80PIO_TAG, FUNC(z80pio_device::read_alt), FUNC(z80pio_device::write_alt));
map(0x50, 0x53).rw(FD1771_TAG, FUNC(fd1771_device::read), FUNC(fd1771_device::write));
map(0x60, 0x60).w(this, FUNC(abc_fd2_device::status_w));
}
//-------------------------------------------------

12
src/devices/bus/abcbus/hdc.cpp
View File

@ -54,17 +54,19 @@ const tiny_rom_entry *abc_hdc_device::device_rom_region() const
// ADDRESS_MAP( abc_hdc_mem )
//-------------------------------------------------
ADDRESS_MAP_START(abc_hdc_device::abc_hdc_mem)
AM_RANGE(0x0000, 0x0ff) AM_ROM AM_REGION(Z80_TAG, 0)
ADDRESS_MAP_END
void abc_hdc_device::abc_hdc_mem(address_map &map)
{
map(0x0000, 0x0ff).rom().region(Z80_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( abc_hdc_io )
//-------------------------------------------------
ADDRESS_MAP_START(abc_hdc_device::abc_hdc_io)
ADDRESS_MAP_END
void abc_hdc_device::abc_hdc_io(address_map &map)
{
}
//-------------------------------------------------

26
src/devices/bus/abcbus/lux10828.cpp
View File

@ -171,24 +171,26 @@ const tiny_rom_entry *luxor_55_10828_device::device_rom_region() const
// ADDRESS_MAP( luxor_55_10828_mem )
//-------------------------------------------------
ADDRESS_MAP_START(luxor_55_10828_device::luxor_55_10828_mem)
ADDRESS_MAP_GLOBAL_MASK(0x1fff)
AM_RANGE(0x0000, 0x07ff) AM_MIRROR(0x0800) AM_ROM AM_REGION(Z80_TAG, 0)
AM_RANGE(0x1000, 0x13ff) AM_MIRROR(0x0c00) AM_RAM
ADDRESS_MAP_END
void luxor_55_10828_device::luxor_55_10828_mem(address_map &map)
{
map.global_mask(0x1fff);
map(0x0000, 0x07ff).mirror(0x0800).rom().region(Z80_TAG, 0);
map(0x1000, 0x13ff).mirror(0x0c00).ram();
}
//-------------------------------------------------
// ADDRESS_MAP( luxor_55_10828_io )
//-------------------------------------------------
ADDRESS_MAP_START(luxor_55_10828_device::luxor_55_10828_io)
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE(0x70, 0x73) AM_MIRROR(0x0c) AM_DEVREADWRITE(Z80PIO_TAG, z80pio_device, read_alt, write_alt)
AM_RANGE(0xb0, 0xb3) AM_MIRROR(0x0c) AM_READWRITE(fdc_r, fdc_w)
AM_RANGE(0xd0, 0xd0) AM_MIRROR(0x0f) AM_WRITE(status_w)
AM_RANGE(0xe0, 0xe0) AM_MIRROR(0x0f) AM_WRITE(ctrl_w)
ADDRESS_MAP_END
void luxor_55_10828_device::luxor_55_10828_io(address_map &map)
{
map.global_mask(0xff);
map(0x70, 0x73).mirror(0x0c).rw(Z80PIO_TAG, FUNC(z80pio_device::read_alt), FUNC(z80pio_device::write_alt));
map(0xb0, 0xb3).mirror(0x0c).rw(this, FUNC(luxor_55_10828_device::fdc_r), FUNC(luxor_55_10828_device::fdc_w));
map(0xd0, 0xd0).mirror(0x0f).w(this, FUNC(luxor_55_10828_device::status_w));
map(0xe0, 0xe0).mirror(0x0f).w(this, FUNC(luxor_55_10828_device::ctrl_w));
}
//-------------------------------------------------

38
src/devices/bus/abcbus/lux21046.cpp
View File

@ -137,30 +137,32 @@ const tiny_rom_entry *luxor_55_21046_device::device_rom_region() const
// ADDRESS_MAP( luxor_55_21046_mem )
//-------------------------------------------------
ADDRESS_MAP_START(luxor_55_21046_device::luxor_55_21046_mem)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_GLOBAL_MASK(0x3fff)
AM_RANGE(0x0000, 0x1fff) AM_ROM AM_REGION(Z80_TAG, 0x2000) // A13 pull-up
AM_RANGE(0x2000, 0x3fff) AM_RAM
ADDRESS_MAP_END
void luxor_55_21046_device::luxor_55_21046_mem(address_map &map)
{
map.unmap_value_high();
map.global_mask(0x3fff);
map(0x0000, 0x1fff).rom().region(Z80_TAG, 0x2000); // A13 pull-up
map(0x2000, 0x3fff).ram();
}
//-------------------------------------------------
// ADDRESS_MAP( luxor_55_21046_io )
//-------------------------------------------------
ADDRESS_MAP_START(luxor_55_21046_device::luxor_55_21046_io)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x0c, 0x0c) AM_MIRROR(0xff03) AM_READ(out_r)
AM_RANGE(0x1c, 0x1c) AM_MIRROR(0xff03) AM_WRITE(inp_w)
AM_RANGE(0x2c, 0x2c) AM_MIRROR(0xff03) AM_WRITE(_4b_w)
AM_RANGE(0x3c, 0x3c) AM_MIRROR(0xff03) AM_WRITE(_9b_w)
AM_RANGE(0x4c, 0x4c) AM_MIRROR(0xff03) AM_WRITE(_8a_w)
AM_RANGE(0x58, 0x58) AM_MIRROR(0x0007) AM_SELECT(0xff00) AM_READ(_9a_r)
AM_RANGE(0x68, 0x6b) AM_MIRROR(0xff00) AM_DEVREAD(SAB1793_TAG, fd1793_device, read)
AM_RANGE(0x78, 0x7b) AM_MIRROR(0xff00) AM_DEVWRITE(SAB1793_TAG, fd1793_device, write)
AM_RANGE(0x80, 0x80) AM_MIRROR(0xff77) AM_DEVREADWRITE(Z80DMA_TAG, z80dma_device, read, write)
ADDRESS_MAP_END
void luxor_55_21046_device::luxor_55_21046_io(address_map &map)
{
map.unmap_value_high();
map(0x0c, 0x0c).mirror(0xff03).r(this, FUNC(luxor_55_21046_device::out_r));
map(0x1c, 0x1c).mirror(0xff03).w(this, FUNC(luxor_55_21046_device::inp_w));
map(0x2c, 0x2c).mirror(0xff03).w(this, FUNC(luxor_55_21046_device::_4b_w));
map(0x3c, 0x3c).mirror(0xff03).w(this, FUNC(luxor_55_21046_device::_9b_w));
map(0x4c, 0x4c).mirror(0xff03).w(this, FUNC(luxor_55_21046_device::_8a_w));
map(0x58, 0x58).mirror(0x0007).select(0xff00).r(this, FUNC(luxor_55_21046_device::_9a_r));
map(0x68, 0x6b).mirror(0xff00).r(SAB1793_TAG, FUNC(fd1793_device::read));
map(0x78, 0x7b).mirror(0xff00).w(SAB1793_TAG, FUNC(fd1793_device::write));
map(0x80, 0x80).mirror(0xff77).rw(Z80DMA_TAG, FUNC(z80dma_device::read), FUNC(z80dma_device::write));
}
//-------------------------------------------------

40
src/devices/bus/abcbus/lux21056.cpp
View File

@ -133,31 +133,33 @@ const tiny_rom_entry *luxor_55_21056_device::device_rom_region() const
// ADDRESS_MAP( luxor_55_21056_mem )
//-------------------------------------------------
ADDRESS_MAP_START(luxor_55_21056_device::luxor_55_21056_mem)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_GLOBAL_MASK(0x3fff)
AM_RANGE(0x0000, 0x0fff) AM_MIRROR(0x1000) AM_ROM AM_REGION(Z80_TAG, 0)
AM_RANGE(0x2000, 0x27ff) AM_MIRROR(0x1800) AM_RAM
ADDRESS_MAP_END
void luxor_55_21056_device::luxor_55_21056_mem(address_map &map)
{
map.unmap_value_high();
map.global_mask(0x3fff);
map(0x0000, 0x0fff).mirror(0x1000).rom().region(Z80_TAG, 0);
map(0x2000, 0x27ff).mirror(0x1800).ram();
}
//-------------------------------------------------
// ADDRESS_MAP( luxor_55_21056_io )
//-------------------------------------------------
ADDRESS_MAP_START(luxor_55_21056_device::luxor_55_21056_io)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_GLOBAL_MASK(0xf8)
AM_RANGE(0x00, 0x00) AM_MIRROR(0xf0) AM_DEVREADWRITE(Z80DMA_TAG, z80dma_device, read, write)
AM_RANGE(0x08, 0x08) AM_READ(sasi_status_r)
AM_RANGE(0x18, 0x18) AM_WRITE(stat_w)
AM_RANGE(0x28, 0x28) AM_READ(out_r)
AM_RANGE(0x38, 0x38) AM_WRITE(inp_w)
AM_RANGE(0x48, 0x48) AM_READWRITE(sasi_data_r, sasi_data_w)
AM_RANGE(0x58, 0x58) AM_READWRITE(rdy_reset_r, rdy_reset_w)
AM_RANGE(0x68, 0x68) AM_READWRITE(sasi_sel_r, sasi_sel_w)
AM_RANGE(0x78, 0x78) AM_READWRITE(sasi_rst_r, sasi_rst_w)
ADDRESS_MAP_END
void luxor_55_21056_device::luxor_55_21056_io(address_map &map)
{
map.unmap_value_high();
map.global_mask(0xf8);
map(0x00, 0x00).mirror(0xf0).rw(Z80DMA_TAG, FUNC(z80dma_device::read), FUNC(z80dma_device::write));
map(0x08, 0x08).r(this, FUNC(luxor_55_21056_device::sasi_status_r));
map(0x18, 0x18).w(this, FUNC(luxor_55_21056_device::stat_w));
map(0x28, 0x28).r(this, FUNC(luxor_55_21056_device::out_r));
map(0x38, 0x38).w(this, FUNC(luxor_55_21056_device::inp_w));
map(0x48, 0x48).rw(this, FUNC(luxor_55_21056_device::sasi_data_r), FUNC(luxor_55_21056_device::sasi_data_w));
map(0x58, 0x58).rw(this, FUNC(luxor_55_21056_device::rdy_reset_r), FUNC(luxor_55_21056_device::rdy_reset_w));
map(0x68, 0x68).rw(this, FUNC(luxor_55_21056_device::sasi_sel_r), FUNC(luxor_55_21056_device::sasi_sel_w));
map(0x78, 0x78).rw(this, FUNC(luxor_55_21056_device::sasi_rst_r), FUNC(luxor_55_21056_device::sasi_rst_w));
}
//-------------------------------------------------

12
src/devices/bus/abcbus/unidisk.cpp
View File

@ -54,17 +54,19 @@ const tiny_rom_entry *unidisk_t::device_rom_region() const
// ADDRESS_MAP( unidisk_mem )
//-------------------------------------------------
ADDRESS_MAP_START(unidisk_t::unidisk_mem)
AM_RANGE(0x0000, 0x0fff) AM_ROM AM_REGION(TMS9995_TAG, 0)
ADDRESS_MAP_END
void unidisk_t::unidisk_mem(address_map &map)
{
map(0x0000, 0x0fff).rom().region(TMS9995_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( unidisk_io )
//-------------------------------------------------
ADDRESS_MAP_START(unidisk_t::unidisk_io)
ADDRESS_MAP_END
void unidisk_t::unidisk_io(address_map &map)
{
}
//-------------------------------------------------

16
src/devices/bus/abckb/abc77.cpp
View File

@ -89,19 +89,21 @@ const tiny_rom_entry *abc77_device::device_rom_region() const
// ADDRESS_MAP( abc77_mem )
//-------------------------------------------------
ADDRESS_MAP_START(abc77_device::abc77_map)
AM_RANGE(0x000, 0xfff) AM_ROM AM_REGION("z16", 0)
ADDRESS_MAP_END
void abc77_device::abc77_map(address_map &map)
{
map(0x000, 0xfff).rom().region("z16", 0);
}
//-------------------------------------------------
// ADDRESS_MAP( abc77_io )
//-------------------------------------------------
ADDRESS_MAP_START(abc77_device::abc77_io)
AM_RANGE(0x00, 0x00) AM_MIRROR(0xff) AM_WRITE(j3_w)
AM_RANGE(0x00, 0x00) AM_MIRROR(0xff) AM_READ_PORT("DSW")
ADDRESS_MAP_END
void abc77_device::abc77_io(address_map &map)
{
map(0x00, 0x00).mirror(0xff).w(this, FUNC(abc77_device::j3_w));
map(0x00, 0x00).mirror(0xff).portr("DSW");
}
//-------------------------------------------------

53
src/devices/bus/abckb/abc99.cpp
View File

@ -106,43 +106,46 @@ const tiny_rom_entry *abc99_device::device_rom_region() const
// ADDRESS_MAP( abc99_z2_mem )
//-------------------------------------------------
ADDRESS_MAP_START(abc99_device::abc99_z2_mem)
AM_RANGE(0x0000, 0x0fff) AM_ROM AM_REGION(I8035_Z2_TAG, 0)
ADDRESS_MAP_END
void abc99_device::abc99_z2_mem(address_map &map)
{
map(0x0000, 0x0fff).rom().region(I8035_Z2_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( abc99_z2_io )
//-------------------------------------------------
ADDRESS_MAP_START(abc99_device::abc99_z2_io)
AM_RANGE(0x21, 0x21) AM_WRITE(z2_led_w)
AM_RANGE(0x30, 0x30) AM_READ_PORT("X0") AM_WRITENOP
AM_RANGE(0x31, 0x31) AM_READ_PORT("X1") AM_WRITENOP
AM_RANGE(0x32, 0x32) AM_READ_PORT("X2") AM_WRITENOP
AM_RANGE(0x33, 0x33) AM_READ_PORT("X3") AM_WRITENOP
AM_RANGE(0x34, 0x34) AM_READ_PORT("X4") AM_WRITENOP
AM_RANGE(0x35, 0x35) AM_READ_PORT("X5") AM_WRITENOP
AM_RANGE(0x36, 0x36) AM_READ_PORT("X6") AM_WRITENOP
AM_RANGE(0x37, 0x37) AM_READ_PORT("X7") AM_WRITENOP
AM_RANGE(0x38, 0x38) AM_READ_PORT("X8") AM_WRITENOP
AM_RANGE(0x39, 0x39) AM_READ_PORT("X9") AM_WRITENOP
AM_RANGE(0x3a, 0x3a) AM_READ_PORT("X10") AM_WRITENOP
AM_RANGE(0x3b, 0x3b) AM_READ_PORT("X11") AM_WRITENOP
AM_RANGE(0x3c, 0x3c) AM_READ_PORT("X12") AM_WRITENOP
AM_RANGE(0x3d, 0x3d) AM_READ_PORT("X13") AM_WRITENOP
AM_RANGE(0x3e, 0x3e) AM_READ_PORT("X14") AM_WRITENOP
AM_RANGE(0x3f, 0x3f) AM_READ_PORT("X15") AM_WRITENOP
ADDRESS_MAP_END
void abc99_device::abc99_z2_io(address_map &map)
{
map(0x21, 0x21).w(this, FUNC(abc99_device::z2_led_w));
map(0x30, 0x30).portr("X0").nopw();
map(0x31, 0x31).portr("X1").nopw();
map(0x32, 0x32).portr("X2").nopw();
map(0x33, 0x33).portr("X3").nopw();
map(0x34, 0x34).portr("X4").nopw();
map(0x35, 0x35).portr("X5").nopw();
map(0x36, 0x36).portr("X6").nopw();
map(0x37, 0x37).portr("X7").nopw();
map(0x38, 0x38).portr("X8").nopw();
map(0x39, 0x39).portr("X9").nopw();
map(0x3a, 0x3a).portr("X10").nopw();
map(0x3b, 0x3b).portr("X11").nopw();
map(0x3c, 0x3c).portr("X12").nopw();
map(0x3d, 0x3d).portr("X13").nopw();
map(0x3e, 0x3e).portr("X14").nopw();
map(0x3f, 0x3f).portr("X15").nopw();
}
//-------------------------------------------------
// ADDRESS_MAP( abc99_z5_mem )
//-------------------------------------------------
ADDRESS_MAP_START(abc99_device::abc99_z5_mem)
AM_RANGE(0x0000, 0x07ff) AM_ROM AM_REGION(I8035_Z5_TAG, 0)
ADDRESS_MAP_END
void abc99_device::abc99_z5_mem(address_map &map)
{
map(0x0000, 0x07ff).rom().region(I8035_Z5_TAG, 0);
}
//-------------------------------------------------

26
src/devices/bus/adamnet/ddp.cpp
View File

@ -50,24 +50,26 @@ const tiny_rom_entry *adam_digital_data_pack_device::device_rom_region() const
// ADDRESS_MAP( adam_ddp_mem )
//-------------------------------------------------
ADDRESS_MAP_START(adam_digital_data_pack_device::adam_ddp_mem)
AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE(M6801_TAG, m6801_cpu_device, m6801_io_r, m6801_io_w)
AM_RANGE(0x0080, 0x00ff) AM_RAM
AM_RANGE(0x0400, 0x07ff) AM_RAM
AM_RANGE(0xf800, 0xffff) AM_ROM AM_REGION(M6801_TAG, 0)
ADDRESS_MAP_END
void adam_digital_data_pack_device::adam_ddp_mem(address_map &map)
{
map(0x0000, 0x001f).rw(M6801_TAG, FUNC(m6801_cpu_device::m6801_io_r), FUNC(m6801_cpu_device::m6801_io_w));
map(0x0080, 0x00ff).ram();
map(0x0400, 0x07ff).ram();
map(0xf800, 0xffff).rom().region(M6801_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( adam_ddp_io )
//-------------------------------------------------
ADDRESS_MAP_START(adam_digital_data_pack_device::adam_ddp_io)
AM_RANGE(M6801_PORT1, M6801_PORT1) AM_WRITE(p1_w)
AM_RANGE(M6801_PORT2, M6801_PORT2) AM_READWRITE(p2_r, p2_w)
AM_RANGE(M6801_PORT3, M6801_PORT3) AM_NOP // Multiplexed Address/Data
AM_RANGE(M6801_PORT4, M6801_PORT4) AM_READ(p4_r) AM_WRITENOP
ADDRESS_MAP_END
void adam_digital_data_pack_device::adam_ddp_io(address_map &map)
{
map(M6801_PORT1, M6801_PORT1).w(this, FUNC(adam_digital_data_pack_device::p1_w));
map(M6801_PORT2, M6801_PORT2).rw(this, FUNC(adam_digital_data_pack_device::p2_r), FUNC(adam_digital_data_pack_device::p2_w));
map(M6801_PORT3, M6801_PORT3).noprw(); // Multiplexed Address/Data
map(M6801_PORT4, M6801_PORT4).r(this, FUNC(adam_digital_data_pack_device::p4_r)).nopw();
}
static const struct CassetteOptions adam_cassette_options =
{

46
src/devices/bus/adamnet/fdc.cpp
View File

@ -77,34 +77,36 @@ const tiny_rom_entry *adam_fdc_device::device_rom_region() const
// ADDRESS_MAP( fdc6801_mem )
//-------------------------------------------------
ADDRESS_MAP_START(adam_fdc_device::adam_fdc_mem)
AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE(M6801_TAG, m6801_cpu_device, m6801_io_r, m6801_io_w)
AM_RANGE(0x0080, 0x00ff) AM_RAM
AM_RANGE(0x0400, 0x07ff) AM_RAM AM_WRITEONLY AM_SHARE("ram")
AM_RANGE(0x0800, 0x0800) AM_MIRROR(0x3ff) AM_DEVREAD(WD2793_TAG, wd2793_device, status_r)
AM_RANGE(0x1400, 0x17ff) AM_RAM AM_READONLY AM_SHARE("ram")
AM_RANGE(0x1800, 0x1800) AM_MIRROR(0x3ff) AM_DEVWRITE(WD2793_TAG, wd2793_device, cmd_w)
AM_RANGE(0x2800, 0x2800) AM_MIRROR(0x3ff) AM_DEVREAD(WD2793_TAG, wd2793_device, track_r)
AM_RANGE(0x3800, 0x3800) AM_MIRROR(0x3ff) AM_DEVWRITE(WD2793_TAG, wd2793_device, track_w)
AM_RANGE(0x4800, 0x4800) AM_MIRROR(0x3ff) AM_DEVREAD(WD2793_TAG, wd2793_device, sector_r)
AM_RANGE(0x5800, 0x5800) AM_MIRROR(0x3ff) AM_DEVWRITE(WD2793_TAG, wd2793_device, sector_w)
AM_RANGE(0x6800, 0x6800) AM_MIRROR(0x3ff) AM_DEVREAD(WD2793_TAG, wd2793_device, data_r)
AM_RANGE(0x6c00, 0x6fff) AM_READ(data_r)
AM_RANGE(0x7800, 0x7800) AM_MIRROR(0x3ff) AM_DEVWRITE(WD2793_TAG, wd2793_device, data_w)
AM_RANGE(0x8000, 0x8fff) AM_MIRROR(0x7000) AM_ROM AM_REGION(M6801_TAG, 0)
ADDRESS_MAP_END
void adam_fdc_device::adam_fdc_mem(address_map &map)
{
map(0x0000, 0x001f).rw(M6801_TAG, FUNC(m6801_cpu_device::m6801_io_r), FUNC(m6801_cpu_device::m6801_io_w));
map(0x0080, 0x00ff).ram();
map(0x0400, 0x07ff).ram().writeonly().share("ram");
map(0x0800, 0x0800).mirror(0x3ff).r(WD2793_TAG, FUNC(wd2793_device::status_r));
map(0x1400, 0x17ff).ram().readonly().share("ram");
map(0x1800, 0x1800).mirror(0x3ff).w(WD2793_TAG, FUNC(wd2793_device::cmd_w));
map(0x2800, 0x2800).mirror(0x3ff).r(WD2793_TAG, FUNC(wd2793_device::track_r));
map(0x3800, 0x3800).mirror(0x3ff).w(WD2793_TAG, FUNC(wd2793_device::track_w));
map(0x4800, 0x4800).mirror(0x3ff).r(WD2793_TAG, FUNC(wd2793_device::sector_r));
map(0x5800, 0x5800).mirror(0x3ff).w(WD2793_TAG, FUNC(wd2793_device::sector_w));
map(0x6800, 0x6800).mirror(0x3ff).r(WD2793_TAG, FUNC(wd2793_device::data_r));
map(0x6c00, 0x6fff).r(this, FUNC(adam_fdc_device::data_r));
map(0x7800, 0x7800).mirror(0x3ff).w(WD2793_TAG, FUNC(wd2793_device::data_w));
map(0x8000, 0x8fff).mirror(0x7000).rom().region(M6801_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( fdc6801_io )
//-------------------------------------------------
ADDRESS_MAP_START(adam_fdc_device::adam_fdc_io)
AM_RANGE(M6801_PORT1, M6801_PORT1) AM_READWRITE(p1_r, p1_w)
AM_RANGE(M6801_PORT2, M6801_PORT2) AM_READWRITE(p2_r, p2_w)
AM_RANGE(M6801_PORT3, M6801_PORT3)
AM_RANGE(M6801_PORT4, M6801_PORT4)
ADDRESS_MAP_END
void adam_fdc_device::adam_fdc_io(address_map &map)
{
map(M6801_PORT1, M6801_PORT1).rw(this, FUNC(adam_fdc_device::p1_r), FUNC(adam_fdc_device::p1_w));
map(M6801_PORT2, M6801_PORT2).rw(this, FUNC(adam_fdc_device::p2_r), FUNC(adam_fdc_device::p2_w));
map(M6801_PORT3, M6801_PORT3);
map(M6801_PORT4, M6801_PORT4);
}
//-------------------------------------------------

24
src/devices/bus/adamnet/kb.cpp
View File

@ -50,23 +50,25 @@ const tiny_rom_entry *adam_keyboard_device::device_rom_region() const
// ADDRESS_MAP( adam_kb_mem )
//-------------------------------------------------
ADDRESS_MAP_START(adam_keyboard_device::adam_kb_mem)
AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE(M6801_TAG, m6801_cpu_device, m6801_io_r, m6801_io_w)
AM_RANGE(0x0080, 0x00ff) AM_RAM
AM_RANGE(0xf800, 0xffff) AM_ROM AM_REGION(M6801_TAG, 0)
ADDRESS_MAP_END
void adam_keyboard_device::adam_kb_mem(address_map &map)
{
map(0x0000, 0x001f).rw(M6801_TAG, FUNC(m6801_cpu_device::m6801_io_r), FUNC(m6801_cpu_device::m6801_io_w));
map(0x0080, 0x00ff).ram();
map(0xf800, 0xffff).rom().region(M6801_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( adam_kb_io )
//-------------------------------------------------
ADDRESS_MAP_START(adam_keyboard_device::adam_kb_io)
AM_RANGE(M6801_PORT1, M6801_PORT1) AM_READ(p1_r)
AM_RANGE(M6801_PORT2, M6801_PORT2) AM_READWRITE(p2_r, p2_w)
AM_RANGE(M6801_PORT3, M6801_PORT3) AM_READWRITE(p3_r, p3_w)
AM_RANGE(M6801_PORT4, M6801_PORT4) AM_READWRITE(p4_r, p4_w)
ADDRESS_MAP_END
void adam_keyboard_device::adam_kb_io(address_map &map)
{
map(M6801_PORT1, M6801_PORT1).r(this, FUNC(adam_keyboard_device::p1_r));
map(M6801_PORT2, M6801_PORT2).rw(this, FUNC(adam_keyboard_device::p2_r), FUNC(adam_keyboard_device::p2_w));
map(M6801_PORT3, M6801_PORT3).rw(this, FUNC(adam_keyboard_device::p3_r), FUNC(adam_keyboard_device::p3_w));
map(M6801_PORT4, M6801_PORT4).rw(this, FUNC(adam_keyboard_device::p4_r), FUNC(adam_keyboard_device::p4_w));
}
//-------------------------------------------------

24
src/devices/bus/adamnet/printer.cpp
View File

@ -50,23 +50,25 @@ const tiny_rom_entry *adam_printer_device::device_rom_region() const
// ADDRESS_MAP( adam_prn_mem )
//-------------------------------------------------
ADDRESS_MAP_START(adam_printer_device::adam_prn_mem)
AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE(M6801_TAG, m6801_cpu_device, m6801_io_r, m6801_io_w)
AM_RANGE(0x0080, 0x00ff) AM_RAM
AM_RANGE(0xf800, 0xffff) AM_ROM AM_REGION(M6801_TAG, 0)
ADDRESS_MAP_END
void adam_printer_device::adam_prn_mem(address_map &map)
{
map(0x0000, 0x001f).rw(M6801_TAG, FUNC(m6801_cpu_device::m6801_io_r), FUNC(m6801_cpu_device::m6801_io_w));
map(0x0080, 0x00ff).ram();
map(0xf800, 0xffff).rom().region(M6801_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( adam_prn_io )
//-------------------------------------------------
ADDRESS_MAP_START(adam_printer_device::adam_prn_io)
AM_RANGE(M6801_PORT1, M6801_PORT1) AM_WRITE(p1_w)
AM_RANGE(M6801_PORT2, M6801_PORT2) AM_READWRITE(p2_r, p2_w)
AM_RANGE(M6801_PORT3, M6801_PORT3) AM_READ(p3_r)
AM_RANGE(M6801_PORT4, M6801_PORT4) AM_READWRITE(p4_r, p4_w)
ADDRESS_MAP_END
void adam_printer_device::adam_prn_io(address_map &map)
{
map(M6801_PORT1, M6801_PORT1).w(this, FUNC(adam_printer_device::p1_w));
map(M6801_PORT2, M6801_PORT2).rw(this, FUNC(adam_printer_device::p2_r), FUNC(adam_printer_device::p2_w));
map(M6801_PORT3, M6801_PORT3).r(this, FUNC(adam_printer_device::p3_r));
map(M6801_PORT4, M6801_PORT4).rw(this, FUNC(adam_printer_device::p4_r), FUNC(adam_printer_device::p4_w));
}
//-------------------------------------------------

18
src/devices/bus/adamnet/spi.cpp
View File

@ -53,20 +53,22 @@ const tiny_rom_entry *adam_spi_device::device_rom_region() const
// ADDRESS_MAP( adam_spi_mem )
//-------------------------------------------------
ADDRESS_MAP_START(adam_spi_device::adam_spi_mem)
AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE(M6801_TAG, m6801_cpu_device, m6801_io_r, m6801_io_w)
AM_RANGE(0x0080, 0x00ff) AM_RAM
AM_RANGE(0xf800, 0xffff) AM_ROM AM_REGION(M6801_TAG, 0)
ADDRESS_MAP_END
void adam_spi_device::adam_spi_mem(address_map &map)
{
map(0x0000, 0x001f).rw(M6801_TAG, FUNC(m6801_cpu_device::m6801_io_r), FUNC(m6801_cpu_device::m6801_io_w));
map(0x0080, 0x00ff).ram();
map(0xf800, 0xffff).rom().region(M6801_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( adam_spi_io )
//-------------------------------------------------
ADDRESS_MAP_START(adam_spi_device::adam_spi_io)
AM_RANGE(M6801_PORT2, M6801_PORT2) AM_READWRITE(p2_r, p2_w)
ADDRESS_MAP_END
void adam_spi_device::adam_spi_io(address_map &map)
{
map(M6801_PORT2, M6801_PORT2).rw(this, FUNC(adam_spi_device::p2_r), FUNC(adam_spi_device::p2_w));
}
//-------------------------------------------------

33
src/devices/bus/amiga/keyboard/a500.cpp
View File

@ -34,22 +34,23 @@ DEFINE_DEVICE_TYPE_NS(A500_KBD_GB, bus::amiga::keyboard, a500_kbd_gb_device, "a5
namespace bus { namespace amiga { namespace keyboard {
ADDRESS_MAP_START(a500_kbd_device::mpu6500_map)
ADDRESS_MAP_GLOBAL_MASK(0xfff)
AM_RANGE(0x000, 0x03f) AM_RAM
AM_RANGE(0x080, 0x080) AM_READWRITE(port_a_r, port_a_w)
AM_RANGE(0x081, 0x081) AM_READ_PORT("special") AM_WRITE(port_b_w)
AM_RANGE(0x082, 0x082) AM_WRITE(port_c_w)
AM_RANGE(0x083, 0x083) AM_WRITE(port_d_w)
AM_RANGE(0x084, 0x085) AM_WRITE(latch_w)
AM_RANGE(0x086, 0x087) AM_READ(counter_r)
AM_RANGE(0x088, 0x088) AM_WRITE(transfer_latch_w)
AM_RANGE(0x089, 0x089) AM_WRITE(clear_pa0_detect)
AM_RANGE(0x08a, 0x08a) AM_WRITE(clear_pa1_detect)
AM_RANGE(0x08f, 0x08f) AM_READWRITE(control_r, control_w)
AM_RANGE(0x090, 0x0ff) AM_NOP
AM_RANGE(0x800, 0xfff) AM_ROM AM_REGION("ic1", 0)
ADDRESS_MAP_END
void a500_kbd_device::mpu6500_map(address_map &map)
{
map.global_mask(0xfff);
map(0x000, 0x03f).ram();
map(0x080, 0x080).rw(this, FUNC(a500_kbd_device::port_a_r), FUNC(a500_kbd_device::port_a_w));
map(0x081, 0x081).portr("special").w(this, FUNC(a500_kbd_device::port_b_w));
map(0x082, 0x082).w(this, FUNC(a500_kbd_device::port_c_w));
map(0x083, 0x083).w(this, FUNC(a500_kbd_device::port_d_w));
map(0x084, 0x085).w(this, FUNC(a500_kbd_device::latch_w));
map(0x086, 0x087).r(this, FUNC(a500_kbd_device::counter_r));
map(0x088, 0x088).w(this, FUNC(a500_kbd_device::transfer_latch_w));
map(0x089, 0x089).w(this, FUNC(a500_kbd_device::clear_pa0_detect));
map(0x08a, 0x08a).w(this, FUNC(a500_kbd_device::clear_pa1_detect));
map(0x08f, 0x08f).rw(this, FUNC(a500_kbd_device::control_r), FUNC(a500_kbd_device::control_w));
map(0x090, 0x0ff).noprw();
map(0x800, 0xfff).rom().region("ic1", 0);
}
namespace {

29
src/devices/bus/amiga/zorro/a2232.cpp
View File

@ -30,20 +30,21 @@ DEFINE_DEVICE_TYPE(A2232, a2232_device, "a2232", "CBM A2232 Serial Card")
// device_add_mconfig - add device configuration
//-------------------------------------------------
ADDRESS_MAP_START(a2232_device::iocpu_map)
AM_RANGE(0x0000, 0x3fff) AM_RAM AM_SHARE("shared")
AM_RANGE(0x4000, 0x47ff) AM_READWRITE(acia_0_r, acia_0_w)
AM_RANGE(0x4800, 0x4fff) AM_READWRITE(acia_1_r, acia_1_w)
AM_RANGE(0x5000, 0x57ff) AM_READWRITE(acia_2_r, acia_2_w)
AM_RANGE(0x5800, 0x5fff) AM_READWRITE(acia_3_r, acia_3_w)
AM_RANGE(0x6000, 0x67ff) AM_READWRITE(acia_4_r, acia_4_w)
AM_RANGE(0x6800, 0x6fff) AM_READWRITE(acia_5_r, acia_5_w)
AM_RANGE(0x7000, 0x73ff) AM_WRITE(int2_w)
AM_RANGE(0x7400, 0x77ff) AM_READWRITE(acia_6_r, acia_6_w)
AM_RANGE(0x7800, 0x7fff) AM_READWRITE(cia_r, cia_w)
AM_RANGE(0x8000, 0x8000) AM_WRITE(irq_ack8_w)
AM_RANGE(0xc000, 0xffff) AM_RAM AM_SHARE("shared")
ADDRESS_MAP_END
void a2232_device::iocpu_map(address_map &map)
{
map(0x0000, 0x3fff).ram().share("shared");
map(0x4000, 0x47ff).rw(this, FUNC(a2232_device::acia_0_r), FUNC(a2232_device::acia_0_w));
map(0x4800, 0x4fff).rw(this, FUNC(a2232_device::acia_1_r), FUNC(a2232_device::acia_1_w));
map(0x5000, 0x57ff).rw(this, FUNC(a2232_device::acia_2_r), FUNC(a2232_device::acia_2_w));
map(0x5800, 0x5fff).rw(this, FUNC(a2232_device::acia_3_r), FUNC(a2232_device::acia_3_w));
map(0x6000, 0x67ff).rw(this, FUNC(a2232_device::acia_4_r), FUNC(a2232_device::acia_4_w));
map(0x6800, 0x6fff).rw(this, FUNC(a2232_device::acia_5_r), FUNC(a2232_device::acia_5_w));
map(0x7000, 0x73ff).w(this, FUNC(a2232_device::int2_w));
map(0x7400, 0x77ff).rw(this, FUNC(a2232_device::acia_6_r), FUNC(a2232_device::acia_6_w));
map(0x7800, 0x7fff).rw(this, FUNC(a2232_device::cia_r), FUNC(a2232_device::cia_w));
map(0x8000, 0x8000).w(this, FUNC(a2232_device::irq_ack8_w));
map(0xc000, 0xffff).ram().share("shared");
}
MACHINE_CONFIG_START(a2232_device::device_add_mconfig)
// main cpu

7
src/devices/bus/bbc/tube/tube_6502.cpp
View File

@ -25,9 +25,10 @@ DEFINE_DEVICE_TYPE(BBC_TUBE_6502, bbc_tube_6502_device, "bbc_tube_6502", "Acorn
// ADDRESS_MAP( tube_6502_mem )
//-------------------------------------------------
ADDRESS_MAP_START(bbc_tube_6502_device::tube_6502_mem)
AM_RANGE(0x0000, 0xffff) AM_READWRITE(read, write)
ADDRESS_MAP_END
void bbc_tube_6502_device::tube_6502_mem(address_map &map)
{
map(0x0000, 0xffff).rw(this, FUNC(bbc_tube_6502_device::read), FUNC(bbc_tube_6502_device::write));
}
//-------------------------------------------------
// ROM( tube_6502 )

7
src/devices/bus/bbc/tube/tube_65c102.cpp
View File

@ -25,9 +25,10 @@ DEFINE_DEVICE_TYPE(BBC_TUBE_65C102, bbc_tube_65c102_device, "bbc_tube_65c102", "
// ADDRESS_MAP( tube_6502_mem )
//-------------------------------------------------
ADDRESS_MAP_START(bbc_tube_65c102_device::tube_6502_mem)
AM_RANGE(0x0000, 0xffff) AM_READWRITE(read, write)
ADDRESS_MAP_END
void bbc_tube_65c102_device::tube_6502_mem(address_map &map)
{
map(0x0000, 0xffff).rw(this, FUNC(bbc_tube_65c102_device::read), FUNC(bbc_tube_65c102_device::write));
}
//-------------------------------------------------
// ROM( tube_65c102 )

14
src/devices/bus/bbc/tube/tube_80186.cpp
View File

@ -25,17 +25,19 @@ DEFINE_DEVICE_TYPE(BBC_TUBE_80186, bbc_tube_80186_device, "bbc_tube_80186", "Aco
// ADDRESS_MAP( tube_80186_mem )
//-------------------------------------------------
ADDRESS_MAP_START(bbc_tube_80186_device::tube_80186_mem)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_END
void bbc_tube_80186_device::tube_80186_mem(address_map &map)
{
map.unmap_value_high();
}
//-------------------------------------------------
// ADDRESS_MAP( tube_80186_io )
//-------------------------------------------------
ADDRESS_MAP_START(bbc_tube_80186_device::tube_80186_io)
AM_RANGE(0x80, 0x8f) AM_DEVREADWRITE8("ula", tube_device, parasite_r, parasite_w, 0x00ff)
ADDRESS_MAP_END
void bbc_tube_80186_device::tube_80186_io(address_map &map)
{
map(0x80, 0x8f).rw("ula", FUNC(tube_device::parasite_r), FUNC(tube_device::parasite_w)).umask16(0x00ff);
}
//-------------------------------------------------
// ROM( tube_80186 )

24
src/devices/bus/bbc/tube/tube_80286.cpp
View File

@ -24,22 +24,24 @@ DEFINE_DEVICE_TYPE(BBC_TUBE_80286, bbc_tube_80286_device, "bbc_tube_80286", "Aco
// ADDRESS_MAP( tube_80286_mem )
//-------------------------------------------------
ADDRESS_MAP_START(bbc_tube_80286_device::tube_80286_mem)
ADDRESS_MAP_GLOBAL_MASK(0xfffff)
AM_RANGE(0x00000, 0xbffff) AM_RAM AM_SHARE("ram")
AM_RANGE(0xc0000, 0xc3fff) AM_ROM AM_REGION("bootstrap", 0) AM_MIRROR(0x3c000)
ADDRESS_MAP_END
void bbc_tube_80286_device::tube_80286_mem(address_map &map)
{
map.global_mask(0xfffff);
map(0x00000, 0xbffff).ram().share("ram");
map(0xc0000, 0xc3fff).rom().region("bootstrap", 0).mirror(0x3c000);
}
//-------------------------------------------------
// ADDRESS_MAP( tube_80286_io )
//-------------------------------------------------
ADDRESS_MAP_START(bbc_tube_80286_device::tube_80286_io)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x50, 0x51) AM_READ8(disable_boot_rom, 0x00ff)
AM_RANGE(0x60, 0x61) AM_WRITE8(irq_latch_w, 0x00ff)
AM_RANGE(0x80, 0x8f) AM_DEVREADWRITE8("ula", tube_device, parasite_r, parasite_w, 0x00ff)
ADDRESS_MAP_END
void bbc_tube_80286_device::tube_80286_io(address_map &map)
{
map.unmap_value_high();
map(0x50, 0x50).r(this, FUNC(bbc_tube_80286_device::disable_boot_rom));
map(0x60, 0x60).w(this, FUNC(bbc_tube_80286_device::irq_latch_w));
map(0x80, 0x8f).rw("ula", FUNC(tube_device::parasite_r), FUNC(tube_device::parasite_w)).umask16(0x00ff);
}
//-------------------------------------------------
// ROM( tube_80286 )

13
src/devices/bus/bbc/tube/tube_arm.cpp
View File

@ -23,12 +23,13 @@ DEFINE_DEVICE_TYPE(BBC_TUBE_ARM, bbc_tube_arm_device, "bbc_tube_arm", "ARM Evalu
// ADDRESS_MAP( tube_arm_mem )
//-------------------------------------------------
ADDRESS_MAP_START(bbc_tube_arm_device::tube_arm_mem)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x0000000, 0x03fffff) AM_READWRITE8(ram_r, ram_w, 0xffffffff)
AM_RANGE(0x1000000, 0x100001f) AM_DEVREADWRITE8("ula", tube_device, parasite_r, parasite_w, 0x000000ff)
AM_RANGE(0x3000000, 0x3003fff) AM_ROM AM_REGION("bootstrap", 0) AM_MIRROR(0xc000)
ADDRESS_MAP_END
void bbc_tube_arm_device::tube_arm_mem(address_map &map)
{
map.unmap_value_high();
map(0x0000000, 0x03fffff).rw(this, FUNC(bbc_tube_arm_device::ram_r), FUNC(bbc_tube_arm_device::ram_w));
map(0x1000000, 0x100001f).rw("ula", FUNC(tube_device::parasite_r), FUNC(tube_device::parasite_w)).umask32(0x000000ff);
map(0x3000000, 0x3003fff).rom().region("bootstrap", 0).mirror(0xc000);
}
//-------------------------------------------------
// ROM( tube_arm )

11
src/devices/bus/bbc/tube/tube_casper.cpp
View File

@ -23,11 +23,12 @@ DEFINE_DEVICE_TYPE(BBC_TUBE_CASPER, bbc_tube_casper_device, "bbc_tube_casper", "
// ADDRESS_MAP( tube_casper_mem )
//-------------------------------------------------
ADDRESS_MAP_START(bbc_tube_casper_device::tube_casper_mem)
AM_RANGE(0x00000, 0x03fff) AM_ROM AM_REGION("casper_rom", 0)
AM_RANGE(0x10000, 0x1001f) AM_DEVREADWRITE8("via6522_1",via6522_device, read, write, 0xff)
AM_RANGE(0x20000, 0x3ffff) AM_RAM
ADDRESS_MAP_END
void bbc_tube_casper_device::tube_casper_mem(address_map &map)
{
map(0x00000, 0x03fff).rom().region("casper_rom", 0);
map(0x10000, 0x1001f).rw("via6522_1", FUNC(via6522_device::read), FUNC(via6522_device::write)).umask16(0x00ff);
map(0x20000, 0x3ffff).ram();
}
//-------------------------------------------------
// ROM( tube_casper )

21
src/devices/bus/bbc/tube/tube_z80.cpp
View File

@ -25,25 +25,28 @@ DEFINE_DEVICE_TYPE(BBC_TUBE_Z80, bbc_tube_z80_device, "bbc_tube_z80", "Acorn Z80
// ADDRESS_MAP( tube_z80_mem )
//-------------------------------------------------
ADDRESS_MAP_START(bbc_tube_z80_device::tube_z80_mem)
AM_RANGE(0x0000, 0xffff) AM_READWRITE(mem_r, mem_w)
ADDRESS_MAP_END
void bbc_tube_z80_device::tube_z80_mem(address_map &map)
{
map(0x0000, 0xffff).rw(this, FUNC(bbc_tube_z80_device::mem_r), FUNC(bbc_tube_z80_device::mem_w));
}
//-------------------------------------------------
// ADDRESS_MAP( tube_z80_fetch )
//-------------------------------------------------
ADDRESS_MAP_START(bbc_tube_z80_device::tube_z80_fetch)
AM_RANGE(0x000, 0xffff) AM_READ(opcode_r)
ADDRESS_MAP_END
void bbc_tube_z80_device::tube_z80_fetch(address_map &map)
{
map(0x000, 0xffff).r(this, FUNC(bbc_tube_z80_device::opcode_r));
}
//-------------------------------------------------
// ADDRESS_MAP( tube_z80_io )
//-------------------------------------------------
ADDRESS_MAP_START(bbc_tube_z80_device::tube_z80_io)
AM_RANGE(0x00, 0x07) AM_MIRROR(0xff00) AM_DEVREADWRITE("ula", tube_device, parasite_r, parasite_w)
ADDRESS_MAP_END
void bbc_tube_z80_device::tube_z80_io(address_map &map)
{
map(0x00, 0x07).mirror(0xff00).rw("ula", FUNC(tube_device::parasite_r), FUNC(tube_device::parasite_w));
}
//-------------------------------------------------
// ROM( tube_z80 )

16
src/devices/bus/bbc/tube/tube_zep100.cpp
View File

@ -25,18 +25,20 @@ DEFINE_DEVICE_TYPE(BBC_TUBE_ZEP100, bbc_tube_zep100_device, "bbc_tube_zep100", "
// ADDRESS_MAP( tube_zep100_mem )
//-------------------------------------------------
ADDRESS_MAP_START(bbc_tube_zep100_device::tube_zep100_mem)
AM_RANGE(0x0000, 0xffff) AM_READWRITE(mem_r, mem_w)
ADDRESS_MAP_END
void bbc_tube_zep100_device::tube_zep100_mem(address_map &map)
{
map(0x0000, 0xffff).rw(this, FUNC(bbc_tube_zep100_device::mem_r), FUNC(bbc_tube_zep100_device::mem_w));
}
//-------------------------------------------------
// ADDRESS_MAP( tube_zep100_io )
//-------------------------------------------------
ADDRESS_MAP_START(bbc_tube_zep100_device::tube_zep100_io)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x00, 0x07) AM_MIRROR(0xff00) AM_READWRITE(io_r, io_w)
ADDRESS_MAP_END
void bbc_tube_zep100_device::tube_zep100_io(address_map &map)
{
map.unmap_value_high();
map(0x00, 0x07).mirror(0xff00).rw(this, FUNC(bbc_tube_zep100_device::io_r), FUNC(bbc_tube_zep100_device::io_w));
}
//-------------------------------------------------
// ROM( tube_zep100 )

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

@ -40,18 +40,20 @@ DEFINE_DEVICE_TYPE(C64_CPM, c64_cpm_cartridge_device, "c64_cpm", "C64 CP/M cartr
// ADDRESS_MAP( z80_mem )
//-------------------------------------------------
ADDRESS_MAP_START(c64_cpm_cartridge_device::z80_mem)
AM_RANGE(0x0000, 0xffff) AM_READWRITE(dma_r, dma_w)
ADDRESS_MAP_END
void c64_cpm_cartridge_device::z80_mem(address_map &map)
{
map(0x0000, 0xffff).rw(this, FUNC(c64_cpm_cartridge_device::dma_r), FUNC(c64_cpm_cartridge_device::dma_w));
}
//-------------------------------------------------
// ADDRESS_MAP( z80_io )
//-------------------------------------------------
ADDRESS_MAP_START(c64_cpm_cartridge_device::z80_io)
AM_RANGE(0x0000, 0xffff) AM_READWRITE(dma_r, dma_w)
ADDRESS_MAP_END
void c64_cpm_cartridge_device::z80_io(address_map &map)
{
map(0x0000, 0xffff).rw(this, FUNC(c64_cpm_cartridge_device::dma_r), FUNC(c64_cpm_cartridge_device::dma_w));
}
//-------------------------------------------------

9
src/devices/bus/c64/fcc.cpp
View File

@ -64,10 +64,11 @@ const tiny_rom_entry *c64_final_chesscard_device::device_rom_region() const
// ADDRESS_MAP( c64_fcc_map )
//-------------------------------------------------
ADDRESS_MAP_START(c64_final_chesscard_device::c64_fcc_map)
AM_RANGE(0x0000, 0x1fff) AM_MIRROR(0x6000) AM_READWRITE(nvram_r, nvram_w)
AM_RANGE(0x8000, 0xffff) AM_ROM AM_REGION(G65SC02P4_TAG, 0)
ADDRESS_MAP_END
void c64_final_chesscard_device::c64_fcc_map(address_map &map)
{
map(0x0000, 0x1fff).mirror(0x6000).rw(this, FUNC(c64_final_chesscard_device::nvram_r), FUNC(c64_final_chesscard_device::nvram_w));
map(0x8000, 0xffff).rom().region(G65SC02P4_TAG, 0);
}
//-------------------------------------------------

7
src/devices/bus/c64/multiscreen.cpp
View File

@ -102,9 +102,10 @@ const tiny_rom_entry *c64_multiscreen_cartridge_device::device_rom_region() cons
}
ADDRESS_MAP_START(c64_multiscreen_cartridge_device::multiscreen_mem)
AM_RANGE(0x0000, 0x1fff) AM_ROM AM_REGION(MC6802P_TAG, 0)
ADDRESS_MAP_END
void c64_multiscreen_cartridge_device::multiscreen_mem(address_map &map)
{
map(0x0000, 0x1fff).rom().region(MC6802P_TAG, 0);
}
//-------------------------------------------------

11
src/devices/bus/c64/supercpu.cpp
View File

@ -49,11 +49,12 @@ const tiny_rom_entry *c64_supercpu_device::device_rom_region() const
// ADDRESS_MAP( c64_supercpu_map )
//-------------------------------------------------
ADDRESS_MAP_START(c64_supercpu_device::c64_supercpu_map)
AM_RANGE(0x000000, 0x01ffff) AM_RAM AM_SHARE("sram")
AM_RANGE(0x020000, 0xf7ffff) AM_RAM AM_SHARE("dimm")
AM_RANGE(0xf80000, 0xf9ffff) AM_MIRROR(0x60000) AM_ROM AM_REGION(G65816_TAG, 0)
ADDRESS_MAP_END
void c64_supercpu_device::c64_supercpu_map(address_map &map)
{
map(0x000000, 0x01ffff).ram().share("sram");
map(0x020000, 0xf7ffff).ram().share("dimm");
map(0xf80000, 0xf9ffff).mirror(0x60000).rom().region(G65816_TAG, 0);
}
//-------------------------------------------------

18
src/devices/bus/cbm2/hrg.cpp
View File

@ -66,20 +66,22 @@ const tiny_rom_entry *cbm2_hrg_device::device_rom_region() const
// ADDRESS_MAP( hrg_a_map )
//-------------------------------------------------
ADDRESS_MAP_START(cbm2_hrg_a_device::hrg_a_map)
ADDRESS_MAP_GLOBAL_MASK(0x7fff)
AM_RANGE(0x0000, 0x7fff) AM_RAM
ADDRESS_MAP_END
void cbm2_hrg_a_device::hrg_a_map(address_map &map)
{
map.global_mask(0x7fff);
map(0x0000, 0x7fff).ram();
}
//-------------------------------------------------
// ADDRESS_MAP( hrg_b_map )
//-------------------------------------------------
ADDRESS_MAP_START(cbm2_hrg_b_device::hrg_b_map)
ADDRESS_MAP_GLOBAL_MASK(0x3fff)
AM_RANGE(0x0000, 0x3fff) AM_RAM
ADDRESS_MAP_END
void cbm2_hrg_b_device::hrg_b_map(address_map &map)
{
map.global_mask(0x3fff);
map(0x0000, 0x3fff).ram();
}
//-------------------------------------------------

20
src/devices/bus/cbmiec/c1541.cpp
View File

@ -500,12 +500,13 @@ WRITE8_MEMBER( c1541_prologic_dos_classic_device::write )
// ADDRESS_MAP( c1541_mem )
//-------------------------------------------------
ADDRESS_MAP_START(c1541_device_base::c1541_mem)
AM_RANGE(0x0000, 0x07ff) AM_MIRROR(0x6000) AM_RAM
AM_RANGE(0x1800, 0x180f) AM_MIRROR(0x63f0) AM_DEVREADWRITE(M6522_0_TAG, via6522_device, read, write)
AM_RANGE(0x1c00, 0x1c0f) AM_MIRROR(0x63f0) AM_DEVREADWRITE(M6522_1_TAG, via6522_device, read, write)
AM_RANGE(0x8000, 0xbfff) AM_MIRROR(0x4000) AM_ROM AM_REGION(M6502_TAG, 0)
ADDRESS_MAP_END
void c1541_device_base::c1541_mem(address_map &map)
{
map(0x0000, 0x07ff).mirror(0x6000).ram();
map(0x1800, 0x180f).mirror(0x63f0).rw(M6522_0_TAG, FUNC(via6522_device::read), FUNC(via6522_device::write));
map(0x1c00, 0x1c0f).mirror(0x63f0).rw(M6522_1_TAG, FUNC(via6522_device::read), FUNC(via6522_device::write));
map(0x8000, 0xbfff).mirror(0x4000).rom().region(M6502_TAG, 0);
}
//-------------------------------------------------
@ -539,8 +540,9 @@ ADDRESS_MAP_END
// ADDRESS_MAP( c1541pdc_mem )
//-------------------------------------------------
ADDRESS_MAP_START(c1541_prologic_dos_classic_device::c1541pdc_mem)
AM_RANGE(0x0000, 0xffff) AM_READWRITE(read, write)
void c1541_prologic_dos_classic_device::c1541pdc_mem(address_map &map)
{
map(0x0000, 0xffff).rw(this, FUNC(c1541_prologic_dos_classic_device::read), FUNC(c1541_prologic_dos_classic_device::write));
/* AM_RANGE(0x0000, 0x07ff) AM_MIRROR(0x6000) AM_RAM AM_SHARE("share1")
AM_RANGE(0x1800, 0x180f) AM_MIRROR(0x63f0) AM_DEVREADWRITE(M6522_0_TAG, via6522_device, read, write)
AM_RANGE(0x1c00, 0x1c0f) AM_MIRROR(0x63f0) AM_DEVREADWRITE(M6522_1_TAG, via6522_device, read, write)
@ -549,7 +551,7 @@ ADDRESS_MAP_START(c1541_prologic_dos_classic_device::c1541pdc_mem)
AM_RANGE(0xa000, 0xb7ff) AM_ROM AM_REGION(M6502_TAG, 0x0000)
AM_RANGE(0xb800, 0xb80f) AM_READWRITE(pia_r, pia_w)
AM_RANGE(0xf000, 0xffff) AM_ROM AM_REGION(M6502_TAG, 0x2000)*/
ADDRESS_MAP_END
}
WRITE_LINE_MEMBER( c1541_device_base::via0_irq_w )

38
src/devices/bus/cbmiec/c1571.cpp
View File

@ -144,30 +144,32 @@ const tiny_rom_entry *mini_chief_device::device_rom_region() const
// ADDRESS_MAP( c1571_mem )
//-------------------------------------------------
ADDRESS_MAP_START(c1571_device::c1571_mem)
AM_RANGE(0x0000, 0x07ff) AM_RAM
AM_RANGE(0x1800, 0x180f) AM_MIRROR(0x03f0) AM_DEVREADWRITE(M6522_0_TAG, via6522_device, read, write)
AM_RANGE(0x1c00, 0x1c0f) AM_MIRROR(0x03f0) AM_READWRITE(via1_r, via1_w)
AM_RANGE(0x2000, 0x2003) AM_MIRROR(0x1ffc) AM_DEVREADWRITE(WD1770_TAG, wd1770_device, read, write)
AM_RANGE(0x4000, 0x400f) AM_MIRROR(0x3ff0) AM_DEVREADWRITE(M6526_TAG, mos6526_device, read, write)
AM_RANGE(0x8000, 0xffff) AM_ROM AM_REGION(M6502_TAG, 0)
ADDRESS_MAP_END
void c1571_device::c1571_mem(address_map &map)
{
map(0x0000, 0x07ff).ram();
map(0x1800, 0x180f).mirror(0x03f0).rw(M6522_0_TAG, FUNC(via6522_device::read), FUNC(via6522_device::write));
map(0x1c00, 0x1c0f).mirror(0x03f0).rw(this, FUNC(c1571_device::via1_r), FUNC(c1571_device::via1_w));
map(0x2000, 0x2003).mirror(0x1ffc).rw(WD1770_TAG, FUNC(wd1770_device::read), FUNC(wd1770_device::write));
map(0x4000, 0x400f).mirror(0x3ff0).rw(M6526_TAG, FUNC(mos6526_device::read), FUNC(mos6526_device::write));
map(0x8000, 0xffff).rom().region(M6502_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( mini_chief_mem )
//-------------------------------------------------
ADDRESS_MAP_START(mini_chief_device::mini_chief_mem)
AM_RANGE(0x0000, 0x07ff) AM_RAM
AM_RANGE(0x1800, 0x180f) AM_MIRROR(0x03f0) AM_DEVREADWRITE(M6522_0_TAG, via6522_device, read, write)
AM_RANGE(0x1c00, 0x1c0f) AM_MIRROR(0x03f0) AM_READWRITE(via1_r, via1_w)
AM_RANGE(0x2000, 0x2003) AM_MIRROR(0x1ffc) AM_DEVREADWRITE(WD1770_TAG, wd1770_device, read, write)
AM_RANGE(0x4000, 0x400f) AM_MIRROR(0xff0) AM_DEVREADWRITE(M6526_TAG, mos6526_device, read, write)
AM_RANGE(0x5000, 0x5fff) AM_MIRROR(0x2000) AM_RAM
AM_RANGE(0x6000, 0x6fff) AM_RAM
AM_RANGE(0x8000, 0xffff) AM_ROM AM_REGION(M6502_TAG, 0)
ADDRESS_MAP_END
void mini_chief_device::mini_chief_mem(address_map &map)
{
map(0x0000, 0x07ff).ram();
map(0x1800, 0x180f).mirror(0x03f0).rw(M6522_0_TAG, FUNC(via6522_device::read), FUNC(via6522_device::write));
map(0x1c00, 0x1c0f).mirror(0x03f0).rw(this, FUNC(mini_chief_device::via1_r), FUNC(mini_chief_device::via1_w));
map(0x2000, 0x2003).mirror(0x1ffc).rw(WD1770_TAG, FUNC(wd1770_device::read), FUNC(wd1770_device::write));
map(0x4000, 0x400f).mirror(0xff0).rw(M6526_TAG, FUNC(mos6526_device::read), FUNC(mos6526_device::write));
map(0x5000, 0x5fff).mirror(0x2000).ram();
map(0x6000, 0x6fff).ram();
map(0x8000, 0xffff).rom().region(M6502_TAG, 0);
}
WRITE_LINE_MEMBER( c1571_device::via0_irq_w )

13
src/devices/bus/cbmiec/c1581.cpp
View File

@ -89,12 +89,13 @@ const tiny_rom_entry *c1563_device::device_rom_region() const
// ADDRESS_MAP( c1581_mem )
//-------------------------------------------------
ADDRESS_MAP_START(c1581_device::c1581_mem)
AM_RANGE(0x0000, 0x1fff) AM_MIRROR(0x2000) AM_RAM
AM_RANGE(0x4000, 0x400f) AM_MIRROR(0x1ff0) AM_DEVREADWRITE(M8520_TAG, mos8520_device, read, write)
AM_RANGE(0x6000, 0x6003) AM_MIRROR(0x1ffc) AM_DEVREADWRITE(WD1772_TAG, wd1772_device, read, write)
AM_RANGE(0x8000, 0xffff) AM_ROM AM_REGION(M6502_TAG, 0)
ADDRESS_MAP_END
void c1581_device::c1581_mem(address_map &map)
{
map(0x0000, 0x1fff).mirror(0x2000).ram();
map(0x4000, 0x400f).mirror(0x1ff0).rw(M8520_TAG, FUNC(mos8520_device::read), FUNC(mos8520_device::write));
map(0x6000, 0x6003).mirror(0x1ffc).rw(WD1772_TAG, FUNC(wd1772_device::read), FUNC(wd1772_device::write));
map(0x8000, 0xffff).rom().region(M6502_TAG, 0);
}
//-------------------------------------------------

19
src/devices/bus/cbmiec/cmdhd.cpp
View File

@ -61,15 +61,16 @@ const tiny_rom_entry *cmd_hd_device::device_rom_region() const
// ADDRESS_MAP( cmd_hd_mem )
//-------------------------------------------------
ADDRESS_MAP_START(cmd_hd_device::cmd_hd_mem)
AM_RANGE(0x0000, 0x7fff) AM_RAM
AM_RANGE(0x8000, 0xffff) AM_ROM AM_REGION(M6502_TAG, 0)
AM_RANGE(0x8000, 0x800f) AM_MIRROR(0x1f0) AM_DEVWRITE(M6522_1_TAG, via6522_device, write)
AM_RANGE(0x8400, 0x840f) AM_MIRROR(0x1f0) AM_DEVWRITE(M6522_2_TAG, via6522_device, write)
AM_RANGE(0x8800, 0x8803) AM_MIRROR(0x1fc) AM_DEVWRITE(I8255A_TAG, i8255_device, write)
AM_RANGE(0x8c00, 0x8c0f) AM_MIRROR(0x1f0) AM_DEVWRITE(RTC72421A_TAG, rtc72421_device, write)
AM_RANGE(0x8f00, 0x8f00) AM_MIRROR(0xff) AM_WRITE(led_w)
ADDRESS_MAP_END
void cmd_hd_device::cmd_hd_mem(address_map &map)
{
map(0x0000, 0x7fff).ram();
map(0x8000, 0xffff).rom().region(M6502_TAG, 0);
map(0x8000, 0x800f).mirror(0x1f0).w(M6522_1_TAG, FUNC(via6522_device::write));
map(0x8400, 0x840f).mirror(0x1f0).w(M6522_2_TAG, FUNC(via6522_device::write));
map(0x8800, 0x8803).mirror(0x1fc).w(I8255A_TAG, FUNC(i8255_device::write));
map(0x8c00, 0x8c0f).mirror(0x1f0).w(RTC72421A_TAG, FUNC(rtc72421_device::write));
map(0x8f00, 0x8f00).mirror(0xff).w(this, FUNC(cmd_hd_device::led_w));
}
//-------------------------------------------------

30
src/devices/bus/cbmiec/fd2000.cpp
View File

@ -89,26 +89,28 @@ const tiny_rom_entry *fd4000_device::device_rom_region() const
// ADDRESS_MAP( fd2000_mem )
//-------------------------------------------------
ADDRESS_MAP_START(fd2000_device::fd2000_mem)
AM_RANGE(0x0000, 0x3fff) AM_RAM
AM_RANGE(0x4000, 0x400f) AM_MIRROR(0xbf0) AM_DEVREADWRITE(G65SC22P2_TAG, via6522_device, read, write)
AM_RANGE(0x4e00, 0x4e07) AM_MIRROR(0x1f8) AM_DEVICE(DP8473V_TAG, dp8473_device, map)
AM_RANGE(0x5000, 0x7fff) AM_RAM
AM_RANGE(0x8000, 0xffff) AM_ROM AM_REGION(G65SC02PI2_TAG, 0)
ADDRESS_MAP_END
void fd2000_device::fd2000_mem(address_map &map)
{
map(0x0000, 0x3fff).ram();
map(0x4000, 0x400f).mirror(0xbf0).rw(G65SC22P2_TAG, FUNC(via6522_device::read), FUNC(via6522_device::write));
map(0x4e00, 0x4e07).mirror(0x1f8).m(DP8473V_TAG, FUNC(dp8473_device::map));
map(0x5000, 0x7fff).ram();
map(0x8000, 0xffff).rom().region(G65SC02PI2_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( fd4000_mem )
//-------------------------------------------------
ADDRESS_MAP_START(fd4000_device::fd4000_mem)
AM_RANGE(0x0000, 0x3fff) AM_RAM
AM_RANGE(0x4000, 0x400f) AM_MIRROR(0xbf0) AM_DEVREADWRITE(G65SC22P2_TAG, via6522_device, read, write)
AM_RANGE(0x4e00, 0x4e07) AM_MIRROR(0x1f8) AM_DEVICE(PC8477AV1_TAG, pc8477a_device, map)
AM_RANGE(0x5000, 0x7fff) AM_RAM
AM_RANGE(0x8000, 0xffff) AM_ROM AM_REGION(R65C02P4_TAG, 0)
ADDRESS_MAP_END
void fd4000_device::fd4000_mem(address_map &map)
{
map(0x0000, 0x3fff).ram();
map(0x4000, 0x400f).mirror(0xbf0).rw(G65SC22P2_TAG, FUNC(via6522_device::read), FUNC(via6522_device::write));
map(0x4e00, 0x4e07).mirror(0x1f8).m(PC8477AV1_TAG, FUNC(pc8477a_device::map));
map(0x5000, 0x7fff).ram();
map(0x8000, 0xffff).rom().region(R65C02P4_TAG, 0);
}
READ8_MEMBER( fd2000_device::via_pa_r )

15
src/devices/bus/cbmiec/interpod.cpp
View File

@ -109,13 +109,14 @@ const tiny_rom_entry *interpod_device::device_rom_region() const
// ADDRESS_MAP( interpod_mem )
//-------------------------------------------------
ADDRESS_MAP_START(interpod_device::interpod_mem)
AM_RANGE(0x0000, 0x007f) AM_MIRROR(0x3b80) AM_DEVICE(R6532_TAG, mos6532_new_device, ram_map)
AM_RANGE(0x0400, 0x041f) AM_MIRROR(0x3be0) AM_DEVICE(R6532_TAG, mos6532_new_device, io_map)
AM_RANGE(0x2000, 0x2001) AM_MIRROR(0x9ffe) AM_DEVREADWRITE(MC6850_TAG, acia6850_device, read, write)
AM_RANGE(0x4000, 0x47ff) AM_MIRROR(0xb800) AM_ROM AM_REGION(R6502_TAG, 0)
AM_RANGE(0x8000, 0x800f) AM_MIRROR(0x5ff0) AM_DEVREADWRITE(R6522_TAG, via6522_device, read, write)
ADDRESS_MAP_END
void interpod_device::interpod_mem(address_map &map)
{
map(0x0000, 0x007f).mirror(0x3b80).m(R6532_TAG, FUNC(mos6532_new_device::ram_map));
map(0x0400, 0x041f).mirror(0x3be0).m(R6532_TAG, FUNC(mos6532_new_device::io_map));
map(0x2000, 0x2001).mirror(0x9ffe).rw(MC6850_TAG, FUNC(acia6850_device::read), FUNC(acia6850_device::write));
map(0x4000, 0x47ff).mirror(0xb800).rom().region(R6502_TAG, 0);
map(0x8000, 0x800f).mirror(0x5ff0).rw(R6522_TAG, FUNC(via6522_device::read), FUNC(via6522_device::write));
}
//-------------------------------------------------

7
src/devices/bus/cbmiec/serialbox.cpp
View File

@ -59,9 +59,10 @@ const tiny_rom_entry *serial_box_device::device_rom_region() const
// ADDRESS_MAP( serial_box_mem )
//-------------------------------------------------
ADDRESS_MAP_START(serial_box_device::serial_box_mem)
AM_RANGE(0xf000, 0xffff) AM_ROM AM_REGION(M6502_TAG, 0)
ADDRESS_MAP_END
void serial_box_device::serial_box_mem(address_map &map)
{
map(0xf000, 0xffff).rom().region(M6502_TAG, 0);
}
//-------------------------------------------------

12
src/devices/bus/cbmiec/vic1515.cpp
View File

@ -42,17 +42,19 @@ const tiny_rom_entry *vic1515_device::device_rom_region() const
// ADDRESS_MAP( vic1515_mem )
//-------------------------------------------------
ADDRESS_MAP_START(vic1515_device::vic1515_mem)
AM_RANGE(0x0000, 0x0fff) AM_ROM AM_REGION("rom", 0)
ADDRESS_MAP_END
void vic1515_device::vic1515_mem(address_map &map)
{
map(0x0000, 0x0fff).rom().region("rom", 0);
}
//-------------------------------------------------
// ADDRESS_MAP( vic1515_io )
//-------------------------------------------------
ADDRESS_MAP_START(vic1515_device::vic1515_io)
ADDRESS_MAP_END
void vic1515_device::vic1515_io(address_map &map)
{
}
//-------------------------------------------------

11
src/devices/bus/cbmiec/vic1520.cpp
View File

@ -82,11 +82,12 @@ const tiny_rom_entry *vic1520_device::device_rom_region() const
// ADDRESS_MAP( vic1520_mem )
//-------------------------------------------------
ADDRESS_MAP_START(vic1520_device::vic1520_mem)
ADDRESS_MAP_GLOBAL_MASK(0xfff)
AM_RANGE(0x000, 0x03f) AM_RAM
AM_RANGE(0x800, 0xfff) AM_ROM AM_REGION(M6500_1_TAG, 0)
ADDRESS_MAP_END
void vic1520_device::vic1520_mem(address_map &map)
{
map.global_mask(0xfff);
map(0x000, 0x03f).ram();
map(0x800, 0xfff).rom().region(M6500_1_TAG, 0);
}
//-------------------------------------------------

15
src/devices/bus/centronics/comxpl80.cpp
View File

@ -62,7 +62,8 @@ const tiny_rom_entry *comx_pl80_device::device_rom_region() const
// ADDRESS_MAP( comxpl80_mem )
//-------------------------------------------------
ADDRESS_MAP_START(comx_pl80_device::comxpl80_mem)
void comx_pl80_device::comxpl80_mem(address_map &map)
{
/* AM_RANGE(0x000, 0x000) AM_READWRITE(cx005_port_a_r, cx005_port_a_w)
AM_RANGE(0x001, 0x001) AM_READWRITE(cx005_port_b_r, cx005_port_b_w)
AM_RANGE(0x002, 0x002) AM_READWRITE(cx005_port_c_r, cx005_port_c_w)
@ -73,12 +74,12 @@ ADDRESS_MAP_START(comx_pl80_device::comxpl80_mem)
AM_RANGE(0x007, 0x007) AM_READ(cx005_port_d_analog_r)
AM_RANGE(0x008, 0x008) AM_READWRITE(cx005_timer_data_r, cx005_timer_data_w)
AM_RANGE(0x008, 0x008) AM_READWRITE(cx005_timer_ctrl_r, cx005_timer_ctrl_w)*/
AM_RANGE(0x00a, 0x01f) AM_NOP // Not Used
AM_RANGE(0x020, 0x07f) AM_RAM // Internal RAM
AM_RANGE(0x080, 0xf7f) AM_ROM AM_REGION(CX005_TAG, 0) // Internal ROM
AM_RANGE(0xf80, 0xff7) AM_ROM AM_REGION(CX005_TAG, 0xf00) // Self-Test
AM_RANGE(0xff8, 0xfff) AM_ROM AM_REGION(CX005_TAG, 0xf78) // Interrupt Vectors
ADDRESS_MAP_END
map(0x00a, 0x01f).noprw(); // Not Used
map(0x020, 0x07f).ram(); // Internal RAM
map(0x080, 0xf7f).rom().region(CX005_TAG, 0); // Internal ROM
map(0xf80, 0xff7).rom().region(CX005_TAG, 0xf00); // Self-Test
map(0xff8, 0xfff).rom().region(CX005_TAG, 0xf78); // Interrupt Vectors
}
//-------------------------------------------------

21
src/devices/bus/centronics/epson_ex800.cpp
View File

@ -198,16 +198,17 @@ const tiny_rom_entry *epson_ex800_device::device_rom_region() const
// ADDRESS_MAP( ex800_mem )
//-------------------------------------------------
ADDRESS_MAP_START(epson_ex800_device::ex800_mem)
AM_RANGE(0x0000, 0x7fff) AM_ROM AM_REGION("maincpu", 0)
AM_RANGE(0x8000, 0xbfff) AM_RAM /* external RAM */
AM_RANGE(0xc000, 0xc7ff) AM_MIRROR(0x1800) AM_READWRITE(devsel_r, devsel_w)
AM_RANGE(0xe000, 0xe7ff) AM_READWRITE(gate5a_r, gate5a_w)
AM_RANGE(0xe800, 0xefff) AM_READWRITE(iosel_r, iosel_w)
AM_RANGE(0xf000, 0xf001) AM_MIRROR(0x07fc) AM_READ(gate7a_r)
AM_RANGE(0xf002, 0xf003) AM_MIRROR(0x07fc) AM_WRITE(gate7a_w)
AM_RANGE(0xf800, 0xfeff) AM_NOP /* not connected */
ADDRESS_MAP_END
void epson_ex800_device::ex800_mem(address_map &map)
{
map(0x0000, 0x7fff).rom().region("maincpu", 0);
map(0x8000, 0xbfff).ram(); /* external RAM */
map(0xc000, 0xc7ff).mirror(0x1800).rw(this, FUNC(epson_ex800_device::devsel_r), FUNC(epson_ex800_device::devsel_w));
map(0xe000, 0xe7ff).rw(this, FUNC(epson_ex800_device::gate5a_r), FUNC(epson_ex800_device::gate5a_w));
map(0xe800, 0xefff).rw(this, FUNC(epson_ex800_device::iosel_r), FUNC(epson_ex800_device::iosel_w));
map(0xf000, 0xf001).mirror(0x07fc).r(this, FUNC(epson_ex800_device::gate7a_r));
map(0xf002, 0xf003).mirror(0x07fc).w(this, FUNC(epson_ex800_device::gate7a_w));
map(0xf800, 0xfeff).noprw(); /* not connected */
}
//-------------------------------------------------

15
src/devices/bus/centronics/epson_lx800.cpp
View File

@ -52,13 +52,14 @@ const tiny_rom_entry *epson_lx800_device::device_rom_region() const
// ADDRESS_MAP( lx800_mem )
//-------------------------------------------------
ADDRESS_MAP_START(epson_lx800_device::lx800_mem)
AM_RANGE(0x0000, 0x7fff) AM_ROM /* 32k firmware */
AM_RANGE(0x8000, 0x9fff) AM_RAM /* 8k external RAM */
AM_RANGE(0xa000, 0xbfff) AM_NOP /* not used */
AM_RANGE(0xc000, 0xc007) AM_MIRROR(0x1ff8) AM_DEVREADWRITE("ic3b", e05a03_device, read, write)
AM_RANGE(0xe000, 0xfeff) AM_NOP /* not used */
ADDRESS_MAP_END
void epson_lx800_device::lx800_mem(address_map &map)
{
map(0x0000, 0x7fff).rom(); /* 32k firmware */
map(0x8000, 0x9fff).ram(); /* 8k external RAM */
map(0xa000, 0xbfff).noprw(); /* not used */
map(0xc000, 0xc007).mirror(0x1ff8).rw("ic3b", FUNC(e05a03_device::read), FUNC(e05a03_device::write));
map(0xe000, 0xfeff).noprw(); /* not used */
}
//-------------------------------------------------

15
src/devices/bus/centronics/epson_lx810l.cpp
View File

@ -95,13 +95,14 @@ const tiny_rom_entry *epson_ap2000_device::device_rom_region() const
// ADDRESS_MAP( lx810l_mem )
//-------------------------------------------------
ADDRESS_MAP_START(epson_lx810l_device::lx810l_mem)
AM_RANGE(0x0000, 0x7fff) AM_ROM /* 32k firmware */
AM_RANGE(0x8000, 0x9fff) AM_RAM /* 8k external RAM */
AM_RANGE(0xa000, 0xbfff) AM_READWRITE(fakemem_r, fakemem_w) /* fake memory, write one, set all */
AM_RANGE(0xc000, 0xc00f) AM_MIRROR(0x1ff0) AM_DEVREADWRITE("e05a30", e05a30_device, read, write)
AM_RANGE(0xe000, 0xfeff) AM_NOP /* not used */
ADDRESS_MAP_END
void epson_lx810l_device::lx810l_mem(address_map &map)
{
map(0x0000, 0x7fff).rom(); /* 32k firmware */
map(0x8000, 0x9fff).ram(); /* 8k external RAM */
map(0xa000, 0xbfff).rw(this, FUNC(epson_lx810l_device::fakemem_r), FUNC(epson_lx810l_device::fakemem_w)); /* fake memory, write one, set all */
map(0xc000, 0xc00f).mirror(0x1ff0).rw("e05a30", FUNC(e05a30_device::read), FUNC(e05a30_device::write));
map(0xe000, 0xfeff).noprw(); /* not used */
}
//-------------------------------------------------

7
src/devices/bus/centronics/nec_p72.cpp
View File

@ -36,12 +36,13 @@ const tiny_rom_entry *nec_p72_device::device_rom_region() const
// ADDRESS_MAP( p72_mem )
//-------------------------------------------------
ADDRESS_MAP_START(nec_p72_device::p72_mem)
AM_RANGE(0x000000, 0x0fffff) AM_ROM /* 1Mbyte firmware */
void nec_p72_device::p72_mem(address_map &map)
{
map(0x000000, 0x0fffff).rom(); /* 1Mbyte firmware */
//AM_RANGE(0x100000, 0x1fffff) AM_RAM /* 1Mbyte external RAM */ /* TODO might be 2x1Mbit */
// [RH] 29 August 2016: Commented out because the NEC V33 only has 20 address lines, and
// the V40 has more, but we don't have an NEC V40 implemented yet.
ADDRESS_MAP_END
}
//-------------------------------------------------

18
src/devices/bus/compis/hrg.cpp
View File

@ -32,15 +32,17 @@ DEFINE_DEVICE_TYPE(COMPIS_UHRG, compis_uhrg_device, "compis_uhrg", "Compis UHRG"
// ADDRESS_MAP( upd7220_map )
//-------------------------------------------------
ADDRESS_MAP_START(compis_hrg_device::hrg_map)
ADDRESS_MAP_GLOBAL_MASK(0x7fff)
AM_RANGE(0x00000, 0x7fff) AM_RAM AM_SHARE("video_ram")
ADDRESS_MAP_END
void compis_hrg_device::hrg_map(address_map &map)
{
map.global_mask(0x7fff);
map(0x00000, 0x7fff).ram().share("video_ram");
}
ADDRESS_MAP_START(compis_uhrg_device::uhrg_map)
ADDRESS_MAP_GLOBAL_MASK(0x1ffff)
AM_RANGE(0x00000, 0x1ffff) AM_RAM AM_SHARE("video_ram")
ADDRESS_MAP_END
void compis_uhrg_device::uhrg_map(address_map &map)
{
map.global_mask(0x1ffff);
map(0x00000, 0x1ffff).ram().share("video_ram");
}
//-------------------------------------------------

22
src/devices/bus/dmv/k230.cpp
View File

@ -32,17 +32,19 @@ ROM_START( dmv_k235 )
ROM_LOAD( "dmv_int_8088_pic_33473.bin", 0x0000, 0x1000, CRC(104195dc) SHA1(08d48ca3b84ab26c1a764792e04ec4def7dad2ad))
ROM_END
ADDRESS_MAP_START(dmv_k230_device::k230_mem)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE( 0x00000, 0x7ffff ) AM_READWRITE(program_r, program_w)
AM_RANGE( 0x80000, 0xfffff ) AM_READ(rom_r)
ADDRESS_MAP_END
void dmv_k230_device::k230_mem(address_map &map)
{
map.unmap_value_high();
map(0x00000, 0x7ffff).rw(this, FUNC(dmv_k230_device::program_r), FUNC(dmv_k230_device::program_w));
map(0x80000, 0xfffff).r(this, FUNC(dmv_k230_device::rom_r));
}
ADDRESS_MAP_START(dmv_k230_device::k230_io)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE( 0x00, 0xff ) AM_READWRITE(io_r, io_w)
ADDRESS_MAP_END
void dmv_k230_device::k230_io(address_map &map)
{
map.unmap_value_high();
map.global_mask(0xff);
map(0x00, 0xff).rw(this, FUNC(dmv_k230_device::io_r), FUNC(dmv_k230_device::io_w));
}
ADDRESS_MAP_START(dmv_k230_device::k234_mem)
ADDRESS_MAP_UNMAP_HIGH

44
src/devices/bus/ecbbus/grip.cpp
View File

@ -124,36 +124,38 @@ const tiny_rom_entry *ecb_grip21_device::device_rom_region() const
// ADDRESS_MAP( grip_mem )
//-------------------------------------------------
ADDRESS_MAP_START(ecb_grip21_device::grip_mem)
AM_RANGE(0x0000, 0x3fff) AM_ROM
AM_RANGE(0x4000, 0x47ff) AM_RAM
AM_RANGE(0x8000, 0xffff) AM_RAMBANK("videoram")
ADDRESS_MAP_END
void ecb_grip21_device::grip_mem(address_map &map)
{
map(0x0000, 0x3fff).rom();
map(0x4000, 0x47ff).ram();
map(0x8000, 0xffff).bankrw("videoram");
}
//-------------------------------------------------
// ADDRESS_MAP( grip_io )
//-------------------------------------------------
ADDRESS_MAP_START(ecb_grip21_device::grip_io)
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE(0x00, 0x00) AM_READWRITE(cxstb_r, cxstb_w)
void ecb_grip21_device::grip_io(address_map &map)
{
map.global_mask(0xff);
map(0x00, 0x00).rw(this, FUNC(ecb_grip21_device::cxstb_r), FUNC(ecb_grip21_device::cxstb_w));
// AM_RANGE(0x10, 0x10) AM_WRITE(ccon_w)
AM_RANGE(0x11, 0x11) AM_WRITE(vol0_w)
map(0x11, 0x11).w(this, FUNC(ecb_grip21_device::vol0_w));
// AM_RANGE(0x12, 0x12) AM_WRITE(rts_w)
AM_RANGE(0x13, 0x13) AM_WRITE(page_w)
map(0x13, 0x13).w(this, FUNC(ecb_grip21_device::page_w));
// AM_RANGE(0x14, 0x14) AM_WRITE(cc1_w)
// AM_RANGE(0x15, 0x15) AM_WRITE(cc2_w)
AM_RANGE(0x16, 0x16) AM_WRITE(flash_w)
AM_RANGE(0x17, 0x17) AM_WRITE(vol1_w)
AM_RANGE(0x20, 0x2f) AM_DEVREADWRITE(Z80STI_TAG, z80sti_device, read, write)
AM_RANGE(0x30, 0x30) AM_READWRITE(lrs_r, lrs_w)
AM_RANGE(0x40, 0x40) AM_READ(stat_r)
AM_RANGE(0x50, 0x50) AM_DEVWRITE(MC6845_TAG, mc6845_device, address_w)
AM_RANGE(0x52, 0x52) AM_DEVWRITE(MC6845_TAG, mc6845_device, register_w)
AM_RANGE(0x53, 0x53) AM_DEVREAD(MC6845_TAG, mc6845_device, register_r)
AM_RANGE(0x60, 0x60) AM_DEVWRITE("cent_data_out", output_latch_device, write)
AM_RANGE(0x70, 0x73) AM_DEVREADWRITE(I8255A_TAG, i8255_device, read, write)
map(0x16, 0x16).w(this, FUNC(ecb_grip21_device::flash_w));
map(0x17, 0x17).w(this, FUNC(ecb_grip21_device::vol1_w));
map(0x20, 0x2f).rw(Z80STI_TAG, FUNC(z80sti_device::read), FUNC(z80sti_device::write));
map(0x30, 0x30).rw(this, FUNC(ecb_grip21_device::lrs_r), FUNC(ecb_grip21_device::lrs_w));
map(0x40, 0x40).r(this, FUNC(ecb_grip21_device::stat_r));
map(0x50, 0x50).w(MC6845_TAG, FUNC(mc6845_device::address_w));
map(0x52, 0x52).w(MC6845_TAG, FUNC(mc6845_device::register_w));
map(0x53, 0x53).r(MC6845_TAG, FUNC(mc6845_device::register_r));
map(0x60, 0x60).w("cent_data_out", FUNC(output_latch_device::write));
map(0x70, 0x73).rw(I8255A_TAG, FUNC(i8255_device::read), FUNC(i8255_device::write));
// AM_RANGE(0x80, 0x80) AM_WRITE(bl2out_w)
// AM_RANGE(0x90, 0x90) AM_WRITE(gr2out_w)
// AM_RANGE(0xa0, 0xa0) AM_WRITE(rd2out_w)
@ -162,7 +164,7 @@ ADDRESS_MAP_START(ecb_grip21_device::grip_io)
// AM_RANGE(0xd0, 0xd0) AM_WRITE(grnout_w)
// AM_RANGE(0xe0, 0xe0) AM_WRITE(redout_w)
// AM_RANGE(0xf0, 0xf0) AM_WRITE(clrg1_w)
ADDRESS_MAP_END
}
//**************************************************************************

33
src/devices/bus/econet/e01.cpp
View File

@ -219,22 +219,23 @@ WRITE_LINE_MEMBER( econet_e01_device::scsi_req_w )
// ADDRESS_MAP( e01_mem )
//-------------------------------------------------
ADDRESS_MAP_START(econet_e01_device::e01_mem)
AM_RANGE(0x0000, 0xffff) AM_READWRITE(read, write)
AM_RANGE(0xfc00, 0xfc00) AM_MIRROR(0x00c3) AM_READWRITE(rtc_address_r, rtc_address_w)
AM_RANGE(0xfc04, 0xfc04) AM_MIRROR(0x00c3) AM_READWRITE(rtc_data_r, rtc_data_w)
AM_RANGE(0xfc08, 0xfc08) AM_MIRROR(0x00c0) AM_READ(ram_select_r) AM_WRITE(floppy_w)
AM_RANGE(0xfc0c, 0xfc0f) AM_MIRROR(0x00c0) AM_DEVREADWRITE(WD2793_TAG, wd2793_device, read, write)
AM_RANGE(0xfc10, 0xfc1f) AM_MIRROR(0x00c0) AM_DEVREADWRITE(R6522_TAG, via6522_device, read, write)
AM_RANGE(0xfc20, 0xfc23) AM_MIRROR(0x00c0) AM_DEVREADWRITE(MC6854_TAG, mc6854_device, read, write)
AM_RANGE(0xfc24, 0xfc24) AM_MIRROR(0x00c3) AM_READWRITE(network_irq_disable_r, network_irq_disable_w)
AM_RANGE(0xfc28, 0xfc28) AM_MIRROR(0x00c3) AM_READWRITE(network_irq_enable_r, network_irq_enable_w)
AM_RANGE(0xfc2c, 0xfc2c) AM_MIRROR(0x00c3) AM_READ_PORT("FLAP")
AM_RANGE(0xfc30, 0xfc30) AM_MIRROR(0x00c0) AM_READWRITE(hdc_data_r, hdc_data_w)
AM_RANGE(0xfc31, 0xfc31) AM_MIRROR(0x00c0) AM_DEVREAD("scsi_ctrl_in", input_buffer_device, read)
AM_RANGE(0xfc32, 0xfc32) AM_MIRROR(0x00c0) AM_WRITE(hdc_select_w)
AM_RANGE(0xfc33, 0xfc33) AM_MIRROR(0x00c0) AM_WRITE(hdc_irq_enable_w)
ADDRESS_MAP_END
void econet_e01_device::e01_mem(address_map &map)
{
map(0x0000, 0xffff).rw(this, FUNC(econet_e01_device::read), FUNC(econet_e01_device::write));
map(0xfc00, 0xfc00).mirror(0x00c3).rw(this, FUNC(econet_e01_device::rtc_address_r), FUNC(econet_e01_device::rtc_address_w));
map(0xfc04, 0xfc04).mirror(0x00c3).rw(this, FUNC(econet_e01_device::rtc_data_r), FUNC(econet_e01_device::rtc_data_w));
map(0xfc08, 0xfc08).mirror(0x00c0).r(this, FUNC(econet_e01_device::ram_select_r)).w(this, FUNC(econet_e01_device::floppy_w));
map(0xfc0c, 0xfc0f).mirror(0x00c0).rw(WD2793_TAG, FUNC(wd2793_device::read), FUNC(wd2793_device::write));
map(0xfc10, 0xfc1f).mirror(0x00c0).rw(R6522_TAG, FUNC(via6522_device::read), FUNC(via6522_device::write));
map(0xfc20, 0xfc23).mirror(0x00c0).rw(MC6854_TAG, FUNC(mc6854_device::read), FUNC(mc6854_device::write));
map(0xfc24, 0xfc24).mirror(0x00c3).rw(this, FUNC(econet_e01_device::network_irq_disable_r), FUNC(econet_e01_device::network_irq_disable_w));
map(0xfc28, 0xfc28).mirror(0x00c3).rw(this, FUNC(econet_e01_device::network_irq_enable_r), FUNC(econet_e01_device::network_irq_enable_w));
map(0xfc2c, 0xfc2c).mirror(0x00c3).portr("FLAP");
map(0xfc30, 0xfc30).mirror(0x00c0).rw(this, FUNC(econet_e01_device::hdc_data_r), FUNC(econet_e01_device::hdc_data_w));
map(0xfc31, 0xfc31).mirror(0x00c0).r("scsi_ctrl_in", FUNC(input_buffer_device::read));
map(0xfc32, 0xfc32).mirror(0x00c0).w(this, FUNC(econet_e01_device::hdc_select_w));
map(0xfc33, 0xfc33).mirror(0x00c0).w(this, FUNC(econet_e01_device::hdc_irq_enable_w));
}
//-------------------------------------------------

26
src/devices/bus/epson_sio/pf10.cpp
View File

@ -25,19 +25,21 @@ DEFINE_DEVICE_TYPE(EPSON_PF10, epson_pf10_device, "epson_pf10", "EPSON PF-10 Por
// address maps
//-------------------------------------------------
ADDRESS_MAP_START(epson_pf10_device::cpu_mem)
AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE("maincpu", hd6303y_cpu_device, m6801_io_r, m6801_io_w)
AM_RANGE(0x0040, 0x00ff) AM_RAM /* 192 bytes internal ram */
AM_RANGE(0x0800, 0x0fff) AM_RAM /* external 2k ram */
AM_RANGE(0x1000, 0x17ff) AM_READWRITE(fdc_r, fdc_w)
AM_RANGE(0x1800, 0x1fff) AM_WRITE(fdc_tc_w)
AM_RANGE(0xe000, 0xffff) AM_ROM AM_REGION("maincpu", 0)
ADDRESS_MAP_END
void epson_pf10_device::cpu_mem(address_map &map)
{
map(0x0000, 0x001f).rw("maincpu", FUNC(hd6303y_cpu_device::m6801_io_r), FUNC(hd6303y_cpu_device::m6801_io_w));
map(0x0040, 0x00ff).ram(); /* 192 bytes internal ram */
map(0x0800, 0x0fff).ram(); /* external 2k ram */
map(0x1000, 0x17ff).rw(this, FUNC(epson_pf10_device::fdc_r), FUNC(epson_pf10_device::fdc_w));
map(0x1800, 0x1fff).w(this, FUNC(epson_pf10_device::fdc_tc_w));
map(0xe000, 0xffff).rom().region("maincpu", 0);
}
ADDRESS_MAP_START(epson_pf10_device::cpu_io)
AM_RANGE(M6801_PORT1, M6801_PORT1) AM_READWRITE(port1_r, port1_w)
AM_RANGE(M6801_PORT2, M6801_PORT2) AM_READWRITE(port2_r, port2_w)
ADDRESS_MAP_END
void epson_pf10_device::cpu_io(address_map &map)
{
map(M6801_PORT1, M6801_PORT1).rw(this, FUNC(epson_pf10_device::port1_r), FUNC(epson_pf10_device::port1_w));
map(M6801_PORT2, M6801_PORT2).rw(this, FUNC(epson_pf10_device::port2_r), FUNC(epson_pf10_device::port2_w));
}
//-------------------------------------------------

28
src/devices/bus/epson_sio/tf20.cpp
View File

@ -29,20 +29,22 @@ DEFINE_DEVICE_TYPE(EPSON_TF20, epson_tf20_device, "epson_tf20", "EPSON TF-20 Dua
// address maps
//-------------------------------------------------
ADDRESS_MAP_START(epson_tf20_device::cpu_mem)
AM_RANGE(0x0000, 0x7fff) AM_RAMBANK("bank1")
AM_RANGE(0x8000, 0xffff) AM_RAMBANK("bank2")
ADDRESS_MAP_END
void epson_tf20_device::cpu_mem(address_map &map)
{
map(0x0000, 0x7fff).bankrw("bank1");
map(0x8000, 0xffff).bankrw("bank2");
}
ADDRESS_MAP_START(epson_tf20_device::cpu_io)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE(0xf0, 0xf3) AM_DEVREADWRITE("3a", upd7201_device, ba_cd_r, ba_cd_w)
AM_RANGE(0xf6, 0xf6) AM_READ(rom_disable_r)
AM_RANGE(0xf7, 0xf7) AM_READ_PORT("tf20_dip")
AM_RANGE(0xf8, 0xf8) AM_READWRITE(upd765_tc_r, fdc_control_w)
AM_RANGE(0xfa, 0xfb) AM_DEVICE("5a", upd765a_device, map)
ADDRESS_MAP_END
void epson_tf20_device::cpu_io(address_map &map)
{
map.unmap_value_high();
map.global_mask(0xff);
map(0xf0, 0xf3).rw("3a", FUNC(upd7201_device::ba_cd_r), FUNC(upd7201_device::ba_cd_w));
map(0xf6, 0xf6).r(this, FUNC(epson_tf20_device::rom_disable_r));
map(0xf7, 0xf7).portr("tf20_dip");
map(0xf8, 0xf8).rw(this, FUNC(epson_tf20_device::upd765_tc_r), FUNC(epson_tf20_device::fdc_control_w));
map(0xfa, 0xfb).m("5a", FUNC(upd765a_device::map));
}
//-------------------------------------------------
// rom_region - device-specific ROM region

11
src/devices/bus/hp80_io/82937.cpp
View File

@ -316,11 +316,12 @@ ROM_START(hp82937)
ROM_LOAD("1820-2437.bin" , 0 , 0x800 , CRC(687d1559) SHA1(44dfc8c3f431cd37a270b094f1db751214009214))
ROM_END
ADDRESS_MAP_START(hp82937_io_card_device::cpu_io_map)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x00 , 0x01) AM_DEVREADWRITE("xlator" , hp_1mb5_device , uc_r , uc_w)
AM_RANGE(0x03 , 0x03) AM_READWRITE(switch_r , latch_w)
ADDRESS_MAP_END
void hp82937_io_card_device::cpu_io_map(address_map &map)
{
map.unmap_value_high();
map(0x00, 0x01).rw("xlator", FUNC(hp_1mb5_device::uc_r), FUNC(hp_1mb5_device::uc_w));
map(0x03, 0x03).rw(this, FUNC(hp82937_io_card_device::switch_r), FUNC(hp82937_io_card_device::latch_w));
}
const tiny_rom_entry *hp82937_io_card_device::device_rom_region() const
{

32
src/devices/bus/hp9845_io/98034.cpp
View File

@ -339,22 +339,24 @@ ROM_START(hp98034)
ROM_LOAD("1816-1242.bin" , 0 , 0x400 , CRC(301a9f5f) SHA1(3d7c1ace38c4d3178fdbf764c044535d9f6ac94f))
ROM_END
ADDRESS_MAP_START(hp98034_io_card_device::np_program_map)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x000 , 0x3ff) AM_ROM AM_REGION("np" , 0)
ADDRESS_MAP_END
void hp98034_io_card_device::np_program_map(address_map &map)
{
map.unmap_value_high();
map(0x000, 0x3ff).rom().region("np", 0);
}
ADDRESS_MAP_START(hp98034_io_card_device::np_io_map)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0 , 0) AM_WRITE(hpib_data_w)
AM_RANGE(1 , 1) AM_WRITE(hpib_ctrl_w)
AM_RANGE(2 , 2) AM_READ(hpib_ctrl_r)
AM_RANGE(3 , 3) AM_READ(hpib_data_r)
AM_RANGE(4 , 4) AM_READ(idr_r)
AM_RANGE(5 , 5) AM_WRITE(odr_w)
AM_RANGE(6 , 6) AM_READWRITE(mode_reg_r , mode_reg_clear_w)
AM_RANGE(7 , 7) AM_READ(switch_r)
ADDRESS_MAP_END
void hp98034_io_card_device::np_io_map(address_map &map)
{
map.unmap_value_high();
map(0, 0).w(this, FUNC(hp98034_io_card_device::hpib_data_w));
map(1, 1).w(this, FUNC(hp98034_io_card_device::hpib_ctrl_w));
map(2, 2).r(this, FUNC(hp98034_io_card_device::hpib_ctrl_r));
map(3, 3).r(this, FUNC(hp98034_io_card_device::hpib_data_r));
map(4, 4).r(this, FUNC(hp98034_io_card_device::idr_r));
map(5, 5).w(this, FUNC(hp98034_io_card_device::odr_w));
map(6, 6).rw(this, FUNC(hp98034_io_card_device::mode_reg_r), FUNC(hp98034_io_card_device::mode_reg_clear_w));
map(7, 7).r(this, FUNC(hp98034_io_card_device::switch_r));
}
const tiny_rom_entry *hp98034_io_card_device::device_rom_region() const
{

42
src/devices/bus/hp9845_io/98035.cpp
View File

@ -727,27 +727,29 @@ ROM_START(hp98035)
ROM_LOAD("1818-0469.bin" , 0 , 0x800 , CRC(e16ab3bc) SHA1(34e89a37a2822f27af21969941201317dbff615b))
ROM_END
ADDRESS_MAP_START(hp98035_io_card_device::np_program_map)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x000 , 0x7ff) AM_ROM AM_REGION("np" , 0)
ADDRESS_MAP_END
void hp98035_io_card_device::np_program_map(address_map &map)
{
map.unmap_value_high();
map(0x000, 0x7ff).rom().region("np", 0);
}
ADDRESS_MAP_START(hp98035_io_card_device::np_io_map)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x0 , 0x0) AM_WRITE(ram_addr_w)
AM_RANGE(0x1 , 0x1) AM_READ(ram_data_r)
AM_RANGE(0x2 , 0x2) AM_WRITE(ram_addr_data_w)
AM_RANGE(0x3 , 0x3) AM_WRITE(ram_data_w)
AM_RANGE(0x5 , 0x5) AM_WRITE(clock_key_w)
AM_RANGE(0x7 , 0x7) AM_READ(clock_digit_r)
AM_RANGE(0x8 , 0x8) AM_WRITE(odr_w)
AM_RANGE(0x9 , 0x9) AM_READ(idr_r)
AM_RANGE(0xa , 0xa) AM_READ(np_status_r)
AM_RANGE(0xb , 0xb) AM_WRITE(clear_np_irq_w)
AM_RANGE(0xc , 0xc) AM_READ(clock_mux_r)
AM_RANGE(0xd , 0xd) AM_WRITE(set_irq_w)
AM_RANGE(0xe , 0xe) AM_READWRITE(clr_inten_r , clr_inten_w)
ADDRESS_MAP_END
void hp98035_io_card_device::np_io_map(address_map &map)
{
map.unmap_value_high();
map(0x0, 0x0).w(this, FUNC(hp98035_io_card_device::ram_addr_w));
map(0x1, 0x1).r(this, FUNC(hp98035_io_card_device::ram_data_r));
map(0x2, 0x2).w(this, FUNC(hp98035_io_card_device::ram_addr_data_w));
map(0x3, 0x3).w(this, FUNC(hp98035_io_card_device::ram_data_w));
map(0x5, 0x5).w(this, FUNC(hp98035_io_card_device::clock_key_w));
map(0x7, 0x7).r(this, FUNC(hp98035_io_card_device::clock_digit_r));
map(0x8, 0x8).w(this, FUNC(hp98035_io_card_device::odr_w));
map(0x9, 0x9).r(this, FUNC(hp98035_io_card_device::idr_r));
map(0xa, 0xa).r(this, FUNC(hp98035_io_card_device::np_status_r));
map(0xb, 0xb).w(this, FUNC(hp98035_io_card_device::clear_np_irq_w));
map(0xc, 0xc).r(this, FUNC(hp98035_io_card_device::clock_mux_r));
map(0xd, 0xd).w(this, FUNC(hp98035_io_card_device::set_irq_w));
map(0xe, 0xe).rw(this, FUNC(hp98035_io_card_device::clr_inten_r), FUNC(hp98035_io_card_device::clr_inten_w));
}
const tiny_rom_entry *hp98035_io_card_device::device_rom_region() const
{

13
src/devices/bus/ieee488/c2031.cpp
View File

@ -61,12 +61,13 @@ const tiny_rom_entry *c2031_device::device_rom_region() const
// ADDRESS_MAP( c2031_mem )
//-------------------------------------------------
ADDRESS_MAP_START(c2031_device::c2031_mem)
AM_RANGE(0x0000, 0x07ff) AM_MIRROR(0x6000) AM_RAM
AM_RANGE(0x1800, 0x180f) AM_MIRROR(0x63f0) AM_DEVREADWRITE(M6522_0_TAG, via6522_device, read, write)
AM_RANGE(0x1c00, 0x1c0f) AM_MIRROR(0x63f0) AM_DEVREADWRITE(M6522_1_TAG, via6522_device, read, write)
AM_RANGE(0x8000, 0xbfff) AM_MIRROR(0x4000) AM_ROM AM_REGION(M6502_TAG, 0)
ADDRESS_MAP_END
void c2031_device::c2031_mem(address_map &map)
{
map(0x0000, 0x07ff).mirror(0x6000).ram();
map(0x1800, 0x180f).mirror(0x63f0).rw(M6522_0_TAG, FUNC(via6522_device::read), FUNC(via6522_device::write));
map(0x1c00, 0x1c0f).mirror(0x63f0).rw(M6522_1_TAG, FUNC(via6522_device::read), FUNC(via6522_device::write));
map(0x8000, 0xbfff).mirror(0x4000).rom().region(M6502_TAG, 0);
}
WRITE_LINE_MEMBER( c2031_device::via0_irq_w )

48
src/devices/bus/ieee488/c2040.cpp
View File

@ -168,35 +168,37 @@ const tiny_rom_entry *c4040_device::device_rom_region() const
// ADDRESS_MAP( c2040_main_mem )
//-------------------------------------------------
ADDRESS_MAP_START(c2040_device::c2040_main_mem)
ADDRESS_MAP_GLOBAL_MASK(0x7fff)
AM_RANGE(0x0000, 0x007f) AM_MIRROR(0x0100) AM_DEVICE(M6532_0_TAG, mos6532_new_device, ram_map)
AM_RANGE(0x0080, 0x00ff) AM_MIRROR(0x0100) AM_DEVICE(M6532_1_TAG, mos6532_new_device, ram_map)
AM_RANGE(0x0200, 0x021f) AM_MIRROR(0x0d60) AM_DEVICE(M6532_0_TAG, mos6532_new_device, io_map)
AM_RANGE(0x0280, 0x029f) AM_MIRROR(0x0d60) AM_DEVICE(M6532_1_TAG, mos6532_new_device, io_map)
AM_RANGE(0x1000, 0x13ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("share1")
AM_RANGE(0x2000, 0x23ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("share2")
AM_RANGE(0x3000, 0x33ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("share3")
AM_RANGE(0x4000, 0x43ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("share4")
AM_RANGE(0x5000, 0x7fff) AM_ROM AM_REGION(M6502_TAG, 0)
ADDRESS_MAP_END
void c2040_device::c2040_main_mem(address_map &map)
{
map.global_mask(0x7fff);
map(0x0000, 0x007f).mirror(0x0100).m(M6532_0_TAG, FUNC(mos6532_new_device::ram_map));
map(0x0080, 0x00ff).mirror(0x0100).m(M6532_1_TAG, FUNC(mos6532_new_device::ram_map));
map(0x0200, 0x021f).mirror(0x0d60).m(M6532_0_TAG, FUNC(mos6532_new_device::io_map));
map(0x0280, 0x029f).mirror(0x0d60).m(M6532_1_TAG, FUNC(mos6532_new_device::io_map));
map(0x1000, 0x13ff).mirror(0x0c00).ram().share("share1");
map(0x2000, 0x23ff).mirror(0x0c00).ram().share("share2");
map(0x3000, 0x33ff).mirror(0x0c00).ram().share("share3");
map(0x4000, 0x43ff).mirror(0x0c00).ram().share("share4");
map(0x5000, 0x7fff).rom().region(M6502_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( c2040_fdc_mem )
//-------------------------------------------------
ADDRESS_MAP_START(c2040_device::c2040_fdc_mem)
ADDRESS_MAP_GLOBAL_MASK(0x1fff)
AM_RANGE(0x0000, 0x003f) AM_MIRROR(0x0300) AM_DEVICE(M6530_TAG, mos6530_new_device, ram_map)
AM_RANGE(0x0040, 0x004f) AM_MIRROR(0x0330) AM_DEVICE(M6522_TAG, via6522_device, map)
AM_RANGE(0x0080, 0x008f) AM_MIRROR(0x0330) AM_DEVICE(M6530_TAG, mos6530_new_device, io_map)
AM_RANGE(0x0400, 0x07ff) AM_RAM AM_SHARE("share1")
AM_RANGE(0x0800, 0x0bff) AM_RAM AM_SHARE("share2")
AM_RANGE(0x0c00, 0x0fff) AM_RAM AM_SHARE("share3")
AM_RANGE(0x1000, 0x13ff) AM_RAM AM_SHARE("share4")
AM_RANGE(0x1c00, 0x1fff) AM_ROM AM_REGION(M6504_TAG, 0)
ADDRESS_MAP_END
void c2040_device::c2040_fdc_mem(address_map &map)
{
map.global_mask(0x1fff);
map(0x0000, 0x003f).mirror(0x0300).m(M6530_TAG, FUNC(mos6530_new_device::ram_map));
map(0x0040, 0x004f).mirror(0x0330).m(M6522_TAG, FUNC(via6522_device::map));
map(0x0080, 0x008f).mirror(0x0330).m(M6530_TAG, FUNC(mos6530_new_device::io_map));
map(0x0400, 0x07ff).ram().share("share1");
map(0x0800, 0x0bff).ram().share("share2");
map(0x0c00, 0x0fff).ram().share("share3");
map(0x1000, 0x13ff).ram().share("share4");
map(0x1c00, 0x1fff).rom().region(M6504_TAG, 0);
}
//-------------------------------------------------

46
src/devices/bus/ieee488/c8050.cpp
View File

@ -184,34 +184,36 @@ const tiny_rom_entry *sfd1001_device::device_rom_region() const
// ADDRESS_MAP( c8050_main_mem )
//-------------------------------------------------
ADDRESS_MAP_START(c8050_device::c8050_main_mem)
AM_RANGE(0x0000, 0x007f) AM_MIRROR(0x0100) AM_DEVICE(M6532_0_TAG, mos6532_new_device, ram_map)
AM_RANGE(0x0080, 0x00ff) AM_MIRROR(0x0100) AM_DEVICE(M6532_1_TAG, mos6532_new_device, ram_map)
AM_RANGE(0x0200, 0x021f) AM_MIRROR(0x0d60) AM_DEVICE(M6532_0_TAG, mos6532_new_device, io_map)
AM_RANGE(0x0280, 0x029f) AM_MIRROR(0x0d60) AM_DEVICE(M6532_1_TAG, mos6532_new_device, io_map)
AM_RANGE(0x1000, 0x13ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("share1")
AM_RANGE(0x2000, 0x23ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("share2")
AM_RANGE(0x3000, 0x33ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("share3")
AM_RANGE(0x4000, 0x43ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("share4")
AM_RANGE(0xc000, 0xffff) AM_ROM AM_REGION(M6502_TAG, 0)
ADDRESS_MAP_END
void c8050_device::c8050_main_mem(address_map &map)
{
map(0x0000, 0x007f).mirror(0x0100).m(M6532_0_TAG, FUNC(mos6532_new_device::ram_map));
map(0x0080, 0x00ff).mirror(0x0100).m(M6532_1_TAG, FUNC(mos6532_new_device::ram_map));
map(0x0200, 0x021f).mirror(0x0d60).m(M6532_0_TAG, FUNC(mos6532_new_device::io_map));
map(0x0280, 0x029f).mirror(0x0d60).m(M6532_1_TAG, FUNC(mos6532_new_device::io_map));
map(0x1000, 0x13ff).mirror(0x0c00).ram().share("share1");
map(0x2000, 0x23ff).mirror(0x0c00).ram().share("share2");
map(0x3000, 0x33ff).mirror(0x0c00).ram().share("share3");
map(0x4000, 0x43ff).mirror(0x0c00).ram().share("share4");
map(0xc000, 0xffff).rom().region(M6502_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( c8050_fdc_mem )
//-------------------------------------------------
ADDRESS_MAP_START(c8050_device::c8050_fdc_mem)
ADDRESS_MAP_GLOBAL_MASK(0x1fff)
AM_RANGE(0x0000, 0x003f) AM_MIRROR(0x0300) AM_DEVICE(M6530_TAG, mos6530_new_device, ram_map)
AM_RANGE(0x0040, 0x004f) AM_MIRROR(0x0330) AM_DEVICE(M6522_TAG, via6522_device, map)
AM_RANGE(0x0080, 0x008f) AM_MIRROR(0x0330) AM_DEVICE(M6530_TAG, mos6530_new_device, io_map)
AM_RANGE(0x0400, 0x07ff) AM_RAM AM_SHARE("share1")
AM_RANGE(0x0800, 0x0bff) AM_RAM AM_SHARE("share2")
AM_RANGE(0x0c00, 0x0fff) AM_RAM AM_SHARE("share3")
AM_RANGE(0x1000, 0x13ff) AM_RAM AM_SHARE("share4")
AM_RANGE(0x1c00, 0x1fff) AM_DEVICE(M6530_TAG, mos6530_new_device, rom_map)
ADDRESS_MAP_END
void c8050_device::c8050_fdc_mem(address_map &map)
{
map.global_mask(0x1fff);
map(0x0000, 0x003f).mirror(0x0300).m(M6530_TAG, FUNC(mos6530_new_device::ram_map));
map(0x0040, 0x004f).mirror(0x0330).m(M6522_TAG, FUNC(via6522_device::map));
map(0x0080, 0x008f).mirror(0x0330).m(M6530_TAG, FUNC(mos6530_new_device::io_map));
map(0x0400, 0x07ff).ram().share("share1");
map(0x0800, 0x0bff).ram().share("share2");
map(0x0c00, 0x0fff).ram().share("share3");
map(0x1000, 0x13ff).ram().share("share4");
map(0x1c00, 0x1fff).m(M6530_TAG, FUNC(mos6530_new_device::rom_map));
}
//-------------------------------------------------

46
src/devices/bus/ieee488/c8280.cpp
View File

@ -73,34 +73,36 @@ const tiny_rom_entry *c8280_device::device_rom_region() const
// ADDRESS_MAP( c8280_main_mem )
//-------------------------------------------------
ADDRESS_MAP_START(c8280_device::c8280_main_mem)
AM_RANGE(0x0000, 0x007f) AM_MIRROR(0x100) AM_DEVICE(M6532_0_TAG, mos6532_new_device, ram_map)
AM_RANGE(0x0080, 0x00ff) AM_MIRROR(0x100) AM_DEVICE(M6532_1_TAG, mos6532_new_device, ram_map)
AM_RANGE(0x0200, 0x021f) AM_MIRROR(0xd60) AM_DEVICE(M6532_0_TAG, mos6532_new_device, io_map)
AM_RANGE(0x0280, 0x029f) AM_MIRROR(0xd60) AM_DEVICE(M6532_1_TAG, mos6532_new_device, io_map)
AM_RANGE(0x1000, 0x13ff) AM_MIRROR(0xc00) AM_RAM AM_SHARE("share1")
AM_RANGE(0x2000, 0x23ff) AM_MIRROR(0xc00) AM_RAM AM_SHARE("share2")
AM_RANGE(0x3000, 0x33ff) AM_MIRROR(0xc00) AM_RAM AM_SHARE("share3")
AM_RANGE(0x4000, 0x43ff) AM_MIRROR(0xc00) AM_RAM AM_SHARE("share4")
AM_RANGE(0xc000, 0xffff) AM_ROM AM_REGION(M6502_DOS_TAG, 0)
ADDRESS_MAP_END
void c8280_device::c8280_main_mem(address_map &map)
{
map(0x0000, 0x007f).mirror(0x100).m(M6532_0_TAG, FUNC(mos6532_new_device::ram_map));
map(0x0080, 0x00ff).mirror(0x100).m(M6532_1_TAG, FUNC(mos6532_new_device::ram_map));
map(0x0200, 0x021f).mirror(0xd60).m(M6532_0_TAG, FUNC(mos6532_new_device::io_map));
map(0x0280, 0x029f).mirror(0xd60).m(M6532_1_TAG, FUNC(mos6532_new_device::io_map));
map(0x1000, 0x13ff).mirror(0xc00).ram().share("share1");
map(0x2000, 0x23ff).mirror(0xc00).ram().share("share2");
map(0x3000, 0x33ff).mirror(0xc00).ram().share("share3");
map(0x4000, 0x43ff).mirror(0xc00).ram().share("share4");
map(0xc000, 0xffff).rom().region(M6502_DOS_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( c8280_fdc_mem )
//-------------------------------------------------
ADDRESS_MAP_START(c8280_device::c8280_fdc_mem)
ADDRESS_MAP_GLOBAL_MASK(0x1fff)
AM_RANGE(0x0000, 0x007f) AM_MIRROR(0x300) AM_RAM
AM_RANGE(0x0080, 0x0083) AM_MIRROR(0x37c) AM_DEVREADWRITE(WD1797_TAG, fd1797_device, read, write)
AM_RANGE(0x0400, 0x07ff) AM_RAM AM_SHARE("share1")
AM_RANGE(0x0800, 0x0bff) AM_RAM AM_SHARE("share2")
AM_RANGE(0x0c00, 0x0fff) AM_RAM AM_SHARE("share3")
AM_RANGE(0x1000, 0x13ff) AM_RAM AM_SHARE("share4")
AM_RANGE(0x1400, 0x1400) AM_MIRROR(0x3ff) AM_READWRITE(fk5_r, fk5_w)
AM_RANGE(0x1800, 0x1fff) AM_ROM AM_REGION(M6502_FDC_TAG, 0)
ADDRESS_MAP_END
void c8280_device::c8280_fdc_mem(address_map &map)
{
map.global_mask(0x1fff);
map(0x0000, 0x007f).mirror(0x300).ram();
map(0x0080, 0x0083).mirror(0x37c).rw(WD1797_TAG, FUNC(fd1797_device::read), FUNC(fd1797_device::write));
map(0x0400, 0x07ff).ram().share("share1");
map(0x0800, 0x0bff).ram().share("share2");
map(0x0c00, 0x0fff).ram().share("share3");
map(0x1000, 0x13ff).ram().share("share4");
map(0x1400, 0x1400).mirror(0x3ff).rw(this, FUNC(c8280_device::fk5_r), FUNC(c8280_device::fk5_w));
map(0x1800, 0x1fff).rom().region(M6502_FDC_TAG, 0);
}
//-------------------------------------------------

44
src/devices/bus/ieee488/d9060.cpp
View File

@ -109,33 +109,35 @@ const tiny_rom_entry *d9060_device_base::device_rom_region() const
// ADDRESS_MAP( d9060_main_mem )
//-------------------------------------------------
ADDRESS_MAP_START(d9060_device_base::d9060_main_mem)
AM_RANGE(0x0000, 0x007f) AM_MIRROR(0x0100) AM_DEVICE(M6532_0_TAG, mos6532_new_device, ram_map)
AM_RANGE(0x0080, 0x00ff) AM_MIRROR(0x0100) AM_DEVICE(M6532_1_TAG, mos6532_new_device, ram_map)
AM_RANGE(0x0200, 0x021f) AM_MIRROR(0x0d60) AM_DEVICE(M6532_0_TAG, mos6532_new_device, io_map)
AM_RANGE(0x0280, 0x029f) AM_MIRROR(0x0d60) AM_DEVICE(M6532_1_TAG, mos6532_new_device, io_map)
AM_RANGE(0x1000, 0x13ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("share1")
AM_RANGE(0x2000, 0x23ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("share2")
AM_RANGE(0x3000, 0x33ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("share3")
AM_RANGE(0x4000, 0x43ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("share4")
AM_RANGE(0xc000, 0xffff) AM_ROM AM_REGION(M6502_DOS_TAG, 0)
ADDRESS_MAP_END
void d9060_device_base::d9060_main_mem(address_map &map)
{
map(0x0000, 0x007f).mirror(0x0100).m(M6532_0_TAG, FUNC(mos6532_new_device::ram_map));
map(0x0080, 0x00ff).mirror(0x0100).m(M6532_1_TAG, FUNC(mos6532_new_device::ram_map));
map(0x0200, 0x021f).mirror(0x0d60).m(M6532_0_TAG, FUNC(mos6532_new_device::io_map));
map(0x0280, 0x029f).mirror(0x0d60).m(M6532_1_TAG, FUNC(mos6532_new_device::io_map));
map(0x1000, 0x13ff).mirror(0x0c00).ram().share("share1");
map(0x2000, 0x23ff).mirror(0x0c00).ram().share("share2");
map(0x3000, 0x33ff).mirror(0x0c00).ram().share("share3");
map(0x4000, 0x43ff).mirror(0x0c00).ram().share("share4");
map(0xc000, 0xffff).rom().region(M6502_DOS_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( d9060_hdc_mem )
//-------------------------------------------------
ADDRESS_MAP_START(d9060_device_base::d9060_hdc_mem)
ADDRESS_MAP_GLOBAL_MASK(0x1fff)
AM_RANGE(0x0000, 0x007f) AM_MIRROR(0x300) AM_RAM
AM_RANGE(0x0080, 0x008f) AM_MIRROR(0x370) AM_DEVREADWRITE(M6522_TAG, via6522_device, read, write)
AM_RANGE(0x0400, 0x07ff) AM_RAM AM_SHARE("share1")
AM_RANGE(0x0800, 0x0bff) AM_RAM AM_SHARE("share2")
AM_RANGE(0x0c00, 0x0fff) AM_RAM AM_SHARE("share3")
AM_RANGE(0x1000, 0x13ff) AM_RAM AM_SHARE("share4")
AM_RANGE(0x1800, 0x1fff) AM_ROM AM_REGION(M6502_HDC_TAG, 0)
ADDRESS_MAP_END
void d9060_device_base::d9060_hdc_mem(address_map &map)
{
map.global_mask(0x1fff);
map(0x0000, 0x007f).mirror(0x300).ram();
map(0x0080, 0x008f).mirror(0x370).rw(M6522_TAG, FUNC(via6522_device::read), FUNC(via6522_device::write));
map(0x0400, 0x07ff).ram().share("share1");
map(0x0800, 0x0bff).ram().share("share2");
map(0x0c00, 0x0fff).ram().share("share3");
map(0x1000, 0x13ff).ram().share("share4");
map(0x1800, 0x1fff).rom().region(M6502_HDC_TAG, 0);
}
//-------------------------------------------------

22
src/devices/bus/ieee488/hardbox.cpp
View File

@ -105,22 +105,24 @@ const tiny_rom_entry *hardbox_device::device_rom_region() const
// ADDRESS_MAP( hardbox_mem )
//-------------------------------------------------
ADDRESS_MAP_START(hardbox_device::hardbox_mem)
AM_RANGE(0x0000, 0x3fff) AM_RAM
AM_RANGE(0xe000, 0xffff) AM_ROM AM_REGION(Z80_TAG, 0)
ADDRESS_MAP_END
void hardbox_device::hardbox_mem(address_map &map)
{
map(0x0000, 0x3fff).ram();
map(0xe000, 0xffff).rom().region(Z80_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( hardbox_io )
//-------------------------------------------------
ADDRESS_MAP_START(hardbox_device::hardbox_io)
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE(0x10, 0x13) AM_DEVREADWRITE(I8255_0_TAG, i8255_device, read, write)
AM_RANGE(0x14, 0x17) AM_DEVREADWRITE(I8255_1_TAG, i8255_device, read, write)
AM_RANGE(0x18, 0x18) AM_DEVREADWRITE(CORVUS_HDC_TAG, corvus_hdc_device, read, write)
ADDRESS_MAP_END
void hardbox_device::hardbox_io(address_map &map)
{
map.global_mask(0xff);
map(0x10, 0x13).rw(I8255_0_TAG, FUNC(i8255_device::read), FUNC(i8255_device::write));
map(0x14, 0x17).rw(I8255_1_TAG, FUNC(i8255_device::read), FUNC(i8255_device::write));
map(0x18, 0x18).rw(CORVUS_HDC_TAG, FUNC(corvus_hdc_device::read), FUNC(corvus_hdc_device::write));
}
//-------------------------------------------------

38
src/devices/bus/ieee488/hp9895.cpp
View File

@ -847,25 +847,27 @@ ROM_START(hp9895)
ROM_LOAD("1818-1391a.bin" , 0 , 0x2000 , CRC(b50dbfb5) SHA1(96edf9af78be75fbad2a0245b8af43958ba32752))
ROM_END
ADDRESS_MAP_START(hp9895_device::z80_program_map)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x0000 , 0x1fff) AM_ROM AM_REGION("cpu" , 0)
AM_RANGE(0x6000 , 0x63ff) AM_RAM
ADDRESS_MAP_END
void hp9895_device::z80_program_map(address_map &map)
{
map.unmap_value_high();
map(0x0000, 0x1fff).rom().region("cpu", 0);
map(0x6000, 0x63ff).ram();
}
ADDRESS_MAP_START(hp9895_device::z80_io_map)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE(0x10 , 0x17) AM_DEVWRITE("phi" , phi_device , reg8_w) AM_READ(phi_reg_r)
AM_RANGE(0x60 , 0x60) AM_READWRITE(data_r , data_w)
AM_RANGE(0x61 , 0x61) AM_READWRITE(clock_r , clock_w)
AM_RANGE(0x62 , 0x62) AM_READWRITE(drivstat_r , reset_w)
AM_RANGE(0x63 , 0x63) AM_READWRITE(switches_r , leds_w)
AM_RANGE(0x64 , 0x64) AM_WRITE(cntl_w)
AM_RANGE(0x65 , 0x65) AM_WRITE(drv_w)
AM_RANGE(0x66 , 0x66) AM_WRITE(xv_w)
AM_RANGE(0x67 , 0x67) AM_READ(switches2_r)
ADDRESS_MAP_END
void hp9895_device::z80_io_map(address_map &map)
{
map.unmap_value_high();
map.global_mask(0xff);
map(0x10, 0x17).w("phi", FUNC(phi_device::reg8_w)).r(this, FUNC(hp9895_device::phi_reg_r));
map(0x60, 0x60).rw(this, FUNC(hp9895_device::data_r), FUNC(hp9895_device::data_w));
map(0x61, 0x61).rw(this, FUNC(hp9895_device::clock_r), FUNC(hp9895_device::clock_w));
map(0x62, 0x62).rw(this, FUNC(hp9895_device::drivstat_r), FUNC(hp9895_device::reset_w));
map(0x63, 0x63).rw(this, FUNC(hp9895_device::switches_r), FUNC(hp9895_device::leds_w));
map(0x64, 0x64).w(this, FUNC(hp9895_device::cntl_w));
map(0x65, 0x65).w(this, FUNC(hp9895_device::drv_w));
map(0x66, 0x66).w(this, FUNC(hp9895_device::xv_w));
map(0x67, 0x67).r(this, FUNC(hp9895_device::switches2_r));
}
static SLOT_INTERFACE_START(hp9895_floppies)
SLOT_INTERFACE("8dsdd" , FLOPPY_8_DSDD)

12
src/devices/bus/ieee488/shark.cpp
View File

@ -61,17 +61,19 @@ const tiny_rom_entry *mshark_device::device_rom_region() const
// ADDRESS_MAP( mshark_mem )
//-------------------------------------------------
ADDRESS_MAP_START(mshark_device::mshark_mem)
AM_RANGE(0x0000, 0x4fff) AM_ROM AM_REGION(I8085_TAG, 0)
ADDRESS_MAP_END
void mshark_device::mshark_mem(address_map &map)
{
map(0x0000, 0x4fff).rom().region(I8085_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( mshark_io )
//-------------------------------------------------
ADDRESS_MAP_START(mshark_device::mshark_io)
ADDRESS_MAP_END
void mshark_device::mshark_io(address_map &map)
{
}
//-------------------------------------------------

28
src/devices/bus/ieee488/softbox.cpp
View File

@ -72,25 +72,27 @@ const tiny_rom_entry *softbox_device::device_rom_region() const
// ADDRESS_MAP( softbox_mem )
//-------------------------------------------------
ADDRESS_MAP_START(softbox_device::softbox_mem)
AM_RANGE(0x0000, 0xefff) AM_RAM
AM_RANGE(0xf000, 0xffff) AM_ROM AM_REGION(Z80_TAG, 0)
ADDRESS_MAP_END
void softbox_device::softbox_mem(address_map &map)
{
map(0x0000, 0xefff).ram();
map(0xf000, 0xffff).rom().region(Z80_TAG, 0);
}
//-------------------------------------------------
// ADDRESS_MAP( softbox_io )
//-------------------------------------------------
ADDRESS_MAP_START(softbox_device::softbox_io)
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE(0x08, 0x08) AM_DEVREADWRITE(I8251_TAG, i8251_device, data_r, data_w)
AM_RANGE(0x09, 0x09) AM_DEVREADWRITE(I8251_TAG, i8251_device, status_r, control_w)
AM_RANGE(0x0c, 0x0c) AM_WRITE(dbrg_w)
AM_RANGE(0x10, 0x13) AM_DEVREADWRITE(I8255_0_TAG, i8255_device, read, write)
AM_RANGE(0x14, 0x17) AM_DEVREADWRITE(I8255_1_TAG, i8255_device, read, write)
AM_RANGE(0x18, 0x18) AM_DEVREADWRITE(CORVUS_HDC_TAG, corvus_hdc_device, read, write)
ADDRESS_MAP_END
void softbox_device::softbox_io(address_map &map)
{
map.global_mask(0xff);
map(0x08, 0x08).rw(I8251_TAG, FUNC(i8251_device::data_r), FUNC(i8251_device::data_w));
map(0x09, 0x09).rw(I8251_TAG, FUNC(i8251_device::status_r), FUNC(i8251_device::control_w));
map(0x0c, 0x0c).w(this, FUNC(softbox_device::dbrg_w));
map(0x10, 0x13).rw(I8255_0_TAG, FUNC(i8255_device::read), FUNC(i8255_device::write));
map(0x14, 0x17).rw(I8255_1_TAG, FUNC(i8255_device::read), FUNC(i8255_device::write));
map(0x18, 0x18).rw(CORVUS_HDC_TAG, FUNC(corvus_hdc_device::read), FUNC(corvus_hdc_device::write));
}

40
src/devices/bus/imi7000/imi5000h.cpp
View File

@ -62,31 +62,33 @@ const tiny_rom_entry *imi5000h_device::device_rom_region() const
// ADDRESS_MAP( imi5000h_mem )
//-------------------------------------------------
ADDRESS_MAP_START(imi5000h_device::imi5000h_mem)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x0000, 0x0fff) AM_MIRROR(0x1000) AM_ROM AM_REGION(Z80_TAG, 0)
AM_RANGE(0x4000, 0x47ff) AM_MIRROR(0x1800) AM_RAM
AM_RANGE(0x6000, 0x63ff) AM_MIRROR(0x1c00) AM_RAM
AM_RANGE(0x8000, 0x83ff) AM_MIRROR(0x1c00) AM_RAM
AM_RANGE(0xa000, 0xa3ff) AM_MIRROR(0x1c00) AM_RAM
ADDRESS_MAP_END
void imi5000h_device::imi5000h_mem(address_map &map)
{
map.unmap_value_high();
map(0x0000, 0x0fff).mirror(0x1000).rom().region(Z80_TAG, 0);
map(0x4000, 0x47ff).mirror(0x1800).ram();
map(0x6000, 0x63ff).mirror(0x1c00).ram();
map(0x8000, 0x83ff).mirror(0x1c00).ram();
map(0xa000, 0xa3ff).mirror(0x1c00).ram();
}
//-------------------------------------------------
// ADDRESS_MAP( imi5000h_io )
//-------------------------------------------------
ADDRESS_MAP_START(imi5000h_device::imi5000h_io)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_GLOBAL_MASK(0x9f)
AM_RANGE(0x00, 0x03) AM_DEVREADWRITE(Z80PIO_0_TAG, z80pio_device, read, write)
AM_RANGE(0x08, 0x0b) AM_DEVREADWRITE(Z80PIO_2_TAG, z80pio_device, read, write)
AM_RANGE(0x0c, 0x0f) AM_DEVREADWRITE(Z80PIO_3_TAG, z80pio_device, read, write)
AM_RANGE(0x10, 0x10) AM_MIRROR(0x03) // BEGRDY
AM_RANGE(0x14, 0x14) AM_MIRROR(0x03) // HSXCLR
AM_RANGE(0x18, 0x18) AM_MIRROR(0x03) // XFERSTB
AM_RANGE(0x1c, 0x1f) AM_DEVREADWRITE(Z80CTC_TAG, z80ctc_device, read, write)
ADDRESS_MAP_END
void imi5000h_device::imi5000h_io(address_map &map)
{
map.unmap_value_high();
map.global_mask(0x9f);
map(0x00, 0x03).rw(Z80PIO_0_TAG, FUNC(z80pio_device::read), FUNC(z80pio_device::write));
map(0x08, 0x0b).rw(Z80PIO_2_TAG, FUNC(z80pio_device::read), FUNC(z80pio_device::write));
map(0x0c, 0x0f).rw(Z80PIO_3_TAG, FUNC(z80pio_device::read), FUNC(z80pio_device::write));
map(0x10, 0x10).mirror(0x03); // BEGRDY
map(0x14, 0x14).mirror(0x03); // HSXCLR
map(0x18, 0x18).mirror(0x03); // XFERSTB
map(0x1c, 0x1f).rw(Z80CTC_TAG, FUNC(z80ctc_device::read), FUNC(z80ctc_device::write));
}
//-------------------------------------------------

15
src/devices/bus/isa/aha1542.cpp
View File

@ -161,13 +161,14 @@ ROM_START( aha1542 )
ROM_LOAD( "553801-00.u15", 0x0000, 0x8000, CRC(7824397e) SHA1(35bc2c8fab31aad3190a478f2dc8f3a72958cf04) ) /* ADAPTEC, INC MCODE */
ROM_END
ADDRESS_MAP_START(aha1542_device::z84c0010_mem)
AM_RANGE(0x0000, 0x7fff) AM_ROM AM_REGION(Z84C0010_TAG, 0)
AM_RANGE(0x8000, 0x800f) AM_NOP // something is mapped there
AM_RANGE(0x9000, 0xafff) AM_RAM // 2kb RAM chip
AM_RANGE(0xe000, 0xe0ff) AM_RAM // probably PC<->Z80 communication area
AM_RANGE(0xb000, 0xb000) AM_NOP // something?
ADDRESS_MAP_END
void aha1542_device::z84c0010_mem(address_map &map)
{
map(0x0000, 0x7fff).rom().region(Z84C0010_TAG, 0);
map(0x8000, 0x800f).noprw(); // something is mapped there
map(0x9000, 0xafff).ram(); // 2kb RAM chip
map(0xe000, 0xe0ff).ram(); // probably PC<->Z80 communication area
map(0xb000, 0xb000).noprw(); // something?
}
const tiny_rom_entry *aha1542_device::device_rom_region() const
{

44
src/devices/bus/isa/dectalk.cpp
View File

@ -116,29 +116,33 @@ WRITE_LINE_MEMBER(dectalk_isa_device::clock_w)
m_dsp->set_input_line(INPUT_LINE_IRQ0, (!(m_ctl & 0x20) || state) ? CLEAR_LINE : ASSERT_LINE);
}
ADDRESS_MAP_START(dectalk_isa_device::dectalk_cpu_io)
AM_RANGE(0x0400, 0x0401) AM_READWRITE(cmd_r, status_w) //PCS0
AM_RANGE(0x0480, 0x0481) AM_READWRITE(data_r, data_w) //PCS1
AM_RANGE(0x0500, 0x0501) AM_WRITE(dsp_dma_w) //PCS2
AM_RANGE(0x0580, 0x0581) AM_READ(host_irq_r) //PCS3
AM_RANGE(0x0600, 0x0601) AM_WRITE(output_ctl_w) //PCS4
AM_RANGE(0x0680, 0x0681) AM_READWRITE8(dma_r, dma_w, 0xff) //PCS5
AM_RANGE(0x0700, 0x0701) AM_WRITE(irq_line_w) //PCS6
ADDRESS_MAP_END
void dectalk_isa_device::dectalk_cpu_io(address_map &map)
{
map(0x0400, 0x0401).rw(this, FUNC(dectalk_isa_device::cmd_r), FUNC(dectalk_isa_device::status_w)); //PCS0
map(0x0480, 0x0481).rw(this, FUNC(dectalk_isa_device::data_r), FUNC(dectalk_isa_device::data_w)); //PCS1
map(0x0500, 0x0501).w(this, FUNC(dectalk_isa_device::dsp_dma_w)); //PCS2
map(0x0580, 0x0581).r(this, FUNC(dectalk_isa_device::host_irq_r)); //PCS3
map(0x0600, 0x0601).w(this, FUNC(dectalk_isa_device::output_ctl_w)); //PCS4
map(0x0680, 0x0680).rw(this, FUNC(dectalk_isa_device::dma_r), FUNC(dectalk_isa_device::dma_w)); //PCS5
map(0x0700, 0x0701).w(this, FUNC(dectalk_isa_device::irq_line_w)); //PCS6
}
ADDRESS_MAP_START(dectalk_isa_device::dectalk_cpu_map)
AM_RANGE(0x00000, 0xFBFFF) AM_RAM
AM_RANGE(0xFC000, 0xFFFFF) AM_ROM AM_REGION("dectalk_cpu", 0)
ADDRESS_MAP_END
void dectalk_isa_device::dectalk_cpu_map(address_map &map)
{
map(0x00000, 0xFBFFF).ram();
map(0xFC000, 0xFFFFF).rom().region("dectalk_cpu", 0);
}
ADDRESS_MAP_START(dectalk_isa_device::dectalk_dsp_io)
AM_RANGE(0x0, 0x0) AM_READ(dsp_dma_r)
AM_RANGE(0x1, 0x1) AM_READWRITE(dsp_dma_r, dac_w)
ADDRESS_MAP_END
void dectalk_isa_device::dectalk_dsp_io(address_map &map)
{
map(0x0, 0x0).r(this, FUNC(dectalk_isa_device::dsp_dma_r));
map(0x1, 0x1).rw(this, FUNC(dectalk_isa_device::dsp_dma_r), FUNC(dectalk_isa_device::dac_w));
}
ADDRESS_MAP_START(dectalk_isa_device::dectalk_dsp_map)
AM_RANGE(0x0000, 0x0FFF) AM_ROM AM_REGION("dectalk_dsp", 0)
ADDRESS_MAP_END
void dectalk_isa_device::dectalk_dsp_map(address_map &map)
{
map(0x0000, 0x0FFF).rom().region("dectalk_dsp", 0);
}
ROM_START( dectalk_isa )
ROM_REGION( 0x4000, "dectalk_cpu", 0 )

17
src/devices/bus/isa/finalchs.cpp
View File

@ -37,14 +37,15 @@ WRITE8_MEMBER( isa8_finalchs_device::io6000_write )
m_FCH_latch_data = data;
}
ADDRESS_MAP_START(isa8_finalchs_device::finalchs_mem)
AM_RANGE( 0x0000, 0x1fff ) AM_RAM
AM_RANGE( 0x7ff8, 0x7ff8 ) AM_READ(io7ff8_read)
AM_RANGE( 0x7ff8, 0x7ff8 ) AM_WRITE(io7ff8_write)
AM_RANGE( 0x6000, 0x6000 ) AM_READ(io6000_read)
AM_RANGE( 0x6000, 0x6000 ) AM_WRITE(io6000_write)
AM_RANGE( 0x8000, 0xffff ) AM_ROM
ADDRESS_MAP_END
void isa8_finalchs_device::finalchs_mem(address_map &map)
{
map(0x0000, 0x1fff).ram();
map(0x7ff8, 0x7ff8).r(this, FUNC(isa8_finalchs_device::io7ff8_read));
map(0x7ff8, 0x7ff8).w(this, FUNC(isa8_finalchs_device::io7ff8_write));
map(0x6000, 0x6000).r(this, FUNC(isa8_finalchs_device::io6000_read));
map(0x6000, 0x6000).w(this, FUNC(isa8_finalchs_device::io6000_write));
map(0x8000, 0xffff).rom();
}
ROM_START(finalchs)
ROM_REGION(0x10000,"maincpu",0)

32
src/devices/bus/isa/ibm_mfc.cpp
View File

@ -113,22 +113,24 @@ void isa8_ibm_mfc_device::update_z80_interrupts(void)
// Z80 memory map
//-------------------------------------------------
ADDRESS_MAP_START(isa8_ibm_mfc_device::prg_map)
AM_RANGE(0x0000, 0x7fff) AM_ROM
AM_RANGE(0x8000, 0x8000) AM_RAM // Unknown - tested on startup
AM_RANGE(0xbfff, 0xbfff) AM_RAM // Unknown - tested on startup
AM_RANGE(0xc000, 0xdfff) AM_RAM
AM_RANGE(0xe000, 0xffff) AM_RAM
ADDRESS_MAP_END
void isa8_ibm_mfc_device::prg_map(address_map &map)
{
map(0x0000, 0x7fff).rom();
map(0x8000, 0x8000).ram(); // Unknown - tested on startup
map(0xbfff, 0xbfff).ram(); // Unknown - tested on startup
map(0xc000, 0xdfff).ram();
map(0xe000, 0xffff).ram();
}
ADDRESS_MAP_START(isa8_ibm_mfc_device::io_map)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE(0x00, 0x01) AM_DEVREADWRITE("ym2151", ym2151_device, read, write)
AM_RANGE(0x10, 0x10) AM_DEVREADWRITE("d71051", i8251_device, data_r, data_w)
AM_RANGE(0x11, 0x11) AM_DEVREADWRITE("d71051", i8251_device, status_r, control_w)
AM_RANGE(0x20, 0x23) AM_DEVREADWRITE("d71055c_1", i8255_device, read, write)
ADDRESS_MAP_END
void isa8_ibm_mfc_device::io_map(address_map &map)
{
map.unmap_value_high();
map.global_mask(0xff);
map(0x00, 0x01).rw("ym2151", FUNC(ym2151_device::read), FUNC(ym2151_device::write));
map(0x10, 0x10).rw("d71051", FUNC(i8251_device::data_r), FUNC(i8251_device::data_w));
map(0x11, 0x11).rw("d71051", FUNC(i8251_device::status_r), FUNC(i8251_device::control_w));
map(0x20, 0x23).rw("d71055c_1", FUNC(i8255_device::read), FUNC(i8255_device::write));
}
//-------------------------------------------------

7
src/devices/bus/isa/num9rev.cpp
View File

@ -14,9 +14,10 @@
DEFINE_DEVICE_TYPE(ISA8_NUM_9_REV, isa8_number_9_rev_device, "number_9_rev", "Number Nine Revolution 512x32/1024x8")
ADDRESS_MAP_START(isa8_number_9_rev_device::upd7220_map)
AM_RANGE(0x00000, 0x3ffff) AM_NOP
ADDRESS_MAP_END
void isa8_number_9_rev_device::upd7220_map(address_map &map)
{
map(0x00000, 0x3ffff).noprw();
}
UPD7220_DISPLAY_PIXELS_MEMBER( isa8_number_9_rev_device::hgdc_display_pixels )
{

26
src/devices/bus/isa/pgc.cpp
View File

@ -105,21 +105,23 @@ read only
3C001 INIT L/INIT H
*/
ADDRESS_MAP_START(isa8_pgc_device::pgc_map)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x00000, 0x07fff) AM_ROM
AM_RANGE(0x08000, 0x0ffff) AM_ROM AM_REGION("maincpu", 0x8000)
AM_RANGE(0x10000, 0x1001f) AM_READWRITE(stateparam_r, stateparam_w)
void isa8_pgc_device::pgc_map(address_map &map)
{
map.unmap_value_high();
map(0x00000, 0x07fff).rom();
map(0x08000, 0x0ffff).rom().region("maincpu", 0x8000);
map(0x10000, 0x1001f).rw(this, FUNC(isa8_pgc_device::stateparam_r), FUNC(isa8_pgc_device::stateparam_w));
// AM_RANGE(0x18000, 0x18fff) AM_RAM // ??
AM_RANGE(0x28000, 0x287ff) AM_RAM AM_REGION("commarea", 0) AM_MIRROR(0x800)
AM_RANGE(0x3c000, 0x3c001) AM_READ(init_r)
map(0x28000, 0x287ff).ram().region("commarea", 0).mirror(0x800);
map(0x3c000, 0x3c001).r(this, FUNC(isa8_pgc_device::init_r));
// AM_RANGE(0x3e000, 0x3efff) AM_RAM // ??
AM_RANGE(0xf8000, 0xfffff) AM_ROM AM_REGION("maincpu", 0x8000)
ADDRESS_MAP_END
map(0xf8000, 0xfffff).rom().region("maincpu", 0x8000);
}
ADDRESS_MAP_START(isa8_pgc_device::pgc_io)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_END
void isa8_pgc_device::pgc_io(address_map &map)
{
map.unmap_value_high();
}
static const gfx_layout pgc_charlayout =
{

47
src/devices/bus/isa/sb16.cpp
View File

@ -373,35 +373,36 @@ ROM_START( sb16 )
ROM_LOAD("ct1741_v413_xor.bin", 0x00, 0x40, CRC(5243d15a) SHA1(c7637c92828843f47e6e2f956af639b07aee4571))
ROM_END
ADDRESS_MAP_START(sb16_lle_device::sb16_io)
AM_RANGE(0x0000, 0x0000) AM_MIRROR(0xff00) AM_READWRITE(dsp_data_r, dsp_data_w)
void sb16_lle_device::sb16_io(address_map &map)
{
map(0x0000, 0x0000).mirror(0xff00).rw(this, FUNC(sb16_lle_device::dsp_data_r), FUNC(sb16_lle_device::dsp_data_w));
// AM_RANGE(0x0001, 0x0001) // MIDI related?
// AM_RANGE(0x0002, 0x0002)
AM_RANGE(0x0004, 0x0004) AM_MIRROR(0xff00) AM_READWRITE(mode_r, mode_w)
AM_RANGE(0x0005, 0x0005) AM_MIRROR(0xff00) AM_READWRITE(dac_ctrl_r, dac_ctrl_w)
AM_RANGE(0x0006, 0x0006) AM_MIRROR(0xff00) AM_READ(dma_stat_r)
map(0x0004, 0x0004).mirror(0xff00).rw(this, FUNC(sb16_lle_device::mode_r), FUNC(sb16_lle_device::mode_w));
map(0x0005, 0x0005).mirror(0xff00).rw(this, FUNC(sb16_lle_device::dac_ctrl_r), FUNC(sb16_lle_device::dac_ctrl_w));
map(0x0006, 0x0006).mirror(0xff00).r(this, FUNC(sb16_lle_device::dma_stat_r));
// AM_RANGE(0x0007, 0x0007) // unknown
AM_RANGE(0x0008, 0x0008) AM_MIRROR(0xff00) AM_READWRITE(ctrl8_r, ctrl8_w)
AM_RANGE(0x0009, 0x0009) AM_MIRROR(0xff00) AM_WRITE(rate_w)
AM_RANGE(0x000A, 0x000A) AM_MIRROR(0xff00) AM_READ(dma8_cnt_lo_r)
AM_RANGE(0x000B, 0x000B) AM_MIRROR(0xff00) AM_WRITE(dma8_len_lo_w)
AM_RANGE(0x000C, 0x000C) AM_MIRROR(0xff00) AM_WRITE(dma8_len_hi_w)
AM_RANGE(0x000D, 0x000D) AM_MIRROR(0xff00) AM_READ(dma8_cnt_hi_r)
AM_RANGE(0x000E, 0x000E) AM_MIRROR(0xff00) AM_READWRITE(dac_fifo_ctrl_r, dac_fifo_ctrl_w)
AM_RANGE(0x000F, 0x000F) AM_MIRROR(0xff00) AM_READ(dma8_ready_r)
AM_RANGE(0x0010, 0x0010) AM_MIRROR(0xff00) AM_READWRITE(ctrl16_r, ctrl16_w)
AM_RANGE(0x0013, 0x0013) AM_MIRROR(0xff00) AM_WRITE(dma16_len_lo_w)
AM_RANGE(0x0014, 0x0014) AM_MIRROR(0xff00) AM_WRITE(dma16_len_hi_w)
AM_RANGE(0x0016, 0x0016) AM_MIRROR(0xff00) AM_READWRITE(adc_fifo_ctrl_r, adc_fifo_ctrl_w)
AM_RANGE(0x0017, 0x0017) AM_MIRROR(0xff00) AM_READ(adc_data_ready_r)
AM_RANGE(0x0019, 0x0019) AM_MIRROR(0xff00) AM_WRITE(dac_data_w)
AM_RANGE(0x001B, 0x001B) AM_MIRROR(0xff00) AM_READ(adc_data_r)
AM_RANGE(0x001D, 0x001D) AM_MIRROR(0xff00) AM_WRITE(dma8_w)
AM_RANGE(0x001F, 0x001F) AM_MIRROR(0xff00) AM_READ(dma8_r)
map(0x0008, 0x0008).mirror(0xff00).rw(this, FUNC(sb16_lle_device::ctrl8_r), FUNC(sb16_lle_device::ctrl8_w));
map(0x0009, 0x0009).mirror(0xff00).w(this, FUNC(sb16_lle_device::rate_w));
map(0x000A, 0x000A).mirror(0xff00).r(this, FUNC(sb16_lle_device::dma8_cnt_lo_r));
map(0x000B, 0x000B).mirror(0xff00).w(this, FUNC(sb16_lle_device::dma8_len_lo_w));
map(0x000C, 0x000C).mirror(0xff00).w(this, FUNC(sb16_lle_device::dma8_len_hi_w));
map(0x000D, 0x000D).mirror(0xff00).r(this, FUNC(sb16_lle_device::dma8_cnt_hi_r));
map(0x000E, 0x000E).mirror(0xff00).rw(this, FUNC(sb16_lle_device::dac_fifo_ctrl_r), FUNC(sb16_lle_device::dac_fifo_ctrl_w));
map(0x000F, 0x000F).mirror(0xff00).r(this, FUNC(sb16_lle_device::dma8_ready_r));
map(0x0010, 0x0010).mirror(0xff00).rw(this, FUNC(sb16_lle_device::ctrl16_r), FUNC(sb16_lle_device::ctrl16_w));
map(0x0013, 0x0013).mirror(0xff00).w(this, FUNC(sb16_lle_device::dma16_len_lo_w));
map(0x0014, 0x0014).mirror(0xff00).w(this, FUNC(sb16_lle_device::dma16_len_hi_w));
map(0x0016, 0x0016).mirror(0xff00).rw(this, FUNC(sb16_lle_device::adc_fifo_ctrl_r), FUNC(sb16_lle_device::adc_fifo_ctrl_w));
map(0x0017, 0x0017).mirror(0xff00).r(this, FUNC(sb16_lle_device::adc_data_ready_r));
map(0x0019, 0x0019).mirror(0xff00).w(this, FUNC(sb16_lle_device::dac_data_w));
map(0x001B, 0x001B).mirror(0xff00).r(this, FUNC(sb16_lle_device::adc_data_r));
map(0x001D, 0x001D).mirror(0xff00).w(this, FUNC(sb16_lle_device::dma8_w));
map(0x001F, 0x001F).mirror(0xff00).r(this, FUNC(sb16_lle_device::dma8_r));
// AM_RANGE(0x0080, 0x0080) // ASP comms
// AM_RANGE(0x0081, 0x0081)
// AM_RANGE(0x0082, 0x0082)
ADDRESS_MAP_END
}
const tiny_rom_entry *sb16_lle_device::device_rom_region() const
{

24
src/devices/bus/isa/stereo_fx.cpp
View File

@ -93,19 +93,21 @@ ROM_START( stereo_fx )
ROM_LOAD("ati_stereo_fx.bin", 0x0000, 0x8000, CRC(1bebffa6) SHA1(e66c2619a6c05199554b5702d67877ae3799d415))
ROM_END
ADDRESS_MAP_START(stereo_fx_device::stereo_fx_io)
AM_RANGE(0xFF00, 0xFF00) AM_WRITE(port00_w)
AM_RANGE(0xFF10, 0xFF10) AM_DEVWRITE("rdac", dac_byte_interface, write)
AM_RANGE(0xFF20, 0xFF20) AM_WRITE(port20_w)
void stereo_fx_device::stereo_fx_io(address_map &map)
{
map(0xFF00, 0xFF00).w(this, FUNC(stereo_fx_device::port00_w));
map(0xFF10, 0xFF10).w("rdac", FUNC(dac_byte_interface::write));
map(0xFF20, 0xFF20).w(this, FUNC(stereo_fx_device::port20_w));
//AM_RANGE(0xFF30, 0xFF30) AM_WRITE() // used only on reset and undocumented cmd 0xc4
AM_RANGE(0xFF40, 0xFF40) AM_READWRITE(dev_dsp_data_r, dev_dsp_data_w)
AM_RANGE(0xFF50, 0xFF50) AM_WRITE(raise_drq_w)
AM_RANGE(0xFF60, 0xFF60) AM_WRITE(dev_host_irq_w)
ADDRESS_MAP_END
map(0xFF40, 0xFF40).rw(this, FUNC(stereo_fx_device::dev_dsp_data_r), FUNC(stereo_fx_device::dev_dsp_data_w));
map(0xFF50, 0xFF50).w(this, FUNC(stereo_fx_device::raise_drq_w));
map(0xFF60, 0xFF60).w(this, FUNC(stereo_fx_device::dev_host_irq_w));
}
ADDRESS_MAP_START(stereo_fx_device::stereo_fx_rom)
AM_RANGE(0x0000, 0x7fff) AM_ROM
ADDRESS_MAP_END
void stereo_fx_device::stereo_fx_rom(address_map &map)
{
map(0x0000, 0x7fff).rom();
}
const tiny_rom_entry *stereo_fx_device::device_rom_region() const
{

7
src/devices/bus/isa/wdxt_gen.cpp
View File

@ -92,9 +92,10 @@ const tiny_rom_entry *wdxt_gen_device::device_rom_region() const
// ADDRESS_MAP( wd1015_io )
//-------------------------------------------------
ADDRESS_MAP_START(wdxt_gen_device::wd1015_io)
AM_RANGE(0x00, 0xff) AM_DEVREADWRITE(WD11C00_17_TAG, wd11c00_17_device, read, write)
ADDRESS_MAP_END
void wdxt_gen_device::wd1015_io(address_map &map)
{
map(0x00, 0xff).rw(WD11C00_17_TAG, FUNC(wd11c00_17_device::read), FUNC(wd11c00_17_device::write));
}
//-------------------------------------------------

51
src/devices/bus/kc/d004.cpp
View File

@ -22,32 +22,35 @@
IMPLEMENTATION
***************************************************************************/
ADDRESS_MAP_START(kc_d004_device::kc_d004_mem)
AM_RANGE(0x0000, 0xfbff) AM_RAM
AM_RANGE(0xfc00, 0xffff) AM_RAM AM_SHARE("koppelram")
ADDRESS_MAP_END
void kc_d004_device::kc_d004_mem(address_map &map)
{
map(0x0000, 0xfbff).ram();
map(0xfc00, 0xffff).ram().share("koppelram");
}
ADDRESS_MAP_START(kc_d004_device::kc_d004_io)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE(0xf0, 0xf1) AM_DEVICE(UPD765_TAG, upd765a_device, map)
AM_RANGE(0xf2, 0xf3) AM_DEVREADWRITE(UPD765_TAG, upd765a_device, mdma_r, mdma_w)
AM_RANGE(0xf4, 0xf4) AM_READ(hw_input_gate_r)
AM_RANGE(0xf6, 0xf7) AM_WRITE(fdd_select_w)
AM_RANGE(0xf8, 0xf9) AM_WRITE(hw_terminal_count_w)
AM_RANGE(0xfc, 0xff) AM_DEVREADWRITE(Z80CTC_TAG, z80ctc_device, read, write)
ADDRESS_MAP_END
void kc_d004_device::kc_d004_io(address_map &map)
{
map.unmap_value_high();
map.global_mask(0xff);
map(0xf0, 0xf1).m(UPD765_TAG, FUNC(upd765a_device::map));
map(0xf2, 0xf3).rw(UPD765_TAG, FUNC(upd765a_device::mdma_r), FUNC(upd765a_device::mdma_w));
map(0xf4, 0xf4).r(this, FUNC(kc_d004_device::hw_input_gate_r));
map(0xf6, 0xf7).w(this, FUNC(kc_d004_device::fdd_select_w));
map(0xf8, 0xf9).w(this, FUNC(kc_d004_device::hw_terminal_count_w));
map(0xfc, 0xff).rw(Z80CTC_TAG, FUNC(z80ctc_device::read), FUNC(z80ctc_device::write));
}
ADDRESS_MAP_START(kc_d004_gide_device::kc_d004_gide_io)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x0000, 0xffff) AM_READWRITE(gide_r, gide_w)
AM_RANGE(0x00f0, 0x00f1) AM_MIRROR(0xff00) AM_DEVICE(UPD765_TAG, upd765a_device, map)
AM_RANGE(0x00f2, 0x00f3) AM_MIRROR(0xff00) AM_DEVREADWRITE(UPD765_TAG, upd765a_device, mdma_r, mdma_w)
AM_RANGE(0x00f4, 0x00f4) AM_MIRROR(0xff00) AM_READ(hw_input_gate_r)
AM_RANGE(0x00f6, 0x00f7) AM_MIRROR(0xff00) AM_WRITE(fdd_select_w)
AM_RANGE(0x00f8, 0x00f9) AM_MIRROR(0xff00) AM_WRITE(hw_terminal_count_w)
AM_RANGE(0x00fc, 0x00ff) AM_MIRROR(0xff00) AM_DEVREADWRITE(Z80CTC_TAG, z80ctc_device, read, write)
ADDRESS_MAP_END
void kc_d004_gide_device::kc_d004_gide_io(address_map &map)
{
map.unmap_value_high();
map(0x0000, 0xffff).rw(this, FUNC(kc_d004_gide_device::gide_r), FUNC(kc_d004_gide_device::gide_w));
map(0x00f0, 0x00f1).mirror(0xff00).m(UPD765_TAG, FUNC(upd765a_device::map));
map(0x00f2, 0x00f3).mirror(0xff00).rw(UPD765_TAG, FUNC(upd765a_device::mdma_r), FUNC(upd765a_device::mdma_w));
map(0x00f4, 0x00f4).mirror(0xff00).r(this, FUNC(kc_d004_gide_device::hw_input_gate_r));
map(0x00f6, 0x00f7).mirror(0xff00).w(this, FUNC(kc_d004_gide_device::fdd_select_w));
map(0x00f8, 0x00f9).mirror(0xff00).w(this, FUNC(kc_d004_gide_device::hw_terminal_count_w));
map(0x00fc, 0x00ff).mirror(0xff00).rw(Z80CTC_TAG, FUNC(z80ctc_device::read), FUNC(z80ctc_device::write));
}
FLOPPY_FORMATS_MEMBER( kc_d004_device::floppy_formats )
FLOPPY_KC85_FORMAT

30
src/devices/bus/megadrive/svp.cpp
View File

@ -318,27 +318,29 @@ INPUT_PORTS_END
// ADDRESS_MAP( svp_ssp_map )
//-------------------------------------------------
ADDRESS_MAP_START(md_rom_svp_device::md_svp_ssp_map)
void md_rom_svp_device::md_svp_ssp_map(address_map &map)
{
// AM_RANGE(0x0000, 0x03ff) AM_READ(rom_read1)
// AM_RANGE(0x0400, 0xffff) AM_READ(rom_read2)
AM_RANGE(0x0000, 0x03ff) AM_ROMBANK("iram_svp")
AM_RANGE(0x0400, 0xffff) AM_ROMBANK("cart_svp")
ADDRESS_MAP_END
map(0x0000, 0x03ff).bankr("iram_svp");
map(0x0400, 0xffff).bankr("cart_svp");
}
//-------------------------------------------------
// ADDRESS_MAP( svp_ext_map )
//-------------------------------------------------
ADDRESS_MAP_START(md_rom_svp_device::md_svp_ext_map)
ADDRESS_MAP_GLOBAL_MASK(0xf)
AM_RANGE(0*2, 0*2+1) AM_READWRITE(read_pm0, write_pm0)
AM_RANGE(1*2, 1*2+1) AM_READWRITE(read_pm1, write_pm1)
AM_RANGE(2*2, 2*2+1) AM_READWRITE(read_pm2, write_pm2)
AM_RANGE(3*2, 3*2+1) AM_READWRITE(read_xst, write_xst)
AM_RANGE(4*2, 4*2+1) AM_READWRITE(read_pm4, write_pm4)
AM_RANGE(6*2, 6*2+1) AM_READWRITE(read_pmc, write_pmc)
AM_RANGE(7*2, 7*2+1) AM_READWRITE(read_al, write_al)
ADDRESS_MAP_END
void md_rom_svp_device::md_svp_ext_map(address_map &map)
{
map.global_mask(0xf);
map(0*2, 0*2+1).rw(this, FUNC(md_rom_svp_device::read_pm0), FUNC(md_rom_svp_device::write_pm0));
map(1*2, 1*2+1).rw(this, FUNC(md_rom_svp_device::read_pm1), FUNC(md_rom_svp_device::write_pm1));
map(2*2, 2*2+1).rw(this, FUNC(md_rom_svp_device::read_pm2), FUNC(md_rom_svp_device::write_pm2));
map(3*2, 3*2+1).rw(this, FUNC(md_rom_svp_device::read_xst), FUNC(md_rom_svp_device::write_xst));
map(4*2, 4*2+1).rw(this, FUNC(md_rom_svp_device::read_pm4), FUNC(md_rom_svp_device::write_pm4));
map(6*2, 6*2+1).rw(this, FUNC(md_rom_svp_device::read_pmc), FUNC(md_rom_svp_device::write_pmc));
map(7*2, 7*2+1).rw(this, FUNC(md_rom_svp_device::read_al), FUNC(md_rom_svp_device::write_al));
}
//-------------------------------------------------

9
src/devices/bus/msx_cart/bm_012.cpp
View File

@ -32,10 +32,11 @@ msx_cart_bm_012_device::msx_cart_bm_012_device(const machine_config &mconfig, co
}
ADDRESS_MAP_START(msx_cart_bm_012_device::bm_012_memory_map)
AM_RANGE(0x0000, 0x7fff) AM_ROM
AM_RANGE(0xe000, 0xffff) AM_RAM
ADDRESS_MAP_END
void msx_cart_bm_012_device::bm_012_memory_map(address_map &map)
{
map(0x0000, 0x7fff).rom();
map(0xe000, 0xffff).ram();
}
MACHINE_CONFIG_START(msx_cart_bm_012_device::device_add_mconfig)

7
src/devices/bus/msx_cart/konami.cpp
View File

@ -866,9 +866,10 @@ msx_cart_keyboard_master_device::msx_cart_keyboard_master_device(const machine_c
}
ADDRESS_MAP_START(msx_cart_keyboard_master_device::vlm_map)
AM_RANGE(0x0000, 0xffff) AM_READ(read_vlm)
ADDRESS_MAP_END
void msx_cart_keyboard_master_device::vlm_map(address_map &map)
{
map(0x0000, 0xffff).r(this, FUNC(msx_cart_keyboard_master_device::read_vlm));
}
MACHINE_CONFIG_START(msx_cart_keyboard_master_device::device_add_mconfig)

9
src/devices/bus/msx_cart/moonsound.cpp
View File

@ -29,10 +29,11 @@ msx_cart_moonsound_device::msx_cart_moonsound_device(const machine_config &mconf
}
ADDRESS_MAP_START(msx_cart_moonsound_device::ymf278b_map)
AM_RANGE(0x000000, 0x1fffff) AM_ROM
AM_RANGE(0x200000, 0x3fffff) AM_RAM // 2MB sram for testing
ADDRESS_MAP_END
void msx_cart_moonsound_device::ymf278b_map(address_map &map)
{
map(0x000000, 0x1fffff).rom();
map(0x200000, 0x3fffff).ram(); // 2MB sram for testing
}
MACHINE_CONFIG_START(msx_cart_moonsound_device::device_add_mconfig)

24
src/devices/bus/newbrain/fdc.cpp
View File

@ -69,23 +69,25 @@ const tiny_rom_entry *newbrain_fdc_device::device_rom_region() const
// ADDRESS_MAP( newbrain_fdc_mem )
//-------------------------------------------------
ADDRESS_MAP_START(newbrain_fdc_device::newbrain_fdc_mem)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x0000, 0x1fff) AM_ROM
ADDRESS_MAP_END
void newbrain_fdc_device::newbrain_fdc_mem(address_map &map)
{
map.unmap_value_high();
map(0x0000, 0x1fff).rom();
}
//-------------------------------------------------
// ADDRESS_MAP( newbrain_fdc_io )
//-------------------------------------------------
ADDRESS_MAP_START(newbrain_fdc_device::newbrain_fdc_io)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_GLOBAL_MASK(0x71)
AM_RANGE(0x00, 0x01) AM_MIRROR(0x10) AM_DEVICE(UPD765_TAG, upd765a_device, map)
AM_RANGE(0x20, 0x20) AM_MIRROR(0x11) AM_WRITE(fdc_auxiliary_w)
AM_RANGE(0x40, 0x40) AM_MIRROR(0x11) AM_READ(fdc_control_r)
ADDRESS_MAP_END
void newbrain_fdc_device::newbrain_fdc_io(address_map &map)
{
map.unmap_value_high();
map.global_mask(0x71);
map(0x00, 0x01).mirror(0x10).m(UPD765_TAG, FUNC(upd765a_device::map));
map(0x20, 0x20).mirror(0x11).w(this, FUNC(newbrain_fdc_device::fdc_auxiliary_w));
map(0x40, 0x40).mirror(0x11).r(this, FUNC(newbrain_fdc_device::fdc_control_r));
}
//-------------------------------------------------

16
src/devices/bus/odyssey2/chess.cpp
View File

@ -29,14 +29,16 @@ o2_chess_device::o2_chess_device(const machine_config &mconfig, const char *tag,
}
ADDRESS_MAP_START(o2_chess_device::chess_mem)
AM_RANGE(0x0000, 0x07ff) AM_READ(read_rom04)
ADDRESS_MAP_END
void o2_chess_device::chess_mem(address_map &map)
{
map(0x0000, 0x07ff).r(this, FUNC(o2_chess_device::read_rom04));
}
ADDRESS_MAP_START(o2_chess_device::chess_io)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_GLOBAL_MASK(0xff)
ADDRESS_MAP_END
void o2_chess_device::chess_io(address_map &map)
{
map.unmap_value_high();
map.global_mask(0xff);
}
//-------------------------------------------------

7
src/devices/bus/pc_kbd/iskr1030.cpp
View File

@ -61,9 +61,10 @@ const tiny_rom_entry *iskr_1030_keyboard_device::device_rom_region() const
// ADDRESS_MAP( kb_io )
//-------------------------------------------------
ADDRESS_MAP_START(iskr_1030_keyboard_device::iskr_1030_keyboard_io)
AM_RANGE(0x00, 0xff) AM_READWRITE(ram_r, ram_w)
ADDRESS_MAP_END
void iskr_1030_keyboard_device::iskr_1030_keyboard_io(address_map &map)
{
map(0x00, 0xff).rw(this, FUNC(iskr_1030_keyboard_device::ram_r), FUNC(iskr_1030_keyboard_device::ram_w));
}
//-------------------------------------------------

14
src/devices/bus/pc_kbd/keytro.cpp
View File

@ -344,13 +344,15 @@ DEFINE_DEVICE_TYPE(PC_KBD_KEYTRONIC_PC3270_AT, pc_kbd_keytronic_pc3270_at_device
ADDRESS MAPS
*****************************************************************************/
ADDRESS_MAP_START(pc_kbd_keytronic_pc3270_device::keytronic_pc3270_program)
AM_RANGE(0x0000, 0x0fff) AM_ROM AM_REGION("kb_keytr", 0)
ADDRESS_MAP_END
void pc_kbd_keytronic_pc3270_device::keytronic_pc3270_program(address_map &map)
{
map(0x0000, 0x0fff).rom().region("kb_keytr", 0);
}
ADDRESS_MAP_START(pc_kbd_keytronic_pc3270_device::keytronic_pc3270_io)
AM_RANGE(0x0000, 0xffff) AM_READWRITE(internal_data_read, internal_data_write)
ADDRESS_MAP_END
void pc_kbd_keytronic_pc3270_device::keytronic_pc3270_io(address_map &map)
{
map(0x0000, 0xffff).rw(this, FUNC(pc_kbd_keytronic_pc3270_device::internal_data_read), FUNC(pc_kbd_keytronic_pc3270_device::internal_data_write));
}
/***************************************************************************

18
src/devices/bus/pet/hsg.cpp
View File

@ -69,20 +69,22 @@ const tiny_rom_entry *cbm8000_hsg_device::device_rom_region() const
// ADDRESS_MAP( hsg_a_map )
//-------------------------------------------------
ADDRESS_MAP_START(cbm8000_hsg_a_device::hsg_a_map)
ADDRESS_MAP_GLOBAL_MASK(0x7fff)
AM_RANGE(0x0000, 0x7fff) AM_RAM
ADDRESS_MAP_END
void cbm8000_hsg_a_device::hsg_a_map(address_map &map)
{
map.global_mask(0x7fff);
map(0x0000, 0x7fff).ram();
}
//-------------------------------------------------
// ADDRESS_MAP( hsg_b_map )
//-------------------------------------------------
ADDRESS_MAP_START(cbm8000_hsg_b_device::hsg_b_map)
ADDRESS_MAP_GLOBAL_MASK(0x3fff)
AM_RANGE(0x0000, 0x3fff) AM_RAM
ADDRESS_MAP_END
void cbm8000_hsg_b_device::hsg_b_map(address_map &map)
{
map.global_mask(0x3fff);
map(0x0000, 0x3fff).ram();
}
//-------------------------------------------------

7
src/devices/bus/pet/superpet.cpp
View File

@ -60,9 +60,10 @@ const tiny_rom_entry *superpet_device::device_rom_region() const
// ADDRESS_MAP( superpet_mem )
//-------------------------------------------------
ADDRESS_MAP_START(superpet_device::superpet_mem)
AM_RANGE(0x0000, 0xffff) AM_READWRITE(read, write)
ADDRESS_MAP_END
void superpet_device::superpet_mem(address_map &map)
{
map(0x0000, 0xffff).rw(this, FUNC(superpet_device::read), FUNC(superpet_device::write));
}
//-------------------------------------------------

11
src/devices/bus/plus4/c1551.cpp
View File

@ -313,11 +313,12 @@ WRITE8_MEMBER( c1551_device::tpi1_pc_w )
// ADDRESS_MAP( c1551_mem )
//-------------------------------------------------
ADDRESS_MAP_START(c1551_device::c1551_mem)
AM_RANGE(0x0000, 0x07ff) AM_MIRROR(0x0800) AM_RAM
AM_RANGE(0x4000, 0x4007) AM_MIRROR(0x3ff8) AM_READWRITE(tpi0_r, tpi0_w)
AM_RANGE(0xc000, 0xffff) AM_ROM AM_REGION(M6510T_TAG, 0)
ADDRESS_MAP_END
void c1551_device::c1551_mem(address_map &map)
{
map(0x0000, 0x07ff).mirror(0x0800).ram();
map(0x4000, 0x4007).mirror(0x3ff8).rw(this, FUNC(c1551_device::tpi0_r), FUNC(c1551_device::tpi0_w));
map(0xc000, 0xffff).rom().region(M6510T_TAG, 0);
}
//-------------------------------------------------

12
src/devices/bus/psi_kbd/ergoline.cpp
View File

@ -22,12 +22,14 @@ DEFINE_DEVICE_TYPE(ERGOLINE_KEYBOARD, ergoline_keyboard_device, "ergoline_kbd",
// address_map - device-specific address maps
//-------------------------------------------------
ADDRESS_MAP_START(ergoline_keyboard_device::kbd_mem)
AM_RANGE(0x0000, 0x0fff) AM_ROM AM_REGION("firmware", 0)
ADDRESS_MAP_END
void ergoline_keyboard_device::kbd_mem(address_map &map)
{
map(0x0000, 0x0fff).rom().region("firmware", 0);
}
ADDRESS_MAP_START(ergoline_keyboard_device::kbd_io)
ADDRESS_MAP_END
void ergoline_keyboard_device::kbd_io(address_map &map)
{
}
//-------------------------------------------------

12
src/devices/bus/s100/djdma.cpp
View File

@ -59,17 +59,19 @@ const tiny_rom_entry *s100_djdma_device::device_rom_region() const
// ADDRESS_MAP( djdma_mem )
//-------------------------------------------------
ADDRESS_MAP_START(s100_djdma_device::djdma_mem)
AM_RANGE(0x0000, 0x0fff) AM_ROM AM_REGION("14a", 0)
ADDRESS_MAP_END
void s100_djdma_device::djdma_mem(address_map &map)
{
map(0x0000, 0x0fff).rom().region("14a", 0);
}
//-------------------------------------------------
// ADDRESS_MAP( djdma_io )
//-------------------------------------------------
ADDRESS_MAP_START(s100_djdma_device::djdma_io)
ADDRESS_MAP_END
void s100_djdma_device::djdma_io(address_map &map)
{
}
//-------------------------------------------------

38
src/devices/bus/scsi/s1410.cpp
View File

@ -133,30 +133,32 @@ const tiny_rom_entry *s1410_device::device_rom_region() const
// ADDRESS_MAP( s1410_mem )
//-------------------------------------------------
ADDRESS_MAP_START(s1410_device::s1410_mem)
AM_RANGE(0x0000, 0x0fff) AM_ROM AM_REGION(Z8400A_TAG, 0)
AM_RANGE(0x1000, 0x13ff) AM_RAM
ADDRESS_MAP_END
void s1410_device::s1410_mem(address_map &map)
{
map(0x0000, 0x0fff).rom().region(Z8400A_TAG, 0);
map(0x1000, 0x13ff).ram();
}
//-------------------------------------------------
// ADDRESS_MAP( s1410_io )
//-------------------------------------------------
ADDRESS_MAP_START(s1410_device::s1410_io)
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE(0x66, 0x66) AM_WRITENOP
AM_RANGE(0x67, 0x67) AM_WRITENOP
AM_RANGE(0x68, 0x68) AM_READNOP
AM_RANGE(0x69, 0x69) AM_WRITENOP
AM_RANGE(0x6a, 0x6a) AM_WRITENOP
AM_RANGE(0x6b, 0x6b) AM_WRITENOP
AM_RANGE(0x6c, 0x6c) AM_WRITENOP
AM_RANGE(0xa0, 0xa0) AM_NOP
AM_RANGE(0xc1, 0xc1) AM_WRITENOP
AM_RANGE(0xc2, 0xc2) AM_WRITENOP
AM_RANGE(0xc3, 0xc3) AM_WRITENOP
ADDRESS_MAP_END
void s1410_device::s1410_io(address_map &map)
{
map.global_mask(0xff);
map(0x66, 0x66).nopw();
map(0x67, 0x67).nopw();
map(0x68, 0x68).nopr();
map(0x69, 0x69).nopw();
map(0x6a, 0x6a).nopw();
map(0x6b, 0x6b).nopw();
map(0x6c, 0x6c).nopw();
map(0xa0, 0xa0).noprw();
map(0xc1, 0xc1).nopw();
map(0xc2, 0xc2).nopw();
map(0xc3, 0xc3).nopw();
}
//-------------------------------------------------

14
src/devices/bus/snes/event.cpp
View File

@ -201,18 +201,20 @@ READ16_MEMBER( sns_pfest94_device::necdsp_data_r )
// ADDRESS_MAP( dsp_prg_map )
//-------------------------------------------------
ADDRESS_MAP_START(sns_pfest94_device::dsp_prg_map_lorom)
AM_RANGE(0x0000, 0x07ff) AM_READ(necdsp_prg_r)
ADDRESS_MAP_END
void sns_pfest94_device::dsp_prg_map_lorom(address_map &map)
{
map(0x0000, 0x07ff).r(this, FUNC(sns_pfest94_device::necdsp_prg_r));
}
//-------------------------------------------------
// ADDRESS_MAP( dsp_data_map )
//-------------------------------------------------
ADDRESS_MAP_START(sns_pfest94_device::dsp_data_map_lorom)
AM_RANGE(0x0000, 0x03ff) AM_READ(necdsp_data_r)
ADDRESS_MAP_END
void sns_pfest94_device::dsp_data_map_lorom(address_map &map)
{
map(0x0000, 0x03ff).r(this, FUNC(sns_pfest94_device::necdsp_data_r));
}
//-------------------------------------------------

11
src/devices/bus/snes/sa1.cpp
View File

@ -1135,11 +1135,12 @@ WRITE8_MEMBER( sns_sa1_device::sa1_lo_w )
sa1_hi_w(space, offset, data);
}
ADDRESS_MAP_START(sns_sa1_device::sa1_map)
AM_RANGE(0x000000, 0x7dffff) AM_READWRITE(sa1_lo_r, sa1_lo_w)
AM_RANGE(0x7e0000, 0x7fffff) AM_NOP
AM_RANGE(0x800000, 0xffffff) AM_READWRITE(sa1_hi_r, sa1_hi_w)
ADDRESS_MAP_END
void sns_sa1_device::sa1_map(address_map &map)
{
map(0x000000, 0x7dffff).rw(this, FUNC(sns_sa1_device::sa1_lo_r), FUNC(sns_sa1_device::sa1_lo_w));
map(0x7e0000, 0x7fffff).noprw();
map(0x800000, 0xffffff).rw(this, FUNC(sns_sa1_device::sa1_hi_r), FUNC(sns_sa1_device::sa1_hi_w));
}
MACHINE_CONFIG_START(sns_sa1_device::device_add_mconfig)

17
src/devices/bus/snes/sfx.cpp
View File

@ -69,14 +69,15 @@ WRITE8_MEMBER( sns_rom_superfx_device::superfx_w_bank3 )
sfx_ram[offset & 0xfffff] = data;
}
ADDRESS_MAP_START(sns_rom_superfx_device::sfx_map)
AM_RANGE(0x000000, 0x3fffff) AM_READWRITE(superfx_r_bank1, superfx_w_bank1)
AM_RANGE(0x400000, 0x5fffff) AM_READWRITE(superfx_r_bank2, superfx_w_bank2)
AM_RANGE(0x600000, 0x7dffff) AM_READWRITE(superfx_r_bank3, superfx_w_bank3)
AM_RANGE(0x800000, 0xbfffff) AM_READWRITE(superfx_r_bank1, superfx_w_bank1)
AM_RANGE(0xc00000, 0xdfffff) AM_READWRITE(superfx_r_bank2, superfx_w_bank2)
AM_RANGE(0xe00000, 0xffffff) AM_READWRITE(superfx_r_bank3, superfx_w_bank3)
ADDRESS_MAP_END
void sns_rom_superfx_device::sfx_map(address_map &map)
{
map(0x000000, 0x3fffff).rw(this, FUNC(sns_rom_superfx_device::superfx_r_bank1), FUNC(sns_rom_superfx_device::superfx_w_bank1));
map(0x400000, 0x5fffff).rw(this, FUNC(sns_rom_superfx_device::superfx_r_bank2), FUNC(sns_rom_superfx_device::superfx_w_bank2));
map(0x600000, 0x7dffff).rw(this, FUNC(sns_rom_superfx_device::superfx_r_bank3), FUNC(sns_rom_superfx_device::superfx_w_bank3));
map(0x800000, 0xbfffff).rw(this, FUNC(sns_rom_superfx_device::superfx_r_bank1), FUNC(sns_rom_superfx_device::superfx_w_bank1));
map(0xc00000, 0xdfffff).rw(this, FUNC(sns_rom_superfx_device::superfx_r_bank2), FUNC(sns_rom_superfx_device::superfx_w_bank2));
map(0xe00000, 0xffffff).rw(this, FUNC(sns_rom_superfx_device::superfx_r_bank3), FUNC(sns_rom_superfx_device::superfx_w_bank3));
}
WRITE_LINE_MEMBER(sns_rom_superfx_device::snes_extern_irq_w)

28
src/devices/bus/snes/upd.cpp
View File

@ -112,18 +112,20 @@ READ16_MEMBER( sns_rom20_necdsp_device::necdsp_data_r )
// ADDRESS_MAP( dsp_prg_map )
//-------------------------------------------------
ADDRESS_MAP_START(sns_rom20_necdsp_device::dsp_prg_map_lorom)
AM_RANGE(0x0000, 0x07ff) AM_READ(necdsp_prg_r)
ADDRESS_MAP_END
void sns_rom20_necdsp_device::dsp_prg_map_lorom(address_map &map)
{
map(0x0000, 0x07ff).r(this, FUNC(sns_rom20_necdsp_device::necdsp_prg_r));
}
//-------------------------------------------------
// ADDRESS_MAP( dsp_data_map )
//-------------------------------------------------
ADDRESS_MAP_START(sns_rom20_necdsp_device::dsp_data_map_lorom)
AM_RANGE(0x0000, 0x03ff) AM_READ(necdsp_data_r)
ADDRESS_MAP_END
void sns_rom20_necdsp_device::dsp_data_map_lorom(address_map &map)
{
map(0x0000, 0x03ff).r(this, FUNC(sns_rom20_necdsp_device::necdsp_data_r));
}
//-------------------------------------------------
@ -168,18 +170,20 @@ READ16_MEMBER( sns_rom21_necdsp_device::necdsp_data_r )
// ADDRESS_MAP( dsp_prg_map )
//-------------------------------------------------
ADDRESS_MAP_START(sns_rom21_necdsp_device::dsp_prg_map_hirom)
AM_RANGE(0x0000, 0x07ff) AM_READ(necdsp_prg_r)
ADDRESS_MAP_END
void sns_rom21_necdsp_device::dsp_prg_map_hirom(address_map &map)
{
map(0x0000, 0x07ff).r(this, FUNC(sns_rom21_necdsp_device::necdsp_prg_r));
}
//-------------------------------------------------
// ADDRESS_MAP( dsp_data_map )
//-------------------------------------------------
ADDRESS_MAP_START(sns_rom21_necdsp_device::dsp_data_map_hirom)
AM_RANGE(0x0000, 0x03ff) AM_READ(necdsp_data_r)
ADDRESS_MAP_END
void sns_rom21_necdsp_device::dsp_data_map_hirom(address_map &map)
{
map(0x0000, 0x03ff).r(this, FUNC(sns_rom21_necdsp_device::necdsp_data_r));
}
//-------------------------------------------------
// device_add_mconfig - add device configuration

26
src/devices/bus/spc1000/fdd.cpp
View File

@ -55,19 +55,21 @@ WRITE8_MEMBER( spc1000_fdd_exp_device::control_w )
m_fd1->mon_w(!BIT(data, 0));
}
ADDRESS_MAP_START(spc1000_fdd_exp_device::sd725_mem)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE(0x0000, 0x1fff) AM_ROM
AM_RANGE(0x2000, 0xffff) AM_RAM
ADDRESS_MAP_END
void spc1000_fdd_exp_device::sd725_mem(address_map &map)
{
map.unmap_value_high();
map(0x0000, 0x1fff).rom();
map(0x2000, 0xffff).ram();
}
ADDRESS_MAP_START(spc1000_fdd_exp_device::sd725_io)
ADDRESS_MAP_UNMAP_HIGH
ADDRESS_MAP_GLOBAL_MASK(0xff)
AM_RANGE(0xf8, 0xf8) AM_READWRITE(tc_r, control_w) // (R) Terminal Count Port (W) Motor Control Port
AM_RANGE(0xfa, 0xfb) AM_DEVICE("upd765", upd765a_device, map)
AM_RANGE(0xfc, 0xff) AM_DEVREADWRITE("d8255_master", i8255_device, read, write)
ADDRESS_MAP_END
void spc1000_fdd_exp_device::sd725_io(address_map &map)
{
map.unmap_value_high();
map.global_mask(0xff);
map(0xf8, 0xf8).rw(this, FUNC(spc1000_fdd_exp_device::tc_r), FUNC(spc1000_fdd_exp_device::control_w)); // (R) Terminal Count Port (W) Motor Control Port
map(0xfa, 0xfb).m("upd765", FUNC(upd765a_device::map));
map(0xfc, 0xff).rw("d8255_master", FUNC(i8255_device::read), FUNC(i8255_device::write));
}
static SLOT_INTERFACE_START( sd725_floppies )
SLOT_INTERFACE("sd320", EPSON_SD_320)

18
src/devices/bus/tiki100/8088.cpp
View File

@ -49,16 +49,18 @@ const tiny_rom_entry *tiki100_8088_device::device_rom_region() const
}
ADDRESS_MAP_START(tiki100_8088_device::i8088_mem)
AM_RANGE(0x00000, 0xbffff) AM_RAM
AM_RANGE(0xc0000, 0xcffff) AM_DEVREADWRITE(":" TIKI100_BUS_TAG, tiki100_bus_device, exin_mrq_r, exin_mrq_w)
AM_RANGE(0xff000, 0xfffff) AM_ROM AM_REGION(I8088_TAG, 0)
ADDRESS_MAP_END
void tiki100_8088_device::i8088_mem(address_map &map)
{
map(0x00000, 0xbffff).ram();
map(0xc0000, 0xcffff).rw(":" TIKI100_BUS_TAG, FUNC(tiki100_bus_device::exin_mrq_r), FUNC(tiki100_bus_device::exin_mrq_w));
map(0xff000, 0xfffff).rom().region(I8088_TAG, 0);
}
ADDRESS_MAP_START(tiki100_8088_device::i8088_io)
AM_RANGE(0x7f, 0x7f) AM_READWRITE(read, write)
ADDRESS_MAP_END
void tiki100_8088_device::i8088_io(address_map &map)
{
map(0x7f, 0x7f).rw(this, FUNC(tiki100_8088_device::read), FUNC(tiki100_8088_device::write));
}
//-------------------------------------------------

5
src/devices/bus/vcs/harmony_melody.cpp
View File

@ -78,8 +78,9 @@ void a26_rom_harmony_device::device_start()
save_item(NAME(m_base_bank));
}
ADDRESS_MAP_START(a26_rom_harmony_device::harmony_arm7_map)
ADDRESS_MAP_END
void a26_rom_harmony_device::harmony_arm7_map(address_map &map)
{
}
MACHINE_CONFIG_START(a26_rom_harmony_device::device_add_mconfig)
MCFG_CPU_ADD("arm", LPC2103, 70000000)

29
src/devices/bus/vme/vme_fccpu20.cpp
View File

@ -226,20 +226,21 @@ DEFINE_DEVICE_TYPE(VME_FCCPU21YB, vme_fccpu21yb_card_device, "fccpu21yb", "Force
#define CLOCK40 XTAL(40'000'000) /* HCJ */
#define CLOCK32 XTAL(32'000'000) /* HCJ */
ADDRESS_MAP_START(vme_fccpu20_device::cpu20_mem)
ADDRESS_MAP_UNMAP_HIGH
AM_RANGE (0x00000000, 0x00000007) AM_RAM AM_WRITE (bootvect_w) /* After first write we act as RAM */
AM_RANGE (0x00000000, 0x00000007) AM_ROM AM_READ (bootvect_r) /* ROM mirror just during reset */
AM_RANGE (0x00000008, 0x0007ffff) AM_RAM /* Local SRAM */
AM_RANGE (0x00080000, 0x000fffff) AM_RAM /* SRAM-22 installed */
AM_RANGE (0xff040000, 0xff04ffff) AM_RAM
AM_RANGE (0xff000000, 0xff00ffff) AM_ROM AM_REGION("roms", 0x0000)
AM_RANGE (0xff800000, 0xff80001f) AM_DEVREADWRITE8("mpcc", mpcc68561_device, read, write, 0xffffffff)
AM_RANGE (0xff800200, 0xff80021f) AM_DEVREADWRITE8("mpcc2", mpcc68561_device, read, write, 0xffffffff)
AM_RANGE (0xff800600, 0xff80061f) AM_DEVREADWRITE8("mpcc3", mpcc68561_device, read, write, 0xffffffff)
AM_RANGE (0xff800800, 0xff80080f) AM_DEVREADWRITE8("bim", bim68153_device, read, write, 0xff00ff00)
AM_RANGE (0xff800c00, 0xff800dff) AM_DEVREADWRITE8("pit", pit68230_device, read, write, 0xffffffff)
ADDRESS_MAP_END
void vme_fccpu20_device::cpu20_mem(address_map &map)
{
map.unmap_value_high();
map(0x00000000, 0x00000007).ram().w(this, FUNC(vme_fccpu20_device::bootvect_w)); /* After first write we act as RAM */
map(0x00000000, 0x00000007).rom().r(this, FUNC(vme_fccpu20_device::bootvect_r)); /* ROM mirror just during reset */
map(0x00000008, 0x0007ffff).ram(); /* Local SRAM */
map(0x00080000, 0x000fffff).ram(); /* SRAM-22 installed */
map(0xff040000, 0xff04ffff).ram();
map(0xff000000, 0xff00ffff).rom().region("roms", 0x0000);
map(0xff800000, 0xff80001f).rw("mpcc", FUNC(mpcc68561_device::read), FUNC(mpcc68561_device::write));
map(0xff800200, 0xff80021f).rw("mpcc2", FUNC(mpcc68561_device::read), FUNC(mpcc68561_device::write));
map(0xff800600, 0xff80061f).rw("mpcc3", FUNC(mpcc68561_device::read), FUNC(mpcc68561_device::write));
map(0xff800800, 0xff80080f).rw("bim", FUNC(bim68153_device::read), FUNC(bim68153_device::write)).umask32(0xff00ff00);
map(0xff800c00, 0xff800dff).rw("pit", FUNC(pit68230_device::read), FUNC(pit68230_device::write));
}
MACHINE_CONFIG_START(vme_fccpu20_device::device_add_mconfig)

Some files were not shown because too many files have changed in this diff Show More