static MACHINE_RESET( palm )
{
// Copy boot ROM
UINT8* bios = machine.region("bios")->base();
memset(ram_get_ptr(machine.device(RAM_TAG)), 0, ram_get_size(machine.device(RAM_TAG)));
memcpy(ram_get_ptr(machine.device(RAM_TAG)), bios, 0x20000);
machine.device("maincpu")->reset();
}
void sf7000_state::machine_start()
{
/* configure VDP */
TMS9928A_configure(&tms9928a_interface);
/* configure memory banking */
memory_configure_bank(machine(), "bank1", 0, 1, machine().region(Z80_TAG)->base(), 0);
memory_configure_bank(machine(), "bank1", 1, 1, ram_get_ptr(m_ram), 0);
memory_configure_bank(machine(), "bank2", 0, 1, ram_get_ptr(m_ram), 0);
/* register for state saving */
state_save_register_global(machine(), m_keylatch);
state_save_register_global(machine(), m_fdc_irq);
state_save_register_global(machine(), m_fdc_index);
}
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);
}
void vixen_state::machine_start()
{
// interrupt callback
device_set_irq_callback(m_maincpu, vixen_int_ack);
// configure memory banking
UINT8 *ram = ram_get_ptr(m_ram);
memory_configure_bank(m_machine, "bank1", 0, 1, ram, 0);
memory_configure_bank(m_machine, "bank1", 1, 1, m_machine.region(Z8400A_TAG)->base(), 0);
memory_configure_bank(m_machine, "bank2", 0, 1, ram, 0);
memory_configure_bank(m_machine, "bank2", 1, 1, m_video_ram, 0);
memory_configure_bank(m_machine, "bank3", 0, 1, m_video_ram, 0);
memory_configure_bank(m_machine, "bank3", 1, 1, m_machine.region(Z8400A_TAG)->base(), 0);
memory_configure_bank(m_machine, "bank4", 0, 1, m_video_ram, 0);
// register for state saving
state_save_register_global(m_machine, m_reset);
state_save_register_global(m_machine, m_col);
state_save_register_global(m_machine, m_cmd_d0);
state_save_register_global(m_machine, m_cmd_d1);
state_save_register_global(m_machine, m_fdint);
}
static MC6845_UPDATE_ROW( apricot_update_row )
{
apricot_state *state = device->machine().driver_data<apricot_state>();
UINT8 *ram = ram_get_ptr(device->machine().device(RAM_TAG));
int i, x;
if (state->m_video_mode)
{
/* text mode */
for (i = 0; i < x_count; i++)
{
UINT16 code = state->m_screen_buffer[(ma + i) & 0x7ff];
UINT16 offset = ((code & 0x7ff) << 5) | (ra << 1);
UINT16 data = ram[offset + 1] << 8 | ram[offset];
int fill = 0;
if (BIT(code, 12) && BIT(data, 14)) fill = 1; /* strike-through? */
if (BIT(code, 13) && BIT(data, 15)) fill = 1; /* underline? */
/* draw 10 pixels of the character */
for (x = 0; x <= 10; x++)
{
int color = fill ? 1 : BIT(data, x);
if (BIT(code, 15)) color = !color; /* reverse? */
*BITMAP_ADDR16(bitmap, y, x + i*10) = color ? 1 + BIT(code, 14) : 0;
}
}
}
else
{
/* graphics mode */
fatalerror("Graphics mode not implemented!");
}
}
static void mato_update_memory(running_machine &machine)
{
pmd85_state *state = machine.driver_data<pmd85_state>();
address_space* space = machine.device("maincpu")->memory().space(AS_PROGRAM);
UINT8 *ram = ram_get_ptr(machine.device(RAM_TAG));
if (state->m_startup_mem_map)
{
UINT8 *mem = machine.region("maincpu")->base();
space->unmap_write(0x0000, 0x3fff);
memory_set_bankptr(machine, "bank1", mem + 0x010000);
memory_set_bankptr(machine, "bank2", ram + 0xc000);
memory_set_bankptr(machine, "bank3", mem + 0x010000);
memory_set_bankptr(machine, "bank4", ram + 0xc000);
}
else
{
space->install_write_bank(0x0000, 0x3fff, "bank1");
memory_set_bankptr(machine, "bank1", ram);
memory_set_bankptr(machine, "bank2", ram + 0x4000);
}
}
static DRIVER_INIT( mc10 )
{
mc10_state *mc10 = machine.driver_data<mc10_state>();
address_space *prg = machine.device("maincpu")->memory().space(AS_PROGRAM);
/* initialize keyboard strobe */
mc10->m_keyboard_strobe = 0x00;
/* initialize memory */
mc10->m_ram_base = ram_get_ptr(mc10->m_ram);
mc10->m_ram_size = ram_get_size(mc10->m_ram);
mc10->m_pr_state = PRINTER_WAIT;
memory_set_bankptr(machine, "bank1", mc10->m_ram_base);
/* initialize memory expansion */
if (mc10->m_ram_size == 20*1024)
memory_set_bankptr(machine, "bank2", mc10->m_ram_base + 0x1000);
else if (mc10->m_ram_size == 24*1024)
memory_set_bankptr(machine, "bank2", mc10->m_ram_base + 0x2000);
else if (mc10->m_ram_size != 32*1024) //ensure that is not alice90
prg->nop_readwrite(0x5000, 0x8fff);
/* register for state saving */
state_save_register_global(machine, mc10->m_keyboard_strobe);
//for alice32 force port4 DDR to 0xff at startup
if (!strcmp(machine.system().name, "alice32") || !strcmp(machine.system().name, "alice90"))
m6801_io_w(prg, 0x05, 0xff);
}
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 READ8_HANDLER( fk1_bank_rom_r )
{
address_space *space_mem = space->machine().device("maincpu")->memory().space(AS_PROGRAM);
space_mem->unmap_write(0x0000, 0x3fff);
memory_set_bankptr(space->machine(), "bank1", space->machine().region("maincpu")->base());
memory_set_bankptr(space->machine(), "bank2", ram_get_ptr(space->machine().device(RAM_TAG)) + 0x10000);
return 0;
}
static READ8_HANDLER( fk1_bank_ram_r )
{
address_space *space_mem = space->machine().device("maincpu")->memory().space(AS_PROGRAM);
UINT8 *ram = ram_get_ptr(space->machine().device(RAM_TAG));
space_mem->install_write_bank(0x0000, 0x3fff, "bank1");
memory_set_bankptr(space->machine(), "bank1", ram);
memory_set_bankptr(space->machine(), "bank2", ram + 0x4000);
return 0;
}
static void ondra_update_banks(running_machine &machine)
{
ondra_state *state = machine.driver_data<ondra_state>();
UINT8 *mem = machine.region("maincpu")->base();
if (state->m_bank1_status==0) {
machine.device("maincpu")->memory().space(AS_PROGRAM)->unmap_write(0x0000, 0x3fff);
memory_set_bankptr(machine, "bank1", mem + 0x010000);
} else {
machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_bank(0x0000, 0x3fff, "bank1");
memory_set_bankptr(machine, "bank1", ram_get_ptr(machine.device(RAM_TAG)) + 0x0000);
}
memory_set_bankptr(machine, "bank2", ram_get_ptr(machine.device(RAM_TAG)) + 0x4000);
if (state->m_bank2_status==0) {
machine.device("maincpu")->memory().space(AS_PROGRAM)->install_readwrite_bank(0xe000, 0xffff, "bank3");
memory_set_bankptr(machine, "bank3", ram_get_ptr(machine.device(RAM_TAG)) + 0xe000);
} else {
machine.device("maincpu")->memory().space(AS_PROGRAM)->unmap_write(0xe000, 0xffff);
machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler (0xe000, 0xffff, FUNC(ondra_keyboard_r));
}
}
static DRIVER_INIT( aquarius )
{
/* install expansion memory if available */
if (ram_get_size(machine.device(RAM_TAG)) > 0x1000)
{
address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM);
space->install_readwrite_bank(0x4000, 0x4000 + ram_get_size(machine.device(RAM_TAG)) - 0x1000 - 1, "bank1");
memory_set_bankptr(machine, "bank1", ram_get_ptr(machine.device(RAM_TAG)));
}
}
static MACHINE_RESET(fk1)
{
address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM);
UINT8 *ram = ram_get_ptr(machine.device(RAM_TAG));
space->unmap_write(0x0000, 0x3fff);
memory_set_bankptr(machine, "bank1", machine.region("maincpu")->base()); // ROM
memory_set_bankptr(machine, "bank2", ram + 0x10000); // VRAM
memory_set_bankptr(machine, "bank3", ram + 0x8000);
memory_set_bankptr(machine, "bank4", ram + 0xc000);
device_set_irq_callback(machine.device("maincpu"), fk1_irq_callback);
}
static MACHINE_START( palm )
{
palm_state *state = machine.driver_data<palm_state>();
address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM);
space->install_read_bank (0x000000, ram_get_size(machine.device(RAM_TAG)) - 1, ram_get_size(machine.device(RAM_TAG)) - 1, 0, "bank1");
space->install_write_bank(0x000000, ram_get_size(machine.device(RAM_TAG)) - 1, ram_get_size(machine.device(RAM_TAG)) - 1, 0, "bank1");
memory_set_bankptr(machine, "bank1", ram_get_ptr(machine.device(RAM_TAG)));
state->save_item(NAME(state->m_port_f_latch));
state->save_item(NAME(state->m_spim_data));
if (machine.device<cpu_device>("maincpu")->debug()) {
machine.device<cpu_device>("maincpu")->debug()->set_dasm_override(palm_dasm_override);
}
}
static QUICKLOAD_LOAD( elf )
{
elf2_state *state = image.device().machine().driver_data<elf2_state>();
int size = image.length();
if (size > ram_get_size(state->m_ram))
{
return IMAGE_INIT_FAIL;
}
image.fread(ram_get_ptr(state->m_ram), size);
return IMAGE_INIT_PASS;
}
static void orionz80_switch_bank(running_machine &machine)
{
orion_state *state = machine.driver_data<orion_state>();
UINT8 bank_select;
UINT8 segment_select;
address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM);
bank_select = (state->m_orionz80_dispatcher & 0x0c) >> 2;
segment_select = state->m_orionz80_dispatcher & 0x03;
space->install_write_bank(0x0000, 0x3fff, "bank1");
if ((state->m_orionz80_dispatcher & 0x80)==0)
{ // dispatcher on
memory_set_bankptr(machine, "bank1", ram_get_ptr(machine.device(RAM_TAG)) + 0x10000 * bank_select + segment_select * 0x4000 );
}
else
{ // dispatcher off
memory_set_bankptr(machine, "bank1", ram_get_ptr(machine.device(RAM_TAG)) + 0x10000 * state->m_orionz80_memory_page);
}
memory_set_bankptr(machine, "bank2", ram_get_ptr(machine.device(RAM_TAG)) + 0x4000 + 0x10000 * state->m_orionz80_memory_page);
if ((state->m_orionz80_dispatcher & 0x20) == 0)
{
space->install_legacy_write_handler(0xf400, 0xf4ff, FUNC(orion128_system_w));
space->install_legacy_write_handler(0xf500, 0xf5ff, FUNC(orion128_romdisk_w));
space->install_legacy_write_handler(0xf700, 0xf7ff, FUNC(orionz80_floppy_rtc_w));
space->install_legacy_read_handler(0xf400, 0xf4ff, FUNC(orion128_system_r));
space->install_legacy_read_handler(0xf500, 0xf5ff, FUNC(orion128_romdisk_r));
space->install_legacy_read_handler(0xf700, 0xf7ff, FUNC(orionz80_floppy_rtc_r));
space->install_legacy_write_handler(0xf800, 0xf8ff, FUNC(orion128_video_mode_w));
space->install_legacy_write_handler(0xf900, 0xf9ff, FUNC(orionz80_memory_page_w));
space->install_legacy_write_handler(0xfa00, 0xfaff, FUNC(orion128_video_page_w));
space->install_legacy_write_handler(0xfb00, 0xfbff, FUNC(orionz80_dispatcher_w));
space->unmap_write(0xfc00, 0xfeff);
space->install_legacy_write_handler(0xff00, 0xffff, FUNC(orionz80_sound_w));
memory_set_bankptr(machine, "bank3", ram_get_ptr(machine.device(RAM_TAG)) + 0xf000);
memory_set_bankptr(machine, "bank5", machine.region("maincpu")->base() + 0xf800);
}
else
{
/* if it is full memory access */
memory_set_bankptr(machine, "bank3", ram_get_ptr(machine.device(RAM_TAG)) + 0xf000 + 0x10000 * state->m_orionz80_memory_page);
memory_set_bankptr(machine, "bank4", ram_get_ptr(machine.device(RAM_TAG)) + 0xf400 + 0x10000 * state->m_orionz80_memory_page);
memory_set_bankptr(machine, "bank5", ram_get_ptr(machine.device(RAM_TAG)) + 0xf800 + 0x10000 * state->m_orionz80_memory_page);
}
}
void elf2_state::machine_start()
{
address_space *program = m_maincpu->memory().space(AS_PROGRAM);
/* initialize LED displays */
m_led_l->rbi_w(1);
m_led_h->rbi_w(1);
/* setup memory banking */
program->install_read_bank(0x0000, 0x00ff, "bank1");
program->install_write_handler(0x0000, 0x00ff, write8_delegate(FUNC(elf2_state::memory_w), this));
memory_configure_bank(machine(), "bank1", 0, 1, ram_get_ptr(m_ram), 0);
memory_set_bank(machine(), "bank1", 0);
/* register for state saving */
save_item(NAME(m_data));
}
void bigbord2_state::bankswitch(int bank)
{
address_space *program = m_maincpu->memory().space(AS_PROGRAM);
UINT8 *ram = ram_get_ptr(m_ram);
if (bank)
{
/* ROM */
program->install_rom(0x0000, 0x0fff, machine.region("monitor")->base());
program->unmap_readwrite(0x1000, 0x1fff);
program->install_ram(0x3000, 0x3fff, m_videoram);
}
else
{
/* RAM */
program->install_ram(0x0000, 0x3fff, ram);
}
}
void abc1600_state::write_ram(offs_t offset, UINT8 data)
{
if (offset < 0x100000)
{
// main RAM
UINT8 *ram = ram_get_ptr(m_ram);
ram[offset] = data;
}
else if (offset < 0x180000)
{
// video RAM
address_space *program = m_maincpu->memory().space(AS_PROGRAM);
video_ram_w(*program, offset, data);
}
else
{
if (LOG) logerror("Unmapped write to virtual memory %06x : %02x\n", offset, data);
}
}
void comx35_state::machine_start()
{
// allocate reset timer
m_reset_timer = machine().scheduler().timer_alloc(FUNC(reset_tick));
// clear the RAM since DOS card will go crazy if RAM is not all zeroes
UINT8 *ram = ram_get_ptr(m_ram);
memset(ram, 0, 0x8000);
// register for state saving
save_item(NAME(m_clear));
save_item(NAME(m_q));
save_item(NAME(m_ef4));
save_item(NAME(m_iden));
save_item(NAME(m_dma));
save_item(NAME(m_int));
save_item(NAME(m_prd));
save_item(NAME(m_cr1));
}
const UINT8 *sam6883_videoram(device_t *device,int scanline)
{
sam6883_t *sam = get_safe_token(device);
const UINT8 *ram_base;
UINT16 video_position;
if (scanline != sam->last_scanline)
{
/* first scanline? */
if (scanline == 0)
{
/* reset video position */
sam->video_position = (sam->state & 0x03F8) << 6;
}
else
{
/* time to advance a row? */
if ((scanline % sam_video_mode_row_heights[sam->state & 0x0007]) == 0)
sam->video_position += sam_video_mode_row_pitches[sam->state & 0x0007];
}
sam->last_scanline = scanline;
}
video_position = sam->video_position;
if (sam->type != TYPE_SAM6883_GIME)
{
/* mask the video position according to the SAM's settings */
switch(sam->state & 0x6000)
{
case 0x0000: video_position &= 0x0FFF; break; /* 4k */
case 0x2000: video_position &= 0x3FFF; break; /* 16k */
default: video_position &= 0xFFFF; break; /* 64k/static RAM */
}
}
if (LOG_VIDEO_POSITION)
logerror("sam_m6847_get_video_ram(): scanline=%d video_position=0x%04X\n", scanline, video_position);
/* return actual position */
ram_base = sam->intf->get_rambase ? sam->intf->get_rambase(device) : ram_get_ptr(device->machine().device(RAM_TAG));
return &ram_base[video_position];
}
static SCREEN_UPDATE( fk1 )
{
fk1_state *state = screen->machine().driver_data<fk1_state>();
UINT8 code;
int y, x, b;
UINT8 *ram = ram_get_ptr(screen->machine().device(RAM_TAG));
for (x = 0; x < 64; x++)
{
for (y = 0; y < 256; y++)
{
code = ram[x * 0x100 + ((y + state->m_video_rol) & 0xff) + 0x10000];
for (b = 0; b < 8; b++)
{
*BITMAP_ADDR16(bitmap, y, x*8+b) = ((code << b) & 0x80) ? 1 : 0;
}
}
}
return 0;
}
void cosmicos_state::set_ram_mode()
{
address_space *program = m_maincpu->memory().space(AS_PROGRAM);
UINT8 *ram = ram_get_ptr(m_ram);
if (m_ram_disable)
{
program->unmap_readwrite(0xff00, 0xffff);
}
else
{
if (m_ram_protect)
{
program->install_rom(0xff00, 0xffff, ram);
}
else
{
program->install_ram(0xff00, 0xffff, ram);
}
}
}
static DRIVER_INIT( apricot )
{
apricot_state *state = machine.driver_data<apricot_state>();
device_t *maincpu = machine.device("maincpu");
address_space *prg = maincpu->memory().space(AS_PROGRAM);
UINT8 *ram = ram_get_ptr(machine.device(RAM_TAG));
UINT32 ram_size = ram_get_size(machine.device(RAM_TAG));
prg->unmap_readwrite(0x40000, 0xeffff);
prg->install_ram(0x00000, ram_size - 1, ram);
device_set_irq_callback(maincpu, apricot_irq_ack);
state->m_pic8259 = machine.device("ic31");
state->m_wd2793 = machine.device("ic68");
state->m_mc6845 = machine.device<mc6845_device>("ic30");
state->m_video_mode = 0;
state->m_display_on = 1;
}
UINT8 abc1600_state::read_ram(offs_t offset)
{
UINT8 data = 0;
if (offset < 0x100000)
{
// main RAM
UINT8 *ram = ram_get_ptr(m_ram);
data = ram[offset];
}
else if (offset < 0x180000)
{
// video RAM
address_space *program = m_maincpu->memory().space(AS_PROGRAM);
data = video_ram_r(*program, offset);
}
else
{
if (LOG) logerror("Unmapped read from virtual memory %06x\n", offset);
}
return data;
}
static void pmd853_update_memory(running_machine &machine)
{
pmd85_state *state = machine.driver_data<pmd85_state>();
UINT8 *mem = machine.region("maincpu")->base();
UINT8 *ram = ram_get_ptr(machine.device(RAM_TAG));
if (state->m_startup_mem_map)
{
memory_set_bankptr(machine, "bank1", mem + 0x010000);
memory_set_bankptr(machine, "bank2", mem + 0x010000);
memory_set_bankptr(machine, "bank3", mem + 0x010000);
memory_set_bankptr(machine, "bank4", mem + 0x010000);
memory_set_bankptr(machine, "bank5", mem + 0x010000);
memory_set_bankptr(machine, "bank6", mem + 0x010000);
memory_set_bankptr(machine, "bank7", mem + 0x010000);
memory_set_bankptr(machine, "bank8", mem + 0x010000);
memory_set_bankptr(machine, "bank9", ram);
memory_set_bankptr(machine, "bank10", ram + 0x2000);
memory_set_bankptr(machine, "bank11", ram + 0x4000);
memory_set_bankptr(machine, "bank12", ram + 0x6000);
memory_set_bankptr(machine, "bank13", ram + 0x8000);
memory_set_bankptr(machine, "bank14", ram + 0xa000);
memory_set_bankptr(machine, "bank15", ram + 0xc000);
memory_set_bankptr(machine, "bank16", ram + 0xe000);
}
else
{
memory_set_bankptr(machine, "bank1", ram);
memory_set_bankptr(machine, "bank2", ram + 0x2000);
memory_set_bankptr(machine, "bank3", ram + 0x4000);
memory_set_bankptr(machine, "bank4", ram + 0x6000);
memory_set_bankptr(machine, "bank5", ram + 0x8000);
memory_set_bankptr(machine, "bank6", ram + 0xa000);
memory_set_bankptr(machine, "bank7", ram + 0xc000);
memory_set_bankptr(machine, "bank8", state->m_pmd853_memory_mapping ? mem + 0x010000 : ram + 0xe000);
}
}
ADDRESS_MAP_END
static INPUT_CHANGED( set_write_protect ) // run when RAM expansion write protect switch is changed
{
int ram_expansion_installed = 0, write_protect_on = 0, expansion_ram_start = 0, expansion_ram_end = 0, shadow_ram_end = 0;
address_space *space = field.machine().device("maincpu")->memory().space(AS_PROGRAM);
UINT8 *expram = ram_get_ptr(field.machine().device("ram_tag"));
get_ram_expansion_settings(space, ram_expansion_installed, write_protect_on, expansion_ram_start, expansion_ram_end, shadow_ram_end); // passing by reference
if (ram_expansion_installed == 1)
{
if (write_protect_on == 0) // write protect off, so install memory normally
{
space->install_ram(expansion_ram_start, expansion_ram_end, expram);
if (shadow_ram_end > expansion_ram_end)
space->install_ram(expansion_ram_end + 1, shadow_ram_end, expram);
}
else // write protect on, so make memory read only
{
space->nop_write(expansion_ram_start, expansion_ram_end);
}
}
}
static void orionpro_bank_switch(running_machine &machine)
{
orion_state *state = machine.driver_data<orion_state>();
address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM);
int page = state->m_orionpro_page & 7; // we have only 8 pages
int is128 = (state->m_orionpro_dispatcher & 0x80) ? 1 : 0;
UINT8 *ram = ram_get_ptr(machine.device(RAM_TAG));
if (is128==1)
{
page = state->m_orionpro_128_page & 7;
}
space->install_write_bank(0x0000, 0x1fff, "bank1");
space->install_write_bank(0x2000, 0x3fff, "bank2");
space->install_write_bank(0x4000, 0x7fff, "bank3");
space->install_write_bank(0x8000, 0xbfff, "bank4");
space->install_write_bank(0xc000, 0xefff, "bank5");
space->install_write_bank(0xf000, 0xf3ff, "bank6");
space->install_write_bank(0xf400, 0xf7ff, "bank7");
space->install_write_bank(0xf800, 0xffff, "bank8");
if ((state->m_orionpro_dispatcher & 0x01)==0x00)
{ // RAM0 segment disabled
memory_set_bankptr(machine, "bank1", ram + 0x10000 * page);
memory_set_bankptr(machine, "bank2", ram + 0x10000 * page + 0x2000);
}
else
{
memory_set_bankptr(machine, "bank1", ram + (state->m_orionpro_ram0_segment & 31) * 0x4000);
memory_set_bankptr(machine, "bank2", ram + (state->m_orionpro_ram0_segment & 31) * 0x4000 + 0x2000);
}
if ((state->m_orionpro_dispatcher & 0x10)==0x10)
{ // ROM1 enabled
space->unmap_write(0x0000, 0x1fff);
memory_set_bankptr(machine, "bank1", machine.region("maincpu")->base() + 0x20000);
}
if ((state->m_orionpro_dispatcher & 0x08)==0x08)
{ // ROM2 enabled
space->unmap_write(0x2000, 0x3fff);
memory_set_bankptr(machine, "bank2", machine.region("maincpu")->base() + 0x22000 + (state->m_orionpro_rom2_segment & 7) * 0x2000);
}
if ((state->m_orionpro_dispatcher & 0x02)==0x00)
{ // RAM1 segment disabled
memory_set_bankptr(machine, "bank3", ram + 0x10000 * page + 0x4000);
}
else
{
memory_set_bankptr(machine, "bank3", ram + (state->m_orionpro_ram1_segment & 31) * 0x4000);
}
if ((state->m_orionpro_dispatcher & 0x04)==0x00)
{ // RAM2 segment disabled
memory_set_bankptr(machine, "bank4", ram + 0x10000 * page + 0x8000);
}
else
{
memory_set_bankptr(machine, "bank4", ram + (state->m_orionpro_ram2_segment & 31) * 0x4000);
}
memory_set_bankptr(machine, "bank5", ram + 0x10000 * page + 0xc000);
if (is128)
{
memory_set_bankptr(machine, "bank6", ram + 0x10000 * 0 + 0xf000);
space->install_legacy_write_handler(0xf400, 0xf4ff, FUNC(orion128_system_w));
space->install_legacy_write_handler(0xf500, 0xf5ff, FUNC(orion128_romdisk_w));
space->unmap_write(0xf600, 0xf6ff);
space->install_legacy_write_handler(0xf700, 0xf7ff, FUNC(orion128_floppy_w));
space->install_legacy_read_handler(0xf400, 0xf4ff, FUNC(orion128_system_r));
space->install_legacy_read_handler(0xf500, 0xf5ff, FUNC(orion128_romdisk_r));
space->unmap_read(0xf600, 0xf6ff);
space->install_legacy_read_handler(0xf700, 0xf7ff, FUNC(orion128_floppy_r));
space->install_legacy_write_handler(0xf800, 0xf8ff, FUNC(orion128_video_mode_w));
space->install_legacy_write_handler(0xf900, 0xf9ff, FUNC(orionpro_memory_page_w));
space->install_legacy_write_handler(0xfa00, 0xfaff, FUNC(orion128_video_page_w));
space->unmap_write(0xfb00, 0xfeff);
space->install_legacy_write_handler(0xff00, 0xffff, FUNC(orionz80_sound_w));
memory_set_bankptr(machine, "bank8", ram + 0x10000 * 0 + 0xf800);
}
else
{
if ((state->m_orionpro_dispatcher & 0x40)==0x40)
{ // FIX F000 enabled
memory_set_bankptr(machine, "bank6", ram + 0x10000 * 0 + 0xf000);
memory_set_bankptr(machine, "bank7", ram + 0x10000 * 0 + 0xf400);
memory_set_bankptr(machine, "bank8", ram + 0x10000 * 0 + 0xf800);
}
else
{
memory_set_bankptr(machine, "bank6", ram + 0x10000 * page + 0xf000);
memory_set_bankptr(machine, "bank7", ram + 0x10000 * page + 0xf400);
memory_set_bankptr(machine, "bank8", ram + 0x10000 * page + 0xf800);
}
}
}
static void galaxy_setup_snapshot (running_machine &machine, const UINT8 * data, UINT32 size)
{
device_t *cpu = machine.device("maincpu");
switch (size)
{
case GALAXY_SNAPSHOT_V1_SIZE:
cpu_set_reg(cpu, Z80_AF, data[0x00] | data[0x01] << 8);
cpu_set_reg(cpu, Z80_BC, data[0x04] | data[0x05] << 8);
cpu_set_reg(cpu, Z80_DE, data[0x08] | data[0x09] << 8);
cpu_set_reg(cpu, Z80_HL, data[0x0c] | data[0x0d] << 8);
cpu_set_reg(cpu, Z80_IX, data[0x10] | data[0x11] << 8);
cpu_set_reg(cpu, Z80_IY, data[0x14] | data[0x15] << 8);
cpu_set_reg(cpu, Z80_PC, data[0x18] | data[0x19] << 8);
cpu_set_reg(cpu, Z80_SP, data[0x1c] | data[0x1d] << 8);
cpu_set_reg(cpu, Z80_AF2, data[0x20] | data[0x21] << 8);
cpu_set_reg(cpu, Z80_BC2, data[0x24] | data[0x25] << 8);
cpu_set_reg(cpu, Z80_DE2, data[0x28] | data[0x29] << 8);
cpu_set_reg(cpu, Z80_HL2, data[0x2c] | data[0x2d] << 8);
cpu_set_reg(cpu, Z80_IFF1, data[0x30]);
cpu_set_reg(cpu, Z80_IFF2, data[0x34]);
cpu_set_reg(cpu, Z80_HALT, data[0x38]);
cpu_set_reg(cpu, Z80_IM, data[0x3c]);
cpu_set_reg(cpu, Z80_I, data[0x40]);
cpu_set_reg(cpu, Z80_R, (data[0x44] & 0x7f) | (data[0x48] & 0x80));
memcpy (ram_get_ptr(machine.device(RAM_TAG)), data + 0x084c, (ram_get_size(machine.device(RAM_TAG)) < 0x1800) ? ram_get_size(machine.device(RAM_TAG)) : 0x1800);
break;
case GALAXY_SNAPSHOT_V2_SIZE:
cpu_set_reg(cpu, Z80_AF, data[0x00] | data[0x01] << 8);
cpu_set_reg(cpu, Z80_BC, data[0x02] | data[0x03] << 8);
cpu_set_reg(cpu, Z80_DE, data[0x04] | data[0x05] << 8);
cpu_set_reg(cpu, Z80_HL, data[0x06] | data[0x07] << 8);
cpu_set_reg(cpu, Z80_IX, data[0x08] | data[0x09] << 8);
cpu_set_reg(cpu, Z80_IY, data[0x0a] | data[0x0b] << 8);
cpu_set_reg(cpu, Z80_PC, data[0x0c] | data[0x0d] << 8);
cpu_set_reg(cpu, Z80_SP, data[0x0e] | data[0x0f] << 8);
cpu_set_reg(cpu, Z80_AF2, data[0x10] | data[0x11] << 8);
cpu_set_reg(cpu, Z80_BC2, data[0x12] | data[0x13] << 8);
cpu_set_reg(cpu, Z80_DE2, data[0x14] | data[0x15] << 8);
cpu_set_reg(cpu, Z80_HL2, data[0x16] | data[0x17] << 8);
cpu_set_reg(cpu, Z80_IFF1, data[0x18] & 0x01);
cpu_set_reg(cpu, Z80_IFF2, (UINT64)0);
cpu_set_reg(cpu, Z80_HALT, (UINT64)0);
cpu_set_reg(cpu, Z80_IM, (data[0x18] >> 1) & 0x03);
cpu_set_reg(cpu, Z80_I, data[0x19]);
cpu_set_reg(cpu, Z80_R, data[0x1a]);
memcpy (ram_get_ptr(machine.device(RAM_TAG)), data + 0x0834, (ram_get_size(machine.device(RAM_TAG)) < 0x1800) ? ram_get_size(machine.device(RAM_TAG)) : 0x1800);
break;
}
device_set_input_line(cpu, INPUT_LINE_NMI, CLEAR_LINE);
device_set_input_line(cpu, INPUT_LINE_IRQ0, CLEAR_LINE);
}
static void coco_vhd_readwrite(device_t *device, UINT8 data)
{
vhd_info *vhd = get_safe_token(device);
device_image_interface *image = dynamic_cast<device_image_interface *>(device);
int result;
int phyOffset;
UINT32 nBA = vhd->buffer_address;
UINT32 bytes_to_read;
UINT32 bytes_to_write;
UINT64 seek_position;
UINT64 total_size;
char buffer[1024];
/* access the image */
if (!image->exists())
{
vhd->status = VHDSTATUS_NO_VHD_ATTACHED;
return;
}
/* perform the seek */
seek_position = ((UINT64) 256) * vhd->logical_record_number;
total_size = image->length();
result = image->fseek(MIN(seek_position, total_size), SEEK_SET);
if (result < 0)
{
vhd->status = VHDSTATUS_ACCESS_DENIED;
return;
}
/* expand the disk, if necessary */
if (data == VHDCMD_WRITE)
{
while(total_size < seek_position)
{
memset(buffer, 0, sizeof(buffer));
bytes_to_write = (UINT32) MIN(seek_position - total_size, (UINT64) sizeof(buffer));
result = image->fwrite(buffer, bytes_to_write);
if (result != bytes_to_write)
{
vhd->status = VHDSTATUS_ACCESS_DENIED;
return;
}
total_size += bytes_to_write;
}
}
phyOffset = coco3_mmu_translate(device->machine(), (nBA >> 12 ) / 2, nBA % 8192 );
switch(data)
{
case VHDCMD_READ: /* Read sector */
memset(&ram_get_ptr(device->machine().device(RAM_TAG))[phyOffset], 0, 256);
if (total_size > seek_position)
{
bytes_to_read = (UINT32) MIN((UINT64) 256, total_size - seek_position);
result = image->fread(&ram_get_ptr(device->machine().device(RAM_TAG))[phyOffset], bytes_to_read);
if (result != bytes_to_read)
{
vhd->status = VHDSTATUS_ACCESS_DENIED;
return;
}
}
vhd->status = VHDSTATUS_OK;
break;
case VHDCMD_WRITE: /* Write Sector */
result = image->fwrite((&ram_get_ptr(device->machine().device(RAM_TAG))[phyOffset]), 256);
if (result != 256)
{
vhd->status = VHDSTATUS_ACCESS_DENIED;
return;
}
vhd->status = VHDSTATUS_OK;
break;
case VHDCMD_FLUSH: /* Flush file cache */
vhd->status = VHDSTATUS_OK;
break;
default:
vhd->status = VHDSTATUS_UNKNOWN_COMMAND;
break;
}
}
