static DRIVER_INIT( esb )
{
/* init the slapstic */
slapstic_init(101);
slapstic_source = &memory_region(REGION_CPU1)[0x14000];
slapstic_base = &memory_region(REGION_CPU1)[0x08000];
/* install an opcode base handler */
memory_set_opbase_handler(0, esb_setopbase);
/* install read/write handlers for it */
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0x8000, 0x9fff, 0, 0, esb_slapstic_r);
memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, 0x8000, 0x9fff, 0, 0, esb_slapstic_w);
/* install additional banking */
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0xa000, 0xffff, 0, 0, MRA8_BANK2);
/* prepare the mathbox */
starwars_is_esb = 1;
swmathbox_init();
/* initialize banking */
memory_configure_bank(1, 0, 2, memory_region(REGION_CPU1) + 0x6000, 0x10000 - 0x6000);
memory_set_bank(1, 0);
memory_configure_bank(2, 0, 2, memory_region(REGION_CPU1) + 0xa000, 0x1c000 - 0xa000);
memory_set_bank(2, 0);
}
void e01_state::machine_start()
{
UINT8 *ram = ram_get_ptr(m_ram);
UINT8 *rom = machine().region(R65C102_TAG)->base();
/* setup memory banking */
memory_configure_bank(machine(), "bank1", 0, 1, ram, 0);
memory_configure_bank(machine(), "bank1", 1, 1, rom, 0);
memory_set_bank(machine(), "bank1", 1);
memory_configure_bank(machine(), "bank2", 0, 1, ram, 0);
memory_set_bank(machine(), "bank2", 0);
memory_configure_bank(machine(), "bank3", 0, 1, ram + 0xfd00, 0);
memory_configure_bank(machine(), "bank3", 1, 1, rom + 0xfd00, 0);
memory_set_bank(machine(), "bank3", 1);
memory_configure_bank(machine(), "bank4", 0, 1, ram + 0xfd00, 0);
memory_set_bank(machine(), "bank4", 0);
/* register for state saving */
save_item(NAME(m_adlc_ie));
save_item(NAME(m_hdc_ie));
save_item(NAME(m_rtc_irq));
save_item(NAME(m_via_irq));
save_item(NAME(m_hdc_irq));
save_item(NAME(m_fdc_drq));
save_item(NAME(m_adlc_irq));
}
static MACHINE_RESET( shangkid )
{
cputag_set_input_line(machine, "bbx", INPUT_LINE_HALT, 1 );
memory_set_bank(machine, "bank1", 0);
memory_set_bank(machine, "bank2", 0);
}
static WRITE8_HANDLER(pcat_nit_rombank_w)
{
pcat_nit_state *state = space->machine().driver_data<pcat_nit_state>();
logerror( "rom bank #%02x at PC=%08X\n", data, cpu_get_pc(&space->device()) );
if ( data & 0x40 )
{
// rom bank
space->install_read_bank(0x000d8000, 0x000dffff, "rombank" );
space->unmap_write(0x000d8000, 0x000dffff);
if ( data & 0x80 )
{
memory_set_bank(space->machine(), "rombank", (data & 0x3f) | 0x40 );
}
else
{
memory_set_bank(space->machine(), "rombank", data & 0x3f );
}
}
else
{
// nvram bank
space->unmap_readwrite(0x000d8000, 0x000dffff);
space->install_readwrite_bank(0x000d8000, 0x000d9fff, "nvrambank" );
memory_set_bankptr(space->machine(), "nvrambank", state->m_banked_nvram);
}
}
/**
* xx------ msb scrollx
* --x----- msb scrolly
* ---x---- screen flip
* ----xxxx bank
*/
static WRITE8_HANDLER( cpu1_bankswitch_w )
{
djboy_state *state = space->machine->driver_data<djboy_state>();
state->videoreg = data;
switch (data & 0xf)
{
/* bs65.5y */
case 0x00:
case 0x01:
case 0x02:
case 0x03:
memory_set_bank(space->machine, "bank2", (data & 0xf));
break;
/* bs101.6w */
case 0x08:
case 0x09:
case 0x0a:
case 0x0b:
case 0x0c:
case 0x0d:
case 0x0e:
case 0x0f:
memory_set_bank(space->machine, "bank2", (data & 0xf) - 4);
break;
default:
break;
}
}
static WRITE8_HANDLER( gng_bankswitch_w )
{
if (data == 4)
memory_set_bank(space->machine(), "bank1", 4);
else
memory_set_bank(space->machine(), "bank1", (data & 0x03));
}
void sg1000_state::install_cartridge(UINT8 *ptr, int size)
{
address_space *program = m_maincpu->memory().space(AS_PROGRAM);
switch (size)
{
case 40 * 1024:
program->install_read_bank(0x8000, 0x9fff, "bank1");
program->unmap_write(0x8000, 0x9fff);
memory_configure_bank(machine(), "bank1", 0, 1, machine().region(Z80_TAG)->base() + 0x8000, 0);
memory_set_bank(machine(), "bank1", 0);
break;
case 48 * 1024:
program->install_read_bank(0x8000, 0xbfff, "bank1");
program->unmap_write(0x8000, 0xbfff);
memory_configure_bank(machine(), "bank1", 0, 1, machine().region(Z80_TAG)->base() + 0x8000, 0);
memory_set_bank(machine(), "bank1", 0);
break;
default:
if (IS_CARTRIDGE_TV_DRAW(ptr))
{
program->install_write_handler(0x6000, 0x6000, 0, 0, write8_delegate(FUNC(sg1000_state::tvdraw_axis_w), this), 0);
program->install_read_handler(0x8000, 0x8000, 0, 0, read8_delegate(FUNC(sg1000_state::tvdraw_status_r), this), 0);
program->install_read_handler(0xa000, 0xa000, 0, 0, read8_delegate(FUNC(sg1000_state::tvdraw_data_r), this), 0);
program->nop_write(0xa000, 0xa000);
}
else if (IS_CARTRIDGE_THE_CASTLE(ptr))
{
program->install_readwrite_bank(0x8000, 0x9fff, "bank1");
}
break;
}
}
static WRITE8_HANDLER(tutor_mapper_w)
{
tutor_state *state = space->machine().driver_data<tutor_state>();
switch (offset)
{
case 0x00:
/* disable system ROM, enable alternate boot ROM in cartridge */
break;
case 0x08:
/* disable cartridge ROM, enable BASIC ROM at base >8000 */
state->m_cartridge_enable = 0;
memory_set_bank(space->machine(), "bank1", 0);
break;
case 0x0c:
/* enable cartridge ROM, disable BASIC ROM at base >8000 */
state->m_cartridge_enable = 1;
memory_set_bank(space->machine(), "bank1", 1);
break;
default:
if (! (offset & 1))
logerror("unknown port in %s %d\n", __FILE__, __LINE__);
break;
}
}
static WRITE8_HANDLER(pcat_nit_rombank_w)
{
logerror( "rom bank #%02x at PC=%08X\n", data, cpu_get_pc(space->cpu) );
if ( data & 0x40 )
{
// rom bank
memory_install_read_bank(space, 0x000d8000, 0x000dffff, 0, 0, "rombank" );
memory_unmap_write(space, 0x000d8000, 0x000dffff, 0, 0);
if ( data & 0x80 )
{
memory_set_bank(space->machine, "rombank", (data & 0x3f) | 0x40 );
}
else
{
memory_set_bank(space->machine, "rombank", data & 0x3f );
}
}
else
{
// nvram bank
memory_unmap_readwrite(space, 0x000d8000, 0x000dffff, 0, 0);
memory_install_readwrite_bank(space, 0x000d8000, 0x000d9fff, 0, 0, "nvrambank" );
memory_set_bankptr(space->machine, "nvrambank", banked_nvram);
}
}
static MACHINE_RESET( chinhero )
{
memory_configure_bank(1, 0, 2, memory_region(REGION_CPU1) + 0x8000, 0x8000);
memory_set_bank(1, 0);
memory_configure_bank(2, 0, 2, memory_region(REGION_CPU3) + 0x0000, 0x10000);
memory_set_bank(2, 0);
}
static WRITE8_HANDLER( cpu0_bankswitch_w )
{
djboy_state *state = space->machine->driver_data<djboy_state>();
data ^= state->bankxor;
memory_set_bank(space->machine, "bank1", data);
memory_set_bank(space->machine, "bank4", 0); /* unsure if/how this area is banked */
}
static MACHINE_START( dealer )
{
UINT8 *ROM = memory_region(machine, "maincpu");
memory_configure_bank(machine, "bank1", 0, 4, &ROM[0x0000], 0x10000);
memory_configure_bank(machine, "bank2", 0, 2, &ROM[0x6000], 0x1000);
memory_set_bank(machine, "bank1", 0);
memory_set_bank(machine, "bank2", 0);
MACHINE_START_CALL(epos);
}
void lc80_state::machine_start()
{
address_space *program = m_maincpu->memory().space(AS_PROGRAM);
/* setup memory banking */
memory_configure_bank(machine(), "bank1", 0, 1, machine().region(Z80_TAG)->base(), 0); // TODO
memory_configure_bank(machine(), "bank1", 1, 1, machine().region(Z80_TAG)->base(), 0);
memory_set_bank(machine(), "bank1", 1);
memory_configure_bank(machine(), "bank2", 0, 1, machine().region(Z80_TAG)->base() + 0x800, 0); // TODO
memory_configure_bank(machine(), "bank2", 1, 1, machine().region(Z80_TAG)->base() + 0x800, 0);
memory_set_bank(machine(), "bank2", 1);
memory_configure_bank(machine(), "bank3", 0, 1, machine().region(Z80_TAG)->base() + 0x1000, 0); // TODO
memory_configure_bank(machine(), "bank3", 1, 1, machine().region(Z80_TAG)->base() + 0x1000, 0);
memory_set_bank(machine(), "bank3", 1);
memory_configure_bank(machine(), "bank4", 0, 1, machine().region(Z80_TAG)->base() + 0x2000, 0);
memory_set_bank(machine(), "bank4", 0);
program->install_readwrite_bank(0x0000, 0x07ff, "bank1");
program->install_readwrite_bank(0x0800, 0x0fff, "bank2");
program->install_readwrite_bank(0x1000, 0x17ff, "bank3");
switch (ram_get_size(m_ram))
{
case 1*1024:
program->install_readwrite_bank(0x2000, 0x23ff, "bank4");
program->unmap_readwrite(0x2400, 0x2fff);
break;
case 2*1024:
program->install_readwrite_bank(0x2000, 0x27ff, "bank4");
program->unmap_readwrite(0x2800, 0x2fff);
break;
case 3*1024:
program->install_readwrite_bank(0x2000, 0x2bff, "bank4");
program->unmap_readwrite(0x2c00, 0x2fff);
break;
case 4*1024:
program->install_readwrite_bank(0x2000, 0x2fff, "bank4");
break;
}
/* register for state saving */
save_item(NAME(m_digit));
save_item(NAME(m_segment));
}
void mm1_state::machine_start()
{
address_space *program = m_maincpu->memory().space(AS_PROGRAM);
/* find memory regions */
m_key_rom = machine().region("keyboard")->base();
/* setup memory banking */
program->install_read_bank(0x0000, 0x0fff, "bank1");
program->unmap_write(0x0000, 0x0fff);
memory_configure_bank(machine(), "bank1", 0, 1, machine().region("bios")->base(), 0);
memory_configure_bank(machine(), "bank1", 1, 1, ram_get_ptr(machine().device(RAM_TAG)), 0);
memory_set_bank(machine(), "bank1", 0);
/* register for state saving */
state_save_register_global(machine(), m_sense);
state_save_register_global(machine(), m_drive);
state_save_register_global(machine(), m_llen);
state_save_register_global(machine(), m_intc);
state_save_register_global(machine(), m_rx21);
state_save_register_global(machine(), m_tx21);
state_save_register_global(machine(), m_rcl);
state_save_register_global(machine(), m_recall);
state_save_register_global(machine(), m_dack3);
}
ROM_END
/***************************************************************************
Game driver(s)
***************************************************************************/
static KONAMI_SETLINES_CALLBACK( crimfght_banking )
{
crimfght_state *state = device->machine().driver_data<crimfght_state>();
/* bit 5 = select work RAM or palette */
if (lines & 0x20)
{
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
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->m_k052109, (lines & 0x40) ? ASSERT_LINE : CLEAR_LINE);
memory_set_bank(device->machine(), "bank2", lines & 0x0f);
}
ADDRESS_MAP_END
static WRITE8_HANDLER( tecmosys_z80_bank_w )
{
memory_set_bank(space->machine(), "bank1", data);
}
AM_RANGE(0x8000, 0xffff) AM_ROM
ADDRESS_MAP_END
static WRITE8_HANDLER( z80_bankswitch_w )
{
memory_set_bank(2, data & 7);
}
void segaic16_memory_mapper_set_decrypted(running_machine *machine, UINT8 *decrypted)
{
struct memory_mapper_chip *chip = &memory_mapper;
offs_t romsize = chip->cpu->region()->bytes();
int rgnum;
/* loop over the regions */
for (rgnum = 0; chip->map[rgnum].regbase != 0; rgnum++)
{
static const offs_t region_size_map[4] = { 0x00ffff, 0x01ffff, 0x07ffff, 0x1fffff };
const segaic16_memory_map_entry *rgn = &chip->map[rgnum];
offs_t region_size = region_size_map[chip->regs[rgn->regbase] & 3];
offs_t region_base = (chip->regs[rgn->regbase + 1] << 16) & ~region_size;
offs_t region_start = region_base + (rgn->regoffs & region_size);
const char *readbank = rgn->readbank;
/* skip non-ROM regions */
if (readbank == NULL || rgn->romoffset == ~0)
continue;
/* skip any mappings beyond the ROM size */
if (region_start >= romsize)
continue;
memory_configure_bank_decrypted(machine, readbank, 0, 1, decrypted + region_start, 0);
memory_set_bank(machine, readbank, 0);
}
}
/***************************************************************************
Game ROMs
***************************************************************************/
ROM_START( blockhl )
ROM_REGION( 0x18000, "maincpu", 0 ) /* code + banked roms + space for banked RAM */
ROM_LOAD( "973l02.e21", 0x10000, 0x08000, CRC(e14f849a) SHA1(d44cf178cc98998b72ed32c6e20b6ebdf1f97579) )
ROM_CONTINUE( 0x08000, 0x08000 )
ROM_REGION( 0x10000, "audiocpu", 0 ) /* 64k for the sound CPU */
ROM_LOAD( "973d01.g6", 0x0000, 0x8000, CRC(eeee9d92) SHA1(6c6c324b1f6f4fba0aa12e0d1fc5dbab133ef669) )
ROM_REGION( 0x20000, "gfx1", 0 ) /* graphics (addressable by the main CPU) */
ROM_LOAD16_BYTE( "973f07.k15", 0x00000, 0x08000, CRC(1a8cd9b4) SHA1(7cb7944d24ac51fa6b610542d9dec68697cacf0f) ) /* tiles */
ROM_LOAD16_BYTE( "973f08.k18", 0x00001, 0x08000, CRC(952b51a6) SHA1(017575738d444b688b137cad5611638d53be84f2) )
ROM_LOAD16_BYTE( "973f09.k20", 0x10000, 0x08000, CRC(77841594) SHA1(e1bfdc5bb598d865868d578ef7faba8078becd7a) )
ROM_LOAD16_BYTE( "973f10.k23", 0x10001, 0x08000, CRC(09039fab) SHA1(a9dea17aacf4484d21ef3b16470263447b51b6b5) )
ROM_REGION( 0x20000, "gfx2", 0 ) /* graphics (addressable by the main CPU) */
ROM_LOAD16_BYTE( "973f06.k12", 0x00000, 0x08000, CRC(51acfdb6) SHA1(94d243f341b490684f5297d95d4835bd522ece35) ) /* sprites */
ROM_LOAD16_BYTE( "973f05.k9", 0x00001, 0x08000, CRC(4cfea298) SHA1(4772b5b99f5fd8174d8884bd84173512e1edabf4) )
ROM_LOAD16_BYTE( "973f04.k7", 0x10000, 0x08000, CRC(69ca41bd) SHA1(9b0b1c888efd2f2d5525f14778e18fb4a7353eb6) )
ROM_LOAD16_BYTE( "973f03.k4", 0x10001, 0x08000, CRC(21e98472) SHA1(8c697d369a1f57be0825c33b4e9107ce1b02a130) )
ROM_REGION( 0x0100, "proms", 0 ) /* PROMs */
ROM_LOAD( "973a11.h10", 0x0000, 0x0100, CRC(46d28fe9) SHA1(9d0811a928c8907785ef483bfbee5445506b3ec8) ) /* priority encoder (not used) */
ROM_END
ROM_START( quarth )
ROM_REGION( 0x18000, "maincpu", 0 ) /* code + banked roms + space for banked RAM */
ROM_LOAD( "973j02.e21", 0x10000, 0x08000, CRC(27a90118) SHA1(51309385b93db29b9277d14252166c4ea1746303) )
ROM_CONTINUE( 0x08000, 0x08000 )
ROM_REGION( 0x10000, "audiocpu", 0 ) /* 64k for the sound CPU */
ROM_LOAD( "973d01.g6", 0x0000, 0x8000, CRC(eeee9d92) SHA1(6c6c324b1f6f4fba0aa12e0d1fc5dbab133ef669) )
ROM_REGION( 0x20000, "gfx1", 0 ) /* graphics (addressable by the main CPU) */
ROM_LOAD16_BYTE( "973e07.k15", 0x00000, 0x08000, CRC(0bd6b0f8) SHA1(6c59cf637354fe2df424eaa89feb9c1bc1f66a92) ) /* tiles */
ROM_LOAD16_BYTE( "973e08.k18", 0x00001, 0x08000, CRC(104d0d5f) SHA1(595698911513113d01e5b565f5b073d1bd033d3f) )
ROM_LOAD16_BYTE( "973e09.k20", 0x10000, 0x08000, CRC(bd3a6f24) SHA1(eb45db3a6a52bb2b25df8c2dace877e59b4130a6) )
ROM_LOAD16_BYTE( "973e10.k23", 0x10001, 0x08000, CRC(cf5e4b86) SHA1(43348753894c1763b26dbfc70245dac92048db8f) )
ROM_REGION( 0x20000, "gfx2", 0 ) /* graphics (addressable by the main CPU) */
ROM_LOAD16_BYTE( "973e06.k12", 0x00000, 0x08000, CRC(0d58af85) SHA1(2efd661d614fb305a14cfe1aa4fb17714f215d4f) ) /* sprites */
ROM_LOAD16_BYTE( "973e05.k9", 0x00001, 0x08000, CRC(15d822cb) SHA1(70ecad5e0a461df0da6e6eb23f43a7b643297f0d) )
ROM_LOAD16_BYTE( "973e04.k7", 0x10000, 0x08000, CRC(d70f4a2c) SHA1(25f835a17bacf2b8debb2eb8a3cff90cab3f402a) )
ROM_LOAD16_BYTE( "973e03.k4", 0x10001, 0x08000, CRC(2c5a4b4b) SHA1(e2991dd78b9cd96cf93ebd6de0d4e060d346ab9c) )
ROM_REGION( 0x0100, "proms", 0 ) /* PROMs */
ROM_LOAD( "973a11.h10", 0x0000, 0x0100, CRC(46d28fe9) SHA1(9d0811a928c8907785ef483bfbee5445506b3ec8) ) /* priority encoder (not used) */
ROM_END
/***************************************************************************
Game driver(s)
***************************************************************************/
static KONAMI_SETLINES_CALLBACK( blockhl_banking )
{
blockhl_state *state = device->machine->driver_data<blockhl_state>();
/* bits 0-1 = ROM bank */
state->rombank = lines & 0x03;
memory_set_bank(device->machine, "bank1", state->rombank);
/* bits 3/4 = coin counters */
coin_counter_w(device->machine, 0, lines & 0x08);
coin_counter_w(device->machine, 1, lines & 0x10);
/* bit 5 = select palette RAM or work RAM at 5800-5fff */
state->palette_selected = ~lines & 0x20;
/* bit 6 = enable char ROM reading through the video RAM */
k052109_set_rmrd_line(state->k052109, (lines & 0x40) ? ASSERT_LINE : CLEAR_LINE);
/* bit 7 used but unknown */
/* other bits unknown */
if ((lines & 0x84) != 0x80)
logerror("%04x: setlines %02x\n", cpu_get_pc(device), lines);
}
static void gmgalax_select_game(int game)
{
gmgalax_selected_game = game;
memory_set_bank(1, game);
galaxold_gfxbank_w(Machine, 0, gmgalax_selected_game);
}
static WRITE8_HANDLER( fromanc2_subcpu_rombank_w )
{
// Change ROM BANK
memory_set_bank(space->machine(), "bank1", data & 0x03);
// Change RAM BANK
memory_set_bank(space->machine(), "bank2", (data & 0x0c) >> 2);
}
INPUT_PORTS_END
/* after the first 4 bytes have been read from ROM, switch the ram back in */
static TIMER_CALLBACK( sys2900_boot )
{
memory_set_bank(machine, "boot", 0);
}
ADDRESS_MAP_END
/*** Sound ***/
static WRITE8_HANDLER ( mcatadv_sound_bw_w )
{
memory_set_bank(space->machine, "bank1", data);
}
void mc1000_state::bankswitch()
{
address_space *program = m_maincpu->memory().space(AS_PROGRAM);
/* MC6845 video RAM */
memory_set_bank(machine(), "bank2", m_mc6845_bank);
/* extended RAM */
if (ram_get_size(m_ram) > 16*1024)
{
program->install_readwrite_bank(0x4000, 0x7fff, "bank3");
}
else
{
program->unmap_readwrite(0x4000, 0x7fff);
}
/* MC6847 video RAM */
if (m_mc6847_bank)
{
if (ram_get_size(m_ram) > 16*1024)
{
program->install_readwrite_bank(0x8000, 0x97ff, "bank4");
}
else
{
program->unmap_readwrite(0x8000, 0x97ff);
}
}
else
{
program->install_readwrite_bank(0x8000, 0x97ff, "bank4");
}
memory_set_bank(machine(), "bank4", m_mc6847_bank);
/* extended RAM */
if (ram_get_size(m_ram) > 16*1024)
{
program->install_readwrite_bank(0x9800, 0xbfff, "bank5");
}
else
{
program->unmap_readwrite(0x9800, 0xbfff);
}
}
static void gmgalax_select_game(int game)
{
gmgalax_selected_game = game;
memory_set_bank(1, game);
galaxian_gfxbank_w(0, gmgalax_selected_game);
}
static void common_init_machine(int base)
{
/* internal ram */
memory_configure_bank(1, 0, 1, mess_ram, 0);
memory_set_bank(1, 0);
/* expansion memory configuration */
switch (mess_ram_size) {
case 18 * 1024:
case 22 * 1024:
case 32 * 1024:
/* install 16KB memory expansion */
memory_install_read8_handler (0, ADDRESS_SPACE_PROGRAM, base, base + 0x3fff, 0, 0, MRA8_BANK2);
memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, base, base + 0x3fff, 0, 0, MWA8_BANK2);
memory_configure_bank(2, 0, 1, mess_ram + base - 0x7800, 0);
memory_set_bank(2, 0);
memory_install_read8_handler (0, ADDRESS_SPACE_PROGRAM, base + 0x4000, 0xffff, 0, 0, MRA8_NOP);
memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, base + 0x4000, 0xffff, 0, 0, MWA8_NOP);
break;
case 66 * 1024:
case 4098 * 1024:
/* 64KB/4MB memory expansion */
/* install fixed first bank */
memory_install_read8_handler (0, ADDRESS_SPACE_PROGRAM, 0x8000, 0xbfff, 0, 0, MRA8_BANK2);
memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, 0x8000, 0xbfff, 0, 0, MWA8_BANK2);
memory_configure_bank(2, 0, 1, mess_ram + 0x800, 0);
memory_set_bank(2, 0);
/* install the others, dynamically banked in */
memory_install_read8_handler (0, ADDRESS_SPACE_PROGRAM, 0xc000, 0xffff, 0, 0, MRA8_BANK3);
memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, 0xc000, 0xffff, 0, 0, MWA8_BANK3);
memory_configure_bank(3, 0, (mess_ram_size - 0x4800) / 0x4000, mess_ram + 0x4800, 0x4000);
memory_set_bank(3, 0);
break;
default:
/* no memory expansion */
memory_install_read8_handler (0, ADDRESS_SPACE_PROGRAM, base, 0xffff, 0, 0, MRA8_NOP);
memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, base, 0xffff, 0, 0, MWA8_NOP);
break;
}
}
static DRIVER_INIT(tutor)
{
tutor_state *state = machine.driver_data<tutor_state>();
state->m_tape_interrupt_timer = machine.scheduler().timer_alloc(FUNC(tape_interrupt_handler));
memory_configure_bank(machine, "bank1", 0, 1, machine.region("maincpu")->base() + basic_base, 0);
memory_configure_bank(machine, "bank1", 1, 1, machine.region("maincpu")->base() + cartridge_base, 0);
memory_set_bank(machine, "bank1", 0);
}
static WRITE8_HANDLER(magtouch_io_w)
{
switch(offset)
{
case 6:
memory_set_bank(space->machine(), "rombank", data & 0x7f );
break;
}
}
static void cavelon_banksw(running_machine *machine)
{
/* any read/write access in the 0x8000-0xffff region causes a bank switch.
Only the lower 0x2000 is switched but we switch the whole region
to keep the CPU core happy at the boundaries */
cavelon_bank = !cavelon_bank;
memory_set_bank(machine, "bank1", cavelon_bank);
}
void vixen_state::machine_reset()
{
address_space *program = m_maincpu->memory().space(AS_PROGRAM);
program->install_read_bank(0x0000, 0xefff, 0xfff, 0, "bank1");
program->install_write_bank(0x0000, 0xefff, 0xfff, 0, "bank2");
memory_set_bank(m_machine, "bank1", 1);
memory_set_bank(m_machine, "bank2", 1);
memory_set_bank(m_machine, "bank3", 1);
m_reset = 1;
m_vsync = 0;
m_cmd_d0 = 0;
m_cmd_d1 = 0;
update_interrupt();
}
