static void init_buffered_spriteram(void)
{
assert_always(spriteram_size != 0, "Video buffers spriteram but spriteram_size is 0");
/* allocate memory for the back buffer */
buffered_spriteram = auto_malloc(spriteram_size);
/* register for saving it */
state_save_register_global_pointer(buffered_spriteram, spriteram_size);
/* do the same for the secon back buffer, if present */
if (spriteram_2_size)
{
/* allocate memory */
buffered_spriteram_2 = auto_malloc(spriteram_2_size);
/* register for saving it */
state_save_register_global_pointer(buffered_spriteram_2, spriteram_2_size);
}
/* make 16-bit and 32-bit pointer variants */
buffered_spriteram16 = (UINT16 *)buffered_spriteram;
buffered_spriteram32 = (UINT32 *)buffered_spriteram;
buffered_spriteram16_2 = (UINT16 *)buffered_spriteram_2;
buffered_spriteram32_2 = (UINT32 *)buffered_spriteram_2;
}
static int init_buffered_spriteram(void)
{
/* make sure we have a valid size */
if (spriteram_size == 0)
{
logerror("video_init(): Video buffers spriteram but spriteram_size is 0\n");
return 0;
}
/* allocate memory for the back buffer */
buffered_spriteram = auto_malloc(spriteram_size);
/* register for saving it */
state_save_register_global_pointer(buffered_spriteram, spriteram_size);
/* do the same for the secon back buffer, if present */
if (spriteram_2_size)
{
/* allocate memory */
buffered_spriteram_2 = auto_malloc(spriteram_2_size);
/* register for saving it */
state_save_register_global_pointer(buffered_spriteram_2, spriteram_2_size);
}
/* make 16-bit and 32-bit pointer variants */
buffered_spriteram16 = (UINT16 *)buffered_spriteram;
buffered_spriteram32 = (UINT32 *)buffered_spriteram;
buffered_spriteram16_2 = (UINT16 *)buffered_spriteram_2;
buffered_spriteram32_2 = (UINT32 *)buffered_spriteram_2;
return 0;
}
static VIDEO_START( common )
{
midyunit_state *state = machine.driver_data<midyunit_state>();
/* allocate memory */
state->m_cmos_ram = auto_alloc_array(machine, UINT16, (0x2000 * 4)/2);
state->m_local_videoram = auto_alloc_array_clear(machine, UINT16, 0x80000/2);
state->m_pen_map = auto_alloc_array(machine, pen_t, 65536);
machine.device<nvram_device>("nvram")->set_base(state->m_cmos_ram, 0x2000 * 4);
/* reset all the globals */
state->m_cmos_page = 0;
state->m_autoerase_enable = 0;
state->m_yawdim_dma = 0;
/* reset DMA state */
memset(state->m_dma_register, 0, sizeof(state->m_dma_register));
memset(&state->m_dma_state, 0, sizeof(state->m_dma_state));
/* register for state saving */
state_save_register_global(machine, state->m_autoerase_enable);
state_save_register_global_pointer(machine, state->m_local_videoram, 0x80000/2);
state_save_register_global_pointer(machine, state->m_cmos_ram, (0x2000 * 4)/2);
state_save_register_global(machine, state->m_videobank_select);
state_save_register_global_array(machine, state->m_dma_register);
}
static void video_start_common(running_machine &machine, int pagecount)
{
system1_state *state = machine.driver_data<system1_state>();
int pagenum;
/* allocate memory for the collision arrays */
state->m_mix_collide = auto_alloc_array_clear(machine, UINT8, 64);
state->m_sprite_collide = auto_alloc_array_clear(machine, UINT8, 1024);
/* allocate memory for videoram */
state->m_tilemap_pages = pagecount;
state->m_videoram = auto_alloc_array_clear(machine, UINT8, 0x800 * pagecount);
/* create the tilemap pages */
for (pagenum = 0; pagenum < pagecount; pagenum++)
{
state->m_tilemap_page[pagenum] = &machine.tilemap().create(tilemap_get_info_delegate(FUNC(system1_state::tile_get_info),state), TILEMAP_SCAN_ROWS, 8,8, 32,32);
state->m_tilemap_page[pagenum]->set_transparent_pen(0);
state->m_tilemap_page[pagenum]->set_user_data(state->m_videoram + 0x800 * pagenum);
}
/* allocate a temporary bitmap for sprite rendering */
state->m_sprite_bitmap = auto_bitmap_ind16_alloc(machine, 512, 256);
/* register for save stats */
state_save_register_global(machine, state->m_video_mode);
state_save_register_global(machine, state->m_mix_collide_summary);
state_save_register_global(machine, state->m_sprite_collide_summary);
state->save_pointer(NAME(state->m_videoram), 0x800 * pagecount);
state_save_register_global_pointer(machine, state->m_mix_collide, 64);
state_save_register_global_pointer(machine, state->m_sprite_collide, 1024);
}
static void neogeo_register_sub_savestate(void)
{
UINT8* gamevector = memory_region(REGION_CPU1);
state_save_register_global(neogeo_sram_locked);
state_save_register_global_pointer(neogeo_ram16, 0x10000/2);
state_save_register_global_pointer(neogeo_memcard, 0x800);
state_save_register_global_pointer(gamevector, 0x80);
state_save_register_global(neogeo_prot_data);
}
void palette_init(running_machine *machine)
{
palette_private *palette = auto_malloc(sizeof(*palette));
/* request cleanup */
machine->palette_data = palette;
add_exit_callback(machine, palette_exit);
/* reset all our data */
memset(palette, 0, sizeof(*palette));
palette->format = machine->screen[0].format;
/* determine the color mode */
switch (palette->format)
{
case BITMAP_FORMAT_INDEXED16:
/* indexed modes are fine for everything */
break;
case BITMAP_FORMAT_RGB15:
case BITMAP_FORMAT_RGB32:
/* RGB modes can't use color tables */
assert(machine->drv->color_table_len == 0);
break;
case BITMAP_FORMAT_INVALID:
/* invalid format means no palette - or at least it should */
assert(machine->drv->total_colors == 0);
assert(machine->drv->color_table_len == 0);
return;
default:
fatalerror("Unsupported screen bitmap format!");
break;
}
/* allocate all the data structures */
if (machine->drv->total_colors > 0)
{
int numcolors;
allocate_palette(machine, palette);
allocate_color_tables(machine, palette);
allocate_shadow_tables(machine, palette);
/* set up save/restore of the palette */
numcolors = palette_get_num_colors(machine->palette);
palette->save_pen = auto_malloc(sizeof(*palette->save_pen) * numcolors);
palette->save_bright = auto_malloc(sizeof(*palette->save_bright) * numcolors);
state_save_register_global_pointer(palette->save_pen, numcolors);
state_save_register_global_pointer(palette->save_bright, numcolors);
state_save_register_func_presave(palette_presave);
state_save_register_func_postload(palette_postload);
}
}
void cidelsa_state::video_start()
{
// allocate memory
m_pcbram = auto_alloc_array(machine, UINT8, CIDELSA_CHARRAM_SIZE);
m_charram = auto_alloc_array(machine, UINT8, CIDELSA_CHARRAM_SIZE);
// register for state saving
state_save_register_global(machine, m_cdp1869_pcb);
state_save_register_global_pointer(machine, m_pcbram, CIDELSA_CHARRAM_SIZE);
state_save_register_global_pointer(machine, m_charram, CIDELSA_CHARRAM_SIZE);
}
ROM_END
static DRIVER_INIT(ssingles)
{
ssingles_state *state = machine->driver_data<ssingles_state>();
state->videoram=auto_alloc_array_clear(machine, UINT8, VMEM_SIZE);
state->colorram=auto_alloc_array_clear(machine, UINT8, VMEM_SIZE);
state_save_register_global_pointer(machine, state->videoram, VMEM_SIZE);
state_save_register_global_pointer(machine, state->colorram, VMEM_SIZE);
}
static VIDEO_START( laserbat )
{
laserbat_state *state = (laserbat_state *)machine->driver_data;
state->bg_tilemap = tilemap_create(machine, get_tile_info, tilemap_scan_rows, 8, 8, 32, 32);
state->videoram = auto_alloc_array(machine, UINT8, 0x400);
state->colorram = auto_alloc_array(machine, UINT8, 0x400);
state_save_register_global_pointer(machine, state->videoram, 0x400);
state_save_register_global_pointer(machine, state->colorram, 0x400);
}
void namcos1_state::video_start()
{
int i;
m_tilemap_maskdata = (UINT8 *)memregion("gfx1")->base();
/* allocate videoram */
m_videoram = auto_alloc_array(machine(), UINT8, 0x8000);
m_spriteram = auto_alloc_array(machine(), UINT8, 0x1000);
/* initialize playfields */
m_bg_tilemap[0] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos1_state::bg_get_info0),this),TILEMAP_SCAN_ROWS,8,8,64,64);
m_bg_tilemap[1] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos1_state::bg_get_info1),this),TILEMAP_SCAN_ROWS,8,8,64,64);
m_bg_tilemap[2] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos1_state::bg_get_info2),this),TILEMAP_SCAN_ROWS,8,8,64,64);
m_bg_tilemap[3] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos1_state::bg_get_info3),this),TILEMAP_SCAN_ROWS,8,8,64,32);
m_bg_tilemap[4] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos1_state::fg_get_info4),this),TILEMAP_SCAN_ROWS,8,8,36,28);
m_bg_tilemap[5] = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(namcos1_state::fg_get_info5),this),TILEMAP_SCAN_ROWS,8,8,36,28);
m_bg_tilemap[4]->set_scrolldx(73,512-73);
m_bg_tilemap[5]->set_scrolldx(73,512-73);
m_bg_tilemap[4]->set_scrolldy(0x10,0x110);
m_bg_tilemap[5]->set_scrolldy(0x10,0x110);
/* register videoram to the save state system (post-allocation) */
state_save_register_global_pointer(machine(), m_videoram, 0x8000);
state_save_register_global_array(machine(), m_cus116);
state_save_register_global_pointer(machine(), m_spriteram, 0x1000);
state_save_register_global_array(machine(), m_playfield_control);
/* set table for sprite color == 0x7f */
for (i = 0;i < 15;i++)
m_drawmode_table[i] = DRAWMODE_SHADOW;
m_drawmode_table[15] = DRAWMODE_NONE;
/* clear paletteram */
memset(m_paletteram, 0, 0x8000);
memset(m_cus116, 0, 0x10);
for (i = 0; i < 0x2000; i++)
palette_set_color(machine(), i, MAKE_RGB(0, 0, 0));
/* all palette entries are not affected by shadow sprites... */
for (i = 0;i < 0x2000;i++)
machine().shadow_table[i] = i;
/* ... except for tilemap colors */
for (i = 0x0800;i < 0x1000;i++)
machine().shadow_table[i] = i + 0x0800;
memset(m_playfield_control, 0, sizeof(m_playfield_control));
m_copy_sprites = 0;
}
static VIDEO_START( nightgal )
{
nightgal_state *state = machine->driver_data<nightgal_state>();
state->blit_buffer = auto_alloc_array(machine, UINT8, 256*256);
state_save_register_global_pointer(machine, state->blit_buffer, 256*256);
}
static CPU_INIT( mb86233 )
{
mb86233_state *cpustate = get_safe_token(device);
mb86233_cpu_core * _config = (mb86233_cpu_core *)device->static_config();
(void)irqcallback;
memset(cpustate, 0, sizeof( *cpustate ) );
cpustate->device = device;
cpustate->program = device->space(AS_PROGRAM);
cpustate->direct = &cpustate->program->direct();
if ( _config )
{
cpustate->fifo_read_cb = _config->fifo_read_cb;
cpustate->fifo_write_cb = _config->fifo_write_cb;
cpustate->Tables = (UINT32*) device->machine().region(_config->tablergn)->base();
}
cpustate->RAM = auto_alloc_array(device->machine(), UINT32, 2 * 0x200); /* 2x 2KB */
memset( cpustate->RAM, 0, 2 * 0x200 * sizeof(UINT32) );
cpustate->ARAM = &cpustate->RAM[0];
cpustate->BRAM = &cpustate->RAM[0x200];
state_save_register_global_pointer(device->machine(), cpustate->RAM,2 * 0x200 * sizeof(UINT32));
}
static VIDEO_START( mole )
{
mole_state *state = machine->driver_data<mole_state>();
state->tileram = auto_alloc_array_clear(machine, UINT16, 0x400);
state->bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_rows, 8, 8, 40, 25);
state_save_register_global_pointer(machine, state->tileram, 0x400);
}
void comx35_state::video_start()
{
// allocate memory
m_charram = auto_alloc_array(machine(), UINT8, COMX35_CHARRAM_SIZE);
// register for save state
state_save_register_global_pointer(machine(), m_charram, COMX35_CHARRAM_SIZE);
}
ROM_END
static DRIVER_INIT(ssingles)
{
ssingles_vram=auto_malloc(0x2000);
memset(ssingles_vram,0,0x2000);
state_save_register_global_pointer(ssingles_vram, 0x2000);
}
static void video_start(running_machine *machine, UINT16 pageram_size)
{
cidelsa_state *state = (cidelsa_state *)machine->driver_data;
/* allocate memory */
state->pageram = auto_alloc_array(machine, UINT8, pageram_size);
state->pcbram = auto_alloc_array(machine, UINT8, CIDELSA_CHARRAM_SIZE);
state->charram = auto_alloc_array(machine, UINT8, CIDELSA_CHARRAM_SIZE);
/* find devices */
state->cdp1869 = devtag_get_device(machine, CDP1869_TAG);
/* register for state saving */
state_save_register_global(machine, state->cdp1869_pcb);
state_save_register_global_pointer(machine, state->pageram, pageram_size);
state_save_register_global_pointer(machine, state->pcbram, CIDELSA_CHARRAM_SIZE);
state_save_register_global_pointer(machine, state->charram, CIDELSA_CHARRAM_SIZE);
}
void v1050_state::video_start()
{
/* allocate memory */
m_attr_ram = auto_alloc_array(machine(), UINT8, V1050_VIDEORAM_SIZE);
/* register for state saving */
state_save_register_global(machine(), m_attr);
state_save_register_global_pointer(machine(), m_attr_ram, V1050_VIDEORAM_SIZE);
}
static void taitof2_core_vh_start (running_machine *machine, int sprite_type, int hide, int flip_hide )
{
int i;
taitof2_state *state = machine->driver_data<taitof2_state>();
state->sprite_type = sprite_type;
state->hide_pixels = hide;
state->flip_hide_pixels = flip_hide;
state->spriteram_delayed = auto_alloc_array(machine, UINT16, state->spriteram_size / 2);
state->spriteram_buffered = auto_alloc_array(machine, UINT16, state->spriteram_size / 2);
state->spritelist = auto_alloc_array(machine, struct f2_tempsprite, 0x400);
for (i = 0; i < 8; i ++)
{
state->spritebank_buffered[i] = 0x400 * i;
state->spritebank[i] = state->spritebank_buffered[i];
}
state->sprites_disabled = 1;
state->sprites_active_area = 0;
state->sprites_flipscreen = 0;
state->sprites_master_scrollx = 0;
state->sprites_master_scrolly = 0;
state->spriteblendmode = 0;
state->prepare_sprites = 0;
state->game = 0; /* means NOT footchmp */
state_save_register_global_array(machine, state->spritebank);
state_save_register_global_array(machine, state->spritebank_buffered);
state_save_register_global(machine, state->sprites_disabled);
state_save_register_global(machine, state->sprites_active_area);
state_save_register_global(machine, state->sprites_flipscreen);
state_save_register_global(machine, state->sprites_master_scrollx);
state_save_register_global(machine, state->sprites_master_scrolly);
state_save_register_global_array(machine, state->tilepri);
state_save_register_global_array(machine, state->spritepri);
state_save_register_global(machine, state->spriteblendmode);
state_save_register_global(machine, state->prepare_sprites);
state_save_register_global_pointer(machine, state->spriteram_delayed, state->spriteram_size / 2);
state_save_register_global_pointer(machine, state->spriteram_buffered, state->spriteram_size / 2);
}
void volfied_cchip_init(void)
{
cchip_ram=auto_malloc(0x400 * 8);
state_save_register_global(current_bank);
state_save_register_global(current_cmd);
state_save_register_global(current_flag);
state_save_register_global(cc_port);
state_save_register_global_pointer(cchip_ram, 0x400 * 8);
}
GFXDECODE_END
static MACHINE_START(merit)
{
slotcarn_state *state = machine.driver_data<slotcarn_state>();
state->m_ram_palette = auto_alloc_array(machine, UINT8, RAM_PALETTE_SIZE);
state_save_register_global_pointer(machine, state->m_ram_palette, RAM_PALETTE_SIZE);
}
ADDRESS_MAP_END
static VIDEO_START(hotblock)
{
hotblock_state *state = machine->driver_data<hotblock_state>();
state->pal = auto_alloc_array(machine, UINT8, 0x10000);
state_save_register_global_pointer(machine, state->pal, 0x10000);
}
static void register_savestate(void)
{
state_save_register_global(flipscreen);
state_save_register_global(kidniki_background_bank);
state_save_register_global(m62_background_hscroll);
state_save_register_global(m62_background_vscroll);
state_save_register_global(kidniki_text_vscroll);
state_save_register_global(spelunkr_palbank);
state_save_register_global_pointer(irem_textram, irem_textram_size);
}
void vixen_state::video_start()
{
// find memory regions
m_sync_rom = m_machine.region("video")->base();
m_char_rom = m_machine.region("chargen")->base();
// register for state saving
state_save_register_global(m_machine, m_alt);
state_save_register_global(m_machine, m_256);
state_save_register_global(m_machine, m_vsync);
state_save_register_global_pointer(m_machine, m_video_ram, 0x1000);
}
void volfied_cchip_init( running_machine *machine )
{
volfied_state *state = (volfied_state *)machine->driver_data;
state->cchip_ram = auto_alloc_array_clear(machine, UINT8, 0x400 * 8);
state_save_register_global(machine, state->current_bank);
state_save_register_global(machine, state->current_cmd);
state_save_register_global(machine, state->current_flag);
state_save_register_global(machine, state->cc_port);
state_save_register_global_pointer(machine, state->cchip_ram, 0x400 * 8);
}
void atari_machine_start(running_machine &machine)
{
gtia_interface gtia_intf;
/* GTIA */
memset(>ia_intf, 0, sizeof(gtia_intf));
if (machine.root_device().ioport("console") != NULL)
gtia_intf.console_read = console_read;
if (machine.device<dac_device>("dac") != NULL)
gtia_intf.console_write = console_write;
gtia_init(machine, >ia_intf);
/* pokey */
machine.add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(FUNC(pokey_reset), &machine));
/* ANTIC */
machine.add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(FUNC(_antic_reset), &machine));
/* save states */
state_save_register_global_pointer(machine, ((UINT8 *) &antic.r), sizeof(antic.r));
state_save_register_global_pointer(machine, ((UINT8 *) &antic.w), sizeof(antic.w));
}
VIDEO_START_MEMBER(twincobr_state,toaplan0)
{
/* the video RAM is accessed via ports, it's not memory mapped */
m_txvideoram_size = 0x0800;
m_bgvideoram_size = 0x2000; /* banked two times 0x1000 */
m_fgvideoram_size = 0x1000;
twincobr_create_tilemaps(machine());
m_txvideoram16 = auto_alloc_array_clear(machine(), UINT16, m_txvideoram_size);
m_fgvideoram16 = auto_alloc_array_clear(machine(), UINT16, m_fgvideoram_size);
m_bgvideoram16 = auto_alloc_array_clear(machine(), UINT16, m_bgvideoram_size);
m_display_on = 0;
twincobr_display(machine(), m_display_on);
state_save_register_global_pointer(machine(), m_txvideoram16, m_txvideoram_size);
state_save_register_global_pointer(machine(), m_fgvideoram16, m_fgvideoram_size);
state_save_register_global_pointer(machine(), m_bgvideoram16, m_bgvideoram_size);
state_save_register_global(machine(), m_txoffs);
state_save_register_global(machine(), m_fgoffs);
state_save_register_global(machine(), m_bgoffs);
state_save_register_global(machine(), m_scroll_x);
state_save_register_global(machine(), m_scroll_y);
state_save_register_global(machine(), m_txscrollx);
state_save_register_global(machine(), m_fgscrollx);
state_save_register_global(machine(), m_bgscrollx);
state_save_register_global(machine(), m_txscrolly);
state_save_register_global(machine(), m_fgscrolly);
state_save_register_global(machine(), m_bgscrolly);
state_save_register_global(machine(), m_display_on);
state_save_register_global(machine(), m_fg_rom_bank);
state_save_register_global(machine(), m_bg_ram_bank);
state_save_register_global(machine(), m_flip_screen);
state_save_register_global(machine(), m_wardner_sprite_hack);
machine().save().register_postload(save_prepost_delegate(FUNC(twincobr_restore_screen), &machine()));
}
static VIDEO_START( common )
{
/* allocate memory */
midyunit_cmos_ram = auto_alloc_array(machine, UINT16, (0x2000 * 4)/2);
local_videoram = auto_alloc_array_clear(machine, UINT16, 0x80000/2);
pen_map = auto_alloc_array(machine, pen_t, 65536);
/* reset all the globals */
midyunit_cmos_page = 0;
autoerase_enable = 0;
yawdim_dma = 0;
/* reset DMA state */
memset(dma_register, 0, sizeof(dma_register));
memset(&dma_state, 0, sizeof(dma_state));
/* register for state saving */
state_save_register_global(machine, autoerase_enable);
state_save_register_global_pointer(machine, local_videoram, 0x80000/2);
state_save_register_global_pointer(machine, midyunit_cmos_ram, (0x2000 * 4)/2);
state_save_register_global(machine, videobank_select);
state_save_register_global_array(machine, dma_register);
}
static void init_common(running_machine *machine)
{
flipscreen_old = -1;
/* allocate local videoram */
local_videoram[0] = auto_alloc_array(machine, UINT8, 0x1000 * 3);
local_videoram[1] = auto_alloc_array(machine, UINT8, 0x1000 * 3);
/* allocate local palette RAM */
local_paletteram = auto_alloc_array(machine, UINT8, 0x800 * 2);
/* configure tilemaps */
tilemap_set_transparent_pen(fg_tilemap,15);
/* reset the timer */
crtc_timer = timer_alloc(machine, crtc_interrupt_gen, NULL);
scrollx_ofs = 0x159;
scrolly_ofs = 0x10;
/* state save */
state_save_register_global(machine, selected_videoram);
state_save_register_global_pointer(machine, local_videoram[0], 0x1000 * 3);
state_save_register_global_pointer(machine, local_videoram[1], 0x1000 * 3);
state_save_register_global(machine, selected_paletteram);
state_save_register_global_array(machine, scrollx);
state_save_register_global_array(machine, scrolly);
state_save_register_global(machine, gfxreg);
state_save_register_global(machine, flipscreen);
state_save_register_global(machine, flipscreen_old);
state_save_register_global(machine, scrollx_ofs);
state_save_register_global(machine, scrolly_ofs);
state_save_register_global(machine, crtc_register);
state_save_register_global_array(machine, crtc_data);
state_save_register_global_pointer(machine, local_paletteram, 0x800 * 2);
}
static MACHINE_START( ccastles )
{
rectangle visarea;
/* initialize globals */
syncprom = memory_region(REGION_PROMS) + 0x000;
/* find the start of VBLANK in the SYNC PROM */
for (ccastles_vblank_start = 0; ccastles_vblank_start < 256; ccastles_vblank_start++)
if ((syncprom[(ccastles_vblank_start - 1) & 0xff] & 1) == 0 && (syncprom[ccastles_vblank_start] & 1) != 0)
break;
if (ccastles_vblank_start == 0)
ccastles_vblank_start = 256;
/* find the end of VBLANK in the SYNC PROM */
for (ccastles_vblank_end = 0; ccastles_vblank_end < 256; ccastles_vblank_end++)
if ((syncprom[(ccastles_vblank_end - 1) & 0xff] & 1) != 0 && (syncprom[ccastles_vblank_end] & 1) == 0)
break;
/* can't handle the wrapping case */
assert(ccastles_vblank_end < ccastles_vblank_start);
/* reconfigure the visible area to match */
visarea.min_x = 0;
visarea.max_x = 255;
visarea.min_y = ccastles_vblank_end;
visarea.max_y = ccastles_vblank_start - 1;
video_screen_configure(0, 320, 256, &visarea, (float)PIXEL_CLOCK / (float)VTOTAL / (float)HTOTAL);
/* configure the ROM banking */
memory_configure_bank(1, 0, 2, memory_region(REGION_CPU1) + 0xa000, 0x6000);
/* create a timer for IRQs and set up the first callback */
irq_timer = timer_alloc(clock_irq);
irq_state = 0;
schedule_next_irq(0);
/* allocate backing memory for the NVRAM */
generic_nvram = auto_malloc(generic_nvram_size);
/* setup for save states */
state_save_register_global(irq_state);
state_save_register_global_array(nvram_store);
state_save_register_global_pointer(generic_nvram, generic_nvram_size);
return 0;
}
void tms34061_start(running_machine &machine, const struct tms34061_interface *interface)
{
/* reset the data */
memset(&tms34061, 0, sizeof(tms34061));
tms34061.intf = *interface;
tms34061.screen = downcast<screen_device *>(machine.device(tms34061.intf.screen_tag));
tms34061.vrammask = tms34061.intf.vramsize - 1;
/* allocate memory for VRAM */
tms34061.vram = auto_alloc_array_clear(machine, UINT8, tms34061.intf.vramsize + 256 * 2);
/* not really a save state, just there for debugging purposes */
state_save_register_global_pointer(machine, tms34061.vram, tms34061.intf.vramsize);
/* allocate memory for latch RAM */
tms34061.latchram = auto_alloc_array_clear(machine, UINT8, tms34061.intf.vramsize + 256 * 2);
/* add some buffer space for VRAM and latch RAM */
tms34061.vram += 256;
tms34061.latchram += 256;
/* point the shift register to the base of VRAM for now */
tms34061.shiftreg = tms34061.vram;
/* initialize registers to their default values from the manual */
tms34061.regs[TMS34061_HORENDSYNC] = 0x0010;
tms34061.regs[TMS34061_HORENDBLNK] = 0x0020;
tms34061.regs[TMS34061_HORSTARTBLNK] = 0x01f0;
tms34061.regs[TMS34061_HORTOTAL] = 0x0200;
tms34061.regs[TMS34061_VERENDSYNC] = 0x0004;
tms34061.regs[TMS34061_VERENDBLNK] = 0x0010;
tms34061.regs[TMS34061_VERSTARTBLNK] = 0x00f0;
tms34061.regs[TMS34061_VERTOTAL] = 0x0100;
tms34061.regs[TMS34061_DISPUPDATE] = 0x0000;
tms34061.regs[TMS34061_DISPSTART] = 0x0000;
tms34061.regs[TMS34061_VERINT] = 0x0000;
tms34061.regs[TMS34061_CONTROL1] = 0x7000;
tms34061.regs[TMS34061_CONTROL2] = 0x0600;
tms34061.regs[TMS34061_STATUS] = 0x0000;
tms34061.regs[TMS34061_XYOFFSET] = 0x0010;
tms34061.regs[TMS34061_XYADDRESS] = 0x0000;
tms34061.regs[TMS34061_DISPADDRESS] = 0x0000;
tms34061.regs[TMS34061_VERCOUNTER] = 0x0000;
/* start vertical interrupt timer */
tms34061.timer = machine.scheduler().timer_alloc(FUNC(tms34061_interrupt));
}
