Previous

199869 Revisions

Next

r20892 Sunday 10th February, 2013 at 14:16:16 UTC by Wilbert Pol
neogeo.c/ng_aes.c: Reduce tagmap lookups (nw)

[src/mame/drivers]	neogeo.c
[src/mame/includes]	neogeo.h
[src/mame/machine]	neoboot.c neoprot.c
[src/mame/video]	neogeo.c
[src/mess/drivers]	ng_aes.c

trunk/src/mess/drivers/ng_aes.c

r20891	r20892
178	178	DECLARE_DRIVER_INIT(neocdzj);
179	179
180	180	IRQ_CALLBACK_MEMBER(neocd_int_callback);
	181
	182	protected:
	183	void common_machine_start();
181	184	};
182	185
183	186
r20891	r20892
456	459	// writes 00 / 01 / ff
457	460	printf("MapVectorTable? %04x %04x\n",data,mem_mask);
458	461
459		if (!data) neogeo_set_main_cpu_vector_table_source(machine(), 0); // bios vectors
460		else neogeo_set_main_cpu_vector_table_source(machine(), 1); // ram (aka cart) vectors
	462	if (!data) neogeo_set_main_cpu_vector_table_source(0); // bios vectors
	463	else neogeo_set_main_cpu_vector_table_source(1); // ram (aka cart) vectors
461	464
462	465	}
463	466
r20891	r20892
1037	1040	*************************************/
1038	1041
1039	1042
1040		static void common_machine_start(running_machine &machine)
	1043	void ng_aes_state::common_machine_start()
1041	1044	{
1042		neogeo_state *state = machine.driver_data<neogeo_state>();
1043
1044	1045	/* set the BIOS bank */
1045		state->membank(NEOGEO_BANK_BIOS)->set_base(state->memregion("mainbios")->base());
	1046	m_bank_bios->set_base(memregion("mainbios")->base());
1046	1047
1047	1048	/* set the initial main CPU bank */
1048		neogeo_main_cpu_banking_init(machine);
	1049	neogeo_main_cpu_banking_init();
1049	1050
1050	1051	/* set the initial audio CPU ROM banks */
1051		neogeo_audio_cpu_banking_init(machine);
	1052	neogeo_audio_cpu_banking_init();
1052	1053
1053		state->create_interrupt_timers(machine);
	1054	create_interrupt_timers();
1054	1055
1055	1056	/* irq levels for MVS / AES */
1056		state->m_vblank_level = 1;
1057		state->m_raster_level = 2;
	1057	m_vblank_level = 1;
	1058	m_raster_level = 2;
1058	1059
1059	1060	/* start with an IRQ3 - but NOT on a reset */
1060		state->m_irq3_pending = 1;
	1061	m_irq3_pending = 1;
1061	1062
1062		/* get devices */
1063		state->m_maincpu = machine.device<cpu_device>("maincpu");
1064		state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1065		state->m_upd4990a = machine.device("upd4990a");
1066
1067	1063	/* register state save */
1068		state->save_item(NAME(state->m_display_position_interrupt_control));
1069		state->save_item(NAME(state->m_display_counter));
1070		state->save_item(NAME(state->m_vblank_interrupt_pending));
1071		state->save_item(NAME(state->m_display_position_interrupt_pending));
1072		state->save_item(NAME(state->m_irq3_pending));
1073		state->save_item(NAME(state->m_audio_result));
1074		state->save_item(NAME(state->m_controller_select));
1075		state->save_item(NAME(state->m_main_cpu_bank_address));
1076		state->save_item(NAME(state->m_main_cpu_vector_table_source));
1077		state->save_item(NAME(state->m_audio_cpu_banks));
1078		state->save_item(NAME(state->m_audio_cpu_rom_source));
1079		state->save_item(NAME(state->m_audio_cpu_rom_source_last));
1080		state->save_item(NAME(state->m_save_ram_unlocked));
1081		state->save_item(NAME(state->m_output_data));
1082		state->save_item(NAME(state->m_output_latch));
1083		state->save_item(NAME(state->m_el_value));
1084		state->save_item(NAME(state->m_led1_value));
1085		state->save_item(NAME(state->m_led2_value));
1086		state->save_item(NAME(state->m_recurse));
	1064	save_item(NAME(m_display_position_interrupt_control));
	1065	save_item(NAME(m_display_counter));
	1066	save_item(NAME(m_vblank_interrupt_pending));
	1067	save_item(NAME(m_display_position_interrupt_pending));
	1068	save_item(NAME(m_irq3_pending));
	1069	save_item(NAME(m_audio_result));
	1070	save_item(NAME(m_controller_select));
	1071	save_item(NAME(m_main_cpu_bank_address));
	1072	save_item(NAME(m_main_cpu_vector_table_source));
	1073	save_item(NAME(m_audio_cpu_banks));
	1074	save_item(NAME(m_audio_cpu_rom_source));
	1075	save_item(NAME(m_audio_cpu_rom_source_last));
	1076	save_item(NAME(m_save_ram_unlocked));
	1077	save_item(NAME(m_output_data));
	1078	save_item(NAME(m_output_latch));
	1079	save_item(NAME(m_el_value));
	1080	save_item(NAME(m_led1_value));
	1081	save_item(NAME(m_led2_value));
	1082	save_item(NAME(m_recurse));
1087	1083
1088		machine.save().register_postload(save_prepost_delegate(FUNC(neogeo_state::neogeo_postload), state));
	1084	machine().save().register_postload(save_prepost_delegate(FUNC(neogeo_state::neogeo_postload), this));
1089	1085	}
1090	1086
1091	1087	MACHINE_START_MEMBER(ng_aes_state,neogeo)
1092	1088	{
1093		common_machine_start(machine());
	1089	common_machine_start();
1094	1090	m_is_mvs = false;
1095	1091
1096	1092	/* initialize the memcard data structure */
r20891	r20892
1103	1099	m_has_audio_banking = false;
1104	1100	m_is_cartsys = false;
1105	1101
1106		common_machine_start(machine());
	1102	common_machine_start();
1107	1103	m_is_mvs = false;
1108	1104
1109	1105	/* irq levels for NEOCD (swapped compared to MVS / AES) */
r20891	r20892
1117	1113	save_pointer(NAME(m_memcard_data), 0x2000);
1118	1114
1119	1115	// for custom vectors
1120		machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(ng_aes_state::neocd_int_callback),this));
	1116	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(ng_aes_state::neocd_int_callback),this));
1121	1117
1122		neogeo_set_main_cpu_vector_table_source(machine(), 0); // default to the BIOS vectors
	1118	neogeo_set_main_cpu_vector_table_source(0); // default to the BIOS vectors
1123	1119
1124	1120	m_tempcdc->reset_cd();
1125	1121	}
r20891	r20892
1142	1138	MACHINE_RESET_MEMBER(ng_aes_state,neogeo)
1143	1139	{
1144	1140	offs_t offs;
1145		address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
	1141	address_space &space = m_maincpu->space(AS_PROGRAM);
1146	1142
1147	1143	/* reset system control registers */
1148	1144	for (offs = 0; offs < 8; offs++)
1149	1145	system_control_w(space, offs, 0, 0x00ff);
1150	1146
1151		machine().device("maincpu")->reset();
	1147	m_maincpu->reset();
1152	1148
1153	1149	neogeo_reset_rng(machine());
1154	1150
1155		start_interrupt_timers(machine());
	1151	start_interrupt_timers();
1156	1152
1157	1153	/* trigger the IRQ3 that was set by MACHINE_START */
1158		update_interrupts(machine());
	1154	update_interrupts();
1159	1155
1160	1156	m_recurse = 0;
1161	1157
r20891	r20892
1582	1578	if ((nIRQAcknowledge & 0x08) == 0) {
1583	1579	nNeoCDIRQVector = 0x17;
1584	1580	nNeoCDIRQVectorAck = 1;
1585		machine().device("maincpu")->execute().set_input_line(4, HOLD_LINE);
	1581	m_maincpu->set_input_line(4, HOLD_LINE);
1586	1582	return;
1587	1583	}
1588	1584	if ((nIRQAcknowledge & 0x10) == 0) {
1589	1585	nNeoCDIRQVector = 0x16;
1590	1586	nNeoCDIRQVectorAck = 1;
1591		machine().device("maincpu")->execute().set_input_line(4, HOLD_LINE);
	1587	m_maincpu->set_input_line(4, HOLD_LINE);
1592	1588	return;
1593	1589	}
1594	1590	if ((nIRQAcknowledge & 0x20) == 0) {
1595	1591	nNeoCDIRQVector = 0x15;
1596	1592	nNeoCDIRQVectorAck = 1;
1597		machine().device("maincpu")->execute().set_input_line(4, HOLD_LINE);
	1593	m_maincpu->set_input_line(4, HOLD_LINE);
1598	1594	return;
1599	1595	}
1600	1596	}

trunk/src/mame/machine/neoboot.c

r20891	r20892
162	162	UINT32 bank = 0x100000 + ((nBank & 7) << 20);
163	163	if (bank >= 0x700000)
164	164	bank = 0x100000;
165		neogeo_set_main_cpu_bank_address(space, bank);
	165	space.machine().driver_data<neogeo_state>()->neogeo_set_main_cpu_bank_address(bank);
166	166	}
167	167
168	168	static READ16_HANDLER( kof10th_RAMB_r )
r20891	r20892
492	492	if (offset == 0)
493	493	{
494	494	bankaddress = 0x100000 + cthd2003_banks[data&7]*0x100000;
495		neogeo_set_main_cpu_bank_address(space, bankaddress);
	495	space.machine().driver_data<neogeo_state>()->neogeo_set_main_cpu_bank_address(bankaddress);
496	496	}
497	497	}
498	498
r20891	r20892
731	731	if ((offset == 0)&&(data == 0xa0))
732	732	{
733	733	bankaddress=0xa0;
734		neogeo_set_main_cpu_bank_address(space, bankaddress);
	734	space.machine().driver_data<neogeo_state>()->neogeo_set_main_cpu_bank_address(bankaddress);
735	735	logerror("offset: %06x PC %06x: set banking %04x\n\n",offset,space.device().safe_pc(),bankaddress);
736	736	}
737	737	else if(offset == 2)
r20891	r20892
739	739	data=data>>4;
740	740	//data=data&7;
741	741	bankaddress=data*0x100000;
742		neogeo_set_main_cpu_bank_address(space, bankaddress);
	742	space.machine().driver_data<neogeo_state>()->neogeo_set_main_cpu_bank_address(bankaddress);
743	743	logerror("offset: %06x PC %06x: set banking %04x\n\n",offset,space.device().safe_pc(),bankaddress);
744	744	}
745	745	}
r20891	r20892
920	920	{
921	921	UINT32 bankaddress = (mv0_bank_ram[ 0 ] >> 8) + (mv0_bank_ram[ 1 ] << 8) + 0x100000;
922	922	COMBINE_DATA( &mv0_bank_ram[ offset ] );
923		neogeo_set_main_cpu_bank_address( space, bankaddress );
	923	space.machine().driver_data<neogeo_state>()->neogeo_set_main_cpu_bank_address( bankaddress );
924	924	}
925	925	#endif
926	926
r20891	r20892
947	947	cr[BYTE_XOR_LE(0x1ff0)] =  0xa0;
948	948	cr[BYTE_XOR_LE(0x1ff1)] &= 0xfe;
949	949	cr[BYTE_XOR_LE(0x1ff3)] &= 0x7f;
950		neogeo_set_main_cpu_bank_address(space, address+0x100000);
	950	space.machine().driver_data<neogeo_state>()->neogeo_set_main_cpu_bank_address(address+0x100000);
951	951
952	952	mem[BYTE_XOR_LE(0x58196)] = prt;
953	953	}
r20891	r20892
964	964
965	965	cr[BYTE_XOR_LE(0x1ff0)] &= 0xfe;
966	966	cr[BYTE_XOR_LE(0x1ff3)] &= 0x7f;
967		neogeo_set_main_cpu_bank_address(space, address+0x100000);
	967	space.machine().driver_data<neogeo_state>()->neogeo_set_main_cpu_bank_address(address+0x100000);
968	968
969	969	mem[BYTE_XOR_LE(0x58196)] = prt;
970	970	}

trunk/src/mame/machine/neoprot.c

r20891	r20892
257	257
258	258	bankaddress = 0x100000 + bankoffset[data];
259	259
260		neogeo_set_main_cpu_bank_address(space, bankaddress);
	260	space.machine().driver_data<neogeo_state>()->neogeo_set_main_cpu_bank_address(bankaddress);
261	261	}
262	262
263	263
r20891	r20892
294	294
295	295	bankaddress = 0x100000 + bankoffset[data];
296	296
297		neogeo_set_main_cpu_bank_address(space, bankaddress);
	297	space.machine().driver_data<neogeo_state>()->neogeo_set_main_cpu_bank_address(bankaddress);
298	298	}
299	299
300	300
r20891	r20892
333	333
334	334	bankaddress = 0x100000 + bankoffset[data];
335	335
336		neogeo_set_main_cpu_bank_address(space, bankaddress);
	336	space.machine().driver_data<neogeo_state>()->neogeo_set_main_cpu_bank_address(bankaddress);
337	337	}
338	338
339	339
r20891	r20892
369	369
370	370	bankaddress = 0x100000 + bankoffset[data];
371	371
372		neogeo_set_main_cpu_bank_address(space, bankaddress);
	372	space.machine().driver_data<neogeo_state>()->neogeo_set_main_cpu_bank_address(bankaddress);
373	373	}
374	374
375	375
r20891	r20892
401	401
402	402	bankaddress = 0x100000 + bankoffset[data];
403	403
404		neogeo_set_main_cpu_bank_address(space, bankaddress);
	404	space.machine().driver_data<neogeo_state>()->neogeo_set_main_cpu_bank_address(bankaddress);
405	405	}
406	406
407	407
r20891	r20892
550	550	*(((UINT8 *)state->m_pvc_cartridge_ram) + BYTE_XOR_LE(0x1ff0)) = 0xa0;
551	551	*(((UINT8 *)state->m_pvc_cartridge_ram) + BYTE_XOR_LE(0x1ff1)) &= 0xfe;
552	552	*(((UINT8 *)state->m_pvc_cartridge_ram) + BYTE_XOR_LE(0x1ff3)) &= 0x7f;
553		neogeo_set_main_cpu_bank_address(space, bankaddress + 0x100000);
	553	state->neogeo_set_main_cpu_bank_address(bankaddress + 0x100000);
554	554	}
555	555
556	556

trunk/src/mame/includes/neogeo.h

r20891	r20892
36	36	{
37	37	public:
38	38	neogeo_state(const machine_config &mconfig, device_type type, const char *tag)
39		: driver_device(mconfig, type, tag),
40		m_save_ram(*this, "save_ram")
	39	: driver_device(mconfig, type, tag)
	40	, m_save_ram(*this, "save_ram")
	41	, m_maincpu(*this, "maincpu")
	42	, m_audiocpu(*this, "audiocpu")
	43	, m_upd4990a(*this, "upd4990a")
	44	, m_region_maincpu(*this, "maincpu")
	45	, m_bank_vectors(*this, NEOGEO_BANK_VECTORS)
	46	, m_bank_bios(*this, NEOGEO_BANK_BIOS)
	47	, m_bank_cartridge(*this, NEOGEO_BANK_CARTRIDGE)
	48	, m_bank_audio_main(*this, NEOGEO_BANK_AUDIO_CPU_MAIN_BANK)
41	49	{
42	50	m_has_audio_banking = true;
43	51	m_is_mvs = true;
r20891	r20892
46	54	m_has_text_bus = true;
47	55	m_has_ymrom_bus = true;
48	56	m_has_z80_bus = true;
	57	m_bank_audio_cart[0] = NULL;
	58	m_bank_audio_cart[1] = NULL;
	59	m_bank_audio_cart[2] = NULL;
	60	m_bank_audio_cart[3] = NULL;
49	61	}
50	62
51	63	/* memory pointers */
r20891	r20892
124	136	UINT16     m_mslugx_command;
125	137
126	138	/* devices */
127		cpu_device *m_maincpu;
128		cpu_device *m_audiocpu;
129		device_t *m_upd4990a;
	139	required_device<cpu_device> m_maincpu;
	140	required_device<cpu_device> m_audiocpu;
	141	required_device<device_t> m_upd4990a;
	142
130	143	DECLARE_WRITE8_MEMBER(audio_cpu_clear_nmi_w);
131	144	DECLARE_WRITE16_MEMBER(io_control_w);
132	145	DECLARE_WRITE16_MEMBER(save_ram_w);
r20891	r20892
223	236	virtual void video_start();
224	237	virtual void video_reset();
225	238	UINT32 screen_update_neogeo(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
226		void update_interrupts( running_machine &machine );
227		void create_interrupt_timers( running_machine &machine );
228		void start_interrupt_timers( running_machine &machine );
	239	void update_interrupts();
	240	void create_interrupt_timers();
	241	void start_interrupt_timers();
229	242	TIMER_CALLBACK_MEMBER(display_position_interrupt_callback);
230	243	TIMER_CALLBACK_MEMBER(display_position_vblank_callback);
231	244	TIMER_CALLBACK_MEMBER(vblank_interrupt_callback);
r20891	r20892
244	257	bool m_has_text_bus;
245	258	bool m_has_ymrom_bus;
246	259	bool m_has_z80_bus;
	260
	261	void neogeo_set_main_cpu_bank_address( UINT32 bank_address );
	262
	263	protected:
	264	required_memory_region m_region_maincpu;
	265	required_memory_bank m_bank_vectors;
	266	required_memory_bank m_bank_bios;
	267	optional_memory_bank m_bank_cartridge;  // optional because of neocd
	268	optional_memory_bank m_bank_audio_main; // optional because of neocd
	269	memory_bank *m_bank_audio_cart[4];
	270
	271	void neogeo_acknowledge_interrupt(UINT16 data);
	272	void _set_main_cpu_bank_address();
	273	void neogeo_main_cpu_banking_init();
	274	void neogeo_audio_cpu_banking_init();
	275	void set_audio_cpu_banking();
	276	void audio_cpu_bank_select( int region, UINT8 bank );
	277	void adjust_display_position_interrupt_timer();
	278	void neogeo_set_display_position_interrupt_control(UINT16 data);
	279	void neogeo_set_display_counter_msb(UINT16 data);
	280	void neogeo_set_display_counter_lsb(UINT16 data);
	281	void neogeo_set_main_cpu_vector_table_source( UINT8 data );
	282	void set_video_control( UINT16 data );
	283	void _set_audio_cpu_rom_source();
	284	void set_audio_cpu_rom_source( UINT8 data );
	285	void _set_main_cpu_vector_table_source();
247	286	};
248	287
249	288
250	289	/*----------- defined in drivers/neogeo.c -----------*/
251	290
252	291	MACHINE_CONFIG_EXTERN( neogeo_base );
253		void neogeo_set_display_position_interrupt_control(running_machine &machine, UINT16 data);
254		void neogeo_set_display_counter_msb(address_space &space, UINT16 data);
255		void neogeo_set_display_counter_lsb(address_space &space, UINT16 data);
256		void neogeo_acknowledge_interrupt(running_machine &machine, UINT16 data);
257		void neogeo_set_main_cpu_bank_address(address_space &space, UINT32 bank_address);
258		void neogeo_audio_cpu_banking_init( running_machine &machine );
259		void neogeo_main_cpu_banking_init( running_machine &machine );
260		void neogeo_set_main_cpu_vector_table_source( running_machine &machine, UINT8 data );
261	292
262	293	/*----------- defined in machine/neocrypt.c -----------*/
263	294

trunk/src/mame/video/neogeo.c

r20891	r20892
776	776	}
777	777
778	778
779		static void set_video_control( running_machine &machine, UINT16 data )
	779	void neogeo_state::set_video_control( UINT16 data )
780	780	{
781	781	/* this does much more than this, but I'm not sure exactly what */
782		if (VERBOSE) logerror("%s: video control write %04x\n", machine.describe_context(), data);
	782	if (VERBOSE) logerror("%s: video control write %04x\n", machine().describe_context(), data);
783	783
784		set_auto_animation_speed(machine, data >> 8);
785		set_auto_animation_disabled(machine, data & 0x0008);
	784	set_auto_animation_speed(machine(), data >> 8);
	785	set_auto_animation_disabled(machine(), data & 0x0008);
786	786
787		neogeo_set_display_position_interrupt_control(machine, data & 0x00f0);
	787	neogeo_set_display_position_interrupt_control(data & 0x00f0);
788	788	}
789	789
790	790
r20891	r20892
825	825	case 0x00: set_videoram_offset(machine(), data); break;
826	826	case 0x01: set_videoram_data(machine(), data); break;
827	827	case 0x02: set_videoram_modulo(machine(), data); break;
828		case 0x03: set_video_control(machine(), data); break;
829		case 0x04: neogeo_set_display_counter_msb(space, data); break;
830		case 0x05: neogeo_set_display_counter_lsb(space, data); break;
831		case 0x06: neogeo_acknowledge_interrupt(machine(), data); break;
	828	case 0x03: set_video_control(data); break;
	829	case 0x04: neogeo_set_display_counter_msb(data); break;
	830	case 0x05: neogeo_set_display_counter_lsb(data); break;
	831	case 0x06: neogeo_acknowledge_interrupt(data); break;
832	832	case 0x07: break; /* unknown, see get_video_control */
833	833	}
834	834	}

trunk/src/mame/drivers/neogeo.c

r20891	r20892
196	196	#define IRQ2CTRL_AUTOLOAD_REPEAT    (0x80)
197	197
198	198
199		static void adjust_display_position_interrupt_timer( running_machine &machine )
	199	void neogeo_state::adjust_display_position_interrupt_timer()
200	200	{
201		neogeo_state *state = machine.driver_data<neogeo_state>();
202
203		if ((state->m_display_counter + 1) != 0)
	201	if ((m_display_counter + 1) != 0)
204	202	{
205		attotime period = attotime::from_hz(NEOGEO_PIXEL_CLOCK) * (state->m_display_counter + 1);
206		if (LOG_VIDEO_SYSTEM) logerror("adjust_display_position_interrupt_timer  current y: %02x  current x: %02x   target y: %x  target x: %x\n", machine.primary_screen->vpos(), machine.primary_screen->hpos(), (state->m_display_counter + 1) / NEOGEO_HTOTAL, (state->m_display_counter + 1) % NEOGEO_HTOTAL);
	203	attotime period = attotime::from_hz(NEOGEO_PIXEL_CLOCK) * (m_display_counter + 1);
	204	if (LOG_VIDEO_SYSTEM) logerror("adjust_display_position_interrupt_timer  current y: %02x  current x: %02x   target y: %x  target x: %x\n", machine().primary_screen->vpos(), machine().primary_screen->hpos(), (m_display_counter + 1) / NEOGEO_HTOTAL, (m_display_counter + 1) % NEOGEO_HTOTAL);
207	205
208		state->m_display_position_interrupt_timer->adjust(period);
	206	m_display_position_interrupt_timer->adjust(period);
209	207	}
210	208	}
211	209
212	210
213		void neogeo_set_display_position_interrupt_control( running_machine &machine, UINT16 data )
	211	void neogeo_state::neogeo_set_display_position_interrupt_control( UINT16 data )
214	212	{
215		neogeo_state *state = machine.driver_data<neogeo_state>();
216		state->m_display_position_interrupt_control = data;
	213	m_display_position_interrupt_control = data;
217	214	}
218	215
219	216
220		void neogeo_set_display_counter_msb( address_space &space, UINT16 data )
	217	void neogeo_state::neogeo_set_display_counter_msb( UINT16 data )
221	218	{
222		neogeo_state *state = space.machine().driver_data<neogeo_state>();
	219	m_display_counter = (m_display_counter & 0x0000ffff) | ((UINT32)data << 16);
223	220
224		state->m_display_counter = (state->m_display_counter & 0x0000ffff) | ((UINT32)data << 16);
225
226		if (LOG_VIDEO_SYSTEM) logerror("PC %06x: set_display_counter %08x\n", space.device().safe_pc(), state->m_display_counter);
	221	if (LOG_VIDEO_SYSTEM) logerror("PC %06x: set_display_counter %08x\n", m_maincpu->pc(), m_display_counter);
227	222	}
228	223
229	224
230		void neogeo_set_display_counter_lsb( address_space &space, UINT16 data )
	225	void neogeo_state::neogeo_set_display_counter_lsb( UINT16 data )
231	226	{
232		neogeo_state *state = space.machine().driver_data<neogeo_state>();
	227	m_display_counter = (m_display_counter & 0xffff0000) | data;
233	228
234		state->m_display_counter = (state->m_display_counter & 0xffff0000) | data;
	229	if (LOG_VIDEO_SYSTEM) logerror("PC %06x: set_display_counter %08x\n", m_maincpu->pc(), m_display_counter);
235	230
236		if (LOG_VIDEO_SYSTEM) logerror("PC %06x: set_display_counter %08x\n", space.device().safe_pc(), state->m_display_counter);
237
238		if (state->m_display_position_interrupt_control & IRQ2CTRL_LOAD_RELATIVE)
	231	if (m_display_position_interrupt_control & IRQ2CTRL_LOAD_RELATIVE)
239	232	{
240	233	if (LOG_VIDEO_SYSTEM) logerror("AUTOLOAD_RELATIVE ");
241		adjust_display_position_interrupt_timer(space.machine());
	234	adjust_display_position_interrupt_timer();
242	235	}
243	236	}
244	237
245	238
246		void neogeo_state::update_interrupts( running_machine &machine )
	239	void neogeo_state::update_interrupts()
247	240	{
248		neogeo_state *state = machine.driver_data<neogeo_state>();
249
250		machine.device("maincpu")->execute().set_input_line(state->m_vblank_level, state->m_vblank_interrupt_pending ? ASSERT_LINE : CLEAR_LINE);
251		machine.device("maincpu")->execute().set_input_line(state->m_raster_level, state->m_display_position_interrupt_pending ? ASSERT_LINE : CLEAR_LINE);
252		machine.device("maincpu")->execute().set_input_line(3, state->m_irq3_pending ? ASSERT_LINE : CLEAR_LINE);
	241	m_maincpu->set_input_line(m_vblank_level, m_vblank_interrupt_pending ? ASSERT_LINE : CLEAR_LINE);
	242	m_maincpu->set_input_line(m_raster_level, m_display_position_interrupt_pending ? ASSERT_LINE : CLEAR_LINE);
	243	m_maincpu->set_input_line(3, m_irq3_pending ? ASSERT_LINE : CLEAR_LINE);
253	244	}
254	245
255	246
256		void neogeo_acknowledge_interrupt( running_machine &machine, UINT16 data )
	247	void neogeo_state::neogeo_acknowledge_interrupt( UINT16 data )
257	248	{
258		neogeo_state *state = machine.driver_data<neogeo_state>();
259
260	249	if (data & 0x01)
261		state->m_irq3_pending = 0;
	250	m_irq3_pending = 0;
262	251	if (data & 0x02)
263		state->m_display_position_interrupt_pending = 0;
	252	m_display_position_interrupt_pending = 0;
264	253	if (data & 0x04)
265		state->m_vblank_interrupt_pending = 0;
	254	m_vblank_interrupt_pending = 0;
266	255
267		state->update_interrupts(machine);
	256	update_interrupts();
268	257	}
269	258
270	259
r20891	r20892
277	266	if (LOG_VIDEO_SYSTEM) logerror("*** Scanline interrupt (IRQ2) ***  y: %02x  x: %02x\n", machine().primary_screen->vpos(), machine().primary_screen->hpos());
278	267	m_display_position_interrupt_pending = 1;
279	268
280		update_interrupts(machine());
	269	update_interrupts();
281	270	}
282	271
283	272	if (m_display_position_interrupt_control & IRQ2CTRL_AUTOLOAD_REPEAT)
284	273	{
285	274	if (LOG_VIDEO_SYSTEM) logerror("AUTOLOAD_REPEAT ");
286		adjust_display_position_interrupt_timer(machine());
	275	adjust_display_position_interrupt_timer();
287	276	}
288	277	}
289	278
r20891	r20892
293	282	if (m_display_position_interrupt_control & IRQ2CTRL_AUTOLOAD_VBLANK)
294	283	{
295	284	if (LOG_VIDEO_SYSTEM) logerror("AUTOLOAD_VBLANK ");
296		adjust_display_position_interrupt_timer(machine());
	285	adjust_display_position_interrupt_timer();
297	286	}
298	287
299	288	/* set timer for next screen */
r20891	r20892
310	299
311	300	m_vblank_interrupt_pending = 1;
312	301
313		update_interrupts(machine());
	302	update_interrupts();
314	303
315	304	/* set timer for next screen */
316	305	m_vblank_interrupt_timer->adjust(machine().primary_screen->time_until_pos(NEOGEO_VBSTART));
317	306	}
318	307
319	308
320		void neogeo_state::create_interrupt_timers( running_machine &machine )
	309	void neogeo_state::create_interrupt_timers()
321	310	{
322		neogeo_state *state = machine.driver_data<neogeo_state>();
323		state->m_display_position_interrupt_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(neogeo_state::display_position_interrupt_callback),state));
324		state->m_display_position_vblank_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(neogeo_state::display_position_vblank_callback),state));
325		state->m_vblank_interrupt_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(neogeo_state::vblank_interrupt_callback),state));
	311	m_display_position_interrupt_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(neogeo_state::display_position_interrupt_callback),this));
	312	m_display_position_vblank_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(neogeo_state::display_position_vblank_callback),this));
	313	m_vblank_interrupt_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(neogeo_state::vblank_interrupt_callback),this));
326	314	}
327	315
328	316
329		void neogeo_state::start_interrupt_timers( running_machine &machine )
	317	void neogeo_state::start_interrupt_timers()
330	318	{
331		neogeo_state *state = machine.driver_data<neogeo_state>();
332		state->m_vblank_interrupt_timer->adjust(machine.primary_screen->time_until_pos(NEOGEO_VBSTART));
333		state->m_display_position_vblank_timer->adjust(machine.primary_screen->time_until_pos(NEOGEO_VBSTART, NEOGEO_VBLANK_RELOAD_HPOS));
	319	m_vblank_interrupt_timer->adjust(machine().primary_screen->time_until_pos(NEOGEO_VBSTART));
	320	m_display_position_vblank_timer->adjust(machine().primary_screen->time_until_pos(NEOGEO_VBSTART, NEOGEO_VBLANK_RELOAD_HPOS));
334	321	}
335	322
336	323
r20891	r20892
607	594	{
608	595	UINT32 ret = m_audio_result;
609	596
610		//  if (LOG_CPU_COMM) logerror("MAIN CPU PC %06x: audio_result_r %02x\n", machine().device("maincpu")->safe_pc(), ret);
	597	//  if (LOG_CPU_COMM) logerror("MAIN CPU PC %06x: audio_result_r %02x\n", m_maincpu->pc(), ret);
611	598
612	599	return ret;
613	600	}
r20891	r20892
620	607	*
621	608	*************************************/
622	609
623		static void _set_main_cpu_vector_table_source( running_machine &machine )
	610	void neogeo_state::_set_main_cpu_vector_table_source()
624	611	{
625		neogeo_state *state = machine.driver_data<neogeo_state>();
626		state->membank(NEOGEO_BANK_VECTORS)->set_entry(state->m_main_cpu_vector_table_source);
	612	m_bank_vectors->set_entry(m_main_cpu_vector_table_source);
627	613	}
628	614
629	615
630	616
631		void neogeo_set_main_cpu_vector_table_source( running_machine &machine, UINT8 data )
	617	void neogeo_state::neogeo_set_main_cpu_vector_table_source( UINT8 data )
632	618	{
633		neogeo_state *state = machine.driver_data<neogeo_state>();
634		state->m_main_cpu_vector_table_source = data;
	619	m_main_cpu_vector_table_source = data;
635	620
636		_set_main_cpu_vector_table_source(machine);
	621	_set_main_cpu_vector_table_source();
637	622	}
638	623
639	624
640		static void _set_main_cpu_bank_address( running_machine &machine )
	625	void neogeo_state::_set_main_cpu_bank_address()
641	626	{
642		neogeo_state *state = machine.driver_data<neogeo_state>();
643		if (!state->m_is_cartsys) return;
	627	if (!m_is_cartsys) return;
644	628
645		state->membank(NEOGEO_BANK_CARTRIDGE)->set_base(&state->memregion("maincpu")->base()[state->m_main_cpu_bank_address]);
	629	m_bank_cartridge->set_base(m_region_maincpu->base() + m_main_cpu_bank_address);
646	630	}
647	631
648	632
649		void neogeo_set_main_cpu_bank_address( address_space &space, UINT32 bank_address )
	633	void neogeo_state::neogeo_set_main_cpu_bank_address( UINT32 bank_address )
650	634	{
651		neogeo_state *state = space.machine().driver_data<neogeo_state>();
	635	if (LOG_MAIN_CPU_BANKING) logerror("MAIN CPU PC %06x: neogeo_set_main_cpu_bank_address %06x\n", m_maincpu->pc(), bank_address);
652	636
653		if (LOG_MAIN_CPU_BANKING) logerror("MAIN CPU PC %06x: neogeo_set_main_cpu_bank_address %06x\n", space.device().safe_pc(), bank_address);
	637	m_main_cpu_bank_address = bank_address;
654	638
655		state->m_main_cpu_bank_address = bank_address;
656
657		_set_main_cpu_bank_address(space.machine());
	639	_set_main_cpu_bank_address();
658	640	}
659	641
660	642
r20891	r20892
662	644	WRITE16_MEMBER(neogeo_state::main_cpu_bank_select_w)
663	645	{
664	646	UINT32 bank_address;
665		UINT32 len = memregion("maincpu")->bytes();
	647	UINT32 len = m_region_maincpu->bytes();
666	648
667	649	if ((len <= 0x100000) && (data & 0x07))
668	650	logerror("PC %06x: warning: bankswitch to %02x but no banks available\n", space.device().safe_pc(), data);
r20891	r20892
676	658	bank_address = 0x100000;
677	659	}
678	660
679		neogeo_set_main_cpu_bank_address(space, bank_address);
	661	neogeo_set_main_cpu_bank_address(bank_address);
680	662	}
681	663	}
682	664
683	665
684	666
685	667
686		void neogeo_main_cpu_banking_init( running_machine &machine )
	668	void neogeo_state::neogeo_main_cpu_banking_init()
687	669	{
688		neogeo_state *state = machine.driver_data<neogeo_state>();
689		address_space &mainspace = machine.device("maincpu")->memory().space(AS_PROGRAM);
690
691	670	/* create vector banks */
692		state->membank(NEOGEO_BANK_VECTORS)->configure_entry(0, machine.root_device().memregion("mainbios")->base());
693		state->membank(NEOGEO_BANK_VECTORS)->configure_entry(1, machine.root_device().memregion("maincpu")->base());
	671	m_bank_vectors->configure_entry(0, machine().root_device().memregion("mainbios")->base());
	672	m_bank_vectors->configure_entry(1, m_region_maincpu->base());
694	673
695		if (state->m_is_cartsys)
	674	if (m_is_cartsys)
696	675	{
697	676	/* set initial main CPU bank */
698		if (machine.root_device().memregion("maincpu")->bytes() > 0x100000)
699		neogeo_set_main_cpu_bank_address(mainspace, 0x100000);
	677	if (m_region_maincpu->bytes() > 0x100000)
	678	neogeo_set_main_cpu_bank_address(0x100000);
700	679	else
701		neogeo_set_main_cpu_bank_address(mainspace, 0x000000);
	680	neogeo_set_main_cpu_bank_address(0x000000);
702	681	}
703	682	}
704	683
r20891	r20892
709	688	*
710	689	*************************************/
711	690
712		static void set_audio_cpu_banking( running_machine &machine )
	691	void neogeo_state::set_audio_cpu_banking()
713	692	{
714		neogeo_state *state = machine.driver_data<neogeo_state>();
	693	if (!m_has_audio_banking) return;
715	694
716		if (!state->m_has_audio_banking) return;
717
718	695	int region;
719	696
720	697	for (region = 0; region < 4; region++)
721		state->membank(audio_banks[region])->set_entry(state->m_audio_cpu_banks[region]);
	698	m_bank_audio_cart[region]->set_entry(m_audio_cpu_banks[region]);
722	699	}
723	700
724	701
725	702
726		static void audio_cpu_bank_select( address_space &space, int region, UINT8 bank )
	703	void neogeo_state::audio_cpu_bank_select( int region, UINT8 bank )
727	704	{
728		neogeo_state *state = space.machine().driver_data<neogeo_state>();
	705	if (!m_has_audio_banking) return;
729	706
730		if (!state->m_has_audio_banking) return;
	707	if (LOG_AUDIO_CPU_BANKING) logerror("Audio CPU PC %03x: audio_cpu_bank_select: Region: %d   Bank: %02x\n", m_audiocpu->pc(), region, bank);
731	708
732		if (LOG_AUDIO_CPU_BANKING) logerror("Audio CPU PC %03x: audio_cpu_bank_select: Region: %d   Bank: %02x\n", space.device().safe_pc(), region, bank);
	709	m_audio_cpu_banks[region] = bank;
733	710
734		state->m_audio_cpu_banks[region] = bank;
735
736		set_audio_cpu_banking(space.machine());
	711	set_audio_cpu_banking();
737	712	}
738	713
739	714
740	715
741	716	READ8_MEMBER(neogeo_state::audio_cpu_bank_select_f000_f7ff_r)
742	717	{
743		audio_cpu_bank_select(space, 0, offset >> 8);
	718	audio_cpu_bank_select(0, offset >> 8);
744	719
745	720	return 0;
746	721	}
r20891	r20892
748	723
749	724	READ8_MEMBER(neogeo_state::audio_cpu_bank_select_e000_efff_r)
750	725	{
751		audio_cpu_bank_select(space, 1, offset >> 8);
	726	audio_cpu_bank_select(1, offset >> 8);
752	727
753	728	return 0;
754	729	}
r20891	r20892
756	731
757	732	READ8_MEMBER(neogeo_state::audio_cpu_bank_select_c000_dfff_r)
758	733	{
759		audio_cpu_bank_select(space, 2, offset >> 8);
	734	audio_cpu_bank_select(2, offset >> 8);
760	735
761	736	return 0;
762	737	}
r20891	r20892
764	739
765	740	READ8_MEMBER(neogeo_state::audio_cpu_bank_select_8000_bfff_r)
766	741	{
767		audio_cpu_bank_select(space, 3, offset >> 8);
	742	audio_cpu_bank_select(3, offset >> 8);
768	743
769	744	return 0;
770	745	}
771	746
772	747
773		static void _set_audio_cpu_rom_source( address_space &space )
	748	void neogeo_state::_set_audio_cpu_rom_source()
774	749	{
775		neogeo_state *state = space.machine().driver_data<neogeo_state>();
776		if (!state->m_has_audio_banking) return;
	750	if (!m_has_audio_banking) return;
777	751
778		/*  if (!state->memregion("audiobios")->base())   */
779		state->m_audio_cpu_rom_source = 1;
	752	/*  if (!memregion("audiobios")->base())   */
	753	m_audio_cpu_rom_source = 1;
780	754
781		state->membank(NEOGEO_BANK_AUDIO_CPU_MAIN_BANK)->set_entry(state->m_audio_cpu_rom_source);
	755	m_bank_audio_main->set_entry(m_audio_cpu_rom_source);
782	756
783	757	/* reset CPU if the source changed -- this is a guess */
784		if (state->m_audio_cpu_rom_source != state->m_audio_cpu_rom_source_last)
	758	if (m_audio_cpu_rom_source != m_audio_cpu_rom_source_last)
785	759	{
786		state->m_audio_cpu_rom_source_last = state->m_audio_cpu_rom_source;
	760	m_audio_cpu_rom_source_last = m_audio_cpu_rom_source;
787	761
788		space.machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE);
	762	m_audiocpu->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
789	763
790		if (LOG_AUDIO_CPU_BANKING) logerror("Audio CPU PC %03x: selecting %s ROM\n", space.device().safe_pc(), state->m_audio_cpu_rom_source ? "CARTRIDGE" : "BIOS");
	764	if (LOG_AUDIO_CPU_BANKING) logerror("Audio CPU PC %03x: selecting %s ROM\n", m_audiocpu->pc(), m_audio_cpu_rom_source ? "CARTRIDGE" : "BIOS");
791	765	}
792	766	}
793	767
794	768
795	769
796	770
797		static void set_audio_cpu_rom_source( address_space &space, UINT8 data )
	771	void neogeo_state::set_audio_cpu_rom_source( UINT8 data )
798	772	{
799		neogeo_state *state = space.machine().driver_data<neogeo_state>();
800		state->m_audio_cpu_rom_source = data;
801
802		_set_audio_cpu_rom_source(space);
	773	m_audio_cpu_rom_source = data;
	774	_set_audio_cpu_rom_source();
803	775	}
804	776
805	777
806	778
807	779
808	780
809		void neogeo_audio_cpu_banking_init( running_machine &machine )
	781	void neogeo_state::neogeo_audio_cpu_banking_init()
810	782	{
811		neogeo_state *state = machine.driver_data<neogeo_state>();
812		if (!state->m_has_audio_banking) return;
	783	if (!m_has_audio_banking) return;
813	784
814	785	int region;
815	786	int bank;
r20891	r20892
817	788	UINT32 address_mask;
818	789
819	790	/* audio bios/cartridge selection */
820		if (state->memregion("audiobios")->base())
821		state->membank(NEOGEO_BANK_AUDIO_CPU_MAIN_BANK)->configure_entry(0, state->memregion("audiobios")->base());
822		state->membank(NEOGEO_BANK_AUDIO_CPU_MAIN_BANK)->configure_entry(1, state->memregion("audiocpu")->base());
	791	if (memregion("audiobios")->base())
	792	m_bank_audio_main->configure_entry(0, memregion("audiobios")->base());
	793	m_bank_audio_main->configure_entry(1, memregion("audiocpu")->base());
823	794
824	795	/* audio banking */
825		address_mask = state->memregion("audiocpu")->bytes() - 0x10000 - 1;
	796	address_mask = memregion("audiocpu")->bytes() - 0x10000 - 1;
826	797
827		rgn = state->memregion("audiocpu")->base();
	798	rgn = memregion("audiocpu")->base();
828	799	for (region = 0; region < 4; region++)
829	800	{
	801	m_bank_audio_cart[region] = membank(audio_banks[region]);
830	802	for (bank = 0; bank < 0x100; bank++)
831	803	{
832	804	UINT32 bank_address = 0x10000 + (((bank << (11 + region)) & 0x3ffff) & address_mask);
833		state->membank(audio_banks[region])->configure_entry(bank, &rgn[bank_address]);
	805	m_bank_audio_cart[region]->configure_entry(bank, &rgn[bank_address]);
834	806	}
835	807	}
836	808
837	809	/* set initial audio banks --
838	810	how does this really work, or is it even necessary? */
839		state->m_audio_cpu_banks[0] = 0x1e;
840		state->m_audio_cpu_banks[1] = 0x0e;
841		state->m_audio_cpu_banks[2] = 0x06;
842		state->m_audio_cpu_banks[3] = 0x02;
	811	m_audio_cpu_banks[0] = 0x1e;
	812	m_audio_cpu_banks[1] = 0x0e;
	813	m_audio_cpu_banks[2] = 0x06;
	814	m_audio_cpu_banks[3] = 0x02;
843	815
844		set_audio_cpu_banking(machine);
	816	set_audio_cpu_banking();
845	817
846		state->m_audio_cpu_rom_source_last = 0;
847		set_audio_cpu_rom_source(machine.device("maincpu")->memory().space(AS_PROGRAM), 0);
	818	m_audio_cpu_rom_source_last = 0;
	819	set_audio_cpu_rom_source(0);
848	820	}
849	821
850	822
r20891	r20892
870	842	case 0x01:
871	843	if (m_is_cartsys)
872	844	{
873		neogeo_set_main_cpu_vector_table_source(machine(), bit); // NeoCD maps the vector swap elsewhere
	845	neogeo_set_main_cpu_vector_table_source(bit); // NeoCD maps the vector swap elsewhere
874	846	}
875	847	else
876	848	{
r20891	r20892
878	850	if (bit)
879	851	{
880	852	if (m_main_cpu_vector_table_source)
881		neogeo_set_main_cpu_vector_table_source(machine(), 0);
	853	neogeo_set_main_cpu_vector_table_source(0);
882	854	else
883		neogeo_set_main_cpu_vector_table_source(machine(), 1);
	855	neogeo_set_main_cpu_vector_table_source(1);
884	856	}
885	857	#endif
886	858	printf("NeoCD: write to regular vector change address? %d\n", bit); // what IS going on with "neocdz doubledr" and why do games write here if it's hooked up to nothing?
887	859	}
888		if (m_has_audio_banking) set_audio_cpu_rom_source(space, bit); /* this is a guess */
	860	if (m_has_audio_banking) set_audio_cpu_rom_source(bit); /* this is a guess */
889	861	break;
890	862	case 0x05: neogeo_set_fixed_layer_source(machine(), bit); break;
891	863	case 0x06: if (m_is_mvs) set_save_ram_unlock(machine(), bit); break;
r20891	r20892
1015	987
1016	988	void neogeo_state::neogeo_postload()
1017	989	{
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));
	990	_set_main_cpu_bank_address();
	991	_set_main_cpu_vector_table_source();
	992	set_audio_cpu_banking();
	993	_set_audio_cpu_rom_source();
1022	994	if (m_is_mvs) set_outputs(machine());
1023	995	}
1024	996
r20891	r20892
1033	1005	machine().device<nvram_device>("saveram")->set_base(m_save_ram, 0x10000);
1034	1006
1035	1007	/* set the BIOS bank */
1036		membank(NEOGEO_BANK_BIOS)->set_base(memregion("mainbios")->base());
	1008	m_bank_bios->set_base(memregion("mainbios")->base());
1037	1009
1038	1010	/* set the initial main CPU bank */
1039		neogeo_main_cpu_banking_init(machine());
	1011	neogeo_main_cpu_banking_init();
1040	1012
1041	1013	/* set the initial audio CPU ROM banks */
1042		neogeo_audio_cpu_banking_init(machine());
	1014	neogeo_audio_cpu_banking_init();
1043	1015
1044		create_interrupt_timers(machine());
	1016	create_interrupt_timers();
1045	1017
1046	1018	/* initialize the memcard data structure */
1047	1019	memcard_data = auto_alloc_array_clear(machine(), UINT8, MEMCARD_SIZE);
r20891	r20892
1053	1025	/* start with an IRQ3 - but NOT on a reset */
1054	1026	m_irq3_pending = 1;
1055	1027
1056		/* get devices */
1057		m_maincpu = machine().device<cpu_device>("maincpu");
1058		m_audiocpu = machine().device<cpu_device>("audiocpu");
1059		m_upd4990a = machine().device("upd4990a");
1060
1061	1028	/* register state save */
1062	1029	save_item(NAME(m_display_position_interrupt_control));
1063	1030	save_item(NAME(m_display_counter));
r20891	r20892
1094	1061	void neogeo_state::machine_reset()
1095	1062	{
1096	1063	offs_t offs;
1097		address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
	1064	address_space &space = m_maincpu->space(AS_PROGRAM);
1098	1065
1099	1066	/* reset system control registers */
1100	1067	for (offs = 0; offs < 8; offs++)
1101	1068	system_control_w(space, offs, 0, 0x00ff);
1102	1069
1103		machine().device("maincpu")->reset();
	1070	m_maincpu->reset();
1104	1071
1105	1072	neogeo_reset_rng(machine());
1106	1073
1107		start_interrupt_timers(machine());
	1074	start_interrupt_timers();
1108	1075
1109	1076	/* trigger the IRQ3 that was set by MACHINE_START */
1110		update_interrupts(machine());
	1077	update_interrupts();
1111	1078
1112	1079	m_recurse = 0;
1113	1080
r20891	r20892
1326	1293	{
1327	1294	// create memory regions
1328	1295	size = image.get_software_region_length("maincpu");
1329		image.device().machine().memory().region_free(":maincpu");
1330		image.device().machine().memory().region_alloc(":maincpu",size, 2, ENDIANNESS_BIG);
1331		memcpy(image.device().machine().root_device().memregion("maincpu")->base(),image.get_software_region("maincpu"),size);
1332
	1296	machine().memory().region_free(":maincpu");
	1297	machine().memory().region_alloc(":maincpu",size, 2, ENDIANNESS_BIG);
	1298	memcpy(memregion("maincpu")->base(),image.get_software_region("maincpu"),size);
	1299	// Reset the reference to the region
	1300	m_region_maincpu.findit();
1333	1301	// for whatever reason (intentional, or design flaw) software loaded via software lists is swapped in endianess vs. the standard ROM loading, regardless of the above.  Swap it to keep consistency
1334	1302	for (int i=0; i<size/2;i++)
1335	1303	{
1336		UINT16* ROM = (UINT16*)image.device().machine().root_device().memregion("maincpu")->base();
	1304	UINT16* ROM = (UINT16*)memregion("maincpu")->base();
1337	1305	ROM[i] = ((ROM[i]&0xff00)>>8) | ((ROM[i]&0x00ff)<<8);
1338	1306	}
1339	1307
1340	1308	size = image.get_software_region_length("fixed");
1341		image.device().machine().memory().region_free(":fixed");
1342		image.device().machine().memory().region_alloc(":fixed",size,1, ENDIANNESS_LITTLE);
1343		memcpy(image.device().machine().root_device().memregion("fixed")->base(),image.get_software_region("fixed"),size);
	1309	machine().memory().region_free(":fixed");
	1310	machine().memory().region_alloc(":fixed",size,1, ENDIANNESS_LITTLE);
	1311	memcpy(memregion("fixed")->base(),image.get_software_region("fixed"),size);
1344	1312
1345	1313	if(image.get_software_region("audiocpu") != NULL)
1346	1314	{
1347	1315	size = image.get_software_region_length("audiocpu");
1348		image.device().machine().memory().region_free(":audiocpu");
1349		image.device().machine().memory().region_alloc(":audiocpu",size+0x10000,1, ENDIANNESS_LITTLE);
1350		memcpy(image.device().machine().root_device().memregion("audiocpu")->base(),image.get_software_region("audiocpu"),size);
1351		memcpy(image.device().machine().root_device().memregion("audiocpu")->base()+0x10000,image.get_software_region("audiocpu"),size); // avoid reloading in XML, should just improve banking instead tho?
	1316	machine().memory().region_free(":audiocpu");
	1317	machine().memory().region_alloc(":audiocpu",size+0x10000,1, ENDIANNESS_LITTLE);
	1318	memcpy(machine().root_device().memregion("audiocpu")->base(),image.get_software_region("audiocpu"),size);
	1319	memcpy(machine().root_device().memregion("audiocpu")->base()+0x10000,image.get_software_region("audiocpu"),size); // avoid reloading in XML, should just improve banking instead tho?
1352	1320	}
1353	1321
1354	1322
1355	1323	size = image.get_software_region_length("ymsnd");
1356		image.device().machine().memory().region_free(":ymsnd");
1357		image.device().machine().memory().region_alloc(":ymsnd",size,1, ENDIANNESS_LITTLE);
1358		memcpy(image.device().machine().root_device().memregion("ymsnd")->base(),image.get_software_region("ymsnd"),size);
	1324	machine().memory().region_free(":ymsnd");
	1325	machine().memory().region_alloc(":ymsnd",size,1, ENDIANNESS_LITTLE);
	1326	memcpy(machine().root_device().memregion("ymsnd")->base(),image.get_software_region("ymsnd"),size);
1359	1327	if(image.get_software_region("ymsnd.deltat") != NULL)
1360	1328	{
1361	1329	size = image.get_software_region_length("ymsnd.deltat");
1362		image.device().machine().memory().region_free(":ymsnd.deltat");
1363		image.device().machine().memory().region_alloc(":ymsnd.deltat",size,1, ENDIANNESS_LITTLE);
1364		memcpy(image.device().machine().root_device().memregion("ymsnd.deltat")->base(),image.get_software_region("ymsnd.deltat"),size);
	1330	machine().memory().region_free(":ymsnd.deltat");
	1331	machine().memory().region_alloc(":ymsnd.deltat",size,1, ENDIANNESS_LITTLE);
	1332	memcpy(machine().root_device().memregion("ymsnd.deltat")->base(),image.get_software_region("ymsnd.deltat"),size);
1365	1333	}
1366	1334	else
1367		image.device().machine().memory().region_free(":ymsnd.deltat");  // removing the region will fix sound glitches in non-Delta-T games
	1335	machine().memory().region_free(":ymsnd.deltat");  // removing the region will fix sound glitches in non-Delta-T games
1368	1336	ym->reset();
1369	1337	size = image.get_software_region_length("sprites");
1370		image.device().machine().memory().region_free(":sprites");
1371		image.device().machine().memory().region_alloc(":sprites",size,1, ENDIANNESS_LITTLE);
1372		memcpy(image.device().machine().root_device().memregion("sprites")->base(),image.get_software_region("sprites"),size);
	1338	machine().memory().region_free(":sprites");
	1339	machine().memory().region_alloc(":sprites",size,1, ENDIANNESS_LITTLE);
	1340	memcpy(machine().root_device().memregion("sprites")->base(),image.get_software_region("sprites"),size);
1373	1341	if(image.get_software_region("audiocrypt") != NULL)  // encrypted Z80 code
1374	1342	{
1375	1343	size = image.get_software_region_length("audiocrypt");
1376		image.device().machine().memory().region_alloc(":audiocrypt",size,1, ENDIANNESS_LITTLE);
1377		memcpy(image.device().machine().root_device().memregion("audiocrypt")->base(),image.get_software_region("audiocrypt"),size);
	1344	machine().memory().region_alloc(":audiocrypt",size,1, ENDIANNESS_LITTLE);
	1345	memcpy(machine().root_device().memregion("audiocrypt")->base(),image.get_software_region("audiocrypt"),size);
1378	1346	// allocate the audiocpu region to decrypt data into
1379		image.device().machine().memory().region_free(":audiocpu");
1380		image.device().machine().memory().region_alloc(":audiocpu",size+0x10000,1, ENDIANNESS_LITTLE);
	1347	machine().memory().region_free(":audiocpu");
	1348	machine().memory().region_alloc(":audiocpu",size+0x10000,1, ENDIANNESS_LITTLE);
1381	1349	}
1382	1350
1383	1351	// setup cartridge ROM area
1384		image.device().machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x000080,0x0fffff,"cart_rom");
1385		image.device().machine().root_device().membank("cart_rom")->set_base(&image.device().machine().root_device().memregion("maincpu")->base()[0x80]);
	1352	m_maincpu->space(AS_PROGRAM).install_read_bank(0x000080,0x0fffff,"cart_rom");
	1353	machine().root_device().membank("cart_rom")->set_base(m_region_maincpu->base() + 0x80);
1386	1354
1387	1355	// handle possible protection
1388		neogeo_state *state = image.device().machine().driver_data<neogeo_state>();
1389		state->mvs_install_protection(image);
	1356	mvs_install_protection(image);
1390	1357
1391	1358	return IMAGE_INIT_PASS;
1392	1359	}

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team