Previous

199869 Revisions

Next

r20638 Thursday 31st January, 2013 at 15:49:00 UTC by Miodrag Milanović
modernized some pre/postload calls (no whatsnew)

[src/mame/drivers]	neogeo.c
[src/mame/includes]	neogeo.h
[src/mame/video]	neogeo.c
[src/mess/drivers]	ng_aes.c
[src/mess/includes]	apple2.h b2m.h hp48.h lynx.h mac.h nes.h
[src/mess/machine]	apple2.c b2m.c hp48.c lynx.c mac.c nes.c

trunk/src/mame/drivers/neogeo.c

r20637	r20638
1013	1013	*
1014	1014	*************************************/
1015	1015
1016		void neogeo_postload(running_machine &machine)
	1016	void neogeo_state::neogeo_postload()
1017	1017	{
1018		neogeo_state *state = machine.driver_data<neogeo_state>();
1019
1020		_set_main_cpu_bank_address(machine);
1021		_set_main_cpu_vector_table_source(machine);
1022		set_audio_cpu_banking(machine);
1023		_set_audio_cpu_rom_source(machine.device("maincpu")->memory().space(AS_PROGRAM));
1024		if (state->m_is_mvs) set_outputs(machine);
	1018	_set_main_cpu_bank_address(machine());
	1019	_set_main_cpu_vector_table_source(machine());
	1020	set_audio_cpu_banking(machine());
	1021	_set_audio_cpu_rom_source(machine().device("maincpu")->memory().space(AS_PROGRAM));
	1022	if (m_is_mvs) set_outputs(machine());
1025	1023	}
1026	1024
1027	1025
r20637	r20638
1082	1080	save_item(NAME(m_led2_value));
1083	1081	save_item(NAME(m_recurse));
1084	1082
1085		machine().save().register_postload(save_prepost_delegate(FUNC(neogeo_postload), &machine()));
	1083	machine().save().register_postload(save_prepost_delegate(FUNC(neogeo_state::neogeo_postload), this));
1086	1084	}
1087	1085
1088	1086

trunk/src/mame/includes/neogeo.h

r20637	r20638
231	231	TIMER_CALLBACK_MEMBER(vblank_interrupt_callback);
232	232	TIMER_CALLBACK_MEMBER(auto_animation_timer_callback);
233	233	TIMER_CALLBACK_MEMBER(sprite_line_timer_callback);
	234	void neogeo_postload();
	235	void regenerate_pens();
234	236
235	237	bool m_has_audio_banking; // does the system use Audio Banking (the NeoCD doesn't?)
236	238	bool m_is_mvs; // is the system an MVS (watchdog, SRAM etc.)
r20637	r20638
253	255	void neogeo_acknowledge_interrupt(running_machine &machine, UINT16 data);
254	256	void neogeo_set_main_cpu_bank_address(address_space &space, UINT32 bank_address);
255	257	DEVICE_IMAGE_LOAD( neo_cartridge );
256		void neogeo_postload(running_machine &machine);
257	258	void neogeo_audio_cpu_banking_init( running_machine &machine );
258	259	void neogeo_main_cpu_banking_init( running_machine &machine );
259	260	void neogeo_set_main_cpu_vector_table_source( running_machine &machine, UINT8 data );

trunk/src/mame/video/neogeo.c

r20637	r20638
145	145	}
146	146
147	147
148		static void regenerate_pens(running_machine &machine)
	148	void neogeo_state::regenerate_pens()
149	149	{
150		neogeo_state *state = machine.driver_data<neogeo_state>();
151	150	int i;
152	151
153	152	for (i = 0; i < NUM_PENS; i++)
154		state->m_pens[i] = get_pen(machine, state->m_palettes[state->m_palette_bank][i]);
	153	m_pens[i] = get_pen(machine(), m_palettes[m_palette_bank][i]);
155	154	}
156	155
157	156
r20637	r20638
162	161	{
163	162	state->m_palette_bank = data;
164	163
165		regenerate_pens(machine);
	164	state->regenerate_pens();
166	165	}
167	166	}
168	167
r20637	r20638
174	173	{
175	174	state->m_screen_dark = data;
176	175
177		regenerate_pens(machine);
	176	state->regenerate_pens();
178	177	}
179	178	}
180	179
r20637	r20638
886	885	save_item(NAME(m_auto_animation_counter));
887	886	save_item(NAME(m_auto_animation_frame_counter));
888	887
889		machine().save().register_postload(save_prepost_delegate(FUNC(regenerate_pens), &machine()));
	888	machine().save().register_postload(save_prepost_delegate(FUNC(neogeo_state::regenerate_pens), this));
890	889
891	890	m_region_zoomy = memregion("zoomy")->base();
892	891	}

trunk/src/mess/machine/b2m.c

r20637	r20638
318	318	return m_b2m_localmachine;
319	319	}
320	320
321		static void b2m_postload(b2m_state *state)
	321	void b2m_state::b2m_postload()
322	322	{
323		b2m_set_bank(state->machine(), state->m_b2m_8255_portc & 7);
	323	b2m_set_bank(machine(), m_b2m_8255_portc & 7);
324	324	}
325	325
326	326	void b2m_state::machine_start()
r20637	r20638
344	344	save_item(NAME(m_b2m_localmachine));
345	345	save_item(NAME(m_vblank_state));
346	346
347		machine().save().register_postload(save_prepost_delegate(FUNC(b2m_postload), this));
	347	machine().save().register_postload(save_prepost_delegate(FUNC(b2m_state::b2m_postload), this));
348	348	}
349	349
350	350	IRQ_CALLBACK_MEMBER(b2m_state::b2m_irq_callback)

trunk/src/mess/machine/apple2.c

r20637	r20638
284	284
285	285
286	286
287		static void apple2_update_memory_postload(apple2_state *state)
	287	void apple2_state::apple2_update_memory_postload()
288	288	{
289		apple2_update_memory(state->machine());
	289	apple2_update_memory(machine());
290	290	}
291	291
292	292
r20637	r20638
1764	1764
1765	1765	/* state save registers */
1766	1766	state->save_item(NAME(state->m_flags));
1767		machine.save().register_postload(save_prepost_delegate(FUNC(apple2_update_memory_postload), state));
	1767	machine.save().register_postload(save_prepost_delegate(FUNC(apple2_state::apple2_update_memory_postload), state));
1768	1768
1769	1769	/* --------------------------------------------- *
1770	1770	* set up the softswitch mask/set                *

trunk/src/mess/machine/lynx.c

r20637	r20638
1953	1953	#endif
1954	1954	}
1955	1955
1956		static void lynx_postload(lynx_state *state)
	1956	void lynx_state::lynx_postload()
1957	1957	{
1958		state->lynx_memory_config_w( state->machine().device("maincpu")->memory().space(AS_PROGRAM), 0, state->m_memory_config);
	1958	lynx_memory_config_w(machine().device("maincpu")->memory().space(AS_PROGRAM), 0, m_memory_config);
1959	1959	}
1960	1960
1961	1961	void lynx_state::machine_start()
r20637	r20638
1965	1965	int i;
1966	1966	save_item(NAME(m_memory_config));
1967	1967	save_pointer(NAME(m_mem_fe00.target()), m_mem_fe00.bytes());
1968		machine().save().register_postload(save_prepost_delegate(FUNC(lynx_postload), this));
	1968	machine().save().register_postload(save_prepost_delegate(FUNC(lynx_state::lynx_postload), this));
1969	1969
1970	1970	membank("bank3")->configure_entry(0, machine().root_device().memregion("maincpu")->base() + 0x0000);
1971	1971	membank("bank3")->configure_entry(1, m_mem_fe00);

trunk/src/mess/machine/mac.c

r20637	r20638
1930	1930	machine().device("maincpu")->execute().set_input_line(INPUT_LINE_RESET, state);
1931	1931	}
1932	1932
1933		static void mac_state_load(mac_state *mac)
	1933	void mac_state::mac_state_load()
1934	1934	{
1935	1935	int overlay;
1936		overlay = mac->m_overlay;
1937		if (mac->m_model < MODEL_MAC_POWERMAC_6100) // no overlay for PowerPC
	1936	overlay = m_overlay;
	1937	if (m_model < MODEL_MAC_POWERMAC_6100) // no overlay for PowerPC
1938	1938	{
1939		mac->m_overlay = -1;
1940		mac->set_memory_overlay(overlay);
	1939	m_overlay = -1;
	1940	set_memory_overlay(overlay);
1941	1941	}
1942	1942	}
1943	1943
r20637	r20638
2077	2077	mac->m_inquiry_timeout = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(mac_state::inquiry_timeout_func),mac));
2078	2078
2079	2079	/* save state stuff */
2080		machine.save().register_postload(save_prepost_delegate(FUNC(mac_state_load), mac));
	2080	machine.save().register_postload(save_prepost_delegate(FUNC(mac_state::mac_state_load), mac));
2081	2081	}
2082	2082
2083	2083	#define MAC_DRIVER_INIT(label, model)   \

trunk/src/mess/machine/nes.c

r20637	r20638
227	227	m_irq_timer->adjust(attotime::never);
228	228	}
229	229
230		static void nes_banks_restore(nes_state *state)
	230	void nes_state::nes_banks_restore()
231	231	{
232		state->membank("bank1")->set_entry(state->m_prg_bank[0]);
233		state->membank("bank2")->set_entry(state->m_prg_bank[1]);
234		state->membank("bank3")->set_entry(state->m_prg_bank[2]);
235		state->membank("bank4")->set_entry(state->m_prg_bank[3]);
236		state->membank("bank5")->set_entry(state->m_prg_bank[4]);
	232	membank("bank1")->set_entry(m_prg_bank[0]);
	233	membank("bank2")->set_entry(m_prg_bank[1]);
	234	membank("bank3")->set_entry(m_prg_bank[2]);
	235	membank("bank4")->set_entry(m_prg_bank[3]);
	236	membank("bank5")->set_entry(m_prg_bank[4]);
237	237	}
238	238
239	239	static void nes_state_register( running_machine &machine )
r20637	r20638
286	286	if (state->m_battery)
287	287	state->save_pointer(NAME(state->m_battery_ram), state->m_battery_size);
288	288
289		machine.save().register_postload(save_prepost_delegate(FUNC(nes_banks_restore), state));
	289	machine.save().register_postload(save_prepost_delegate(FUNC(nes_state::nes_banks_restore), state));
290	290	}
291	291
292	292

trunk/src/mess/machine/hp48.c

r20637	r20638
80	80	FUNCTIONS
81	81	***************************************************************************/
82	82
83		static void hp48_apply_modules(hp48_state *state);
84
85
86	83	static void hp48_pulse_irq( running_machine &machine, int irq_line)
87	84	{
88	85	machine.device("maincpu")->execute().set_input_line(irq_line, ASSERT_LINE );
r20637	r20638
334	331
335	332	/* ------------- annonciators ------------ */
336	333
337		static void hp48_update_annunciators(hp48_state *state)
	334	void hp48_state::hp48_update_annunciators()
338	335	{
339	336	/* bit 0: left shift
340	337	bit 1: right shift
r20637	r20638
344	341	bit 5: transmit
345	342	bit 7: master enable
346	343	*/
	344	hp48_state *state = machine().driver_data<hp48_state>();
347	345	int markers = HP48_IO_8(0xb);
348	346	output_set_value( "lshift0",   (markers & 0x81) == 0x81 );
349	347	output_set_value( "rshift0",   (markers & 0x82) == 0x82 );
r20637	r20638
379	377	case 0x0b:
380	378	case 0x0c:
381	379	m_io[offset] = data;
382		hp48_update_annunciators(this);
	380	hp48_update_annunciators();
383	381	break;
384	382
385	383	/* cntrl ROM */
r20637	r20638
389	387	m_io[offset] = data;
390	388	if ( old_cntrl != (data & 8) )
391	389	{
392		hp48_apply_modules(this);
	390	hp48_apply_modules();
393	391	}
394	392	break;
395	393	}
r20637	r20638
597	595	{
598	596	LOG(( "%05x %f hp48_bank_r: off=%03x\n", space.device().safe_pcbase(), space.machine().time().as_double(), offset ));
599	597	m_bank_switch = offset;
600		hp48_apply_modules(this);
	598	hp48_apply_modules();
601	599	}
602	600	return 0;
603	601	}
r20637	r20638
695	693
696	694
697	695	/* remap all modules according to hp48_modules */
698		static void hp48_apply_modules(hp48_state *state)
	696	void hp48_state::hp48_apply_modules()
699	697	{
700	698	int i;
701	699	int nce2_enable = 1;
702		address_space& space = state->machine().device("maincpu")->memory().space(AS_PROGRAM);
	700	address_space& space = machine().device("maincpu")->memory().space(AS_PROGRAM);
703	701
704		state->m_io_addr = 0x100000;
	702	m_io_addr = 0x100000;
705	703
	704	hp48_state *state = machine().driver_data<hp48_state>();
706	705	if ( HP48_G_SERIES )
707	706	{
708	707	/* port 2 bank switch */
709		if ( state->m_port_size[1] > 0 )
	708	if ( m_port_size[1] > 0 )
710	709	{
711		int off = (state->m_bank_switch << 16) % state->m_port_size[1];
712		state->m_modules[4].data = state->m_port_data[1] + off;
	710	int off = (m_bank_switch << 16) % m_port_size[1];
	711	m_modules[4].data = m_port_data[1] + off;
713	712	}
714	713
715	714	/* ROM A19 (hi 256 KB) / NCE2 (port 2) control switch */
716		if ( state->m_io[0x29] & 8 )
	715	if ( m_io[0x29] & 8 )
717	716	{
718	717	/* A19 */
719		state->m_modules[5].off_mask = 0xfffff;
	718	m_modules[5].off_mask = 0xfffff;
720	719	nce2_enable = 0;
721	720	}
722	721	else
723	722	{
724	723	/* NCE2 */
725		state->m_modules[5].off_mask = 0x7ffff;
726		nce2_enable = state->m_bank_switch >> 6;
	724	m_modules[5].off_mask = 0x7ffff;
	725	nce2_enable = m_bank_switch >> 6;
727	726	}
728	727	}
729	728
730	729	/* S series ROM mapping compatibility */
731		if ( HP48_S_SERIES || !(state->m_io[0x29] & 8) )
	730	if ( HP48_S_SERIES || !(m_io[0x29] & 8) )
732	731	{
733		state->m_modules[5].off_mask = 0x7ffff;
	732	m_modules[5].off_mask = 0x7ffff;
734	733	}
735	734	else
736	735	{
737		state->m_modules[5].off_mask = 0xfffff;
	736	m_modules[5].off_mask = 0xfffff;
738	737	}
739	738
740	739	/* from lowest to highest priority */
741	740	for ( i = 5; i >= 0; i-- )
742	741	{
743		UINT32 select_mask = state->m_modules[i].mask;
	742	UINT32 select_mask = m_modules[i].mask;
744	743	UINT32 nselect_mask = ~select_mask & 0xfffff;
745		UINT32 base = state->m_modules[i].base;
746		UINT32 off_mask = state->m_modules[i].off_mask;
	744	UINT32 base = m_modules[i].base;
	745	UINT32 off_mask = m_modules[i].off_mask;
747	746	UINT32 mirror = nselect_mask & ~off_mask;
748	747	UINT32 end = base + (off_mask & nselect_mask);
749	748	char bank[10];
750	749	sprintf(bank,"bank%d",i);
751	750
752		if ( state->m_modules[i].state != HP48_MODULE_CONFIGURED ) continue;
	751	if ( m_modules[i].state != HP48_MODULE_CONFIGURED ) continue;
753	752
754	753	if ( (i == 4) && !nce2_enable ) continue;
755	754
r20637	r20638
761	760	continue;
762	761	}
763	762
764		if (state->m_modules[i].data)
	763	if (m_modules[i].data)
765	764	space.install_read_bank( base, end, 0, mirror, bank );
766	765	else
767	766	{
768		if (!state->m_modules[i].read.isnull())
769		space.install_read_handler( base, end, 0, mirror, state->m_modules[i].read);
	767	if (!m_modules[i].read.isnull())
	768	space.install_read_handler( base, end, 0, mirror, m_modules[i].read);
770	769	}
771	770
772		if (state->m_modules[i].isnop)
	771	if (m_modules[i].isnop)
773	772	space.nop_write(base, end, 0, mirror);
774	773	else
775	774	{
776		if (state->m_modules[i].data)
	775	if (m_modules[i].data)
777	776	space.install_write_bank( base, end, 0, mirror, bank );
778	777	else
779	778	{
780		if (!state->m_modules[i].write.isnull())
781		space.install_write_handler( base, end, 0, mirror, state->m_modules[i].write);
	779	if (!m_modules[i].write.isnull())
	780	space.install_write_handler( base, end, 0, mirror, m_modules[i].write);
782	781	}
783	782	}
784	783
785	784	LOG(( "hp48_apply_modules: module %s configured at %05x-%05x, mirror %05x\n",
786	785	hp48_module_names[i], base, end, mirror ));
787	786
788		if ( state->m_modules[i].data )
	787	if ( m_modules[i].data )
789	788	{
790		state->membank( bank )->set_base( state->m_modules[i].data );
	789	membank( bank )->set_base( m_modules[i].data );
791	790	}
792	791
793	792	if ( i == 0 )
794	793	{
795		state->m_io_addr = base;
	794	m_io_addr = base;
796	795	}
797	796	}
798	797	}
r20637	r20638
817	816	state->m_modules[5].base = 0;
818	817	state->m_modules[5].mask = 0;
819	818
820		hp48_apply_modules(state);
	819	state->hp48_apply_modules();
821	820	}
822	821
823	822
r20637	r20638
855	854	state->m_modules[i].state = HP48_MODULE_CONFIGURED;
856	855	LOG(( "hp48_mem_config: module %s configured base=%05x, mask=%05x\n",
857	856	hp48_module_names[i], state->m_modules[i].base, state->m_modules[i].mask ));
858		hp48_apply_modules(state);
	857	state->hp48_apply_modules();
859	858	break;
860	859	}
861	860	}
r20637	r20638
878	877	{
879	878	state->m_modules[i].state = i> 0 ? HP48_MODULE_UNCONFIGURED : HP48_MODULE_MASK_KNOWN;
880	879	LOG(( "hp48_mem_unconfig: module %s\n", hp48_module_names[i] ));
881		hp48_apply_modules(state);
	880	state->hp48_apply_modules();
882	881	break;
883	882	}
884	883	}
r20637	r20638
985	984	state->m_modules[conf->module].isnop    = 1;
986	985	}
987	986	state->m_modules[conf->module].data     = state->m_port_data[conf->port];
988		hp48_apply_modules(state);
	987	state->hp48_apply_modules();
989	988	}
990	989
991	990	/* helper for start and unload */
r20637	r20638
1057	1056	}
1058	1057	free( state->m_port_data[conf->port] );
1059	1058	hp48_unfill_port();
1060		hp48_apply_modules(state);
	1059	state->hp48_apply_modules();
1061	1060	}
1062	1061
1063	1062	void hp48_port_image_device::device_start()
r20637	r20638
1099	1098	{
1100	1099	LOG(( "hp48: machine reset called\n" ));
1101	1100	hp48_reset_modules( machine() );
1102		hp48_update_annunciators(this);
	1101	hp48_update_annunciators();
1103	1102	}
1104	1103
1105	1104	void hp48_state::hp48_machine_start( hp48_models model )
r20637	r20638
1186	1185	save_item(NAME(m_io) );
1187	1186	//state_save_register_global_pointer(machine,  machine.generic.nvram.u8, machine.generic.nvram_size );
1188	1187
1189		machine().save().register_postload( save_prepost_delegate(FUNC(hp48_update_annunciators), state ));
1190		machine().save().register_postload( save_prepost_delegate(FUNC(hp48_apply_modules), state ));
	1188	machine().save().register_postload( save_prepost_delegate(FUNC(hp48_state::hp48_update_annunciators), state ));
	1189	machine().save().register_postload( save_prepost_delegate(FUNC(hp48_state::hp48_apply_modules), state ));
1191	1190
1192	1191	#ifdef CHARDEV
1193	1192	/* direct I/O */

trunk/src/mess/includes/mac.h

r20637	r20638
509	509	DECLARE_WRITE8_MEMBER(mac_via2_out_a);
510	510	DECLARE_WRITE8_MEMBER(mac_via2_out_b);
511	511	DECLARE_WRITE_LINE_MEMBER(mac_kbd_clk_in);
	512	void mac_state_load();
512	513	};
513	514
514	515	#endif /* MAC_H_ */

trunk/src/mess/includes/nes.h

r20637	r20638
124	124	DECLARE_READ8_MEMBER(psg_4015_r);
125	125	DECLARE_WRITE8_MEMBER(psg_4015_w);
126	126	DECLARE_WRITE8_MEMBER(psg_4017_w);
	127	void nes_banks_restore();
127	128
128	129	ioport_port       *m_io_ctrlsel;
129	130	ioport_port       *m_io_fckey[9];

trunk/src/mess/includes/lynx.h

r20637	r20638
144	144	TIMER_CALLBACK_MEMBER(lynx_timer_shot);
145	145	TIMER_CALLBACK_MEMBER(lynx_uart_loopback_timer);
146	146	TIMER_CALLBACK_MEMBER(lynx_uart_timer);
	147	void lynx_postload();
147	148	};
148	149
149	150

trunk/src/mess/includes/b2m.h

r20637	r20638
66	66	void b2m_fdc_drq(bool state);
67	67	DECLARE_FLOPPY_FORMATS( b2m_floppy_formats );
68	68	IRQ_CALLBACK_MEMBER(b2m_irq_callback);
	69	void b2m_postload();
69	70	};
70	71
71	72	/*----------- defined in machine/b2m.c -----------*/

trunk/src/mess/includes/apple2.h

r20637	r20638
270	270	DECLARE_WRITE8_MEMBER(a2bus_irq_w);
271	271	DECLARE_WRITE8_MEMBER(a2bus_nmi_w);
272	272	DECLARE_WRITE8_MEMBER(a2bus_inh_w);
	273	void apple2_update_memory_postload();
273	274	};
274	275
275	276

trunk/src/mess/includes/hp48.h

r20637	r20638
84	84	TIMER_CALLBACK_MEMBER(hp48_kbd_cb);
85	85	TIMER_CALLBACK_MEMBER(hp48_timer1_cb);
86	86	TIMER_CALLBACK_MEMBER(hp48_timer2_cb);
	87	void hp48_update_annunciators();
	88	void hp48_apply_modules();
87	89	};
88	90
89	91

trunk/src/mess/drivers/ng_aes.c

r20637	r20638
1085	1085	state->save_item(NAME(state->m_led2_value));
1086	1086	state->save_item(NAME(state->m_recurse));
1087	1087
1088		machine.save().register_postload(save_prepost_delegate(FUNC(neogeo_postload), &machine));
	1088	machine.save().register_postload(save_prepost_delegate(FUNC(neogeo_state::neogeo_postload), state));
1089	1089	}
1090	1090
1091	1091	MACHINE_START_MEMBER(ng_aes_state,neogeo)

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team