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

Deprecate the old memory_install_* macros. Dynamic installation is now handled

Browse Source 
directly by calling methods on the address_space, which have been expanded with
aliases to cover all previous situations. In addition, variants with no mirror
or mask value are provided to cover the common cases:

memory_install_read*_handler(space, begin, end, mirror, mask, handler) ==>
    space->install_legacy_read_handler(begin, end [, mirror, mask], FUNC(handler))

memory_install_write*_handler(space, begin, end, mirror, mask, handler) ==>
    space->install_legacy_write_handler(begin, end [, mirror, mask], FUNC(handler))

memory_install_readwrite*_handler(space, begin, end, mirror, mask, rhandler, whandler) ==>
    space->install_legacy_readwrite_handler(begin, end [, mirror, mask], FUNC(rhandler), FUNC(whandler))

memory_install_read*_device_handler(space, device, begin, end, mirror, mask, handler) ==>
    space->install_legacy_read_handler(*device, begin, end [, mirror, mask], FUNC(handler))

memory_install_write*_device_handler(space, device, begin, end, mirror, mask, handler) ==>
    space->install_legacy_write_handler(*device, begin, end [, mirror, mask], FUNC(handler))

memory_install_readwrite*_device_handler(space, device, begin, end, mirror, mask, rhandler, whandler) ==>
    space->install_legacy_readwrite_handler(*device, begin, end [, mirror, mask], FUNC(rhandler), FUNC(whandler))

memory_install_read_port(space, begin, end, mirror, mask, port) ==>
    space->install_read_port(begin, end [, mirror, mask], port)

memory_install_read_bank(space, begin, end, mirror, mask, bank) ==>
    space->install_read_bank(begin, end [, mirror, mask], bank)

memory_install_rom(space, begin, end, mirror, mask, ptr) ==>
    space->install_rom(begin, end [, mirror, mask], ptr)

memory_install_ram(space, begin, end, mirror, mask, ptr) ==>
    space->install_ram(begin, end [, mirror, mask], ptr)

memory_unmap_read(space, begin, end, mirror, mask) ==>
    space->unmap_read(begin, end [, mirror, mask])

memory_nop_read(space, begin, end, mirror, mask) ==>
    space->nop_read(begin, end [, mirror, mask])


Below are the bulk search & replace regex'es used for this

memory_install_read([0-9]+)_handler( *)\(( *)([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ )]+)( *)\)
\4->install_legacy_read_handler\2\(\3\5FUNC\(\6\)\7\)

memory_install_read([0-9]+)_handler( *)\(( *)([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ )]+)( *)\)
\4->install_legacy_read_handler\2\(\3\5FUNC\(\6\)\7\)

memory_install_write([0-9]+)_handler( *)\(( *)([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ )]+)( *)\)
\4->install_legacy_write_handler\2\(\3\5FUNC\(\6\)\7\)

memory_install_write([0-9]+)_handler( *)\(( *)([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ )]+)( *)\)
\4->install_legacy_write_handler\2\(\3\5FUNC\(\6\)\7\)

memory_install_readwrite([0-9]+)_handler( *)\(( *)([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ ,]+)( *, *)([^ )]+)( *)\)
\4->install_legacy_readwrite_handler\2\(\3\5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite([0-9]+)_handler( *)\(( *)([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ ,]+)( *, *)([^ )]+)( *)\)
\4->install_legacy_readwrite_handler\2\(\3\5FUNC\(\6\)\7FUNC\(\8\)\9\)



memory_install_read([0-9]+)_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ )]+)( *)\)
\4->install_legacy_read_handler\2\(\3\*\5, \6FUNC\(\7\)\8\)

memory_install_read([0-9]+)_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ )]+)( *)\)
\4->install_legacy_read_handler\2\(\3\*\5, \6FUNC\(\7\)\8\)

memory_install_write([0-9]+)_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ )]+)( *)\)
\4->install_legacy_write_handler\2\(\3\*\5, \6FUNC\(\7\)\8\)

memory_install_write([0-9]+)_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ )]+)( *)\)
\4->install_legacy_write_handler\2\(\3\*\5, \6FUNC\(\7\)\8\)

memory_install_readwrite8_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite8_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite16_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite16_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite32_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite32_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite64_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+, *)0 *, *0 *, *([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)

memory_install_readwrite64_device_handler( *)\(( *)([^,]+), *([^,]+), *([^,]+,[^,]+,[^,]+,[^,]+, *)([^ ,]+)( *, *)([^ )]+)( *)\)
\3->install_legacy_readwrite_handler\1\(\2\*\4, \5FUNC\(\6\)\7FUNC\(\8\)\9\)



memory_install_read_port( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_read_port\1\(\2\4,

memory_install_read_port( *)\(( *)([^,]+), *
\3->install_read_port\1\(\2

memory_install_write_port( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_write_port\1\(\2\4,

memory_install_write_port( *)\(( *)([^,]+), *
\3->install_write_port\1\(\2

memory_install_readwrite_port( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_readwrite_port\1\(\2\4,

memory_install_readwrite_port( *)\(( *)([^,]+), *
\3->install_readwrite_port\1\(\2



memory_install_read_bank( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_read_bank\1\(\2\4,

memory_install_read_bank( *)\(( *)([^,]+), *
\3->install_read_bank\1\(\2

memory_install_write_bank( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_write_bank\1\(\2\4,

memory_install_write_bank( *)\(( *)([^,]+), *
\3->install_write_bank\1\(\2

memory_install_readwrite_bank( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_readwrite_bank\1\(\2\4,

memory_install_readwrite_bank( *)\(( *)([^,]+), *
\3->install_readwrite_bank\1\(\2



memory_install_rom( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_rom\1\(\2\4,

memory_install_rom( *)\(( *)([^,]+), *
\3->install_rom\1\(\2

memory_install_ram( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_ram\1\(\2\4,

memory_install_ram( *)\(( *)([^,]+), *
\3->install_ram\1\(\2

memory_install_writeonly( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *,
\3->install_writeonly\1\(\2\4,

memory_install_writeonly( *)\(( *)([^,]+), *
\3->install_writeonly\1\(\2



memory_unmap_read( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *\)
\3->unmap_read\1\(\2\4\)

memory_unmap_read( *)\(( *)([^,]+), *
\3->unmap_read\1\(\2

memory_unmap_write( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *\)
\3->unmap_write\1\(\2\4\)

memory_unmap_write( *)\(( *)([^,]+), *
\3->unmap_write\1\(\2

memory_unmap_readwrite( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *\)
\3->unmap_readwrite\1\(\2\4\)

memory_unmap_readwrite( *)\(( *)([^,]+), *
\3->unmap_readwrite\1\(\2



memory_nop_read( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *\)
\3->nop_read\1\(\2\4\)

memory_nop_read( *)\(( *)([^,]+), *
\3->nop_read\1\(\2

memory_nop_write( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *\)
\3->nop_write\1\(\2\4\)

memory_nop_write( *)\(( *)([^,]+), *
\3->nop_write\1\(\2

memory_nop_readwrite( *)\(( *)([^,]+), *([^,]+,[^,]+), *0 *, *0 *\)
\3->nop_readwrite\1\(\2\4\)

memory_nop_readwrite( *)\(( *)([^,]+), *
\3->nop_readwrite\1\(\2
This commit is contained in:
Aaron Giles 2011-03-27 17:34:05 +00:00
parent 0b87c6e06a
commit a80dcb629b
237 changed files with 1927 additions and 1984 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/emu/cpu/mips/psx.c
View File

@ -1256,16 +1256,16 @@ void psxcpu_device::update_scratchpad()
{
if( ( m_biu & BIU_RAM ) == 0 )
{
memory_install_readwrite32_device_handler( m_program, this, 0x1f800000, 0x1f8003ff, 0, 0, psx_berr_r, psx_berr_w );
m_program->install_legacy_readwrite_handler( *this, 0x1f800000, 0x1f8003ff, FUNC(psx_berr_r), FUNC(psx_berr_w) );
}
else if( ( m_biu & BIU_DS ) == 0 )
{
memory_install_read32_device_handler( m_program, this, 0x1f800000, 0x1f8003ff, 0, 0, psx_berr_r );
memory_nop_write( m_program, 0x1f800000, 0x1f8003ff, 0, 0 );
m_program->install_legacy_read_handler( *this, 0x1f800000, 0x1f8003ff, FUNC(psx_berr_r) );
m_program->nop_write( 0x1f800000, 0x1f8003ff);
}
else
{
memory_install_ram( m_program, 0x1f800000, 0x1f8003ff, 0, 0, m_dcache );
m_program->install_ram( 0x1f800000, 0x1f8003ff, m_dcache );
}
}

44
src/emu/machine/s3c2400.c
View File

@ -47,28 +47,28 @@ DEVICE_START( s3c2400 )
{
address_space *space = device->machine->device( "maincpu")->memory().space( AS_PROGRAM);
DEVICE_START_CALL(s3c24xx);
memory_install_readwrite32_device_handler( space, device, 0x14000000, 0x1400003b, 0, 0, s3c24xx_memcon_r, s3c24xx_memcon_w);
memory_install_readwrite32_device_handler( space, device, 0x14200000, 0x1420005b, 0, 0, s3c24xx_usb_host_r, s3c24xx_usb_host_w);
memory_install_readwrite32_device_handler( space, device, 0x14400000, 0x14400017, 0, 0, s3c24xx_irq_r, s3c24xx_irq_w);
memory_install_readwrite32_device_handler( space, device, 0x14600000, 0x1460001b, 0, 0, s3c24xx_dma_0_r, s3c24xx_dma_0_w);
memory_install_readwrite32_device_handler( space, device, 0x14600020, 0x1460003b, 0, 0, s3c24xx_dma_1_r, s3c24xx_dma_1_w);
memory_install_readwrite32_device_handler( space, device, 0x14600040, 0x1460005b, 0, 0, s3c24xx_dma_2_r, s3c24xx_dma_2_w);
memory_install_readwrite32_device_handler( space, device, 0x14600060, 0x1460007b, 0, 0, s3c24xx_dma_3_r, s3c24xx_dma_3_w);
memory_install_readwrite32_device_handler( space, device, 0x14800000, 0x14800017, 0, 0, s3c24xx_clkpow_r, s3c24xx_clkpow_w);
memory_install_readwrite32_device_handler( space, device, 0x14a00000, 0x14a003ff, 0, 0, s3c2400_lcd_r, s3c24xx_lcd_w);
memory_install_readwrite32_device_handler( space, device, 0x14a00400, 0x14a007ff, 0, 0, s3c24xx_lcd_palette_r, s3c24xx_lcd_palette_w);
memory_install_readwrite32_device_handler( space, device, 0x15000000, 0x1500002b, 0, 0, s3c24xx_uart_0_r, s3c24xx_uart_0_w);
memory_install_readwrite32_device_handler( space, device, 0x15004000, 0x1500402b, 0, 0, s3c24xx_uart_1_r, s3c24xx_uart_1_w);
memory_install_readwrite32_device_handler( space, device, 0x15100000, 0x15100043, 0, 0, s3c24xx_pwm_r, s3c24xx_pwm_w);
memory_install_readwrite32_device_handler( space, device, 0x15200140, 0x152001fb, 0, 0, s3c24xx_usb_device_r, s3c24xx_usb_device_w);
memory_install_readwrite32_device_handler( space, device, 0x15300000, 0x1530000b, 0, 0, s3c24xx_wdt_r, s3c24xx_wdt_w);
memory_install_readwrite32_device_handler( space, device, 0x15400000, 0x1540000f, 0, 0, s3c24xx_iic_r, s3c24xx_iic_w);
memory_install_readwrite32_device_handler( space, device, 0x15508000, 0x15508013, 0, 0, s3c24xx_iis_r, s3c24xx_iis_w);
memory_install_readwrite32_device_handler( space, device, 0x15600000, 0x1560005b, 0, 0, s3c24xx_gpio_r, s3c24xx_gpio_w);
memory_install_readwrite32_device_handler( space, device, 0x15700040, 0x1570008b, 0, 0, s3c24xx_rtc_r, s3c24xx_rtc_w);
memory_install_readwrite32_device_handler( space, device, 0x15800000, 0x15800007, 0, 0, s3c24xx_adc_r, s3c24xx_adc_w);
memory_install_readwrite32_device_handler( space, device, 0x15900000, 0x15900017, 0, 0, s3c24xx_spi_0_r, s3c24xx_spi_0_w);
memory_install_readwrite32_device_handler( space, device, 0x15a00000, 0x15a0003f, 0, 0, s3c24xx_mmc_r, s3c24xx_mmc_w);
space->install_legacy_readwrite_handler( *device, 0x14000000, 0x1400003b, FUNC(s3c24xx_memcon_r), FUNC(s3c24xx_memcon_w));
space->install_legacy_readwrite_handler( *device, 0x14200000, 0x1420005b, FUNC(s3c24xx_usb_host_r), FUNC(s3c24xx_usb_host_w));
space->install_legacy_readwrite_handler( *device, 0x14400000, 0x14400017, FUNC(s3c24xx_irq_r), FUNC(s3c24xx_irq_w));
space->install_legacy_readwrite_handler( *device, 0x14600000, 0x1460001b, FUNC(s3c24xx_dma_0_r), FUNC(s3c24xx_dma_0_w));
space->install_legacy_readwrite_handler( *device, 0x14600020, 0x1460003b, FUNC(s3c24xx_dma_1_r), FUNC(s3c24xx_dma_1_w));
space->install_legacy_readwrite_handler( *device, 0x14600040, 0x1460005b, FUNC(s3c24xx_dma_2_r), FUNC(s3c24xx_dma_2_w));
space->install_legacy_readwrite_handler( *device, 0x14600060, 0x1460007b, FUNC(s3c24xx_dma_3_r), FUNC(s3c24xx_dma_3_w));
space->install_legacy_readwrite_handler( *device, 0x14800000, 0x14800017, FUNC(s3c24xx_clkpow_r), FUNC(s3c24xx_clkpow_w));
space->install_legacy_readwrite_handler( *device, 0x14a00000, 0x14a003ff, FUNC(s3c2400_lcd_r), FUNC(s3c24xx_lcd_w));
space->install_legacy_readwrite_handler( *device, 0x14a00400, 0x14a007ff, FUNC(s3c24xx_lcd_palette_r), FUNC(s3c24xx_lcd_palette_w));
space->install_legacy_readwrite_handler( *device, 0x15000000, 0x1500002b, FUNC(s3c24xx_uart_0_r), FUNC(s3c24xx_uart_0_w));
space->install_legacy_readwrite_handler( *device, 0x15004000, 0x1500402b, FUNC(s3c24xx_uart_1_r), FUNC(s3c24xx_uart_1_w));
space->install_legacy_readwrite_handler( *device, 0x15100000, 0x15100043, FUNC(s3c24xx_pwm_r), FUNC(s3c24xx_pwm_w));
space->install_legacy_readwrite_handler( *device, 0x15200140, 0x152001fb, FUNC(s3c24xx_usb_device_r), FUNC(s3c24xx_usb_device_w));
space->install_legacy_readwrite_handler( *device, 0x15300000, 0x1530000b, FUNC(s3c24xx_wdt_r), FUNC(s3c24xx_wdt_w));
space->install_legacy_readwrite_handler( *device, 0x15400000, 0x1540000f, FUNC(s3c24xx_iic_r), FUNC(s3c24xx_iic_w));
space->install_legacy_readwrite_handler( *device, 0x15508000, 0x15508013, FUNC(s3c24xx_iis_r), FUNC(s3c24xx_iis_w));
space->install_legacy_readwrite_handler( *device, 0x15600000, 0x1560005b, FUNC(s3c24xx_gpio_r), FUNC(s3c24xx_gpio_w));
space->install_legacy_readwrite_handler( *device, 0x15700040, 0x1570008b, FUNC(s3c24xx_rtc_r), FUNC(s3c24xx_rtc_w));
space->install_legacy_readwrite_handler( *device, 0x15800000, 0x15800007, FUNC(s3c24xx_adc_r), FUNC(s3c24xx_adc_w));
space->install_legacy_readwrite_handler( *device, 0x15900000, 0x15900017, FUNC(s3c24xx_spi_0_r), FUNC(s3c24xx_spi_0_w));
space->install_legacy_readwrite_handler( *device, 0x15a00000, 0x15a0003f, FUNC(s3c24xx_mmc_r), FUNC(s3c24xx_mmc_w));
}
DEVICE_GET_INFO( s3c2400 )

50
src/emu/machine/s3c2410.c
View File

@ -47,31 +47,31 @@ DEVICE_START( s3c2410 )
{
address_space *space = device->machine->device( "maincpu")->memory().space( AS_PROGRAM);
DEVICE_START_CALL(s3c24xx);
memory_install_readwrite32_device_handler( space, device, 0x48000000, 0x4800003b, 0, 0, s3c24xx_memcon_r, s3c24xx_memcon_w);
memory_install_readwrite32_device_handler( space, device, 0x49000000, 0x4900005b, 0, 0, s3c24xx_usb_host_r, s3c24xx_usb_host_w);
memory_install_readwrite32_device_handler( space, device, 0x4a000000, 0x4a00001f, 0, 0, s3c24xx_irq_r, s3c24xx_irq_w);
memory_install_readwrite32_device_handler( space, device, 0x4b000000, 0x4b000023, 0, 0, s3c24xx_dma_0_r, s3c24xx_dma_0_w);
memory_install_readwrite32_device_handler( space, device, 0x4b000040, 0x4b000063, 0, 0, s3c24xx_dma_1_r, s3c24xx_dma_1_w);
memory_install_readwrite32_device_handler( space, device, 0x4b000080, 0x4b0000a3, 0, 0, s3c24xx_dma_2_r, s3c24xx_dma_2_w);
memory_install_readwrite32_device_handler( space, device, 0x4b0000c0, 0x4b0000e3, 0, 0, s3c24xx_dma_3_r, s3c24xx_dma_3_w);
memory_install_readwrite32_device_handler( space, device, 0x4c000000, 0x4c000017, 0, 0, s3c24xx_clkpow_r, s3c24xx_clkpow_w);
memory_install_readwrite32_device_handler( space, device, 0x4d000000, 0x4d000063, 0, 0, s3c2410_lcd_r, s3c24xx_lcd_w);
memory_install_readwrite32_device_handler( space, device, 0x4d000400, 0x4d0007ff, 0, 0, s3c24xx_lcd_palette_r, s3c24xx_lcd_palette_w);
memory_install_readwrite32_device_handler( space, device, 0x4e000000, 0x4e000017, 0, 0, s3c24xx_nand_r, s3c24xx_nand_w);
memory_install_readwrite32_device_handler( space, device, 0x50000000, 0x5000002b, 0, 0, s3c24xx_uart_0_r, s3c24xx_uart_0_w);
memory_install_readwrite32_device_handler( space, device, 0x50004000, 0x5000402b, 0, 0, s3c24xx_uart_1_r, s3c24xx_uart_1_w);
memory_install_readwrite32_device_handler( space, device, 0x50008000, 0x5000802b, 0, 0, s3c24xx_uart_2_r, s3c24xx_uart_2_w);
memory_install_readwrite32_device_handler( space, device, 0x51000000, 0x51000043, 0, 0, s3c24xx_pwm_r, s3c24xx_pwm_w);
memory_install_readwrite32_device_handler( space, device, 0x52000140, 0x5200026f, 0, 0, s3c24xx_usb_device_r, s3c24xx_usb_device_w);
memory_install_readwrite32_device_handler( space, device, 0x53000000, 0x5300000b, 0, 0, s3c24xx_wdt_r, s3c24xx_wdt_w);
memory_install_readwrite32_device_handler( space, device, 0x54000000, 0x5400000f, 0, 0, s3c24xx_iic_r, s3c24xx_iic_w);
memory_install_readwrite32_device_handler( space, device, 0x55000000, 0x55000013, 0, 0, s3c24xx_iis_r, s3c24xx_iis_w);
memory_install_readwrite32_device_handler( space, device, 0x56000000, 0x560000bf, 0, 0, s3c24xx_gpio_r, s3c24xx_gpio_w);
memory_install_readwrite32_device_handler( space, device, 0x57000040, 0x5700008b, 0, 0, s3c24xx_rtc_r, s3c24xx_rtc_w);
memory_install_readwrite32_device_handler( space, device, 0x58000000, 0x58000013, 0, 0, s3c24xx_adc_r, s3c24xx_adc_w);
memory_install_readwrite32_device_handler( space, device, 0x59000000, 0x59000017, 0, 0, s3c24xx_spi_0_r, s3c24xx_spi_0_w);
memory_install_readwrite32_device_handler( space, device, 0x59000020, 0x59000037, 0, 0, s3c24xx_spi_1_r, s3c24xx_spi_1_w);
memory_install_readwrite32_device_handler( space, device, 0x5a000000, 0x5a000043, 0, 0, s3c24xx_sdi_r, s3c24xx_sdi_w);
space->install_legacy_readwrite_handler( *device, 0x48000000, 0x4800003b, FUNC(s3c24xx_memcon_r), FUNC(s3c24xx_memcon_w));
space->install_legacy_readwrite_handler( *device, 0x49000000, 0x4900005b, FUNC(s3c24xx_usb_host_r), FUNC(s3c24xx_usb_host_w));
space->install_legacy_readwrite_handler( *device, 0x4a000000, 0x4a00001f, FUNC(s3c24xx_irq_r), FUNC(s3c24xx_irq_w));
space->install_legacy_readwrite_handler( *device, 0x4b000000, 0x4b000023, FUNC(s3c24xx_dma_0_r), FUNC(s3c24xx_dma_0_w));
space->install_legacy_readwrite_handler( *device, 0x4b000040, 0x4b000063, FUNC(s3c24xx_dma_1_r), FUNC(s3c24xx_dma_1_w));
space->install_legacy_readwrite_handler( *device, 0x4b000080, 0x4b0000a3, FUNC(s3c24xx_dma_2_r), FUNC(s3c24xx_dma_2_w));
space->install_legacy_readwrite_handler( *device, 0x4b0000c0, 0x4b0000e3, FUNC(s3c24xx_dma_3_r), FUNC(s3c24xx_dma_3_w));
space->install_legacy_readwrite_handler( *device, 0x4c000000, 0x4c000017, FUNC(s3c24xx_clkpow_r), FUNC(s3c24xx_clkpow_w));
space->install_legacy_readwrite_handler( *device, 0x4d000000, 0x4d000063, FUNC(s3c2410_lcd_r), FUNC(s3c24xx_lcd_w));
space->install_legacy_readwrite_handler( *device, 0x4d000400, 0x4d0007ff, FUNC(s3c24xx_lcd_palette_r), FUNC(s3c24xx_lcd_palette_w));
space->install_legacy_readwrite_handler( *device, 0x4e000000, 0x4e000017, FUNC(s3c24xx_nand_r), FUNC(s3c24xx_nand_w));
space->install_legacy_readwrite_handler( *device, 0x50000000, 0x5000002b, FUNC(s3c24xx_uart_0_r), FUNC(s3c24xx_uart_0_w));
space->install_legacy_readwrite_handler( *device, 0x50004000, 0x5000402b, FUNC(s3c24xx_uart_1_r), FUNC(s3c24xx_uart_1_w));
space->install_legacy_readwrite_handler( *device, 0x50008000, 0x5000802b, FUNC(s3c24xx_uart_2_r), FUNC(s3c24xx_uart_2_w));
space->install_legacy_readwrite_handler( *device, 0x51000000, 0x51000043, FUNC(s3c24xx_pwm_r), FUNC(s3c24xx_pwm_w));
space->install_legacy_readwrite_handler( *device, 0x52000140, 0x5200026f, FUNC(s3c24xx_usb_device_r), FUNC(s3c24xx_usb_device_w));
space->install_legacy_readwrite_handler( *device, 0x53000000, 0x5300000b, FUNC(s3c24xx_wdt_r), FUNC(s3c24xx_wdt_w));
space->install_legacy_readwrite_handler( *device, 0x54000000, 0x5400000f, FUNC(s3c24xx_iic_r), FUNC(s3c24xx_iic_w));
space->install_legacy_readwrite_handler( *device, 0x55000000, 0x55000013, FUNC(s3c24xx_iis_r), FUNC(s3c24xx_iis_w));
space->install_legacy_readwrite_handler( *device, 0x56000000, 0x560000bf, FUNC(s3c24xx_gpio_r), FUNC(s3c24xx_gpio_w));
space->install_legacy_readwrite_handler( *device, 0x57000040, 0x5700008b, FUNC(s3c24xx_rtc_r), FUNC(s3c24xx_rtc_w));
space->install_legacy_readwrite_handler( *device, 0x58000000, 0x58000013, FUNC(s3c24xx_adc_r), FUNC(s3c24xx_adc_w));
space->install_legacy_readwrite_handler( *device, 0x59000000, 0x59000017, FUNC(s3c24xx_spi_0_r), FUNC(s3c24xx_spi_0_w));
space->install_legacy_readwrite_handler( *device, 0x59000020, 0x59000037, FUNC(s3c24xx_spi_1_r), FUNC(s3c24xx_spi_1_w));
space->install_legacy_readwrite_handler( *device, 0x5a000000, 0x5a000043, FUNC(s3c24xx_sdi_r), FUNC(s3c24xx_sdi_w));
}
DEVICE_GET_INFO( s3c2410 )

54
src/emu/machine/s3c2440.c
View File

@ -46,33 +46,33 @@ SCREEN_UPDATE( s3c2440 )
DEVICE_START( s3c2440 )
{
address_space *space = device->machine->device( "maincpu")->memory().space( AS_PROGRAM);
memory_install_readwrite32_device_handler( space, device, 0x48000000, 0x4800003b, 0, 0, s3c24xx_memcon_r, s3c24xx_memcon_w);
memory_install_readwrite32_device_handler( space, device, 0x49000000, 0x4900005b, 0, 0, s3c24xx_usb_host_r, s3c24xx_usb_host_w);
memory_install_readwrite32_device_handler( space, device, 0x4a000000, 0x4a00001f, 0, 0, s3c24xx_irq_r, s3c24xx_irq_w);
memory_install_readwrite32_device_handler( space, device, 0x4b000000, 0x4b000023, 0, 0, s3c24xx_dma_0_r, s3c24xx_dma_0_w);
memory_install_readwrite32_device_handler( space, device, 0x4b000040, 0x4b000063, 0, 0, s3c24xx_dma_1_r, s3c24xx_dma_1_w);
memory_install_readwrite32_device_handler( space, device, 0x4b000080, 0x4b0000a3, 0, 0, s3c24xx_dma_2_r, s3c24xx_dma_2_w);
memory_install_readwrite32_device_handler( space, device, 0x4b0000c0, 0x4b0000e3, 0, 0, s3c24xx_dma_3_r, s3c24xx_dma_3_w);
memory_install_readwrite32_device_handler( space, device, 0x4c000000, 0x4c00001b, 0, 0, s3c24xx_clkpow_r, s3c24xx_clkpow_w);
memory_install_readwrite32_device_handler( space, device, 0x4d000000, 0x4d000063, 0, 0, s3c2440_lcd_r, s3c24xx_lcd_w);
memory_install_readwrite32_device_handler( space, device, 0x4d000400, 0x4d0007ff, 0, 0, s3c24xx_lcd_palette_r, s3c24xx_lcd_palette_w);
memory_install_readwrite32_device_handler( space, device, 0x4e000000, 0x4e00003f, 0, 0, s3c24xx_nand_r, s3c24xx_nand_w);
memory_install_readwrite32_device_handler( space, device, 0x4f000000, 0x4f0000a3, 0, 0, s3c24xx_cam_r, s3c24xx_cam_w);
memory_install_readwrite32_device_handler( space, device, 0x50000000, 0x5000002b, 0, 0, s3c24xx_uart_0_r, s3c24xx_uart_0_w);
memory_install_readwrite32_device_handler( space, device, 0x50004000, 0x5000402b, 0, 0, s3c24xx_uart_1_r, s3c24xx_uart_1_w);
memory_install_readwrite32_device_handler( space, device, 0x50008000, 0x5000802b, 0, 0, s3c24xx_uart_2_r, s3c24xx_uart_2_w);
memory_install_readwrite32_device_handler( space, device, 0x51000000, 0x51000043, 0, 0, s3c24xx_pwm_r, s3c24xx_pwm_w);
memory_install_readwrite32_device_handler( space, device, 0x52000140, 0x5200026f, 0, 0, s3c24xx_usb_device_r, s3c24xx_usb_device_w);
memory_install_readwrite32_device_handler( space, device, 0x53000000, 0x5300000b, 0, 0, s3c24xx_wdt_r, s3c24xx_wdt_w);
memory_install_readwrite32_device_handler( space, device, 0x54000000, 0x54000013, 0, 0, s3c24xx_iic_r, s3c24xx_iic_w);
memory_install_readwrite32_device_handler( space, device, 0x55000000, 0x55000013, 0, 0, s3c24xx_iis_r, s3c24xx_iis_w);
memory_install_readwrite32_device_handler( space, device, 0x56000000, 0x560000df, 0, 0, s3c24xx_gpio_r, s3c24xx_gpio_w);
memory_install_readwrite32_device_handler( space, device, 0x57000040, 0x5700008b, 0, 0, s3c24xx_rtc_r, s3c24xx_rtc_w);
memory_install_readwrite32_device_handler( space, device, 0x58000000, 0x58000017, 0, 0, s3c24xx_adc_r, s3c24xx_adc_w);
memory_install_readwrite32_device_handler( space, device, 0x59000000, 0x59000017, 0, 0, s3c24xx_spi_0_r, s3c24xx_spi_0_w);
memory_install_readwrite32_device_handler( space, device, 0x59000020, 0x59000037, 0, 0, s3c24xx_spi_1_r, s3c24xx_spi_1_w);
memory_install_readwrite32_device_handler( space, device, 0x5a000000, 0x5a000043, 0, 0, s3c24xx_sdi_r, s3c24xx_sdi_w);
memory_install_readwrite32_device_handler( space, device, 0x5b000000, 0x5b00001f, 0, 0, s3c24xx_ac97_r, s3c24xx_ac97_w);
space->install_legacy_readwrite_handler( *device, 0x48000000, 0x4800003b, FUNC(s3c24xx_memcon_r), FUNC(s3c24xx_memcon_w));
space->install_legacy_readwrite_handler( *device, 0x49000000, 0x4900005b, FUNC(s3c24xx_usb_host_r), FUNC(s3c24xx_usb_host_w));
space->install_legacy_readwrite_handler( *device, 0x4a000000, 0x4a00001f, FUNC(s3c24xx_irq_r), FUNC(s3c24xx_irq_w));
space->install_legacy_readwrite_handler( *device, 0x4b000000, 0x4b000023, FUNC(s3c24xx_dma_0_r), FUNC(s3c24xx_dma_0_w));
space->install_legacy_readwrite_handler( *device, 0x4b000040, 0x4b000063, FUNC(s3c24xx_dma_1_r), FUNC(s3c24xx_dma_1_w));
space->install_legacy_readwrite_handler( *device, 0x4b000080, 0x4b0000a3, FUNC(s3c24xx_dma_2_r), FUNC(s3c24xx_dma_2_w));
space->install_legacy_readwrite_handler( *device, 0x4b0000c0, 0x4b0000e3, FUNC(s3c24xx_dma_3_r), FUNC(s3c24xx_dma_3_w));
space->install_legacy_readwrite_handler( *device, 0x4c000000, 0x4c00001b, FUNC(s3c24xx_clkpow_r), FUNC(s3c24xx_clkpow_w));
space->install_legacy_readwrite_handler( *device, 0x4d000000, 0x4d000063, FUNC(s3c2440_lcd_r), FUNC(s3c24xx_lcd_w));
space->install_legacy_readwrite_handler( *device, 0x4d000400, 0x4d0007ff, FUNC(s3c24xx_lcd_palette_r), FUNC(s3c24xx_lcd_palette_w));
space->install_legacy_readwrite_handler( *device, 0x4e000000, 0x4e00003f, FUNC(s3c24xx_nand_r), FUNC(s3c24xx_nand_w));
space->install_legacy_readwrite_handler( *device, 0x4f000000, 0x4f0000a3, FUNC(s3c24xx_cam_r), FUNC(s3c24xx_cam_w));
space->install_legacy_readwrite_handler( *device, 0x50000000, 0x5000002b, FUNC(s3c24xx_uart_0_r), FUNC(s3c24xx_uart_0_w));
space->install_legacy_readwrite_handler( *device, 0x50004000, 0x5000402b, FUNC(s3c24xx_uart_1_r), FUNC(s3c24xx_uart_1_w));
space->install_legacy_readwrite_handler( *device, 0x50008000, 0x5000802b, FUNC(s3c24xx_uart_2_r), FUNC(s3c24xx_uart_2_w));
space->install_legacy_readwrite_handler( *device, 0x51000000, 0x51000043, FUNC(s3c24xx_pwm_r), FUNC(s3c24xx_pwm_w));
space->install_legacy_readwrite_handler( *device, 0x52000140, 0x5200026f, FUNC(s3c24xx_usb_device_r), FUNC(s3c24xx_usb_device_w));
space->install_legacy_readwrite_handler( *device, 0x53000000, 0x5300000b, FUNC(s3c24xx_wdt_r), FUNC(s3c24xx_wdt_w));
space->install_legacy_readwrite_handler( *device, 0x54000000, 0x54000013, FUNC(s3c24xx_iic_r), FUNC(s3c24xx_iic_w));
space->install_legacy_readwrite_handler( *device, 0x55000000, 0x55000013, FUNC(s3c24xx_iis_r), FUNC(s3c24xx_iis_w));
space->install_legacy_readwrite_handler( *device, 0x56000000, 0x560000df, FUNC(s3c24xx_gpio_r), FUNC(s3c24xx_gpio_w));
space->install_legacy_readwrite_handler( *device, 0x57000040, 0x5700008b, FUNC(s3c24xx_rtc_r), FUNC(s3c24xx_rtc_w));
space->install_legacy_readwrite_handler( *device, 0x58000000, 0x58000017, FUNC(s3c24xx_adc_r), FUNC(s3c24xx_adc_w));
space->install_legacy_readwrite_handler( *device, 0x59000000, 0x59000017, FUNC(s3c24xx_spi_0_r), FUNC(s3c24xx_spi_0_w));
space->install_legacy_readwrite_handler( *device, 0x59000020, 0x59000037, FUNC(s3c24xx_spi_1_r), FUNC(s3c24xx_spi_1_w));
space->install_legacy_readwrite_handler( *device, 0x5a000000, 0x5a000043, FUNC(s3c24xx_sdi_r), FUNC(s3c24xx_sdi_w));
space->install_legacy_readwrite_handler( *device, 0x5b000000, 0x5b00001f, FUNC(s3c24xx_ac97_r), FUNC(s3c24xx_ac97_w));
DEVICE_START_CALL(s3c24xx);
}

42
src/emu/memory.c
View File

@ -906,7 +906,7 @@ public:
UINT8 buffer[16];
for (int index = 0; index < 16; index++)
buffer[index ^ ((_Endian == ENDIANNESS_NATIVE) ? 0 : (data_width()/8 - 1))] = index * 0x11;
install_ram(0x00, 0x0f, 0x0f, 0, ROW_READWRITE, buffer);
install_ram_generic(0x00, 0x0f, 0x0f, 0, ROW_READWRITE, buffer);
printf("\n\naddress_space(%d, %s, %s)\n", NATIVE_BITS, (_Endian == ENDIANNESS_LITTLE) ? "little" : "big", _Large ? "large" : "small");
// walk through the first 8 addresses
@ -2052,15 +2052,15 @@ void address_space::populate_map_entry(const address_map_entry &entry, read_or_w
// fall through to the RAM case otherwise
case AMH_RAM:
install_ram(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, readorwrite);
install_ram_generic(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, readorwrite, NULL);
break;
case AMH_NOP:
unmap(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, readorwrite, true);
unmap_generic(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, readorwrite, true);
break;
case AMH_UNMAP:
unmap(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, readorwrite, false);
unmap_generic(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror, readorwrite, false);
break;
case AMH_DRIVER_DELEGATE:
@ -2139,13 +2139,13 @@ void address_space::populate_map_entry(const address_map_entry &entry, read_or_w
break;
case AMH_PORT:
install_port(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror,
install_readwrite_port(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror,
(readorwrite == ROW_READ) ? data.m_tag : NULL,
(readorwrite == ROW_WRITE) ? data.m_tag : NULL);
break;
case AMH_BANK:
install_bank(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror,
install_bank_generic(entry.m_addrstart, entry.m_addrend, entry.m_addrmask, entry.m_addrmirror,
(readorwrite == ROW_READ) ? data.m_tag : NULL,
(readorwrite == ROW_WRITE) ? data.m_tag : NULL);
break;
@ -2409,7 +2409,7 @@ void address_space::dump_map(FILE *file, read_or_write readorwrite)
// unmap - unmap a section of address space
//-------------------------------------------------
void address_space::unmap(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, bool quiet)
void address_space::unmap_generic(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, bool quiet)
{
VPRINTF(("address_space::unmap(%s-%s mask=%s mirror=%s, %s, %s)\n",
core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars),
@ -2428,13 +2428,13 @@ void address_space::unmap(offs_t addrstart, offs_t addrend, offs_t addrmask, off
//-------------------------------------------------
// install_port - install a new I/O port handler
// into this address space
// install_readwrite_port - install a new I/O port
// handler into this address space
//-------------------------------------------------
void address_space::install_port(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag)
void address_space::install_readwrite_port(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag)
{
VPRINTF(("address_space::install_port(%s-%s mask=%s mirror=%s, read=\"%s\" / write=\"%s\")\n",
VPRINTF(("address_space::install_readwrite_port(%s-%s mask=%s mirror=%s, read=\"%s\" / write=\"%s\")\n",
core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars),
core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars),
(rtag != NULL) ? rtag : "(none)", (wtag != NULL) ? wtag : "(none)"));
@ -2470,13 +2470,13 @@ void address_space::install_port(offs_t addrstart, offs_t addrend, offs_t addrma
//-------------------------------------------------
// install_bank - install a range as mapping to
// a particular bank
// install_bank_generic - install a range as
// mapping to a particular bank
//-------------------------------------------------
void address_space::install_bank(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag)
void address_space::install_bank_generic(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag)
{
VPRINTF(("address_space::install_bank(%s-%s mask=%s mirror=%s, read=\"%s\" / write=\"%s\")\n",
VPRINTF(("address_space::install_readwrite_bank(%s-%s mask=%s mirror=%s, read=\"%s\" / write=\"%s\")\n",
core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars),
core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars),
(rtag != NULL) ? rtag : "(none)", (wtag != NULL) ? wtag : "(none)"));
@ -2501,15 +2501,15 @@ void address_space::install_bank(offs_t addrstart, offs_t addrend, offs_t addrma
//-------------------------------------------------
// install_ram - install a simple fixed RAM
// region into the given address space
// install_ram_generic - install a simple fixed
// RAM region into the given address space
//-------------------------------------------------
void *address_space::install_ram(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, void *baseptr)
void *address_space::install_ram_generic(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, void *baseptr)
{
memory_private *memdata = m_machine.memory_data;
VPRINTF(("address_space::install_ram(%s-%s mask=%s mirror=%s, %s, %p)\n",
VPRINTF(("address_space::install_ram_generic(%s-%s mask=%s mirror=%s, %s, %p)\n",
core_i64_hex_format(addrstart, m_addrchars), core_i64_hex_format(addrend, m_addrchars),
core_i64_hex_format(addrmask, m_addrchars), core_i64_hex_format(addrmirror, m_addrchars),
(readorwrite == ROW_READ) ? "read" : (readorwrite == ROW_WRITE) ? "write" : (readorwrite == ROW_READWRITE) ? "read/write" : "??",
@ -2538,7 +2538,7 @@ void *address_space::install_ram(offs_t addrstart, offs_t addrend, offs_t addrma
if (bank.base() == NULL && memdata->initialized)
{
if (m_machine.phase() >= MACHINE_PHASE_RESET)
fatalerror("Attempted to call memory_install_ram() after initialization time without a baseptr!");
fatalerror("Attempted to call install_ram_generic() after initialization time without a baseptr!");
memory_block &block = memdata->blocklist.append(*auto_alloc(&m_machine, memory_block(*this, address_to_byte(addrstart), address_to_byte_end(addrend))));
bank.set_base(block.data());
}
@ -2567,7 +2567,7 @@ void *address_space::install_ram(offs_t addrstart, offs_t addrend, offs_t addrma
if (bank.base() == NULL && memdata->initialized)
{
if (m_machine.phase() >= MACHINE_PHASE_RESET)
fatalerror("Attempted to call memory_install_ram() after initialization time without a baseptr!");
fatalerror("Attempted to call install_ram_generic() after initialization time without a baseptr!");
memory_block &block = memdata->blocklist.append(*auto_alloc(&m_machine, memory_block(*this, address_to_byte(addrstart), address_to_byte_end(addrend))));
bank.set_base(block.data());
}

149
src/emu/memory.h
View File

@ -431,17 +431,45 @@ public:
direct_update_delegate set_direct_update_handler(direct_update_delegate function) { return m_direct.set_direct_update(function); }
bool set_direct_region(offs_t &byteaddress);
// static handler installation
void unmap(offs_t addrstart, offs_t addrend, read_or_write readorwrite, bool quiet) { unmap(addrstart, addrend, 0, 0, readorwrite, quiet); }
void unmap(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, bool quiet);
void install_port(offs_t addrstart, offs_t addrend, const char *rtag, const char *wtag) { install_port(addrstart, addrend, 0, 0, rtag, wtag); }
void install_port(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag);
void install_bank(offs_t addrstart, offs_t addrend, const char *rtag, const char *wtag) { install_bank(addrstart, addrend, 0, 0, rtag, wtag); }
void install_bank(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag);
void *install_ram(offs_t addrstart, offs_t addrend, read_or_write readorwrite, void *baseptr = NULL) { return install_ram(addrstart, addrend, 0, 0, readorwrite, baseptr); }
void *install_ram(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, void *baseptr = NULL);
// umap ranges (short form)
void unmap_read(offs_t addrstart, offs_t addrend) { unmap_read(addrstart, addrend, 0, 0); }
void unmap_write(offs_t addrstart, offs_t addrend) { unmap_write(addrstart, addrend, 0, 0); }
void unmap_readwrite(offs_t addrstart, offs_t addrend) { unmap_readwrite(addrstart, addrend, 0, 0); }
void nop_read(offs_t addrstart, offs_t addrend) { nop_read(addrstart, addrend, 0, 0); }
void nop_write(offs_t addrstart, offs_t addrend) { nop_write(addrstart, addrend, 0, 0); }
void nop_readwrite(offs_t addrstart, offs_t addrend) { nop_readwrite(addrstart, addrend, 0, 0); }
// install new-style delegate handlers
// umap ranges (with mirror/mask)
void unmap_read(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror) { unmap_generic(addrstart, addrend, 0, 0, ROW_READ, false); }
void unmap_write(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror) { unmap_generic(addrstart, addrend, 0, 0, ROW_READWRITE, false); }
void unmap_readwrite(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror) { unmap_generic(addrstart, addrend, 0, 0, ROW_READWRITE, false); }
void nop_read(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror) { unmap_generic(addrstart, addrend, 0, 0, ROW_READ, true); }
void nop_write(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror) { unmap_generic(addrstart, addrend, 0, 0, ROW_READWRITE, true); }
void nop_readwrite(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror) { unmap_generic(addrstart, addrend, 0, 0, ROW_READWRITE, true); }
// install ports, banks, RAM (short form)
void install_read_port(offs_t addrstart, offs_t addrend, const char *rtag) { install_read_port(addrstart, addrend, 0, 0, rtag); }
void install_write_port(offs_t addrstart, offs_t addrend, const char *wtag) { install_write_port(addrstart, addrend, 0, 0, wtag); }
void install_readwrite_port(offs_t addrstart, offs_t addrend, const char *rtag, const char *wtag) { install_readwrite_port(addrstart, addrend, 0, 0, rtag, wtag); }
void install_read_bank(offs_t addrstart, offs_t addrend, const char *tag) { install_read_bank(addrstart, addrend, 0, 0, tag); }
void install_write_bank(offs_t addrstart, offs_t addrend, const char *tag) { install_write_bank(addrstart, addrend, 0, 0, tag); }
void install_readwrite_bank(offs_t addrstart, offs_t addrend, const char *tag) { install_readwrite_bank(addrstart, addrend, 0, 0, tag); }
void *install_rom(offs_t addrstart, offs_t addrend, void *baseptr = NULL) { return install_rom(addrstart, addrend, 0, 0, baseptr); }
void *install_writeonly(offs_t addrstart, offs_t addrend, void *baseptr = NULL) { return install_writeonly(addrstart, addrend, 0, 0, baseptr); }
void *install_ram(offs_t addrstart, offs_t addrend, void *baseptr = NULL) { return install_ram(addrstart, addrend, 0, 0, baseptr); }
// install ports, banks, RAM (with mirror/mask)
void install_read_port(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag) { install_readwrite_port(addrstart, addrend, addrmask, addrmirror, rtag, NULL); }
void install_write_port(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *wtag) { install_readwrite_port(addrstart, addrend, addrmask, addrmirror, NULL, wtag); }
void install_readwrite_port(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag);
void install_read_bank(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *tag) { install_bank_generic(addrstart, addrend, addrmask, addrmirror, tag, NULL); }
void install_write_bank(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *tag) { install_bank_generic(addrstart, addrend, addrmask, addrmirror, NULL, tag); }
void install_readwrite_bank(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *tag) { install_bank_generic(addrstart, addrend, addrmask, addrmirror, tag, tag); }
void *install_rom(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, void *baseptr = NULL) { return install_ram_generic(addrstart, addrend, addrmask, addrmirror, ROW_READ, baseptr); }
void *install_writeonly(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, void *baseptr = NULL) { return install_ram_generic(addrstart, addrend, addrmask, addrmirror, ROW_WRITE, baseptr); }
void *install_ram(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, void *baseptr = NULL) { return install_ram_generic(addrstart, addrend, addrmask, addrmirror, ROW_READWRITE, baseptr); }
// install new-style delegate handlers (short form)
UINT8 *install_read_handler(offs_t addrstart, offs_t addrend, read8_delegate rhandler, UINT64 unitmask = 0) { return install_read_handler(addrstart, addrend, 0, 0, rhandler, unitmask); }
UINT8 *install_write_handler(offs_t addrstart, offs_t addrend, write8_delegate whandler, UINT64 unitmask = 0) { return install_write_handler(addrstart, addrend, 0, 0, whandler, unitmask); }
UINT8 *install_readwrite_handler(offs_t addrstart, offs_t addrend, read8_delegate rhandler, write8_delegate whandler, UINT64 unitmask = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, rhandler, whandler, unitmask); }
@ -455,6 +483,7 @@ public:
UINT64 *install_write_handler(offs_t addrstart, offs_t addrend, write64_delegate whandler, UINT64 unitmask = 0) { return install_write_handler(addrstart, addrend, 0, 0, whandler, unitmask); }
UINT64 *install_readwrite_handler(offs_t addrstart, offs_t addrend, read64_delegate rhandler, write64_delegate whandler, UINT64 unitmask = 0) { return install_readwrite_handler(addrstart, addrend, 0, 0, rhandler, whandler, unitmask); }
// install new-style delegate handlers (with mirror/mask)
UINT8 *install_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_delegate rhandler, UINT64 unitmask = 0);
UINT8 *install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write8_delegate whandler, UINT64 unitmask = 0);
UINT8 *install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_delegate rhandler, write8_delegate whandler, UINT64 unitmask = 0);
@ -468,7 +497,7 @@ public:
UINT64 *install_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write64_delegate whandler, UINT64 unitmask = 0);
UINT64 *install_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read64_delegate rhandler, write64_delegate whandler, UINT64 unitmask = 0);
// install legacy address space handlers
// install legacy address space handlers (short form)
UINT8 *install_legacy_read_handler(offs_t addrstart, offs_t addrend, read8_space_func rhandler, const char *rname, UINT64 unitmask = 0) { return install_legacy_read_handler(addrstart, addrend, 0, 0, rhandler, rname, unitmask); }
UINT8 *install_legacy_write_handler(offs_t addrstart, offs_t addrend, write8_space_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_write_handler(addrstart, addrend, 0, 0, whandler, wname, unitmask); }
UINT8 *install_legacy_readwrite_handler(offs_t addrstart, offs_t addrend, read8_space_func rhandler, const char *rname, write8_space_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_readwrite_handler(addrstart, addrend, 0, 0, rhandler, rname, whandler, wname, unitmask); }
@ -482,6 +511,7 @@ public:
UINT64 *install_legacy_write_handler(offs_t addrstart, offs_t addrend, write64_space_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_write_handler(addrstart, addrend, 0, 0, whandler, wname, unitmask); }
UINT64 *install_legacy_readwrite_handler(offs_t addrstart, offs_t addrend, read64_space_func rhandler, const char *rname, write64_space_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_readwrite_handler(addrstart, addrend, 0, 0, rhandler, rname, whandler, wname, unitmask); }
// install legacy address space handlers (with mirror/mask)
UINT8 *install_legacy_read_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_space_func rhandler, const char *rname, UINT64 unitmask = 0);
UINT8 *install_legacy_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write8_space_func whandler, const char *wname, UINT64 unitmask = 0);
UINT8 *install_legacy_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_space_func rhandler, const char *rname, write8_space_func whandler, const char *wname, UINT64 unitmask = 0);
@ -495,7 +525,7 @@ public:
UINT64 *install_legacy_write_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write64_space_func whandler, const char *wname, UINT64 unitmask = 0);
UINT64 *install_legacy_readwrite_handler(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read64_space_func rhandler, const char *rname, write64_space_func whandler, const char *wname, UINT64 unitmask = 0);
// install legacy device handlers
// install legacy device handlers (short form)
UINT8 *install_legacy_read_handler(device_t &device, offs_t addrstart, offs_t addrend, read8_device_func rhandler, const char *rname, UINT64 unitmask = 0) { return install_legacy_read_handler(device, addrstart, addrend, 0, 0, rhandler, rname, unitmask); }
UINT8 *install_legacy_write_handler(device_t &device, offs_t addrstart, offs_t addrend, write8_device_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_write_handler(device, addrstart, addrend, 0, 0, whandler, wname, unitmask); }
UINT8 *install_legacy_readwrite_handler(device_t &device, offs_t addrstart, offs_t addrend, read8_device_func rhandler, const char *rname, write8_device_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_readwrite_handler(device, addrstart, addrend, 0, 0, rhandler, rname, whandler, wname, unitmask); }
@ -509,6 +539,7 @@ public:
UINT64 *install_legacy_write_handler(device_t &device, offs_t addrstart, offs_t addrend, write64_device_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_write_handler(device, addrstart, addrend, 0, 0, whandler, wname, unitmask); }
UINT64 *install_legacy_readwrite_handler(device_t &device, offs_t addrstart, offs_t addrend, read64_device_func rhandler, const char *rname, write64_device_func whandler, const char *wname, UINT64 unitmask = 0) { return install_legacy_readwrite_handler(device, addrstart, addrend, 0, 0, rhandler, rname, whandler, wname, unitmask); }
// install legacy device handlers (with mirror/mask)
UINT8 *install_legacy_read_handler(device_t &device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_device_func rhandler, const char *rname, UINT64 unitmask = 0);
UINT8 *install_legacy_write_handler(device_t &device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, write8_device_func whandler, const char *wname, UINT64 unitmask = 0);
UINT8 *install_legacy_readwrite_handler(device_t &device, offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read8_device_func rhandler, const char *rname, write8_device_func whandler, const char *wname, UINT64 unitmask = 0);
@ -533,6 +564,9 @@ private:
virtual address_table_read &read() = 0;
virtual address_table_write &write() = 0;
void populate_map_entry(const address_map_entry &entry, read_or_write readorwrite);
void unmap_generic(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, bool quiet);
void *install_ram_generic(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, read_or_write readorwrite, void *baseptr);
void install_bank_generic(offs_t addrstart, offs_t addrend, offs_t addrmask, offs_t addrmirror, const char *rtag, const char *wtag);
void bind_and_install_handler(const address_map_entry &entry, read_or_write readorwrite, device_t *device);
void adjust_addresses(offs_t &start, offs_t &end, offs_t &mask, offs_t &mirror);
void *find_backing_memory(offs_t addrstart, offs_t addrend);
@ -667,97 +701,6 @@ protected:
#define DWORD_XOR_LE(a) ((a) ^ NATIVE_ENDIAN_VALUE_LE_BE(0,4))
// wrappers for dynamic read handler installation
#define memory_install_read8_handler(space, start, end, mask, mirror, rhandler) \
(space)->install_legacy_read_handler(start, end, mask, mirror, rhandler, #rhandler)
#define memory_install_read16_handler(space, start, end, mask, mirror, rhandler) \
(space)->install_legacy_read_handler(start, end, mask, mirror, rhandler, #rhandler)
#define memory_install_read32_handler(space, start, end, mask, mirror, rhandler) \
(space)->install_legacy_read_handler(start, end, mask, mirror, rhandler, #rhandler)
#define memory_install_read64_handler(space, start, end, mask, mirror, rhandler) \
(space)->install_legacy_read_handler(start, end, mask, mirror, rhandler, #rhandler)
#define memory_install_read8_device_handler(space, device, start, end, mask, mirror, rhandler) \
(space)->install_legacy_read_handler(*(device), start, end, mask, mirror, rhandler, #rhandler)
#define memory_install_read16_device_handler(space, device, start, end, mask, mirror, rhandler) \
(space)->install_legacy_read_handler(*(device), start, end, mask, mirror, rhandler, #rhandler)
#define memory_install_read32_device_handler(space, device, start, end, mask, mirror, rhandler) \
(space)->install_legacy_read_handler(*(device), start, end, mask, mirror, rhandler, #rhandler)
#define memory_install_read64_device_handler(space, device, start, end, mask, mirror, rhandler) \
(space)->install_legacy_read_handler(*(device), start, end, mask, mirror, rhandler, #rhandler)
#define memory_install_read_port(space, start, end, mask, mirror, rtag) \
(space)->install_port(start, end, mask, mirror, rtag, NULL)
#define memory_install_read_bank(space, start, end, mask, mirror, rtag) \
(space)->install_bank(start, end, mask, mirror, rtag, NULL)
#define memory_install_rom(space, start, end, mask, mirror, baseptr) \
(space)->install_ram(start, end, mask, mirror, ROW_READ, baseptr)
#define memory_unmap_read(space, start, end, mask, mirror) \
(space)->unmap(start, end, mask, mirror, ROW_READ, false)
#define memory_nop_read(space, start, end, mask, mirror) \
(space)->unmap(start, end, mask, mirror, ROW_READ, true)
// wrappers for dynamic write handler installation
#define memory_install_write8_handler(space, start, end, mask, mirror, whandler) \
(space)->install_legacy_write_handler(start, end, mask, mirror, whandler, #whandler)
#define memory_install_write16_handler(space, start, end, mask, mirror, whandler) \
(space)->install_legacy_write_handler(start, end, mask, mirror, whandler, #whandler)
#define memory_install_write32_handler(space, start, end, mask, mirror, whandler) \
(space)->install_legacy_write_handler(start, end, mask, mirror, whandler, #whandler)
#define memory_install_write64_handler(space, start, end, mask, mirror, whandler) \
(space)->install_legacy_write_handler(start, end, mask, mirror, whandler, #whandler)
#define memory_install_write8_device_handler(space, device, start, end, mask, mirror, whandler) \
(space)->install_legacy_write_handler(*(device), start, end, mask, mirror, whandler, #whandler)
#define memory_install_write16_device_handler(space, device, start, end, mask, mirror, whandler) \
(space)->install_legacy_write_handler(*(device), start, end, mask, mirror, whandler, #whandler)
#define memory_install_write32_device_handler(space, device, start, end, mask, mirror, whandler) \
(space)->install_legacy_write_handler(*(device), start, end, mask, mirror, whandler, #whandler)
#define memory_install_write64_device_handler(space, device, start, end, mask, mirror, whandler) \
(space)->install_legacy_write_handler(*(device), start, end, mask, mirror, whandler, #whandler)
#define memory_install_write_port(space, start, end, mask, mirror, wtag) \
(space)->install_port(start, end, mask, mirror, NULL, wtag)
#define memory_install_write_bank(space, start, end, mask, mirror, wtag) \
(space)->install_bank(start, end, mask, mirror, NULL, wtag)
#define memory_install_writeonly(space, start, end, mask, mirror, baseptr) \
(space)->install_ram(start, end, mask, mirror, ROW_WRITE, baseptr)
#define memory_unmap_write(space, start, end, mask, mirror) \
(space)->unmap(start, end, mask, mirror, ROW_WRITE, false)
#define memory_nop_write(space, start, end, mask, mirror) \
(space)->unmap(start, end, mask, mirror, ROW_WRITE, true)
// wrappers for dynamic read/write handler installation
#define memory_install_readwrite8_handler(space, start, end, mask, mirror, rhandler, whandler) \
(space)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
#define memory_install_readwrite16_handler(space, start, end, mask, mirror, rhandler, whandler) \
(space)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
#define memory_install_readwrite32_handler(space, start, end, mask, mirror, rhandler, whandler) \
(space)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
#define memory_install_readwrite64_handler(space, start, end, mask, mirror, rhandler, whandler) \
(space)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
#define memory_install_readwrite8_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \
(space)->install_legacy_readwrite_handler(*(device), start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
#define memory_install_readwrite16_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \
(space)->install_legacy_readwrite_handler(*(device), start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
#define memory_install_readwrite32_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \
(space)->install_legacy_readwrite_handler(*(device), start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
#define memory_install_readwrite64_device_handler(space, device, start, end, mask, mirror, rhandler, whandler) \
(space)->install_legacy_readwrite_handler(*(device), start, end, mask, mirror, rhandler, #rhandler, whandler, #whandler)
#define memory_install_readwrite_port(space, start, end, mask, mirror, rtag, wtag) \
(space)->install_port(start, end, mask, mirror, rtag, wtag)
#define memory_install_readwrite_bank(space, start, end, mask, mirror, tag) \
(space)->install_bank(start, end, mask, mirror, tag, tag)
#define memory_install_ram(space, start, end, mask, mirror, baseptr) \
(space)->install_ram(start, end, mask, mirror, ROW_READWRITE, baseptr)
#define memory_unmap_readwrite(space, start, end, mask, mirror) \
(space)->unmap(start, end, mask, mirror, ROW_READWRITE, false)
#define memory_nop_readwrite(space, start, end, mask, mirror) \
(space)->unmap(start, end, mask, mirror, ROW_READWRITE, true)
//**************************************************************************
// GLOBAL VARIABLES

2
src/emu/sound/okim6295.c
View File

@ -258,7 +258,7 @@ void okim6295_device::set_bank_base(offs_t base)
if (!m_bank_installed && base != 0)
{
// override our memory map with a bank
memory_install_read_bank(space(), 0x00000, 0x3ffff, 0, 0, tag());
space()->install_read_bank(0x00000, 0x3ffff, tag());
m_bank_installed = true;
}

64
src/emu/video/pc_vga.c
View File

@ -682,17 +682,17 @@ static void vga_cpu_interface(running_machine *machine)
sel = vga.gc.data[6] & 0x0c;
if (sel)
{
if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler) ); else memory_nop_read(space, 0xa0000, 0xaffff, 0, 0);
if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler) ); else memory_nop_read(space, 0xb0000, 0xb7fff, 0, 0);
if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler) ); else memory_nop_read(space, 0xb8000, 0xbffff, 0, 0);
if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler)); else memory_nop_write(space, 0xa0000, 0xaffff, 0, 0);
if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler)); else memory_nop_write(space, 0xb0000, 0xb7fff, 0, 0);
if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler)); else memory_nop_write(space, 0xb8000, 0xbffff, 0, 0);
if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler) ); else space->nop_read(0xa0000, 0xaffff);
if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler) ); else space->nop_read(0xb0000, 0xb7fff);
if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler) ); else space->nop_read(0xb8000, 0xbffff);
if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler)); else space->nop_write(0xa0000, 0xaffff);
if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler)); else space->nop_write(0xb0000, 0xb7fff);
if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler)); else space->nop_write(0xb8000, 0xbffff);
}
else
{
memory_install_read_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
memory_install_write_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
space->install_read_bank(0xa0000, 0xbffff, "vgabank" );
space->install_write_bank(0xa0000, 0xbffff, "vgabank" );
memory_set_bankptr(machine,"vgabank", vga.memory);
}
break;
@ -701,17 +701,17 @@ static void vga_cpu_interface(running_machine *machine)
sel = vga.gc.data[6] & 0x0c;
if (sel)
{
if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler16) ); else memory_nop_read(space, 0xa0000, 0xaffff, 0, 0);
if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler16) ); else memory_nop_read(space, 0xb0000, 0xb7fff, 0, 0);
if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler16) ); else memory_nop_read(space, 0xb8000, 0xbffff, 0, 0);
if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler16)); else memory_nop_write(space, 0xa0000, 0xaffff, 0, 0);
if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler16)); else memory_nop_write(space, 0xb0000, 0xb7fff, 0, 0);
if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler16)); else memory_nop_write(space, 0xb8000, 0xbffff, 0, 0);
if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler16) ); else space->nop_read(0xa0000, 0xaffff);
if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler16) ); else space->nop_read(0xb0000, 0xb7fff);
if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler16) ); else space->nop_read(0xb8000, 0xbffff);
if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler16)); else space->nop_write(0xa0000, 0xaffff);
if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler16)); else space->nop_write(0xb0000, 0xb7fff);
if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler16)); else space->nop_write(0xb8000, 0xbffff);
}
else
{
memory_install_read_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
memory_install_write_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
space->install_read_bank(0xa0000, 0xbffff, "vgabank" );
space->install_write_bank(0xa0000, 0xbffff, "vgabank" );
memory_set_bankptr(machine,"vgabank", vga.memory);
}
break;
@ -720,17 +720,17 @@ static void vga_cpu_interface(running_machine *machine)
sel = vga.gc.data[6] & 0x0c;
if (sel)
{
if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler32) ); else memory_nop_read(space, 0xa0000, 0xaffff, 0, 0);
if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler32) ); else memory_nop_read(space, 0xb0000, 0xb7fff, 0, 0);
if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler32) ); else memory_nop_read(space, 0xb8000, 0xbffff, 0, 0);
if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler32)); else memory_nop_write(space, 0xa0000, 0xaffff, 0, 0);
if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler32)); else memory_nop_write(space, 0xb0000, 0xb7fff, 0, 0);
if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler32)); else memory_nop_write(space, 0xb8000, 0xbffff, 0, 0);
if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler32) ); else space->nop_read(0xa0000, 0xaffff);
if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler32) ); else space->nop_read(0xb0000, 0xb7fff);
if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler32) ); else space->nop_read(0xb8000, 0xbffff);
if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler32)); else space->nop_write(0xa0000, 0xaffff);
if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler32)); else space->nop_write(0xb0000, 0xb7fff);
if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler32)); else space->nop_write(0xb8000, 0xbffff);
}
else
{
memory_install_read_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
memory_install_write_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
space->install_read_bank(0xa0000, 0xbffff, "vgabank" );
space->install_write_bank(0xa0000, 0xbffff, "vgabank" );
memory_set_bankptr(machine,"vgabank", vga.memory);
}
break;
@ -739,17 +739,17 @@ static void vga_cpu_interface(running_machine *machine)
sel = vga.gc.data[6] & 0x0c;
if (sel)
{
if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler64) ); else memory_nop_read(space, 0xa0000, 0xaffff, 0, 0);
if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler64) ); else memory_nop_read(space, 0xb0000, 0xb7fff, 0, 0);
if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler64) ); else memory_nop_read(space, 0xb8000, 0xbffff, 0, 0);
if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler64)); else memory_nop_write(space, 0xa0000, 0xaffff, 0, 0);
if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler64)); else memory_nop_write(space, 0xb0000, 0xb7fff, 0, 0);
if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler64)); else memory_nop_write(space, 0xb8000, 0xbffff, 0, 0);
if (sel == 0x04) space->install_legacy_read_handler(0xa0000, 0xaffff, FUNC(read_handler64) ); else space->nop_read(0xa0000, 0xaffff);
if (sel == 0x08) space->install_legacy_read_handler(0xb0000, 0xb7fff, FUNC(read_handler64) ); else space->nop_read(0xb0000, 0xb7fff);
if (sel == 0x0C) space->install_legacy_read_handler(0xb8000, 0xbffff, FUNC(read_handler64) ); else space->nop_read(0xb8000, 0xbffff);
if (sel == 0x04) space->install_legacy_write_handler(0xa0000, 0xaffff, FUNC(write_handler64)); else space->nop_write(0xa0000, 0xaffff);
if (sel == 0x08) space->install_legacy_write_handler(0xb0000, 0xb7fff, FUNC(write_handler64)); else space->nop_write(0xb0000, 0xb7fff);
if (sel == 0x0C) space->install_legacy_write_handler(0xb8000, 0xbffff, FUNC(write_handler64)); else space->nop_write(0xb8000, 0xbffff);
}
else
{
memory_install_read_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
memory_install_write_bank(space, 0xa0000, 0xbffff, 0, 0, "vgabank" );
space->install_read_bank(0xa0000, 0xbffff, "vgabank" );
space->install_write_bank(0xa0000, 0xbffff, "vgabank" );
memory_set_bankptr(machine,"vgabank", vga.memory);
}
break;

2
src/mame/audio/atarijsa.c
View File

@ -147,7 +147,7 @@ void atarijsa_init(running_machine *machine, const char *testport, int testmask)
/* install POKEY memory handlers */
if (pokey != NULL)
memory_install_readwrite8_device_handler(jsacpu->memory().space(AS_PROGRAM), pokey, 0x2c00, 0x2c0f, 0, 0, pokey_r, pokey_w);
jsacpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(*pokey, 0x2c00, 0x2c0f, FUNC(pokey_r), FUNC(pokey_w));
init_save_state(machine);
atarijsa_reset();

2
src/mame/audio/cage.c
View File

@ -172,7 +172,7 @@ void cage_init(running_machine *machine, offs_t speedup)
timer[1] = machine->device<timer_device>("cage_timer1");
if (speedup)
speedup_ram = memory_install_write32_handler(cage_cpu->memory().space(AS_PROGRAM), speedup, speedup, 0, 0, speedup_w);
speedup_ram = cage_cpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(speedup, speedup, FUNC(speedup_w));
for (chan = 0; chan < DAC_BUFFER_CHANNELS; chan++)
{

2
src/mame/audio/cinemat.c
View File

@ -1622,7 +1622,7 @@ static WRITE8_HANDLER( qb3_sound_w )
static MACHINE_RESET( qb3_sound )
{
MACHINE_RESET_CALL(demon_sound);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x04, 0x04, 0, 0, qb3_sound_w);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x04, 0x04, FUNC(qb3_sound_w));
/* this patch prevents the sound ROM from eating itself when command $0A is sent */
/* on a cube rotate */

26
src/mame/audio/dcs.c
View File

@ -1035,7 +1035,7 @@ void dcs2_init(running_machine *machine, int dram_in_mb, offs_t polling_offset)
/* install the speedup handler */
dcs.polling_offset = polling_offset;
if (polling_offset)
dcs_polling_base = memory_install_readwrite16_handler(dcs.cpu->space(AS_DATA), polling_offset, polling_offset, 0, 0, dcs_polling_r, dcs_polling_w);
dcs_polling_base = dcs.cpu->space(AS_DATA)->install_legacy_readwrite_handler(polling_offset, polling_offset, FUNC(dcs_polling_r), FUNC(dcs_polling_w));
/* allocate a watchdog timer for HLE transfers */
transfer.hle_enabled = (ENABLE_HLE_TRANSFERS && dram_in_mb != 0);
@ -1126,31 +1126,31 @@ static void sdrc_remap_memory(running_machine *machine)
/* if SRAM disabled, clean it out */
if (SDRC_SM_EN == 0)
{
memory_unmap_readwrite(dcs.program, 0x0800, 0x3fff, 0, 0);
memory_unmap_readwrite(dcs.data, 0x0800, 0x37ff, 0, 0);
dcs.program->unmap_readwrite(0x0800, 0x3fff);
dcs.data->unmap_readwrite(0x0800, 0x37ff);
}
/* otherwise, map the SRAM */
else
{
/* first start with a clean program map */
memory_install_ram(dcs.program, 0x0800, 0x3fff, 0, 0, dcs_sram + 0x4800);
dcs.program->install_ram(0x0800, 0x3fff, dcs_sram + 0x4800);
/* set up the data map based on the SRAM banking */
/* map 0: ram from 0800-37ff */
if (SDRC_SM_BK == 0)
{
memory_install_ram(dcs.data, 0x0800, 0x17ff, 0, 0, dcs_sram + 0x0000);
memory_install_ram(dcs.data, 0x1800, 0x27ff, 0, 0, dcs_sram + 0x1000);
memory_install_ram(dcs.data, 0x2800, 0x37ff, 0, 0, dcs_sram + 0x2000);
dcs.data->install_ram(0x0800, 0x17ff, dcs_sram + 0x0000);
dcs.data->install_ram(0x1800, 0x27ff, dcs_sram + 0x1000);
dcs.data->install_ram(0x2800, 0x37ff, dcs_sram + 0x2000);
}
/* map 1: nothing from 0800-17ff, alternate RAM at 1800-27ff, same RAM at 2800-37ff */
else
{
memory_unmap_readwrite(dcs.data, 0x0800, 0x17ff, 0, 0);
memory_install_ram(dcs.data, 0x1800, 0x27ff, 0, 0, dcs_sram + 0x3000);
memory_install_ram(dcs.data, 0x2800, 0x37ff, 0, 0, dcs_sram + 0x2000);
dcs.data->unmap_readwrite(0x0800, 0x17ff);
dcs.data->install_ram(0x1800, 0x27ff, dcs_sram + 0x3000);
dcs.data->install_ram(0x2800, 0x37ff, dcs_sram + 0x2000);
}
}
@ -1159,14 +1159,14 @@ static void sdrc_remap_memory(running_machine *machine)
{
int baseaddr = (SDRC_ROM_ST == 0) ? 0x0000 : (SDRC_ROM_ST == 1) ? 0x3000 : 0x3400;
int pagesize = (SDRC_ROM_SZ == 0 && SDRC_ROM_ST != 0) ? 4096 : 1024;
memory_install_read_bank(dcs.data, baseaddr, baseaddr + pagesize - 1, 0, 0, "rompage");
dcs.data->install_read_bank(baseaddr, baseaddr + pagesize - 1, "rompage");
}
/* map the DRAM page as bank 26 */
if (SDRC_DM_ST != 0)
{
int baseaddr = (SDRC_DM_ST == 1) ? 0x0000 : (SDRC_DM_ST == 2) ? 0x3000 : 0x3400;
memory_install_readwrite_bank(dcs.data, baseaddr, baseaddr + 0x3ff, 0, 0, "drampage");
dcs.data->install_readwrite_bank(baseaddr, baseaddr + 0x3ff, "drampage");
}
/* update the bank pointers */
@ -1174,7 +1174,7 @@ static void sdrc_remap_memory(running_machine *machine)
/* reinstall the polling hotspot */
if (dcs.polling_offset)
dcs_polling_base = memory_install_readwrite16_handler(dcs.cpu->space(AS_DATA), dcs.polling_offset, dcs.polling_offset, 0, 0, dcs_polling_r, dcs_polling_w);
dcs_polling_base = dcs.cpu->space(AS_DATA)->install_legacy_readwrite_handler(dcs.polling_offset, dcs.polling_offset, FUNC(dcs_polling_r), FUNC(dcs_polling_w));
}

2
src/mame/audio/jaguar.c
View File

@ -262,7 +262,7 @@ void cojag_sound_init(running_machine *machine)
}
#if ENABLE_SPEEDUP_HACKS
memory_install_write32_handler(machine->device("audiocpu")->memory().space(AS_PROGRAM), 0xf1a100, 0xf1a103, 0, 0, dsp_flags_w);
machine->device("audiocpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xf1a100, 0xf1a103, FUNC(dsp_flags_w));
#endif
}

8
src/mame/audio/leland.c
View File

@ -1511,12 +1511,12 @@ static WRITE16_DEVICE_HANDLER( i80186_internal_port_w )
temp = (state->i80186.mem.peripheral & 0xffc0) << 4;
if (state->i80186.mem.middle_size & 0x0040)
{
memory_install_readwrite16_device_handler(state->i80186.cpu->memory().space(AS_PROGRAM), device, temp, temp + 0x2ff, 0, 0, peripheral_r, peripheral_w);
state->i80186.cpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(*device, temp, temp + 0x2ff, FUNC(peripheral_r), FUNC(peripheral_w));
}
else
{
temp &= 0xffff;
memory_install_readwrite16_device_handler(state->i80186.cpu->memory().space(AS_IO), device, temp, temp + 0x2ff, 0, 0, peripheral_r, peripheral_w);
state->i80186.cpu->memory().space(AS_IO)->install_legacy_readwrite_handler(*device, temp, temp + 0x2ff, FUNC(peripheral_r), FUNC(peripheral_w));
}
/* we need to do this at a time when the 80186 context is swapped in */
@ -1582,12 +1582,12 @@ static WRITE16_DEVICE_HANDLER( i80186_internal_port_w )
temp = (data & 0x0fff) << 8;
if (data & 0x1000)
{
memory_install_readwrite16_device_handler(state->i80186.cpu->memory().space(AS_PROGRAM), device, temp, temp + 0xff, 0, 0, i80186_internal_port_r, i80186_internal_port_w);
state->i80186.cpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(*device, temp, temp + 0xff, FUNC(i80186_internal_port_r), FUNC(i80186_internal_port_w));
}
else
{
temp &= 0xffff;
memory_install_readwrite16_device_handler(state->i80186.cpu->memory().space(AS_IO), device, temp, temp + 0xff, 0, 0, i80186_internal_port_r, i80186_internal_port_w);
state->i80186.cpu->memory().space(AS_IO)->install_legacy_readwrite_handler(*device, temp, temp + 0xff, FUNC(i80186_internal_port_r), FUNC(i80186_internal_port_w));
}
/* popmessage("Sound CPU reset");*/
break;

2
src/mame/audio/mario.c
View File

@ -425,7 +425,7 @@ static SOUND_START( mario )
if (audiocpu != NULL && audiocpu->type() != Z80)
{
state->eabank = "bank1";
memory_install_read_bank(audiocpu->memory().space(AS_PROGRAM), 0x000, 0x7ff, 0, 0, "bank1");
audiocpu->memory().space(AS_PROGRAM)->install_read_bank(0x000, 0x7ff, "bank1");
memory_configure_bank(machine, "bank1", 0, 1, machine->region("audiocpu")->base(), 0);
memory_configure_bank(machine, "bank1", 1, 1, machine->region("audiocpu")->base() + 0x1000, 0x800);
}

2
src/mame/audio/namcoc7x.c
View File

@ -90,7 +90,7 @@ void namcoc7x_on_driver_init(running_machine *machine)
// install speedup cheat
for (cpu = machine->device("maincpu"); cpu != NULL; cpu = cpu->typenext())
if (cpu->type() == M37702)
memory_install_readwrite16_handler(cpu->memory().space(AS_PROGRAM), 0x82, 0x83, 0, 0, speedup_r, speedup_w);
cpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x82, 0x83, FUNC(speedup_r), FUNC(speedup_w));
}
void namcoc7x_set_host_ram(UINT32 *hostram)

2
src/mame/drivers/1943.c
View File

@ -603,7 +603,7 @@ static DRIVER_INIT( 1943b )
DRIVER_INIT_CALL( 1943 );
//it expects 0x00 to be returned from the protection reads because the protection has been patched out.
//AM_RANGE(0xc007, 0xc007) AM_READ(c1943_protection_r)
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc007, 0xc007, 0, 0, _1943b_c007_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc007, 0xc007, FUNC(_1943b_c007_r));
}

2
src/mame/drivers/39in1.c
View File

@ -1460,7 +1460,7 @@ static DRIVER_INIT( 39in1 )
state->eeprom = machine->device<eeprom_device>("eeprom");
address_space *space = machine->device<pxa255_device>("maincpu")->space(AS_PROGRAM);
memory_install_read32_handler (space, 0xa0151648, 0xa015164b, 0, 0, prot_cheater_r);
space->install_legacy_read_handler (0xa0151648, 0xa015164b, FUNC(prot_cheater_r));
}
static ADDRESS_MAP_START( 39in1_map, AS_PROGRAM, 32 )

4
src/mame/drivers/actfancr.c
View File

@ -616,12 +616,12 @@ static READ8_HANDLER( cyclej_r )
static DRIVER_INIT( actfancr )
{
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x1f0026, 0x1f0027, 0, 0, cycle_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x1f0026, 0x1f0027, FUNC(cycle_r));
}
static DRIVER_INIT( actfancrj )
{
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x1f0026, 0x1f0027, 0, 0, cyclej_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x1f0026, 0x1f0027, FUNC(cyclej_r));
}

2
src/mame/drivers/airbustr.c
View File

@ -798,7 +798,7 @@ ROM_END
static DRIVER_INIT( airbustr )
{
memory_install_read8_handler(machine->device("master")->memory().space(AS_PROGRAM), 0xe000, 0xefff, 0, 0, devram_r); // protection device lives here
machine->device("master")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xe000, 0xefff, FUNC(devram_r)); // protection device lives here
}

4
src/mame/drivers/alg.c
View File

@ -229,11 +229,11 @@ static WRITE8_DEVICE_HANDLER( alg_cia_0_porta_w )
/* swap the write handlers between ROM and bank 1 based on the bit */
if ((data & 1) == 0)
/* overlay disabled, map RAM on 0x000000 */
memory_install_write_bank(space, 0x000000, 0x07ffff, 0, 0, "bank1");
space->install_write_bank(0x000000, 0x07ffff, "bank1");
else
/* overlay enabled, map Amiga system ROM on 0x000000 */
memory_unmap_write(space, 0x000000, 0x07ffff, 0, 0);
space->unmap_write(0x000000, 0x07ffff);
}

2
src/mame/drivers/alpha68k.c
View File

@ -3108,7 +3108,7 @@ static DRIVER_INIT( kyros )
static DRIVER_INIT( jongbou )
{
alpha68k_state *state = machine->driver_data<alpha68k_state>();
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0c0000, 0x0c0001, 0, 0, jongbou_inputs_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x0c0000, 0x0c0001, FUNC(jongbou_inputs_r));
state->invert_controls = 0;
state->microcontroller_id = 0x00ff;
state->coin_id = 0x23 | (0x24 << 8);

8
src/mame/drivers/arcadia.c
View File

@ -75,9 +75,9 @@ public:
static WRITE16_HANDLER( arcadia_multibios_change_game )
{
if (data == 0)
memory_install_read_bank(space, 0x800000, 0x97ffff, 0, 0, "bank2");
space->install_read_bank(0x800000, 0x97ffff, "bank2");
else
memory_nop_read(space, 0x800000, 0x97ffff, 0, 0);
space->nop_read(0x800000, 0x97ffff);
}
@ -105,11 +105,11 @@ static WRITE8_DEVICE_HANDLER( arcadia_cia_0_porta_w )
/* swap the write handlers between ROM and bank 1 based on the bit */
if ((data & 1) == 0)
/* overlay disabled, map RAM on 0x000000 */
memory_install_write_bank(device->machine->device("maincpu")->memory().space(AS_PROGRAM), 0x000000, 0x07ffff, 0, 0, "bank1");
device->machine->device("maincpu")->memory().space(AS_PROGRAM)->install_write_bank(0x000000, 0x07ffff, "bank1");
else
/* overlay enabled, map Amiga system ROM on 0x000000 */
memory_unmap_write(device->machine->device("maincpu")->memory().space(AS_PROGRAM), 0x000000, 0x07ffff, 0, 0);
device->machine->device("maincpu")->memory().space(AS_PROGRAM)->unmap_write(0x000000, 0x07ffff);
/* bit 2 = Power Led on Amiga */
set_led_status(device->machine, 0, (data & 2) ? 0 : 1);

10
src/mame/drivers/arkanoid.c
View File

@ -1446,10 +1446,10 @@ ROM_END
static void arkanoid_bootleg_init( running_machine *machine )
{
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xf000, 0xf000, 0, 0, arkanoid_bootleg_f000_r );
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xf002, 0xf002, 0, 0, arkanoid_bootleg_f002_r );
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xd018, 0xd018, 0, 0, arkanoid_bootleg_d018_w );
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xd008, 0xd008, 0, 0, arkanoid_bootleg_d008_r );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xf000, 0xf000, FUNC(arkanoid_bootleg_f000_r) );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xf002, 0xf002, FUNC(arkanoid_bootleg_f002_r) );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xd018, 0xd018, FUNC(arkanoid_bootleg_d018_w) );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xd008, 0xd008, FUNC(arkanoid_bootleg_d008_r) );
}
static DRIVER_INIT( arkangc )
@ -1541,7 +1541,7 @@ static DRIVER_INIT( tetrsark )
ROM[x] = ROM[x] ^ 0x94;
}
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xd008, 0xd008, 0, 0, tetrsark_d008_w );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xd008, 0xd008, FUNC(tetrsark_d008_w) );
}

2
src/mame/drivers/artmagic.c
View File

@ -1172,7 +1172,7 @@ static DRIVER_INIT( ultennis )
state->protection_handler = ultennis_protection;
/* additional (protection?) hack */
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x300000, 0x300001, 0, 0, ultennis_hack_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x300000, 0x300001, FUNC(ultennis_hack_r));
}

6
src/mame/drivers/asteroid.c
View File

@ -921,14 +921,14 @@ ROM_END
static DRIVER_INIT( asteroidb )
{
memory_install_read_port(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2000, 0x2000, 0, 0, "IN0");
memory_install_read_port(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2003, 0x2003, 0, 0, "HS");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port(0x2000, 0x2000, "IN0");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port(0x2003, 0x2003, "HS");
}
static DRIVER_INIT( asterock )
{
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2000, 0x2007, 0, 0, asterock_IN0_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x2000, 0x2007, FUNC(asterock_IN0_r));
}

62
src/mame/drivers/astrocde.c
View File

@ -431,12 +431,12 @@ static WRITE8_HANDLER( profpac_banksw_w )
profpac_bank = data;
/* set the main banking */
memory_install_read_bank(space, 0x4000, 0xbfff, 0, 0, "bank1");
space->install_read_bank(0x4000, 0xbfff, "bank1");
memory_set_bankptr(space->machine, "bank1", space->machine->region("user1")->base() + 0x8000 * bank);
/* bank 0 reads video RAM in the 4000-7FFF range */
if (bank == 0)
memory_install_read8_handler(space, 0x4000, 0x7fff, 0, 0, profpac_videoram_r);
space->install_legacy_read_handler(0x4000, 0x7fff, FUNC(profpac_videoram_r));
/* if we have a 640k EPROM board, map that on top of the 4000-7FFF range if specified */
if ((data & 0x80) && space->machine->region("user2")->base() != NULL)
@ -447,11 +447,11 @@ static WRITE8_HANDLER( profpac_banksw_w )
/* if the bank is in range, map the appropriate bank */
if (bank < 0x28)
{
memory_install_read_bank(space, 0x4000, 0x7fff, 0, 0, "bank2");
space->install_read_bank(0x4000, 0x7fff, "bank2");
memory_set_bankptr(space->machine, "bank2", space->machine->region("user2")->base() + 0x4000 * bank);
}
else
memory_unmap_read(space, 0x4000, 0x7fff, 0, 0);
space->unmap_read(0x4000, 0x7fff);
}
}
@ -1729,48 +1729,48 @@ ROM_END
static DRIVER_INIT( seawolf2 )
{
astrocade_video_config = 0x00;
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x40, 0x40, 0, 0xff18, seawolf2_sound_1_w);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x41, 0x41, 0, 0xff18, seawolf2_sound_2_w);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x42, 0x43, 0, 0xff18, seawolf2_lamps_w);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x40, 0x40, 0, 0xff18, FUNC(seawolf2_sound_1_w));
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x41, 0x41, 0, 0xff18, FUNC(seawolf2_sound_2_w));
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x42, 0x43, 0, 0xff18, FUNC(seawolf2_lamps_w));
}
static DRIVER_INIT( ebases )
{
astrocade_video_config = AC_SOUND_PRESENT;
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x20, 0x20, 0, 0xff07, ebases_coin_w);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x28, 0x28, 0, 0xff07, ebases_trackball_select_w);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x20, 0x20, 0, 0xff07, FUNC(ebases_coin_w));
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x28, 0x28, 0, 0xff07, FUNC(ebases_trackball_select_w));
}
static DRIVER_INIT( spacezap )
{
astrocade_video_config = AC_SOUND_PRESENT | AC_MONITOR_BW;
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x13, 0x13, 0x03ff, 0xff00, spacezap_io_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x13, 0x13, 0x03ff, 0xff00, FUNC(spacezap_io_r));
}
static DRIVER_INIT( wow )
{
astrocade_video_config = AC_SOUND_PRESENT | AC_LIGHTPEN_INTS | AC_STARS;
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x15, 0x15, 0x0fff, 0xff00, wow_io_r);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x17, 0x17, 0xffff, 0xff00, wow_speech_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x15, 0x15, 0x0fff, 0xff00, FUNC(wow_io_r));
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x17, 0x17, 0xffff, 0xff00, FUNC(wow_speech_r));
}
static DRIVER_INIT( gorf )
{
astrocade_video_config = AC_SOUND_PRESENT | AC_LIGHTPEN_INTS | AC_STARS;
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x15, 0x15, 0x0fff, 0xff00, gorf_io_1_r);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x16, 0x16, 0x0fff, 0xff00, gorf_io_2_r);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x17, 0x17, 0xffff, 0xff00, gorf_speech_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x15, 0x15, 0x0fff, 0xff00, FUNC(gorf_io_1_r));
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x16, 0x16, 0x0fff, 0xff00, FUNC(gorf_io_2_r));
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x17, 0x17, 0xffff, 0xff00, FUNC(gorf_speech_r));
}
static DRIVER_INIT( robby )
{
astrocade_video_config = AC_SOUND_PRESENT;
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x15, 0x15, 0x0fff, 0xff00, robby_io_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x15, 0x15, 0x0fff, 0xff00, FUNC(robby_io_r));
}
@ -1779,8 +1779,8 @@ static DRIVER_INIT( profpac )
address_space *iospace = machine->device("maincpu")->memory().space(AS_IO);
astrocade_video_config = AC_SOUND_PRESENT;
memory_install_read8_handler(iospace, 0x14, 0x14, 0x0fff, 0xff00, profpac_io_1_r);
memory_install_read8_handler(iospace, 0x15, 0x15, 0x77ff, 0xff00, profpac_io_2_r);
iospace->install_legacy_read_handler(0x14, 0x14, 0x0fff, 0xff00, FUNC(profpac_io_1_r));
iospace->install_legacy_read_handler(0x15, 0x15, 0x77ff, 0xff00, FUNC(profpac_io_2_r));
/* reset banking */
profpac_banksw_w(iospace, 0, 0);
@ -1793,10 +1793,10 @@ static DRIVER_INIT( demndrgn )
address_space *iospace = machine->device("maincpu")->memory().space(AS_IO);
astrocade_video_config = 0x00;
memory_install_read8_handler(iospace, 0x14, 0x14, 0x1fff, 0xff00, demndrgn_io_r);
memory_install_read_port(iospace, 0x1c, 0x1c, 0x0000, 0xff00, "FIREX");
memory_install_read_port(iospace, 0x1d, 0x1d, 0x0000, 0xff00, "FIREY");
memory_install_write8_handler(iospace, 0x97, 0x97, 0x0000, 0xff00, demndrgn_sound_w);
iospace->install_legacy_read_handler(0x14, 0x14, 0x1fff, 0xff00, FUNC(demndrgn_io_r));
iospace->install_read_port(0x1c, 0x1c, 0x0000, 0xff00, "FIREX");
iospace->install_read_port(0x1d, 0x1d, 0x0000, 0xff00, "FIREY");
iospace->install_legacy_write_handler(0x97, 0x97, 0x0000, 0xff00, FUNC(demndrgn_sound_w));
/* reset banking */
profpac_banksw_w(iospace, 0, 0);
@ -1809,15 +1809,15 @@ static DRIVER_INIT( tenpindx )
address_space *iospace = machine->device("maincpu")->memory().space(AS_IO);
astrocade_video_config = 0x00;
memory_install_read_port(iospace, 0x60, 0x60, 0x0000, 0xff00, "P60");
memory_install_read_port(iospace, 0x61, 0x61, 0x0000, 0xff00, "P61");
memory_install_read_port(iospace, 0x62, 0x62, 0x0000, 0xff00, "P62");
memory_install_read_port(iospace, 0x63, 0x63, 0x0000, 0xff00, "P63");
memory_install_read_port(iospace, 0x64, 0x64, 0x0000, 0xff00, "P64");
memory_install_write8_handler(iospace, 0x65, 0x66, 0x0000, 0xff00, tenpindx_lamp_w);
memory_install_write8_handler(iospace, 0x67, 0x67, 0x0000, 0xff00, tenpindx_counter_w);
memory_install_write8_handler(iospace, 0x68, 0x68, 0x0000, 0xff00, tenpindx_lights_w);
memory_install_write8_handler(iospace, 0x97, 0x97, 0x0000, 0xff00, tenpindx_sound_w);
iospace->install_read_port(0x60, 0x60, 0x0000, 0xff00, "P60");
iospace->install_read_port(0x61, 0x61, 0x0000, 0xff00, "P61");
iospace->install_read_port(0x62, 0x62, 0x0000, 0xff00, "P62");
iospace->install_read_port(0x63, 0x63, 0x0000, 0xff00, "P63");
iospace->install_read_port(0x64, 0x64, 0x0000, 0xff00, "P64");
iospace->install_legacy_write_handler(0x65, 0x66, 0x0000, 0xff00, FUNC(tenpindx_lamp_w));
iospace->install_legacy_write_handler(0x67, 0x67, 0x0000, 0xff00, FUNC(tenpindx_counter_w));
iospace->install_legacy_write_handler(0x68, 0x68, 0x0000, 0xff00, FUNC(tenpindx_lights_w));
iospace->install_legacy_write_handler(0x97, 0x97, 0x0000, 0xff00, FUNC(tenpindx_sound_w));
/* reset banking */
profpac_banksw_w(iospace, 0, 0);

12
src/mame/drivers/astrof.c
View File

@ -1308,8 +1308,8 @@ static DRIVER_INIT( abattle )
rom[i] = prom[rom[i]];
/* set up protection handlers */
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa003, 0xa003, 0, 0, shoot_r);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa004, 0xa004, 0, 0, abattle_coin_prot_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa003, 0xa003, FUNC(shoot_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa004, 0xa004, FUNC(abattle_coin_prot_r));
}
@ -1322,8 +1322,8 @@ static DRIVER_INIT( afire )
rom[i] = ~rom[i];
/* set up protection handlers */
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa003, 0xa003, 0, 0, shoot_r);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa004, 0xa004, 0, 0, afire_coin_prot_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa003, 0xa003, FUNC(shoot_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa004, 0xa004, FUNC(afire_coin_prot_r));
}
@ -1336,8 +1336,8 @@ static DRIVER_INIT( sstarbtl )
rom[i] = ~rom[i];
/* set up protection handlers */
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa003, 0xa003, 0, 0, shoot_r);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa004, 0xa004, 0, 0, abattle_coin_prot_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa003, 0xa003, FUNC(shoot_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa004, 0xa004, FUNC(abattle_coin_prot_r));
}

2
src/mame/drivers/atarig1.c
View File

@ -192,7 +192,7 @@ static void pitfightb_cheap_slapstic_init(running_machine *machine)
atarig1_state *state = machine->driver_data<atarig1_state>();
/* install a read handler */
state->bslapstic_base = memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x038000, 0x03ffff, 0, 0, pitfightb_cheap_slapstic_r);
state->bslapstic_base = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x038000, 0x03ffff, FUNC(pitfightb_cheap_slapstic_r));
/* allocate memory for a copy of bank 0 */
state->bslapstic_bank0 = auto_alloc_array(machine, UINT8, 0x2000);

4
src/mame/drivers/atarig42.c
View File

@ -801,7 +801,7 @@ static DRIVER_INIT( roadriot )
state->playfield_base = 0x400;
address_space *main = machine->device<m68000_device>("maincpu")->space(AS_PROGRAM);
state->sloop_base = memory_install_readwrite16_handler(main, 0x000000, 0x07ffff, 0, 0, roadriot_sloop_data_r, roadriot_sloop_data_w);
state->sloop_base = main->install_legacy_readwrite_handler(0x000000, 0x07ffff, FUNC(roadriot_sloop_data_r), FUNC(roadriot_sloop_data_w));
main->set_direct_update_handler(direct_update_delegate_create_static(atarig42_sloop_direct_handler, *machine));
asic65_config(machine, ASIC65_ROMBASED);
@ -840,7 +840,7 @@ static DRIVER_INIT( guardian )
*(UINT16 *)&machine->region("maincpu")->base()[0x80000] = 0x4E75;
address_space *main = machine->device<m68000_device>("maincpu")->space(AS_PROGRAM);
state->sloop_base = memory_install_readwrite16_handler(main, 0x000000, 0x07ffff, 0, 0, guardians_sloop_data_r, guardians_sloop_data_w);
state->sloop_base = main->install_legacy_readwrite_handler(0x000000, 0x07ffff, FUNC(guardians_sloop_data_r), FUNC(guardians_sloop_data_w));
main->set_direct_update_handler(direct_update_delegate_create_static(atarig42_sloop_direct_handler, *machine));
asic65_config(machine, ASIC65_GUARDIANS);

2
src/mame/drivers/atarigt.c
View File

@ -1282,7 +1282,7 @@ static DRIVER_INIT( tmek )
state->protection_w = tmek_protection_w;
/* temp hack */
memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xd72000, 0xd75fff, 0, 0, tmek_pf_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xd72000, 0xd75fff, FUNC(tmek_pf_w));
}

2
src/mame/drivers/atarigx2.c
View File

@ -2246,7 +2246,7 @@ static DRIVER_INIT( rrreveng )
state->playfield_base = 0x000;
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xca0fc0, 0xca0fc3, 0, 0, rrreveng_prot_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xca0fc0, 0xca0fc3, FUNC(rrreveng_prot_r));
}

36
src/mame/drivers/ataxx.c
View File

@ -711,7 +711,7 @@ static DRIVER_INIT( ataxx )
leland_rotate_memory(machine, "slave");
/* set up additional input ports */
memory_install_read8_handler(machine->device("master")->memory().space(AS_IO), 0x00, 0x03, 0, 0, ataxx_trackball_r);
machine->device("master")->memory().space(AS_IO)->install_legacy_read_handler(0x00, 0x03, FUNC(ataxx_trackball_r));
}
@ -721,7 +721,7 @@ static DRIVER_INIT( ataxxj )
leland_rotate_memory(machine, "slave");
/* set up additional input ports */
memory_install_read8_handler(machine->device("master")->memory().space(AS_IO), 0x00, 0x03, 0, 0, ataxx_trackball_r);
machine->device("master")->memory().space(AS_IO)->install_legacy_read_handler(0x00, 0x03, FUNC(ataxx_trackball_r));
}
@ -731,9 +731,9 @@ static DRIVER_INIT( wsf )
leland_rotate_memory(machine, "slave");
/* set up additional input ports */
memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0d, 0x0d, 0, 0, "P1_P2");
memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0e, 0x0e, 0, 0, "P3_P4");
memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0f, 0x0f, 0, 0, "BUTTONS");
machine->device("master")->memory().space(AS_IO)->install_read_port(0x0d, 0x0d, "P1_P2");
machine->device("master")->memory().space(AS_IO)->install_read_port(0x0e, 0x0e, "P3_P4");
machine->device("master")->memory().space(AS_IO)->install_read_port(0x0f, 0x0f, "BUTTONS");
}
@ -743,14 +743,14 @@ static DRIVER_INIT( indyheat )
leland_rotate_memory(machine, "slave");
/* set up additional input ports */
memory_install_read8_handler(machine->device("master")->memory().space(AS_IO), 0x00, 0x02, 0, 0, indyheat_wheel_r);
memory_install_read8_handler(machine->device("master")->memory().space(AS_IO), 0x08, 0x0b, 0, 0, indyheat_analog_r);
memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0d, 0x0d, 0, 0, "P1");
memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0e, 0x0e, 0, 0, "P2");
memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0f, 0x0f, 0, 0, "P3");
machine->device("master")->memory().space(AS_IO)->install_legacy_read_handler(0x00, 0x02, FUNC(indyheat_wheel_r));
machine->device("master")->memory().space(AS_IO)->install_legacy_read_handler(0x08, 0x0b, FUNC(indyheat_analog_r));
machine->device("master")->memory().space(AS_IO)->install_read_port(0x0d, 0x0d, "P1");
machine->device("master")->memory().space(AS_IO)->install_read_port(0x0e, 0x0e, "P2");
machine->device("master")->memory().space(AS_IO)->install_read_port(0x0f, 0x0f, "P3");
/* set up additional output ports */
memory_install_write8_handler(machine->device("master")->memory().space(AS_IO), 0x08, 0x0b, 0, 0, indyheat_analog_w);
machine->device("master")->memory().space(AS_IO)->install_legacy_write_handler(0x08, 0x0b, FUNC(indyheat_analog_w));
}
@ -760,9 +760,9 @@ static DRIVER_INIT( brutforc )
leland_rotate_memory(machine, "slave");
/* set up additional input ports */
memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0d, 0x0d, 0, 0, "P2");
memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0e, 0x0e, 0, 0, "P1");
memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0f, 0x0f, 0, 0, "P3");
machine->device("master")->memory().space(AS_IO)->install_read_port(0x0d, 0x0d, "P2");
machine->device("master")->memory().space(AS_IO)->install_read_port(0x0e, 0x0e, "P1");
machine->device("master")->memory().space(AS_IO)->install_read_port(0x0f, 0x0f, "P3");
}
@ -772,12 +772,12 @@ static DRIVER_INIT( asylum )
leland_rotate_memory(machine, "slave");
/* asylum appears to have some extra RAM for the slave CPU */
memory_install_ram(machine->device("slave")->memory().space(AS_PROGRAM), 0xf000, 0xfffb, 0, 0, NULL);
machine->device("slave")->memory().space(AS_PROGRAM)->install_ram(0xf000, 0xfffb);
/* set up additional input ports */
memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0d, 0x0d, 0, 0, "P2");
memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0e, 0x0e, 0, 0, "P1");
memory_install_read_port(machine->device("master")->memory().space(AS_IO), 0x0f, 0x0f, 0, 0, "P3");
machine->device("master")->memory().space(AS_IO)->install_read_port(0x0d, 0x0d, "P2");
machine->device("master")->memory().space(AS_IO)->install_read_port(0x0e, 0x0e, "P1");
machine->device("master")->memory().space(AS_IO)->install_read_port(0x0f, 0x0f, "P3");
}

2
src/mame/drivers/backfire.c
View File

@ -685,7 +685,7 @@ static DRIVER_INIT( backfire )
deco156_decrypt(machine);
machine->device("maincpu")->set_clock_scale(4.0f); /* core timings aren't accurate */
descramble_sound(machine);
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0170018, 0x017001b, 0, 0, backfire_speedup_r );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x0170018, 0x017001b, FUNC(backfire_speedup_r) );
}
GAME( 1995, backfire, 0, backfire, backfire, backfire, ROT0, "Data East Corporation", "Backfire! (set 1)", GAME_SUPPORTS_SAVE )

2
src/mame/drivers/bagman.c
View File

@ -934,7 +934,7 @@ static DRIVER_INIT( bagman )
/* Unmap video enable register, not available on earlier hardware revision(s)
Bagman is supposed to have glitches during screen transitions */
memory_unmap_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa003, 0xa003, 0, 0);
machine->device("maincpu")->memory().space(AS_PROGRAM)->unmap_write(0xa003, 0xa003);
*state->video_enable = 1;
}

20
src/mame/drivers/balsente.c
View File

@ -2135,47 +2135,47 @@ static DRIVER_INIT( toggle ) { expand_roms(machine, EXPAND_ALL); config_shoot
static DRIVER_INIT( nametune )
{
address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
memory_install_write8_handler(space, 0x9f00, 0x9f00, 0, 0, balsente_rombank2_select_w);
space->install_legacy_write_handler(0x9f00, 0x9f00, FUNC(balsente_rombank2_select_w));
expand_roms(machine, EXPAND_NONE | SWAP_HALVES); config_shooter_adc(machine, FALSE, 0 /* noanalog */);
}
static DRIVER_INIT( nstocker )
{
address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
memory_install_write8_handler(space, 0x9f00, 0x9f00, 0, 0, balsente_rombank2_select_w);
space->install_legacy_write_handler(0x9f00, 0x9f00, FUNC(balsente_rombank2_select_w));
expand_roms(machine, EXPAND_NONE | SWAP_HALVES); config_shooter_adc(machine, TRUE, 1);
}
static DRIVER_INIT( sfootbal )
{
address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
memory_install_write8_handler(space, 0x9f00, 0x9f00, 0, 0, balsente_rombank2_select_w);
space->install_legacy_write_handler(0x9f00, 0x9f00, FUNC(balsente_rombank2_select_w));
expand_roms(machine, EXPAND_ALL | SWAP_HALVES); config_shooter_adc(machine, FALSE, 0);
}
static DRIVER_INIT( spiker )
{
address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
memory_install_readwrite8_handler(space, 0x9f80, 0x9f8f, 0, 0, spiker_expand_r, spiker_expand_w);
memory_install_write8_handler(space, 0x9f00, 0x9f00, 0, 0, balsente_rombank2_select_w);
space->install_legacy_readwrite_handler(0x9f80, 0x9f8f, FUNC(spiker_expand_r), FUNC(spiker_expand_w));
space->install_legacy_write_handler(0x9f00, 0x9f00, FUNC(balsente_rombank2_select_w));
expand_roms(machine, EXPAND_ALL | SWAP_HALVES); config_shooter_adc(machine, FALSE, 1);
}
static DRIVER_INIT( stompin )
{
address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
memory_install_write8_handler(space, 0x9f00, 0x9f00, 0, 0, balsente_rombank2_select_w);
space->install_legacy_write_handler(0x9f00, 0x9f00, FUNC(balsente_rombank2_select_w));
expand_roms(machine, 0x0c | SWAP_HALVES); config_shooter_adc(machine, FALSE, 32);
}
static DRIVER_INIT( rescraid ) { expand_roms(machine, EXPAND_NONE); config_shooter_adc(machine, FALSE, 0 /* noanalog */); }
static DRIVER_INIT( grudge )
{
address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
memory_install_read8_handler(space, 0x9400, 0x9400, 0, 0, grudge_steering_r);
space->install_legacy_read_handler(0x9400, 0x9400, FUNC(grudge_steering_r));
expand_roms(machine, EXPAND_NONE); config_shooter_adc(machine, FALSE, 0);
}
static DRIVER_INIT( shrike )
{
address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
memory_install_readwrite8_handler(space, 0x9e00, 0x9fff, 0, 0, shrike_shared_6809_r, shrike_shared_6809_w);
memory_install_write8_handler(space, 0x9e01, 0x9e01, 0, 0, shrike_sprite_select_w );
memory_install_readwrite16_handler(machine->device("68k")->memory().space(AS_PROGRAM), 0x10000, 0x1001f, 0, 0, shrike_io_68k_r, shrike_io_68k_w);
space->install_legacy_readwrite_handler(0x9e00, 0x9fff, FUNC(shrike_shared_6809_r), FUNC(shrike_shared_6809_w));
space->install_legacy_write_handler(0x9e01, 0x9e01, FUNC(shrike_sprite_select_w) );
machine->device("68k")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x10000, 0x1001f, FUNC(shrike_io_68k_r), FUNC(shrike_io_68k_w));
expand_roms(machine, EXPAND_ALL); config_shooter_adc(machine, FALSE, 32);
}

4
src/mame/drivers/berzerk.c
View File

@ -1210,8 +1210,8 @@ ROM_END
static DRIVER_INIT( moonwarp )
{
address_space *io = machine->device("maincpu")->memory().space(AS_IO);
memory_install_read8_handler (io, 0x48, 0x48, 0, 0, moonwarp_p1_r);
memory_install_read8_handler (io, 0x4a, 0x4a, 0, 0, moonwarp_p2_r);
io->install_legacy_read_handler (0x48, 0x48, FUNC(moonwarp_p1_r));
io->install_legacy_read_handler (0x4a, 0x4a, FUNC(moonwarp_p2_r));
}
/*************************************

6
src/mame/drivers/btime.c
View File

@ -2176,7 +2176,7 @@ static DRIVER_INIT( cookrace )
btime_state *state = machine->driver_data<btime_state>();
decrypt_C10707_cpu(machine, "maincpu");
memory_install_read_bank(machine->device("audiocpu")->memory().space(AS_PROGRAM), 0x0200, 0x0fff, 0, 0, "bank10");
machine->device("audiocpu")->memory().space(AS_PROGRAM)->install_read_bank(0x0200, 0x0fff, "bank10");
memory_set_bankptr(machine, "bank10", machine->region("audiocpu")->base() + 0xe200);
state->audio_nmi_enable_type = AUDIO_ENABLE_DIRECT;
}
@ -2193,9 +2193,9 @@ static DRIVER_INIT( wtennis )
btime_state *state = machine->driver_data<btime_state>();
decrypt_C10707_cpu(machine, "maincpu");
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc15f, 0xc15f, 0, 0, wtennis_reset_hack_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc15f, 0xc15f, FUNC(wtennis_reset_hack_r));
memory_install_read_bank(machine->device("audiocpu")->memory().space(AS_PROGRAM), 0x0200, 0x0fff, 0, 0, "bank10");
machine->device("audiocpu")->memory().space(AS_PROGRAM)->install_read_bank(0x0200, 0x0fff, "bank10");
memory_set_bankptr(machine, "bank10", machine->region("audiocpu")->base() + 0xe200);
state->audio_nmi_enable_type = AUDIO_ENABLE_AY8910;
}

2
src/mame/drivers/bublbobl.c
View File

@ -1555,7 +1555,7 @@ static DRIVER_INIT( tokiob )
{
DRIVER_INIT_CALL(tokio);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfe00, 0xfe00, 0, 0, tokiob_mcu_r );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfe00, 0xfe00, FUNC(tokiob_mcu_r) );
}
static DRIVER_INIT( dland )

10
src/mame/drivers/bzone.c
View File

@ -798,11 +798,11 @@ static WRITE8_HANDLER( analog_select_w )
static DRIVER_INIT( bradley )
{
address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
memory_install_ram(space, 0x400, 0x7ff, 0, 0, NULL);
memory_install_read_port(space, 0x1808, 0x1808, 0, 0, "1808");
memory_install_read_port(space, 0x1809, 0x1809, 0, 0, "1809");
memory_install_read8_handler(space, 0x180a, 0x180a, 0, 0, analog_data_r);
memory_install_write8_handler(space, 0x1848, 0x1850, 0, 0, analog_select_w);
space->install_ram(0x400, 0x7ff);
space->install_read_port(0x1808, 0x1808, "1808");
space->install_read_port(0x1809, 0x1809, "1809");
space->install_legacy_read_handler(0x180a, 0x180a, FUNC(analog_data_r));
space->install_legacy_write_handler(0x1848, 0x1850, FUNC(analog_select_w));
}

4
src/mame/drivers/cd32.c
View File

@ -60,10 +60,10 @@ static WRITE32_HANDLER( aga_overlay_w )
/* swap the write handlers between ROM and bank 1 based on the bit */
if ((data & 1) == 0)
/* overlay disabled, map RAM on 0x000000 */
memory_install_write_bank(space, 0x000000, 0x1fffff, 0, 0, "bank1");
space->install_write_bank(0x000000, 0x1fffff, "bank1");
else
/* overlay enabled, map Amiga system ROM on 0x000000 */
memory_unmap_write(space, 0x000000, 0x1fffff, 0, 0);
space->unmap_write(0x000000, 0x1fffff);
}
}

8
src/mame/drivers/centiped.c
View File

@ -1987,8 +1987,8 @@ static DRIVER_INIT( caterplr )
{
address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
device_t *device = machine->device("pokey");
memory_install_readwrite8_device_handler(space, device, 0x1000, 0x100f, 0, 0, caterplr_AY8910_r, caterplr_AY8910_w);
memory_install_read8_device_handler(space, device, 0x1780, 0x1780, 0, 0, caterplr_rand_r);
space->install_legacy_readwrite_handler(*device, 0x1000, 0x100f, FUNC(caterplr_AY8910_r), FUNC(caterplr_AY8910_w));
space->install_legacy_read_handler(*device, 0x1780, 0x1780, FUNC(caterplr_rand_r));
}
@ -1996,8 +1996,8 @@ static DRIVER_INIT( magworm )
{
address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
device_t *device = machine->device("pokey");
memory_install_write8_device_handler(space, device, 0x1001, 0x1001, 0, 0, ay8910_address_w);
memory_install_readwrite8_device_handler(space, device, 0x1003, 0x1003, 0, 0, ay8910_r, ay8910_data_w);
space->install_legacy_write_handler(*device, 0x1001, 0x1001, FUNC(ay8910_address_w));
space->install_legacy_readwrite_handler(*device, 0x1003, 0x1003, FUNC(ay8910_r), FUNC(ay8910_data_w));
}

4
src/mame/drivers/cham24.c
View File

@ -304,7 +304,7 @@ static MACHINE_START( cham24 )
memcpy(&dst[0xc000], &src[0x0f8000], 0x4000);
/* uses 8K swapping, all ROM!*/
memory_install_read_bank(machine->device("ppu")->memory().space(AS_PROGRAM), 0x0000, 0x1fff, 0, 0, "bank1");
machine->device("ppu")->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x1fff, "bank1");
memory_set_bankptr(machine, "bank1", machine->region("gfx1")->base());
/* need nametable ram, though. I doubt this uses more than 2k, but it starts up configured for 4 */
@ -315,7 +315,7 @@ static MACHINE_START( cham24 )
state->nt_page[3] = state->nt_ram + 0xc00;
/* and read/write handlers */
memory_install_readwrite8_handler(machine->device("ppu")->memory().space(AS_PROGRAM), 0x2000, 0x3eff, 0, 0, nt_r, nt_w);
machine->device("ppu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x2000, 0x3eff, FUNC(nt_r), FUNC(nt_w));
}
static DRIVER_INIT( cham24 )

16
src/mame/drivers/chqflag.c
View File

@ -55,19 +55,19 @@ static WRITE8_HANDLER( chqflag_bankswitch_w )
/* bit 5 = memory bank select */
if (data & 0x20)
{
memory_install_read_bank(space, 0x1800, 0x1fff, 0, 0, "bank5");
memory_install_write8_handler(space, 0x1800, 0x1fff, 0, 0, paletteram_xBBBBBGGGGGRRRRR_be_w);
space->install_read_bank(0x1800, 0x1fff, "bank5");
space->install_legacy_write_handler(0x1800, 0x1fff, FUNC(paletteram_xBBBBBGGGGGRRRRR_be_w));
memory_set_bankptr(space->machine, "bank5", space->machine->generic.paletteram.v);
if (state->k051316_readroms)
memory_install_readwrite8_device_handler(space, state->k051316_1, 0x1000, 0x17ff, 0, 0, k051316_rom_r, k051316_w); /* 051316 #1 (ROM test) */
space->install_legacy_readwrite_handler(*state->k051316_1, 0x1000, 0x17ff, FUNC(k051316_rom_r), FUNC(k051316_w)); /* 051316 #1 (ROM test) */
else
memory_install_readwrite8_device_handler(space, state->k051316_1, 0x1000, 0x17ff, 0, 0, k051316_r, k051316_w); /* 051316 #1 */
space->install_legacy_readwrite_handler(*state->k051316_1, 0x1000, 0x17ff, FUNC(k051316_r), FUNC(k051316_w)); /* 051316 #1 */
}
else
{
memory_install_readwrite_bank(space, 0x1000, 0x17ff, 0, 0, "bank1"); /* RAM */
memory_install_readwrite_bank(space, 0x1800, 0x1fff, 0, 0, "bank2"); /* RAM */
space->install_readwrite_bank(0x1000, 0x17ff, "bank1"); /* RAM */
space->install_readwrite_bank(0x1800, 0x1fff, "bank2"); /* RAM */
}
/* other bits unknown/unused */
@ -85,9 +85,9 @@ static WRITE8_HANDLER( chqflag_vreg_w )
state->k051316_readroms = (data & 0x10);
if (state->k051316_readroms)
memory_install_read8_device_handler(space, state->k051316_2, 0x2800, 0x2fff, 0, 0, k051316_rom_r); /* 051316 (ROM test) */
space->install_legacy_read_handler(*state->k051316_2, 0x2800, 0x2fff, FUNC(k051316_rom_r)); /* 051316 (ROM test) */
else
memory_install_read8_device_handler(space, state->k051316_2, 0x2800, 0x2fff, 0, 0, k051316_r); /* 051316 */
space->install_legacy_read_handler(*state->k051316_2, 0x2800, 0x2fff, FUNC(k051316_r)); /* 051316 */
/* Bits 3-7 probably control palette dimming in a similar way to TMNT2/Sunset Riders, */
/* however I don't have enough evidence to determine the exact behaviour. */

16
src/mame/drivers/cinemat.c
View File

@ -1460,35 +1460,35 @@ static DRIVER_INIT( speedfrk )
{
cinemat_state *state = machine->driver_data<cinemat_state>();
state->gear = 0xe;
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x00, 0x03, 0, 0, speedfrk_wheel_r);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x04, 0x06, 0, 0, speedfrk_gear_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x00, 0x03, FUNC(speedfrk_wheel_r));
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x04, 0x06, FUNC(speedfrk_gear_r));
}
static DRIVER_INIT( sundance )
{
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x00, 0x0f, 0, 0, sundance_inputs_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x00, 0x0f, FUNC(sundance_inputs_r));
}
static DRIVER_INIT( tailg )
{
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x07, 0x07, 0, 0, mux_select_w);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x07, 0x07, FUNC(mux_select_w));
}
static DRIVER_INIT( boxingb )
{
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x0c, 0x0f, 0, 0, boxingb_dial_r);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x07, 0x07, 0, 0, mux_select_w);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x0c, 0x0f, FUNC(boxingb_dial_r));
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x07, 0x07, FUNC(mux_select_w));
}
static DRIVER_INIT( qb3 )
{
cinemat_state *state = machine->driver_data<cinemat_state>();
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x0f, 0x0f, 0, 0, qb3_frame_r);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x00, 0x00, 0, 0, qb3_ram_bank_w);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x0f, 0x0f, FUNC(qb3_frame_r));
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x00, 0x00, FUNC(qb3_ram_bank_w));
memory_configure_bank(machine, "bank1", 0, 4, state->rambase, 0x100*2);
}

2
src/mame/drivers/cischeat.c
View File

@ -2554,7 +2554,7 @@ ROM_END
static DRIVER_INIT( wildplt )
{
memory_install_read16_handler(machine->device("cpu1")->memory().space(AS_PROGRAM), 0x080000, 0x087fff, 0, 0, wildplt_vregs_r );
machine->device("cpu1")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x080000, 0x087fff, FUNC(wildplt_vregs_r) );
DRIVER_INIT_CALL(f1gpstar);
}

4
src/mame/drivers/cninja.c
View File

@ -2032,13 +2032,13 @@ static void cninja_patch( running_machine *machine )
static DRIVER_INIT( cninja )
{
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x1bc0a8, 0x1bc0a9, 0, 0, cninja_sound_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x1bc0a8, 0x1bc0a9, FUNC(cninja_sound_w));
cninja_patch(machine);
}
static DRIVER_INIT( stoneage )
{
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x1bc0a8, 0x1bc0a9, 0, 0, stoneage_sound_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x1bc0a8, 0x1bc0a9, FUNC(stoneage_sound_w));
}
static DRIVER_INIT( mutantf )

24
src/mame/drivers/cojag.c
View File

@ -1536,10 +1536,10 @@ static void cojag_common_init(running_machine *machine, UINT16 gpu_jump_offs, UI
/* install synchronization hooks for GPU */
if (cojag_is_r3000)
memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x04f0b000 + gpu_jump_offs, 0x04f0b003 + gpu_jump_offs, 0, 0, gpu_jump_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x04f0b000 + gpu_jump_offs, 0x04f0b003 + gpu_jump_offs, FUNC(gpu_jump_w));
else
memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xf0b000 + gpu_jump_offs, 0xf0b003 + gpu_jump_offs, 0, 0, gpu_jump_w);
memory_install_read32_handler(machine->device("gpu")->memory().space(AS_PROGRAM), 0xf03000 + gpu_jump_offs, 0xf03003 + gpu_jump_offs, 0, 0, gpu_jump_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xf0b000 + gpu_jump_offs, 0xf0b003 + gpu_jump_offs, FUNC(gpu_jump_w));
machine->device("gpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xf03000 + gpu_jump_offs, 0xf03003 + gpu_jump_offs, FUNC(gpu_jump_r));
state->gpu_jump_address = &jaguar_gpu_ram[gpu_jump_offs/4];
state->gpu_spin_pc = 0xf03000 + spin_pc;
@ -1555,7 +1555,7 @@ static DRIVER_INIT( area51a )
#if ENABLE_SPEEDUP_HACKS
/* install speedup for main CPU */
state->main_speedup = memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa02030, 0xa02033, 0, 0, area51_main_speedup_w);
state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xa02030, 0xa02033, FUNC(area51_main_speedup_w));
#endif
}
@ -1568,7 +1568,7 @@ static DRIVER_INIT( area51 )
#if ENABLE_SPEEDUP_HACKS
/* install speedup for main CPU */
state->main_speedup_max_cycles = 120;
state->main_speedup = memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x100062e8, 0x100062eb, 0, 0, cojagr3k_main_speedup_r);
state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x100062e8, 0x100062eb, FUNC(cojagr3k_main_speedup_r));
#endif
}
@ -1583,7 +1583,7 @@ static DRIVER_INIT( maxforce )
#if ENABLE_SPEEDUP_HACKS
/* install speedup for main CPU */
state->main_speedup_max_cycles = 120;
state->main_speedup = memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x1000865c, 0x1000865f, 0, 0, cojagr3k_main_speedup_r);
state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x1000865c, 0x1000865f, FUNC(cojagr3k_main_speedup_r));
#endif
}
@ -1598,7 +1598,7 @@ static DRIVER_INIT( area51mx )
#if ENABLE_SPEEDUP_HACKS
/* install speedup for main CPU */
state->main_speedup = memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xa19550, 0xa19557, 0, 0, area51mx_main_speedup_w);
state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xa19550, 0xa19557, FUNC(area51mx_main_speedup_w));
#endif
}
@ -1614,7 +1614,7 @@ static DRIVER_INIT( a51mxr3k )
#if ENABLE_SPEEDUP_HACKS
/* install speedup for main CPU */
state->main_speedup_max_cycles = 120;
state->main_speedup = memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x10006f0c, 0x10006f0f, 0, 0, cojagr3k_main_speedup_r);
state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x10006f0c, 0x10006f0f, FUNC(cojagr3k_main_speedup_r));
#endif
}
@ -1627,7 +1627,7 @@ static DRIVER_INIT( fishfren )
#if ENABLE_SPEEDUP_HACKS
/* install speedup for main CPU */
state->main_speedup_max_cycles = 200;
state->main_speedup = memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x10021b60, 0x10021b63, 0, 0, cojagr3k_main_speedup_r);
state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x10021b60, 0x10021b63, FUNC(cojagr3k_main_speedup_r));
#endif
}
@ -1641,8 +1641,8 @@ static void init_freeze_common(running_machine *machine, offs_t main_speedup_add
/* install speedup for main CPU */
state->main_speedup_max_cycles = 200;
if (main_speedup_addr != 0)
state->main_speedup = memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), main_speedup_addr, main_speedup_addr + 3, 0, 0, cojagr3k_main_speedup_r);
state->main_gpu_wait = memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0400d900, 0x0400d900 + 3, 0, 0, main_gpu_wait_r);
state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(main_speedup_addr, main_speedup_addr + 3, FUNC(cojagr3k_main_speedup_r));
state->main_gpu_wait = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x0400d900, 0x0400d900 + 3, FUNC(main_gpu_wait_r));
#endif
}
@ -1662,7 +1662,7 @@ static DRIVER_INIT( vcircle )
#if ENABLE_SPEEDUP_HACKS
/* install speedup for main CPU */
state->main_speedup_max_cycles = 50;
state->main_speedup = memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x12005b34, 0x12005b37, 0, 0, cojagr3k_main_speedup_r);
state->main_speedup = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x12005b34, 0x12005b37, FUNC(cojagr3k_main_speedup_r));
#endif
}

10
src/mame/drivers/combatsc.c
View File

@ -251,13 +251,13 @@ static WRITE8_HANDLER( combatscb_bankselect_w )
if (data == 0x1f)
{
memory_set_bank(space->machine, "bank1", 8 + (data & 1));
memory_install_write8_handler(space, 0x4000, 0x7fff, 0, 0, combatscb_io_w);
memory_install_read8_handler(space, 0x4400, 0x4403, 0, 0, combatscb_io_r);/* IO RAM & Video Registers */
space->install_legacy_write_handler(0x4000, 0x7fff, FUNC(combatscb_io_w));
space->install_legacy_read_handler(0x4400, 0x4403, FUNC(combatscb_io_r));/* IO RAM & Video Registers */
}
else
{
memory_install_read_bank(space, 0x4000, 0x7fff, 0, 0, "bank1"); /* banked ROM */
memory_unmap_write(space, 0x4000, 0x7fff, 0, 0); /* banked ROM */
space->install_read_bank(0x4000, 0x7fff, "bank1"); /* banked ROM */
space->unmap_write(0x4000, 0x7fff); /* banked ROM */
}
}
}
@ -995,7 +995,7 @@ ROM_END
static DRIVER_INIT( combatsc )
{
/* joystick instead of trackball */
memory_install_read_port(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0404, 0x0404, 0, 0, "IN1");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port(0x0404, 0x0404, "IN1");
}

2
src/mame/drivers/coolpool.c
View File

@ -1200,7 +1200,7 @@ static DRIVER_INIT( amerdart )
static DRIVER_INIT( coolpool )
{
memory_install_read16_handler(machine->device("dsp")->memory().space(AS_IO), 0x07, 0x07, 0, 0, coolpool_input_r);
machine->device("dsp")->memory().space(AS_IO)->install_legacy_read_handler(0x07, 0x07, FUNC(coolpool_input_r));
register_state_save(machine);
}

4
src/mame/drivers/coolridr.c
View File

@ -1187,8 +1187,8 @@ static READ32_HANDLER( coolridr_hack2_r )
static DRIVER_INIT( coolridr )
{
// memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x60d88a4, 0x060d88a7, 0, 0, coolridr_hack1_r );
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x60d8894, 0x060d8897, 0, 0, coolridr_hack2_r );
// machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x60d88a4, 0x060d88a7, FUNC(coolridr_hack1_r) );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x60d8894, 0x060d8897, FUNC(coolridr_hack2_r) );
}
GAME( 1995, coolridr, 0, coolridr, coolridr, coolridr, ROT0, "Sega", "Cool Riders (US)",GAME_NOT_WORKING|GAME_NO_SOUND )

10
src/mame/drivers/cosmic.c
View File

@ -1596,17 +1596,17 @@ static DRIVER_INIT( cosmica )
static DRIVER_INIT( devzone )
{
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x4807, 0x4807, 0, 0, cosmic_background_enable_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x4807, 0x4807, FUNC(cosmic_background_enable_w));
}
static DRIVER_INIT( nomnlnd )
{
device_t *dac = machine->device("dac");
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x5000, 0x5001, 0, 0, nomnlnd_port_0_1_r);
memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x4800, 0x4800, 0, 0);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x4807, 0x4807, 0, 0, cosmic_background_enable_w);
memory_install_write8_device_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), dac, 0x480a, 0x480a, 0, 0, dac_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x5000, 0x5001, FUNC(nomnlnd_port_0_1_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0x4800, 0x4800);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x4807, 0x4807, FUNC(cosmic_background_enable_w));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(*dac, 0x480a, 0x480a, FUNC(dac_w));
}
static DRIVER_INIT( panic )

30
src/mame/drivers/cps1.c
View File

@ -9965,10 +9965,10 @@ static DRIVER_INIT( forgottn )
/* Forgotten Worlds has a NEC uPD4701AC on the B-board handling dial inputs from the CN-MOWS connector. */
/* The memory mapping is handled by PAL LWIO */
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x800040, 0x800041, 0, 0, forgottn_dial_0_reset_w);
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x800048, 0x800049, 0, 0, forgottn_dial_1_reset_w);
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x800052, 0x800055, 0, 0, forgottn_dial_0_r);
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x80005a, 0x80005d, 0, 0, forgottn_dial_1_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x800040, 0x800041, FUNC(forgottn_dial_0_reset_w));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x800048, 0x800049, FUNC(forgottn_dial_1_reset_w));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x800052, 0x800055, FUNC(forgottn_dial_0_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x80005a, 0x80005d, FUNC(forgottn_dial_1_r));
state->save_item(NAME(state->dial));
@ -9982,8 +9982,8 @@ static DRIVER_INIT( sf2ee )
{
/* This specific revision of SF2 has the CPS-B custom mapped at a different address. */
/* The mapping is handled by the PAL IOB2 on the B-board */
memory_unmap_readwrite(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x800140, 0x80017f, 0, 0);
memory_install_readwrite16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x8001c0, 0x8001ff, 0, 0, cps1_cps_b_r, cps1_cps_b_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->unmap_readwrite(0x800140, 0x80017f);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x8001c0, 0x8001ff, FUNC(cps1_cps_b_r), FUNC(cps1_cps_b_w));
DRIVER_INIT_CALL(cps1);
}
@ -9991,7 +9991,7 @@ static DRIVER_INIT( sf2ee )
static DRIVER_INIT( sf2thndr )
{
/* This particular hack uses a modified B-board PAL which mirrors the CPS-B registers at an alternate address */
memory_install_readwrite16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x8001c0, 0x8001ff, 0, 0, cps1_cps_b_r, cps1_cps_b_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x8001c0, 0x8001ff, FUNC(cps1_cps_b_r), FUNC(cps1_cps_b_w));
DRIVER_INIT_CALL(cps1);
}
@ -9999,7 +9999,7 @@ static DRIVER_INIT( sf2thndr )
static DRIVER_INIT( sf2hack )
{
/* some SF2 hacks have some inputs wired to the LSB instead of MSB */
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x800018, 0x80001f, 0, 0, cps1_hack_dsw_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x800018, 0x80001f, FUNC(cps1_hack_dsw_r));
DRIVER_INIT_CALL(cps1);
}
@ -10032,7 +10032,7 @@ static DRIVER_INIT( pang3n )
{
/* Pang 3 is the only non-QSound game to have an EEPROM. */
/* It is mapped in the CPS-B address range so probably is on the C-board. */
memory_install_readwrite_port(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x80017a, 0x80017b, 0, 0, "EEPROMIN", "EEPROMOUT");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_readwrite_port(0x80017a, 0x80017b, "EEPROMIN", "EEPROMOUT");
DRIVER_INIT_CALL(cps1);
}
@ -10083,11 +10083,11 @@ static DRIVER_INIT( sf2mdt )
rom[i + 3] = rom[i + 6];
rom[i + 6] = tmp;
}
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x70c01a, 0x70c01b, 0, 0, sf2mdt_r);
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x70c01c, 0x70c01d, 0, 0, sf2mdt_r);
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x70c01e, 0x70c01f, 0, 0, sf2mdt_r);
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x70c010, 0x70c011, 0, 0, sf2mdt_r);
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x70c018, 0x70c019, 0, 0, sf2mdt_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x70c01a, 0x70c01b, FUNC(sf2mdt_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x70c01c, 0x70c01d, FUNC(sf2mdt_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x70c01e, 0x70c01f, FUNC(sf2mdt_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x70c010, 0x70c011, FUNC(sf2mdt_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x70c018, 0x70c019, FUNC(sf2mdt_r));
DRIVER_INIT_CALL(cps1);
}
@ -10095,7 +10095,7 @@ static DRIVER_INIT( sf2mdt )
static DRIVER_INIT( dinohunt )
{
// is this shared with the new sound hw?
UINT8* ram = (UINT8*)memory_install_ram(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xf18000, 0xf19fff, 0, 0, 0);
UINT8* ram = (UINT8*)machine->device("maincpu")->memory().space(AS_PROGRAM)->install_ram(0xf18000, 0xf19fff);
memset(ram,0xff,0x2000);
DRIVER_INIT_CALL(cps1);
}

4
src/mame/drivers/cps2.c
View File

@ -8012,7 +8012,7 @@ static DRIVER_INIT ( pzloop2 )
state->save_item(NAME(state->readpaddle));
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x804000, 0x804001, 0, 0, joy_or_paddle_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x804000, 0x804001, FUNC(joy_or_paddle_r));
}
static READ16_HANDLER( gigamn2_dummyqsound_r )
@ -8039,7 +8039,7 @@ static DRIVER_INIT( gigamn2 )
state->gigamn2_dummyqsound_ram = auto_alloc_array(machine, UINT16, 0x20000 / 2);
state->save_pointer(NAME(state->gigamn2_dummyqsound_ram), 0x20000 / 2);
memory_install_readwrite16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x618000, 0x619fff, 0, 0, gigamn2_dummyqsound_r, gigamn2_dummyqsound_w); // no qsound..
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x618000, 0x619fff, FUNC(gigamn2_dummyqsound_r), FUNC(gigamn2_dummyqsound_w)); // no qsound..
space->set_decrypted_region(0x000000, (length) - 1, &rom[length/4]);
m68k_set_encrypted_opcode_range(machine->device("maincpu"), 0, length);
}

2
src/mame/drivers/crgolf.c
View File

@ -600,7 +600,7 @@ ROM_END
static DRIVER_INIT( crgolfhi )
{
device_t *msm = machine->device("msm");
memory_install_write8_device_handler(machine->device("audiocpu")->memory().space(AS_PROGRAM), msm, 0xa000, 0xa003, 0, 0, crgolfhi_sample_w);
machine->device("audiocpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(*msm, 0xa000, 0xa003, FUNC(crgolfhi_sample_w));
}

6
src/mame/drivers/crimfght.c
View File

@ -410,12 +410,12 @@ static KONAMI_SETLINES_CALLBACK( crimfght_banking )
/* bit 5 = select work RAM or palette */
if (lines & 0x20)
{
memory_install_read_bank(device->memory().space(AS_PROGRAM), 0x0000, 0x03ff, 0, 0, "bank3");
memory_install_write8_handler(device->memory().space(AS_PROGRAM), 0x0000, 0x03ff, 0, 0, paletteram_xBBBBBGGGGGRRRRR_be_w);
device->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x03ff, "bank3");
device->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x0000, 0x03ff, FUNC(paletteram_xBBBBBGGGGGRRRRR_be_w));
memory_set_bankptr(device->machine, "bank3", device->machine->generic.paletteram.v);
}
else
memory_install_readwrite_bank(device->memory().space(AS_PROGRAM), 0x0000, 0x03ff, 0, 0, "bank1"); /* RAM */
device->memory().space(AS_PROGRAM)->install_readwrite_bank(0x0000, 0x03ff, "bank1"); /* RAM */
/* bit 6 = enable char ROM reading through the video RAM */
k052109_set_rmrd_line(state->k052109, (lines & 0x40) ? ASSERT_LINE : CLEAR_LINE);

4
src/mame/drivers/dassault.c
View File

@ -865,7 +865,7 @@ static DRIVER_INIT( dassault )
auto_free(machine, tmp);
/* Save time waiting on vblank bit */
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x3f8000, 0x3f8001, 0, 0, dassault_main_skip);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x3f8000, 0x3f8001, FUNC(dassault_main_skip));
}
static DRIVER_INIT( thndzone )
@ -885,7 +885,7 @@ static DRIVER_INIT( thndzone )
auto_free(machine, tmp);
/* Save time waiting on vblank bit */
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x3f8000, 0x3f8001, 0, 0, thndzone_main_skip);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x3f8000, 0x3f8001, FUNC(thndzone_main_skip));
}
/**********************************************************************************/

2
src/mame/drivers/ddealer.c
View File

@ -671,7 +671,7 @@ static READ16_HANDLER( ddealer_mcu_r )
static DRIVER_INIT( ddealer )
{
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfe01c, 0xfe01d, 0, 0, ddealer_mcu_r );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfe01c, 0xfe01d, FUNC(ddealer_mcu_r) );
}
ROM_START( ddealer )

2
src/mame/drivers/ddenlovr.c
View File

@ -9107,7 +9107,7 @@ static DRIVER_INIT( rongrong )
version of the game might be a bootleg with the protection
patched. (both sets need this)
*/
memory_nop_read(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x60d4, 0x60d4, 0, 0);
machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_read(0x60d4, 0x60d4);
}
/***************************************************************************

8
src/mame/drivers/ddragon.c
View File

@ -285,9 +285,9 @@ static WRITE8_HANDLER( darktowr_bankswitch_w )
memory_set_bank(space->machine, "bank1", newbank);
if (newbank == 4 && oldbank != 4)
memory_install_readwrite8_handler(space, 0x4000, 0x7fff, 0, 0, darktowr_mcu_bank_r, darktowr_mcu_bank_w);
space->install_legacy_readwrite_handler(0x4000, 0x7fff, FUNC(darktowr_mcu_bank_r), FUNC(darktowr_mcu_bank_w));
else if (newbank != 4 && oldbank == 4)
memory_install_readwrite_bank(space, 0x4000, 0x7fff, 0, 0, "bank1");
space->install_readwrite_bank(0x4000, 0x7fff, "bank1");
}
@ -2021,7 +2021,7 @@ static DRIVER_INIT( darktowr )
state->sound_irq = M6809_IRQ_LINE;
state->ym_irq = M6809_FIRQ_LINE;
state->technos_video_hw = 0;
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x3808, 0x3808, 0, 0, darktowr_bankswitch_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x3808, 0x3808, FUNC(darktowr_bankswitch_w));
}
@ -2034,7 +2034,7 @@ static DRIVER_INIT( toffy )
state->sound_irq = M6809_IRQ_LINE;
state->ym_irq = M6809_FIRQ_LINE;
state->technos_video_hw = 0;
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x3808, 0x3808, 0, 0, toffy_bankswitch_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x3808, 0x3808, FUNC(toffy_bankswitch_w));
/* the program rom has a simple bitswap encryption */
rom = machine->region("maincpu")->base();

4
src/mame/drivers/deadang.c
View File

@ -403,8 +403,8 @@ static DRIVER_INIT( ghunter )
seibu_sound_decrypt(machine, "audiocpu", 0x2000);
seibu_adpcm_decrypt(machine, "adpcm");
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x80000, 0x80001, 0, 0, ghunter_trackball_low_r);
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xb0000, 0xb0001, 0, 0, ghunter_trackball_high_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x80000, 0x80001, FUNC(ghunter_trackball_low_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xb0000, 0xb0001, FUNC(ghunter_trackball_high_r));
}
/* Game Drivers */

46
src/mame/drivers/dec0.c
View File

@ -423,30 +423,30 @@ void slyspy_set_protection_map(running_machine* machine, int type)
deco_bac06_device *tilegen1 = (deco_bac06_device*)space->machine->device<deco_bac06_device>("tilegen1");
deco_bac06_device *tilegen2 = (deco_bac06_device*)space->machine->device<deco_bac06_device>("tilegen2");
memory_install_write16_handler( space, 0x240000, 0x24ffff, 0, 0, unmapped_w);
space->install_legacy_write_handler( 0x240000, 0x24ffff, FUNC(unmapped_w));
memory_install_write16_handler( space, 0x24a000, 0x24a001, 0, 0, slyspy_state_w);
memory_install_read16_handler( space, 0x244000, 0x244001, 0, 0, slyspy_state_r);
space->install_legacy_write_handler( 0x24a000, 0x24a001, FUNC(slyspy_state_w));
space->install_legacy_read_handler( 0x244000, 0x244001, FUNC(slyspy_state_r));
switch (type)
{
case 0:
memory_install_write16_device_handler( space, tilegen2, 0x240000, 0x240007, 0, 0, deco_bac06_pf_control_0_w);
memory_install_write16_device_handler( space, tilegen2, 0x240010, 0x240017, 0, 0, deco_bac06_pf_control_1_w);
space->install_legacy_write_handler( *tilegen2, 0x240000, 0x240007, FUNC(deco_bac06_pf_control_0_w));
space->install_legacy_write_handler( *tilegen2, 0x240010, 0x240017, FUNC(deco_bac06_pf_control_1_w));
memory_install_write16_device_handler( space, tilegen2, 0x242000, 0x24207f, 0, 0, deco_bac06_pf_colscroll_w);
memory_install_write16_device_handler( space, tilegen2, 0x242400, 0x2427ff, 0, 0, deco_bac06_pf_rowscroll_w);
space->install_legacy_write_handler( *tilegen2, 0x242000, 0x24207f, FUNC(deco_bac06_pf_colscroll_w));
space->install_legacy_write_handler( *tilegen2, 0x242400, 0x2427ff, FUNC(deco_bac06_pf_rowscroll_w));
memory_install_write16_device_handler( space, tilegen2, 0x246000, 0x247fff, 0, 0, deco_bac06_pf_data_w);
space->install_legacy_write_handler( *tilegen2, 0x246000, 0x247fff, FUNC(deco_bac06_pf_data_w));
memory_install_write16_device_handler( space, tilegen1, 0x248000, 0x280007, 0, 0, deco_bac06_pf_control_0_w);
memory_install_write16_device_handler( space, tilegen1, 0x248010, 0x280017, 0, 0, deco_bac06_pf_control_1_w);
space->install_legacy_write_handler( *tilegen1, 0x248000, 0x280007, FUNC(deco_bac06_pf_control_0_w));
space->install_legacy_write_handler( *tilegen1, 0x248010, 0x280017, FUNC(deco_bac06_pf_control_1_w));
memory_install_write16_device_handler( space, tilegen1, 0x24c000, 0x24c07f, 0, 0, deco_bac06_pf_colscroll_w);
memory_install_write16_device_handler( space, tilegen1, 0x24c400, 0x24c7ff, 0, 0, deco_bac06_pf_rowscroll_w);
space->install_legacy_write_handler( *tilegen1, 0x24c000, 0x24c07f, FUNC(deco_bac06_pf_colscroll_w));
space->install_legacy_write_handler( *tilegen1, 0x24c400, 0x24c7ff, FUNC(deco_bac06_pf_rowscroll_w));
memory_install_write16_device_handler( space, tilegen1, 0x24e000, 0x24ffff, 0, 0, deco_bac06_pf_data_w);
space->install_legacy_write_handler( *tilegen1, 0x24e000, 0x24ffff, FUNC(deco_bac06_pf_data_w));
break;
@ -454,26 +454,26 @@ void slyspy_set_protection_map(running_machine* machine, int type)
// 0x240000 - 0x241fff not mapped
// 0x242000 - 0x243fff not mapped
// 0x246000 - 0x247fff not mapped
memory_install_write16_device_handler( space, tilegen1, 0x248000, 0x249fff, 0, 0, deco_bac06_pf_data_w);
memory_install_write16_device_handler( space, tilegen2, 0x24c000, 0x24dfff, 0, 0, deco_bac06_pf_data_w);
space->install_legacy_write_handler( *tilegen1, 0x248000, 0x249fff, FUNC(deco_bac06_pf_data_w));
space->install_legacy_write_handler( *tilegen2, 0x24c000, 0x24dfff, FUNC(deco_bac06_pf_data_w));
// 0x24e000 - 0x24ffff not mapped
break;
case 2:
memory_install_write16_device_handler( space, tilegen2, 0x240000, 0x241fff, 0, 0, deco_bac06_pf_data_w);
memory_install_write16_device_handler( space, tilegen1, 0x242000, 0x243fff, 0, 0, deco_bac06_pf_data_w);
space->install_legacy_write_handler( *tilegen2, 0x240000, 0x241fff, FUNC(deco_bac06_pf_data_w));
space->install_legacy_write_handler( *tilegen1, 0x242000, 0x243fff, FUNC(deco_bac06_pf_data_w));
// 0x242000 - 0x243fff not mapped
// 0x246000 - 0x247fff not mapped
// 0x248000 - 0x249fff not mapped
// 0x24c000 - 0x24dfff not mapped
memory_install_write16_device_handler( space, tilegen1, 0x24e000, 0x24ffff, 0, 0, deco_bac06_pf_data_w);
space->install_legacy_write_handler( *tilegen1, 0x24e000, 0x24ffff, FUNC(deco_bac06_pf_data_w));
break;
case 3:
memory_install_write16_device_handler( space, tilegen1, 0x240000, 0x241fff, 0, 0, deco_bac06_pf_data_w);
space->install_legacy_write_handler( *tilegen1, 0x240000, 0x241fff, FUNC(deco_bac06_pf_data_w));
// 0x242000 - 0x243fff not mapped
// 0x246000 - 0x247fff not mapped
memory_install_write16_device_handler( space, tilegen2, 0x248000, 0x249fff, 0, 0, deco_bac06_pf_data_w);
space->install_legacy_write_handler( *tilegen2, 0x248000, 0x249fff, FUNC(deco_bac06_pf_data_w));
// 0x24c000 - 0x24dfff not mapped
// 0x24e000 - 0x24ffff not mapped
break;
@ -2922,10 +2922,10 @@ static DRIVER_INIT( convert_robocop_gfx4_to_automat )
static DRIVER_INIT( midresb )
{
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x00180000, 0x0018000f, 0, 0, dec0_controls_r );
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x001a0000, 0x001a000f, 0, 0, dec0_rotary_r );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00180000, 0x0018000f, FUNC(dec0_controls_r) );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x001a0000, 0x001a000f, FUNC(dec0_rotary_r) );
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x00180014, 0x00180015, 0, 0, midres_sound_w );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x00180014, 0x00180015, FUNC(midres_sound_w) );
}
/******************************************************************************/

2
src/mame/drivers/deco_mlc.c
View File

@ -745,7 +745,7 @@ static DRIVER_INIT( avengrgs )
sh2drc_add_pcflush(machine->device("maincpu"), 0x32dc);
state->mainCpuIsArm = 0;
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x01089a0, 0x01089a3, 0, 0, avengrgs_speedup_r );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x01089a0, 0x01089a3, FUNC(avengrgs_speedup_r) );
descramble_sound(machine);
}

6
src/mame/drivers/decocass.c
View File

@ -1363,8 +1363,8 @@ static DRIVER_INIT( decocrom )
state->decrypted2[i] = swap_bits_5_6(rom[i]);
/* convert charram to a banked ROM */
memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x6000, 0xafff, 0, 0, "bank1");
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x6000, 0xafff, 0, 0, decocass_de0091_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x6000, 0xafff, "bank1");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x6000, 0xafff, FUNC(decocass_de0091_w));
memory_configure_bank(machine, "bank1", 0, 1, state->charram, 0);
memory_configure_bank(machine, "bank1", 1, 1, machine->region("user3")->base(), 0);
memory_configure_bank_decrypted(machine, "bank1", 0, 1, &state->decrypted[0x6000], 0);
@ -1372,7 +1372,7 @@ static DRIVER_INIT( decocrom )
memory_set_bank(machine, "bank1", 0);
/* install the bank selector */
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xe900, 0xe900, 0, 0, decocass_e900_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xe900, 0xe900, FUNC(decocass_e900_w));
state->save_pointer(NAME(state->decrypted2), romlength);
}

4
src/mame/drivers/dgpix.c
View File

@ -583,7 +583,7 @@ static DRIVER_INIT( xfiles )
rom[BYTE4_XOR_BE(0x3aa933)] = 0;
// protection related ?
// memory_nop_read(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xf0c8b440, 0xf0c8b447, 0, 0);
// machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_read(0xf0c8b440, 0xf0c8b447);
state->flash_roms = 2;
}
@ -604,7 +604,7 @@ static DRIVER_INIT( kdynastg )
rom[BYTE4_XOR_BE(0x3a45c9)] = 0;
// protection related ?
// memory_nop_read(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x12341234, 0x12341243, 0, 0);
// machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_read(0x12341234, 0x12341243);
state->flash_roms = 4;
}

18
src/mame/drivers/dkong.c
View File

@ -3040,7 +3040,7 @@ static DRIVER_INIT( drakton )
{7,1,4,0,3,6,2,5},
};
memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0000, 0x3fff, 0, 0, "bank1" );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x3fff, "bank1" );
/* While the PAL supports up to 16 decryption methods, only four
are actually used in the PAL. Therefore, we'll take a little
@ -3062,7 +3062,7 @@ static DRIVER_INIT( strtheat )
{6,3,4,1,0,7,2,5},
};
memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0000, 0x3fff, 0, 0, "bank1" );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x3fff, "bank1" );
/* While the PAL supports up to 16 decryption methods, only four
are actually used in the PAL. Therefore, we'll take a little
@ -3073,8 +3073,8 @@ static DRIVER_INIT( strtheat )
drakton_decrypt_rom(machine, 0x88, 0x1c000, bs[3]);
/* custom handlers supporting Joystick or Steering Wheel */
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7c00, 0x7c00, 0, 0, strtheat_inputport_0_r);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7c80, 0x7c80, 0, 0, strtheat_inputport_1_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x7c00, 0x7c00, FUNC(strtheat_inputport_0_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x7c80, 0x7c80, FUNC(strtheat_inputport_1_r));
}
@ -3086,13 +3086,13 @@ static DRIVER_INIT( dkongx )
decrypted = auto_alloc_array(machine, UINT8, 0x10000);
memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0000, 0x5fff, 0, 0, "bank1" );
memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x8000, 0xffff, 0, 0, "bank2" );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x5fff, "bank1" );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x8000, 0xffff, "bank2" );
memory_install_write8_handler(space, 0xe000, 0xe000, 0, 0, braze_a15_w);
space->install_legacy_write_handler(0xe000, 0xe000, FUNC(braze_a15_w));
memory_install_read8_device_handler(space, eeprom, 0xc800, 0xc800, 0, 0, braze_eeprom_r);
memory_install_write8_device_handler(space, eeprom, 0xc800, 0xc800, 0, 0, braze_eeprom_w);
space->install_legacy_read_handler(*eeprom, 0xc800, 0xc800, FUNC(braze_eeprom_r));
space->install_legacy_write_handler(*eeprom, 0xc800, 0xc800, FUNC(braze_eeprom_w));
braze_decrypt_rom(machine, decrypted);

2
src/mame/drivers/dynax.c
View File

@ -6517,7 +6517,7 @@ ROM_END
static DRIVER_INIT( mjreach )
{
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x10060, 0x10060, 0, 0, yarunara_flipscreen_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x10060, 0x10060, FUNC(yarunara_flipscreen_w));
}
/***************************************************************************

10
src/mame/drivers/eolith.c
View File

@ -1138,15 +1138,15 @@ static DRIVER_INIT( hidctch2 )
static DRIVER_INIT( hidctch3 )
{
memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfc200000, 0xfc200003, 0, 0); // this generates pens vibration
machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0xfc200000, 0xfc200003); // this generates pens vibration
// It is not clear why the first reads are needed too
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfce00000, 0xfce00003, 0, 0, hidctch3_pen1_r);
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfce80000, 0xfce80003, 0, 0, hidctch3_pen1_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfce00000, 0xfce00003, FUNC(hidctch3_pen1_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfce80000, 0xfce80003, FUNC(hidctch3_pen1_r));
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfcf00000, 0xfcf00003, 0, 0, hidctch3_pen2_r);
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfcf80000, 0xfcf80003, 0, 0, hidctch3_pen2_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfcf00000, 0xfcf00003, FUNC(hidctch3_pen2_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfcf80000, 0xfcf80003, FUNC(hidctch3_pen2_r));
init_eolith_speedup(machine);
}

4
src/mame/drivers/eprom.c
View File

@ -730,8 +730,8 @@ static DRIVER_INIT( eprom )
atarijsa_init(machine, "260010", 0x0002);
/* install CPU synchronization handlers */
state->sync_data = memory_install_readwrite16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x16cc00, 0x16cc01, 0, 0, sync_r, sync_w);
state->sync_data = memory_install_readwrite16_handler(machine->device("extra")->memory().space(AS_PROGRAM), 0x16cc00, 0x16cc01, 0, 0, sync_r, sync_w);
state->sync_data = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x16cc00, 0x16cc01, FUNC(sync_r), FUNC(sync_w));
state->sync_data = machine->device("extra")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x16cc00, 0x16cc01, FUNC(sync_r), FUNC(sync_w));
}

6
src/mame/drivers/equites.c
View File

@ -1899,8 +1899,8 @@ static DRIVER_INIT( gekisou )
unpack_region(machine, "gfx3");
// install special handlers for unknown device (protection?)
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x580000, 0x580001, 0, 0, gekisou_unknown_0_w);
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x5a0000, 0x5a0001, 0, 0, gekisou_unknown_1_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x580000, 0x580001, FUNC(gekisou_unknown_0_w));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x5a0000, 0x5a0001, FUNC(gekisou_unknown_1_w));
}
static DRIVER_INIT( splndrbt )
@ -1913,7 +1913,7 @@ static DRIVER_INIT( hvoltage )
unpack_region(machine, "gfx3");
#if HVOLTAGE_DEBUG
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x000038, 0x000039, 0, 0, hvoltage_debug_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x000038, 0x000039, FUNC(hvoltage_debug_r));
#endif
}

2
src/mame/drivers/exidy.c
View File

@ -1439,7 +1439,7 @@ static DRIVER_INIT( phantoma )
state->color_latch[0] = 0x09;
/* the ROM is actually mapped high */
memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xf800, 0xffff, 0, 0, "bank1");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0xf800, 0xffff, "bank1");
memory_set_bankptr(machine, "bank1", machine->region("maincpu")->base() + 0xf800);
}

14
src/mame/drivers/exidy440.c
View File

@ -303,9 +303,9 @@ void exidy440_bank_select(running_machine *machine, UINT8 bank)
if (state->showdown_bank_data[0] != NULL)
{
if (bank == 0 && state->bank != 0)
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x4000, 0x7fff, 0, 0, showdown_bank0_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x4000, 0x7fff, FUNC(showdown_bank0_r));
else if (bank != 0 && state->bank == 0)
memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x4000, 0x7fff, 0, 0, "bank1");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x4000, 0x7fff, "bank1");
}
/* select the bank and update the bank pointer */
@ -1938,7 +1938,7 @@ static DRIVER_INIT( claypign )
{
DRIVER_INIT_CALL(exidy440);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2ec0, 0x2ec3, 0, 0, claypign_protection_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x2ec0, 0x2ec3, FUNC(claypign_protection_r));
}
@ -1948,11 +1948,11 @@ static DRIVER_INIT( topsecex )
DRIVER_INIT_CALL(exidy440);
/* extra input ports and scrolling */
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2ec5, 0x2ec5, 0, 0, topsecex_input_port_5_r);
memory_install_read_port(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2ec6, 0x2ec6, 0, 0, "AN0");
memory_install_read_port(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2ec7, 0x2ec7, 0, 0, "IN4");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x2ec5, 0x2ec5, FUNC(topsecex_input_port_5_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port(0x2ec6, 0x2ec6, "AN0");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port(0x2ec7, 0x2ec7, "IN4");
state->topsecex_yscroll = memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x2ec1, 0x2ec1, 0, 0, topsecex_yscroll_w);
state->topsecex_yscroll = machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x2ec1, 0x2ec1, FUNC(topsecex_yscroll_w));
}

4
src/mame/drivers/exprraid.c
View File

@ -778,13 +778,13 @@ static DRIVER_INIT( exprraid )
static DRIVER_INIT( wexpressb )
{
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x3800, 0x3800, 0, 0, vblank_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x3800, 0x3800, FUNC(vblank_r));
exprraid_gfx_expand(machine);
}
static DRIVER_INIT( wexpressb2 )
{
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xFFC0, 0xFFC0, 0, 0, vblank_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xFFC0, 0xFFC0, FUNC(vblank_r));
exprraid_gfx_expand(machine);
}

20
src/mame/drivers/fastfred.c
View File

@ -979,8 +979,8 @@ ROM_END
static DRIVER_INIT( flyboy )
{
fastfred_state *state = machine->driver_data<fastfred_state>();
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc085, 0xc099, 0, 0, flyboy_custom1_io_r);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc8fb, 0xc900, 0, 0, flyboy_custom2_io_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc085, 0xc099, FUNC(flyboy_custom1_io_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc8fb, 0xc900, FUNC(flyboy_custom2_io_r));
state->hardware_type = 1;
}
@ -993,32 +993,32 @@ static DRIVER_INIT( flyboyb )
static DRIVER_INIT( fastfred )
{
fastfred_state *state = machine->driver_data<fastfred_state>();
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0, fastfred_custom_io_r);
memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc800, 0xcfff, FUNC(fastfred_custom_io_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0xc800, 0xcfff);
state->hardware_type = 1;
}
static DRIVER_INIT( jumpcoas )
{
fastfred_state *state = machine->driver_data<fastfred_state>();
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0, jumpcoas_custom_io_r);
memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc800, 0xcfff, FUNC(jumpcoas_custom_io_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0xc800, 0xcfff);
state->hardware_type = 0;
}
static DRIVER_INIT( boggy84b )
{
fastfred_state *state = machine->driver_data<fastfred_state>();
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0, jumpcoas_custom_io_r);
memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc800, 0xcfff, FUNC(jumpcoas_custom_io_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0xc800, 0xcfff);
state->hardware_type = 2;
}
static DRIVER_INIT( boggy84 )
{
fastfred_state *state = machine->driver_data<fastfred_state>();
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0, boggy84_custom_io_r);
memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc800, 0xcfff, 0, 0);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc800, 0xcfff, FUNC(boggy84_custom_io_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0xc800, 0xcfff);
state->hardware_type = 2;
}

6
src/mame/drivers/firebeat.c
View File

@ -2216,9 +2216,9 @@ static void init_lights(running_machine *machine, write32_space_func out1, write
if(!out2) out1 = lamp_output2_w;
if(!out3) out1 = lamp_output3_w;
memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7d000804, 0x7d000807, 0, 0, out1);
memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7d000320, 0x7d000323, 0, 0, out2);
memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7d000324, 0x7d000327, 0, 0, out3);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x7d000804, 0x7d000807, FUNC(out1));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x7d000320, 0x7d000323, FUNC(out2));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x7d000324, 0x7d000327, FUNC(out3));
}
static void init_firebeat(running_machine *machine)

4
src/mame/drivers/fitfight.c
View File

@ -978,7 +978,7 @@ static DRIVER_INIT( fitfight )
// UINT16 *mem16 = (UINT16 *)machine->region("maincpu")->base();
// mem16[0x0165B2/2] = 0x4e71; // for now so it boots
fitfight_state *state = machine->driver_data<fitfight_state>();
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x700000, 0x700001, 0, 0, fitfight_700000_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x700000, 0x700001, FUNC(fitfight_700000_r));
state->bbprot_kludge = 0;
}
@ -987,7 +987,7 @@ static DRIVER_INIT( histryma )
// UINT16 *mem16 = (UINT16 *)machine->region("maincpu")->base();
// mem16[0x017FDC/2] = 0x4e71; // for now so it boots
fitfight_state *state = machine->driver_data<fitfight_state>();
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x700000, 0x700001, 0, 0, histryma_700000_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x700000, 0x700001, FUNC(histryma_700000_r));
state->bbprot_kludge = 0;
}

8
src/mame/drivers/gaiden.c
View File

@ -1506,8 +1506,8 @@ static DRIVER_INIT( wildfang )
state->prot = 0;
state->jumpcode = 0;
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x07a006, 0x07a007, 0, 0, wildfang_protection_r);
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x07a804, 0x07a805, 0, 0, wildfang_protection_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x07a006, 0x07a007, FUNC(wildfang_protection_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x07a804, 0x07a805, FUNC(wildfang_protection_w));
}
static DRIVER_INIT( raiga )
@ -1519,8 +1519,8 @@ static DRIVER_INIT( raiga )
state->prot = 0;
state->jumpcode = 0;
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x07a006, 0x07a007, 0, 0, raiga_protection_r);
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x07a804, 0x07a805, 0, 0, raiga_protection_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x07a006, 0x07a007, FUNC(raiga_protection_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x07a804, 0x07a805, FUNC(raiga_protection_w));
}
static void descramble_drgnbowl_gfx(running_machine *machine)

6
src/mame/drivers/galaga.c
View File

@ -3212,7 +3212,7 @@ static DRIVER_INIT (gatsbee)
DRIVER_INIT_CALL(galaga);
/* Gatsbee has a larger character ROM, we need a handler for banking */
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x1000, 0x1000, 0, 0, gatsbee_bank_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x1000, 0x1000, FUNC(gatsbee_bank_w));
}
@ -3253,8 +3253,8 @@ static DRIVER_INIT( xevios )
static DRIVER_INIT( battles )
{
/* replace the Namco I/O handlers with interface to the 4th CPU */
memory_install_readwrite8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7000, 0x700f, 0, 0, battles_customio_data0_r, battles_customio_data0_w );
memory_install_readwrite8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7100, 0x7100, 0, 0, battles_customio0_r, battles_customio0_w );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x7000, 0x700f, FUNC(battles_customio_data0_r), FUNC(battles_customio_data0_w) );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x7100, 0x7100, FUNC(battles_customio0_r), FUNC(battles_customio0_w) );
DRIVER_INIT_CALL(xevious);
}

134
src/mame/drivers/galaxian.c
View File

@ -2635,9 +2635,9 @@ static void unmap_galaxian_sound(running_machine *machine, offs_t base)
{
address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
memory_unmap_write(space, base + 0x0004, base + 0x0007, 0, 0x07f8);
memory_unmap_write(space, base + 0x0800, base + 0x0807, 0, 0x07f8);
memory_unmap_write(space, base + 0x1800, base + 0x1800, 0, 0x07ff);
space->unmap_write(base + 0x0004, base + 0x0007, 0, 0x07f8);
space->unmap_write(base + 0x0800, base + 0x0807, 0, 0x07f8);
space->unmap_write(base + 0x1800, base + 0x1800, 0, 0x07ff);
}
@ -2662,7 +2662,7 @@ static DRIVER_INIT( nolock )
DRIVER_INIT_CALL(galaxian);
/* ...but coin lockout disabled/disconnected */
memory_unmap_write(space, 0x6002, 0x6002, 0, 0x7f8);
space->unmap_write(0x6002, 0x6002, 0, 0x7f8);
}
@ -2674,7 +2674,7 @@ static DRIVER_INIT( azurian )
common_init(machine, scramble_draw_bullet, galaxian_draw_background, NULL, NULL);
/* coin lockout disabled */
memory_unmap_write(space, 0x6002, 0x6002, 0, 0x7f8);
space->unmap_write(0x6002, 0x6002, 0, 0x7f8);
}
@ -2686,7 +2686,7 @@ static DRIVER_INIT( gmgalax )
common_init(machine, galaxian_draw_bullet, galaxian_draw_background, gmgalax_extend_tile_info, gmgalax_extend_sprite_info);
/* ROM is banked */
memory_install_read_bank(space, 0x0000, 0x3fff, 0, 0, "bank1");
space->install_read_bank(0x0000, 0x3fff, "bank1");
memory_configure_bank(machine, "bank1", 0, 2, machine->region("maincpu")->base() + 0x10000, 0x4000);
/* callback when the game select is toggled */
@ -2703,7 +2703,7 @@ static DRIVER_INIT( pisces )
common_init(machine, galaxian_draw_bullet, galaxian_draw_background, pisces_extend_tile_info, pisces_extend_sprite_info);
/* coin lockout replaced by graphics bank */
memory_install_write8_handler(space, 0x6002, 0x6002, 0, 0x7f8, galaxian_gfxbank_w);
space->install_legacy_write_handler(0x6002, 0x6002, 0, 0x7f8, FUNC(galaxian_gfxbank_w));
}
@ -2715,7 +2715,7 @@ static DRIVER_INIT( batman2 )
common_init(machine, galaxian_draw_bullet, galaxian_draw_background, batman2_extend_tile_info, upper_extend_sprite_info);
/* coin lockout replaced by graphics bank */
memory_install_write8_handler(space, 0x6002, 0x6002, 0, 0x7f8, galaxian_gfxbank_w);
space->install_legacy_write_handler(0x6002, 0x6002, 0, 0x7f8, FUNC(galaxian_gfxbank_w));
}
@ -2727,7 +2727,7 @@ static DRIVER_INIT( frogg )
common_init(machine, galaxian_draw_bullet, frogger_draw_background, frogger_extend_tile_info, frogger_extend_sprite_info);
/* ...but needs a full 2k of RAM */
memory_install_ram(space, 0x4000, 0x47ff, 0, 0, NULL);
space->install_ram(0x4000, 0x47ff);
}
@ -2763,7 +2763,7 @@ static DRIVER_INIT( mooncrgx )
common_init(machine, galaxian_draw_bullet, galaxian_draw_background, mooncrst_extend_tile_info, mooncrst_extend_sprite_info);
/* LEDs and coin lockout replaced by graphics banking */
memory_install_write8_handler(space, 0x6000, 0x6002, 0, 0x7f8, galaxian_gfxbank_w);
space->install_legacy_write_handler(0x6000, 0x6002, 0, 0x7f8, FUNC(galaxian_gfxbank_w));
}
@ -2793,7 +2793,7 @@ static DRIVER_INIT( pacmanbl )
DRIVER_INIT_CALL(galaxian);
/* ...but coin lockout disabled/disconnected */
memory_install_write8_handler(space, 0x6002, 0x6002, 0, 0x7f8, (write8_space_func)artic_gfxbank_w);
space->install_legacy_write_handler(0x6002, 0x6002, 0, 0x7f8, FUNC(artic_gfxbank_w));
}
static READ8_HANDLER( tenspot_dsw_read )
@ -2858,18 +2858,18 @@ static DRIVER_INIT( tenspot )
//common_init(machine, galaxian_draw_bullet, galaxian_draw_background, batman2_extend_tile_info, upper_extend_sprite_info);
/* coin lockout replaced by graphics bank */
//memory_install_write8_handler(space, 0x6002, 0x6002, 0, 0x7f8, galaxian_gfxbank_w);
//space->install_legacy_write_handler(0x6002, 0x6002, 0, 0x7f8, FUNC(galaxian_gfxbank_w));
DRIVER_INIT_CALL(galaxian);
memory_install_write8_handler(space, 0x6002, 0x6002, 0, 0x7f8, (write8_space_func)artic_gfxbank_w);
space->install_legacy_write_handler(0x6002, 0x6002, 0, 0x7f8, FUNC(artic_gfxbank_w));
tenspot_current_game = 0;
tenspot_set_game_bank(machine, tenspot_current_game, 0);
memory_install_read8_handler(space, 0x7000, 0x7000, 0, 0, tenspot_dsw_read);
space->install_legacy_read_handler(0x7000, 0x7000, FUNC(tenspot_dsw_read));
}
@ -2893,28 +2893,28 @@ static DRIVER_INIT( zigzag )
galaxian_draw_bullet_ptr = NULL;
/* make ROMs 2 & 3 swappable */
memory_install_read_bank(space, 0x2000, 0x2fff, 0, 0, "bank1");
memory_install_read_bank(space, 0x3000, 0x3fff, 0, 0, "bank2");
space->install_read_bank(0x2000, 0x2fff, "bank1");
space->install_read_bank(0x3000, 0x3fff, "bank2");
memory_configure_bank(machine, "bank1", 0, 2, machine->region("maincpu")->base() + 0x2000, 0x1000);
memory_configure_bank(machine, "bank2", 0, 2, machine->region("maincpu")->base() + 0x2000, 0x1000);
/* also re-install the fixed ROM area as a bank in order to inform the memory system that
the fixed area only extends to 0x1fff */
memory_install_read_bank(space, 0x0000, 0x1fff, 0, 0, "bank3");
space->install_read_bank(0x0000, 0x1fff, "bank3");
memory_set_bankptr(machine, "bank3", machine->region("maincpu")->base() + 0x0000);
/* handler for doing the swaps */
memory_install_write8_handler(space, 0x7002, 0x7002, 0, 0x07f8, zigzag_bankswap_w);
space->install_legacy_write_handler(0x7002, 0x7002, 0, 0x07f8, FUNC(zigzag_bankswap_w));
zigzag_bankswap_w(space, 0, 0);
/* coin lockout disabled */
memory_unmap_write(space, 0x6002, 0x6002, 0, 0x7f8);
space->unmap_write(0x6002, 0x6002, 0, 0x7f8);
/* remove the galaxian sound hardware */
unmap_galaxian_sound(machine, 0x6000);
/* install our AY-8910 handler */
memory_install_write8_handler(space, 0x4800, 0x4fff, 0, 0, zigzag_ay8910_w);
space->install_legacy_write_handler(0x4800, 0x4fff, FUNC(zigzag_ay8910_w));
}
@ -2934,11 +2934,11 @@ static DRIVER_INIT( checkman )
common_init(machine, galaxian_draw_bullet, galaxian_draw_background, mooncrst_extend_tile_info, mooncrst_extend_sprite_info);
/* move the interrupt enable from $b000 to $b001 */
memory_unmap_write(space, 0xb000, 0xb000, 0, 0x7f8);
memory_install_write8_handler(space, 0xb001, 0xb001, 0, 0x7f8, irq_enable_w);
space->unmap_write(0xb000, 0xb000, 0, 0x7f8);
space->install_legacy_write_handler(0xb001, 0xb001, 0, 0x7f8, FUNC(irq_enable_w));
/* attach the sound command handler */
memory_install_write8_handler(iospace, 0x00, 0x00, 0, 0xffff, checkman_sound_command_w);
iospace->install_legacy_write_handler(0x00, 0x00, 0, 0xffff, FUNC(checkman_sound_command_w));
/* decrypt program code */
decode_checkman(machine);
@ -2953,10 +2953,10 @@ static DRIVER_INIT( checkmaj )
common_init(machine, galaxian_draw_bullet, galaxian_draw_background, NULL, NULL);
/* attach the sound command handler */
memory_install_write8_handler(space, 0x7800, 0x7800, 0, 0x7ff, checkman_sound_command_w);
space->install_legacy_write_handler(0x7800, 0x7800, 0, 0x7ff, FUNC(checkman_sound_command_w));
/* for the title screen */
memory_install_read8_handler(space, 0x3800, 0x3800, 0, 0, checkmaj_protection_r);
space->install_legacy_read_handler(0x3800, 0x3800, FUNC(checkmaj_protection_r));
}
@ -2968,10 +2968,10 @@ static DRIVER_INIT( dingo )
common_init(machine, galaxian_draw_bullet, galaxian_draw_background, NULL, NULL);
/* attach the sound command handler */
memory_install_write8_handler(space, 0x7800, 0x7800, 0, 0x7ff, checkman_sound_command_w);
space->install_legacy_write_handler(0x7800, 0x7800, 0, 0x7ff, FUNC(checkman_sound_command_w));
memory_install_read8_handler(space, 0x3000, 0x3000, 0, 0, dingo_3000_r);
memory_install_read8_handler(space, 0x3035, 0x3035, 0, 0, dingo_3035_r);
space->install_legacy_read_handler(0x3000, 0x3000, FUNC(dingo_3000_r));
space->install_legacy_read_handler(0x3035, 0x3035, FUNC(dingo_3035_r));
}
@ -2984,13 +2984,13 @@ static DRIVER_INIT( dingoe )
common_init(machine, galaxian_draw_bullet, galaxian_draw_background, mooncrst_extend_tile_info, mooncrst_extend_sprite_info);
/* move the interrupt enable from $b000 to $b001 */
memory_unmap_write(space, 0xb000, 0xb000, 0, 0x7f8);
memory_install_write8_handler(space, 0xb001, 0xb001, 0, 0x7f8, irq_enable_w);
space->unmap_write(0xb000, 0xb000, 0, 0x7f8);
space->install_legacy_write_handler(0xb001, 0xb001, 0, 0x7f8, FUNC(irq_enable_w));
/* attach the sound command handler */
memory_install_write8_handler(iospace, 0x00, 0x00, 0, 0xffff, checkman_sound_command_w);
iospace->install_legacy_write_handler(0x00, 0x00, 0, 0xffff, FUNC(checkman_sound_command_w));
memory_install_read8_handler(space, 0x3001, 0x3001, 0, 0, dingoe_3001_r); /* Protection check */
space->install_legacy_read_handler(0x3001, 0x3001, FUNC(dingoe_3001_r)); /* Protection check */
/* decrypt program code */
decode_dingoe(machine);
@ -3005,13 +3005,13 @@ static DRIVER_INIT( skybase )
common_init(machine, galaxian_draw_bullet, galaxian_draw_background, pisces_extend_tile_info, pisces_extend_sprite_info);
/* coin lockout replaced by graphics bank */
memory_install_write8_handler(space, 0xa002, 0xa002, 0, 0x7f8, galaxian_gfxbank_w);
space->install_legacy_write_handler(0xa002, 0xa002, 0, 0x7f8, FUNC(galaxian_gfxbank_w));
/* needs a full 2k of RAM */
memory_install_ram(space, 0x8000, 0x87ff, 0, 0, NULL);
space->install_ram(0x8000, 0x87ff);
/* extend ROM */
memory_install_rom(space, 0x0000, 0x5fff, 0, 0, machine->region("maincpu")->base());
space->install_rom(0x0000, 0x5fff, machine->region("maincpu")->base());
}
@ -3100,10 +3100,10 @@ static DRIVER_INIT( kingball )
/* video extensions */
common_init(machine, galaxian_draw_bullet, galaxian_draw_background, NULL, NULL);
memory_install_write8_handler(space, 0xb000, 0xb000, 0, 0x7f8, kingball_sound1_w);
memory_install_write8_handler(space, 0xb001, 0xb001, 0, 0x7f8, irq_enable_w);
memory_install_write8_handler(space, 0xb002, 0xb002, 0, 0x7f8, kingball_sound2_w);
memory_install_write8_handler(space, 0xb003, 0xb003, 0, 0x7f8, kingball_speech_dip_w);
space->install_legacy_write_handler(0xb000, 0xb000, 0, 0x7f8, FUNC(kingball_sound1_w));
space->install_legacy_write_handler(0xb001, 0xb001, 0, 0x7f8, FUNC(irq_enable_w));
space->install_legacy_write_handler(0xb002, 0xb002, 0, 0x7f8, FUNC(kingball_sound2_w));
space->install_legacy_write_handler(0xb003, 0xb003, 0, 0x7f8, FUNC(kingball_speech_dip_w));
state_save_register_global(machine, kingball_speech_dip);
state_save_register_global(machine, kingball_sound);
@ -3118,17 +3118,17 @@ static DRIVER_INIT( scorpnmc )
common_init(machine, galaxian_draw_bullet, galaxian_draw_background, batman2_extend_tile_info, upper_extend_sprite_info);
/* move the interrupt enable from $b000 to $b001 */
memory_unmap_write(space, 0xb000, 0xb000, 0, 0x7f8);
memory_install_write8_handler(space, 0xb001, 0xb001, 0, 0x7f8, irq_enable_w);
space->unmap_write(0xb000, 0xb000, 0, 0x7f8);
space->install_legacy_write_handler(0xb001, 0xb001, 0, 0x7f8, FUNC(irq_enable_w));
/* extra ROM */
memory_install_rom(space, 0x5000, 0x67ff, 0, 0, machine->region("maincpu")->base() + 0x5000);
space->install_rom(0x5000, 0x67ff, machine->region("maincpu")->base() + 0x5000);
/* install RAM at $4000-$4800 */
memory_install_ram(space, 0x4000, 0x47ff, 0, 0, NULL);
space->install_ram(0x4000, 0x47ff);
/* doesn't appear to use original RAM */
memory_unmap_readwrite(space, 0x8000, 0x87ff, 0, 0);
space->unmap_readwrite(0x8000, 0x87ff);
}
static DRIVER_INIT( thepitm )
@ -3139,14 +3139,14 @@ static DRIVER_INIT( thepitm )
common_init(machine, galaxian_draw_bullet, galaxian_draw_background, mooncrst_extend_tile_info, mooncrst_extend_sprite_info);
/* move the interrupt enable from $b000 to $b001 */
memory_unmap_write(space, 0xb000, 0xb000, 0, 0x7f8);
memory_install_write8_handler(space, 0xb001, 0xb001, 0, 0x7f8, irq_enable_w);
space->unmap_write(0xb000, 0xb000, 0, 0x7f8);
space->install_legacy_write_handler(0xb001, 0xb001, 0, 0x7f8, FUNC(irq_enable_w));
/* disable the stars */
memory_unmap_write(space, 0xb004, 0xb004, 0, 0x07f8);
space->unmap_write(0xb004, 0xb004, 0, 0x07f8);
/* extend ROM */
memory_install_rom(space, 0x0000, 0x47ff, 0, 0, machine->region("maincpu")->base());
space->install_rom(0x0000, 0x47ff, machine->region("maincpu")->base());
}
/*************************************
@ -3163,7 +3163,7 @@ static DRIVER_INIT( theend )
common_init(machine, theend_draw_bullet, galaxian_draw_background, NULL, NULL);
/* coin counter on the upper bit of port C */
memory_unmap_write(space, 0x6802, 0x6802, 0, 0x7f8);
space->unmap_write(0x6802, 0x6802, 0, 0x7f8);
}
@ -3182,16 +3182,16 @@ static DRIVER_INIT( explorer )
common_init(machine, scramble_draw_bullet, scramble_draw_background, NULL, NULL);
/* watchdog works for writes as well? (or is it just disabled?) */
memory_install_write8_handler(space, 0x7000, 0x7000, 0, 0x7ff, watchdog_reset_w);
space->install_legacy_write_handler(0x7000, 0x7000, 0, 0x7ff, FUNC(watchdog_reset_w));
/* I/O appears to be direct, not via PPIs */
memory_unmap_readwrite(space, 0x8000, 0xffff, 0, 0);
memory_install_read_port(space, 0x8000, 0x8000, 0, 0xffc, "IN0");
memory_install_read_port(space, 0x8001, 0x8001, 0, 0xffc, "IN1");
memory_install_read_port(space, 0x8002, 0x8002, 0, 0xffc, "IN2");
memory_install_read_port(space, 0x8003, 0x8003, 0, 0xffc, "IN3");
memory_install_write8_handler(space, 0x8000, 0x8000, 0, 0xfff, soundlatch_w);
memory_install_write8_handler(space, 0x9000, 0x9000, 0, 0xfff, explorer_sound_control_w);
space->unmap_readwrite(0x8000, 0xffff);
space->install_read_port(0x8000, 0x8000, 0, 0xffc, "IN0");
space->install_read_port(0x8001, 0x8001, 0, 0xffc, "IN1");
space->install_read_port(0x8002, 0x8002, 0, 0xffc, "IN2");
space->install_read_port(0x8003, 0x8003, 0, 0xffc, "IN3");
space->install_legacy_write_handler(0x8000, 0x8000, 0, 0xfff, FUNC(soundlatch_w));
space->install_legacy_write_handler(0x9000, 0x9000, 0, 0xfff, FUNC(explorer_sound_control_w));
}
@ -3202,7 +3202,7 @@ static DRIVER_INIT( sfx )
galaxian_sfx_tilemap = TRUE;
/* sound board has space for extra ROM */
memory_install_read_bank(machine->device("audiocpu")->memory().space(AS_PROGRAM), 0x0000, 0x3fff, 0, 0, "bank1");
machine->device("audiocpu")->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x3fff, "bank1");
memory_set_bankptr(machine, "bank1", machine->region("audiocpu")->base());
}
@ -3215,8 +3215,8 @@ static DRIVER_INIT( atlantis )
common_init(machine, scramble_draw_bullet, scramble_draw_background, NULL, NULL);
/* watchdog is at $7800? (or is it just disabled?) */
memory_unmap_read(space, 0x7000, 0x7000, 0, 0x7ff);
memory_install_read8_handler(space, 0x7800, 0x7800, 0, 0x7ff, watchdog_reset_r);
space->unmap_read(0x7000, 0x7000, 0, 0x7ff);
space->install_legacy_read_handler(0x7800, 0x7800, 0, 0x7ff, FUNC(watchdog_reset_r));
}
@ -3256,11 +3256,11 @@ static DRIVER_INIT( froggrmc )
/* video extensions */
common_init(machine, NULL, frogger_draw_background, frogger_extend_tile_info, frogger_extend_sprite_info);
memory_install_write8_handler(space, 0xa800, 0xa800, 0, 0x7ff, soundlatch_w);
memory_install_write8_handler(space, 0xb001, 0xb001, 0, 0x7f8, froggrmc_sound_control_w);
space->install_legacy_write_handler(0xa800, 0xa800, 0, 0x7ff, FUNC(soundlatch_w));
space->install_legacy_write_handler(0xb001, 0xb001, 0, 0x7f8, FUNC(froggrmc_sound_control_w));
/* actually needs 2k of RAM */
memory_install_ram(space, 0x8000, 0x87ff, 0, 0, NULL);
space->install_ram(0x8000, 0x87ff);
/* decrypt */
decode_frogger_sound(machine);
@ -3301,16 +3301,16 @@ static DRIVER_INIT( scorpion )
common_init(machine, scramble_draw_bullet, scramble_draw_background, batman2_extend_tile_info, upper_extend_sprite_info);
/* hook up AY8910 */
memory_install_readwrite8_handler(machine->device("audiocpu")->memory().space(AS_IO), 0x00, 0xff, 0, 0, scorpion_ay8910_r, scorpion_ay8910_w);
machine->device("audiocpu")->memory().space(AS_IO)->install_legacy_readwrite_handler(0x00, 0xff, FUNC(scorpion_ay8910_r), FUNC(scorpion_ay8910_w));
/* extra ROM */
memory_install_read_bank(space, 0x5800, 0x67ff, 0, 0, "bank1");
space->install_read_bank(0x5800, 0x67ff, "bank1");
memory_set_bankptr(machine, "bank1", machine->region("maincpu")->base() + 0x5800);
/* no background related */
// memory_nop_write(space, 0x6803, 0x6803, 0, 0);
// space->nop_write(0x6803, 0x6803);
memory_install_read8_handler(machine->device("audiocpu")->memory().space(AS_PROGRAM), 0x3000, 0x3000, 0, 0, scorpion_digitalker_intr_r);
machine->device("audiocpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x3000, 0x3000, FUNC(scorpion_digitalker_intr_r));
/*
{
const UINT8 *rom = machine->region("speech")->base();

14
src/mame/drivers/galivan.c
View File

@ -1043,20 +1043,20 @@ static WRITE8_HANDLER( youmab_84_w )
static DRIVER_INIT( youmab )
{
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x82, 0x82, 0, 0, youmab_extra_bank_w); // banks rom at 0x8000? writes 0xff and 0x00 before executing code there
memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0000, 0x7fff, 0, 0, "bank3");
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x82, 0x82, FUNC(youmab_extra_bank_w)); // banks rom at 0x8000? writes 0xff and 0x00 before executing code there
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x0000, 0x7fff, "bank3");
memory_set_bankptr(machine, "bank3", machine->region("maincpu")->base());
memory_install_read_bank(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x8000, 0xbfff, 0, 0, "bank2");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x8000, 0xbfff, "bank2");
memory_configure_bank(machine, "bank2", 0, 2, machine->region("user2")->base(), 0x4000);
memory_set_bank(machine, "bank2", 0);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x81, 0x81, 0, 0, youmab_81_w); // ?? often, alternating values
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x84, 0x84, 0, 0, youmab_84_w); // ?? often, sequence..
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x81, 0x81, FUNC(youmab_81_w)); // ?? often, alternating values
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x84, 0x84, FUNC(youmab_84_w)); // ?? often, sequence..
memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xd800, 0xd81f, 0, 0); // scrolling isn't here..
machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0xd800, 0xd81f); // scrolling isn't here..
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x8a, 0x8a, 0, 0, youmab_8a_r); // ???
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x8a, 0x8a, FUNC(youmab_8a_r)); // ???
}

2
src/mame/drivers/ghosteo.c
View File

@ -437,7 +437,7 @@ static READ32_HANDLER( bballoon_speedup_r )
static MACHINE_RESET( bballoon )
{
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x4d000010, 0x4d000013, 0, 0, bballoon_speedup_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x4d000010, 0x4d000013, FUNC(bballoon_speedup_r));
s3c2410 = machine->device("s3c2410");
}

2
src/mame/drivers/gladiatr.c
View File

@ -1030,7 +1030,7 @@ static DRIVER_INIT(ppking)
}
}
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xf6a3,0xf6a3,0,0, f6a3_r );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xf6a3,0xf6a3,FUNC(f6a3_r) );
}

2
src/mame/drivers/gng.c
View File

@ -721,7 +721,7 @@ static READ8_HANDLER( diamond_hack_r )
static DRIVER_INIT( diamond )
{
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x6000, 0x6000, 0, 0, diamond_hack_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x6000, 0x6000, FUNC(diamond_hack_r));
}

42
src/mame/drivers/goldstar.c
View File

@ -9853,8 +9853,8 @@ static DRIVER_INIT( schery97 )
ROM[i] = x;
}
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x1d, 0x1d, 0, 0, fixedvala8_r);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x2a, 0x2a, 0, 0, fixedvalb4_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x1d, 0x1d, FUNC(fixedvala8_r));
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x2a, 0x2a, FUNC(fixedvalb4_r));
/* Oki 6295 at 0x20 */
}
@ -9883,7 +9883,7 @@ static DRIVER_INIT( schery97a )
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x16, 0x16, 0, 0, fixedval38_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x16, 0x16, FUNC(fixedval38_r));
/* Oki 6295 at 0x20 */
}
@ -9910,7 +9910,7 @@ static DRIVER_INIT( skill98 )
ROM[i] = x;
}
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x1e, 0x1e, 0, 0, fixedvalea_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x1e, 0x1e, FUNC(fixedvalea_r));
/* Oki 6295 at 0x20 */
}
@ -9937,7 +9937,7 @@ static DRIVER_INIT( fb36xc1 )
ROM[i] = x;
}
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x31, 0x31, 0, 0, fixedval68_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x31, 0x31, FUNC(fixedval68_r));
}
@ -9974,11 +9974,11 @@ static DRIVER_INIT( fbse354 )
ROM[i] = x;
}
// nfb96b needs both of these
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x23, 0x23, 0, 0, fixedval80_r);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x5a, 0x5a, 0, 0, fixedvalaa_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x23, 0x23, FUNC(fixedval80_r));
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x5a, 0x5a, FUNC(fixedvalaa_r));
// csel96b
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x6e, 0x6e, 0, 0, fixedval96_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x6e, 0x6e, FUNC(fixedval96_r));
}
@ -10006,7 +10006,7 @@ static DRIVER_INIT( fbse362 )
ROM[i] = x;
}
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x2e, 0x2e, 0, 0, fixedvalbe_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x2e, 0x2e, FUNC(fixedvalbe_r));
}
@ -10038,8 +10038,8 @@ static DRIVER_INIT( rp35 )
ROM[i] = x;
}
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x5e, 0x5e, 0, 0, fixedval84_r);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x36, 0x36, 0, 0, fixedval90_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x5e, 0x5e, FUNC(fixedval84_r));
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x36, 0x36, FUNC(fixedval90_r));
}
static READ8_HANDLER( fixedvalb2_r )
@ -10066,7 +10066,7 @@ static DRIVER_INIT( rp36 )
ROM[i] = x;
}
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x34, 0x34, 0, 0, fixedvalb2_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x34, 0x34, FUNC(fixedvalb2_r));
}
static READ8_HANDLER( fixedval48_r )
@ -10093,7 +10093,7 @@ static DRIVER_INIT( rp36c3 )
ROM[i] = x;
}
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x17, 0x17, 0, 0, fixedval48_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x17, 0x17, FUNC(fixedval48_r));
}
static READ8_HANDLER( fixedval09_r )
@ -10125,8 +10125,8 @@ static DRIVER_INIT( po33 )
ROM[i] = x;
}
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x32, 0x32, 0, 0, fixedval74_r);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x12, 0x12, 0, 0, fixedval09_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x32, 0x32, FUNC(fixedval74_r));
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x12, 0x12, FUNC(fixedval09_r));
/* oki6295 at 0x20 */
}
@ -10154,7 +10154,7 @@ static DRIVER_INIT( tc132axt )
ROM[i] = x;
}
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x21, 0x21, 0, 0, fixedval58_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x21, 0x21, FUNC(fixedval58_r));
}
static READ8_HANDLER( fixedvale4_r )
@ -10186,8 +10186,8 @@ static DRIVER_INIT( match133 )
ROM[i] = x;
}
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x16, 0x16, 0, 0, fixedvalc7_r);
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_IO), 0x1a, 0x1a, 0, 0, fixedvale4_r);
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x16, 0x16, FUNC(fixedvalc7_r));
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x1a, 0x1a, FUNC(fixedvale4_r));
}
static DRIVER_INIT(cherrys)
@ -10253,9 +10253,9 @@ static DRIVER_INIT( tonypok )
{
// the ppi doesn't seem to work properly, so just install the inputs directly
address_space *io = machine->device("maincpu")->memory().space(AS_IO);
memory_install_read_port(io, 0x04, 0x04, 0, 0, "IN0" );
memory_install_read_port(io, 0x05, 0x05, 0, 0, "IN1" );
memory_install_read_port(io, 0x06, 0x06, 0, 0, "IN2" );
io->install_read_port(0x04, 0x04, "IN0" );
io->install_read_port(0x05, 0x05, "IN1" );
io->install_read_port(0x06, 0x06, "IN2" );
}

8
src/mame/drivers/gottlieb.c
View File

@ -248,9 +248,9 @@ static MACHINE_START( gottlieb )
if (state->laserdisc != NULL)
{
/* attach to the I/O ports */
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x05805, 0x05807, 0, 0x07f8, laserdisc_status_r);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x05805, 0x05805, 0, 0x07f8, laserdisc_command_w); /* command for the player */
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x05806, 0x05806, 0, 0x07f8, laserdisc_select_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x05805, 0x05807, 0, 0x07f8, FUNC(laserdisc_status_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x05805, 0x05805, 0, 0x07f8, FUNC(laserdisc_command_w)); /* command for the player */
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x05806, 0x05806, 0, 0x07f8, FUNC(laserdisc_select_w));
/* allocate a timer for serial transmission, and one for philips code processing */
state->laserdisc_bit_timer = machine->scheduler().timer_alloc(FUNC(laserdisc_bit_callback));
@ -2613,7 +2613,7 @@ static DRIVER_INIT( romtiles )
static DRIVER_INIT( stooges )
{
DRIVER_INIT_CALL(ramtiles);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x05803, 0x05803, 0, 0x07f8, stooges_output_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x05803, 0x05803, 0, 0x07f8, FUNC(stooges_output_w));
}

2
src/mame/drivers/groundfx.c
View File

@ -464,7 +464,7 @@ static DRIVER_INIT( groundfx )
int data;
/* Speedup handlers */
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x20b574, 0x20b577, 0, 0, irq_speedup_r_groundfx);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x20b574, 0x20b577, FUNC(irq_speedup_r_groundfx));
/* make piv tile GFX format suitable for gfxdecode */
offset = size/2;

2
src/mame/drivers/gstream.c
View File

@ -634,7 +634,7 @@ static READ32_HANDLER( gstream_speedup_r )
static DRIVER_INIT( gstream )
{
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xd1ee0, 0xd1ee3, 0, 0, gstream_speedup_r );
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xd1ee0, 0xd1ee3, FUNC(gstream_speedup_r) );
}

12
src/mame/drivers/gstriker.c
View File

@ -1022,11 +1022,11 @@ static void mcu_init( running_machine *machine )
state->pending_command = 0;
state->mcu_data = 0;
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x20008a, 0x20008b, 0, 0, twrldc94_mcu_w);
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x20008a, 0x20008b, 0, 0, twrldc94_mcu_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x20008a, 0x20008b, FUNC(twrldc94_mcu_w));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x20008a, 0x20008b, FUNC(twrldc94_mcu_r));
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x20008e, 0x20008f, 0, 0, twrldc94_prot_reg_w);
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x20008e, 0x20008f, 0, 0, twrldc94_prot_reg_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x20008e, 0x20008f, FUNC(twrldc94_prot_reg_w));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x20008e, 0x20008f, FUNC(twrldc94_prot_reg_r));
}
static DRIVER_INIT( twrldc94 )
@ -1049,8 +1049,8 @@ static DRIVER_INIT( vgoalsoc )
state->gametype = 3;
mcu_init( machine );
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x200090, 0x200091, 0, 0, vbl_toggle_w); // vblank toggle
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x200090, 0x200091, 0, 0, vbl_toggle_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x200090, 0x200091, FUNC(vbl_toggle_w)); // vblank toggle
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x200090, 0x200091, FUNC(vbl_toggle_r));
}
/*** GAME DRIVERS ************************************************************/

4
src/mame/drivers/gsword.c
View File

@ -917,7 +917,7 @@ static DRIVER_INIT( gsword )
#endif
#if 1
/* hack for sound protection or time out function */
memory_install_read8_handler(machine->device("sub")->memory().space(AS_PROGRAM), 0x4004, 0x4005, 0, 0, gsword_hack_r);
machine->device("sub")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x4004, 0x4005, FUNC(gsword_hack_r));
#endif
}
@ -932,7 +932,7 @@ static DRIVER_INIT( gsword2 )
#endif
#if 1
/* hack for sound protection or time out function */
memory_install_read8_handler(machine->device("sub")->memory().space(AS_PROGRAM), 0x4004, 0x4005, 0, 0, gsword_hack_r);
machine->device("sub")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x4004, 0x4005, FUNC(gsword_hack_r));
#endif
}

2
src/mame/drivers/gunbustr.c
View File

@ -417,7 +417,7 @@ static READ32_HANDLER( main_cycle_r )
static DRIVER_INIT( gunbustr )
{
/* Speedup handler */
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x203acc, 0x203acf, 0, 0, main_cycle_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x203acc, 0x203acf, FUNC(main_cycle_r));
}
GAME( 1992, gunbustr, 0, gunbustr, gunbustr, gunbustr, ORIENTATION_FLIP_X, "Taito Corporation", "Gunbuster (Japan)", 0 )

2
src/mame/drivers/gundealr.c
View File

@ -579,7 +579,7 @@ static DRIVER_INIT( yamyam )
{
gundealr_state *state = machine->driver_data<gundealr_state>();
state->input_ports_hack = 1;
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xe000, 0xe000, 0, 0, yamyam_protection_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xe000, 0xe000, FUNC(yamyam_protection_w));
}

198
src/mame/drivers/harddriv.c
View File

@ -3791,9 +3791,9 @@ static void init_multisync(running_machine *machine, int compact_inputs)
/* install handlers for the compact driving games' inputs */
if (compact_inputs)
{
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x400000, 0x400001, 0, 0, hdc68k_wheel_r);
memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x408000, 0x408001, 0, 0, hdc68k_wheel_edge_reset_w);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xa80000, 0xafffff, 0, 0, hdc68k_port1_r);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x400000, 0x400001, FUNC(hdc68k_wheel_r));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x408000, 0x408001, FUNC(hdc68k_wheel_edge_reset_w));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa80000, 0xafffff, FUNC(hdc68k_port1_r));
}
}
@ -3804,18 +3804,18 @@ static void init_adsp(running_machine *machine)
harddriv_state *state = machine->driver_data<harddriv_state>();
/* install ADSP program RAM */
memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x800000, 0x807fff, 0, 0, hd68k_adsp_program_r, hd68k_adsp_program_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x800000, 0x807fff, FUNC(hd68k_adsp_program_r), FUNC(hd68k_adsp_program_w));
/* install ADSP data RAM */
memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x808000, 0x80bfff, 0, 0, hd68k_adsp_data_r, hd68k_adsp_data_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x808000, 0x80bfff, FUNC(hd68k_adsp_data_r), FUNC(hd68k_adsp_data_w));
/* install ADSP serial buffer RAM */
memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x810000, 0x813fff, 0, 0, hd68k_adsp_buffer_r, hd68k_adsp_buffer_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x810000, 0x813fff, FUNC(hd68k_adsp_buffer_r), FUNC(hd68k_adsp_buffer_w));
/* install ADSP control locations */
memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x818000, 0x81801f, 0, 0, hd68k_adsp_control_w);
memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x818060, 0x81807f, 0, 0, hd68k_adsp_irq_clear_w);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x838000, 0x83ffff, 0, 0, hd68k_adsp_irq_state_r);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x818000, 0x81801f, FUNC(hd68k_adsp_control_w));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x818060, 0x81807f, FUNC(hd68k_adsp_irq_clear_w));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x838000, 0x83ffff, FUNC(hd68k_adsp_irq_state_r));
}
@ -3825,21 +3825,21 @@ static void init_ds3(running_machine *machine)
harddriv_state *state = machine->driver_data<harddriv_state>();
/* install ADSP program RAM */
memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x800000, 0x807fff, 0, 0, hd68k_ds3_program_r, hd68k_ds3_program_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x800000, 0x807fff, FUNC(hd68k_ds3_program_r), FUNC(hd68k_ds3_program_w));
/* install ADSP data RAM */
memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x808000, 0x80bfff, 0, 0, hd68k_adsp_data_r, hd68k_adsp_data_w);
memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x80c000, 0x80dfff, 0, 0, hdds3_special_r, hdds3_special_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x808000, 0x80bfff, FUNC(hd68k_adsp_data_r), FUNC(hd68k_adsp_data_w));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x80c000, 0x80dfff, FUNC(hdds3_special_r), FUNC(hdds3_special_w));
/* install ADSP control locations */
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x820000, 0x8207ff, 0, 0, hd68k_ds3_gdata_r);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x820800, 0x820fff, 0, 0, hd68k_ds3_girq_state_r);
memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x820000, 0x8207ff, 0, 0, hd68k_ds3_gdata_w);
memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x821000, 0x8217ff, 0, 0, hd68k_adsp_irq_clear_w);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x822000, 0x8227ff, 0, 0, hd68k_ds3_sdata_r);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x822800, 0x822fff, 0, 0, hd68k_ds3_sirq_state_r);
memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x822000, 0x8227ff, 0, 0, hd68k_ds3_sdata_w);
memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x823800, 0x823fff, 0, 0, hd68k_ds3_control_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x820000, 0x8207ff, FUNC(hd68k_ds3_gdata_r));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x820800, 0x820fff, FUNC(hd68k_ds3_girq_state_r));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x820000, 0x8207ff, FUNC(hd68k_ds3_gdata_w));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x821000, 0x8217ff, FUNC(hd68k_adsp_irq_clear_w));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x822000, 0x8227ff, FUNC(hd68k_ds3_sdata_r));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x822800, 0x822fff, FUNC(hd68k_ds3_sirq_state_r));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x822000, 0x8227ff, FUNC(hd68k_ds3_sdata_w));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x823800, 0x823fff, FUNC(hd68k_ds3_control_w));
/* if we have a sound DSP, boot it */
if (state->ds4cpu1 != NULL)
@ -3924,26 +3924,26 @@ static void init_dsk(running_machine *machine)
UINT8 *usr3 = machine->region("user3")->base();
/* install ASIC61 */
memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x85c000, 0x85c7ff, 0, 0, hd68k_dsk_dsp32_r, hd68k_dsk_dsp32_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x85c000, 0x85c7ff, FUNC(hd68k_dsk_dsp32_r), FUNC(hd68k_dsk_dsp32_w));
/* install control registers */
memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x85c800, 0x85c81f, 0, 0, hd68k_dsk_control_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x85c800, 0x85c81f, FUNC(hd68k_dsk_control_w));
/* install extra RAM */
memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x900000, 0x90ffff, 0, 0, hd68k_dsk_ram_r, hd68k_dsk_ram_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x900000, 0x90ffff, FUNC(hd68k_dsk_ram_r), FUNC(hd68k_dsk_ram_w));
state->dsk_ram = (UINT16 *)(usr3 + 0x40000);
/* install extra ZRAM */
memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x910000, 0x910fff, 0, 0, hd68k_dsk_zram_r, hd68k_dsk_zram_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x910000, 0x910fff, FUNC(hd68k_dsk_zram_r), FUNC(hd68k_dsk_zram_w));
state->dsk_zram = (UINT16 *)(usr3 + 0x50000);
/* install ASIC65 */
memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x914000, 0x917fff, 0, 0, asic65_data_w);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x914000, 0x917fff, 0, 0, asic65_r);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x918000, 0x91bfff, 0, 0, asic65_io_r);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x914000, 0x917fff, FUNC(asic65_data_w));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x914000, 0x917fff, FUNC(asic65_r));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x918000, 0x91bfff, FUNC(asic65_io_r));
/* install extra ROM */
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x940000, 0x9fffff, 0, 0, hd68k_dsk_small_rom_r);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x940000, 0x9fffff, FUNC(hd68k_dsk_small_rom_r));
state->dsk_rom = (UINT16 *)(usr3 + 0x00000);
/* set up the ASIC65 */
@ -3958,22 +3958,22 @@ static void init_dsk2(running_machine *machine)
UINT8 *usr3 = machine->region("user3")->base();
/* install ASIC65 */
memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x824000, 0x824003, 0, 0, asic65_data_w);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x824000, 0x824003, 0, 0, asic65_r);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x825000, 0x825001, 0, 0, asic65_io_r);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x824000, 0x824003, FUNC(asic65_data_w));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x824000, 0x824003, FUNC(asic65_r));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x825000, 0x825001, FUNC(asic65_io_r));
/* install ASIC61 */
memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x827000, 0x8277ff, 0, 0, hd68k_dsk_dsp32_r, hd68k_dsk_dsp32_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x827000, 0x8277ff, FUNC(hd68k_dsk_dsp32_r), FUNC(hd68k_dsk_dsp32_w));
/* install control registers */
memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x827800, 0x82781f, 0, 0, hd68k_dsk_control_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x827800, 0x82781f, FUNC(hd68k_dsk_control_w));
/* install extra RAM */
memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x880000, 0x8bffff, 0, 0, hd68k_dsk_ram_r, hd68k_dsk_ram_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x880000, 0x8bffff, FUNC(hd68k_dsk_ram_r), FUNC(hd68k_dsk_ram_w));
state->dsk_ram = (UINT16 *)(usr3 + 0x100000);
/* install extra ROM */
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x900000, 0x9fffff, 0, 0, hd68k_dsk_rom_r);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x900000, 0x9fffff, FUNC(hd68k_dsk_rom_r));
state->dsk_rom = (UINT16 *)(usr3 + 0x000000);
/* set up the ASIC65 */
@ -3987,15 +3987,15 @@ static void init_dspcom(running_machine *machine)
harddriv_state *state = machine->driver_data<harddriv_state>();
/* install ASIC65 */
memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x900000, 0x900003, 0, 0, asic65_data_w);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x900000, 0x900003, 0, 0, asic65_r);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x901000, 0x910001, 0, 0, asic65_io_r);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x900000, 0x900003, FUNC(asic65_data_w));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x900000, 0x900003, FUNC(asic65_r));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x901000, 0x910001, FUNC(asic65_io_r));
/* set up the ASIC65 */
asic65_config(machine, ASIC65_STEELTAL);
/* install DSPCOM control */
memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x904000, 0x90401f, 0, 0, hddspcom_control_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x904000, 0x90401f, FUNC(hddspcom_control_w));
}
@ -4007,9 +4007,9 @@ static void init_driver_sound(running_machine *machine)
hdsnd_init(machine);
/* install sound handlers */
memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x840000, 0x840001, 0, 0, hd68k_snd_data_r, hd68k_snd_data_w);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x844000, 0x844001, 0, 0, hd68k_snd_status_r);
memory_install_write16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x84c000, 0x84c001, 0, 0, hd68k_snd_reset_w);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x840000, 0x840001, FUNC(hd68k_snd_data_r), FUNC(hd68k_snd_data_w));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x844000, 0x844001, FUNC(hd68k_snd_status_r));
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x84c000, 0x84c001, FUNC(hd68k_snd_reset_w));
}
@ -4031,18 +4031,18 @@ static DRIVER_INIT( harddriv )
init_driver_sound(machine);
/* set up gsp speedup handler */
state->gsp_speedup_addr[0] = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff9fc00, 0xfff9fc0f, 0, 0, hdgsp_speedup1_w);
state->gsp_speedup_addr[1] = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfffcfc00, 0xfffcfc0f, 0, 0, hdgsp_speedup2_w);
memory_install_read16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff9fc00, 0xfff9fc0f, 0, 0, hdgsp_speedup_r);
state->gsp_speedup_addr[0] = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff9fc00, 0xfff9fc0f, FUNC(hdgsp_speedup1_w));
state->gsp_speedup_addr[1] = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfffcfc00, 0xfffcfc0f, FUNC(hdgsp_speedup2_w));
state->gsp->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfff9fc00, 0xfff9fc0f, FUNC(hdgsp_speedup_r));
state->gsp_speedup_pc = 0xffc00f10;
/* set up msp speedup handler */
state->msp_speedup_addr = memory_install_write16_handler(state->msp->memory().space(AS_PROGRAM), 0x00751b00, 0x00751b0f, 0, 0, hdmsp_speedup_w);
memory_install_read16_handler(state->msp->memory().space(AS_PROGRAM), 0x00751b00, 0x00751b0f, 0, 0, hdmsp_speedup_r);
state->msp_speedup_addr = state->msp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x00751b00, 0x00751b0f, FUNC(hdmsp_speedup_w));
state->msp->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00751b00, 0x00751b0f, FUNC(hdmsp_speedup_r));
state->msp_speedup_pc = 0x00723b00;
/* set up adsp speedup handlers */
memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
}
@ -4056,18 +4056,18 @@ static DRIVER_INIT( harddrivc )
init_driver_sound(machine);
/* set up gsp speedup handler */
state->gsp_speedup_addr[0] = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff9fc00, 0xfff9fc0f, 0, 0, hdgsp_speedup1_w);
state->gsp_speedup_addr[1] = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfffcfc00, 0xfffcfc0f, 0, 0, hdgsp_speedup2_w);
memory_install_read16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff9fc00, 0xfff9fc0f, 0, 0, hdgsp_speedup_r);
state->gsp_speedup_addr[0] = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff9fc00, 0xfff9fc0f, FUNC(hdgsp_speedup1_w));
state->gsp_speedup_addr[1] = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfffcfc00, 0xfffcfc0f, FUNC(hdgsp_speedup2_w));
state->gsp->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfff9fc00, 0xfff9fc0f, FUNC(hdgsp_speedup_r));
state->gsp_speedup_pc = 0xfff40ff0;
/* set up msp speedup handler */
state->msp_speedup_addr = memory_install_write16_handler(state->msp->memory().space(AS_PROGRAM), 0x00751b00, 0x00751b0f, 0, 0, hdmsp_speedup_w);
memory_install_read16_handler(state->msp->memory().space(AS_PROGRAM), 0x00751b00, 0x00751b0f, 0, 0, hdmsp_speedup_r);
state->msp_speedup_addr = state->msp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x00751b00, 0x00751b0f, FUNC(hdmsp_speedup_w));
state->msp->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x00751b00, 0x00751b0f, FUNC(hdmsp_speedup_r));
state->msp_speedup_pc = 0x00723b00;
/* set up adsp speedup handlers */
memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
}
@ -4081,13 +4081,13 @@ static DRIVER_INIT( stunrun )
atarijsa_init(machine, "IN0", 0x0020);
/* set up gsp speedup handler */
state->gsp_speedup_addr[0] = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff9fc00, 0xfff9fc0f, 0, 0, hdgsp_speedup1_w);
state->gsp_speedup_addr[1] = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfffcfc00, 0xfffcfc0f, 0, 0, hdgsp_speedup2_w);
memory_install_read16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff9fc00, 0xfff9fc0f, 0, 0, hdgsp_speedup_r);
state->gsp_speedup_addr[0] = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff9fc00, 0xfff9fc0f, FUNC(hdgsp_speedup1_w));
state->gsp_speedup_addr[1] = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfffcfc00, 0xfffcfc0f, FUNC(hdgsp_speedup2_w));
state->gsp->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfff9fc00, 0xfff9fc0f, FUNC(hdgsp_speedup_r));
state->gsp_speedup_pc = 0xfff41070;
/* set up adsp speedup handlers */
memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
}
@ -4103,14 +4103,14 @@ static DRIVER_INIT( racedriv )
/* set up the slapstic */
slapstic_init(machine, 117);
state->m68k_slapstic_base = memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xe0000, 0xfffff, 0, 0, rd68k_slapstic_r, rd68k_slapstic_w);
state->m68k_slapstic_base = state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0xe0000, 0xfffff, FUNC(rd68k_slapstic_r), FUNC(rd68k_slapstic_w));
/* synchronization */
state->rddsp32_sync[0] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x613c00, 0x613c03, 0, 0, rddsp32_sync0_w);
state->rddsp32_sync[1] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x613e00, 0x613e03, 0, 0, rddsp32_sync1_w);
state->rddsp32_sync[0] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x613c00, 0x613c03, FUNC(rddsp32_sync0_w));
state->rddsp32_sync[1] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x613e00, 0x613e03, FUNC(rddsp32_sync1_w));
/* set up adsp speedup handlers */
memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
}
@ -4126,22 +4126,22 @@ static void racedrivc_init_common(running_machine *machine, offs_t gsp_protectio
/* set up the slapstic */
slapstic_init(machine, 117);
state->m68k_slapstic_base = memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xe0000, 0xfffff, 0, 0, rd68k_slapstic_r, rd68k_slapstic_w);
state->m68k_slapstic_base = state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0xe0000, 0xfffff, FUNC(rd68k_slapstic_r), FUNC(rd68k_slapstic_w));
/* synchronization */
state->rddsp32_sync[0] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x613c00, 0x613c03, 0, 0, rddsp32_sync0_w);
state->rddsp32_sync[1] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x613e00, 0x613e03, 0, 0, rddsp32_sync1_w);
state->rddsp32_sync[0] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x613c00, 0x613c03, FUNC(rddsp32_sync0_w));
state->rddsp32_sync[1] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x613e00, 0x613e03, FUNC(rddsp32_sync1_w));
/* set up protection hacks */
state->gsp_protection = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), gsp_protection, gsp_protection + 0x0f, 0, 0, hdgsp_protection_w);
state->gsp_protection = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(gsp_protection, gsp_protection + 0x0f, FUNC(hdgsp_protection_w));
/* set up gsp speedup handler */
state->gsp_speedup_addr[0] = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff76f60, 0xfff76f6f, 0, 0, rdgsp_speedup1_w);
memory_install_read16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff76f60, 0xfff76f6f, 0, 0, rdgsp_speedup1_r);
state->gsp_speedup_addr[0] = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff76f60, 0xfff76f6f, FUNC(rdgsp_speedup1_w));
state->gsp->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfff76f60, 0xfff76f6f, FUNC(rdgsp_speedup1_r));
state->gsp_speedup_pc = 0xfff43a00;
/* set up adsp speedup handlers */
memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
}
static DRIVER_INIT( racedrivc ) { racedrivc_init_common(machine, 0xfff95cd0); }
@ -4166,34 +4166,34 @@ static void steeltal_init_common(running_machine *machine, offs_t ds3_transfer_p
init_dspcom(machine);
atarijsa_init(machine, "IN0", 0x0020);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x908000, 0x908001, 0, 0, steeltal_dummy_r);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x908000, 0x908001, FUNC(steeltal_dummy_r));
/* set up the SLOOP */
if (!proto_sloop)
{
state->m68k_slapstic_base = memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xe0000, 0xfffff, 0, 0, st68k_sloop_r, st68k_sloop_w);
state->m68k_sloop_alt_base = memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0x4e000, 0x4ffff, 0, 0, st68k_sloop_alt_r);
state->m68k_slapstic_base = state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0xe0000, 0xfffff, FUNC(st68k_sloop_r), FUNC(st68k_sloop_w));
state->m68k_sloop_alt_base = state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x4e000, 0x4ffff, FUNC(st68k_sloop_alt_r));
}
else
state->m68k_slapstic_base = memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xe0000, 0xfffff, 0, 0, st68k_protosloop_r, st68k_protosloop_w);
state->m68k_slapstic_base = state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0xe0000, 0xfffff, FUNC(st68k_protosloop_r), FUNC(st68k_protosloop_w));
/* synchronization */
state->stmsp_sync[0] = &state->msp_ram[TOWORD(0x80010)];
memory_install_write16_handler(state->msp->memory().space(AS_PROGRAM), 0x80010, 0x8007f, 0, 0, stmsp_sync0_w);
state->msp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x80010, 0x8007f, FUNC(stmsp_sync0_w));
state->stmsp_sync[1] = &state->msp_ram[TOWORD(0x99680)];
memory_install_write16_handler(state->msp->memory().space(AS_PROGRAM), 0x99680, 0x9968f, 0, 0, stmsp_sync1_w);
state->msp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x99680, 0x9968f, FUNC(stmsp_sync1_w));
state->stmsp_sync[2] = &state->msp_ram[TOWORD(0x99d30)];
memory_install_write16_handler(state->msp->memory().space(AS_PROGRAM), 0x99d30, 0x99d4f, 0, 0, stmsp_sync2_w);
state->msp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x99d30, 0x99d4f, FUNC(stmsp_sync2_w));
/* set up protection hacks */
state->gsp_protection = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff965d0, 0xfff965df, 0, 0, hdgsp_protection_w);
state->gsp_protection = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff965d0, 0xfff965df, FUNC(hdgsp_protection_w));
/* set up msp speedup handlers */
memory_install_read16_handler(state->msp->memory().space(AS_PROGRAM), 0x80020, 0x8002f, 0, 0, stmsp_speedup_r);
state->msp->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x80020, 0x8002f, FUNC(stmsp_speedup_r));
/* set up adsp speedup handlers */
memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1f99, 0x1f99, 0, 0, hdds3_speedup_r);
state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1f99, 0x1f99, FUNC(hdds3_speedup_r));
state->ds3_speedup_addr = &state->adsp_data_memory[0x1f99];
state->ds3_speedup_pc = 0xff;
state->ds3_transfer_pc = ds3_transfer_pc;
@ -4216,20 +4216,20 @@ static DRIVER_INIT( strtdriv )
/* set up the slapstic */
slapstic_init(machine, 117);
state->m68k_slapstic_base = memory_install_readwrite16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xe0000, 0xfffff, 0, 0, rd68k_slapstic_r, rd68k_slapstic_w);
state->m68k_slapstic_base = state->maincpu->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0xe0000, 0xfffff, FUNC(rd68k_slapstic_r), FUNC(rd68k_slapstic_w));
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xa80000, 0xafffff, 0, 0, hda68k_port1_r);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa80000, 0xafffff, FUNC(hda68k_port1_r));
/* synchronization */
state->rddsp32_sync[0] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x613c00, 0x613c03, 0, 0, rddsp32_sync0_w);
state->rddsp32_sync[1] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x613e00, 0x613e03, 0, 0, rddsp32_sync1_w);
state->rddsp32_sync[0] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x613c00, 0x613c03, FUNC(rddsp32_sync0_w));
state->rddsp32_sync[1] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x613e00, 0x613e03, FUNC(rddsp32_sync1_w));
/* set up protection hacks */
state->gsp_protection = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff960a0, 0xfff960af, 0, 0, hdgsp_protection_w);
state->gsp_protection = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff960a0, 0xfff960af, FUNC(hdgsp_protection_w));
/* set up adsp speedup handlers */
memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1f99, 0x1f99, 0, 0, hdds3_speedup_r);
state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1f99, 0x1f99, FUNC(hdds3_speedup_r));
state->ds3_speedup_addr = &state->adsp_data_memory[0x1f99];
state->ds3_speedup_pc = 0xff;
state->ds3_transfer_pc = 0x43672;
@ -4245,18 +4245,18 @@ static DRIVER_INIT( hdrivair )
init_ds3(machine);
init_dsk2(machine);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xa80000, 0xafffff, 0, 0, hda68k_port1_r);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa80000, 0xafffff, FUNC(hda68k_port1_r));
/* synchronization */
state->rddsp32_sync[0] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x21fe00, 0x21fe03, 0, 0, rddsp32_sync0_w);
state->rddsp32_sync[1] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x21ff00, 0x21ff03, 0, 0, rddsp32_sync1_w);
state->rddsp32_sync[0] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x21fe00, 0x21fe03, FUNC(rddsp32_sync0_w));
state->rddsp32_sync[1] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x21ff00, 0x21ff03, FUNC(rddsp32_sync1_w));
/* set up protection hacks */
state->gsp_protection = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff943f0, 0xfff943ff, 0, 0, hdgsp_protection_w);
state->gsp_protection = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff943f0, 0xfff943ff, FUNC(hdgsp_protection_w));
/* set up adsp speedup handlers */
memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1f99, 0x1f99, 0, 0, hdds3_speedup_r);
state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1f99, 0x1f99, FUNC(hdds3_speedup_r));
state->ds3_speedup_addr = &state->adsp_data_memory[0x1f99];
state->ds3_speedup_pc = 0x2da;
state->ds3_transfer_pc = 0x407b8;
@ -4272,18 +4272,18 @@ static DRIVER_INIT( hdrivairp )
init_ds3(machine);
init_dsk2(machine);
memory_install_read16_handler(state->maincpu->memory().space(AS_PROGRAM), 0xa80000, 0xafffff, 0, 0, hda68k_port1_r);
state->maincpu->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xa80000, 0xafffff, FUNC(hda68k_port1_r));
/* synchronization */
state->rddsp32_sync[0] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x21fe00, 0x21fe03, 0, 0, rddsp32_sync0_w);
state->rddsp32_sync[1] = memory_install_write32_handler(state->dsp32->memory().space(AS_PROGRAM), 0x21ff00, 0x21ff03, 0, 0, rddsp32_sync1_w);
state->rddsp32_sync[0] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x21fe00, 0x21fe03, FUNC(rddsp32_sync0_w));
state->rddsp32_sync[1] = state->dsp32->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x21ff00, 0x21ff03, FUNC(rddsp32_sync1_w));
/* set up protection hacks */
state->gsp_protection = memory_install_write16_handler(state->gsp->memory().space(AS_PROGRAM), 0xfff916c0, 0xfff916cf, 0, 0, hdgsp_protection_w);
state->gsp_protection = state->gsp->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfff916c0, 0xfff916cf, FUNC(hdgsp_protection_w));
/* set up adsp speedup handlers */
memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1fff, 0x1fff, 0, 0, hdadsp_speedup_r);
memory_install_read16_handler(state->adsp->memory().space(AS_DATA), 0x1f9a, 0x1f9a, 0, 0, hdds3_speedup_r);
state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1fff, 0x1fff, FUNC(hdadsp_speedup_r));
state->adsp->memory().space(AS_DATA)->install_legacy_read_handler(0x1f9a, 0x1f9a, FUNC(hdds3_speedup_r));
state->ds3_speedup_addr = &state->adsp_data_memory[0x1f9a];
state->ds3_speedup_pc = 0x2d9;
state->ds3_transfer_pc = 0X407da;

4
src/mame/drivers/highvdeo.c
View File

@ -1159,7 +1159,7 @@ static READ16_HANDLER( ciclone_status_r )
static DRIVER_INIT( ciclone )
{
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_IO), 0x0030, 0x0033, 0, 0, ciclone_status_r );
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_read_handler(0x0030, 0x0033, FUNC(ciclone_status_r) );
}
/*
@ -1229,7 +1229,7 @@ static WRITE16_HANDLER( fashion_output_w )
static DRIVER_INIT( fashion )
{
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_IO), 0x0002, 0x0003, 0, 0, fashion_output_w );
machine->device("maincpu")->memory().space(AS_IO)->install_legacy_write_handler(0x0002, 0x0003, FUNC(fashion_output_w) );
}
GAMEL( 2000, tour4000, 0, tv_vcf, tv_vcf, 0, ROT0, "High Video", "Tour 4000", 0, layout_fashion )

8
src/mame/drivers/homedata.c
View File

@ -2032,15 +2032,15 @@ static DRIVER_INIT( jogakuen )
/* it seems that Mahjong Jogakuen runs on the same board as the others,
but with just these two addresses swapped. Instead of creating a new
MachineDriver, I just fix them here. */
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x8007, 0x8007, 0, 0, pteacher_blitter_bank_w);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x8005, 0x8005, 0, 0, pteacher_gfx_bank_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x8007, 0x8007, FUNC(pteacher_blitter_bank_w));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x8005, 0x8005, FUNC(pteacher_gfx_bank_w));
}
static DRIVER_INIT( mjikaga )
{
/* Mahjong Ikagadesuka is different as well. */
memory_install_read8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x7802, 0x7802, 0, 0, pteacher_snd_r);
memory_install_write8_handler(machine->device("audiocpu")->memory().space(AS_PROGRAM), 0x0123, 0x0123, 0, 0, pteacher_snd_answer_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x7802, 0x7802, FUNC(pteacher_snd_r));
machine->device("audiocpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x0123, 0x0123, FUNC(pteacher_snd_answer_w));
}
static DRIVER_INIT( reikaids )

2
src/mame/drivers/hshavoc.c
View File

@ -219,7 +219,7 @@ static DRIVER_INIT(hshavoc)
{
address_space *space = machine->device("maincpu")->memory().space(AS_PROGRAM);
memory_nop_write(space, 0x200000, 0x201fff, 0, 0);
space->nop_write(0x200000, 0x201fff);
}
DRIVER_INIT_CALL(megadriv);

8
src/mame/drivers/hyprduel.c
View File

@ -812,10 +812,10 @@ static DRIVER_INIT( hyprduel )
state->int_num = 0x02;
/* cpu synchronization (severe timings) */
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc0040e, 0xc00411, 0, 0, hyprduel_cpusync_trigger1_w);
memory_install_read16_handler(machine->device("sub")->memory().space(AS_PROGRAM), 0xc00408, 0xc00409, 0, 0, hyprduel_cpusync_trigger1_r);
memory_install_write16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xc00408, 0xc00409, 0, 0, hyprduel_cpusync_trigger2_w);
memory_install_read16_handler(machine->device("sub")->memory().space(AS_PROGRAM), 0xfff34c, 0xfff34d, 0, 0, hyprduel_cpusync_trigger2_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xc0040e, 0xc00411, FUNC(hyprduel_cpusync_trigger1_w));
machine->device("sub")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xc00408, 0xc00409, FUNC(hyprduel_cpusync_trigger1_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xc00408, 0xc00409, FUNC(hyprduel_cpusync_trigger2_w));
machine->device("sub")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xfff34c, 0xfff34d, FUNC(hyprduel_cpusync_trigger2_r));
}
static DRIVER_INIT( magerror )

12
src/mame/drivers/igs011.c
View File

@ -967,13 +967,13 @@ static WRITE16_HANDLER( igs011_prot_addr_w )
UINT8 *rom = space->machine->region("maincpu")->base();
// Plug previous address range with ROM access
memory_install_rom(sp, state->prot1_addr + 0, state->prot1_addr + 9, 0, 0, rom + state->prot1_addr);
sp->install_rom(state->prot1_addr + 0, state->prot1_addr + 9, rom + state->prot1_addr);
state->prot1_addr = (data << 4) ^ 0x8340;
// Add protection memory range
memory_install_write16_handler(sp, state->prot1_addr + 0, state->prot1_addr + 7, 0, 0, igs011_prot1_w);
memory_install_read16_handler (sp, state->prot1_addr + 8, state->prot1_addr + 9, 0, 0, igs011_prot1_r);
sp->install_legacy_write_handler(state->prot1_addr + 0, state->prot1_addr + 7, FUNC(igs011_prot1_w));
sp->install_legacy_read_handler (state->prot1_addr + 8, state->prot1_addr + 9, FUNC(igs011_prot1_r));
}
/*
static READ16_HANDLER( igs011_prot_fake_r )
@ -1800,7 +1800,7 @@ static DRIVER_INIT( drgnwrldv21 )
drgnwrld_type2_decrypt(machine);
drgnwrld_gfx_decrypt(machine);
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xd4c0, 0xd4ff, 0, 0, drgnwrldv21_igs011_prot2_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0xd4c0, 0xd4ff, FUNC(drgnwrldv21_igs011_prot2_r));
/*
// PROTECTION CHECKS
// bp 32ee; bp 11ca8; bp 23d5e; bp 23fd0; bp 24170; bp 24348; bp 2454e; bp 246cc; bp 24922; bp 24b66; bp 24de2; bp 2502a; bp 25556; bp 269de; bp 2766a; bp 2a830
@ -1940,7 +1940,7 @@ static DRIVER_INIT( dbc )
dbc_decrypt(machine);
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x10600, 0x107ff, 0, 0, dbc_igs011_prot2_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x10600, 0x107ff, FUNC(dbc_igs011_prot2_r));
/*
// PROTECTION CHECKS
rom[0x04c42/2] = 0x602e; // 004C42: 6604 bne 4c48 (rom test error otherwise)
@ -1969,7 +1969,7 @@ static DRIVER_INIT( ryukobou )
ryukobou_decrypt(machine);
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x10600, 0x107ff, 0, 0, ryukobou_igs011_prot2_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x10600, 0x107ff, FUNC(ryukobou_igs011_prot2_r));
// PROTECTION CHECKS
// rom[0x2df68/2] = 0x4e75; // 02DF68: 4E56 FE00 link A6, #-$200 (fills palette with pink otherwise)

4
src/mame/drivers/iqblock.c
View File

@ -444,7 +444,7 @@ static DRIVER_INIT( iqblock )
machine->generic.paletteram2.u8 = rom + 0x12800;
state->fgvideoram = rom + 0x16800;
state->bgvideoram = rom + 0x17000;
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfe26, 0xfe26, 0, 0, iqblock_prot_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfe26, 0xfe26, FUNC(iqblock_prot_w));
state->video_type=1;
}
@ -467,7 +467,7 @@ static DRIVER_INIT( grndtour )
machine->generic.paletteram2.u8 = rom + 0x12800;
state->fgvideoram = rom + 0x16800;
state->bgvideoram = rom + 0x17000;
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0xfe39, 0xfe39, 0, 0, grndtour_prot_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0xfe39, 0xfe39, FUNC(grndtour_prot_w));
state->video_type=0;
}

40
src/mame/drivers/itech32.c
View File

@ -4008,8 +4008,8 @@ static DRIVER_INIT( drivedge )
state->planes = 1;
state->is_drivedge = 1;
memory_install_read32_handler(machine->device("dsp1")->memory().space(AS_PROGRAM), 0x8382, 0x8382, 0, 0, drivedge_tms1_speedup_r);
memory_install_read32_handler(machine->device("dsp2")->memory().space(AS_PROGRAM), 0x8382, 0x8382, 0, 0, drivedge_tms2_speedup_r);
machine->device("dsp1")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x8382, 0x8382, FUNC(drivedge_tms1_speedup_r));
machine->device("dsp2")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x8382, 0x8382, FUNC(drivedge_tms2_speedup_r));
}
@ -4026,11 +4026,11 @@ static DRIVER_INIT( wcbowl )
state->vram_height = 1024;
state->planes = 1;
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x680000, 0x680001, 0, 0, trackball_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x680000, 0x680001, FUNC(trackball_r));
memory_nop_read(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x578000, 0x57ffff, 0, 0);
memory_install_read16_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x680080, 0x680081, 0, 0, wcbowl_prot_result_r);
memory_nop_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x680080, 0x680081, 0, 0);
machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_read(0x578000, 0x57ffff);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x680080, 0x680081, FUNC(wcbowl_prot_result_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->nop_write(0x680080, 0x680081);
}
@ -4044,8 +4044,8 @@ static void init_sftm_common(running_machine *machine, int prot_addr)
state->itech020_prot_address = prot_addr;
memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x300000, 0x300003, 0, 0, itech020_color2_w);
memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x380000, 0x380003, 0, 0, itech020_color1_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x300000, 0x300003, FUNC(itech020_color2_w));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x380000, 0x380003, FUNC(itech020_color1_w));
}
@ -4076,10 +4076,10 @@ static void init_shuffle_bowl_common(running_machine *machine, int prot_addr)
state->itech020_prot_address = prot_addr;
memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x300000, 0x300003, 0, 0, itech020_color2_w);
memory_install_write32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x380000, 0x380003, 0, 0, itech020_color1_w);
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x180800, 0x180803, 0, 0, trackball32_4bit_p1_r);
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x181000, 0x181003, 0, 0, trackball32_4bit_p2_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x300000, 0x300003, FUNC(itech020_color2_w));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x380000, 0x380003, FUNC(itech020_color1_w));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x180800, 0x180803, FUNC(trackball32_4bit_p1_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x181000, 0x181003, FUNC(trackball32_4bit_p2_r));
}
@ -4098,7 +4098,7 @@ static DRIVER_INIT( wcbowln ) /* PIC 16C54 labeled as ITBWL-3 */
static void install_timekeeper(running_machine *machine)
{
device_t *device = machine->device("m48t02");
memory_install_readwrite32_device_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), device, 0x681000, 0x6817ff, 0, 0, timekeeper_32be_r, timekeeper_32be_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(*device, 0x681000, 0x6817ff, FUNC(timekeeper_32be_r), FUNC(timekeeper_32be_w));
}
static DRIVER_INIT( wcbowlt ) /* PIC 16C54 labeled as ITBWL-3 */
@ -4130,7 +4130,7 @@ static DRIVER_INIT( gt3d )
Hacked versions of this PCB have been found with GT97
through GTClassic. This is _NOT_ a factory modification
*/
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x200000, 0x200003, 0, 0, trackball32_8bit_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x200000, 0x200003, FUNC(trackball32_8bit_r));
init_gt_common(machine);
}
@ -4143,8 +4143,8 @@ static DRIVER_INIT( aama )
board share the same sound CPU code and sample ROMs.
This board has all versions of GT for it, GT3D through GTClassic
*/
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x180800, 0x180803, 0, 0, trackball32_4bit_p1_r);
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x181000, 0x181003, 0, 0, trackball32_4bit_p2_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x180800, 0x180803, FUNC(trackball32_4bit_p1_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x181000, 0x181003, FUNC(trackball32_4bit_p2_r));
init_gt_common(machine);
}
@ -4168,7 +4168,7 @@ static DRIVER_INIT( s_ver )
board: GT97 v1.21S, GT98, GT99, GT2K & GT Classic Versions 1.00S
Trackball info is read through 200202 (actually 200203).
*/
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x200200, 0x200203, 0, 0, trackball32_4bit_p1_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x200200, 0x200203, FUNC(trackball32_4bit_p1_r));
init_gt_common(machine);
}
@ -4182,7 +4182,7 @@ static DRIVER_INIT( gt3dl )
Player 1 trackball read through 200003
Player 2 trackball read through 200002
*/
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x200000, 0x200003, 0, 0, trackball32_4bit_combined_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x200000, 0x200003, FUNC(trackball32_4bit_combined_r));
init_gt_common(machine);
}
@ -4190,7 +4190,7 @@ static DRIVER_INIT( gt3dl )
static DRIVER_INIT( gt2kp )
{
/* a little extra protection */
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x680000, 0x680003, 0, 0, gt2kp_prot_result_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x680000, 0x680003, FUNC(gt2kp_prot_result_r));
DRIVER_INIT_CALL(aama);
/* The protection code is:
@ -4211,7 +4211,7 @@ Label1 bne.s Label1 ; Infinite loop if result isn't 0x01
static DRIVER_INIT( gtclasscp )
{
/* a little extra protection */
memory_install_read32_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x680000, 0x680003, 0, 0, gtclass_prot_result_r);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler(0x680000, 0x680003, FUNC(gtclass_prot_result_r));
DRIVER_INIT_CALL(aama);
/* The protection code is:

32
src/mame/drivers/itech8.c
View File

@ -2634,25 +2634,25 @@ ROM_END
static DRIVER_INIT( grmatch )
{
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0160, 0x0160, 0, 0, grmatch_palette_w);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0180, 0x0180, 0, 0, grmatch_xscroll_w);
memory_unmap_write(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x01e0, 0x01ff, 0, 0);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x0160, 0x0160, FUNC(grmatch_palette_w));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x0180, 0x0180, FUNC(grmatch_xscroll_w));
machine->device("maincpu")->memory().space(AS_PROGRAM)->unmap_write(0x01e0, 0x01ff);
}
static DRIVER_INIT( slikshot )
{
memory_install_read8_handler (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0180, 0x0180, 0, 0, slikshot_z80_r);
memory_install_read8_handler (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x01cf, 0x01cf, 0, 0, slikshot_z80_control_r);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x01cf, 0x01cf, 0, 0, slikshot_z80_control_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler (0x0180, 0x0180, FUNC(slikshot_z80_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler (0x01cf, 0x01cf, FUNC(slikshot_z80_control_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x01cf, 0x01cf, FUNC(slikshot_z80_control_w));
}
static DRIVER_INIT( sstrike )
{
memory_install_read8_handler (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x1180, 0x1180, 0, 0, slikshot_z80_r);
memory_install_read8_handler (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x11cf, 0x11cf, 0, 0, slikshot_z80_control_r);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x11cf, 0x11cf, 0, 0, slikshot_z80_control_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler (0x1180, 0x1180, FUNC(slikshot_z80_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler (0x11cf, 0x11cf, FUNC(slikshot_z80_control_r));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x11cf, 0x11cf, FUNC(slikshot_z80_control_w));
}
@ -2691,15 +2691,15 @@ static DRIVER_INIT( neckneck )
static DRIVER_INIT( rimrockn )
{
/* additional input ports */
memory_install_read_port (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0161, 0x0161, 0, 0, "161");
memory_install_read_port (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0162, 0x0162, 0, 0, "162");
memory_install_read_port (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0163, 0x0163, 0, 0, "163");
memory_install_read_port (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0164, 0x0164, 0, 0, "164");
memory_install_read_port (machine->device("maincpu")->memory().space(AS_PROGRAM), 0x0165, 0x0165, 0, 0, "165");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port (0x0161, 0x0161, "161");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port (0x0162, 0x0162, "162");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port (0x0163, 0x0163, "163");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port (0x0164, 0x0164, "164");
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_read_port (0x0165, 0x0165, "165");
/* different banking mechanism (disable the old one) */
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x01a0, 0x01a0, 0, 0, rimrockn_bank_w);
memory_install_write8_handler(machine->device("maincpu")->memory().space(AS_PROGRAM), 0x01c0, 0x01df, 0, 0, itech8_blitter_w);
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x01a0, 0x01a0, FUNC(rimrockn_bank_w));
machine->device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x01c0, 0x01df, FUNC(itech8_blitter_w));
}

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