Beispiel #1
0
void stv_register_protection_savestates(void)
{
	state_save_register_global_array(a_bus);
	state_save_register_global(ctrl_index);
	state_save_register_global(internal_counter);
	state_save_register_global(char_offset);
}
Beispiel #2
0
static MACHINE_START( tceptor )
{
	tceptor_state *state = machine.driver_data<tceptor_state>();
	state_save_register_global(machine, state->m_m6809_irq_enable);
	state_save_register_global(machine, state->m_m68k_irq_enable);
	state_save_register_global(machine, state->m_mcu_irq_enable);
}
static MACHINE_START( lvpoker )
{
	state_save_register_global(payout);
	state_save_register_global(pulse);
	state_save_register_global(result);
	return 0;
}
Beispiel #4
0
static void tubep_setup_save_state(void)
{
	/* Set up save state */
	state_save_register_global(sound_latch);
	state_save_register_global(ls74);
	state_save_register_global(ls377);
}
Beispiel #5
0
void m5_state::machine_start()
{
	address_space *program = m_maincpu->memory().space(AS_PROGRAM);

	// configure VDP
	TMS9928A_configure(m_vdp_intf);

	// configure RAM
	switch (ram_get_size(m_ram))
	{
	case 4*1024:
		program->unmap_readwrite(0x8000, 0xffff);
		break;

	case 36*1024:
		break;

	case 68*1024:
		break;
	}

	// register for state saving
	state_save_register_global(machine(), m_fd5_data);
	state_save_register_global(machine(), m_fd5_com);
	state_save_register_global(machine(), m_intra);
	state_save_register_global(machine(), m_ibfa);
	state_save_register_global(machine(), m_obfa);
}
Beispiel #6
0
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);
}
Beispiel #7
0
static MACHINE_START( ninjaw )
{
	ninjaw_state *state = (ninjaw_state *)machine->driver_data;

	memory_configure_bank(machine, "bank10", 0, 8, memory_region(machine, "audiocpu") + 0xc000, 0x4000);

	state->maincpu = machine->device("maincpu");
	state->audiocpu = machine->device("audiocpu");
	state->subcpu = machine->device("sub");
	state->tc0140syt = machine->device("tc0140syt");
	state->tc0100scn_1 = machine->device("tc0100scn_1");
	state->tc0100scn_2 = machine->device("tc0100scn_2");
	state->tc0100scn_3 = machine->device("tc0100scn_3");

	state->lscreen = machine->device("lscreen");
	state->mscreen = machine->device("mscreen");
	state->rscreen = machine->device("rscreen");

	state->_2610_1l = machine->device("2610.1.l");
	state->_2610_1r = machine->device("2610.1.r");
	state->_2610_2l = machine->device("2610.2.l");
	state->_2610_2r = machine->device("2610.2.r");

	state_save_register_global(machine, state->cpua_ctrl);
	state_save_register_global(machine, state->banknum);
	state_save_register_global_array(machine, state->pandata);
	state_save_register_postload(machine, ninjaw_postload, NULL);
}
Beispiel #8
0
static void tubep_setup_save_state(running_machine *machine)
{
	/* Set up save state */
	state_save_register_global(machine, sound_latch);
	state_save_register_global(machine, ls74);
	state_save_register_global(machine, ls377);
}
Beispiel #9
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);
}
Beispiel #10
0
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);
}
Beispiel #11
0
static MACHINE_START( lvpoker )
{
	lvcards_state *state = machine.driver_data<lvcards_state>();
	state_save_register_global(machine, state->m_payout);
	state_save_register_global(machine, state->m_pulse);
	state_save_register_global(machine, state->m_result);
}
Beispiel #12
0
ADDRESS_MAP_END


/***************************************************************************/


//static UINT8 adpcm_d[0x08];
//0 - start ROM offset LSB
//1 - start ROM offset MSB
//2 - end ROM offset LSB
//3 - end ROM offset MSB
//start & end need to be multiplied by 16 to get a proper _byte_ address in adpcm ROM
//4 - always zero write (start trigger ?)
//5 - different values
//6 - different values

static MACHINE_START( opwolf )
{
	opwolf_state *state = machine->driver_data<opwolf_state>();

	state->maincpu = machine->device<cpu_device>("maincpu");
	state->audiocpu = machine->device<cpu_device>("audiocpu");
	state->pc080sn = machine->device("pc080sn");
	state->pc090oj = machine->device("pc090oj");
	state->msm1 = machine->device("msm1");
	state->msm2 = machine->device("msm2");

	state_save_register_global(machine, state->sprite_ctrl);
	state_save_register_global(machine, state->sprites_flipscreen);

	state_save_register_global_array(machine, state->adpcm_b);
	state_save_register_global_array(machine, state->adpcm_c);
	state_save_register_global_array(machine, state->adpcm_pos);
	state_save_register_global_array(machine, state->adpcm_end);
}
Beispiel #13
0
void beathead_state::video_start()
{
	state_save_register_global(&m_machine, m_finescroll);
	state_save_register_global(&m_machine, m_vram_latch_offset);
	state_save_register_global(&m_machine, m_hsyncram_offset);
	state_save_register_global(&m_machine, m_hsyncram_start);
	state_save_register_global_array(&m_machine, m_hsyncram);
}
Beispiel #14
0
static MACHINE_START( btoads )
{
	state_save_register_global(machine, main_to_sound_data);
	state_save_register_global(machine, main_to_sound_ready);
	state_save_register_global(machine, sound_to_main_data);
	state_save_register_global(machine, sound_to_main_ready);
	state_save_register_global(machine, sound_int_state);
}
Beispiel #15
0
static SOUND_START( jedi )
{
	jedi_state *state = machine->driver_data<jedi_state>();

	/* set up save state */
	state_save_register_global(machine, state->audio_latch);
	state_save_register_global(machine, state->audio_ack_latch);
	state_save_register_global(machine, state->speech_strobe_state);
}
Beispiel #16
0
static MACHINE_START( tomahawk )
{
	create_irq_timer();

	/* register for state saving */
	state_save_register_global(red_on);
	state_save_register_global(flipscreen);
	state_save_register_global(screen_off);
}
Beispiel #17
0
void demonwld_driver_savestate(running_machine *machine)
{
	state_save_register_global(machine, demonwld_dsp_on);
	state_save_register_global(machine, dsp_addr_w);
	state_save_register_global(machine, main_ram_seg);
	state_save_register_global(machine, demonwld_dsp_BIO);
	state_save_register_global(machine, dsp_execute);
	state_save_register_postload(machine, demonwld_restore_dsp, NULL);
}
Beispiel #18
0
static MACHINE_START( gotya )
{
	gotya_state *state = (gotya_state *)machine->driver_data;

	state->samples = machine->device("samples");

	state_save_register_global(machine, state->scroll_bit_8);
	state_save_register_global(machine, state->theme_playing);
}
Beispiel #19
0
static MACHINE_START( chanbara )
{
	chanbara_state *state = (chanbara_state *)machine->driver_data;

	state->maincpu = devtag_get_device(machine, "maincpu");

	state_save_register_global(machine, state->scroll);
	state_save_register_global(machine, state->scrollhi);
}
Beispiel #20
0
static MACHINE_START( chanbara )
{
	chanbara_state *state = machine->driver_data<chanbara_state>();

	state->maincpu = machine->device("maincpu");

	state_save_register_global(machine, state->scroll);
	state_save_register_global(machine, state->scrollhi);
}
Beispiel #21
0
static void register_state_saving(running_machine &machine)
{
	midwunit_state *state = machine.driver_data<midwunit_state>();
	state_save_register_global(machine, state->m_cmos_write_enable);
	state_save_register_global_array(machine, state->m_iodata);
	state_save_register_global_array(machine, state->m_ioshuffle);
	state_save_register_global_array(machine, state->m_uart);
	state_save_register_global(machine, state->m_security_bits);
}
Beispiel #22
0
void abc802_state::video_start()
{
	// find memory regions
	m_char_rom = machine().region(MC6845_TAG)->base();

	// register for state saving
	state_save_register_global(machine(), m_flshclk_ctr);
	state_save_register_global(machine(), m_flshclk);
	state_save_register_global(machine(), m_80_40_mux);
}
Beispiel #23
0
static MACHINE_START( hnayayoi )
{
	hnayayoi_state *state = (hnayayoi_state *)machine->driver_data;

	state_save_register_global(machine, state->palbank);
	state_save_register_global(machine, state->blit_layer);
	state_save_register_global(machine, state->blit_dest);
	state_save_register_global(machine, state->blit_src);
	state_save_register_global(machine, state->keyb);
}
Beispiel #24
0
static void srtc_init( running_machine &machine )
{
	rtc_state.mode = RTCM_Read;
	rtc_state.index = -1;
	srtc_update_time(machine);

	state_save_register_global_array(machine, rtc_state.ram);
	state_save_register_global(machine, rtc_state.mode);
	state_save_register_global(machine, rtc_state.index);
}
Beispiel #25
0
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);
}
Beispiel #26
0
static MACHINE_START( ninjaw )
{
	cpua_ctrl = 0xff;
	banknum = -1;
	memset(ninjaw_pandata, 0, sizeof(ninjaw_pandata));

	state_save_register_global(machine, cpua_ctrl);
	state_save_register_global(machine, banknum);
	state_save_register_postload(machine, ninjaw_postload, NULL);
}
Beispiel #27
0
static DRIVER_INIT( redbaron )
{
	OVERLAY_START( redbaron_overlay )
		OVERLAY_RECT( 0.0, 0.0, 1.0, 1.0, MAKE_ARGB(0x04,0x88,0xff,0xff) )
	OVERLAY_END

	artwork_set_overlay(redbaron_overlay);
	state_save_register_global(analog_data);
	state_save_register_global(rb_input_select);
}
Beispiel #28
0
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);
}
Beispiel #29
0
static MACHINE_START( formatz )
{
	aeroboto_state *state = machine->driver_data<aeroboto_state>();

	state->stars_rom = memory_region(machine, "gfx2");
	state->stars_length = memory_region_length(machine, "gfx2");

	state_save_register_global(machine, state->disable_irq);
	state_save_register_global(machine, state->count);
}
Beispiel #30
0
static MACHINE_START( atetris )
{
	/* Allocate interrupt timer */
	interrupt_timer = timer_alloc(machine, interrupt_gen, NULL);

	/* Set up save state */
	state_save_register_global(machine, current_bank);
	state_save_register_global(machine, nvram_write_enable);
	state_save_register_postload(machine, atetris_postload, NULL);
}