Previous

199869 Revisions

Next

r21027 Wednesday 13th February, 2013 at 13:19:20 UTC by Miodrag Milanović
Modernization of drivers part 22 (no whatsnew)

[src/mame/drivers]

aristmk4.c atarisy4.c bfcobra.c bfm_sc1.c bfm_sc2.c bfmsys85.c calchase.c chanbara.c cntsteer.c cobra.c cops.c deco156.c deco_ld.c diverboy.c egghunt.c enigma2.c firebeat.c firefox.c galpani3.c hornet.c igs011.c igs017.c igs_m027.c konamigq.c konamigv.c konamim2.c m63.c maxaflex.c mediagx.c mgolf.c mpu3.c mpu4vid.c mwarr.c olibochu.c pcxt.c pengadvb.c popobear.c queen.c royalmah.c sandscrp.c sangho.c sbrkout.c sfkick.c silvmil.c

trunk/src/mame/drivers/igs_m027.c

r21026	r21027
69	69	UINT32 screen_update_igs_majhong(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
70	70	UINT32 screen_update_fearless(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
71	71	INTERRUPT_GEN_MEMBER(igs_majhong_interrupt);
	72	void sdwx_gfx_decrypt();
	73	void pgm_create_dummy_internal_arm_region();
72	74	};
73	75
74	76
r21026	r21027
278	280
279	281
280	282
281		static void sdwx_gfx_decrypt(running_machine &machine)
	283	void igs_m027_state::sdwx_gfx_decrypt()
282	284	{
283	285	int i;
284	286	unsigned rom_size = 0x80000;
285		UINT8 *src = (UINT8 *) (machine.root_device().memregion("gfx1")->base());
286		UINT8 *result_data = auto_alloc_array(machine, UINT8, rom_size);
	287	UINT8 *src = (UINT8 *) (machine().root_device().memregion("gfx1")->base());
	288	UINT8 *result_data = auto_alloc_array(machine(), UINT8, rom_size);
287	289
288	290	for (i=0; i<rom_size; i++)
289	291	result_data[i] = src[BITSWAP24(i, 23,22,21,20,19,18,17,16,15,14,13,12,11,8,7,6,10,9,5,4,3,2,1,0)];
r21026	r21027
295	297	memcpy(src+i+0x100,result_data+i+0x080,0x80);
296	298	memcpy(src+i+0x180,result_data+i+0x180,0x80);
297	299	}
298		auto_free(machine, result_data);
	300	auto_free(machine(), result_data);
299	301	}
300	302
301	303	/***************************************************************************
r21026	r21027
840	842
841	843
842	844
843		static void pgm_create_dummy_internal_arm_region(running_machine &machine)
	845	void igs_m027_state::pgm_create_dummy_internal_arm_region()
844	846	{
845		UINT16 *temp16 = (UINT16 *)machine.root_device().memregion("maincpu")->base();
	847	UINT16 *temp16 = (UINT16 *)machine().root_device().memregion("maincpu")->base();
846	848
847	849	// fill with RX 14
848	850	int i;
r21026	r21027
875	877	DRIVER_INIT_MEMBER(igs_m027_state,sdwx)
876	878	{
877	879	sdwx_decrypt(machine());
878		sdwx_gfx_decrypt(machine());
879		pgm_create_dummy_internal_arm_region(machine());
	880	sdwx_gfx_decrypt();
	881	pgm_create_dummy_internal_arm_region();
880	882	}
881	883
882	884	DRIVER_INIT_MEMBER(igs_m027_state,klxyj)
883	885	{
884	886	klxyj_decrypt(machine());
885	887	//sdwx_gfx_decrypt(machine());
886		pgm_create_dummy_internal_arm_region(machine());
	888	pgm_create_dummy_internal_arm_region();
887	889	}
888	890
889	891	DRIVER_INIT_MEMBER(igs_m027_state,chessc2)
890	892	{
891	893	chessc2_decrypt(machine());
892	894	//sdwx_gfx_decrypt(machine());
893		pgm_create_dummy_internal_arm_region(machine());
	895	pgm_create_dummy_internal_arm_region();
894	896	}
895	897
896	898	DRIVER_INIT_MEMBER(igs_m027_state,hauntedh)
897	899	{
898	900	hauntedh_decrypt(machine());
899	901	//sdwx_gfx_decrypt(machine());
900		pgm_create_dummy_internal_arm_region(machine());
	902	pgm_create_dummy_internal_arm_region();
901	903	}
902	904
903	905	DRIVER_INIT_MEMBER(igs_m027_state,fearless)
904	906	{
905	907	fearless_decrypt(machine());
906	908	//sdwx_gfx_decrypt(machine());
907		pgm_create_dummy_internal_arm_region(machine());
	909	pgm_create_dummy_internal_arm_region();
908	910	}
909	911
910	912
r21026	r21027
912	914	{
913	915	lhzb4_decrypt(machine());
914	916	//sdwx_gfx_decrypt(machine());
915		pgm_create_dummy_internal_arm_region(machine());
	917	pgm_create_dummy_internal_arm_region();
916	918	}
917	919
918	920	DRIVER_INIT_MEMBER(igs_m027_state,mgfx)
919	921	{
920	922	mgfx_decrypt(machine());
921	923	//sdwx_gfx_decrypt(machine());
922		pgm_create_dummy_internal_arm_region(machine());
	924	pgm_create_dummy_internal_arm_region();
923	925	}
924	926
925	927	DRIVER_INIT_MEMBER(igs_m027_state,lhzb3)
926	928	{
927	929	lhzb3_decrypt(machine());
928	930	//sdwx_gfx_decrypt(machine());
929		pgm_create_dummy_internal_arm_region(machine());
	931	pgm_create_dummy_internal_arm_region();
930	932	}
931	933
932	934	DRIVER_INIT_MEMBER(igs_m027_state,sddz)
933	935	{
934	936	sddz_decrypt(machine());
935	937	//sdwx_gfx_decrypt(machine());
936		pgm_create_dummy_internal_arm_region(machine());
	938	pgm_create_dummy_internal_arm_region();
937	939	}
938	940
939	941	DRIVER_INIT_MEMBER(igs_m027_state,gonefsh2)
940	942	{
941	943	gonefsh2_decrypt(machine());
942	944	//sdwx_gfx_decrypt(machine());
943		pgm_create_dummy_internal_arm_region(machine());
	945	pgm_create_dummy_internal_arm_region();
944	946	}
945	947
946	948	DRIVER_INIT_MEMBER(igs_m027_state,bigd2)
947	949	{
948	950	big2_decrypt(machine());
949	951	//sdwx_gfx_decrypt(machine());
950		pgm_create_dummy_internal_arm_region(machine());
	952	pgm_create_dummy_internal_arm_region();
951	953	}
952	954
953	955	/***************************************************************************

trunk/src/mame/drivers/aristmk4.c

r21026	r21027
326	326	TIMER_CALLBACK_MEMBER(coin_input_reset);
327	327	TIMER_CALLBACK_MEMBER(hopper_reset);
328	328	TIMER_DEVICE_CALLBACK_MEMBER(aristmk4_pf);
	329	inline void uBackgroundColour();
329	330	};
330	331
331	332	/* Partial Cashcade protocol */
r21026	r21027
340	341	}
341	342	}
342	343
343		INLINE void uBackgroundColour(running_machine &machine)
	344	void aristmk4_state::uBackgroundColour()
344	345	{
345		aristmk4_state *state = machine.driver_data<aristmk4_state>();
346	346
347	347	/* SW7 can be set when the main door is open, this allows the colours for the background
348	348	to be adjusted whilst the machine is running.
r21026	r21027
350	350	There are 4 possible combinations for colour select via SW7, colours vary based on software installed.
351	351	*/
352	352
353		switch(state->ioport("SW7")->read())
	353	switch(ioport("SW7")->read())
354	354	{
355	355	case 0x00:
356	356	// restore defaults
357		memcpy(state->m_shapeRomPtr,state->m_shapeRom, sizeof(state->m_shapeRom)); // restore defaults, both switches off
	357	memcpy(m_shapeRomPtr,m_shapeRom, sizeof(m_shapeRom)); // restore defaults, both switches off
358	358	// OE enabled on both shapes
359	359	break;
360	360	case 0x01:
361	361	// unselect U22 via SW7. OE on U22 is low.
362		memset(&state->m_shapeRomPtr[0x4000],0xff,0x2000);          // fill unused space with 0xff
363		memcpy(&state->m_shapeRomPtr[0xa000],&state->m_shapeRom[0xa000], 0x2000); // restore defaults here
	362	memset(&m_shapeRomPtr[0x4000],0xff,0x2000);          // fill unused space with 0xff
	363	memcpy(&m_shapeRomPtr[0xa000],&m_shapeRom[0xa000], 0x2000); // restore defaults here
364	364	break;
365	365	case 0x02:
366	366	// unselect U47 via SW7. OE on U47 is low.
367		memcpy(&state->m_shapeRomPtr[0x4000],&state->m_shapeRom[0x4000], 0x2000);
368		memset(&state->m_shapeRomPtr[0xa000],0xff,0x2000);
	367	memcpy(&m_shapeRomPtr[0x4000],&m_shapeRom[0x4000], 0x2000);
	368	memset(&m_shapeRomPtr[0xa000],0xff,0x2000);
369	369	break;
370	370	case 0x03:
371	371	// unselect U47 & U22 via SW7. Both output enable low.
372		memset(&state->m_shapeRomPtr[0x4000],0xff,0x2000);
373		memset(&state->m_shapeRomPtr[0xa000],0xff,0x2000);
	372	memset(&m_shapeRomPtr[0x4000],0xff,0x2000);
	373	memset(&m_shapeRomPtr[0xa000],0xff,0x2000);
374	374	break;
375	375	}
376	376	}
r21026	r21027
393	393	color = ((m_mkiv_vram[count]) & 0xe0) >> 5;
394	394	tile = (m_mkiv_vram[count+1]|m_mkiv_vram[count]<<8) & 0x3ff;
395	395	bgtile = (m_mkiv_vram[count+1]|m_mkiv_vram[count]<<8) & 0xff; // first 256 tiles
396		uBackgroundColour(machine());   // read sw7
	396	uBackgroundColour();   // read sw7
397	397	gfx->decode(bgtile);    // force the machine to update only the first 256 tiles.
398	398	// as we only update the background, not the entire display.
399	399	flipx = ((m_mkiv_vram[count]) & 0x04);

trunk/src/mame/drivers/olibochu.c

r21026	r21027
88	88	virtual void palette_init();
89	89	UINT32 screen_update_olibochu(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
90	90	TIMER_DEVICE_CALLBACK_MEMBER(olibochu_scanline);
	91	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
91	92	};
92	93
93	94
r21026	r21027
168	169	m_bg_tilemap = &machine().tilemap().create(tilemap_get_info_delegate(FUNC(olibochu_state::get_bg_tile_info),this), TILEMAP_SCAN_ROWS, 8, 8, 32, 32);
169	170	}
170	171
171		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	172	void olibochu_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
172	173	{
173		olibochu_state *state = machine.driver_data<olibochu_state>();
174		UINT8 *spriteram = state->m_spriteram;
175		UINT8 *spriteram_2 = state->m_spriteram2;
	174	UINT8 *spriteram = m_spriteram;
	175	UINT8 *spriteram_2 = m_spriteram2;
176	176	int offs;
177	177
178	178	/* 16x16 sprites */
179		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	179	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
180	180	{
181	181	int attr = spriteram[offs + 1];
182	182	int code = spriteram[offs];
r21026	r21027
186	186	int sx = spriteram[offs + 3];
187	187	int sy = ((spriteram[offs + 2] + 8) & 0xff) - 8;
188	188
189		if (state->flip_screen())
	189	if (flip_screen())
190	190	{
191	191	sx = 240 - sx;
192	192	sy = 240 - sy;
r21026	r21027
195	195	}
196	196
197	197	drawgfx_transpen(bitmap, cliprect,
198		machine.gfx[1],
	198	machine().gfx[1],
199	199	code, color,
200	200	flipx, flipy,
201	201	sx, sy, 0);
202	202	}
203	203
204	204	/* 8x8 sprites */
205		for (offs = 0; offs < state->m_spriteram2.bytes(); offs += 4)
	205	for (offs = 0; offs < m_spriteram2.bytes(); offs += 4)
206	206	{
207	207	int attr = spriteram_2[offs + 1];
208	208	int code = spriteram_2[offs];
r21026	r21027
212	212	int sx = spriteram_2[offs + 3];
213	213	int sy = spriteram_2[offs + 2];
214	214
215		if (state->flip_screen())
	215	if (flip_screen())
216	216	{
217	217	sx = 248 - sx;
218	218	sy = 248 - sy;
r21026	r21027
221	221	}
222	222
223	223	drawgfx_transpen(bitmap, cliprect,
224		machine.gfx[0],
	224	machine().gfx[0],
225	225	code, color,
226	226	flipx, flipy,
227	227	sx, sy, 0);
r21026	r21027
231	231	UINT32 olibochu_state::screen_update_olibochu(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
232	232	{
233	233	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
234		draw_sprites(machine(), bitmap, cliprect);
	234	draw_sprites(bitmap, cliprect);
235	235	return 0;
236	236	}
237	237

trunk/src/mame/drivers/deco_ld.c

r21026	r21027
148	148	virtual void machine_start();
149	149	UINT32 screen_update_rblaster(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
150	150	INTERRUPT_GEN_MEMBER(sound_interrupt);
	151	void draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect, UINT8 *spriteram, UINT16 tile_bank );
151	152	};
152	153
153		static void draw_sprites(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect, UINT8 *spriteram, UINT16 tile_bank )
	154	void deco_ld_state::draw_sprites(bitmap_rgb32 &bitmap, const rectangle &cliprect, UINT8 *spriteram, UINT16 tile_bank )
154	155	{
155		gfx_element *gfx = machine.gfx[1];
	156	gfx_element *gfx = machine().gfx[1];
156	157	int i,spr_offs,x,y,col,fx,fy;
157	158
158	159	/*
r21026	r21027
202	203
203	204	bitmap.fill(0, cliprect);
204	205
205		draw_sprites(machine(), bitmap,cliprect,m_vram1,0x000);
206		draw_sprites(machine(), bitmap,cliprect,m_vram0,0x100);
	206	draw_sprites(bitmap,cliprect,m_vram1,0x000);
	207	draw_sprites(bitmap,cliprect,m_vram0,0x100);
207	208
208	209	for (y=0;y<32;y++)
209	210	{

trunk/src/mame/drivers/sfkick.c

r21026	r21027
80	80	DECLARE_DRIVER_INIT(sfkick);
81	81	virtual void machine_reset();
82	82	TIMER_DEVICE_CALLBACK_MEMBER(sfkick_interrupt);
	83	void sfkick_remap_banks();
	84	void sfkick_bank_set(int num, int data);
83	85	};
84	86
85	87
r21026	r21027
105	107	return 0xff;
106	108	}
107	109
108		static void sfkick_remap_banks(running_machine &machine)
	110	void sfkick_state::sfkick_remap_banks()
109	111	{
110		sfkick_state *state = machine.driver_data<sfkick_state>();
111	112	/* 0000-3ffff */
112		switch(state->m_bank_cfg&3)
	113	switch(m_bank_cfg&3)
113	114	{
114	115	case 0: /* bios */
115	116	{
116		UINT8 *mem = state->memregion("bios")->base();
117		state->membank("bank1")->set_base(mem);
118		state->membank("bank2")->set_base(mem+0x2000);
	117	UINT8 *mem = memregion("bios")->base();
	118	membank("bank1")->set_base(mem);
	119	membank("bank2")->set_base(mem+0x2000);
119	120	}
120	121	break;
121	122
122	123	case 1: /* ext rom */
123	124	{
124		UINT8 *mem = machine.root_device().memregion("extrom")->base();
125		state->membank("bank1")->set_base(mem+0x4000);
126		state->membank("bank2")->set_base(mem+0x6000);
	125	UINT8 *mem = machine().root_device().memregion("extrom")->base();
	126	membank("bank1")->set_base(mem+0x4000);
	127	membank("bank2")->set_base(mem+0x6000);
127	128	}
128	129	break;
129	130
130	131	case 2: /* banked */
131	132	{
132		UINT8 *mem = machine.root_device().memregion("banked")->base();
133		state->membank("bank1")->set_base(mem+0x2000*state->m_bank[0]);
134		state->membank("bank2")->set_base(mem+0x2000*state->m_bank[1]);
	133	UINT8 *mem = machine().root_device().memregion("banked")->base();
	134	membank("bank1")->set_base(mem+0x2000*m_bank[0]);
	135	membank("bank2")->set_base(mem+0x2000*m_bank[1]);
135	136	}
136	137	break;
137	138
138	139	case 3: /* unknown */
139	140	{
140		UINT8 *mem = machine.root_device().memregion("banked")->base();
141		state->membank("bank1")->set_base(mem+0x18000);
142		state->membank("bank2")->set_base(mem+0x18000);
	141	UINT8 *mem = machine().root_device().memregion("banked")->base();
	142	membank("bank1")->set_base(mem+0x18000);
	143	membank("bank2")->set_base(mem+0x18000);
143	144	}
144	145	break;
145	146	}
146	147
147	148	/* 4000-7ffff */
148		switch((state->m_bank_cfg>>2)&3)
	149	switch((m_bank_cfg>>2)&3)
149	150	{
150	151	case 0: /* bios - upper part */
151	152	{
152		UINT8 *mem = machine.root_device().memregion("bios")->base();
153		state->membank("bank3")->set_base(mem+0x4000);
154		state->membank("bank4")->set_base(mem+0x6000);
	153	UINT8 *mem = machine().root_device().memregion("bios")->base();
	154	membank("bank3")->set_base(mem+0x4000);
	155	membank("bank4")->set_base(mem+0x6000);
155	156	}
156	157	break;
157	158
158	159	case 1:  /* unknown */
159	160	case 3:
160	161	{
161		UINT8 *mem = machine.root_device().memregion("banked")->base();
162		state->membank("bank3")->set_base(mem+0x18000);
163		state->membank("bank4")->set_base(mem+0x18000);
	162	UINT8 *mem = machine().root_device().memregion("banked")->base();
	163	membank("bank3")->set_base(mem+0x18000);
	164	membank("bank4")->set_base(mem+0x18000);
164	165	}
165	166	break;
166	167
167	168	case 2: /* banked */
168	169	{
169		UINT8 *mem = machine.root_device().memregion("banked")->base();
170		state->membank("bank3")->set_base(mem+0x2000*state->m_bank[2]);
171		state->membank("bank4")->set_base(mem+0x2000*state->m_bank[3]);
	170	UINT8 *mem = machine().root_device().memregion("banked")->base();
	171	membank("bank3")->set_base(mem+0x2000*m_bank[2]);
	172	membank("bank4")->set_base(mem+0x2000*m_bank[3]);
172	173	}
173	174	break;
174	175	}
175	176
176	177	/* 8000-bffff */
177		switch((state->m_bank_cfg>>4)&3)
	178	switch((m_bank_cfg>>4)&3)
178	179	{
179	180	case 0: /* cartridge */
180	181	{
181		UINT8 *mem = machine.root_device().memregion("cartridge")->base();
182		state->membank("bank5")->set_base(mem+0x4000);
183		state->membank("bank6")->set_base(mem+0x6000);
	182	UINT8 *mem = machine().root_device().memregion("cartridge")->base();
	183	membank("bank5")->set_base(mem+0x4000);
	184	membank("bank6")->set_base(mem+0x6000);
184	185	}
185	186	break;
186	187
187	188	case 1: /* unknown */
188	189	case 3:
189	190	{
190		UINT8 *mem = machine.root_device().memregion("banked")->base();
191		state->membank("bank5")->set_base(mem+0x18000);
192		state->membank("bank6")->set_base(mem+0x18000);
	191	UINT8 *mem = machine().root_device().memregion("banked")->base();
	192	membank("bank5")->set_base(mem+0x18000);
	193	membank("bank6")->set_base(mem+0x18000);
193	194	}
194	195	break;
195	196
196	197	case 2: /* banked */
197	198	{
198		UINT8 *mem = machine.root_device().memregion("banked")->base();
199		state->membank("bank5")->set_base(mem+0x2000*state->m_bank[4]);
200		state->membank("bank6")->set_base(mem+0x2000*state->m_bank[5]);
	199	UINT8 *mem = machine().root_device().memregion("banked")->base();
	200	membank("bank5")->set_base(mem+0x2000*m_bank[4]);
	201	membank("bank6")->set_base(mem+0x2000*m_bank[5]);
201	202	}
202	203	break;
203	204	}
204	205
205	206	/* c000-fffff */
206		switch((state->m_bank_cfg>>6)&3)
	207	switch((m_bank_cfg>>6)&3)
207	208	{
208	209	case 0: /* unknown */
209	210	case 1:
210	211	{
211		UINT8 *mem = machine.root_device().memregion("banked")->base();
212		state->membank("bank7")->set_base(mem+0x18000);
213		state->membank("bank8")->set_base(mem+0x18000);
	212	UINT8 *mem = machine().root_device().memregion("banked")->base();
	213	membank("bank7")->set_base(mem+0x18000);
	214	membank("bank8")->set_base(mem+0x18000);
214	215	}
215	216	break;
216	217
217	218	case 2: /* banked */
218	219	{
219		UINT8 *mem = machine.root_device().memregion("banked")->base();
220		state->membank("bank7")->set_base(mem+0x2000*state->m_bank[6]);
221		state->membank("bank8")->set_base(mem+0x2000*state->m_bank[7]);
	220	UINT8 *mem = machine().root_device().memregion("banked")->base();
	221	membank("bank7")->set_base(mem+0x2000*m_bank[6]);
	222	membank("bank8")->set_base(mem+0x2000*m_bank[7]);
222	223	}
223	224	break;
224	225
225	226	case 3: /* RAM */
226	227	{
227		state->membank("bank7")->set_base(state->m_main_mem);
228		state->membank("bank8")->set_base(state->m_main_mem+0x2000);
	228	membank("bank7")->set_base(m_main_mem);
	229	membank("bank8")->set_base(m_main_mem+0x2000);
229	230	}
230	231	break;
231	232	}
r21026	r21027
234	235	WRITE8_MEMBER(sfkick_state::ppi_port_a_w)
235	236	{
236	237	m_bank_cfg=data;
237		sfkick_remap_banks(machine());
	238	sfkick_remap_banks();
238	239	}
239	240
240		static void sfkick_bank_set(running_machine &machine,int num, int data)
	241	void sfkick_state::sfkick_bank_set(int num, int data)
241	242	{
242		sfkick_state *state = machine.driver_data<sfkick_state>();
243	243	/* ignore bit 1 */
244	244	data&=0xf;
245	245	num&=5;
246		state->m_bank[num]=data;
	246	m_bank[num]=data;
247	247	num|=2;
248		state->m_bank[num]=data;
249		sfkick_remap_banks(machine);
	248	m_bank[num]=data;
	249	sfkick_remap_banks();
250	250	}
251	251
252	252	WRITE8_MEMBER(sfkick_state::page0_w)
r21026	r21027
255	255	{
256	256	if(offset<0x2000)
257	257	{
258		sfkick_bank_set(machine(),0,data);
	258	sfkick_bank_set(0,data);
259	259	}
260	260	else
261	261	{
262		sfkick_bank_set(machine(),1,data);
	262	sfkick_bank_set(1,data);
263	263	}
264	264	}
265	265	}
r21026	r21027
270	270	{
271	271	if(offset<0x2000)
272	272	{
273		sfkick_bank_set(machine(),2,data);
	273	sfkick_bank_set(2,data);
274	274	}
275	275	else
276	276	{
277		sfkick_bank_set(machine(),3,data);
	277	sfkick_bank_set(3,data);
278	278	}
279	279	}
280	280	}
r21026	r21027
285	285	{
286	286	if(offset<0x2000)
287	287	{
288		sfkick_bank_set(machine(),4,data);
	288	sfkick_bank_set(4,data);
289	289	}
290	290	else
291	291	{
292		sfkick_bank_set(machine(),5,data);
	292	sfkick_bank_set(5,data);
293	293	}
294	294	}
295	295	}
r21026	r21027
300	300	{
301	301	if(offset<0x2000)
302	302	{
303		sfkick_bank_set(machine(),6,data);
	303	sfkick_bank_set(6,data);
304	304	}
305	305	else
306	306	{
307		sfkick_bank_set(machine(),7,data);
	307	sfkick_bank_set(7,data);
308	308	}
309	309	}
310	310	else
r21026	r21027
447	447	m_bank[5]=0;
448	448	m_bank[6]=0;
449	449	m_bank[7]=0;
450		sfkick_remap_banks(machine());
	450	sfkick_remap_banks();
451	451	}
452	452
453	453	TIMER_DEVICE_CALLBACK_MEMBER(sfkick_state::sfkick_interrupt)

trunk/src/mame/drivers/sangho.c

r21026	r21027
68	68	DECLARE_MACHINE_RESET(pzlestar);
69	69	DECLARE_MACHINE_RESET(sexyboom);
70	70	TIMER_DEVICE_CALLBACK_MEMBER(sangho_interrupt);
	71	void pzlestar_map_banks();
	72	void sexyboom_map_bank(int bank);
71	73	};
72	74
73	75
74		static void pzlestar_map_banks(running_machine &machine)
	76	void sangho_state::pzlestar_map_banks()
75	77	{
76		sangho_state *state = machine.driver_data<sangho_state>();
77	78	int slot_select;
78	79
79	80	// page 0
80		slot_select = (state->m_pzlestar_mem_bank >> 0) & 0x03;
	81	slot_select = (m_pzlestar_mem_bank >> 0) & 0x03;
81	82	switch(slot_select)
82	83	{
83	84	case 0:
84		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x0000, 0x3fff, "bank1");
85		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(0x0000, 0x3fff, "bank5");
86		state->membank("bank1")->set_base(state->m_ram);
87		state->membank("bank5")->set_base(state->m_ram);
	85	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x0000, 0x3fff, "bank1");
	86	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(0x0000, 0x3fff, "bank5");
	87	membank("bank1")->set_base(m_ram);
	88	membank("bank5")->set_base(m_ram);
88	89	break;
89	90	case 2:
90		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x0000, 0x3fff, "bank1");
91		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x0000, 0x3fff);
92		state->membank("bank1")->set_base(state->memregion("user1")->base()+ 0x10000);
	91	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x0000, 0x3fff, "bank1");
	92	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x0000, 0x3fff);
	93	membank("bank1")->set_base(memregion("user1")->base()+ 0x10000);
93	94	break;
94	95	case 1:
95	96	case 3:
96		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0x0000, 0x3fff);
97		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x0000, 0x3fff);
	97	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0x0000, 0x3fff);
	98	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x0000, 0x3fff);
98	99	break;
99	100	}
100	101
101	102	// page 1
102		slot_select = (state->m_pzlestar_mem_bank >> 2) & 0x03;
	103	slot_select = (m_pzlestar_mem_bank >> 2) & 0x03;
103	104	switch(slot_select)
104	105	{
105	106	case 0:
106		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x4000, 0x7fff, "bank2");
107		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(0x4000, 0x7fff, "bank6");
108		state->membank("bank2")->set_base(state->m_ram + 0x4000);
109		state->membank("bank6")->set_base(state->m_ram + 0x4000);
	107	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x4000, 0x7fff, "bank2");
	108	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(0x4000, 0x7fff, "bank6");
	109	membank("bank2")->set_base(m_ram + 0x4000);
	110	membank("bank6")->set_base(m_ram + 0x4000);
110	111	break;
111	112	case 2:
112		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x4000, 0x7fff, "bank2");
113		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x4000, 0x7fff);
114		state->membank("bank2")->set_base(machine.root_device().memregion("user1")->base()+ 0x18000);
	113	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x4000, 0x7fff, "bank2");
	114	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x4000, 0x7fff);
	115	membank("bank2")->set_base(machine().root_device().memregion("user1")->base()+ 0x18000);
115	116	break;
116	117	case 3:
117		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x4000, 0x7fff, "bank2");
118		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x4000, 0x7fff);
119		state->membank("bank2")->set_base(machine.root_device().memregion("user1")->base()+ 0x20000 + (state->m_pzlestar_rom_bank*0x8000) + 0x4000);
	118	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x4000, 0x7fff, "bank2");
	119	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x4000, 0x7fff);
	120	membank("bank2")->set_base(machine().root_device().memregion("user1")->base()+ 0x20000 + (m_pzlestar_rom_bank*0x8000) + 0x4000);
120	121	break;
121	122	case 1:
122		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0x4000, 0x7fff);
123		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x4000, 0x7fff);
	123	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0x4000, 0x7fff);
	124	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x4000, 0x7fff);
124	125	break;
125	126	}
126	127
127	128	// page 2
128		slot_select = (state->m_pzlestar_mem_bank >> 4) & 0x03;
	129	slot_select = (m_pzlestar_mem_bank >> 4) & 0x03;
129	130	switch(slot_select)
130	131	{
131	132	case 0:
132		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x8000, 0xbfff, "bank3");
133		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(0x8000, 0xbfff, "bank7");
134		state->membank("bank3")->set_base(state->m_ram + 0x8000);
135		state->membank("bank7")->set_base(state->m_ram + 0x8000);
	133	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x8000, 0xbfff, "bank3");
	134	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(0x8000, 0xbfff, "bank7");
	135	membank("bank3")->set_base(m_ram + 0x8000);
	136	membank("bank7")->set_base(m_ram + 0x8000);
136	137	break;
137	138	case 3:
138		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x8000, 0xbfff, "bank3");
139		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x8000, 0xbfff);
140		state->membank("bank3")->set_base(machine.root_device().memregion("user1")->base()+ 0x20000 + (state->m_pzlestar_rom_bank*0x8000));
	139	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x8000, 0xbfff, "bank3");
	140	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x8000, 0xbfff);
	141	membank("bank3")->set_base(machine().root_device().memregion("user1")->base()+ 0x20000 + (m_pzlestar_rom_bank*0x8000));
141	142	break;
142	143	case 1:
143	144	case 2:
144		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0x8000, 0xbfff);
145		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x8000, 0xbfff);
	145	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0x8000, 0xbfff);
	146	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x8000, 0xbfff);
146	147	break;
147	148	}
148	149
149	150	// page 3
150		slot_select = (state->m_pzlestar_mem_bank >> 6) & 0x03;
	151	slot_select = (m_pzlestar_mem_bank >> 6) & 0x03;
151	152	switch(slot_select)
152	153	{
153	154	case 0:
154		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0xc000, 0xffff, "bank4");
155		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(0xc000, 0xffff, "bank8");
156		state->membank("bank4")->set_base(state->m_ram + 0xc000);
157		state->membank("bank8")->set_base(state->m_ram + 0xc000);
	155	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0xc000, 0xffff, "bank4");
	156	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(0xc000, 0xffff, "bank8");
	157	membank("bank4")->set_base(m_ram + 0xc000);
	158	membank("bank8")->set_base(m_ram + 0xc000);
158	159	break;
159	160	case 1:
160	161	case 2:
161	162	case 3:
162		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0xc000, 0xffff);
163		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0xc000, 0xffff);
	163	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0xc000, 0xffff);
	164	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0xc000, 0xffff);
164	165	break;
165	166	}
166	167
r21026	r21027
170	171	{
171	172	logerror("rom bank %02x\n", data);
172	173	m_pzlestar_rom_bank = data;
173		pzlestar_map_banks(machine());
	174	pzlestar_map_banks();
174	175	}
175	176
176	177	WRITE8_MEMBER(sangho_state::pzlestar_mem_bank_w)
177	178	{
178	179	logerror("mem bank %02x\n", data);
179	180	m_pzlestar_mem_bank = data;
180		pzlestar_map_banks(machine());
	181	pzlestar_map_banks();
181	182	}
182	183
183	184	READ8_MEMBER(sangho_state::pzlestar_mem_bank_r)
r21026	r21027
185	186	return m_pzlestar_mem_bank;
186	187	}
187	188
188		static void sexyboom_map_bank(running_machine &machine, int bank)
	189	void sangho_state::sexyboom_map_bank(int bank)
189	190	{
190		sangho_state *state = machine.driver_data<sangho_state>();
191	191	UINT8 banknum, banktype;
192	192	char read_bank_name[6], write_bank_name[6];
193	193
194		banknum = state->m_sexyboom_bank[bank*2];
195		banktype = state->m_sexyboom_bank[bank*2 + 1];
	194	banknum = m_sexyboom_bank[bank*2];
	195	banktype = m_sexyboom_bank[bank*2 + 1];
196	196	sprintf(read_bank_name, "bank%d", bank+1);
197	197	sprintf(write_bank_name, "bank%d", bank+1+4);
198	198
r21026	r21027
201	201	if (banknum & 0x80)
202	202	{
203	203	// ram
204		state->membank(read_bank_name)->set_base(&state->m_ram[(banknum & 0x7f) * 0x4000]);
205		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(bank*0x4000, (bank+1)*0x4000 - 1, write_bank_name );
206		state->membank(write_bank_name)->set_base(&state->m_ram[(banknum & 0x7f) * 0x4000]);
	204	membank(read_bank_name)->set_base(&m_ram[(banknum & 0x7f) * 0x4000]);
	205	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_bank(bank*0x4000, (bank+1)*0x4000 - 1, write_bank_name );
	206	membank(write_bank_name)->set_base(&m_ram[(banknum & 0x7f) * 0x4000]);
207	207	}
208	208	else
209	209	{
210	210	// rom 0
211		state->membank(read_bank_name)->set_base(machine.root_device().memregion("user1")->base()+0x4000*banknum);
212		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_write(bank*0x4000, (bank+1)*0x4000 - 1);
	211	membank(read_bank_name)->set_base(machine().root_device().memregion("user1")->base()+0x4000*banknum);
	212	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(bank*0x4000, (bank+1)*0x4000 - 1);
213	213	}
214	214	}
215	215	else if (banktype == 0x82)
216	216	{
217		state->membank(read_bank_name)->set_base(machine.root_device().memregion("user1")->base()+0x20000+banknum*0x4000);
218		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_write(bank*0x4000, (bank+1)*0x4000 - 1);
	217	membank(read_bank_name)->set_base(machine().root_device().memregion("user1")->base()+0x20000+banknum*0x4000);
	218	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(bank*0x4000, (bank+1)*0x4000 - 1);
219	219	}
220	220	else if (banktype == 0x80)
221	221	{
222		state->membank(read_bank_name)->set_base(machine.root_device().memregion("user1")->base()+0x120000+banknum*0x4000);
223		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_write(bank*0x4000, (bank+1)*0x4000 - 1);
	222	membank(read_bank_name)->set_base(machine().root_device().memregion("user1")->base()+0x120000+banknum*0x4000);
	223	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_write(bank*0x4000, (bank+1)*0x4000 - 1);
224	224	}
225	225	else
226	226	{
r21026	r21027
231	231	WRITE8_MEMBER(sangho_state::sexyboom_bank_w)
232	232	{
233	233	m_sexyboom_bank[offset] = data;
234		sexyboom_map_bank(machine(), offset>>1);
	234	sexyboom_map_bank(offset>>1);
235	235	}
236	236
237	237	static ADDRESS_MAP_START( sangho_map, AS_PROGRAM, 8, sangho_state )
r21026	r21027
382	382	MACHINE_RESET_MEMBER(sangho_state,pzlestar)
383	383	{
384	384	m_pzlestar_mem_bank = 2;
385		pzlestar_map_banks(machine());
	385	pzlestar_map_banks();
386	386	}
387	387
388	388	MACHINE_RESET_MEMBER(sangho_state,sexyboom)
r21026	r21027
395	395	m_sexyboom_bank[5] = 0x00;
396	396	m_sexyboom_bank[6] = 0x80;
397	397	m_sexyboom_bank[7] = 0x01;
398		sexyboom_map_bank(machine(), 0);
399		sexyboom_map_bank(machine(), 1);
400		sexyboom_map_bank(machine(), 2);
401		sexyboom_map_bank(machine(), 3);
	398	sexyboom_map_bank(0);
	399	sexyboom_map_bank(1);
	400	sexyboom_map_bank(2);
	401	sexyboom_map_bank(3);
402	402	}
403	403
404	404	static void msx_vdp_interrupt(device_t *, v99x8_device &device, int i)

trunk/src/mame/drivers/mgolf.c

r21026	r21027
40	40	virtual void palette_init();
41	41	UINT32 screen_update_mgolf(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
42	42	TIMER_CALLBACK_MEMBER(interrupt_callback);
	43	void update_plunger(  );
	44	double calc_plunger_pos();
43	45	};
44	46
45	47
r21026	r21027
92	94	}
93	95
94	96
95		static void update_plunger( running_machine &machine )
	97	void mgolf_state::update_plunger(  )
96	98	{
97		mgolf_state *state = machine.driver_data<mgolf_state>();
98		UINT8 val = state->ioport("BUTTON")->read();
	99	UINT8 val = ioport("BUTTON")->read();
99	100
100		if (state->m_prev != val)
	101	if (m_prev != val)
101	102	{
102	103	if (val == 0)
103	104	{
104		state->m_time_released = machine.time();
	105	m_time_released = machine().time();
105	106
106		if (!state->m_mask)
107		state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
	107	if (!m_mask)
	108	m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
108	109	}
109	110	else
110		state->m_time_pushed = machine.time();
	111	m_time_pushed = machine().time();
111	112
112		state->m_prev = val;
	113	m_prev = val;
113	114	}
114	115	}
115	116
r21026	r21027
118	119	{
119	120	int scanline = param;
120	121
121		update_plunger(machine());
	122	update_plunger();
122	123
123	124	generic_pulse_irq_line(*m_maincpu, 0, 1);
124	125
r21026	r21027
131	132	}
132	133
133	134
134		static double calc_plunger_pos(running_machine &machine)
	135	double mgolf_state::calc_plunger_pos()
135	136	{
136		mgolf_state *state = machine.driver_data<mgolf_state>();
137		return (machine.time().as_double() - state->m_time_released.as_double()) * (state->m_time_released.as_double() - state->m_time_pushed.as_double() + 0.2);
	137	return (machine().time().as_double() - m_time_released.as_double()) * (m_time_released.as_double() - m_time_pushed.as_double() + 0.2);
138	138	}
139	139
140	140
r21026	r21027
163	163
164	164	READ8_MEMBER(mgolf_state::mgolf_misc_r)
165	165	{
166		double plunger = calc_plunger_pos(machine()); /* see Video Pinball */
	166	double plunger = calc_plunger_pos(); /* see Video Pinball */
167	167
168	168	UINT8 val = ioport("61")->read();
169	169

trunk/src/mame/drivers/sbrkout.c

r21026	r21027
69	69	UINT32 screen_update_sbrkout(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
70	70	TIMER_CALLBACK_MEMBER(scanline_callback);
71	71	TIMER_CALLBACK_MEMBER(pot_trigger_callback);
	72	void update_nmi_state();
72	73	};
73	74
74	75
r21026	r21027
201	202	}
202	203
203	204
204		static void update_nmi_state(running_machine &machine)
	205	void sbrkout_state::update_nmi_state()
205	206	{
206		sbrkout_state *state = machine.driver_data<sbrkout_state>();
207		if ((state->m_pot_trigger[0] & ~state->m_pot_mask[0]) | (state->m_pot_trigger[1] & ~state->m_pot_mask[1]))
208		machine.device("maincpu")->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
	207	if ((m_pot_trigger[0] & ~m_pot_mask[0]) | (m_pot_trigger[1] & ~m_pot_mask[1]))
	208	machine().device("maincpu")->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
209	209	else
210		machine.device("maincpu")->execute().set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
	210	machine().device("maincpu")->execute().set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
211	211	}
212	212
213	213
214	214	TIMER_CALLBACK_MEMBER(sbrkout_state::pot_trigger_callback)
215	215	{
216	216	m_pot_trigger[param] = 1;
217		update_nmi_state(machine());
	217	update_nmi_state();
218	218	}
219	219
220	220
r21026	r21027
222	222	{
223	223	m_pot_mask[0] = ~offset & 1;
224	224	m_pot_trigger[0] = 0;
225		update_nmi_state(machine());
	225	update_nmi_state();
226	226	}
227	227
228	228
r21026	r21027
230	230	{
231	231	m_pot_mask[1] = ~offset & 1;
232	232	m_pot_trigger[1] = 0;
233		update_nmi_state(machine());
	233	update_nmi_state();
234	234	}
235	235
236	236

trunk/src/mame/drivers/mwarr.c

r21026	r21027
100	100	virtual void machine_reset();
101	101	virtual void video_start();
102	102	UINT32 screen_update_mwarr(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	103	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
103	104	};
104	105
105	106
r21026	r21027
404	405	save_item(NAME(m_sprites_buffer));
405	406	}
406	407
407		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	408	void mwarr_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
408	409	{
409		mwarr_state *state = machine.driver_data<mwarr_state>();
410		const UINT16 *source = state->m_sprites_buffer + 0x800 - 4;
411		const UINT16 *finish = state->m_sprites_buffer;
412		gfx_element *gfx = machine.gfx[0];
	410	const UINT16 *source = m_sprites_buffer + 0x800 - 4;
	411	const UINT16 *finish = m_sprites_buffer;
	412	gfx_element *gfx = machine().gfx[0];
413	413	int x, y, color, flipx, dy, pri, pri_mask, i;
414	414
415	415	while (source >= finish)
r21026	r21027
437	437	color,
438	438	flipx,0,
439	439	x,y+i*16,
440		machine.priority_bitmap,pri_mask,0 );
	440	machine().priority_bitmap,pri_mask,0 );
441	441
442	442	/* wrap around x */
443	443	pdrawgfx_transpen( bitmap,
r21026	r21027
447	447	color,
448	448	flipx,0,
449	449	x-1024,y+i*16,
450		machine.priority_bitmap,pri_mask,0 );
	450	machine().priority_bitmap,pri_mask,0 );
451	451
452	452	/* wrap around y */
453	453	pdrawgfx_transpen( bitmap,
r21026	r21027
457	457	color,
458	458	flipx,0,
459	459	x,y-512+i*16,
460		machine.priority_bitmap,pri_mask,0 );
	460	machine().priority_bitmap,pri_mask,0 );
461	461
462	462	/* wrap around x & y */
463	463	pdrawgfx_transpen( bitmap,
r21026	r21027
467	467	color,
468	468	flipx,0,
469	469	x-1024,y-512+i*16,
470		machine.priority_bitmap,pri_mask,0 );
	470	machine().priority_bitmap,pri_mask,0 );
471	471	}
472	472	}
473	473
r21026	r21027
525	525	m_mlow_tilemap->draw(bitmap, cliprect, 0, 0x02);
526	526	m_mhigh_tilemap->draw(bitmap, cliprect, 0, 0x04);
527	527	m_tx_tilemap->draw(bitmap, cliprect, 0, 0x10);
528		draw_sprites(machine(), bitmap, cliprect);
	528	draw_sprites(bitmap, cliprect);
529	529	return 0;
530	530	}
531	531

trunk/src/mame/drivers/calchase.c

r21026	r21027
182	182	virtual void machine_start();
183	183	virtual void machine_reset();
184	184	IRQ_CALLBACK_MEMBER(irq_callback);
	185	void intel82439tx_init();
185	186	};
186	187
187	188
r21026	r21027
368	369	state->m_mxtc_config_reg[reg] = data;
369	370	}
370	371
371		static void intel82439tx_init(running_machine &machine)
	372	void calchase_state::intel82439tx_init()
372	373	{
373		calchase_state *state = machine.driver_data<calchase_state>();
374		state->m_mxtc_config_reg[0x60] = 0x02;
375		state->m_mxtc_config_reg[0x61] = 0x02;
376		state->m_mxtc_config_reg[0x62] = 0x02;
377		state->m_mxtc_config_reg[0x63] = 0x02;
378		state->m_mxtc_config_reg[0x64] = 0x02;
379		state->m_mxtc_config_reg[0x65] = 0x02;
	374	m_mxtc_config_reg[0x60] = 0x02;
	375	m_mxtc_config_reg[0x61] = 0x02;
	376	m_mxtc_config_reg[0x62] = 0x02;
	377	m_mxtc_config_reg[0x63] = 0x02;
	378	m_mxtc_config_reg[0x64] = 0x02;
	379	m_mxtc_config_reg[0x65] = 0x02;
380	380	}
381	381
382	382	static UINT32 intel82439tx_pci_r(device_t *busdevice, device_t *device, int function, int reg, UINT32 mem_mask)
r21026	r21027
968	968
969	969	init_pc_common(machine(), PCCOMMON_KEYBOARD_AT, calchase_set_keyb_int);
970	970
971		intel82439tx_init(machine());
	971	intel82439tx_init();
972	972
973	973	kbdc8042_init(machine(), &at8042);
974	974

trunk/src/mame/drivers/popobear.c

r21026	r21027
97	97	virtual void video_start();
98	98	UINT32 screen_update_popobear(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
99	99	TIMER_DEVICE_CALLBACK_MEMBER(popobear_irq);
	100	void draw_layer(bitmap_ind16 &bitmap,const rectangle &cliprect, UINT8 layer_n);
	101	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
100	102	};
101	103
102	104	void popobear_state::video_start()
103	105	{
104	106	}
105	107
106		static void draw_layer(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect, UINT8 layer_n)
	108	void popobear_state::draw_layer(bitmap_ind16 &bitmap,const rectangle &cliprect, UINT8 layer_n)
107	109	{
108		popobear_state *state = machine.driver_data<popobear_state>();
109	110	// ERROR: This cast is NOT endian-safe without the use of BYTE/WORD/DWORD_XOR_* macros!
110		UINT8* vram = reinterpret_cast<UINT8 *>(state->m_vram.target());
111		UINT16* vreg = (UINT16 *)state->m_vregs;
	111	UINT8* vram = reinterpret_cast<UINT8 *>(m_vram.target());
	112	UINT16* vreg = (UINT16 *)m_vregs;
112	113	int count;
113	114	const UINT8 vreg_base[] = { 0x10/2, 0x14/2 };
114	115	int xscroll,yscroll;
115	116
116		//  count = (state->m_vregs[vreg_base[layer_n]]<<5);
	117	//  count = (m_vregs[vreg_base[layer_n]]<<5);
117	118	//  count &= 0xfc000;
118	119	count = (0xf0000+layer_n*0x4000);
119	120	if(layer_n & 2)
r21026	r21027
154	155	color = (vram[((xi+yi*1024)+xtile+ytile) & 0xfffff] & 0xff);
155	156
156	157	if(cliprect.contains(xoffs+1, yoffs) && color)
157		bitmap.pix16(yoffs, xoffs+1) = machine.pens[color];
	158	bitmap.pix16(yoffs, xoffs+1) = machine().pens[color];
158	159
159	160	if(cliprect.contains(xoffs+1, yoffs+512) && color)
160		bitmap.pix16(yoffs+512, xoffs+1) = machine.pens[color];
	161	bitmap.pix16(yoffs+512, xoffs+1) = machine().pens[color];
161	162
162	163	//if(cliprect.contains(xoffs+1, yoffs+256) && color)
163		//  bitmap.pix16(yoffs+512, xoffs+1) = machine.pens[color];
	164	//  bitmap.pix16(yoffs+512, xoffs+1) = machine().pens[color];
164	165
165	166	color = (vram[((xi+1+yi*1024)+xtile+ytile) & 0xfffff] & 0xff);
166	167
167	168	if(cliprect.contains(xoffs, yoffs) && color)
168		bitmap.pix16(yoffs, xoffs) = machine.pens[color];
	169	bitmap.pix16(yoffs, xoffs) = machine().pens[color];
169	170
170	171	if(cliprect.contains(xoffs, yoffs+512) && color)
171		bitmap.pix16(yoffs+512, xoffs) = machine.pens[color];
	172	bitmap.pix16(yoffs+512, xoffs) = machine().pens[color];
172	173	}
173	174	}
174	175
r21026	r21027
177	178	}
178	179	}
179	180
180		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	181	void popobear_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
181	182	{
182		popobear_state *state = machine.driver_data<popobear_state>();
183	183	// ERROR: This cast is NOT endian-safe without the use of BYTE/WORD/DWORD_XOR_* macros!
184		UINT8* vram = reinterpret_cast<UINT8 *>(state->m_spr.target());
	184	UINT8* vram = reinterpret_cast<UINT8 *>(m_spr.target());
185	185	int i;
186	186	#if 0
187	187	static int bank_test = 1;
188	188
189		if(machine.input().code_pressed_once(KEYCODE_Z))
	189	if(machine().input().code_pressed_once(KEYCODE_Z))
190	190	bank_test<<=1;
191	191
192		if(machine.input().code_pressed_once(KEYCODE_X))
	192	if(machine().input().code_pressed_once(KEYCODE_X))
193	193	bank_test>>=1;
194	194
195	195	popmessage("%02x",bank_test);
r21026	r21027
242	242	y_res = (y_dir) ? y+(height - yi) : y+yi;
243	243
244	244	if(cliprect.contains(x_res, y_res) && color)
245		bitmap.pix16(y_res, x_res) = machine.pens[color+0x100+color_bank];
	245	bitmap.pix16(y_res, x_res) = machine().pens[color+0x100+color_bank];
246	246
247	247	color = (vram[spr_num+1] & 0xff);
248	248	x_res = (x_dir) ? x+1+(width - xi) : x+0+xi;
249	249	y_res = (y_dir) ? y+(height - yi) : y+yi;
250	250
251	251	if(cliprect.contains(x_res, y_res) && color)
252		bitmap.pix16(y_res, x_res) = machine.pens[color+0x100+color_bank];
	252	bitmap.pix16(y_res, x_res) = machine().pens[color+0x100+color_bank];
253	253
254	254	spr_num+=2;
255	255	}
r21026	r21027
263	263
264	264	//popmessage("%04x",m_vregs[0/2]);
265	265
266		draw_layer(machine(),bitmap,cliprect,3);
267		draw_layer(machine(),bitmap,cliprect,2);
268		draw_layer(machine(),bitmap,cliprect,1);
269		draw_layer(machine(),bitmap,cliprect,0);
270		draw_sprites(machine(),bitmap,cliprect);
	266	draw_layer(bitmap,cliprect,3);
	267	draw_layer(bitmap,cliprect,2);
	268	draw_layer(bitmap,cliprect,1);
	269	draw_layer(bitmap,cliprect,0);
	270	draw_sprites(bitmap,cliprect);
271	271
272	272	return 0;
273	273	}

trunk/src/mame/drivers/egghunt.c

r21026	r21027
80	80	virtual void machine_reset();
81	81	virtual void video_start();
82	82	UINT32 screen_update_egghunt(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	83	void draw_sprites( bitmap_ind16 &bitmap,const rectangle &cliprect );
83	84	};
84	85
85	86
86		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect )
	87	void egghunt_state::draw_sprites( bitmap_ind16 &bitmap,const rectangle &cliprect )
87	88	{
88		egghunt_state *state = machine.driver_data<egghunt_state>();
89	89	int flipscreen = 0;
90	90	int offs, sx, sy;
91	91
92	92	for (offs = 0x1000 - 0x40; offs >= 0; offs -= 0x20)
93	93	{
94		int code = state->m_spram[offs];
95		int attr = state->m_spram[offs + 1];
	94	int code = m_spram[offs];
	95	int attr = m_spram[offs + 1];
96	96	int color = attr & 0x0f;
97		sx = state->m_spram[offs + 3] + ((attr & 0x10) << 4);
98		sy = ((state->m_spram[offs + 2] + 8) & 0xff) - 8;
	97	sx = m_spram[offs + 3] + ((attr & 0x10) << 4);
	98	sy = ((m_spram[offs + 2] + 8) & 0xff) - 8;
99	99	code += (attr & 0xe0) << 3;
100	100
101	101	if (attr & 0xe0)
102	102	{
103		switch(state->m_gfx_banking & 0x30)
	103	switch(m_gfx_banking & 0x30)
104	104	{
105	105	//          case 0x00:
106	106	//          case 0x10: code += 0; break;
r21026	r21027
114	114	sx = 496 - sx;
115	115	sy = 240 - sy;
116	116	}
117		drawgfx_transpen(bitmap,cliprect,machine.gfx[1],
	117	drawgfx_transpen(bitmap,cliprect,machine().gfx[1],
118	118	code,
119	119	color,
120	120	flipscreen,flipscreen,
r21026	r21027
183	183	UINT32 egghunt_state::screen_update_egghunt(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
184	184	{
185	185	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
186		draw_sprites(machine(), bitmap, cliprect);
	186	draw_sprites(bitmap, cliprect);
187	187	return 0;
188	188	}
189	189

trunk/src/mame/drivers/bfcobra.c

r21026	r21027
89	89	#define M6809_XTAL  1000000
90	90
91	91
92		/*
93		Function prototypes
94		*/
95		INLINE void z80_bank(running_machine &machine, int num, int data);
96	92
97
98	93	/***************************************************************************
99	94
100	95	Split into video\cobra.c !
r21026	r21027
308	303	void exec_w_phase(UINT8 data);
309	304	void init_ram();
310	305	void command_phase(struct fdc_t &fdc, UINT8 data);
	306	inline UINT8* blitter_get_addr(UINT32 addr);
	307	inline void z80_bank(int num, int data);
	308	UINT8 exec_r_phase(void);
	309	UINT8 results_phase(void);
311	310	};
312	311
313	312
r21026	r21027
434	433	return 0;
435	434	}
436	435
437		INLINE UINT8* blitter_get_addr(running_machine &machine, UINT32 addr)
	436	UINT8* bfcobra_state::blitter_get_addr(UINT32 addr)
438	437	{
439		bfcobra_state *state = machine.driver_data<bfcobra_state>();
440	438	if (addr < 0x10000)
441	439	{
442	440	/* Is this region fixed? */
443		return (UINT8*)(state->memregion("user1")->base() + addr);
	441	return (UINT8*)(memregion("user1")->base() + addr);
444	442	}
445	443	else if(addr < 0x20000)
446	444	{
447	445	addr &= 0xffff;
448		addr += (state->m_bank_data[0] & 1) ? 0x10000 : 0;
	446	addr += (m_bank_data[0] & 1) ? 0x10000 : 0;
449	447
450		return (UINT8*)(machine.root_device().memregion("user1")->base() + addr + ((state->m_bank_data[0] >> 1) * 0x20000));
	448	return (UINT8*)(machine().root_device().memregion("user1")->base() + addr + ((m_bank_data[0] >> 1) * 0x20000));
451	449	}
452	450	else if (addr >= 0x20000 && addr < 0x40000)
453	451	{
454		return (UINT8*)&state->m_video_ram[addr - 0x20000];
	452	return (UINT8*)&m_video_ram[addr - 0x20000];
455	453	}
456	454	else
457	455	{
458		return (UINT8*)&state->m_work_ram[addr - 0x40000];
	456	return (UINT8*)&m_work_ram[addr - 0x40000];
459	457	}
460	458	}
461	459
r21026	r21027
467	465	*/
468	466	void bfcobra_state::RunBlit(address_space &space)
469	467	{
470		#define BLITPRG_READ(x)     blitter.x = *(blitter_get_addr(space.machine(), blitter.program.addr++))
	468	#define BLITPRG_READ(x)     blitter.x = *(blitter_get_addr(blitter.program.addr++))
471	469
472	470	struct blitter_t &blitter = m_blitter;
473	471	int cycles_used = 0;
r21026	r21027
577	575	blitter.source.addr0 -=blitter.step;
578	576	}
579	577
580		*blitter_get_addr(space.machine(), blitter.dest.addr) = blitter.pattern;
	578	*blitter_get_addr( blitter.dest.addr) = blitter.pattern;
581	579	cycles_used++;
582	580
583	581	} while (--innercnt);
r21026	r21027
591	589
592	590	if (LOOPTYPE == 3 && innercnt == blitter.innercnt)
593	591	{
594		srcdata = *(blitter_get_addr(space.machine(), blitter.source.addr & 0xfffff));
	592	srcdata = *(blitter_get_addr( blitter.source.addr & 0xfffff));
595	593	blitter.source.loword++;
596	594	cycles_used++;
597	595	}
r21026	r21027
601	599	{
602	600	if (LOOPTYPE == 0 || LOOPTYPE == 1)
603	601	{
604		srcdata = *(blitter_get_addr(space.machine(), blitter.source.addr & 0xfffff));
	602	srcdata = *(blitter_get_addr( blitter.source.addr & 0xfffff));
605	603	cycles_used++;
606	604
607	605	if (blitter.modectl & MODE_SSIGN)
r21026	r21027
616	614	/* Read destination pixel? */
617	615	if (LOOPTYPE == 0)
618	616	{
619		dstdata = *blitter_get_addr(space.machine(), blitter.dest.addr & 0xfffff);
	617	dstdata = *blitter_get_addr( blitter.dest.addr & 0xfffff);
620	618	cycles_used++;
621	619	}
622	620
r21026	r21027
685	683	The existing destination pixel is used as a lookup
686	684	into the table and the colours is replaced.
687	685	*/
688		UINT8 dest = *blitter_get_addr(space.machine(), blitter.dest.addr);
689		UINT8 newcol = *(blitter_get_addr(space.machine(), (blitter.source.addr + dest) & 0xfffff));
	686	UINT8 dest = *blitter_get_addr( blitter.dest.addr);
	687	UINT8 newcol = *(blitter_get_addr( (blitter.source.addr + dest) & 0xfffff));
690	688
691		*blitter_get_addr(space.machine(), blitter.dest.addr) = newcol;
	689	*blitter_get_addr( blitter.dest.addr) = newcol;
692	690	cycles_used += 3;
693	691	}
694	692	else
r21026	r21027
707	705	if (blitter.compfunc & CMPFUNC_LOG0)
708	706	final_result |= ~result & ~dstdata;
709	707
710		*blitter_get_addr(space.machine(), blitter.dest.addr) = final_result;
	708	*blitter_get_addr( blitter.dest.addr) = final_result;
711	709	cycles_used++;
712	710	}
713	711	}
r21026	r21027
956	954
957	955	data &= 0x3f;
958	956	m_bank_data[offset] = data;
959		z80_bank(machine(), offset, data);
	957	z80_bank(offset, data);
960	958	break;
961	959	}
962	960
r21026	r21027
1031	1029	}
1032	1030	}
1033	1031
1034		INLINE void z80_bank(running_machine &machine, int num, int data)
	1032	void bfcobra_state::z80_bank(int num, int data)
1035	1033	{
1036		bfcobra_state *state = machine.driver_data<bfcobra_state>();
1037	1034	static const char * const bank_names[] = { "bank1", "bank2", "bank3" };
1038	1035
1039	1036	if (data < 0x08)
1040	1037	{
1041		UINT32 offset = ((state->m_bank_data[0] >> 1) * 0x20000) + ((0x4000 * data) ^ ((state->m_bank_data[0] & 1) ? 0 : 0x10000));
	1038	UINT32 offset = ((m_bank_data[0] >> 1) * 0x20000) + ((0x4000 * data) ^ ((m_bank_data[0] & 1) ? 0 : 0x10000));
1042	1039
1043		state->membank(bank_names[num - 1])->set_base(machine.root_device().memregion("user1")->base() + offset);
	1040	membank(bank_names[num - 1])->set_base(machine().root_device().memregion("user1")->base() + offset);
1044	1041	}
1045	1042	else if (data < 0x10)
1046	1043	{
1047		state->membank(bank_names[num - 1])->set_base(&state->m_video_ram[(data - 0x08) * 0x4000]);
	1044	membank(bank_names[num - 1])->set_base(&m_video_ram[(data - 0x08) * 0x4000]);
1048	1045	}
1049	1046	else
1050	1047	{
1051		state->membank(bank_names[num - 1])->set_base(&state->m_work_ram[(data - 0x10) * 0x4000]);
	1048	membank(bank_names[num - 1])->set_base(&m_work_ram[(data - 0x10) * 0x4000]);
1052	1049	}
1053	1050	}
1054	1051
1055	1052	WRITE8_MEMBER(bfcobra_state::rombank_w)
1056	1053	{
1057	1054	m_bank_data[0] = data;
1058		z80_bank(machine(), 1, m_bank_data[1]);
1059		z80_bank(machine(), 2, m_bank_data[2]);
1060		z80_bank(machine(), 3, m_bank_data[3]);
	1055	z80_bank(1, m_bank_data[1]);
	1056	z80_bank(2, m_bank_data[2]);
	1057	z80_bank(3, m_bank_data[3]);
1061	1058	}
1062	1059
1063	1060
r21026	r21027
1297	1294	}
1298	1295
1299	1296	#ifdef UNUSED_FUNCTION
1300		UINT8 exec_r_phase(void)
	1297	UINT8 bfcobra_state::exec_r_phase(void)
1301	1298	{
1302	1299	return 0;
1303	1300	}
r21026	r21027
1308	1305	}
1309	1306
1310	1307	#ifdef UNUSED_FUNCTION
1311		UINT8 results_phase(void)
	1308	UINT8 bfcobra_state::results_phase(void)
1312	1309	{
1313	1310	return 0;
1314	1311	}

trunk/src/mame/drivers/m63.c

r21026	r21027
186	186	UINT32 screen_update_m63(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
187	187	INTERRUPT_GEN_MEMBER(snd_irq);
188	188	INTERRUPT_GEN_MEMBER(vblank_irq);
	189	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
189	190	};
190	191
191	192
r21026	r21027
313	314	m_fg_tilemap->set_transparent_pen(0);
314	315	}
315	316
316		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	317	void m63_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
317	318	{
318		m63_state *state = machine.driver_data<m63_state>();
319	319	int offs;
320	320
321		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	321	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
322	322	{
323		int code = state->m_spriteram[offs + 1] | ((state->m_spriteram[offs + 2] & 0x10) << 4);
324		int color = (state->m_spriteram[offs + 2] & 0x0f) + (state->m_pal_bank << 4);
325		int flipx = state->m_spriteram[offs + 2] & 0x20;
	323	int code = m_spriteram[offs + 1] | ((m_spriteram[offs + 2] & 0x10) << 4);
	324	int color = (m_spriteram[offs + 2] & 0x0f) + (m_pal_bank << 4);
	325	int flipx = m_spriteram[offs + 2] & 0x20;
326	326	int flipy = 0;
327		int sx = state->m_spriteram[offs + 3];
328		int sy = state->m_sy_offset - state->m_spriteram[offs];
	327	int sx = m_spriteram[offs + 3];
	328	int sy = m_sy_offset - m_spriteram[offs];
329	329
330		if (state->flip_screen())
	330	if (flip_screen())
331	331	{
332	332	sx = 240 - sx;
333		sy = state->m_sy_offset - sy;
	333	sy = m_sy_offset - sy;
334	334	flipx = !flipx;
335	335	flipy = !flipy;
336	336	}
337	337
338	338	drawgfx_transpen(bitmap, cliprect,
339		machine.gfx[2],
	339	machine().gfx[2],
340	340	code, color,
341	341	flipx, flipy,
342	342	sx, sy, 0);
r21026	r21027
345	345	if (sx > 0xf0)
346	346	{
347	347	drawgfx_transpen(bitmap, cliprect,
348		machine.gfx[2],
	348	machine().gfx[2],
349	349	code, color,
350	350	flipx, flipy,
351	351	sx - 0x100, sy, 0);
r21026	r21027
362	362	m_bg_tilemap->set_scrolly(col, m_scrollram[col * 8]);
363	363
364	364	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
365		draw_sprites(machine(), bitmap, cliprect);
	365	draw_sprites(bitmap, cliprect);
366	366	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
367	367	return 0;
368	368	}

trunk/src/mame/drivers/bfm_sc1.c

r21026	r21027
181	181	virtual void machine_reset();
182	182	INTERRUPT_GEN_MEMBER(timer_irq);
183	183	void sc1_common_init(int reels, int decrypt, int defaultbank);
	184	void Scorpion1_SetSwitchState(int strobe, int data, int state);
	185	int Scorpion1_GetSwitchState(int strobe, int data);
	186	int sc1_find_project_string( );
184	187	};
185	188
186	189	#define VFD_RESET  0x20
r21026	r21027
192	195
193	196	///////////////////////////////////////////////////////////////////////////
194	197
195		static void Scorpion1_SetSwitchState(bfm_sc1_state *drvstate, int strobe, int data, int state)
	198	void bfm_sc1_state::Scorpion1_SetSwitchState(int strobe, int data, int state)
196	199	{
197		if ( state ) drvstate->m_sc1_Inputs[strobe] |=  (1<<data);
198		else         drvstate->m_sc1_Inputs[strobe] &= ~(1<<data);
	200	if ( state ) m_sc1_Inputs[strobe] |=  (1<<data);
	201	else         m_sc1_Inputs[strobe] &= ~(1<<data);
199	202	}
200	203
201	204	///////////////////////////////////////////////////////////////////////////
202	205	#ifdef UNUSED_FUNCTION
203		static int Scorpion1_GetSwitchState(bfm_sc1_state *drvstate, int strobe, int data)
	206	int bfm_sc1_state::Scorpion1_GetSwitchState(int strobe, int data)
204	207	{
205	208	int state = 0;
206	209
207		if ( strobe < 7 && data < 8 ) state = (drvstate->sc1_Inputs[strobe] & (1<<data))?1:0;
	210	if ( strobe < 7 && data < 8 ) state = (sc1_Inputs[strobe] & (1<<data))?1:0;
208	211
209	212	return state;
210	213	}
r21026	r21027
1171	1174	}
1172	1175
1173	1176
1174		int sc1_find_project_string(running_machine &machine )
	1177	int bfm_sc1_state::sc1_find_project_string( )
1175	1178	{
1176	1179	// search for the project string to find the title (usually just at ff00)
1177	1180	char title_string[7][32] = { "PROJECT NUMBER", "PROJECT PR", "PROJECT ", "CASH ON THE NILE 2", "PR6121", "CHINA TOWN\x0d\x0a", "PROJECTNUMBER" };
1178		UINT8 *src = machine.root_device().memregion( "maincpu" )->base();
1179		int size = machine.root_device().memregion( "maincpu" )->bytes();
	1181	UINT8 *src = machine().root_device().memregion( "maincpu" )->base();
	1182	int size = machine().root_device().memregion( "maincpu" )->bytes();
1180	1183
1181	1184	for (int search=0;search<7;search++)
1182	1185	{
r21026	r21027
1252	1255	sc1_common_init(3,1, 3);
1253	1256	adder2_decode_char_roms(machine()); // decode GFX roms
1254	1257	MechMtr_config(machine(),8);
1255		sc1_find_project_string(machine());
	1258	sc1_find_project_string();
1256	1259	}
1257	1260
1258	1261	DRIVER_INIT_MEMBER(bfm_sc1_state,lotse)
1259	1262	{
1260	1263	sc1_common_init(6,1, 3);
1261	1264	MechMtr_config(machine(),8);
1262		sc1_find_project_string(machine());
	1265	sc1_find_project_string();
1263	1266	}
1264	1267
1265	1268	DRIVER_INIT_MEMBER(bfm_sc1_state,lotse_bank0)
1266	1269	{
1267	1270	sc1_common_init(6,1, 0);
1268	1271	MechMtr_config(machine(),8);
1269		sc1_find_project_string(machine());
	1272	sc1_find_project_string();
1270	1273	}
1271	1274
1272	1275
r21026	r21027
1274	1277	{
1275	1278	sc1_common_init(6,0, 3);
1276	1279	MechMtr_config(machine(),8);
1277		sc1_find_project_string(machine());
	1280	sc1_find_project_string();
1278	1281	}
1279	1282
1280	1283	DRIVER_INIT_MEMBER(bfm_sc1_state,nocrypt_bank0)
1281	1284	{
1282	1285	sc1_common_init(6,0, 0);
1283	1286	MechMtr_config(machine(),8);
1284		sc1_find_project_string(machine());
	1287	sc1_find_project_string();
1285	1288	}
1286	1289
1287	1290
r21026	r21027
1291	1294	{
1292	1295	sc1_common_init(6,0, 3);
1293	1296	MechMtr_config(machine(),8);
1294		sc1_find_project_string(machine());
	1297	sc1_find_project_string();
1295	1298	}
1296	1299
1297	1300	/////////////////////////////////////////////////////////////////////////////////////
r21026	r21027
1301	1304	sc1_common_init(6,1, 3);
1302	1305	MechMtr_config(machine(),8);
1303	1306
1304		Scorpion1_SetSwitchState(this,3,2,1);
1305		Scorpion1_SetSwitchState(this,3,3,1);
1306		Scorpion1_SetSwitchState(this,3,6,1);
1307		Scorpion1_SetSwitchState(this,4,1,1);
1308		sc1_find_project_string(machine());
	1307	Scorpion1_SetSwitchState(3,2,1);
	1308	Scorpion1_SetSwitchState(3,3,1);
	1309	Scorpion1_SetSwitchState(3,6,1);
	1310	Scorpion1_SetSwitchState(4,1,1);
	1311	sc1_find_project_string();
1309	1312	}
1310	1313
1311	1314

trunk/src/mame/drivers/cops.c

r21026	r21027
88	88
89	89	void laserdisc_w(UINT8 data);
90	90	void laserdisc_response_w(UINT8 data);
	91	DECLARE_PALETTE_INIT( cops );
91	92	};
92	93
93	94	void cops_state::video_start()
r21026	r21027
617	618	}
618	619
619	620
620		static PALETTE_INIT( cops )
	621	PALETTE_INIT_MEMBER( cops_state,cops )
621	622	{
622	623	}
623	624
r21026	r21027
635	636	MCFG_SCREEN_SIZE(32*8, 32*8)
636	637	MCFG_SCREEN_VISIBLE_AREA(0*8, 32*8-1, 2*8, 30*8-1)
637	638
638		MCFG_PALETTE_INIT(cops)
	639	MCFG_PALETTE_INIT_OVERRIDE(cops_state,cops)
639	640	MCFG_PALETTE_LENGTH(8)
640	641
641	642	/* via */

trunk/src/mame/drivers/mediagx.c

r21026	r21027
200	200	DECLARE_READ32_MEMBER(speedup11_r);
201	201	TIMER_DEVICE_CALLBACK_MEMBER(sound_timer_callback);
202	202	IRQ_CALLBACK_MEMBER(irq_callback);
	203	void draw_char(bitmap_rgb32 &bitmap, const rectangle &cliprect, gfx_element *gfx, int ch, int att, int x, int y);
	204	void draw_framebuffer(bitmap_rgb32 &bitmap, const rectangle &cliprect);
	205	void draw_cga(bitmap_rgb32 &bitmap, const rectangle &cliprect);
	206	void ad1847_reg_write(int reg, UINT8 data);
	207	inline UINT32 generic_speedup(address_space &space, int idx);
	208	void report_speedups();
	209	void install_speedups(const speedup_entry *entries, int count);
	210	void init_mediagx();
203	211	};
204	212
205	213	// Display controller registers
r21026	r21027
252	260	}
253	261	}
254	262
255		static void draw_char(bitmap_rgb32 &bitmap, const rectangle &cliprect, gfx_element *gfx, int ch, int att, int x, int y)
	263	void mediagx_state::draw_char(bitmap_rgb32 &bitmap, const rectangle &cliprect, gfx_element *gfx, int ch, int att, int x, int y)
256	264	{
257	265	int i,j;
258	266	const UINT8 *dp;
r21026	r21027
278	286	}
279	287	}
280	288
281		static void draw_framebuffer(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect)
	289	void mediagx_state::draw_framebuffer(bitmap_rgb32 &bitmap, const rectangle &cliprect)
282	290	{
283		mediagx_state *state = machine.driver_data<mediagx_state>();
284	291	int i, j;
285	292	int width, height;
286		int line_delta = (state->m_disp_ctrl_reg[DC_LINE_DELTA] & 0x3ff) * 4;
	293	int line_delta = (m_disp_ctrl_reg[DC_LINE_DELTA] & 0x3ff) * 4;
287	294
288		width = (state->m_disp_ctrl_reg[DC_H_TIMING_1] & 0x7ff) + 1;
289		if (state->m_disp_ctrl_reg[DC_TIMING_CFG] & 0x8000)     // pixel double
	295	width = (m_disp_ctrl_reg[DC_H_TIMING_1] & 0x7ff) + 1;
	296	if (m_disp_ctrl_reg[DC_TIMING_CFG] & 0x8000)     // pixel double
290	297	{
291	298	width >>= 1;
292	299	}
293	300	width += 4;
294	301
295		height = (state->m_disp_ctrl_reg[DC_V_TIMING_1] & 0x7ff) + 1;
	302	height = (m_disp_ctrl_reg[DC_V_TIMING_1] & 0x7ff) + 1;
296	303
297		if ( (width != state->m_frame_width || height != state->m_frame_height) &&
	304	if ( (width != m_frame_width || height != m_frame_height) &&
298	305	(width > 1 && height > 1 && width <= 640 && height <= 480) )
299	306	{
300	307	rectangle visarea;
301	308
302		state->m_frame_width = width;
303		state->m_frame_height = height;
	309	m_frame_width = width;
	310	m_frame_height = height;
304	311
305	312	visarea.set(0, width - 1, 0, height - 1);
306		machine.primary_screen->configure(width, height * 262 / 240, visarea, machine.primary_screen->frame_period().attoseconds);
	313	machine().primary_screen->configure(width, height * 262 / 240, visarea, machine().primary_screen->frame_period().attoseconds);
307	314	}
308	315
309		if (state->m_disp_ctrl_reg[DC_OUTPUT_CFG] & 0x1)        // 8-bit mode
	316	if (m_disp_ctrl_reg[DC_OUTPUT_CFG] & 0x1)        // 8-bit mode
310	317	{
311		UINT8 *framebuf = (UINT8*)&state->m_vram[state->m_disp_ctrl_reg[DC_FB_ST_OFFSET]/4];
312		UINT8 *pal = state->m_pal;
	318	UINT8 *framebuf = (UINT8*)&m_vram[m_disp_ctrl_reg[DC_FB_ST_OFFSET]/4];
	319	UINT8 *pal = m_pal;
313	320
314		for (j=0; j < state->m_frame_height; j++)
	321	for (j=0; j < m_frame_height; j++)
315	322	{
316	323	UINT32 *p = &bitmap.pix32(j);
317	324	UINT8 *si = &framebuf[j * line_delta];
318		for (i=0; i < state->m_frame_width; i++)
	325	for (i=0; i < m_frame_width; i++)
319	326	{
320	327	int c = *si++;
321	328	int r = pal[(c*3)+0] << 2;
r21026	r21027
328	335	}
329	336	else            // 16-bit
330	337	{
331		UINT16 *framebuf = (UINT16*)&state->m_vram[state->m_disp_ctrl_reg[DC_FB_ST_OFFSET]/4];
	338	UINT16 *framebuf = (UINT16*)&m_vram[m_disp_ctrl_reg[DC_FB_ST_OFFSET]/4];
332	339
333	340	// RGB 5-6-5 mode
334		if ((state->m_disp_ctrl_reg[DC_OUTPUT_CFG] & 0x2) == 0)
	341	if ((m_disp_ctrl_reg[DC_OUTPUT_CFG] & 0x2) == 0)
335	342	{
336		for (j=0; j < state->m_frame_height; j++)
	343	for (j=0; j < m_frame_height; j++)
337	344	{
338	345	UINT32 *p = &bitmap.pix32(j);
339	346	UINT16 *si = &framebuf[j * (line_delta/2)];
340		for (i=0; i < state->m_frame_width; i++)
	347	for (i=0; i < m_frame_width; i++)
341	348	{
342	349	UINT16 c = *si++;
343	350	int r = ((c >> 11) & 0x1f) << 3;
r21026	r21027
351	358	// RGB 5-5-5 mode
352	359	else
353	360	{
354		for (j=0; j < state->m_frame_height; j++)
	361	for (j=0; j < m_frame_height; j++)
355	362	{
356	363	UINT32 *p = &bitmap.pix32(j);
357	364	UINT16 *si = &framebuf[j * (line_delta/2)];
358		for (i=0; i < state->m_frame_width; i++)
	365	for (i=0; i < m_frame_width; i++)
359	366	{
360	367	UINT16 c = *si++;
361	368	int r = ((c >> 10) & 0x1f) << 3;
r21026	r21027
369	376	}
370	377	}
371	378
372		static void draw_cga(running_machine &machine, bitmap_rgb32 &bitmap, const rectangle &cliprect)
	379	void mediagx_state::draw_cga(bitmap_rgb32 &bitmap, const rectangle &cliprect)
373	380	{
374		mediagx_state *state = machine.driver_data<mediagx_state>();
375	381	int i, j;
376		gfx_element *gfx = machine.gfx[0];
377		UINT32 *cga = state->m_cga_ram;
	382	gfx_element *gfx = machine().gfx[0];
	383	UINT32 *cga = m_cga_ram;
378	384	int index = 0;
379	385
380	386	for (j=0; j < 25; j++)
r21026	r21027
397	403	{
398	404	bitmap.fill(0, cliprect);
399	405
400		draw_framebuffer(machine(), bitmap, cliprect);
	406	draw_framebuffer( bitmap, cliprect);
401	407
402	408	if (m_disp_ctrl_reg[DC_OUTPUT_CFG] & 0x1)   // don't show MDA text screen on 16-bit mode. this is basically a hack
403	409	{
404		draw_cga(machine(), bitmap, cliprect);
	410	draw_cga(bitmap, cliprect);
405	411	}
406	412	return 0;
407	413	}
r21026	r21027
749	755	m_dacr_ptr = 0;
750	756	}
751	757
752		static void ad1847_reg_write(running_machine &machine, int reg, UINT8 data)
	758	void mediagx_state::ad1847_reg_write(int reg, UINT8 data)
753	759	{
754		mediagx_state *state = machine.driver_data<mediagx_state>();
755	760	static const int divide_factor[] = { 3072, 1536, 896, 768, 448, 384, 512, 2560 };
756	761
757	762	switch (reg)
r21026	r21027
760	765	{
761	766	if (data & 0x1)
762	767	{
763		state->m_ad1847_sample_rate = 16934400 / divide_factor[(data >> 1) & 0x7];
	768	m_ad1847_sample_rate = 16934400 / divide_factor[(data >> 1) & 0x7];
764	769	}
765	770	else
766	771	{
767		state->m_ad1847_sample_rate = 24576000 / divide_factor[(data >> 1) & 0x7];
	772	m_ad1847_sample_rate = 24576000 / divide_factor[(data >> 1) & 0x7];
768	773	}
769	774
770		dmadac_set_frequency(&state->m_dmadac[0], 2, state->m_ad1847_sample_rate);
	775	dmadac_set_frequency(&m_dmadac[0], 2, m_ad1847_sample_rate);
771	776
772	777	if (data & 0x20)
773	778	{
r21026	r21027
782	787
783	788	default:
784	789	{
785		state->m_ad1847_regs[reg] = data;
	790	m_ad1847_regs[reg] = data;
786	791	break;
787	792	}
788	793	}
r21026	r21027
818	823	else if (offset == 3)
819	824	{
820	825	int reg = (data >> 8) & 0xf;
821		ad1847_reg_write(machine(), reg, data & 0xff);
	826	ad1847_reg_write(reg, data & 0xff);
822	827	}
823	828	}
824	829
r21026	r21027
1233	1238	pic8259_ir1_w(state->m_pic8259_1, _state);
1234	1239	}
1235	1240
1236		static void init_mediagx(running_machine &machine)
	1241	void mediagx_state::init_mediagx()
1237	1242	{
1238		mediagx_state *state = machine.driver_data<mediagx_state>();
	1243	m_frame_width = m_frame_height = 1;
1239	1244
1240		state->m_frame_width = state->m_frame_height = 1;
	1245	init_pc_common(machine(), PCCOMMON_KEYBOARD_AT,mediagx_set_keyb_int);
1241	1246
1242		init_pc_common(machine, PCCOMMON_KEYBOARD_AT,mediagx_set_keyb_int);
1243
1244		kbdc8042_init(machine, &at8042);
	1247	kbdc8042_init(machine(), &at8042);
1245	1248	}
1246	1249
1247	1250	#if SPEEDUP_HACKS
1248	1251
1249		INLINE UINT32 generic_speedup(address_space &space, int idx)
	1252	UINT32 mediagx_state::generic_speedup(address_space &space, int idx)
1250	1253	{
1251		mediagx_state *state = space.machine().driver_data<mediagx_state>();
1252
1253		if (space.device().safe_pc() == state->m_speedup_table[idx].pc)
	1254	if (space.device().safe_pc() == m_speedup_table[idx].pc)
1254	1255	{
1255		state->m_speedup_hits[idx]++;
	1256	m_speedup_hits[idx]++;
1256	1257	space.device().execute().spin_until_interrupt();
1257	1258	}
1258		return state->m_main_ram[state->m_speedup_table[idx].offset/4];
	1259	return m_main_ram[m_speedup_table[idx].offset/4];
1259	1260	}
1260	1261
1261	1262	READ32_MEMBER(mediagx_state::speedup0_r) { return generic_speedup(space, 0); }
r21026	r21027
1279	1280	};
1280	1281
1281	1282	#ifdef MAME_DEBUG
1282		static void report_speedups(running_machine &machine)
	1283	void mediagx_state::report_speedups()
1283	1284	{
1284		mediagx_state *state = machine.driver_data<mediagx_state>();
1285	1285	int i;
1286	1286
1287		for (i = 0; i < state->m_speedup_count; i++)
1288		printf("Speedup %2d: offs=%06X pc=%06X hits=%d\n", i, state->m_speedup_table[i].offset, state->m_speedup_table[i].pc, state->m_speedup_hits[i]);
	1287	for (i = 0; i < m_speedup_count; i++)
	1288	printf("Speedup %2d: offs=%06X pc=%06X hits=%d\n", i, m_speedup_table[i].offset, m_speedup_table[i].pc, m_speedup_hits[i]);
1289	1289	}
1290	1290	#endif
1291	1291
1292		static void install_speedups(running_machine &machine, const speedup_entry *entries, int count)
	1292	void mediagx_state::install_speedups(const speedup_entry *entries, int count)
1293	1293	{
1294		mediagx_state *state = machine.driver_data<mediagx_state>();
1295	1294	int i;
1296	1295
1297	1296	assert(count < ARRAY_LENGTH(speedup_handlers));
1298	1297
1299		state->m_speedup_table = entries;
1300		state->m_speedup_count = count;
	1298	m_speedup_table = entries;
	1299	m_speedup_count = count;
1301	1300
1302	1301	for (i = 0; i < count; i++) {
1303	1302	read32_delegate func = speedup_handlers[i].func;
1304		func.late_bind(*state);
1305		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(entries[i].offset, entries[i].offset + 3, func);
	1303	func.late_bind(*this);
	1304	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(entries[i].offset, entries[i].offset + 3, func);
1306	1305	}
1307	1306
1308	1307	#ifdef MAME_DEBUG
1309		machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(report_speedups), &machine));
	1308	machine().add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(report_speedups), &machine));
1310	1309	#endif
1311	1310	}
1312	1311
r21026	r21027
1328	1327
1329	1328	DRIVER_INIT_MEMBER(mediagx_state,a51site4)
1330	1329	{
1331		init_mediagx(machine());
	1330	init_mediagx();
1332	1331
1333	1332	#if SPEEDUP_HACKS
1334		install_speedups(machine(), a51site4_speedups, ARRAY_LENGTH(a51site4_speedups));
	1333	install_speedups(a51site4_speedups, ARRAY_LENGTH(a51site4_speedups));
1335	1334	#endif
1336	1335	}
1337	1336

trunk/src/mame/drivers/firebeat.c

r21026	r21027
239	239	DECLARE_WRITE32_MEMBER(ppc_spu_share_w);
240	240	DECLARE_READ16_MEMBER(spu_unk_r);
241	241	TIMER_CALLBACK_MEMBER(keyboard_timer_callback);
	242	void gcu_draw_object(bitmap_ind16 &bitmap, const rectangle &cliprect, int chip, UINT32 *cmd);
	243	void gcu_fill_rect(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 *cmd);
	244	void gcu_draw_character(bitmap_ind16 &bitmap, const rectangle &cliprect, int chip, UINT32 *cmd);
	245	void gcu_exec_display_list(bitmap_ind16 &bitmap, const rectangle &cliprect, int chip, UINT32 address);
	246	UINT32 update_screen(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int chip);
	247	UINT32 GCU_r(int chip, UINT32 offset, UINT32 mem_mask);
	248	void GCU_w(int chip, UINT32 offset, UINT32 data, UINT32 mem_mask);
	249	void atapi_cause_irq();
	250	void atapi_clear_irq();
	251	void atapi_init();
	252	void atapi_reset();
	253	UINT16 atapi_command_reg_r(int reg);
	254	void atapi_command_reg_w(int reg, UINT16 data);
	255	UINT16 atapi_control_reg_r(int reg);
	256	void atapi_control_reg_w(int reg, UINT16 data);
	257	void set_ibutton(UINT8 *data);
	258	int ibutton_w(UINT8 data);
	259	void init_lights(write32_delegate out1, write32_delegate out2, write32_delegate out3);
	260	void init_firebeat();
	261	void init_keyboard();
242	262	};
243	263
244	264
r21026	r21027
255	275	}
256	276
257	277
258		static void gcu_draw_object(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int chip, UINT32 *cmd)
	278	void firebeat_state::gcu_draw_object(bitmap_ind16 &bitmap, const rectangle &cliprect, int chip, UINT32 *cmd)
259	279	{
260		firebeat_state *state = machine.driver_data<firebeat_state>();
261	280	// 0x00: xxx----- -------- -------- --------   command type
262	281	// 0x00: -------- xxxxxxxx xxxxxxxx xxxxxxxx   object data address in vram
263	282
r21026	r21027
287	306
288	307	int i, j;
289	308	int u, v;
290		UINT16 *vr = (UINT16*)state->m_gcu[chip].vram;
	309	UINT16 *vr = (UINT16*)m_gcu[chip].vram;
291	310
292	311	if (xscale == 0 || yscale == 0)
293	312	{
r21026	r21027
409	428	}
410	429	}
411	430
412		static void gcu_fill_rect(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 *cmd)
	431	void firebeat_state::gcu_fill_rect(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 *cmd)
413	432	{
414	433	int i, j;
415	434	int x1, y1, x2, y2;
r21026	r21027
456	475	}
457	476	}
458	477
459		static void gcu_draw_character(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int chip, UINT32 *cmd)
	478	void firebeat_state::gcu_draw_character(bitmap_ind16 &bitmap, const rectangle &cliprect, int chip, UINT32 *cmd)
460	479	{
461		firebeat_state *state = machine.driver_data<firebeat_state>();
462	480	// 0x00: xxx----- -------- -------- --------   command type
463	481	// 0x00: -------- xxxxxxxx xxxxxxxx xxxxxxxx   character data address in vram
464	482
r21026	r21027
477	495	UINT32 address      = cmd[0] & 0xffffff;
478	496	UINT16 color[4];
479	497
480		UINT16 *vr = (UINT16*)state->m_gcu[chip].vram;
	498	UINT16 *vr = (UINT16*)m_gcu[chip].vram;
481	499
482	500	color[0] = (cmd[2] >> 16) & 0xffff;
483	501	color[1] = (cmd[2] >>  0) & 0xffff;
r21026	r21027
505	523	}
506	524	}
507	525
508		static void gcu_exec_display_list(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int chip, UINT32 address)
	526	void firebeat_state::gcu_exec_display_list(bitmap_ind16 &bitmap, const rectangle &cliprect, int chip, UINT32 address)
509	527	{
510		firebeat_state *state = machine.driver_data<firebeat_state>();
511	528	int counter = 0;
512	529	int end = 0;
513	530
r21026	r21027
517	534	{
518	535	int command;
519	536	UINT32 cmd[4];
520		cmd[0] = state->m_gcu[chip].vram[i+0];
521		cmd[1] = state->m_gcu[chip].vram[i+1];
522		cmd[2] = state->m_gcu[chip].vram[i+2];
523		cmd[3] = state->m_gcu[chip].vram[i+3];
	537	cmd[0] = m_gcu[chip].vram[i+0];
	538	cmd[1] = m_gcu[chip].vram[i+1];
	539	cmd[2] = m_gcu[chip].vram[i+2];
	540	cmd[3] = m_gcu[chip].vram[i+3];
524	541
525	542	command = (cmd[0] >> 29) & 0x7;
526	543
r21026	r21027
533	550
534	551	case 0x1:       // Branch
535	552	{
536		gcu_exec_display_list(machine, bitmap, cliprect, chip, cmd[0] & 0xffffff);
	553	gcu_exec_display_list(bitmap, cliprect, chip, cmd[0] & 0xffffff);
537	554	break;
538	555	}
539	556
r21026	r21027
556	573
557	574	case 0x5:       // Draw object
558	575	{
559		gcu_draw_object(machine, bitmap, cliprect, chip, cmd);
	576	gcu_draw_object(bitmap, cliprect, chip, cmd);
560	577	break;
561	578	}
562	579
563	580	case 0x7:       // Draw 8x8 Character (2-bits per pixel)
564	581	{
565		gcu_draw_character(machine, bitmap, cliprect, chip, cmd);
	582	gcu_draw_character(bitmap, cliprect, chip, cmd);
566	583	break;
567	584	}
568	585
r21026	r21027
576	593	};
577	594	}
578	595
579		static UINT32 update_screen(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int chip)
	596	UINT32 firebeat_state::update_screen(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int chip)
580	597	{
581		firebeat_state *state = screen.machine().driver_data<firebeat_state>();
582
583	598	bitmap.fill(0, cliprect);
584	599
585	600	if ((mame_strnicmp(screen.machine().system().name, "popn", 4) == 0) || (mame_strnicmp(screen.machine().system().name, "bm3", 3) == 0))
586	601	{
587		gcu_exec_display_list(screen.machine(), bitmap, cliprect, chip, 0x1f80000);
	602	gcu_exec_display_list( bitmap, cliprect, chip, 0x1f80000);
588	603	}
589	604	else
590	605	{
591		if (state->m_layer >= 2)
	606	if (m_layer >= 2)
592	607	{
593		gcu_exec_display_list(screen.machine(), bitmap, cliprect, chip, 0x8000);
594		gcu_exec_display_list(screen.machine(), bitmap, cliprect, chip, 0x0000);
595		gcu_exec_display_list(screen.machine(), bitmap, cliprect, chip, 0x10000);
	608	gcu_exec_display_list(bitmap, cliprect, chip, 0x8000);
	609	gcu_exec_display_list(bitmap, cliprect, chip, 0x0000);
	610	gcu_exec_display_list(bitmap, cliprect, chip, 0x10000);
596	611	}
597		else if (state->m_layer == 0)
	612	else if (m_layer == 0)
598	613	{
599		gcu_exec_display_list(screen.machine(), bitmap, cliprect, chip, 0x200000);
	614	gcu_exec_display_list(bitmap, cliprect, chip, 0x200000);
600	615
601		//gcu_exec_display_list(screen.machine(), bitmap, cliprect, chip, 0x186040);
	616	//gcu_exec_display_list(bitmap, cliprect, chip, 0x186040);
602	617	}
603		else if (state->m_layer == 1)
	618	else if (m_layer == 1)
604	619	{
605		gcu_exec_display_list(screen.machine(), bitmap, cliprect, chip, 0x1d0800);
	620	gcu_exec_display_list(bitmap, cliprect, chip, 0x1d0800);
606	621
607		gcu_exec_display_list(screen.machine(), bitmap, cliprect, chip, 0x1a9440);
	622	gcu_exec_display_list(bitmap, cliprect, chip, 0x1a9440);
608	623	}
609	624	}
610	625
611		state->m_tick++;
612		if (state->m_tick >= 5)
	626	m_tick++;
	627	if (m_tick >= 5)
613	628	{
614		state->m_tick = 0;
	629	m_tick = 0;
615	630	if (screen.machine().input().code_pressed(KEYCODE_0))
616	631	{
617		state->m_layer++;
618		if (state->m_layer > 2)
	632	m_layer++;
	633	if (m_layer > 2)
619	634	{
620		state->m_layer = 0;
	635	m_layer = 0;
621	636	}
622	637	}
623	638
r21026	r21027
629	644
630	645	for (i=0; i < 0x2000000/4; i++)
631	646	{
632		fputc((state->m_gcu[0].vram[i] >> 24) & 0xff, file);
633		fputc((state->m_gcu[0].vram[i] >> 16) & 0xff, file);
634		fputc((state->m_gcu[0].vram[i] >> 8) & 0xff, file);
635		fputc((state->m_gcu[0].vram[i] >> 0) & 0xff, file);
	647	fputc((m_gcu[0].vram[i] >> 24) & 0xff, file);
	648	fputc((m_gcu[0].vram[i] >> 16) & 0xff, file);
	649	fputc((m_gcu[0].vram[i] >> 8) & 0xff, file);
	650	fputc((m_gcu[0].vram[i] >> 0) & 0xff, file);
636	651	}
637	652
638	653	fclose(file);
r21026	r21027
640	655
641	656	for (i=0; i < 0x2000000/4; i++)
642	657	{
643		fputc((state->m_gcu[1].vram[i] >> 24) & 0xff, file);
644		fputc((state->m_gcu[1].vram[i] >> 16) & 0xff, file);
645		fputc((state->m_gcu[1].vram[i] >> 8) & 0xff, file);
646		fputc((state->m_gcu[1].vram[i] >> 0) & 0xff, file);
	658	fputc((m_gcu[1].vram[i] >> 24) & 0xff, file);
	659	fputc((m_gcu[1].vram[i] >> 16) & 0xff, file);
	660	fputc((m_gcu[1].vram[i] >> 8) & 0xff, file);
	661	fputc((m_gcu[1].vram[i] >> 0) & 0xff, file);
647	662	}
648	663
649	664	fclose(file);
r21026	r21027
657	672	UINT32 firebeat_state::screen_update_firebeat_0(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect){ return update_screen(screen, bitmap, cliprect, 0); }
658	673	UINT32 firebeat_state::screen_update_firebeat_1(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect){ return update_screen(screen, bitmap, cliprect, 1); }
659	674
660		static UINT32 GCU_r(running_machine &machine, int chip, UINT32 offset, UINT32 mem_mask)
	675	UINT32 firebeat_state::GCU_r(int chip, UINT32 offset, UINT32 mem_mask)
661	676	{
662		firebeat_state *state = machine.driver_data<firebeat_state>();
663	677	int reg = offset * 4;
664	678
665	679	/* VRAM Read */
666	680	if (reg >= 0x80 && reg < 0x100)
667	681	{
668		return state->m_gcu[chip].vram[state->m_gcu[chip].vram_read_address + ((reg/4) - 0x20)];
	682	return m_gcu[chip].vram[m_gcu[chip].vram_read_address + ((reg/4) - 0x20)];
669	683	}
670	684
671	685	switch(reg)
r21026	r21027
681	695	return 0xffffffff;
682	696	}
683	697
684		static void GCU_w(running_machine &machine, int chip, UINT32 offset, UINT32 data, UINT32 mem_mask)
	698	void firebeat_state::GCU_w(int chip, UINT32 offset, UINT32 data, UINT32 mem_mask)
685	699	{
686		firebeat_state *state = machine.driver_data<firebeat_state>();
687	700	int reg = offset * 4;
688	701
689	702	if (reg != 0x70 && chip == 0)
690	703	{
691		//printf("%s:gcu%d_w: %08X, %08X, %08X at %08X\n", machine.describe_context(), chip, data, offset, mem_mask);
	704	//printf("%s:gcu%d_w: %08X, %08X, %08X at %08X\n", machine().describe_context(), chip, data, offset, mem_mask);
692	705	//logerror("%s:gcu%d_w: %08X, %08X, %08X at %08X\n", cmachine->describe_context(), hip, data, offset, mem_mask);
693	706	}
694	707
r21026	r21027
698	711	/* IRQ clear/enable; ppd writes bit off then on in response to interrupt */
699	712	/* it enables bits 0x41, but 0x01 seems to be the one it cares about */
700	713	if (ACCESSING_BITS_16_31 && (data & 0x0001) == 0)
701		machine.device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
	714	machine().device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
702	715	break;
703	716
704	717	case 0x30:
r21026	r21027
706	719	//case 0x38:
707	720	//case 0x3c:
708	721	{
709		COMBINE_DATA( &state->m_gcu[chip].visible_area );
	722	COMBINE_DATA( &m_gcu[chip].visible_area );
710	723	if (ACCESSING_BITS_0_15)
711	724	{
712		screen_device_iterator iter(machine.root_device());
	725	screen_device_iterator iter(machine().root_device());
713	726	screen_device *screen = iter.byindex(chip);
714	727
715	728	if (screen != NULL)
r21026	r21027
717	730	rectangle visarea = screen->visible_area();
718	731	int width, height;
719	732
720		width = (state->m_gcu[chip].visible_area & 0xffff);
721		height = (state->m_gcu[chip].visible_area >> 16) & 0xffff;
	733	width = (m_gcu[chip].visible_area & 0xffff);
	734	height = (m_gcu[chip].visible_area >> 16) & 0xffff;
722	735
723	736	visarea.max_x = width-1;
724	737	visarea.max_y = height-1;
r21026	r21027
732	745	case 0x40:      /* framebuffer config */
733	746	// HACK: switch display lists at the right times for the ParaParaParadise games until we
734	747	// do the video emulation properly
735		if (mame_strnicmp(machine.system().name, "pp", 2) == 0)
	748	if (mame_strnicmp(machine().system().name, "pp", 2) == 0)
736	749	{
737	750	switch (data)
738	751	{
739	752	case 0x00080000:    // post
740		state->m_layer = 0;
	753	m_layer = 0;
741	754	break;
742	755
743	756	case 0x00008400:    // startup tests
744		if (state->m_layer != 2)
	757	if (m_layer != 2)
745	758	{
746		state->m_layer = 1;
	759	m_layer = 1;
747	760	}
748	761	break;
749	762
750	763	case 0x00068400:    // game & svc menu
751		state->m_layer = 2;
	764	m_layer = 2;
752	765	break;
753	766	}
754	767	}
755		else if (mame_strnicmp(machine.system().name, "kbm", 3) == 0)
	768	else if (mame_strnicmp(machine().system().name, "kbm", 3) == 0)
756	769	{
757	770	switch (data)
758	771	{
759	772	case 0x00080000:    // post
760		state->m_layer = 0;
	773	m_layer = 0;
761	774	break;
762	775
763	776	case 0x0000c400:    // game & svn menu
764		state->m_layer = 2;
	777	m_layer = 2;
765	778	break;
766	779	}
767	780	}
r21026	r21027
771	784	//  break;
772	785
773	786	case 0x5c:      /* VRAM Read Address */
774		state->m_gcu[chip].vram_read_address = (data & 0xffffff) / 2;
	787	m_gcu[chip].vram_read_address = (data & 0xffffff) / 2;
775	788	break;
776	789
777	790	case 0x60:      /* VRAM FIFO Write Address */
778		state->m_gcu[chip].vram_write_fifo_address = (data & 0xffffff) / 2;
	791	m_gcu[chip].vram_write_fifo_address = (data & 0xffffff) / 2;
779	792
780	793	//      printf("gcu%d_w: %08X, %08X, %08X\n", chip, data, offset, mem_mask);
781	794	break;
r21026	r21027
786	799	}
787	800
788	801	case 0x70:      /* VRAM FIFO Write */
789		state->m_gcu[chip].vram[state->m_gcu[chip].vram_write_fifo_address] = data;
790		state->m_gcu[chip].vram_write_fifo_address++;
	802	m_gcu[chip].vram[m_gcu[chip].vram_write_fifo_address] = data;
	803	m_gcu[chip].vram_write_fifo_address++;
791	804	break;
792	805
793	806	default:
r21026	r21027
798	811
799	812	READ32_MEMBER(firebeat_state::gcu0_r)
800	813	{
801		return GCU_r(space.machine(), 0, offset, mem_mask);
	814	return GCU_r(0, offset, mem_mask);
802	815	}
803	816
804	817	WRITE32_MEMBER(firebeat_state::gcu0_w)
805	818	{
806		GCU_w(space.machine(), 0, offset, data, mem_mask);
	819	GCU_w(0, offset, data, mem_mask);
807	820	}
808	821
809	822	READ32_MEMBER(firebeat_state::gcu1_r)
810	823	{
811		return GCU_r(space.machine(), 1, offset, mem_mask);
	824	return GCU_r(1, offset, mem_mask);
812	825	}
813	826
814	827	WRITE32_MEMBER(firebeat_state::gcu1_w)
815	828	{
816		GCU_w(space.machine(), 1, offset, data, mem_mask);
	829	GCU_w(1, offset, data, mem_mask);
817	830	}
818	831
819	832	/*****************************************************************************/
r21026	r21027
824	837
825	838	if (ACCESSING_BITS_24_31)
826	839	{
827		r |= (space.machine().root_device().ioport("IN0")->read() & 0xff) << 24;
	840	r |= (machine().root_device().ioport("IN0")->read() & 0xff) << 24;
828	841	}
829	842	if (ACCESSING_BITS_8_15)
830	843	{
831		r |= (space.machine().root_device().ioport("IN1")->read() & 0xff) << 8;
	844	r |= (machine().root_device().ioport("IN1")->read() & 0xff) << 8;
832	845	}
833	846	if (ACCESSING_BITS_0_7)
834	847	{
835		r |= (space.machine().root_device().ioport("IN2")->read() & 0xff);
	848	r |= (machine().root_device().ioport("IN2")->read() & 0xff);
836	849	}
837	850
838	851	return r;
r21026	r21027
842	855	{
843	856	if (offset == 0)
844	857	{
845		return space.machine().root_device().ioport("SENSOR1")->read() | 0x01000100;
	858	return machine().root_device().ioport("SENSOR1")->read() | 0x01000100;
846	859	}
847	860	else
848	861	{
849		return space.machine().root_device().ioport("SENSOR2")->read() | 0x01000100;
	862	return machine().root_device().ioport("SENSOR2")->read() | 0x01000100;
850	863	}
851	864	}
852	865
r21026	r21027
994	1007	#define ATAPI_REG_CMDSTATUS 7
995	1008
996	1009
997		static void atapi_cause_irq(running_machine &machine)
	1010	void firebeat_state::atapi_cause_irq()
998	1011	{
999		machine.device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ4, ASSERT_LINE);
	1012	machine().device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ4, ASSERT_LINE);
1000	1013	}
1001	1014
1002		static void atapi_clear_irq(running_machine &machine)
	1015	void firebeat_state::atapi_clear_irq()
1003	1016	{
1004		machine.device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ4, CLEAR_LINE);
	1017	machine().device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ4, CLEAR_LINE);
1005	1018	}
1006	1019
1007		static void atapi_init(running_machine &machine)
	1020	void firebeat_state::atapi_init()
1008	1021	{
1009		firebeat_state *state = machine.driver_data<firebeat_state>();
1010		memset(state->m_atapi_regs, 0, sizeof(state->m_atapi_regs));
	1022	memset(m_atapi_regs, 0, sizeof(m_atapi_regs));
1011	1023
1012		state->m_atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
1013		state->m_atapi_regs[ATAPI_REG_ERRFEAT] = 1;
1014		state->m_atapi_regs[ATAPI_REG_COUNTLOW] = 0x14;
1015		state->m_atapi_regs[ATAPI_REG_COUNTHIGH] = 0xeb;
	1024	m_atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
	1025	m_atapi_regs[ATAPI_REG_ERRFEAT] = 1;
	1026	m_atapi_regs[ATAPI_REG_COUNTLOW] = 0x14;
	1027	m_atapi_regs[ATAPI_REG_COUNTHIGH] = 0xeb;
1016	1028
1017		state->m_atapi_data_ptr = 0;
1018		state->m_atapi_cdata_wait = 0;
	1029	m_atapi_data_ptr = 0;
	1030	m_atapi_cdata_wait = 0;
1019	1031
1020		state->m_atapi_device_data[0] = machine.device<scsihle_device>( "scsi0" );
1021		state->m_atapi_device_data[1] = machine.device<scsihle_device>( "scsi1" );
	1032	m_atapi_device_data[0] = machine().device<scsihle_device>( "scsi0" );
	1033	m_atapi_device_data[1] = machine().device<scsihle_device>( "scsi1" );
1022	1034	}
1023	1035
1024		static void atapi_reset(running_machine &machine)
	1036	void firebeat_state::atapi_reset()
1025	1037	{
1026		firebeat_state *state = machine.driver_data<firebeat_state>();
1027	1038	logerror("ATAPI reset\n");
1028	1039
1029		state->m_atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
1030		state->m_atapi_regs[ATAPI_REG_ERRFEAT] = 1;
1031		state->m_atapi_regs[ATAPI_REG_COUNTLOW] = 0x14;
1032		state->m_atapi_regs[ATAPI_REG_COUNTHIGH] = 0xeb;
	1040	m_atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
	1041	m_atapi_regs[ATAPI_REG_ERRFEAT] = 1;
	1042	m_atapi_regs[ATAPI_REG_COUNTLOW] = 0x14;
	1043	m_atapi_regs[ATAPI_REG_COUNTHIGH] = 0xeb;
1033	1044
1034		state->m_atapi_data_ptr = 0;
1035		state->m_atapi_cdata_wait = 0;
	1045	m_atapi_data_ptr = 0;
	1046	m_atapi_cdata_wait = 0;
1036	1047	}
1037	1048
1038	1049
1039	1050
1040		static UINT16 atapi_command_reg_r(running_machine &machine, int reg)
	1051	UINT16 firebeat_state::atapi_command_reg_r(int reg)
1041	1052	{
1042		firebeat_state *state = machine.driver_data<firebeat_state>();
1043	1053	int i, data;
1044	1054
1045	1055	//  printf("ATAPI: Command reg read %d\n", reg);
r21026	r21027
1047	1057	if (reg == ATAPI_REG_DATA)
1048	1058	{
1049	1059	// assert IRQ and drop DRQ
1050		if (state->m_atapi_data_ptr == 0)
	1060	if (m_atapi_data_ptr == 0)
1051	1061	{
1052	1062	//printf("ATAPI: dropping DRQ\n");
1053		atapi_cause_irq(machine);
1054		state->m_atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
	1063	atapi_cause_irq();
	1064	m_atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
1055	1065
1056	1066	// get the data from the device
1057		state->m_atapi_device_data[state->m_atapi_drivesel]->ReadData( state->m_temp_data, state->m_atapi_xferlen );
	1067	m_atapi_device_data[m_atapi_drivesel]->ReadData( m_temp_data, m_atapi_xferlen );
1058	1068
1059	1069	// fix it up in an endian-safe way
1060		for (i = 0; i < state->m_atapi_xferlen; i += 2)
	1070	for (i = 0; i < m_atapi_xferlen; i += 2)
1061	1071	{
1062		state->m_atapi_data[i/2] = state->m_temp_data[i+0] | state->m_temp_data[i+1]<<8;
	1072	m_atapi_data[i/2] = m_temp_data[i+0] | m_temp_data[i+1]<<8;
1063	1073	}
1064	1074	}
1065	1075
1066		data = state->m_atapi_data[state->m_atapi_data_ptr];
1067		//      printf("ATAPI: %d, packet read = %04x\n", state->m_atapi_data_ptr, state->m_atapi_data[state->m_atapi_data_ptr]);
1068		state->m_atapi_data_ptr++;
	1076	data = m_atapi_data[m_atapi_data_ptr];
	1077	//      printf("ATAPI: %d, packet read = %04x\n", m_atapi_data_ptr, m_atapi_data[m_atapi_data_ptr]);
	1078	m_atapi_data_ptr++;
1069	1079
1070		if (state->m_atapi_xfermod && state->m_atapi_data_ptr == (state->m_atapi_xferlen/2))
	1080	if (m_atapi_xfermod && m_atapi_data_ptr == (m_atapi_xferlen/2))
1071	1081	{
1072	1082	//printf("ATAPI: DRQ interrupt\n");
1073		atapi_cause_irq(machine);
1074		state->m_atapi_regs[ATAPI_REG_CMDSTATUS] |= ATAPI_STAT_DRQ;
1075		state->m_atapi_data_ptr = 0;
	1083	atapi_cause_irq();
	1084	m_atapi_regs[ATAPI_REG_CMDSTATUS] |= ATAPI_STAT_DRQ;
	1085	m_atapi_data_ptr = 0;
1076	1086
1077		if (state->m_atapi_xfermod > 63488)
	1087	if (m_atapi_xfermod > 63488)
1078	1088	{
1079		state->m_atapi_xfermod = state->m_atapi_xfermod - 63488;
1080		state->m_atapi_xferlen = 63488;
	1089	m_atapi_xfermod = m_atapi_xfermod - 63488;
	1090	m_atapi_xferlen = 63488;
1081	1091	}
1082	1092	else
1083	1093	{
1084		state->m_atapi_xferlen = state->m_atapi_xfermod;
1085		state->m_atapi_xfermod = 0;
	1094	m_atapi_xferlen = m_atapi_xfermod;
	1095	m_atapi_xfermod = 0;
1086	1096	}
1087	1097
1088		//printf("ATAPI Transfer: %d, %d, %d\n", atapi_transfer_length, state->m_atapi_xfermod, state->m_atapi_xferlen);
	1098	//printf("ATAPI Transfer: %d, %d, %d\n", atapi_transfer_length, m_atapi_xfermod, m_atapi_xferlen);
1089	1099
1090		state->m_atapi_regs[ATAPI_REG_COUNTLOW] = state->m_atapi_xferlen & 0xff;
1091		state->m_atapi_regs[ATAPI_REG_COUNTHIGH] = (state->m_atapi_xferlen>>8)&0xff;
	1100	m_atapi_regs[ATAPI_REG_COUNTLOW] = m_atapi_xferlen & 0xff;
	1101	m_atapi_regs[ATAPI_REG_COUNTHIGH] = (m_atapi_xferlen>>8)&0xff;
1092	1102	}
1093	1103	return data;
1094	1104	}
1095	1105	else
1096	1106	{
1097	1107	if (reg == ATAPI_REG_CMDSTATUS)
1098		atapi_clear_irq(machine);
1099		return state->m_atapi_regs[reg];
	1108	atapi_clear_irq();
	1109	return m_atapi_regs[reg];
1100	1110	}
1101	1111	}
1102	1112
1103		static void atapi_command_reg_w(running_machine &machine, int reg, UINT16 data)
	1113	void firebeat_state::atapi_command_reg_w(int reg, UINT16 data)
1104	1114	{
1105		firebeat_state *state = machine.driver_data<firebeat_state>();
1106	1115	int i;
1107	1116
1108	1117	if (reg == ATAPI_REG_DATA)
1109	1118	{
1110	1119	//      printf("%s:ATAPI: packet write %04x\n", device->machine().describe_context(), data);
1111		state->m_atapi_data[state->m_atapi_data_ptr] = data;
1112		state->m_atapi_data_ptr++;
	1120	m_atapi_data[m_atapi_data_ptr] = data;
	1121	m_atapi_data_ptr++;
1113	1122
1114		if (state->m_atapi_cdata_wait)
	1123	if (m_atapi_cdata_wait)
1115	1124	{
1116		//          printf("ATAPI: waiting, ptr %d wait %d\n", state->m_atapi_data_ptr, state->m_atapi_cdata_wait);
1117		if (state->m_atapi_data_ptr == state->m_atapi_cdata_wait)
	1125	//          printf("ATAPI: waiting, ptr %d wait %d\n", m_atapi_data_ptr, m_atapi_cdata_wait);
	1126	if (m_atapi_data_ptr == m_atapi_cdata_wait)
1118	1127	{
1119	1128	// decompose SCSI packet into proper byte order
1120		for (i = 0; i < state->m_atapi_cdata_wait; i += 2)
	1129	for (i = 0; i < m_atapi_cdata_wait; i += 2)
1121	1130	{
1122		state->m_atapi_scsi_packet[i] = state->m_atapi_data[i/2]&0xff;
1123		state->m_atapi_scsi_packet[i+1] = state->m_atapi_data[i/2]>>8;
	1131	m_atapi_scsi_packet[i] = m_atapi_data[i/2]&0xff;
	1132	m_atapi_scsi_packet[i+1] = m_atapi_data[i/2]>>8;
1124	1133	}
1125	1134
1126	1135	// send it to the device
1127		state->m_atapi_device_data[state->m_atapi_drivesel]->WriteData( state->m_atapi_scsi_packet, state->m_atapi_cdata_wait );
	1136	m_atapi_device_data[m_atapi_drivesel]->WriteData( m_atapi_scsi_packet, m_atapi_cdata_wait );
1128	1137
1129	1138	// assert IRQ
1130		atapi_cause_irq(machine);
	1139	atapi_cause_irq();
1131	1140
1132	1141	// not sure here, but clear DRQ at least?
1133		state->m_atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
	1142	m_atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
1134	1143	}
1135	1144	}
1136	1145
1137		if ((!state->m_atapi_cdata_wait) && (state->m_atapi_data_ptr == 6))
	1146	if ((!m_atapi_cdata_wait) && (m_atapi_data_ptr == 6))
1138	1147	{
1139	1148	int phase;
1140	1149
1141	1150	// reset data pointer for reading SCSI results
1142		state->m_atapi_data_ptr = 0;
	1151	m_atapi_data_ptr = 0;
1143	1152
1144		state->m_atapi_regs[ATAPI_REG_CMDSTATUS] |= ATAPI_STAT_BSY;
	1153	m_atapi_regs[ATAPI_REG_CMDSTATUS] |= ATAPI_STAT_BSY;
1145	1154
1146	1155	// assert IRQ
1147		atapi_cause_irq(machine);
	1156	atapi_cause_irq();
1148	1157
1149	1158	// decompose SCSI packet into proper byte order
1150	1159	for (i = 0; i < 16; i += 2)
1151	1160	{
1152		state->m_atapi_scsi_packet[i+0] = state->m_atapi_data[i/2]&0xff;
1153		state->m_atapi_scsi_packet[i+1] = state->m_atapi_data[i/2]>>8;
	1161	m_atapi_scsi_packet[i+0] = m_atapi_data[i/2]&0xff;
	1162	m_atapi_scsi_packet[i+1] = m_atapi_data[i/2]>>8;
1154	1163	}
1155	1164
1156	1165	// send it to the SCSI device
1157		state->m_atapi_device_data[state->m_atapi_drivesel]->SetCommand( state->m_atapi_scsi_packet, 12 );
1158		state->m_atapi_device_data[state->m_atapi_drivesel]->ExecCommand( &state->m_atapi_xferlen );
1159		state->m_atapi_device_data[state->m_atapi_drivesel]->GetPhase( &phase );
	1166	m_atapi_device_data[m_atapi_drivesel]->SetCommand( m_atapi_scsi_packet, 12 );
	1167	m_atapi_device_data[m_atapi_drivesel]->ExecCommand( &m_atapi_xferlen );
	1168	m_atapi_device_data[m_atapi_drivesel]->GetPhase( &phase );
1160	1169
1161		if (state->m_atapi_xferlen != -1)
	1170	if (m_atapi_xferlen != -1)
1162	1171	{
1163		logerror("ATAPI: SCSI command %02x returned %d bytes from the device\n", state->m_atapi_data[0]&0xff, state->m_atapi_xferlen);
	1172	logerror("ATAPI: SCSI command %02x returned %d bytes from the device\n", m_atapi_data[0]&0xff, m_atapi_xferlen);
1164	1173
1165	1174	// store the returned command length in the ATAPI regs, splitting into
1166	1175	// multiple transfers if necessary
1167	1176
1168		state->m_atapi_xfermod = 0;
1169		if (state->m_atapi_xferlen > 63488)
	1177	m_atapi_xfermod = 0;
	1178	if (m_atapi_xferlen > 63488)
1170	1179	{
1171		state->m_atapi_xfermod = state->m_atapi_xferlen - 63488;
1172		state->m_atapi_xferlen = 63488;
	1180	m_atapi_xfermod = m_atapi_xferlen - 63488;
	1181	m_atapi_xferlen = 63488;
1173	1182	}
1174	1183
1175		//              printf("ATAPI Transfer: %d, %d\n", state->m_atapi_xfermod, state->m_atapi_xferlen);
	1184	//              printf("ATAPI Transfer: %d, %d\n", m_atapi_xfermod, m_atapi_xferlen);
1176	1185
1177		state->m_atapi_regs[ATAPI_REG_COUNTLOW] = state->m_atapi_xferlen & 0xff;
1178		state->m_atapi_regs[ATAPI_REG_COUNTHIGH] = (state->m_atapi_xferlen>>8)&0xff;
	1186	m_atapi_regs[ATAPI_REG_COUNTLOW] = m_atapi_xferlen & 0xff;
	1187	m_atapi_regs[ATAPI_REG_COUNTHIGH] = (m_atapi_xferlen>>8)&0xff;
1179	1188
1180	1189	switch( phase )
1181	1190	{
1182	1191	case SCSI_PHASE_DATAOUT:
1183		state->m_atapi_data_ptr = 0;
1184		state->m_atapi_cdata_wait = state->m_atapi_xferlen;
1185		logerror("ATAPI: Waiting for %x bytes of data\n", state->m_atapi_cdata_wait);
	1192	m_atapi_data_ptr = 0;
	1193	m_atapi_cdata_wait = m_atapi_xferlen;
	1194	logerror("ATAPI: Waiting for %x bytes of data\n", m_atapi_cdata_wait);
1186	1195	break;
1187	1196	}
1188	1197
1189	1198	// perform special ATAPI processing of certain commands
1190		//if (state->m_atapi_drivesel==1) logerror("!!!ATAPI COMMAND %x\n", state->m_atapi_data[0]&0xff);
1191		switch (state->m_atapi_data[0]&0xff)
	1199	//if (m_atapi_drivesel==1) logerror("!!!ATAPI COMMAND %x\n", m_atapi_data[0]&0xff);
	1200	switch (m_atapi_data[0]&0xff)
1192	1201	{
1193	1202	case 0x55:  // MODE SELECT
1194		state->m_atapi_cdata_wait = state->m_atapi_data[4]/2;
1195		state->m_atapi_data_ptr = 0;
1196		logerror("ATAPI: Waiting for %x bytes of MODE SELECT data\n", state->m_atapi_cdata_wait);
	1203	m_atapi_cdata_wait = m_atapi_data[4]/2;
	1204	m_atapi_data_ptr = 0;
	1205	logerror("ATAPI: Waiting for %x bytes of MODE SELECT data\n", m_atapi_cdata_wait);
1197	1206	break;
1198	1207
1199	1208
1200	1209	case 0xa8:  // READ (12)
1201	1210	// indicate data ready: set DRQ and DMA ready, and IO in INTREASON
1202		state->m_atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_DRQ | ATAPI_STAT_SERVDSC;
1203		state->m_atapi_regs[ATAPI_REG_INTREASON] = ATAPI_INTREASON_IO;
	1211	m_atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_DRQ | ATAPI_STAT_SERVDSC;
	1212	m_atapi_regs[ATAPI_REG_INTREASON] = ATAPI_INTREASON_IO;
1204	1213
1205	1214	fatalerror("ATAPI: DMA read command attempted\n");
1206	1215	break;
r21026	r21027
1210	1219	case 0xa5: // PLAY AUDIO
1211	1220	case 0x1b: // START_STOP_UNIT
1212	1221	case 0x4e: // STOPPLAY_SCAN
1213		state->m_atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
	1222	m_atapi_regs[ATAPI_REG_CMDSTATUS] = 0;
1214	1223	break;
1215	1224	}
1216	1225	}
r21026	r21027
1218	1227	{
1219	1228	//              printf("ATAPI: SCSI device returned error!\n");
1220	1229
1221		state->m_atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_DRQ | ATAPI_STAT_CHECK;
1222		state->m_atapi_regs[ATAPI_REG_ERRFEAT] = 0x50;  // sense key = ILLEGAL REQUEST
1223		state->m_atapi_regs[ATAPI_REG_COUNTLOW] = 0;
1224		state->m_atapi_regs[ATAPI_REG_COUNTHIGH] = 0;
	1230	m_atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_DRQ | ATAPI_STAT_CHECK;
	1231	m_atapi_regs[ATAPI_REG_ERRFEAT] = 0x50;  // sense key = ILLEGAL REQUEST
	1232	m_atapi_regs[ATAPI_REG_COUNTLOW] = 0;
	1233	m_atapi_regs[ATAPI_REG_COUNTHIGH] = 0;
1225	1234	}
1226	1235	}
1227	1236	}
1228	1237	else
1229	1238	{
1230	1239	data &= 0xff;
1231		state->m_atapi_regs[reg] = data;
	1240	m_atapi_regs[reg] = data;
1232	1241	//      printf("ATAPI: Command reg %d = %02X\n", reg, data);
1233	1242
1234	1243	switch(reg)
1235	1244	{
1236	1245	case ATAPI_REG_DRIVESEL:
1237		state->m_atapi_drivesel = (data >> 4) & 0x1;
	1246	m_atapi_drivesel = (data >> 4) & 0x1;
1238	1247	break;
1239	1248
1240	1249	case ATAPI_REG_CMDSTATUS:
r21026	r21027
1246	1255	break;
1247	1256
1248	1257	case 0x08:      /* ATAPI Soft Reset */
1249		atapi_reset(machine);
	1258	atapi_reset();
1250	1259	break;
1251	1260
1252	1261	case 0xa0:      /* ATAPI Packet */
1253		state->m_atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_BSY | ATAPI_STAT_DRQ;
1254		state->m_atapi_regs[ATAPI_REG_INTREASON] = ATAPI_INTREASON_COMMAND;
	1262	m_atapi_regs[ATAPI_REG_CMDSTATUS] = ATAPI_STAT_BSY | ATAPI_STAT_DRQ;
	1263	m_atapi_regs[ATAPI_REG_INTREASON] = ATAPI_INTREASON_COMMAND;
1255	1264
1256		state->m_atapi_data_ptr = 0;
1257		state->m_atapi_cdata_wait = 0;
	1265	m_atapi_data_ptr = 0;
	1266	m_atapi_cdata_wait = 0;
1258	1267	break;
1259	1268
1260	1269	default:
r21026	r21027
1265	1274	}
1266	1275	}
1267	1276
1268		static UINT16 atapi_control_reg_r(running_machine &machine, int reg)
	1277	UINT16 firebeat_state::atapi_control_reg_r(int reg)
1269	1278	{
1270		firebeat_state *state = machine.driver_data<firebeat_state>();
1271	1279	UINT16 value;
1272	1280	switch(reg)
1273	1281	{
1274	1282	case 0x6:
1275	1283	{
1276		value = state->m_atapi_regs[ATAPI_REG_CMDSTATUS];
1277		if (state->m_atapi_regs[ATAPI_REG_CMDSTATUS] & ATAPI_STAT_BSY)
	1284	value = m_atapi_regs[ATAPI_REG_CMDSTATUS];
	1285	if (m_atapi_regs[ATAPI_REG_CMDSTATUS] & ATAPI_STAT_BSY)
1278	1286	{
1279		state->m_atapi_regs[ATAPI_REG_CMDSTATUS] ^= ATAPI_STAT_BSY;
	1287	m_atapi_regs[ATAPI_REG_CMDSTATUS] ^= ATAPI_STAT_BSY;
1280	1288	}
1281	1289	return value;
1282	1290	}
r21026	r21027
1289	1297	return 0;
1290	1298	}
1291	1299
1292		static void atapi_control_reg_w(running_machine &machine, int reg, UINT16 data)
	1300	void firebeat_state::atapi_control_reg_w(int reg, UINT16 data)
1293	1301	{
1294	1302	switch(reg)
1295	1303	{
r21026	r21027
1297	1305	{
1298	1306	if (data & 0x4)
1299	1307	{
1300		atapi_reset(machine);
	1308	atapi_reset();
1301	1309	}
1302	1310	break;
1303	1311	}
r21026	r21027
1315	1323	//  printf("atapi_command_r: %08X, %08X\n", offset, mem_mask);
1316	1324	if (ACCESSING_BITS_16_31)
1317	1325	{
1318		r = atapi_command_reg_r(space.machine(), offset*2);
	1326	r = atapi_command_reg_r(offset*2);
1319	1327	return ATAPI_ENDIAN(r) << 16;
1320	1328	}
1321	1329	else
1322	1330	{
1323		r = atapi_command_reg_r(space.machine(), (offset*2) + 1);
	1331	r = atapi_command_reg_r((offset*2) + 1);
1324	1332	return ATAPI_ENDIAN(r) << 0;
1325	1333	}
1326	1334	}
r21026	r21027
1331	1339
1332	1340	if (ACCESSING_BITS_16_31)
1333	1341	{
1334		atapi_command_reg_w(space.machine(), offset*2, ATAPI_ENDIAN((data >> 16) & 0xffff));
	1342	atapi_command_reg_w(offset*2, ATAPI_ENDIAN((data >> 16) & 0xffff));
1335	1343	}
1336	1344	else
1337	1345	{
1338		atapi_command_reg_w(space.machine(), (offset*2) + 1, ATAPI_ENDIAN((data >> 0) & 0xffff));
	1346	atapi_command_reg_w((offset*2) + 1, ATAPI_ENDIAN((data >> 0) & 0xffff));
1339	1347	}
1340	1348	}
1341	1349
r21026	r21027
1347	1355
1348	1356	if (ACCESSING_BITS_16_31)
1349	1357	{
1350		r = atapi_control_reg_r(space.machine(), offset*2);
	1358	r = atapi_control_reg_r(offset*2);
1351	1359	return ATAPI_ENDIAN(r) << 16;
1352	1360	}
1353	1361	else
1354	1362	{
1355		r = atapi_control_reg_r(space.machine(), (offset*2) + 1);
	1363	r = atapi_control_reg_r((offset*2) + 1);
1356	1364	return ATAPI_ENDIAN(r) << 0;
1357	1365	}
1358	1366	}
r21026	r21027
1361	1369	{
1362	1370	if (ACCESSING_BITS_16_31)
1363	1371	{
1364		atapi_control_reg_w(space.machine(), offset*2, ATAPI_ENDIAN(data >> 16) & 0xff);
	1372	atapi_control_reg_w(offset*2, ATAPI_ENDIAN(data >> 16) & 0xff);
1365	1373	}
1366	1374	else
1367	1375	{
1368		atapi_control_reg_w(space.machine(), (offset*2) + 1, ATAPI_ENDIAN(data >> 0) & 0xff);
	1376	atapi_control_reg_w((offset*2) + 1, ATAPI_ENDIAN(data >> 0) & 0xff);
1369	1377	}
1370	1378	}
1371	1379
r21026	r21027
2166	2174
2167	2175
2168	2176
2169		static void set_ibutton(firebeat_state *state, UINT8 *data)
	2177	void firebeat_state::set_ibutton(UINT8 *data)
2170	2178	{
2171	2179	int i, j;
2172	2180
r21026	r21027
2175	2183	// identifier
2176	2184	for (j=0; j < 8; j++)
2177	2185	{
2178		state->m_ibutton.subkey[i].identifier[j] = *data++;
	2186	m_ibutton.subkey[i].identifier[j] = *data++;
2179	2187	}
2180	2188
2181	2189	// password
2182	2190	for (j=0; j < 8; j++)
2183	2191	{
2184		state->m_ibutton.subkey[i].password[j] = *data++;
	2192	m_ibutton.subkey[i].password[j] = *data++;
2185	2193	}
2186	2194
2187	2195	// data
2188	2196	for (j=0; j < 48; j++)
2189	2197	{
2190		state->m_ibutton.subkey[i].data[j] = *data++;
	2198	m_ibutton.subkey[i].data[j] = *data++;
2191	2199	}
2192	2200	}
2193	2201	}
2194	2202
2195		static int ibutton_w(running_machine &machine, UINT8 data)
	2203	int firebeat_state::ibutton_w(UINT8 data)
2196	2204	{
2197		firebeat_state *state = machine.driver_data<firebeat_state>();
2198	2205	int r = -1;
2199	2206
2200		switch (state->m_ibutton_state)
	2207	switch (m_ibutton_state)
2201	2208	{
2202	2209	case DS1991_STATE_NORMAL:
2203	2210	{
r21026	r21027
2226	2233	case 0x66:          // DS1991 Read SubKey
2227	2234	{
2228	2235	r = 0x66;
2229		state->m_ibutton_state = DS1991_STATE_READ_SUBKEY;
2230		state->m_ibutton_read_subkey_ptr = 0;
	2236	m_ibutton_state = DS1991_STATE_READ_SUBKEY;
	2237	m_ibutton_read_subkey_ptr = 0;
2231	2238	break;
2232	2239	}
2233	2240	case 0xcc:          // DS1991 skip rom
2234	2241	{
2235	2242	r = 0xcc;
2236		state->m_ibutton_state = DS1991_STATE_NORMAL;
	2243	m_ibutton_state = DS1991_STATE_NORMAL;
2237	2244	break;
2238	2245	}
2239	2246	default:
r21026	r21027
2247	2254
2248	2255	case DS1991_STATE_READ_SUBKEY:
2249	2256	{
2250		if (state->m_ibutton_read_subkey_ptr == 0)      // Read SubKey, 2nd command byte
	2257	if (m_ibutton_read_subkey_ptr == 0)      // Read SubKey, 2nd command byte
2251	2258	{
2252	2259	int subkey = (data >> 6) & 0x3;
2253	2260	//      printf("iButton SubKey %d\n", subkey);
r21026	r21027
2255	2262
2256	2263	if (subkey < 3)
2257	2264	{
2258		memcpy(&state->m_ibutton_subkey_data[0],  state->m_ibutton.subkey[subkey].identifier, 8);
2259		memcpy(&state->m_ibutton_subkey_data[8],  state->m_ibutton.subkey[subkey].password, 8);
2260		memcpy(&state->m_ibutton_subkey_data[16], state->m_ibutton.subkey[subkey].data, 0x30);
	2265	memcpy(&m_ibutton_subkey_data[0],  m_ibutton.subkey[subkey].identifier, 8);
	2266	memcpy(&m_ibutton_subkey_data[8],  m_ibutton.subkey[subkey].password, 8);
	2267	memcpy(&m_ibutton_subkey_data[16], m_ibutton.subkey[subkey].data, 0x30);
2261	2268	}
2262	2269	else
2263	2270	{
2264		memset(&state->m_ibutton_subkey_data[0], 0, 0x40);
	2271	memset(&m_ibutton_subkey_data[0], 0, 0x40);
2265	2272	}
2266	2273	}
2267		else if (state->m_ibutton_read_subkey_ptr == 1) // Read SubKey, 3rd command byte
	2274	else if (m_ibutton_read_subkey_ptr == 1) // Read SubKey, 3rd command byte
2268	2275	{
2269	2276	r = data;
2270	2277	}
2271	2278	else
2272	2279	{
2273		r = state->m_ibutton_subkey_data[state->m_ibutton_read_subkey_ptr-2];
	2280	r = m_ibutton_subkey_data[m_ibutton_read_subkey_ptr-2];
2274	2281	}
2275		state->m_ibutton_read_subkey_ptr++;
2276		if (state->m_ibutton_read_subkey_ptr >= 0x42)
	2282	m_ibutton_read_subkey_ptr++;
	2283	if (m_ibutton_read_subkey_ptr >= 0x42)
2277	2284	{
2278		state->m_ibutton_state = DS1991_STATE_NORMAL;
	2285	m_ibutton_state = DS1991_STATE_NORMAL;
2279	2286	}
2280	2287	break;
2281	2288	}
r21026	r21027
2286	2293
2287	2294	static void security_w(device_t *device, UINT8 data)
2288	2295	{
2289		int r = ibutton_w(device->machine(), data);
	2296	firebeat_state *state = device->machine().driver_data<firebeat_state>();
	2297	int r = state->ibutton_w(data);
2290	2298	if (r >= 0)
2291	2299	ppc4xx_spu_receive_byte(device->machine().device("maincpu"), r);
2292	2300	}
2293	2301
2294	2302	/*****************************************************************************/
2295	2303
2296		static void init_lights(running_machine &machine, write32_delegate out1, write32_delegate out2, write32_delegate out3)
	2304	void firebeat_state::init_lights(write32_delegate out1, write32_delegate out2, write32_delegate out3)
2297	2305	{
2298		firebeat_state *state = machine.driver_data<firebeat_state>();
2299		if(out1.isnull()) out1 = write32_delegate(FUNC(firebeat_state::lamp_output_w),state);
2300		if(out2.isnull()) out2 = write32_delegate(FUNC(firebeat_state::lamp_output2_w),state);
2301		if(out3.isnull()) out3 = write32_delegate(FUNC(firebeat_state::lamp_output3_w),state);
	2306	if(out1.isnull()) out1 = write32_delegate(FUNC(firebeat_state::lamp_output_w),this);
	2307	if(out2.isnull()) out2 = write32_delegate(FUNC(firebeat_state::lamp_output2_w),this);
	2308	if(out3.isnull()) out3 = write32_delegate(FUNC(firebeat_state::lamp_output3_w),this);
2302	2309
2303		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x7d000804, 0x7d000807, out1);
2304		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x7d000320, 0x7d000323, out2);
2305		machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x7d000324, 0x7d000327, out3);
	2310	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x7d000804, 0x7d000807, out1);
	2311	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x7d000320, 0x7d000323, out2);
	2312	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x7d000324, 0x7d000327, out3);
2306	2313	}
2307	2314
2308		static void init_firebeat(running_machine &machine)
	2315	void firebeat_state::init_firebeat()
2309	2316	{
2310		firebeat_state *state = machine.driver_data<firebeat_state>();
2311		UINT8 *rom = state->memregion("user2")->base();
	2317	UINT8 *rom = memregion("user2")->base();
2312	2318
2313		atapi_init(machine);
	2319	atapi_init();
2314	2320
2315		pc16552d_init(machine, 0, 19660800, comm_uart_irq_callback, 0);     // Network UART
2316		pc16552d_init(machine, 1, 24000000, midi_uart_irq_callback, 0);     // MIDI UART
	2321	pc16552d_init(machine(), 0, 19660800, comm_uart_irq_callback, 0);     // Network UART
	2322	pc16552d_init(machine(), 1, 24000000, midi_uart_irq_callback, 0);     // MIDI UART
2317	2323
2318		state->m_extend_board_irq_enable = 0x3f;
2319		state->m_extend_board_irq_active = 0x00;
	2324	m_extend_board_irq_enable = 0x3f;
	2325	m_extend_board_irq_active = 0x00;
2320	2326
2321		state->m_cur_cab_data = cab_data;
	2327	m_cur_cab_data = cab_data;
2322	2328
2323		ppc4xx_spu_set_tx_handler(machine.device("maincpu"), security_w);
	2329	ppc4xx_spu_set_tx_handler(machine().device("maincpu"), security_w);
2324	2330
2325		set_ibutton(state, rom);
	2331	set_ibutton(rom);
2326	2332
2327		init_lights(machine, write32_delegate(), write32_delegate(), write32_delegate());
	2333	init_lights(write32_delegate(), write32_delegate(), write32_delegate());
2328	2334	}
2329	2335
2330	2336	DRIVER_INIT_MEMBER(firebeat_state,ppp)
2331	2337	{
2332		init_firebeat(machine());
2333		init_lights(machine(), write32_delegate(FUNC(firebeat_state::lamp_output_ppp_w),this), write32_delegate(FUNC(firebeat_state::lamp_output2_ppp_w),this), write32_delegate(FUNC(firebeat_state::lamp_output3_ppp_w),this));
	2338	init_firebeat();
	2339	init_lights(write32_delegate(FUNC(firebeat_state::lamp_output_ppp_w),this), write32_delegate(FUNC(firebeat_state::lamp_output2_ppp_w),this), write32_delegate(FUNC(firebeat_state::lamp_output3_ppp_w),this));
2334	2340	}
2335	2341
2336	2342	DRIVER_INIT_MEMBER(firebeat_state,ppd)
2337	2343	{
2338		init_firebeat(machine());
2339		init_lights(machine(), write32_delegate(FUNC(firebeat_state::lamp_output_ppp_w),this), write32_delegate(FUNC(firebeat_state::lamp_output2_ppp_w),this), write32_delegate(FUNC(firebeat_state::lamp_output3_ppp_w),this));
	2344	init_firebeat();
	2345	init_lights(write32_delegate(FUNC(firebeat_state::lamp_output_ppp_w),this), write32_delegate(FUNC(firebeat_state::lamp_output2_ppp_w),this), write32_delegate(FUNC(firebeat_state::lamp_output3_ppp_w),this));
2340	2346
2341	2347	m_cur_cab_data = ppd_cab_data;
2342	2348	}
2343	2349
2344		static void init_keyboard(running_machine &machine)
	2350	void firebeat_state::init_keyboard()
2345	2351	{
2346		firebeat_state *state = machine.driver_data<firebeat_state>();
2347	2352	// set keyboard timer
2348		state->m_keyboard_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(firebeat_state::keyboard_timer_callback),state));
2349		state->m_keyboard_timer->adjust(attotime::from_msec(10), 0, attotime::from_msec(10));
	2353	m_keyboard_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(firebeat_state::keyboard_timer_callback),this));
	2354	m_keyboard_timer->adjust(attotime::from_msec(10), 0, attotime::from_msec(10));
2350	2355	}
2351	2356
2352	2357	DRIVER_INIT_MEMBER(firebeat_state,kbm)
2353	2358	{
2354		init_firebeat(machine());
2355		init_lights(machine(), write32_delegate(FUNC(firebeat_state::lamp_output_kbm_w),this), write32_delegate(), write32_delegate());
	2359	init_firebeat();
	2360	init_lights(write32_delegate(FUNC(firebeat_state::lamp_output_kbm_w),this), write32_delegate(), write32_delegate());
2356	2361
2357		init_keyboard(machine());
	2362	init_keyboard();
2358	2363
2359	2364	m_cur_cab_data = kbm_cab_data;
2360	2365	}

trunk/src/mame/drivers/queen.c

r21026	r21027
91	91	virtual void machine_start();
92	92	virtual void machine_reset();
93	93	IRQ_CALLBACK_MEMBER(irq_callback);
	94	void intel82439tx_init();
94	95	};
95	96
96	97
r21026	r21027
134	135	state->m_mxtc_config_reg[reg] = data;
135	136	}
136	137
137		static void intel82439tx_init(running_machine &machine)
	138	void queen_state::intel82439tx_init()
138	139	{
139		queen_state *state = machine.driver_data<queen_state>();
140		state->m_mxtc_config_reg[0x60] = 0x02;
141		state->m_mxtc_config_reg[0x61] = 0x02;
142		state->m_mxtc_config_reg[0x62] = 0x02;
143		state->m_mxtc_config_reg[0x63] = 0x02;
144		state->m_mxtc_config_reg[0x64] = 0x02;
145		state->m_mxtc_config_reg[0x65] = 0x02;
	140	m_mxtc_config_reg[0x60] = 0x02;
	141	m_mxtc_config_reg[0x61] = 0x02;
	142	m_mxtc_config_reg[0x62] = 0x02;
	143	m_mxtc_config_reg[0x63] = 0x02;
	144	m_mxtc_config_reg[0x64] = 0x02;
	145	m_mxtc_config_reg[0x65] = 0x02;
146	146	}
147	147
148	148	static UINT32 intel82439tx_pci_r(device_t *busdevice, device_t *device, int function, int reg, UINT32 mem_mask)
r21026	r21027
521	521	init_pc_common(machine(), PCCOMMON_KEYBOARD_AT, queen_set_keyb_int);
522	522
523	523	m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(queen_state::irq_callback),this));
524		intel82439tx_init(machine());
	524	intel82439tx_init();
525	525
526	526	kbdc8042_init(machine(), &at8042);
527	527	}

trunk/src/mame/drivers/igs011.c

r21026	r21027
205	205	UINT32 screen_update_igs011(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
206	206	void screen_eof_vbowl(screen_device &screen, bool state);
207	207	INTERRUPT_GEN_MEMBER(lhb_vblank_irq);
	208	void wlcc_decrypt();
	209	void lhb_decrypt();
	210	void drgnwrld_type3_decrypt();
	211	void drgnwrld_type2_decrypt();
	212	void drgnwrld_type1_decrypt();
	213	void lhb2_decrypt();
	214	void nkishusp_decrypt();
	215	void vbowlj_decrypt();
	216	void dbc_decrypt();
	217	void ryukobou_decrypt();
	218	void lhb2_decrypt_gfx();
	219	void drgnwrld_gfx_decrypt();
208	220	};
209	221
210	222
r21026	r21027
586	598
587	599	***************************************************************************/
588	600
589		static void wlcc_decrypt(running_machine &machine)
	601	void igs011_state::wlcc_decrypt()
590	602	{
591	603	int i;
592		UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base());
	604	UINT16 *src = (UINT16 *) (machine().root_device().memregion("maincpu")->base());
593	605
594	606	int rom_size = 0x80000;
595	607
r21026	r21027
610	622	}
611	623
612	624
613		static void lhb_decrypt(running_machine &machine)
	625	void igs011_state::lhb_decrypt()
614	626	{
615	627	int i;
616		UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base());
	628	UINT16 *src = (UINT16 *) (machine().root_device().memregion("maincpu")->base());
617	629
618	630	int rom_size = 0x80000;
619	631
r21026	r21027
635	647	}
636	648
637	649
638		static void drgnwrld_type3_decrypt(running_machine &machine)
	650	void igs011_state::drgnwrld_type3_decrypt()
639	651	{
640	652	int i;
641		UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base());
	653	UINT16 *src = (UINT16 *) (machine().root_device().memregion("maincpu")->base());
642	654
643	655	int rom_size = 0x80000;
644	656
r21026	r21027
663	675	}
664	676	}
665	677
666		static void drgnwrld_type2_decrypt(running_machine &machine)
	678	void igs011_state::drgnwrld_type2_decrypt()
667	679	{
668	680	int i;
669		UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base());
	681	UINT16 *src = (UINT16 *) (machine().root_device().memregion("maincpu")->base());
670	682
671	683	int rom_size = 0x80000;
672	684
r21026	r21027
696	708	}
697	709	}
698	710
699		static void drgnwrld_type1_decrypt(running_machine &machine)
	711	void igs011_state::drgnwrld_type1_decrypt()
700	712	{
701	713	int i;
702		UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base());
	714	UINT16 *src = (UINT16 *) (machine().root_device().memregion("maincpu")->base());
703	715
704	716	int rom_size = 0x80000;
705	717
r21026	r21027
725	737	}
726	738
727	739
728		static void lhb2_decrypt(running_machine &machine)
	740	void igs011_state::lhb2_decrypt()
729	741	{
730	742	int i,j;
731	743	int rom_size = 0x80000;
732		UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base());
733		UINT16 *result_data = auto_alloc_array(machine, UINT16, rom_size/2);
	744	UINT16 *src = (UINT16 *) (machine().root_device().memregion("maincpu")->base());
	745	UINT16 *result_data = auto_alloc_array(machine(), UINT16, rom_size/2);
734	746
735	747	for (i=0; i<rom_size/2; i++)
736	748	{
r21026	r21027
752	764
753	765	memcpy(src,result_data,rom_size);
754	766
755		auto_free(machine, result_data);
	767	auto_free(machine(), result_data);
756	768	}
757	769
758	770
759	771	// xor similar to ryukobou (both sets are Japan), address scrambling from lhb2
760		static void nkishusp_decrypt(running_machine &machine)
	772	void igs011_state::nkishusp_decrypt()
761	773	{
762	774	int i,j;
763	775	int rom_size = 0x80000;
764		UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base());
765		UINT16 *result_data = auto_alloc_array(machine, UINT16, rom_size/2);
	776	UINT16 *src = (UINT16 *) (machine().root_device().memregion("maincpu")->base());
	777	UINT16 *result_data = auto_alloc_array(machine(), UINT16, rom_size/2);
766	778
767	779	for (i=0; i<rom_size/2; i++)
768	780	{
r21026	r21027
792	804
793	805	memcpy(src,result_data,rom_size);
794	806
795		auto_free(machine, result_data);
	807	auto_free(machine(), result_data);
796	808	}
797	809
798	810
799		static void vbowlj_decrypt(running_machine &machine)
	811	void igs011_state::vbowlj_decrypt()
800	812	{
801	813	int i;
802		UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base());
	814	UINT16 *src = (UINT16 *) (machine().root_device().memregion("maincpu")->base());
803	815
804	816	int rom_size = 0x80000;
805	817
r21026	r21027
830	842	}
831	843
832	844
833		static void dbc_decrypt(running_machine &machine)
	845	void igs011_state::dbc_decrypt()
834	846	{
835	847	int i;
836		UINT16 *src = (UINT16 *) (machine.root_device().memregion("maincpu")->base());
	848	UINT16 *src = (UINT16 *) (machine().root_device().memregion("maincpu")->base());
837	849
838	850	int rom_size = 0x80000;
839	851
r21026	r21027
880	892	}
881	893
882	894
883		static void ryukobou_decrypt(running_machine &machine)
	895	void igs011_state::ryukobou_decrypt()
884	896	{
885	897	int i;
886		UINT16 *src = (UINT16 *) machine.root_device().memregion("maincpu")->base();
	898	UINT16 *src = (UINT16 *) machine().root_device().memregion("maincpu")->base();
887	899	int rom_size = 0x80000;
888	900
889	901	for (i=0; i<rom_size/2; i++)
r21026	r21027
911	923	***************************************************************************/
912	924
913	925
914		static void lhb2_decrypt_gfx(running_machine &machine)
	926	void igs011_state::lhb2_decrypt_gfx()
915	927	{
916	928	int i;
917	929	unsigned rom_size = 0x200000;
918		UINT8 *src = (UINT8 *) (machine.root_device().memregion("blitter")->base());
919		UINT8 *result_data = auto_alloc_array(machine, UINT8, rom_size);
	930	UINT8 *src = (UINT8 *) (machine().root_device().memregion("blitter")->base());
	931	UINT8 *result_data = auto_alloc_array(machine(), UINT8, rom_size);
920	932
921	933	for (i=0; i<rom_size; i++)
922	934	result_data[i] = src[BITSWAP24(i, 23,22,21,20, 19, 17,16,15, 13,12, 10,9,8,7,6,5,4, 2,1, 3, 11, 14, 18, 0)];
923	935
924	936	memcpy(src,result_data,rom_size);
925	937
926		auto_free(machine, result_data);
	938	auto_free(machine(), result_data);
927	939	}
928	940
929		static void drgnwrld_gfx_decrypt(running_machine &machine)
	941	void igs011_state::drgnwrld_gfx_decrypt()
930	942	{
931	943	int i;
932	944	unsigned rom_size = 0x400000;
933		UINT8 *src = (UINT8 *) (machine.root_device().memregion("blitter")->base());
934		UINT8 *result_data = auto_alloc_array(machine, UINT8, rom_size);
	945	UINT8 *src = (UINT8 *) (machine().root_device().memregion("blitter")->base());
	946	UINT8 *result_data = auto_alloc_array(machine(), UINT8, rom_size);
935	947
936	948	for (i=0; i<rom_size; i++)
937	949	result_data[i] = src[BITSWAP24(i, 23,22,21,20,19,18,17,16,15, 12, 13, 14, 11,10,9,8,7,6,5,4,3,2,1,0)];
938	950
939	951	memcpy(src,result_data,rom_size);
940	952
941		auto_free(machine, result_data);
	953	auto_free(machine(), result_data);
942	954	}
943	955
944	956
r21026	r21027
1899	1911	{
1900	1912	//  UINT16 *rom = (UINT16 *) machine().root_device().memregion("maincpu")->base();
1901	1913
1902		drgnwrld_type1_decrypt(machine());
1903		drgnwrld_gfx_decrypt(machine());
	1914	drgnwrld_type1_decrypt();
	1915	drgnwrld_gfx_decrypt();
1904	1916	/*
1905	1917	// PROTECTION CHECKS
1906	1918	rom[0x032ee/2]  =   0x606c;     // 0032EE: 676C        beq 335c     (ASIC11 CHECK PORT ERROR 3)
r21026	r21027
1925	1937	{
1926	1938	//  UINT16 *rom = (UINT16 *) machine().root_device().memregion("maincpu")->base();
1927	1939
1928		drgnwrld_type1_decrypt(machine());
1929		drgnwrld_gfx_decrypt(machine());
	1940	drgnwrld_type1_decrypt();
	1941	drgnwrld_gfx_decrypt();
1930	1942	/*
1931	1943	// PROTECTION CHECKS
1932	1944	rom[0x032ee/2]  =   0x606c;     // 0032EE: 676C        beq 335c     (ASIC11 CHECK PORT ERROR 3)
r21026	r21027
1950	1962	{
1951	1963	//  UINT16 *rom = (UINT16 *) machine().root_device().memregion("maincpu")->base();
1952	1964
1953		drgnwrld_type2_decrypt(machine());
1954		drgnwrld_gfx_decrypt(machine());
	1965	drgnwrld_type2_decrypt();
	1966	drgnwrld_gfx_decrypt();
1955	1967	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0xd4c0, 0xd4ff, read16_delegate(FUNC(igs011_state::drgnwrldv21_igs011_prot2_r), this));
1956	1968	/*
1957	1969	// PROTECTION CHECKS
r21026	r21027
1979	1991	{
1980	1992	//  UINT16 *rom = (UINT16 *) machine().root_device().memregion("maincpu")->base();
1981	1993
1982		drgnwrld_type3_decrypt(machine());
1983		drgnwrld_gfx_decrypt(machine());
	1994	drgnwrld_type3_decrypt();
	1995	drgnwrld_gfx_decrypt();
1984	1996	/*
1985	1997	// PROTECTION CHECKS
1986	1998	rom[0x033d2/2]  =   0x606c;     // 0033D2: 676C        beq 3440     (ASIC11 CHECK PORT ERROR 3)
r21026	r21027
2006	2018	{
2007	2019	//  UINT16 *rom = (UINT16 *) machine().root_device().memregion("maincpu")->base();
2008	2020
2009		drgnwrld_type3_decrypt(machine());
2010		drgnwrld_gfx_decrypt(machine());
	2021	drgnwrld_type3_decrypt();
	2022	drgnwrld_gfx_decrypt();
2011	2023	/*
2012	2024	// PROTECTION CHECKS
2013	2025	// bp 33d2; bp 11c74; bp 23d2a; bp 23f68; bp 240d4; bp 242ac; bp 244b2; bp 24630; bp 24886; bp 24aca; bp 24d46; bp 24f8e; bp 254ba; bp 26a52; bp 276a0; bp 2a86e
r21026	r21027
2033	2045
2034	2046	DRIVER_INIT_MEMBER(igs011_state,drgnwrldv11h)
2035	2047	{
2036		drgnwrld_type1_decrypt(machine());
2037		drgnwrld_gfx_decrypt(machine());
	2048	drgnwrld_type1_decrypt();
	2049	drgnwrld_gfx_decrypt();
2038	2050
2039	2051	// PROTECTION CHECKS
2040	2052	// the protection checks are already patched out like we do!
r21026	r21027
2044	2056	{
2045	2057	//  UINT16 *rom = (UINT16 *) machine().root_device().memregion("maincpu")->base();
2046	2058
2047		drgnwrld_type1_decrypt(machine());
2048		drgnwrld_gfx_decrypt(machine());
	2059	drgnwrld_type1_decrypt();
	2060	drgnwrld_gfx_decrypt();
2049	2061	/*
2050	2062	// PROTECTION CHECKS
2051	2063	// bp 33d2; bp 23d0e; bp 23f58; bp 240d0; bp 242a8; bp 244ae; bp 2462c; bp 24882; bp 24ac6; bp 24d42; bp 24f8a; bp 254b6; bp 2a23a
r21026	r21027
2070	2082	{
2071	2083	//  UINT16 *rom = (UINT16 *) machine().root_device().memregion("maincpu")->base();
2072	2084
2073		lhb_decrypt(machine());
	2085	lhb_decrypt();
2074	2086
2075	2087	// PROTECTION CHECKS
2076	2088	//  rom[0x2eef6/2]  =   0x4e75;     // 02EEF6: 4E56 FE00    link A6, #-$200  (fills palette with pink otherwise)
r21026	r21027
2080	2092	{
2081	2093	//  UINT16 *rom = (UINT16 *) machine().root_device().memregion("maincpu")->base();
2082	2094
2083		lhb_decrypt(machine());
	2095	lhb_decrypt();
2084	2096
2085	2097	// PROTECTION CHECKS
2086	2098	//  rom[0x2e988/2]  =   0x4e75;     // 02E988: 4E56 FE00    link A6, #-$200  (fills palette with pink otherwise)
r21026	r21027
2090	2102	{
2091	2103	//  UINT16 *rom = (UINT16 *) machine().root_device().memregion("maincpu")->base();
2092	2104
2093		dbc_decrypt(machine());
	2105	dbc_decrypt();
2094	2106
2095	2107	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x10600, 0x107ff, read16_delegate(FUNC(igs011_state::dbc_igs011_prot2_r), this));
2096	2108	/*
r21026	r21027
2120	2132	{
2121	2133	//  UINT16 *rom = (UINT16 *) machine().root_device().memregion("maincpu")->base();
2122	2134
2123		ryukobou_decrypt(machine());
	2135	ryukobou_decrypt();
2124	2136
2125	2137	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler(0x10600, 0x107ff, read16_delegate(FUNC(igs011_state::ryukobou_igs011_prot2_r), this));
2126	2138
r21026	r21027
2133	2145	{
2134	2146	//  UINT16 *rom = (UINT16 *) machine().root_device().memregion("maincpu")->base();
2135	2147
2136		lhb_decrypt(machine());
	2148	lhb_decrypt();
2137	2149	/*
2138	2150	// PROTECTION CHECKS
2139	2151	rom[0x00502/2]  =   0x6006;     // 000502: 6050         bra 554
r21026	r21027
2167	2179	{
2168	2180	//  UINT16 *rom = (UINT16 *) machine().root_device().memregion("maincpu")->base();
2169	2181
2170		wlcc_decrypt(machine());
	2182	wlcc_decrypt();
2171	2183	/*
2172	2184	// PROTECTION CHECKS
2173	2185	rom[0x16b96/2]  =   0x6000;     // 016B96: 6700 02FE    beq 16e96  (fills palette with red otherwise)
r21026	r21027
2191	2203	{
2192	2204	//  UINT16 *rom = (UINT16 *) machine().root_device().memregion("maincpu")->base();
2193	2205
2194		lhb2_decrypt(machine());
2195		lhb2_decrypt_gfx(machine());
	2206	lhb2_decrypt();
	2207	lhb2_decrypt_gfx();
2196	2208	/*
2197	2209	// PROTECTION CHECKS
2198	2210	rom[0x034f4/2]  =   0x4e71;     // 0034F4: 660E    bne 3504   (rom test, fills palette with white otherwise)
r21026	r21027
2216	2228	UINT8  *gfx = (UINT8 *)  machine().root_device().memregion("blitter")->base();
2217	2229	int i;
2218	2230
2219		vbowlj_decrypt(machine());
	2231	vbowlj_decrypt();
2220	2232
2221	2233	for (i = 0x400000-1; i >= 0; i--)
2222	2234	{
r21026	r21027
2242	2254	UINT8  *gfx = (UINT8 *)  machine().root_device().memregion("blitter")->base();
2243	2255	int i;
2244	2256
2245		vbowlj_decrypt(machine());
	2257	vbowlj_decrypt();
2246	2258
2247	2259	for (i = 0x400000-1; i >= 0; i--)
2248	2260	{
r21026	r21027
2263	2275	{
2264	2276	UINT16 *rom = (UINT16 *) machine().root_device().memregion("maincpu")->base();
2265	2277
2266		nkishusp_decrypt(machine());
2267		lhb2_decrypt_gfx(machine());
	2278	nkishusp_decrypt();
	2279	lhb2_decrypt_gfx();
2268	2280
2269	2281	// PROTECTION CHECKS (similar to lhb2)
2270	2282

trunk/src/mame/drivers/bfmsys85.c

r21026	r21027
113	113	virtual void machine_start();
114	114	virtual void machine_reset();
115	115	INTERRUPT_GEN_MEMBER(timer_irq);
	116	int b85_find_project_string( );
116	117	};
117	118
118	119	#define MASTER_CLOCK    (XTAL_4MHz)
r21026	r21027
676	677	ROM_END
677	678
678	679
679		int b85_find_project_string(running_machine &machine )
	680	int bfmsys85_state::b85_find_project_string( )
680	681	{
681	682	// search for the project string to find the title (usually just at ff00)
682	683	char title_string[7][32] = { "PROJECT NUMBER", "PROJECT PR", "PROJECT ", "CASH ON THE NILE 2", "PR6121", "CHINA TOWN\x0d\x0a", "PROJECTNUMBER" };
683		UINT8 *src = machine.root_device().memregion( "maincpu" )->base();
684		int size = machine.root_device().memregion( "maincpu" )->bytes();
	684	UINT8 *src = machine().root_device().memregion( "maincpu" )->base();
	685	int size = machine().root_device().memregion( "maincpu" )->bytes();
685	686
686	687	for (int search=0;search<7;search++)
687	688	{
r21026	r21027
754	755	DRIVER_INIT_MEMBER(bfmsys85_state,decode)
755	756	{
756	757	bfm_decode_mainrom(machine(),"maincpu", m_codec_data);
757		b85_find_project_string(machine());
	758	b85_find_project_string();
758	759	}
759	760
760	761	DRIVER_INIT_MEMBER(bfmsys85_state,nodecode)
761	762	{
762		b85_find_project_string(machine());
	763	b85_find_project_string();
763	764	}
764	765
765	766	// PROJECT NUMBER 5539  2P CASH EXPLOSION  GAME No 39-350-190 -   29-MAR-1989 11:45:25

trunk/src/mame/drivers/konamigv.c

r21026	r21027
170	170	DECLARE_DRIVER_INIT(konamigv);
171	171	DECLARE_DRIVER_INIT(btchamp);
172	172	DECLARE_MACHINE_START(konamigv);
	173	void scsi_dma_read( UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size );
	174	void scsi_dma_write( UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size );
173	175	};
174	176
175	177	/* EEPROM handlers */
r21026	r21027
210	212
211	213	/* SCSI */
212	214
213		static void scsi_dma_read( konamigv_state *state, UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size )
	215	void konamigv_state::scsi_dma_read( UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size )
214	216	{
215		UINT8 *sector_buffer = state->m_sector_buffer;
	217	UINT8 *sector_buffer = m_sector_buffer;
216	218	int i;
217	219	int n_this;
218	220
219	221	while( n_size > 0 )
220	222	{
221		if( n_size > sizeof( state->m_sector_buffer ) / 4 )
	223	if( n_size > sizeof( m_sector_buffer ) / 4 )
222	224	{
223		n_this = sizeof( state->m_sector_buffer ) / 4;
	225	n_this = sizeof( m_sector_buffer ) / 4;
224	226	}
225	227	else
226	228	{
r21026	r21027
229	231	if( n_this < 2048 / 4 )
230	232	{
231	233	/* non-READ commands */
232		state->m_am53cf96->dma_read_data( n_this * 4, sector_buffer );
	234	m_am53cf96->dma_read_data( n_this * 4, sector_buffer );
233	235	}
234	236	else
235	237	{
236	238	/* assume normal 2048 byte data for now */
237		state->m_am53cf96->dma_read_data( 2048, sector_buffer );
	239	m_am53cf96->dma_read_data( 2048, sector_buffer );
238	240	n_this = 2048 / 4;
239	241	}
240	242	n_size -= n_this;
r21026	r21027
254	256	}
255	257	}
256	258
257		static void scsi_dma_write( konamigv_state *state, UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size )
	259	void konamigv_state::scsi_dma_write( UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size )
258	260	{
259		UINT8 *sector_buffer = state->m_sector_buffer;
	261	UINT8 *sector_buffer = m_sector_buffer;
260	262	int i;
261	263	int n_this;
262	264
263	265	while( n_size > 0 )
264	266	{
265		if( n_size > sizeof( state->m_sector_buffer ) / 4 )
	267	if( n_size > sizeof( m_sector_buffer ) / 4 )
266	268	{
267		n_this = sizeof( state->m_sector_buffer ) / 4;
	269	n_this = sizeof( m_sector_buffer ) / 4;
268	270	}
269	271	else
270	272	{
r21026	r21027
284	286	n_this--;
285	287	}
286	288
287		state->m_am53cf96->dma_write_data( n_this * 4, sector_buffer );
	289	m_am53cf96->dma_write_data( n_this * 4, sector_buffer );
288	290	}
289	291	}
290	292
r21026	r21027
307	309	MCFG_CPU_ADD( "maincpu", CXD8530BQ, XTAL_67_7376MHz )
308	310	MCFG_CPU_PROGRAM_MAP( konamigv_map )
309	311
310		MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate( FUNC( scsi_dma_read ), (konamigv_state *) owner ) )
311		MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 5, psx_dma_write_delegate( FUNC( scsi_dma_write ), (konamigv_state *) owner ) )
	312	MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate( FUNC( konamigv_state::scsi_dma_read ), (konamigv_state *) owner ) )
	313	MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 5, psx_dma_write_delegate( FUNC( konamigv_state::scsi_dma_write ), (konamigv_state *) owner ) )
312	314
313	315	MCFG_MACHINE_START_OVERRIDE(konamigv_state, konamigv )
314	316

trunk/src/mame/drivers/hornet.c

r21026	r21027
372	372	UINT32 screen_update_hornet(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
373	373	UINT32 screen_update_hornet_2board(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
374	374	TIMER_CALLBACK_MEMBER(irq_off);
	375	int jvs_encode_data(UINT8 *in, int length);
	376	int jvs_decode_data(UINT8 *in, UINT8 *out, int length);
	377	void jamma_jvs_cmd_exec();
375	378	};
376	379
377	380
r21026	r21027
1140	1143
1141	1144	/*****************************************************************************/
1142	1145
1143		static void jamma_jvs_cmd_exec(running_machine &machine);
1144
1145	1146	static void jamma_jvs_w(device_t *device, UINT8 data)
1146	1147	{
1147	1148	hornet_state *state = device->machine().driver_data<hornet_state>();
r21026	r21027
1151	1152	state->m_jvs_sdata_ptr++;
1152	1153
1153	1154	if (state->m_jvs_sdata_ptr >= 3 && state->m_jvs_sdata_ptr >= 3 + state->m_jvs_sdata[2])
1154		jamma_jvs_cmd_exec(device->machine());
	1155	state->jamma_jvs_cmd_exec();
1155	1156	}
1156	1157
1157		static int jvs_encode_data(running_machine &machine, UINT8 *in, int length)
	1158	int hornet_state::jvs_encode_data(UINT8 *in, int length)
1158	1159	{
1159	1160	int inptr = 0;
1160	1161	int sum = 0;
r21026	r21027
1165	1166	if (b == 0xe0)
1166	1167	{
1167	1168	sum += 0xd0 + 0xdf;
1168		ppc4xx_spu_receive_byte(machine.device("maincpu"), 0xd0);
1169		ppc4xx_spu_receive_byte(machine.device("maincpu"), 0xdf);
	1169	ppc4xx_spu_receive_byte(machine().device("maincpu"), 0xd0);
	1170	ppc4xx_spu_receive_byte(machine().device("maincpu"), 0xdf);
1170	1171	}
1171	1172	else if (b == 0xd0)
1172	1173	{
1173	1174	sum += 0xd0 + 0xcf;
1174		ppc4xx_spu_receive_byte(machine.device("maincpu"), 0xd0);
1175		ppc4xx_spu_receive_byte(machine.device("maincpu"), 0xcf);
	1175	ppc4xx_spu_receive_byte(machine().device("maincpu"), 0xd0);
	1176	ppc4xx_spu_receive_byte(machine().device("maincpu"), 0xcf);
1176	1177	}
1177	1178	else
1178	1179	{
1179	1180	sum += b;
1180		ppc4xx_spu_receive_byte(machine.device("maincpu"), b);
	1181	ppc4xx_spu_receive_byte(machine().device("maincpu"), b);
1181	1182	}
1182	1183	}
1183	1184	return sum;
1184	1185	}
1185	1186
1186		static int jvs_decode_data(UINT8 *in, UINT8 *out, int length)
	1187	int hornet_state::jvs_decode_data(UINT8 *in, UINT8 *out, int length)
1187	1188	{
1188	1189	int outptr = 0;
1189	1190	int inptr = 0;
r21026	r21027
1205	1206	return outptr;
1206	1207	}
1207	1208
1208		static void jamma_jvs_cmd_exec(running_machine &machine)
	1209	void hornet_state::jamma_jvs_cmd_exec()
1209	1210	{
1210		hornet_state *state = machine.driver_data<hornet_state>();
1211	1211	UINT8 byte_num;
1212	1212	UINT8 data[1024], rdata[1024];
1213	1213	#if 0
r21026	r21027
1216	1216	int rdata_ptr;
1217	1217	int sum;
1218	1218
1219		//  sync = state->m_jvs_sdata[0];
1220		//  node = state->m_jvs_sdata[1];
1221		byte_num = state->m_jvs_sdata[2];
	1219	//  sync = m_jvs_sdata[0];
	1220	//  node = m_jvs_sdata[1];
	1221	byte_num = m_jvs_sdata[2];
1222	1222
1223	1223	#if 0
1224	1224	length =
1225	1225	#endif
1226		jvs_decode_data(&state->m_jvs_sdata[3], data, byte_num-1);
	1226	jvs_decode_data(&m_jvs_sdata[3], data, byte_num-1);
1227	1227	#if 0
1228	1228	printf("jvs input data:\n");
1229	1229	for (i=0; i < byte_num; i++)
1230	1230	{
1231		printf("%02X ", state->m_jvs_sdata[3+i]);
	1231	printf("%02X ", m_jvs_sdata[3+i]);
1232	1232	}
1233	1233	printf("\n");
1234	1234
r21026	r21027
1271	1271
1272	1272	// write jvs return data
1273	1273	sum = 0x00 + (rdata_ptr+1);
1274		ppc4xx_spu_receive_byte(machine.device("maincpu"), 0xe0);           // sync
1275		ppc4xx_spu_receive_byte(machine.device("maincpu"), 0x00);           // node
1276		ppc4xx_spu_receive_byte(machine.device("maincpu"), rdata_ptr + 1);  // num of bytes
1277		sum += jvs_encode_data(machine, rdata, rdata_ptr);
1278		ppc4xx_spu_receive_byte(machine.device("maincpu"), sum - 1);        // checksum
	1274	ppc4xx_spu_receive_byte(machine().device("maincpu"), 0xe0);           // sync
	1275	ppc4xx_spu_receive_byte(machine().device("maincpu"), 0x00);           // node
	1276	ppc4xx_spu_receive_byte(machine().device("maincpu"), rdata_ptr + 1);  // num of bytes
	1277	sum += jvs_encode_data(rdata, rdata_ptr);
	1278	ppc4xx_spu_receive_byte(machine().device("maincpu"), sum - 1);        // checksum
1279	1279
1280		state->m_jvs_sdata_ptr = 0;
	1280	m_jvs_sdata_ptr = 0;
1281	1281	}
1282	1282
1283	1283	/*****************************************************************************/

trunk/src/mame/drivers/pcxt.c

r21026	r21027
126	126	virtual void machine_reset();
127	127	UINT32 screen_update_tetriskr(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
128	128	IRQ_CALLBACK_MEMBER(irq_callback);
	129	UINT8 pcxt_speaker_get_spk();
	130	void pcxt_speaker_set_spkrdata(UINT8 data);
	131	void pcxt_speaker_set_input(UINT8 data);
129	132	};
130	133
131	134	UINT32 pcxt_state::screen_update_tetriskr(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
r21026	r21027
235	238	*********************************/
236	239
237	240	// pc_speaker_get_spk, pc_speaker_set_spkrdata, and pc_speaker_set_input already exists in MESS, can the implementations be merged?
238		UINT8 pcxt_speaker_get_spk(running_machine &machine)
	241	UINT8 pcxt_state::pcxt_speaker_get_spk()
239	242	{
240		pcxt_state *state = machine.driver_data<pcxt_state>();
241		return state->m_pc_spkrdata & state->m_pc_input;
	243	return m_pc_spkrdata & m_pc_input;
242	244	}
243	245
244		void pcxt_speaker_set_spkrdata(running_machine &machine, UINT8 data)
	246	void pcxt_state::pcxt_speaker_set_spkrdata(UINT8 data)
245	247	{
246		device_t *speaker = machine.device("speaker");
247		pcxt_state *state = machine.driver_data<pcxt_state>();
248		state->m_pc_spkrdata = data ? 1 : 0;
249		speaker_level_w( speaker, pcxt_speaker_get_spk(machine) );
	248	device_t *speaker = machine().device("speaker");
	249	m_pc_spkrdata = data ? 1 : 0;
	250	speaker_level_w( speaker, pcxt_speaker_get_spk() );
250	251	}
251	252
252		void pcxt_speaker_set_input(running_machine &machine, UINT8 data)
	253	void pcxt_state::pcxt_speaker_set_input(UINT8 data)
253	254	{
254		device_t *speaker = machine.device("speaker");
255		pcxt_state *state = machine.driver_data<pcxt_state>();
256		state->m_pc_input = data ? 1 : 0;
257		speaker_level_w( speaker, pcxt_speaker_get_spk(machine) );
	255	device_t *speaker = machine().device("speaker");
	256	m_pc_input = data ? 1 : 0;
	257	speaker_level_w( speaker, pcxt_speaker_get_spk() );
258	258	}
259	259
260	260
261	261	WRITE_LINE_MEMBER(pcxt_state::ibm5150_pit8253_out2_changed)
262	262	{
263		pcxt_speaker_set_input( machine(), state );
	263	pcxt_speaker_set_input( state );
264	264	}
265	265
266	266
r21026	r21027
330	330	{
331	331	/* PPI controller port B*/
332	332	pit8253_gate2_w(m_pit8253, BIT(data, 0));
333		pcxt_speaker_set_spkrdata( machine(), data & 0x02 );
	333	pcxt_speaker_set_spkrdata( data & 0x02 );
334	334	m_port_b_data = data;
335	335	// device_t *beep = machine().device("beep");
336	336	// device_t *cvsd = machine().device("cvsd");

trunk/src/mame/drivers/sandscrp.c

r21026	r21027
112	112	UINT32 screen_update_sandscrp(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
113	113	void screen_eof_sandscrp(screen_device &screen, bool state);
114	114	INTERRUPT_GEN_MEMBER(sandscrp_interrupt);
	115	void update_irq_state();
115	116	};
116	117
117	118
r21026	r21027
149	150
150	151
151	152	/* Update the IRQ state based on all possible causes */
152		static void update_irq_state(running_machine &machine)
	153	void sandscrp_state::update_irq_state()
153	154	{
154		sandscrp_state *state = machine.driver_data<sandscrp_state>();
155		if (state->m_vblank_irq || state->m_sprite_irq || state->m_unknown_irq)
156		machine.device("maincpu")->execute().set_input_line(1, ASSERT_LINE);
	155	if (m_vblank_irq || m_sprite_irq || m_unknown_irq)
	156	machine().device("maincpu")->execute().set_input_line(1, ASSERT_LINE);
157	157	else
158		machine.device("maincpu")->execute().set_input_line(1, CLEAR_LINE);
	158	machine().device("maincpu")->execute().set_input_line(1, CLEAR_LINE);
159	159	}
160	160
161	161
r21026	r21027
164	164	INTERRUPT_GEN_MEMBER(sandscrp_state::sandscrp_interrupt)
165	165	{
166	166	m_vblank_irq = 1;
167		update_irq_state(machine());
	167	update_irq_state();
168	168	}
169	169
170	170
r21026	r21027
175	175	{
176	176	device_t *pandora = machine().device("pandora");
177	177	m_sprite_irq = 1;
178		update_irq_state(machine());
	178	update_irq_state();
179	179	pandora_eof(pandora);
180	180	}
181	181	}
r21026	r21027
202	202	if (data & 0x20)    m_vblank_irq  = 0;
203	203	}
204	204
205		update_irq_state(machine());
	205	update_irq_state();
206	206	}
207	207
208	208

trunk/src/mame/drivers/firefox.c

r21026	r21027
100	100	virtual void video_start();
101	101	UINT32 screen_update_firefox(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
102	102	TIMER_DEVICE_CALLBACK_MEMBER(video_timer_callback);
	103	void set_rgba( int start, int index, unsigned char *palette_ram );
	104	void firq_gen(phillips_22vp931_device &laserdisc, int state);
103	105	};
104	106
105	107
r21026	r21027
258	260	machine().device("maincpu")->execute().set_input_line(M6809_IRQ_LINE, ASSERT_LINE );
259	261	}
260	262
261		static void set_rgba( running_machine &machine, int start, int index, unsigned char *palette_ram )
	263	void firefox_state::set_rgba( int start, int index, unsigned char *palette_ram )
262	264	{
263	265	int r = palette_ram[ index ];
264	266	int g = palette_ram[ index + 256 ];
265	267	int b = palette_ram[ index + 512 ];
266	268	int a = ( b & 3 ) * 0x55;
267	269
268		palette_set_color( machine, start + index, MAKE_ARGB( a, r, g, b ) );
	270	palette_set_color( machine(), start + index, MAKE_ARGB( a, r, g, b ) );
269	271	}
270	272
271	273	WRITE8_MEMBER(firefox_state::tile_palette_w)
272	274	{
273	275	m_tile_palette[ offset ] = data;
274		set_rgba( machine(), 0, offset & 0xff, m_tile_palette );
	276	set_rgba( 0, offset & 0xff, m_tile_palette );
275	277	}
276	278
277	279	WRITE8_MEMBER(firefox_state::sprite_palette_w)
278	280	{
279	281	m_sprite_palette[ offset ] = data;
280		set_rgba( machine(), 256, offset & 0xff, m_sprite_palette );
	282	set_rgba( 256, offset & 0xff, m_sprite_palette );
281	283	}
282	284
283	285	WRITE8_MEMBER(firefox_state::firefox_objram_bank_w)
r21026	r21027
476	478
477	479
478	480
479		static void firq_gen(running_machine &machine, phillips_22vp931_device &laserdisc, int state)
	481	void firefox_state::firq_gen(phillips_22vp931_device &laserdisc, int state)
480	482	{
481	483	if (state)
482		machine.device("maincpu")->execute().set_input_line(M6809_FIRQ_LINE, ASSERT_LINE );
	484	machine().device("maincpu")->execute().set_input_line(M6809_FIRQ_LINE, ASSERT_LINE );
483	485	}
484	486
485	487
r21026	r21027
489	491	m_nvram_1c = machine().device<x2212_device>("nvram_1c");
490	492	m_nvram_1d = machine().device<x2212_device>("nvram_1d");
491	493
492		m_laserdisc->set_data_ready_callback(phillips_22vp931_device::data_ready_delegate(FUNC(firq_gen), &machine()));
	494	m_laserdisc->set_data_ready_callback(phillips_22vp931_device::data_ready_delegate(FUNC(firefox_state::firq_gen), this));
493	495
494	496	m_control_num = 0;
495	497	m_sprite_bank = 0;

trunk/src/mame/drivers/deco156.c

r21026	r21027
59	59	virtual void video_start();
60	60	UINT32 screen_update_wcvol95(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
61	61	INTERRUPT_GEN_MEMBER(deco32_vbl_interrupt);
	62	void descramble_sound( const char *tag );
62	63	};
63	64
64	65
r21026	r21027
617	618
618	619	/**********************************************************************************/
619	620
620		static void descramble_sound( running_machine &machine, const char *tag )
	621	void deco156_state::descramble_sound( const char *tag )
621	622	{
622		UINT8 *rom = machine.root_device().memregion(tag)->base();
623		int length = machine.root_device().memregion(tag)->bytes();
624		UINT8 *buf1 = auto_alloc_array(machine, UINT8, length);
	623	UINT8 *rom = machine().root_device().memregion(tag)->base();
	624	int length = machine().root_device().memregion(tag)->bytes();
	625	UINT8 *buf1 = auto_alloc_array(machine(), UINT8, length);
625	626	UINT32 x;
626	627
627	628	for (x = 0; x < length; x++)
r21026	r21027
640	641
641	642	memcpy(rom,buf1,length);
642	643
643		auto_free(machine, buf1);
	644	auto_free(machine(), buf1);
644	645	}
645	646
646	647	DRIVER_INIT_MEMBER(deco156_state,hvysmsh)
647	648	{
648	649	deco56_decrypt_gfx(machine(), "gfx1"); /* 141 */
649	650	deco156_decrypt(machine());
650		descramble_sound(machine(), "oki2");
	651	descramble_sound("oki2");
651	652	}
652	653
653	654	DRIVER_INIT_MEMBER(deco156_state,wcvol95)
654	655	{
655	656	deco56_decrypt_gfx(machine(), "gfx1"); /* 141 */
656	657	deco156_decrypt(machine());
657		descramble_sound(machine(), "ymz");
	658	descramble_sound("ymz");
658	659	}
659	660
660	661

trunk/src/mame/drivers/konamim2.c

r21026	r21027
251	251	virtual void video_start();
252	252	UINT32 screen_update_m2(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
253	253	INTERRUPT_GEN_MEMBER(m2);
	254	void cde_init();
	255	void cde_handle_command();
	256	void cde_handle_reports();
	257	void cde_dma_transfer(address_space &space, int channel, int next);
254	258	};
255	259
256	260
r21026	r21027
487	491
488	492
489	493
490		static void cde_init(running_machine &machine)
	494	void konamim2_state::cde_init()
491	495	{
492		konamim2_state *state = machine.driver_data<konamim2_state>();
493		cdrom_file *cdfile = cdrom_open(get_disk_handle(machine, ":cdrom"));
	496	cdrom_file *cdfile = cdrom_open(get_disk_handle(machine(), ":cdrom"));
494	497
495	498	const cdrom_toc *toc = cdrom_get_toc(cdfile);
496	499
497	500	if (cdfile)
498	501	{
499		memcpy(&state->m_cde_toc, toc, sizeof(cdrom_toc));
	502	memcpy(&m_cde_toc, toc, sizeof(cdrom_toc));
500	503
501	504	/*
502	505	printf("%d tracks\n", toc->numtrks);
r21026	r21027
511	514	cdrom_close(cdfile);
512	515	}
513	516
514		state->m_cde_drive_state = CDE_DRIVE_STATE_PAUSED;
	517	m_cde_drive_state = CDE_DRIVE_STATE_PAUSED;
515	518
516		state->m_cde_num_status_bytes = 0;
517		state->m_cde_status_byte_ptr = 0;
518		state->m_cde_command_byte_ptr = 0;
	519	m_cde_num_status_bytes = 0;
	520	m_cde_status_byte_ptr = 0;
	521	m_cde_command_byte_ptr = 0;
519	522
520		state->m_cde_response = 0;
	523	m_cde_response = 0;
521	524
522		state->m_cde_enable_qchannel_reports = 0;
523		state->m_cde_enable_seek_reports = 0;
	525	m_cde_enable_qchannel_reports = 0;
	526	m_cde_enable_seek_reports = 0;
524	527
525		state->m_cde_qchannel_offset = 0;
	528	m_cde_qchannel_offset = 0;
526	529	}
527	530
528		static void cde_handle_command(running_machine &machine)
	531	void konamim2_state::cde_handle_command()
529	532	{
530		konamim2_state *state = machine.driver_data<konamim2_state>();
531		switch (state->m_cde_command_bytes[0])
	533	switch (m_cde_command_bytes[0])
532	534	{
533	535	case 0x04:      // Set Speed
534	536	{
535		state->m_cde_num_status_bytes = 1;
	537	m_cde_num_status_bytes = 1;
536	538
537		state->m_cde_status_bytes[0] = 0x04;
538		state->m_cde_status_byte_ptr = 0;
	539	m_cde_status_bytes[0] = 0x04;
	540	m_cde_status_byte_ptr = 0;
539	541
540		//          mame_printf_debug("CDE: SET SPEED %02X, %02X\n", state->m_cde_command_bytes[1], state->m_cde_command_bytes[2]);
	542	//          mame_printf_debug("CDE: SET SPEED %02X, %02X\n", m_cde_command_bytes[1], m_cde_command_bytes[2]);
541	543	break;
542	544	}
543	545	case 0x06:      // Audio Format / Data Format
544	546	{
545		state->m_cde_num_status_bytes = 1;
	547	m_cde_num_status_bytes = 1;
546	548
547		state->m_cde_status_bytes[0] = 0x06;
548		state->m_cde_status_byte_ptr = 0;
	549	m_cde_status_bytes[0] = 0x06;
	550	m_cde_status_byte_ptr = 0;
549	551
550		if (state->m_cde_command_bytes[1] == 0x00)      // Audio Format
	552	if (m_cde_command_bytes[1] == 0x00)      // Audio Format
551	553	{
552	554	//              mame_printf_debug("CDE: AUDIO FORMAT\n");
553	555	}
554		else if (state->m_cde_command_bytes[1] == 0x78) // Data Format
	556	else if (m_cde_command_bytes[1] == 0x78) // Data Format
555	557	{
556	558	//              mame_printf_debug("CDE: DATA FORMAT\n");
557	559	}
558	560	else
559	561	{
560		fatalerror("CDE: unknown command %02X, %02X\n", state->m_cde_command_bytes[0], state->m_cde_command_bytes[1]);
	562	fatalerror("CDE: unknown command %02X, %02X\n", m_cde_command_bytes[0], m_cde_command_bytes[1]);
561	563	}
562	564	break;
563	565	}
564	566	case 0x08:      // Pause / Eject / Play
565	567	{
566		state->m_cde_num_status_bytes = 1;
	568	m_cde_num_status_bytes = 1;
567	569
568		state->m_cde_status_bytes[0] = 0x08;
569		state->m_cde_status_byte_ptr = 0;
	570	m_cde_status_bytes[0] = 0x08;
	571	m_cde_status_byte_ptr = 0;
570	572
571		if (state->m_cde_command_bytes[1] == 0x00)      // Eject
	573	if (m_cde_command_bytes[1] == 0x00)      // Eject
572	574	{
573	575	//              mame_printf_debug("CDE: EJECT command\n");
574	576	}
575		else if (state->m_cde_command_bytes[1] == 0x02) // Pause
	577	else if (m_cde_command_bytes[1] == 0x02) // Pause
576	578	{
577	579	//              mame_printf_debug("CDE: PAUSE command\n");
578		state->m_cde_drive_state = CDE_DRIVE_STATE_PAUSED;
	580	m_cde_drive_state = CDE_DRIVE_STATE_PAUSED;
579	581	}
580		else if (state->m_cde_command_bytes[1] == 0x03) // Play
	582	else if (m_cde_command_bytes[1] == 0x03) // Play
581	583	{
582	584	//              mame_printf_debug("CDE: PLAY command\n");
583	585	}
584	586	else
585	587	{
586		fatalerror("CDE: unknown command %02X, %02X\n", state->m_cde_command_bytes[0], state->m_cde_command_bytes[1]);
	588	fatalerror("CDE: unknown command %02X, %02X\n", m_cde_command_bytes[0], m_cde_command_bytes[1]);
587	589	}
588	590	break;
589	591	}
590	592	case 0x09:      // Seek
591	593	{
592		state->m_cde_num_status_bytes = 1;
	594	m_cde_num_status_bytes = 1;
593	595
594		state->m_cde_status_bytes[0] = 0x1b;
595		state->m_cde_status_byte_ptr = 0;
	596	m_cde_status_bytes[0] = 0x1b;
	597	m_cde_status_byte_ptr = 0;
596	598
597		state->m_cde_drive_state = CDE_DRIVE_STATE_SEEK_DONE;
	599	m_cde_drive_state = CDE_DRIVE_STATE_SEEK_DONE;
598	600
599		//          mame_printf_debug("CDE: SEEK %08X\n", (state->m_cde_command_bytes[1] << 16) | (state->m_cde_command_bytes[2] << 8) | (state->m_cde_command_bytes[3]));
	601	//          mame_printf_debug("CDE: SEEK %08X\n", (m_cde_command_bytes[1] << 16) | (m_cde_command_bytes[2] << 8) | (m_cde_command_bytes[3]));
600	602	break;
601	603	}
602	604	case 0x0b:      // Get Drive State
603	605	{
604		state->m_cde_num_status_bytes = 0x3;
	606	m_cde_num_status_bytes = 0x3;
605	607
606		state->m_cde_status_bytes[0] = 0x0b;
607		state->m_cde_status_bytes[1] = 0x1b;
608		state->m_cde_status_bytes[2] = state->m_cde_drive_state;
609		state->m_cde_status_byte_ptr = 0;
	608	m_cde_status_bytes[0] = 0x0b;
	609	m_cde_status_bytes[1] = 0x1b;
	610	m_cde_status_bytes[2] = m_cde_drive_state;
	611	m_cde_status_byte_ptr = 0;
610	612
611		if (state->m_cde_command_bytes[1] & 0x02)
	613	if (m_cde_command_bytes[1] & 0x02)
612	614	{
613		state->m_cde_enable_seek_reports = 1;
	615	m_cde_enable_seek_reports = 1;
614	616	}
615	617	else
616	618	{
617		state->m_cde_enable_seek_reports = 0;
	619	m_cde_enable_seek_reports = 0;
618	620	}
619	621
620		//          mame_printf_debug("CDE: GET DRIVE STATE %02X\n", state->m_cde_command_bytes[1]);
	622	//          mame_printf_debug("CDE: GET DRIVE STATE %02X\n", m_cde_command_bytes[1]);
621	623	break;
622	624	}
623	625	case 0x0c:      // ?
624	626	{
625		state->m_cde_num_status_bytes = 1;
	627	m_cde_num_status_bytes = 1;
626	628
627		state->m_cde_status_bytes[0] = 0x0c;
628		state->m_cde_status_byte_ptr = 0;
	629	m_cde_status_bytes[0] = 0x0c;
	630	m_cde_status_byte_ptr = 0;
629	631
630		if (state->m_cde_command_bytes[1] == 0x02)
	632	if (m_cde_command_bytes[1] == 0x02)
631	633	{
632		state->m_cde_enable_qchannel_reports = 1;
633		state->m_cde_drive_state = CDE_DRIVE_STATE_PAUSED;
	634	m_cde_enable_qchannel_reports = 1;
	635	m_cde_drive_state = CDE_DRIVE_STATE_PAUSED;
634	636	}
635		else if (state->m_cde_command_bytes[0] == 0x00)
	637	else if (m_cde_command_bytes[0] == 0x00)
636	638	{
637		state->m_cde_enable_qchannel_reports = 0;
	639	m_cde_enable_qchannel_reports = 0;
638	640	}
639	641
640		//          mame_printf_debug("CDE: UNKNOWN CMD 0x0c %02X\n", state->m_cde_command_bytes[1]);
	642	//          mame_printf_debug("CDE: UNKNOWN CMD 0x0c %02X\n", m_cde_command_bytes[1]);
641	643	break;
642	644	}
643	645	case 0x0d:      // Get Switch State
644	646	{
645		state->m_cde_num_status_bytes = 0x4;
	647	m_cde_num_status_bytes = 0x4;
646	648
647		state->m_cde_status_bytes[0] = 0x0d;
648		state->m_cde_status_bytes[1] = 0x1d;
649		state->m_cde_status_bytes[2] = 0x02;
650		state->m_cde_status_byte_ptr = 0;
	649	m_cde_status_bytes[0] = 0x0d;
	650	m_cde_status_bytes[1] = 0x1d;
	651	m_cde_status_bytes[2] = 0x02;
	652	m_cde_status_byte_ptr = 0;
651	653
652		//          mame_printf_debug("CDE: GET SWITCH STATE %02X\n", state->m_cde_command_bytes[1]);
	654	//          mame_printf_debug("CDE: GET SWITCH STATE %02X\n", m_cde_command_bytes[1]);
653	655	break;
654	656	}
655	657	case 0x21:      // Mech type
656	658	{
657		state->m_cde_num_status_bytes = 0x8;
	659	m_cde_num_status_bytes = 0x8;
658	660
659		state->m_cde_status_bytes[0] = 0x21;
660		state->m_cde_status_bytes[1] = 0xff;
661		state->m_cde_status_bytes[2] = 0x08;        // Max Speed
662		state->m_cde_status_bytes[3] = 0xff;
663		state->m_cde_status_bytes[4] = 0xff;
664		state->m_cde_status_bytes[5] = 0xff;
665		state->m_cde_status_bytes[6] = 0xff;
666		state->m_cde_status_bytes[7] = 0xff;
	661	m_cde_status_bytes[0] = 0x21;
	662	m_cde_status_bytes[1] = 0xff;
	663	m_cde_status_bytes[2] = 0x08;        // Max Speed
	664	m_cde_status_bytes[3] = 0xff;
	665	m_cde_status_bytes[4] = 0xff;
	666	m_cde_status_bytes[5] = 0xff;
	667	m_cde_status_bytes[6] = 0xff;
	668	m_cde_status_bytes[7] = 0xff;
667	669
668		state->m_cde_status_byte_ptr = 0;
	670	m_cde_status_byte_ptr = 0;
669	671
670		//          mame_printf_debug("CDE: MECH TYPE %02X, %02X, %02X\n", state->m_cde_command_bytes[1], state->m_cde_command_bytes[2], state->m_cde_command_bytes[3]);
	672	//          mame_printf_debug("CDE: MECH TYPE %02X, %02X, %02X\n", m_cde_command_bytes[1], m_cde_command_bytes[2], m_cde_command_bytes[3]);
671	673	break;
672	674	}
673	675	case 0x83:      // Read ID
674	676	{
675		state->m_cde_num_status_bytes = 0xc;
	677	m_cde_num_status_bytes = 0xc;
676	678
677		state->m_cde_status_bytes[0] = 0x03;
678		state->m_cde_status_bytes[1] = 0xff;
679		state->m_cde_status_bytes[2] = 0xff;
680		state->m_cde_status_bytes[3] = 0xff;
681		state->m_cde_status_bytes[4] = 0xff;
682		state->m_cde_status_bytes[5] = 0xff;
683		state->m_cde_status_bytes[6] = 0xff;
684		state->m_cde_status_bytes[7] = 0xff;
685		state->m_cde_status_bytes[8] = 0xff;
686		state->m_cde_status_bytes[9] = 0xff;
687		state->m_cde_status_bytes[10] = 0xff;
688		state->m_cde_status_bytes[11] = 0xff;
	679	m_cde_status_bytes[0] = 0x03;
	680	m_cde_status_bytes[1] = 0xff;
	681	m_cde_status_bytes[2] = 0xff;
	682	m_cde_status_bytes[3] = 0xff;
	683	m_cde_status_bytes[4] = 0xff;
	684	m_cde_status_bytes[5] = 0xff;
	685	m_cde_status_bytes[6] = 0xff;
	686	m_cde_status_bytes[7] = 0xff;
	687	m_cde_status_bytes[8] = 0xff;
	688	m_cde_status_bytes[9] = 0xff;
	689	m_cde_status_bytes[10] = 0xff;
	690	m_cde_status_bytes[11] = 0xff;
689	691
690		state->m_cde_status_byte_ptr = 0;
	692	m_cde_status_byte_ptr = 0;
691	693
692	694	//          mame_printf_debug("CDE: READ ID\n");
693	695	break;
694	696	}
695	697	default:
696	698	{
697		fatalerror("CDE: unknown command %08X\n", state->m_cde_command_bytes[0]);
	699	fatalerror("CDE: unknown command %08X\n", m_cde_command_bytes[0]);
698	700	break;
699	701	}
700	702	}
701	703	}
702	704
703		static void cde_handle_reports(running_machine &machine)
	705	void konamim2_state::cde_handle_reports()
704	706	{
705		konamim2_state *state = machine.driver_data<konamim2_state>();
706		switch (state->m_cde_command_bytes[0])
	707	switch (m_cde_command_bytes[0])
707	708	{
708	709	case 0x09:
709	710	{
710		if (state->m_cde_enable_seek_reports)
	711	if (m_cde_enable_seek_reports)
711	712	{
712		state->m_cde_num_status_bytes = 0x2;
713		state->m_cde_status_bytes[0] = 0x02;
	713	m_cde_num_status_bytes = 0x2;
	714	m_cde_status_bytes[0] = 0x02;
714	715
715		state->m_cde_status_byte_ptr = 0;
	716	m_cde_status_byte_ptr = 0;
716	717
717		state->m_cde_command_bytes[0] = 0x0c;
	718	m_cde_command_bytes[0] = 0x0c;
718	719
719	720	//              mame_printf_debug("CDE: SEEK REPORT\n");
720	721	}
r21026	r21027
723	724
724	725	case 0x0b:
725	726	{
726		if (state->m_cde_enable_qchannel_reports)
	727	if (m_cde_enable_qchannel_reports)
727	728	{
728	729	int track, num_tracks;
729	730
730		num_tracks = state->m_cde_toc.numtrks;
731		track = state->m_cde_qchannel_offset % (num_tracks+3);
	731	num_tracks = m_cde_toc.numtrks;
	732	track = m_cde_qchannel_offset % (num_tracks+3);
732	733
733		state->m_cde_num_status_bytes = 0xb;
734		state->m_cde_status_bytes[0] = 0x1c;
	734	m_cde_num_status_bytes = 0xb;
	735	m_cde_status_bytes[0] = 0x1c;
735	736
736	737	/*
737		state->m_cde_status_bytes[1] = 0x0;      // q-Mode
738		state->m_cde_status_bytes[2] = 0x0;      // TNO
739		state->m_cde_status_bytes[3] = 0x0;      // Index / Pointer
740		state->m_cde_status_bytes[4] = 0x0;      // Min
741		state->m_cde_status_bytes[5] = 0x0;      // Sec
742		state->m_cde_status_bytes[6] = 0x0;      // Frac
743		state->m_cde_status_bytes[7] = 0x0;      // Zero
744		state->m_cde_status_bytes[8] = 0x0;      // A-Min
745		state->m_cde_status_bytes[9] = 0x0;      // A-Sec
746		state->m_cde_status_bytes[10] = 0x0;     // A-Frac
	738	m_cde_status_bytes[1] = 0x0;      // q-Mode
	739	m_cde_status_bytes[2] = 0x0;      // TNO
	740	m_cde_status_bytes[3] = 0x0;      // Index / Pointer
	741	m_cde_status_bytes[4] = 0x0;      // Min
	742	m_cde_status_bytes[5] = 0x0;      // Sec
	743	m_cde_status_bytes[6] = 0x0;      // Frac
	744	m_cde_status_bytes[7] = 0x0;      // Zero
	745	m_cde_status_bytes[8] = 0x0;      // A-Min
	746	m_cde_status_bytes[9] = 0x0;      // A-Sec
	747	m_cde_status_bytes[10] = 0x0;     // A-Frac
747	748	*/
748	749
749	750	if (track < num_tracks)
750	751	{
751		int time = lba_to_msf(state->m_cde_toc.tracks[track].physframeofs);
	752	int time = lba_to_msf(m_cde_toc.tracks[track].physframeofs);
752	753
753		state->m_cde_status_bytes[1] = 0x41;                    // q-Mode
754		state->m_cde_status_bytes[2] = 0x0;                 // TNO (Lead-in track)
755		state->m_cde_status_bytes[3] = track+1;             // Pointer
756		state->m_cde_status_bytes[4] = 0x0;                 // Min
757		state->m_cde_status_bytes[5] = 0x0;                 // Sec
758		state->m_cde_status_bytes[6] = 0x0;                 // Frac
759		state->m_cde_status_bytes[7] = 0x0;                 // Zero
760		state->m_cde_status_bytes[8] = (time >> 16) & 0xff; // P-Min
761		state->m_cde_status_bytes[9] = (time >>  8) & 0xff; // P-Sec
762		state->m_cde_status_bytes[10] = time & 0xff;            // P-Frac
	754	m_cde_status_bytes[1] = 0x41;                    // q-Mode
	755	m_cde_status_bytes[2] = 0x0;                 // TNO (Lead-in track)
	756	m_cde_status_bytes[3] = track+1;             // Pointer
	757	m_cde_status_bytes[4] = 0x0;                 // Min
	758	m_cde_status_bytes[5] = 0x0;                 // Sec
	759	m_cde_status_bytes[6] = 0x0;                 // Frac
	760	m_cde_status_bytes[7] = 0x0;                 // Zero
	761	m_cde_status_bytes[8] = (time >> 16) & 0xff; // P-Min
	762	m_cde_status_bytes[9] = (time >>  8) & 0xff; // P-Sec
	763	m_cde_status_bytes[10] = time & 0xff;            // P-Frac
763	764	}
764	765	else
765	766	{
766	767	if (track == num_tracks+0)
767	768	{
768		state->m_cde_status_bytes[1] = 0x41;                    // q-Mode / Control
769		state->m_cde_status_bytes[2] = 0x0;                 // TNO (Lead-in track)
770		state->m_cde_status_bytes[3] = 0xa0;                    // Pointer
771		state->m_cde_status_bytes[4] = 0x0;                 // Min
772		state->m_cde_status_bytes[5] = 0x0;                 // Sec
773		state->m_cde_status_bytes[6] = 0x0;                 // Frac
774		state->m_cde_status_bytes[7] = 0x0;                 // Zero
775		state->m_cde_status_bytes[8] = 1;                   // P-Min
776		state->m_cde_status_bytes[9] = 0x0;                 // P-Sec
777		state->m_cde_status_bytes[10] = 0x0;                    // P-Frac
	769	m_cde_status_bytes[1] = 0x41;                    // q-Mode / Control
	770	m_cde_status_bytes[2] = 0x0;                 // TNO (Lead-in track)
	771	m_cde_status_bytes[3] = 0xa0;                    // Pointer
	772	m_cde_status_bytes[4] = 0x0;                 // Min
	773	m_cde_status_bytes[5] = 0x0;                 // Sec
	774	m_cde_status_bytes[6] = 0x0;                 // Frac
	775	m_cde_status_bytes[7] = 0x0;                 // Zero
	776	m_cde_status_bytes[8] = 1;                   // P-Min
	777	m_cde_status_bytes[9] = 0x0;                 // P-Sec
	778	m_cde_status_bytes[10] = 0x0;                    // P-Frac
778	779	}
779	780	else if (track == num_tracks+1)
780	781	{
781		state->m_cde_status_bytes[1] = 0x41;                    // q-Mode / Control
782		state->m_cde_status_bytes[2] = 0x0;                 // TNO (Lead-in track)
783		state->m_cde_status_bytes[3] = 0xa1;                    // Pointer
784		state->m_cde_status_bytes[4] = 0x0;                 // Min
785		state->m_cde_status_bytes[5] = 0x0;                 // Sec
786		state->m_cde_status_bytes[6] = 0x0;                 // Frac
787		state->m_cde_status_bytes[7] = 0x0;                 // Zero
788		state->m_cde_status_bytes[8] = num_tracks;          // P-Min
789		state->m_cde_status_bytes[9] = 0x0;                 // P-Sec
790		state->m_cde_status_bytes[10] = 0x0;                    // P-Frac
	782	m_cde_status_bytes[1] = 0x41;                    // q-Mode / Control
	783	m_cde_status_bytes[2] = 0x0;                 // TNO (Lead-in track)
	784	m_cde_status_bytes[3] = 0xa1;                    // Pointer
	785	m_cde_status_bytes[4] = 0x0;                 // Min
	786	m_cde_status_bytes[5] = 0x0;                 // Sec
	787	m_cde_status_bytes[6] = 0x0;                 // Frac
	788	m_cde_status_bytes[7] = 0x0;                 // Zero
	789	m_cde_status_bytes[8] = num_tracks;          // P-Min
	790	m_cde_status_bytes[9] = 0x0;                 // P-Sec
	791	m_cde_status_bytes[10] = 0x0;                    // P-Frac
791	792	}
792	793	else
793	794	{
794		int leadout_lba = state->m_cde_toc.tracks[num_tracks-1].physframeofs + state->m_cde_toc.tracks[num_tracks-1].frames;
	795	int leadout_lba = m_cde_toc.tracks[num_tracks-1].physframeofs + m_cde_toc.tracks[num_tracks-1].frames;
795	796	int leadout_time = lba_to_msf(leadout_lba);
796	797
797		state->m_cde_status_bytes[1] = 0x41;                    // q-Mode / Control
798		state->m_cde_status_bytes[2] = 0x0;                 // TNO (Lead-in track)
799		state->m_cde_status_bytes[3] = 0xa2;                    // Pointer
800		state->m_cde_status_bytes[4] = 0x0;                 // Min
801		state->m_cde_status_bytes[5] = 0x0;                 // Sec
802		state->m_cde_status_bytes[6] = 0x0;                 // Frac
803		state->m_cde_status_bytes[7] = 0x0;                 // Zero
804		state->m_cde_status_bytes[8] = (leadout_time >> 16) & 0xff; // P-Min
805		state->m_cde_status_bytes[9] = (leadout_time >>  8) & 0xff; // P-Sec
806		state->m_cde_status_bytes[10] = leadout_time & 0xff;            // P-Frac
	798	m_cde_status_bytes[1] = 0x41;                    // q-Mode / Control
	799	m_cde_status_bytes[2] = 0x0;                 // TNO (Lead-in track)
	800	m_cde_status_bytes[3] = 0xa2;                    // Pointer
	801	m_cde_status_bytes[4] = 0x0;                 // Min
	802	m_cde_status_bytes[5] = 0x0;                 // Sec
	803	m_cde_status_bytes[6] = 0x0;                 // Frac
	804	m_cde_status_bytes[7] = 0x0;                 // Zero
	805	m_cde_status_bytes[8] = (leadout_time >> 16) & 0xff; // P-Min
	806	m_cde_status_bytes[9] = (leadout_time >>  8) & 0xff; // P-Sec
	807	m_cde_status_bytes[10] = leadout_time & 0xff;            // P-Frac
807	808	}
808	809	}
809	810
810		state->m_cde_qchannel_offset++;
	811	m_cde_qchannel_offset++;
811	812
812		state->m_cde_status_byte_ptr = 0;
813		state->m_cde_command_bytes[0] = 0x0c;
	813	m_cde_status_byte_ptr = 0;
	814	m_cde_command_bytes[0] = 0x0c;
814	815
815	816	//              mame_printf_debug("CDE: QCHANNEL REPORT\n");
816	817	break;
r21026	r21027
819	820	}
820	821	}
821	822
822		static void cde_dma_transfer(address_space &space, int channel, int next)
	823	void konamim2_state::cde_dma_transfer(address_space &space, int channel, int next)
823	824	{
824		konamim2_state *state = space.machine().driver_data<konamim2_state>();
825	825	UINT32 address;
826	826	//int length;
827	827	int i;
828	828
829	829	if (next)
830	830	{
831		address = state->m_cde_dma[channel].next_dst_addr;
832		//length = state->m_cde_dma[channel].next_length;
	831	address = m_cde_dma[channel].next_dst_addr;
	832	//length = m_cde_dma[channel].next_length;
833	833	}
834	834	else
835	835	{
836		address = state->m_cde_dma[channel].dst_addr;
837		//length = state->m_cde_dma[channel].length;
	836	address = m_cde_dma[channel].dst_addr;
	837	//length = m_cde_dma[channel].length;
838	838	}
839	839
840		for (i=0; i < state->m_cde_dma[channel].next_length; i++)
	840	for (i=0; i < m_cde_dma[channel].next_length; i++)
841	841	{
842	842	space.write_byte(address, 0xff);        // TODO: do the real transfer...
843	843	address++;
r21026	r21027
883	883
884	884	if (!m_cde_response)
885	885	{
886		cde_handle_reports(machine());
	886	cde_handle_reports();
887	887
888	888	//      m_cde_command_byte_ptr = 0;
889	889	//      m_cde_command_bytes[m_cde_command_byte_ptr++] = 0x1c;
r21026	r21027
944	944	{
945	945	if (m_cde_response)
946	946	{
947		cde_handle_command(machine());
	947	cde_handle_command();
948	948
949	949	m_cde_response = 0;
950	950	}
r21026	r21027
1299	1299	{
1300	1300	m_unk3 = U64(0xffffffffffffffff);
1301	1301	m_unk20004 = 0;
1302		cde_init(machine());
	1302	cde_init();
1303	1303	}
1304	1304
1305	1305	GAME( 1997, polystar, 0,        m2, m2, konamim2_state, m2, ROT0, "Konami", "Tobe! Polystars (ver JAA)", GAME_NOT_WORKING | GAME_NO_SOUND )

trunk/src/mame/drivers/royalmah.c

r21026	r21027
200	200	INTERRUPT_GEN_MEMBER(suzume_irq);
201	201	INTERRUPT_GEN_MEMBER(mjtensin_interrupt);
202	202	TIMER_DEVICE_CALLBACK_MEMBER(janptr96_interrupt);
	203	void mjtensin_update_rombank();
	204	void cafetime_update_rombank();
203	205	};
204	206
205	207
r21026	r21027
1056	1058	return 0xff;
1057	1059	}
1058	1060
1059		static void mjtensin_update_rombank(running_machine &machine)
	1061	void royalmah_state::mjtensin_update_rombank()
1060	1062	{
1061		royalmah_state *state = machine.driver_data<royalmah_state>();
1062		state->membank("bank1")->set_base(state->memregion("maincpu")->base() + 0x10000 + state->m_rombank * 0x8000 );
	1063	membank("bank1")->set_base(memregion("maincpu")->base() + 0x10000 + m_rombank * 0x8000 );
1063	1064	}
1064	1065	WRITE8_MEMBER(royalmah_state::mjtensin_p4_w)
1065	1066	{
1066	1067	m_rombank = (m_rombank & 0xf0) | (data & 0x0f);
1067		mjtensin_update_rombank(machine());
	1068	mjtensin_update_rombank();
1068	1069	}
1069	1070	WRITE8_MEMBER(royalmah_state::mjtensin_6ff3_w)
1070	1071	{
1071	1072	m_rombank = (data << 4) | (m_rombank & 0x0f);
1072		mjtensin_update_rombank(machine());
	1073	mjtensin_update_rombank();
1073	1074	}
1074	1075
1075	1076	static ADDRESS_MAP_START( mjtensin_map, AS_PROGRAM, 8, royalmah_state )
r21026	r21027
1098	1099	Mahjong Cafe Time
1099	1100	****************************************************************************/
1100	1101
1101		static void cafetime_update_rombank(running_machine &machine)
	1102	void royalmah_state::cafetime_update_rombank()
1102	1103	{
1103		royalmah_state *state = machine.driver_data<royalmah_state>();
1104		state->membank("bank1")->set_base(state->memregion("maincpu")->base() + 0x10000 + state->m_rombank * 0x8000 );
	1104	membank("bank1")->set_base(memregion("maincpu")->base() + 0x10000 + m_rombank * 0x8000 );
1105	1105	}
1106	1106	WRITE8_MEMBER(royalmah_state::cafetime_p4_w)
1107	1107	{
1108	1108	m_rombank = (m_rombank & 0xf0) | (data & 0x0f);
1109		cafetime_update_rombank(machine());
	1109	cafetime_update_rombank();
1110	1110	}
1111	1111	WRITE8_MEMBER(royalmah_state::cafetime_p3_w)
1112	1112	{
1113	1113	m_rombank = (m_rombank & 0x0f) | ((data & 0x0c) << 2);
1114		cafetime_update_rombank(machine());
	1114	cafetime_update_rombank();
1115	1115	}
1116	1116
1117	1117	WRITE8_MEMBER(royalmah_state::cafetime_dsw_w)

trunk/src/mame/drivers/igs017.c

r21026	r21027
159	159	TIMER_DEVICE_CALLBACK_MEMBER(irqblocka_interrupt);
160	160	TIMER_DEVICE_CALLBACK_MEMBER(mgcs_interrupt);
161	161	TIMER_DEVICE_CALLBACK_MEMBER(mgdh_interrupt);
	162	void expand_sprites();
	163	void draw_sprite(bitmap_ind16 &bitmap,const rectangle &cliprect, int sx, int sy, int dimx, int dimy, int flipx, int flipy, int color, int addr);
	164	void draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
	165	int debug_viewer(bitmap_ind16 &bitmap,const rectangle &cliprect);
	166	void decrypt_program_rom(int mask, int a7, int a6, int a5, int a4, int a3, int a2, int a1, int a0);
	167	void iqblocka_patch_rom();
	168	void tjsb_decrypt_sprites();
	169	void mgcs_decrypt_program_rom();
	170	void mgcs_decrypt_tiles();
	171	void mgcs_flip_sprites();
	172	void mgcs_patch_rom();
	173	void starzan_decrypt(UINT8 *ROM, int size, bool isOpcode);
	174	void lhzb2_patch_rom();
	175	void lhzb2_decrypt_tiles();
	176	void lhzb2_decrypt_sprites();
	177	void slqz2_patch_rom();
	178	void slqz2_decrypt_tiles();
162	179	};
163	180
164	181
r21026	r21027
249	266
250	267	// Eeach 16 bit word in the sprites gfx roms contains three 5 bit pens: x-22222-11111-00000 (little endian!).
251	268	// This routine expands each word into three bytes.
252		static void expand_sprites(running_machine &machine)
	269	void igs017_state::expand_sprites()
253	270	{
254		igs017_state *state = machine.driver_data<igs017_state>();
255		UINT8 *rom  =   state->memregion("sprites")->base();
256		int size    =   state->memregion("sprites")->bytes();
	271	UINT8 *rom  =   memregion("sprites")->base();
	272	int size    =   memregion("sprites")->bytes();
257	273	int i;
258	274
259		state->m_sprites_gfx_size   =   size / 2 * 3;
260		state->m_sprites_gfx        =   auto_alloc_array(machine, UINT8, state->m_sprites_gfx_size);
	275	m_sprites_gfx_size   =   size / 2 * 3;
	276	m_sprites_gfx        =   auto_alloc_array(machine(), UINT8, m_sprites_gfx_size);
261	277
262	278	for (i = 0; i < size / 2 ; i++)
263	279	{
264	280	UINT16 pens = (rom[i*2+1] << 8) | rom[i*2];
265	281
266		state->m_sprites_gfx[i * 3 + 0] = (pens >>  0) & 0x1f;
267		state->m_sprites_gfx[i * 3 + 1] = (pens >>  5) & 0x1f;
268		state->m_sprites_gfx[i * 3 + 2] = (pens >> 10) & 0x1f;
	282	m_sprites_gfx[i * 3 + 0] = (pens >>  0) & 0x1f;
	283	m_sprites_gfx[i * 3 + 1] = (pens >>  5) & 0x1f;
	284	m_sprites_gfx[i * 3 + 2] = (pens >> 10) & 0x1f;
269	285	}
270	286	}
271	287
r21026	r21027
281	297	m_debug_addr = 0;
282	298	m_debug_width = 512;
283	299
284		expand_sprites(machine());
	300	expand_sprites();
285	301	}
286	302
287	303	/***************************************************************************
r21026	r21027
317	333
318	334	***************************************************************************/
319	335
320		static void draw_sprite(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect, int sx, int sy, int dimx, int dimy, int flipx, int flipy, int color, int addr)
	336	void igs017_state::draw_sprite(bitmap_ind16 &bitmap,const rectangle &cliprect, int sx, int sy, int dimx, int dimy, int flipx, int flipy, int color, int addr)
321	337	{
322		igs017_state *state = machine.driver_data<igs017_state>();
323	338	// prepare GfxElement on the fly
324	339
325	340	// Bounds checking
326		if ( addr + dimx * dimy >= state->m_sprites_gfx_size )
	341	if ( addr + dimx * dimy >= m_sprites_gfx_size )
327	342	return;
328	343
329		gfx_element gfx(machine, state->m_sprites_gfx + addr, dimx, dimy, dimx, 0x100, 32);
	344	gfx_element gfx(machine(), m_sprites_gfx + addr, dimx, dimy, dimx, 0x100, 32);
330	345
331	346	drawgfx_transpen(   bitmap,cliprect, &gfx,
332	347	0, color,
r21026	r21027
334	349	sx, sy, 0x1f    );
335	350	}
336	351
337		static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	352	void igs017_state::draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
338	353	{
339		igs017_state *state = machine.driver_data<igs017_state>();
340		UINT8 *s    =   state->m_spriteram;
341		UINT8 *end  =   state->m_spriteram + 0x800;
	354	UINT8 *s    =   m_spriteram;
	355	UINT8 *end  =   m_spriteram + 0x800;
342	356
343	357	for ( ; s < end; s += 8 )
344	358	{
r21026	r21027
365	379
366	380	color = (s[7] & 0xe0) >> 5;
367	381
368		draw_sprite(machine, bitmap, cliprect, sx, sy, dimx, dimy, flipx, flipy, color, addr);
	382	draw_sprite(bitmap, cliprect, sx, sy, dimx, dimy, flipx, flipy, color, addr);
369	383	}
370	384	}
371	385
372	386	// A simple gfx viewer (toggle with T)
373		static int debug_viewer(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	387	int igs017_state::debug_viewer(bitmap_ind16 &bitmap,const rectangle &cliprect)
374	388	{
375	389	#ifdef MAME_DEBUG
376		igs017_state *state = machine.driver_data<igs017_state>();
377		if (machine.input().code_pressed_once(KEYCODE_T))   state->m_toggle = 1-state->m_toggle;
378		if (state->m_toggle)    {
379		int h = 256, w = state->m_debug_width, a = state->m_debug_addr;
	390	if (machine().input().code_pressed_once(KEYCODE_T))   m_toggle = 1-m_toggle;
	391	if (m_toggle)    {
	392	int h = 256, w = m_debug_width, a = m_debug_addr;
380	393
381		if (machine.input().code_pressed(KEYCODE_O))        w += 1;
382		if (machine.input().code_pressed(KEYCODE_I))        w -= 1;
	394	if (machine().input().code_pressed(KEYCODE_O))        w += 1;
	395	if (machine().input().code_pressed(KEYCODE_I))        w -= 1;
383	396
384		if (machine.input().code_pressed(KEYCODE_U))        w += 8;
385		if (machine.input().code_pressed(KEYCODE_Y))        w -= 8;
	397	if (machine().input().code_pressed(KEYCODE_U))        w += 8;
	398	if (machine().input().code_pressed(KEYCODE_Y))        w -= 8;
386	399
387		if (machine.input().code_pressed(KEYCODE_RIGHT))    a += 1;
388		if (machine.input().code_pressed(KEYCODE_LEFT))     a -= 1;
	400	if (machine().input().code_pressed(KEYCODE_RIGHT))    a += 1;
	401	if (machine().input().code_pressed(KEYCODE_LEFT))     a -= 1;
389	402
390		if (machine.input().code_pressed(KEYCODE_DOWN))     a += w;
391		if (machine.input().code_pressed(KEYCODE_UP))       a -= w;
	403	if (machine().input().code_pressed(KEYCODE_DOWN))     a += w;
	404	if (machine().input().code_pressed(KEYCODE_UP))       a -= w;
392	405
393		if (machine.input().code_pressed(KEYCODE_PGDN))     a += w * h;
394		if (machine.input().code_pressed(KEYCODE_PGUP))     a -= w * h;
	406	if (machine().input().code_pressed(KEYCODE_PGDN))     a += w * h;
	407	if (machine().input().code_pressed(KEYCODE_PGUP))     a -= w * h;
395	408
396	409	if (a < 0)      a = 0;
397		if (a > state->m_sprites_gfx_size)  a = state->m_sprites_gfx_size;
	410	if (a > m_sprites_gfx_size)  a = m_sprites_gfx_size;
398	411
399	412	if (w <= 0)     w = 0;
400	413	if (w > 1024)   w = 1024;
r21026	r21027
403	416
404	417	draw_sprite(machine, bitmap, cliprect, 0,0, w,h, 0,0, 0, a);
405	418
406		popmessage("a: %08X w: %03X p: %02x-%02x-%02x",a,w,state->m_sprites_gfx[a/3*3+0],state->m_sprites_gfx[a/3*3+1],state->m_sprites_gfx[a/3*3+2]);
407		state->m_debug_addr = a;
408		state->m_debug_width = w;
	419	popmessage("a: %08X w: %03X p: %02x-%02x-%02x",a,w,m_sprites_gfx[a/3*3+0],m_sprites_gfx[a/3*3+1],m_sprites_gfx[a/3*3+2]);
	420	m_debug_addr = a;
	421	m_debug_width = w;
409	422	osd_sleep(200000);
410	423	return 1;
411	424	}
r21026	r21027
428	441	}
429	442	#endif
430	443
431		if (debug_viewer(machine(), bitmap,cliprect))
	444	if (debug_viewer(bitmap,cliprect))
432	445	return 0;
433	446
434	447	bitmap.fill(get_black_pen(machine()), cliprect);
r21026	r21027
438	451
439	452	if (layers_ctrl & 1)    m_bg_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_OPAQUE, 0);
440	453
441		if (layers_ctrl & 4)    draw_sprites(machine(), bitmap, cliprect);
	454	if (layers_ctrl & 4)    draw_sprites(bitmap, cliprect);
442	455
443	456	if (layers_ctrl & 2)    m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
444	457
r21026	r21027
449	462	Decryption
450	463	***************************************************************************/
451	464
452		static void decrypt_program_rom(running_machine &machine, int mask, int a7, int a6, int a5, int a4, int a3, int a2, int a1, int a0)
	465	void igs017_state::decrypt_program_rom(int mask, int a7, int a6, int a5, int a4, int a3, int a2, int a1, int a0)
453	466	{
454		int length = machine.root_device().memregion("maincpu")->bytes();
455		UINT8 *rom = machine.root_device().memregion("maincpu")->base();
456		UINT8 *tmp = auto_alloc_array(machine, UINT8, length);
	467	int length = machine().root_device().memregion("maincpu")->bytes();
	468	UINT8 *rom = machine().root_device().memregion("maincpu")->base();
	469	UINT8 *tmp = auto_alloc_array(machine(), UINT8, length);
457	470	int i;
458	471
459	472	// decrypt the program ROM
r21026	r21027
502	515
503	516	// iqblocka
504	517
505		static void iqblocka_patch_rom(running_machine &machine)
	518	void igs017_state::iqblocka_patch_rom()
506	519	{
507		UINT8 *rom = machine.root_device().memregion("maincpu")->base();
	520	UINT8 *rom = machine().root_device().memregion("maincpu")->base();
508	521
509	522	//  rom[0x7b64] = 0xc9;
510	523
r21026	r21027
529	542
530	543	DRIVER_INIT_MEMBER(igs017_state,iqblocka)
531	544	{
532		decrypt_program_rom(machine(), 0x11, 7, 6, 5, 4, 3, 2, 1, 0);
533		iqblocka_patch_rom(machine());
	545	decrypt_program_rom(0x11, 7, 6, 5, 4, 3, 2, 1, 0);
	546	iqblocka_patch_rom();
534	547	}
535	548
536	549	// iqblockf
537	550
538	551	DRIVER_INIT_MEMBER(igs017_state,iqblockf)
539	552	{
540		decrypt_program_rom(machine(), 0x11, 7, 6, 5, 4, 3, 2, 1, 0);
541		//  iqblockf_patch_rom(machine());
	553	decrypt_program_rom(0x11, 7, 6, 5, 4, 3, 2, 1, 0);
	554	//  iqblockf_patch_rom();
542	555	}
543	556
544	557	// tjsb
545	558
546		static void tjsb_decrypt_sprites(running_machine &machine)
	559	void igs017_state::tjsb_decrypt_sprites()
547	560	{
548		int length = machine.root_device().memregion("sprites")->bytes();
549		UINT8 *rom = machine.root_device().memregion("sprites")->base();
550		UINT8 *tmp = auto_alloc_array(machine, UINT8, length);
	561	int length = machine().root_device().memregion("sprites")->bytes();
	562	UINT8 *rom = machine().root_device().memregion("sprites")->base();
	563	UINT8 *tmp = auto_alloc_array(machine(), UINT8, length);
551	564	int i, addr;
552	565
553	566	// address lines swap
r21026	r21027
570	583
571	584	DRIVER_INIT_MEMBER(igs017_state,tjsb)
572	585	{
573		decrypt_program_rom(machine(), 0x05, 7, 6, 3, 2, 5, 4, 1, 0);
	586	decrypt_program_rom(0x05, 7, 6, 3, 2, 5, 4, 1, 0);
574	587
575		tjsb_decrypt_sprites(machine());
	588	tjsb_decrypt_sprites();
576	589	}
577	590
578	591
579	592	// mgcs
580	593
581		static void mgcs_decrypt_program_rom(running_machine &machine)
	594	void igs017_state::mgcs_decrypt_program_rom()
582	595	{
583	596	int i;
584		UINT16 *src = (UINT16 *)machine.root_device().memregion("maincpu")->base();
	597	UINT16 *src = (UINT16 *)machine().root_device().memregion("maincpu")->base();
585	598
586	599	int rom_size = 0x80000;
587	600
r21026	r21027
628	641	}
629	642	}
630	643
631		static void mgcs_decrypt_tiles(running_machine &machine)
	644	void igs017_state::mgcs_decrypt_tiles()
632	645	{
633		int length = machine.root_device().memregion("tilemaps")->bytes();
634		UINT8 *rom = machine.root_device().memregion("tilemaps")->base();
635		UINT8 *tmp = auto_alloc_array(machine, UINT8, length);
	646	int length = machine().root_device().memregion("tilemaps")->bytes();
	647	UINT8 *rom = machine().root_device().memregion("tilemaps")->base();
	648	UINT8 *tmp = auto_alloc_array(machine(), UINT8, length);
636	649	int i;
637	650
638	651	memcpy(tmp,rom,length);
r21026	r21027
642	655	rom[i] = tmp[addr];
643	656	}
644	657
645		auto_free(machine, tmp);
	658	auto_free(machine(), tmp);
646	659	}
647	660
648		static void mgcs_flip_sprites(running_machine &machine)
	661	void igs017_state::mgcs_flip_sprites()
649	662	{
650		int length = machine.root_device().memregion("sprites")->bytes();
651		UINT8 *rom = machine.root_device().memregion("sprites")->base();
	663	int length = machine().root_device().memregion("sprites")->bytes();
	664	UINT8 *rom = machine().root_device().memregion("sprites")->base();
652	665	int i;
653	666
654	667	for (i = 0;i < length;i+=2)
r21026	r21027
666	679	}
667	680	}
668	681
669		static void mgcs_patch_rom(running_machine &machine)
	682	void igs017_state::mgcs_patch_rom()
670	683	{
671		UINT16 *rom = (UINT16 *)machine.root_device().memregion("maincpu")->base();
	684	UINT16 *rom = (UINT16 *)machine().root_device().memregion("maincpu")->base();
672	685
673	686	rom[0x4e036/2] = 0x6006;
674	687
r21026	r21027
681	694
682	695	DRIVER_INIT_MEMBER(igs017_state,mgcs)
683	696	{
684		mgcs_decrypt_program_rom(machine());
685		mgcs_patch_rom(machine());
	697	mgcs_decrypt_program_rom();
	698	mgcs_patch_rom();
686	699
687		mgcs_decrypt_tiles(machine());
688		mgcs_flip_sprites(machine());
	700	mgcs_decrypt_tiles();
	701	mgcs_flip_sprites();
689	702	}
690	703
691	704
r21026	r21027
741	754
742	755	// decryption is incomplete: data decryption is correct but opcodes are encrypted differently.
743	756
744		static void starzan_decrypt(UINT8 *ROM, int size, bool isOpcode)
	757	void igs017_state::starzan_decrypt(UINT8 *ROM, int size, bool isOpcode)
745	758	{
746	759	for(int i=0; i<size; i++)
747	760	{
r21026	r21027
802	815
803	816	machine().device("maincpu")->memory().space(AS_PROGRAM).set_decrypted_region(0x00000, 0x3ffff, code);
804	817
805		mgcs_flip_sprites(machine());
	818	mgcs_flip_sprites();
806	819	}
807	820
808	821
r21026	r21027
896	909	src[i] = x;
897	910	}
898	911
899		mgcs_flip_sprites(machine());
	912	mgcs_flip_sprites();
900	913	}
901	914
902	915	DRIVER_INIT_MEMBER(igs017_state,mgdh)
r21026	r21027
913	926	// lhzb2
914	927
915	928
916		static void lhzb2_patch_rom(running_machine &machine)
	929	void igs017_state::lhzb2_patch_rom()
917	930	{
918		UINT16 *rom = (UINT16 *)machine.root_device().memregion("maincpu")->base();
	931	UINT16 *rom = (UINT16 *)machine().root_device().memregion("maincpu")->base();
919	932
920	933	// Prot. checks:
921	934	rom[0x14786/2] = 0x6044;    // 014786: 6744    beq $147cc
r21026	r21027
924	937	rom[0x0b48a/2] = 0x604e;    // 00B48A: 674E    beq $b4da
925	938	}
926	939
927		static void lhzb2_decrypt_tiles(running_machine &machine)
	940	void igs017_state::lhzb2_decrypt_tiles()
928	941	{
929		int length = machine.root_device().memregion("tilemaps")->bytes();
930		UINT8 *rom = machine.root_device().memregion("tilemaps")->base();
931		UINT8 *tmp = auto_alloc_array(machine, UINT8, length);
	942	int length = machine().root_device().memregion("tilemaps")->bytes();
	943	UINT8 *rom = machine().root_device().memregion("tilemaps")->base();
	944	UINT8 *tmp = auto_alloc_array(machine(), UINT8, length);
932	945	int i;
933	946
934	947	int addr;
r21026	r21027
939	952	rom[i] = tmp[addr];
940	953	}
941	954
942		auto_free(machine, tmp);
	955	auto_free(machine(), tmp);
943	956	}
944	957
945		static void lhzb2_decrypt_sprites(running_machine &machine)
	958	void igs017_state::lhzb2_decrypt_sprites()
946	959	{
947		int length = machine.root_device().memregion("sprites")->bytes();
948		UINT8 *rom = machine.root_device().memregion("sprites")->base();
949		UINT8 *tmp = auto_alloc_array(machine, UINT8, length);
	960	int length = machine().root_device().memregion("sprites")->bytes();
	961	UINT8 *rom = machine().root_device().memregion("sprites")->base();
	962	UINT8 *tmp = auto_alloc_array(machine(), UINT8, length);
950	963	int i, addr;
951	964
952	965	// address lines swap
r21026	r21027
1053	1066	src[i] = x;
1054	1067	}
1055	1068
1056		lhzb2_decrypt_tiles(machine());
1057		lhzb2_decrypt_sprites(machine());
1058		lhzb2_patch_rom(machine());
	1069	lhzb2_decrypt_tiles();
	1070	lhzb2_decrypt_sprites();
	1071	lhzb2_patch_rom();
1059	1072	}
1060	1073
1061	1074
r21026	r21027
1119	1132	src[i] = x;
1120	1133	}
1121	1134
1122		lhzb2_decrypt_tiles(machine());
1123		lhzb2_decrypt_sprites(machine());
	1135	lhzb2_decrypt_tiles();
	1136	lhzb2_decrypt_sprites();
1124	1137	}
1125	1138
1126	1139
1127	1140	//slqz2
1128	1141
1129		static void slqz2_patch_rom(running_machine &machine)
	1142	void igs017_state::slqz2_patch_rom()
1130	1143	{
1131		UINT16 *rom = (UINT16 *)machine.root_device().memregion("maincpu")->base();
	1144	UINT16 *rom = (UINT16 *)machine().root_device().memregion("maincpu")->base();
1132	1145
1133	1146	// Prot. checks:
1134	1147	rom[0x1489c/2] = 0x6044;    // 01489C: 6744    beq $148e2
r21026	r21027
1137	1150	rom[0x0b77a/2] = 0x604e;    // 00B77A: 674E    beq $b7ca
1138	1151	}
1139	1152
1140		static void slqz2_decrypt_tiles(running_machine &machine)
	1153	void igs017_state::slqz2_decrypt_tiles()
1141	1154	{
1142		int length = machine.root_device().memregion("tilemaps")->bytes();
1143		UINT8 *rom = machine.root_device().memregion("tilemaps")->base();
1144		UINT8 *tmp = auto_alloc_array(machine, UINT8, length);
	1155	int length = machine().root_device().memregion("tilemaps")->bytes();
	1156	UINT8 *rom = machine().root_device().memregion("tilemaps")->base();
	1157	UINT8 *tmp = auto_alloc_array(machine(), UINT8, length);
1145	1158	int i;
1146	1159
1147	1160	memcpy(tmp,rom,length);
r21026	r21027
1151	1164	rom[i] = tmp[addr];
1152	1165	}
1153	1166
1154		auto_free(machine, tmp);
	1167	auto_free(machine(), tmp);
1155	1168	}
1156	1169
1157	1170	DRIVER_INIT_MEMBER(igs017_state,slqz2)
r21026	r21027
1230	1243	src[i] = x;
1231	1244	}
1232	1245
1233		slqz2_decrypt_tiles(machine());
1234		lhzb2_decrypt_sprites(machine());
1235		slqz2_patch_rom(machine());
	1246	slqz2_decrypt_tiles();
	1247	lhzb2_decrypt_sprites();
	1248	slqz2_patch_rom();
1236	1249	}
1237	1250
1238	1251	/***************************************************************************

trunk/src/mame/drivers/cobra.c

r21026	r21027
395	395	void gfx_write_reg(running_machine &machine, UINT64 data);
396	396
397	397	void display(bitmap_rgb32 *bitmap, const rectangle &cliprect);
398
	398	inline rgb_t texture_fetch(UINT32 *texture, int u, int v, int width, int format);
399	399	private:
400	400	bitmap_rgb32 *m_framebuffer;
401	401	bitmap_rgb32 *m_backbuffer;
r21026	r21027
724	724	UINT32 screen_update_cobra(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
725	725	INTERRUPT_GEN_MEMBER(cobra_vblank);
726	726	void cobra_video_exit();
	727	int decode_debug_state_value(int v);
727	728	};
728	729
729	730	void cobra_renderer::render_color_scan(INT32 scanline, const extent_t &extent, const cobra_polydata &extradata, int threadid)
r21026	r21027
772	773	}
773	774	}
774	775
775		INLINE rgb_t texture_fetch(UINT32 *texture, int u, int v, int width, int format)
	776	rgb_t cobra_renderer::texture_fetch(UINT32 *texture, int u, int v, int width, int format)
776	777	{
777	778	UINT32 texel = texture[((v * width) + u) / 2];
778	779
r21026	r21027
1020	1021
1021	1022	/*****************************************************************************/
1022	1023
1023		static int decode_debug_state_value(int v)
	1024	int cobra_state::decode_debug_state_value(int v)
1024	1025	{
1025	1026	switch (v)
1026	1027	{

trunk/src/mame/drivers/cntsteer.c

r21026	r21027
93	93	UINT32 screen_update_cntsteer(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
94	94	UINT32 screen_update_zerotrgt(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
95	95	INTERRUPT_GEN_MEMBER(sound_interrupt);
	96	void zerotrgt_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	97	void cntsteer_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	98	void zerotrgt_rearrange_gfx( int romsize, int romarea );
96	99	};
97	100
98	101
r21026	r21027
174	177	[2] xxxx xxxx X attribute
175	178	[3] xxxx xxxx sprite number
176	179	*/
177		static void zerotrgt_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	180	void cntsteer_state::zerotrgt_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
178	181	{
179		cntsteer_state *state = machine.driver_data<cntsteer_state>();
180	182	int offs;
181	183
182	184	for (offs = 0; offs < 0x200; offs += 4)
183	185	{
184	186	int multi, fx, fy, sx, sy, code, color;
185	187
186		if ((state->m_spriteram[offs + 1] & 1) == 1)
	188	if ((m_spriteram[offs + 1] & 1) == 1)
187	189	continue;
188	190
189		code = state->m_spriteram[offs + 3] + ((state->m_spriteram[offs + 1] & 0xc0) << 2);
190		sx = (state->m_spriteram[offs + 2]);
191		sy = 0xf0 - state->m_spriteram[offs];
192		color = 0x10 + ((state->m_spriteram[offs + 1] & 0x20) >> 4) + ((state->m_spriteram[offs + 1] & 0x8)>>3);
	191	code = m_spriteram[offs + 3] + ((m_spriteram[offs + 1] & 0xc0) << 2);
	192	sx = (m_spriteram[offs + 2]);
	193	sy = 0xf0 - m_spriteram[offs];
	194	color = 0x10 + ((m_spriteram[offs + 1] & 0x20) >> 4) + ((m_spriteram[offs + 1] & 0x8)>>3);
193	195
194		fx = !(state->m_spriteram[offs + 1] & 0x04);
195		fy = (state->m_spriteram[offs + 1] & 0x02);
	196	fx = !(m_spriteram[offs + 1] & 0x04);
	197	fy = (m_spriteram[offs + 1] & 0x02);
196	198
197		multi = state->m_spriteram[offs + 1] & 0x10;
	199	multi = m_spriteram[offs + 1] & 0x10;
198	200
199		if (state->m_flipscreen)
	201	if (m_flipscreen)
200	202	{
201	203	sy = 240 - sy;
202	204	sx = 240 - sx;
r21026	r21027
209	211	{
210	212	if (fy)
211	213	{
212		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, color, fx, fy, sx, sy, 0);
213		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code + 1, color, fx, fy, sx, sy - 16, 0);
	214	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code, color, fx, fy, sx, sy, 0);
	215	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code + 1, color, fx, fy, sx, sy - 16, 0);
214	216	}
215	217	else
216	218	{
217		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, color, fx, fy, sx, sy - 16, 0);
218		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code + 1, color, fx, fy, sx, sy, 0);
	219	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code, color, fx, fy, sx, sy - 16, 0);
	220	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code + 1, color, fx, fy, sx, sy, 0);
219	221	}
220	222	}
221	223	else
222		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, color, fx, fy, sx, sy, 0);
	224	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code, color, fx, fy, sx, sy, 0);
223	225	}
224	226	}
225	227
r21026	r21027
232	234	---- --xx tile bank
233	235	*/
234	236
235		static void cntsteer_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	237	void cntsteer_state::cntsteer_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
236	238	{
237		cntsteer_state *state = machine.driver_data<cntsteer_state>();
238	239	int offs;
239	240
240	241	for (offs = 0; offs < 0x80; offs += 4)
241	242	{
242	243	int multi, fx, fy, sx, sy, code, color;
243	244
244		if ((state->m_spriteram[offs + 0] & 1) == 0)
	245	if ((m_spriteram[offs + 0] & 1) == 0)
245	246	continue;
246	247
247		code = state->m_spriteram[offs + 1] + ((state->m_spriteram[offs + 0x80] & 0x03) << 8);
248		sx = 0x100 - state->m_spriteram[offs + 3];
249		sy = 0x100 - state->m_spriteram[offs + 2];
250		color = 0x10 + ((state->m_spriteram[offs + 0x80] & 0x70) >> 4);
	248	code = m_spriteram[offs + 1] + ((m_spriteram[offs + 0x80] & 0x03) << 8);
	249	sx = 0x100 - m_spriteram[offs + 3];
	250	sy = 0x100 - m_spriteram[offs + 2];
	251	color = 0x10 + ((m_spriteram[offs + 0x80] & 0x70) >> 4);
251	252
252		fx = (state->m_spriteram[offs + 0] & 0x04);
253		fy = (state->m_spriteram[offs + 0] & 0x02);
	253	fx = (m_spriteram[offs + 0] & 0x04);
	254	fy = (m_spriteram[offs + 0] & 0x02);
254	255
255		multi = state->m_spriteram[offs + 0] & 0x10;
	256	multi = m_spriteram[offs + 0] & 0x10;
256	257
257		if (state->m_flipscreen)
	258	if (m_flipscreen)
258	259	{
259	260	sy = 240 - sy;
260	261	sx = 240 - sx;
r21026	r21027
267	268	{
268	269	if (fy)
269	270	{
270		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, color, fx, fy, sx, sy, 0);
271		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code + 1, color, fx, fy, sx, sy - 16, 0);
	271	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code, color, fx, fy, sx, sy, 0);
	272	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code + 1, color, fx, fy, sx, sy - 16, 0);
272	273	}
273	274	else
274	275	{
275		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, color, fx, fy, sx, sy - 16, 0);
276		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code + 1, color, fx, fy, sx, sy, 0);
	276	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code, color, fx, fy, sx, sy - 16, 0);
	277	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code + 1, color, fx, fy, sx, sy, 0);
277	278	}
278	279	}
279	280	else
280		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, color, fx, fy, sx, sy, 0);
	281	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code, color, fx, fy, sx, sy, 0);
281	282	}
282	283	}
283	284
r21026	r21027
324	325	0, 0);
325	326	}
326	327
327		zerotrgt_draw_sprites(machine(), bitmap, cliprect);
	328	zerotrgt_draw_sprites(bitmap, cliprect);
328	329	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
329	330
330	331	return 0;
r21026	r21027
371	372	0, 0);
372	373	}
373	374
374		cntsteer_draw_sprites(machine(), bitmap, cliprect);
	375	cntsteer_draw_sprites(bitmap, cliprect);
375	376	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
376	377
377	378	return 0;
r21026	r21027
1139	1140
1140	1141	/***************************************************************************/
1141	1142
1142		static void zerotrgt_rearrange_gfx( running_machine &machine, int romsize, int romarea )
	1143	void cntsteer_state::zerotrgt_rearrange_gfx( int romsize, int romarea )
1143	1144	{
1144		UINT8 *src = machine.root_device().memregion("gfx4")->base();
1145		UINT8 *dst = machine.root_device().memregion("gfx3")->base();
	1145	UINT8 *src = machine().root_device().memregion("gfx4")->base();
	1146	UINT8 *dst = machine().root_device().memregion("gfx3")->base();
1146	1147	int rm;
1147	1148	int cnt1;
1148	1149
r21026	r21027
1174	1175
1175	1176	DRIVER_INIT_MEMBER(cntsteer_state,zerotrgt)
1176	1177	{
1177		zerotrgt_rearrange_gfx(machine(), 0x02000, 0x10000);
	1178	zerotrgt_rearrange_gfx(0x02000, 0x10000);
1178	1179	}
1179	1180
1180	1181

trunk/src/mame/drivers/galpani3.c

r21026	r21027
114	114	virtual void video_start();
115	115	UINT32 screen_update_galpani3(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
116	116	TIMER_DEVICE_CALLBACK_MEMBER(galpani3_vblank);
	117	int gp3_is_alpha_pen(int pen);
117	118	};
118	119
119	120
r21026	r21027
150	151
151	152
152	153
153		static int gp3_is_alpha_pen(running_machine &machine, int pen)
	154	int galpani3_state::gp3_is_alpha_pen(int pen)
154	155	{
155		galpani3_state *state = machine.driver_data<galpani3_state>();
156	156	UINT16 dat = 0;
157	157
158	158	if (pen<0x4000)
159	159	{
160		dat = state->m_generic_paletteram_16[pen];
	160	dat = m_generic_paletteram_16[pen];
161	161	}
162	162	else if (pen<0x4100)
163	163	{
164		dat = state->m_grap2_0->m_framebuffer_palette[pen&0xff];
	164	dat = m_grap2_0->m_framebuffer_palette[pen&0xff];
165	165	}
166	166	else if (pen<0x4200)
167	167	{
168		dat = state->m_grap2_1->m_framebuffer_palette[pen&0xff];
	168	dat = m_grap2_1->m_framebuffer_palette[pen&0xff];
169	169	}
170	170	else if (pen<0x4300)
171	171	{
172		dat = state->m_grap2_2->m_framebuffer_palette[pen&0xff];
	172	dat = m_grap2_2->m_framebuffer_palette[pen&0xff];
173	173	}
174	174	else if (pen<0x4301)
175	175	{
176		dat = state->m_grap2_0->m_framebuffer_bgcol;
	176	dat = m_grap2_0->m_framebuffer_bgcol;
177	177	}
178	178	else if (pen<0x4302)
179	179	{
180		dat = state->m_grap2_1->m_framebuffer_bgcol;
	180	dat = m_grap2_1->m_framebuffer_bgcol;
181	181	}
182	182	else if (pen<0x4303)
183	183	{
184		dat = state->m_grap2_2->m_framebuffer_bgcol;
	184	dat = m_grap2_2->m_framebuffer_bgcol;
185	185	}
186	186
187	187	if (dat&0x8000) return 1;
r21026	r21027
259	259	UINT16 pen = dat1+0x4000;
260	260	UINT32 pal = paldata[pen];
261	261
262		if (gp3_is_alpha_pen(machine(), pen))
	262	if (gp3_is_alpha_pen(pen))
263	263	{
264	264	int r,g,b;
265	265	r = (pal & 0x00ff0000)>>16;
r21026	r21027
287	287	UINT16 pen = dat2+0x4100;
288	288	UINT32 pal = paldata[pen];
289	289
290		if (gp3_is_alpha_pen(machine(), pen))
	290	if (gp3_is_alpha_pen(pen))
291	291	{
292	292	int r,g,b;
293	293	r = (pal & 0x00ff0000)>>16;

trunk/src/mame/drivers/maxaflex.c

r21026	r21027
60	60	DECLARE_DRIVER_INIT(a600xl);
61	61	DECLARE_MACHINE_RESET(supervisor_board);
62	62	TIMER_DEVICE_CALLBACK_MEMBER(mcu_timer_proc);
	63	int atari_input_disabled();
63	64	};
64	65
65	66
r21026	r21027
263	264	machine().device("mcu")->execute().set_input_line(M6805_IRQ_LINE, HOLD_LINE );
264	265	}
265	266
266		int atari_input_disabled(running_machine &machine)
	267	int maxaflex_state::atari_input_disabled()
267	268	{
268		maxaflex_state *state = machine.driver_data<maxaflex_state>();
269		return (state->m_portB_out & 0x80) == 0x00;
	269	return (m_portB_out & 0x80) == 0x00;
270	270	}
271	271
272	272
r21026	r21027
373	373
374	374	READ8_MEMBER(maxaflex_state::maxaflex_atari_pia_pa_r)
375	375	{
376		return atari_input_disabled(machine()) ? 0xFF : machine().root_device().ioport("djoy_0_1")->read_safe(0);
	376	return atari_input_disabled() ? 0xFF : machine().root_device().ioport("djoy_0_1")->read_safe(0);
377	377	}
378	378
379	379	READ8_MEMBER(maxaflex_state::maxaflex_atari_pia_pb_r)
380	380	{
381		return atari_input_disabled(machine()) ? 0xFF : machine().root_device().ioport("djoy_2_3")->read_safe(0);
	381	return atari_input_disabled() ? 0xFF : machine().root_device().ioport("djoy_2_3")->read_safe(0);
382	382	}
383	383
384	384

trunk/src/mame/drivers/chanbara.c

r21026	r21027
93	93	virtual void video_start();
94	94	virtual void palette_init();
95	95	UINT32 screen_update_chanbara(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	96	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
96	97	};
97	98
98	99
r21026	r21027
159	160	m_bg_tilemap->set_transparent_pen(0);
160	161	}
161	162
162		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	163	void chanbara_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
163	164	{
164		chanbara_state *state = machine.driver_data<chanbara_state>();
165	165	int offs;
166	166
167	167	for (offs = 0; offs < 0x80; offs += 4)
168	168	{
169		if (state->m_spriteram[offs + 0x80] & 0x80)
	169	if (m_spriteram[offs + 0x80] & 0x80)
170	170	{
171		int attr = state->m_spriteram[offs + 0];
172		int code = state->m_spriteram[offs + 1];
173		int color = state->m_spriteram[offs + 0x80] & 0x1f;
	171	int attr = m_spriteram[offs + 0];
	172	int code = m_spriteram[offs + 1];
	173	int color = m_spriteram[offs + 0x80] & 0x1f;
174	174	int flipx = 0;
175	175	int flipy = attr & 2;
176		int sx = 240 - state->m_spriteram[offs + 3];
177		int sy = 232 - state->m_spriteram[offs + 2];
	176	int sx = 240 - m_spriteram[offs + 3];
	177	int sy = 232 - m_spriteram[offs + 2];
178	178
179	179	sy+=16;
180	180
181		if (state->m_spriteram[offs + 0x80] & 0x10) code += 0x200;
182		if (state->m_spriteram[offs + 0x80] & 0x20) code += 0x400;
183		if (state->m_spriteram[offs + 0x80] & 0x40) code += 0x100;
	181	if (m_spriteram[offs + 0x80] & 0x10) code += 0x200;
	182	if (m_spriteram[offs + 0x80] & 0x20) code += 0x400;
	183	if (m_spriteram[offs + 0x80] & 0x40) code += 0x100;
184	184
185	185	if (attr & 0x10)
186	186	{
187	187	if (!flipy)
188	188	{
189		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, color, flipx, flipy, sx, sy-16, 0);
190		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code+1, color, flipx, flipy, sx, sy, 0);
	189	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code, color, flipx, flipy, sx, sy-16, 0);
	190	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code+1, color, flipx, flipy, sx, sy, 0);
191	191	}
192	192	else
193	193	{
194		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, color, flipx, flipy, sx, sy, 0);
195		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code+1, color, flipx, flipy, sx, sy-16, 0);
	194	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code, color, flipx, flipy, sx, sy, 0);
	195	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code+1, color, flipx, flipy, sx, sy-16, 0);
196	196	}
197	197	}
198	198	else
199	199	{
200		drawgfx_transpen(bitmap, cliprect, machine.gfx[1], code, color, flipx, flipy, sx, sy, 0);
	200	drawgfx_transpen(bitmap, cliprect, machine().gfx[1], code, color, flipx, flipy, sx, sy, 0);
201	201	}
202	202	}
203	203	}
r21026	r21027
207	207	{
208	208	m_bg2_tilemap->set_scrolly(0, m_scroll | (m_scrollhi << 8));
209	209	m_bg2_tilemap->draw(bitmap, cliprect, 0, 0);
210		draw_sprites(machine(), bitmap, cliprect);
	210	draw_sprites(bitmap, cliprect);
211	211	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
212	212	return 0;
213	213	}

trunk/src/mame/drivers/mpu4vid.c

r21026	r21027
298	298	DECLARE_WRITE8_MEMBER(vid_o2_callback);
299	299	DECLARE_WRITE8_MEMBER(vid_o3_callback);
300	300	DECLARE_READ8_MEMBER(pia_ic5_porta_track_r);
	301	void mpu4vid_char_cheat( int address);
301	302	};
302	303
303	304
r21026	r21027
2018	2019	m_current_chr_table = prizeinv_data;
2019	2020	}
2020	2021
2021		void mpu4vid_char_cheat(running_machine& machine, int address)
	2022	void mpu4vid_state::mpu4vid_char_cheat( int address)
2022	2023	{
2023		mpu4_state *state = machine.driver_data<mpu4_state>();
2024		UINT8* cheattable = state->memregion( "video" )->base()+address;
2025		state->m_current_chr_table = blank_data;
	2024	UINT8* cheattable = memregion( "video" )->base()+address;
	2025	m_current_chr_table = blank_data;
2026	2026	for (int i=0;i<72;i++)
2027	2027	{
2028		state->m_current_chr_table[i].response = cheattable++[0];
2029		state->m_current_chr_table[i].call = cheattable++[0];
	2028	m_current_chr_table[i].response = cheattable++[0];
	2029	m_current_chr_table[i].call = cheattable++[0];
2030	2030	}
2031	2031	}
2032	2032
2033	2033	DRIVER_INIT_MEMBER(mpu4vid_state,v4barqst)
2034	2034	{
2035		mpu4vid_char_cheat(machine(),0x154);
	2035	mpu4vid_char_cheat(0x154);
2036	2036	}
2037	2037
2038	2038	DRIVER_INIT_MEMBER(mpu4vid_state,v4barqst2)
2039	2039	{
2040		mpu4vid_char_cheat(machine(),0x15c);
	2040	mpu4vid_char_cheat(0x15c);
2041	2041	}
2042	2042
2043	2043	DRIVER_INIT_MEMBER(mpu4vid_state,v4wize)
2044	2044	{
2045		mpu4vid_char_cheat(machine(),0x16c);
	2045	mpu4vid_char_cheat(0x16c);
2046	2046	}
2047	2047
2048	2048	DRIVER_INIT_MEMBER(mpu4vid_state,v4cmazeb)
2049	2049	{
2050		mpu4vid_char_cheat(machine(),0x4c6);
	2050	mpu4vid_char_cheat(0x4c6);
2051	2051	}
2052	2052
2053	2053	DRIVER_INIT_MEMBER(mpu4vid_state,v4opt3)
2054	2054	{
2055		mpu4vid_char_cheat(machine(),0x164);
	2055	mpu4vid_char_cheat(0x164);
2056	2056	}
2057	2057
2058	2058

trunk/src/mame/drivers/silvmil.c

r21026	r21027
113	113	virtual void machine_reset();
114	114	virtual void video_start();
115	115	UINT32 screen_update_silvmil(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	116	void tumblepb_gfx1_rearrange();
116	117	};
117	118
118	119
r21026	r21027
394	395	ROM_END
395	396
396	397
397		static void tumblepb_gfx1_rearrange(running_machine &machine)
	398	void silvmil_state::tumblepb_gfx1_rearrange()
398	399	{
399		UINT8 *rom = machine.root_device().memregion("gfx1")->base();
400		int len = machine.root_device().memregion("gfx1")->bytes();
	400	UINT8 *rom = machine().root_device().memregion("gfx1")->base();
	401	int len = machine().root_device().memregion("gfx1")->bytes();
401	402	int i;
402	403
403	404	/* gfx data is in the wrong order */
r21026	r21027
417	418
418	419	DRIVER_INIT_MEMBER(silvmil_state,silvmil)
419	420	{
420		tumblepb_gfx1_rearrange(machine());
	421	tumblepb_gfx1_rearrange();
421	422	}
422	423
423	424	GAME( 1995, silvmil, 0, silvmil, silvmil, silvmil_state, silvmil, ROT270, "Para", "Silver Millennium", 0 )

trunk/src/mame/drivers/pengadvb.c

r21026	r21027
47	47	virtual void machine_start();
48	48	virtual void machine_reset();
49	49	void pengadvb_postload();
	50	void mem_map_banks();
	51	void pengadvb_decrypt(const char* region);
50	52	};
51	53
52	54
53	55
54		static void mem_map_banks(running_machine &machine)
	56	void pengadvb_state::mem_map_banks()
55	57	{
56		pengadvb_state *state = machine.driver_data<pengadvb_state>();
57	58	/*  memorymap: (rest is assumed unmapped)
58	59	slot 0
59	60	0000-7fff   BIOS ROM
r21026	r21027
64	65	*/
65	66
66	67	// page 0 (0000-3fff)
67		switch(state->m_mem_map & 3)
	68	switch(m_mem_map & 3)
68	69	{
69	70	case 0:
70	71	// BIOS
71		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x0000, 0x3fff, "bank1" );
72		state->membank("bank1")->set_base(state->memregion("maincpu")->base());
	72	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x0000, 0x3fff, "bank1" );
	73	membank("bank1")->set_base(memregion("maincpu")->base());
73	74	break;
74	75
75	76	default:
76		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0x0000, 0x3fff);
	77	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0x0000, 0x3fff);
77	78	break;
78	79	}
79	80
80	81	// page 1 (4000-7fff)
81		switch(state->m_mem_map >> 2 & 3)
	82	switch(m_mem_map >> 2 & 3)
82	83	{
83	84	case 0:
84	85	// BIOS
85		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x4000, 0x5fff, "bank21" );
86		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x6000, 0x7fff, "bank22" );
87		state->membank("bank21")->set_base(machine.root_device().memregion("maincpu")->base() + 0x4000);
88		state->membank("bank22")->set_base(machine.root_device().memregion("maincpu")->base() + 0x4000 + 0x2000);
	86	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x4000, 0x5fff, "bank21" );
	87	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x6000, 0x7fff, "bank22" );
	88	membank("bank21")->set_base(machine().root_device().memregion("maincpu")->base() + 0x4000);
	89	membank("bank22")->set_base(machine().root_device().memregion("maincpu")->base() + 0x4000 + 0x2000);
89	90	break;
90	91
91	92	case 1:
92	93	// game
93		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x4000, 0x5fff, "bank21" );
94		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x6000, 0x7fff, "bank22" );
95		state->membank("bank21")->set_base(machine.root_device().memregion("game")->base() + state->m_mem_banks[0]*0x2000);
96		state->membank("bank22")->set_base(machine.root_device().memregion("game")->base() + state->m_mem_banks[1]*0x2000);
	94	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x4000, 0x5fff, "bank21" );
	95	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x6000, 0x7fff, "bank22" );
	96	membank("bank21")->set_base(machine().root_device().memregion("game")->base() + m_mem_banks[0]*0x2000);
	97	membank("bank22")->set_base(machine().root_device().memregion("game")->base() + m_mem_banks[1]*0x2000);
97	98	break;
98	99
99	100	default:
100		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0x4000, 0x7fff);
	101	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0x4000, 0x7fff);
101	102	break;
102	103	}
103	104
104	105	// page 2 (8000-bfff)
105		switch(state->m_mem_map >> 4 & 3)
	106	switch(m_mem_map >> 4 & 3)
106	107	{
107	108	case 1:
108	109	// game
109		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x8000, 0x9fff, "bank31" );
110		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0xa000, 0xbfff, "bank32" );
111		state->membank("bank31")->set_base(machine.root_device().memregion("game")->base() + state->m_mem_banks[2]*0x2000);
112		state->membank("bank32")->set_base(machine.root_device().memregion("game")->base() + state->m_mem_banks[3]*0x2000);
	110	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x8000, 0x9fff, "bank31" );
	111	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0xa000, 0xbfff, "bank32" );
	112	membank("bank31")->set_base(machine().root_device().memregion("game")->base() + m_mem_banks[2]*0x2000);
	113	membank("bank32")->set_base(machine().root_device().memregion("game")->base() + m_mem_banks[3]*0x2000);
113	114	break;
114	115
115	116	default:
116		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0x8000, 0xbfff);
	117	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0x8000, 0xbfff);
117	118	break;
118	119	}
119	120
120	121	// page 3 (c000-ffff)
121		switch(state->m_mem_map >> 6 & 3)
	122	switch(m_mem_map >> 6 & 3)
122	123	{
123	124	case 3:
124	125	// RAM
125		machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0xc000, 0xffff, "bank4" );
126		state->membank("bank4")->set_base(state->m_main_mem);
	126	machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0xc000, 0xffff, "bank4" );
	127	membank("bank4")->set_base(m_main_mem);
127	128	break;
128	129
129	130	default:
130		machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0xc000, 0xffff);
	131	machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_read(0xc000, 0xffff);
131	132	break;
132	133	}
133	134	}
r21026	r21027
144	145	{
145	146	// ROM bankswitch
146	147	m_mem_banks[(offset - 0x4000) >> 13] = data & 0xf;
147		mem_map_banks(machine());
	148	mem_map_banks();
148	149	}
149	150	}
150	151
r21026	r21027
210	211	if (data != m_mem_map)
211	212	{
212	213	m_mem_map = data;
213		mem_map_banks(machine());
	214	mem_map_banks();
214	215	}
215	216	}
216	217
r21026	r21027
247	248
248	249	void pengadvb_state::pengadvb_postload()
249	250	{
250		mem_map_banks(machine());
	251	mem_map_banks();
251	252	}
252	253
253	254	void pengadvb_state::machine_start()
r21026	r21027
262	263	{
263	264	m_mem_map = 0;
264	265	m_mem_banks[0] = m_mem_banks[1] = m_mem_banks[2] = m_mem_banks[3] = 0;
265		mem_map_banks(machine());
	266	mem_map_banks();
266	267	}
267	268
268	269
r21026	r21027
287	288	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
288	289	MACHINE_CONFIG_END
289	290
290		static void pengadvb_decrypt(running_machine &machine, const char* region)
	291	void pengadvb_state::pengadvb_decrypt(const char* region)
291	292	{
292		UINT8 *mem = machine.root_device().memregion(region)->base();
293		int memsize = machine.root_device().memregion(region)->bytes();
	293	UINT8 *mem = machine().root_device().memregion(region)->base();
	294	int memsize = machine().root_device().memregion(region)->bytes();
294	295	UINT8 *buf;
295	296	int i;
296	297
r21026	r21027
301	302	}
302	303
303	304	// address line swap
304		buf = auto_alloc_array(machine, UINT8, memsize);
	305	buf = auto_alloc_array(machine(), UINT8, memsize);
305	306	memcpy(buf, mem, memsize);
306	307	for ( i = 0; i < memsize; i++ )
307	308	{
308	309	mem[i] = buf[BITSWAP24(i,23,22,21,20,19,18,17,16,15,14,13,5,11,10,9,8,7,6,12,4,3,2,1,0)];
309	310	}
310		auto_free(machine, buf);
	311	auto_free(machine(), buf);
311	312	}
312	313
313	314	DRIVER_INIT_MEMBER(pengadvb_state,pengadvb)
314	315	{
315		pengadvb_decrypt(machine(), "maincpu");
316		pengadvb_decrypt(machine(), "game");
	316	pengadvb_decrypt("maincpu");
	317	pengadvb_decrypt("game");
317	318
318	319	m_main_mem = auto_alloc_array(machine(), UINT8, 0x4000);
319	320	}

trunk/src/mame/drivers/konamigq.c

r21026	r21027
84	84	DECLARE_DRIVER_INIT(konamigq);
85	85	DECLARE_MACHINE_START(konamigq);
86	86	DECLARE_MACHINE_RESET(konamigq);
	87	void scsi_dma_read( UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size );
	88	void scsi_dma_write( UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size );
87	89	};
88	90
89	91	/* Sound */
r21026	r21027
250	252
251	253	/* SCSI */
252	254
253		static void scsi_dma_read( konamigq_state *state, UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size )
	255	void konamigq_state::scsi_dma_read( UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size )
254	256	{
255		UINT8 *sector_buffer = state->m_sector_buffer;
	257	UINT8 *sector_buffer = m_sector_buffer;
256	258	int i;
257	259	int n_this;
258	260
259	261	while( n_size > 0 )
260	262	{
261		if( n_size > sizeof( state->m_sector_buffer ) / 4 )
	263	if( n_size > sizeof( m_sector_buffer ) / 4 )
262	264	{
263		n_this = sizeof( state->m_sector_buffer ) / 4;
	265	n_this = sizeof( m_sector_buffer ) / 4;
264	266	}
265	267	else
266	268	{
267	269	n_this = n_size;
268	270	}
269		state->m_am53cf96->dma_read_data( n_this * 4, sector_buffer );
	271	m_am53cf96->dma_read_data( n_this * 4, sector_buffer );
270	272	n_size -= n_this;
271	273
272	274	i = 0;
r21026	r21027
284	286	}
285	287	}
286	288
287		static void scsi_dma_write( konamigq_state *state, UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size )
	289	void konamigq_state::scsi_dma_write( UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size )
288	290	{
289	291	}
290	292
r21026	r21027
310	312	MCFG_CPU_ADD( "maincpu", CXD8530BQ, XTAL_67_7376MHz )
311	313	MCFG_CPU_PROGRAM_MAP( konamigq_map )
312	314
313		MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate( FUNC( scsi_dma_read ), (konamigq_state *) owner ) )
314		MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 5, psx_dma_write_delegate( FUNC( scsi_dma_write ), (konamigq_state *) owner ) )
	315	MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate( FUNC( konamigq_state::scsi_dma_read ), (konamigq_state *) owner ) )
	316	MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 5, psx_dma_write_delegate( FUNC( konamigq_state::scsi_dma_write ), (konamigq_state *) owner ) )
315	317
316	318	MCFG_CPU_ADD( "soundcpu", M68000, 8000000 )
317	319	MCFG_CPU_PROGRAM_MAP( konamigq_sound_map)

trunk/src/mame/drivers/bfm_sc2.c

r21026	r21027
304	304	DECLARE_MACHINE_START(sc2dmd);
305	305	DECLARE_MACHINE_RESET(dm01_init);
306	306	INTERRUPT_GEN_MEMBER(timer_irq);
	307	void on_scorpion2_reset();
	308	void Scorpion2_SetSwitchState(int strobe, int data, int state);
	309	int Scorpion2_GetSwitchState(int strobe, int data);
	310	void e2ram_reset();
	311	int recAck(int changed, int data);
	312	int read_e2ram();
	313	int sc2_find_project_string( );
	314	void sc2_common_init(int decrypt);
	315	void adder2_common_init();
	316	void sc2awp_common_init(int reels, int decrypt);
	317	void sc2awpdmd_common_init(int reels, int decrypt);
307	318	};
308	319
309	320
r21026	r21027
320	331
321	332	#define MASTER_CLOCK        (XTAL_8MHz)
322	333
323		// local prototypes ///////////////////////////////////////////////////////
324
325		static int  read_e2ram(running_machine &machine);
326		static void e2ram_reset(running_machine &machine);
327
328	334	/*      INPUTS layout
329	335
330	336	b7 b6 b5 b4 b3 b2 b1 b0
r21026	r21027
347	353	// called if board is reset ///////////////////////////////////////////////
348	354	///////////////////////////////////////////////////////////////////////////
349	355
350		static void on_scorpion2_reset(running_machine &machine)
	356	void bfm_sc2_state::on_scorpion2_reset()
351	357	{
352		bfm_sc2_state *state = machine.driver_data<bfm_sc2_state>();
353		state->m_mmtr_latch        = 0;
354		state->m_triac_latch       = 0;
355		state->m_irq_status        = 0;
356		state->m_is_timer_enabled  = 1;
357		state->m_coin_inhibits     = 0;
358		state->m_irq_timer_stat    = 0;
359		state->m_expansion_latch   = 0;
360		state->m_global_volume     = 0;
361		state->m_volume_override   = 0;
362		state->m_triac_select      = 0;
363		state->m_pay_latch         = 0;
	358	m_mmtr_latch        = 0;
	359	m_triac_latch       = 0;
	360	m_irq_status        = 0;
	361	m_is_timer_enabled  = 1;
	362	m_coin_inhibits     = 0;
	363	m_irq_timer_stat    = 0;
	364	m_expansion_latch   = 0;
	365	m_global_volume     = 0;
	366	m_volume_override   = 0;
	367	m_triac_select      = 0;
	368	m_pay_latch         = 0;
364	369
365		state->m_reel12_latch      = 0;
366		state->m_reel34_latch      = 0;
367		state->m_reel56_latch      = 0;
	370	m_reel12_latch      = 0;
	371	m_reel34_latch      = 0;
	372	m_reel56_latch      = 0;
368	373
369		state->m_hopper_running    = 0;  // for video games
370		state->m_hopper_coin_sense = 0;
	374	m_hopper_running    = 0;  // for video games
	375	m_hopper_coin_sense = 0;
371	376
372		state->m_slide_states[0] = 0;
373		state->m_slide_states[1] = 0;
374		state->m_slide_states[2] = 0;
375		state->m_slide_states[3] = 0;
376		state->m_slide_states[4] = 0;
377		state->m_slide_states[5] = 0;
	377	m_slide_states[0] = 0;
	378	m_slide_states[1] = 0;
	379	m_slide_states[2] = 0;
	380	m_slide_states[3] = 0;
	381	m_slide_states[4] = 0;
	382	m_slide_states[5] = 0;
378	383
379		e2ram_reset(machine);
	384	e2ram_reset();
380	385
381		machine.device("ymsnd")->reset();
	386	machine().device("ymsnd")->reset();
382	387
383	388	// reset stepper motors /////////////////////////////////////////////////
384	389	{
385	390	int pattern =0, i;
386	391
387		for ( i = 0; i < state->m_reels; i++)
	392	for ( i = 0; i < m_reels; i++)
388	393	{
389	394	stepper_reset_position(i);
390	395	if ( stepper_optic_state(i) ) pattern |= 1<<i;
391	396	}
392	397
393		state->m_optic_pattern = pattern;
	398	m_optic_pattern = pattern;
394	399
395	400	}
396	401
397		state->m_locked        = 0;
	402	m_locked        = 0;
398	403
399	404	// make sure no inputs are overidden ////////////////////////////////////
400		memset(state->m_input_override, 0, sizeof(state->m_input_override));
	405	memset(m_input_override, 0, sizeof(m_input_override));
401	406
402	407	// init rom bank ////////////////////////////////////////////////////////
403	408
404	409	{
405		UINT8 *rom = machine.root_device().memregion("maincpu")->base();
	410	UINT8 *rom = machine().root_device().memregion("maincpu")->base();
406	411
407		state->membank("bank1")->configure_entries(0, 4, &rom[0x00000], 0x02000);
	412	membank("bank1")->configure_entries(0, 4, &rom[0x00000], 0x02000);
408	413
409		state->membank("bank1")->set_entry(3);
	414	membank("bank1")->set_entry(3);
410	415	}
411	416	}
412	417
413	418	///////////////////////////////////////////////////////////////////////////
414	419
415		void Scorpion2_SetSwitchState(running_machine &machine, int strobe, int data, int state)
	420	void bfm_sc2_state::Scorpion2_SetSwitchState(int strobe, int data, int state)
416	421	{
417		bfm_sc2_state *drvstate = machine.driver_data<bfm_sc2_state>();
418	422	if ( strobe < 11 && data < 8 )
419	423	{
420	424	if ( strobe < 8 )
421	425	{
422		drvstate->m_input_override[strobe] |= (1<<data);
	426	m_input_override[strobe] |= (1<<data);
423	427
424		if ( state ) drvstate->m_sc2_Inputs[strobe] |=  (1<<data);
425		else         drvstate->m_sc2_Inputs[strobe] &= ~(1<<data);
	428	if ( state ) m_sc2_Inputs[strobe] |=  (1<<data);
	429	else         m_sc2_Inputs[strobe] &= ~(1<<data);
426	430	}
427	431	else
428	432	{
429	433	if ( data > 2 )
430	434	{
431		drvstate->m_input_override[strobe-8+4] |= (1<<(data+2));
	435	m_input_override[strobe-8+4] |= (1<<(data+2));
432	436
433		if ( state ) drvstate->m_sc2_Inputs[strobe-8+4] |=  (1<<(data+2));
434		else         drvstate->m_sc2_Inputs[strobe-8+4] &= ~(1<<(data+2));
	437	if ( state ) m_sc2_Inputs[strobe-8+4] |=  (1<<(data+2));
	438	else         m_sc2_Inputs[strobe-8+4] &= ~(1<<(data+2));
435	439	}
436	440	else
437	441	{
438		drvstate->m_input_override[strobe-8] |= (1<<(data+5));
	442	m_input_override[strobe-8] |= (1<<(data+5));
439	443
440		if ( state ) drvstate->m_sc2_Inputs[strobe-8] |=  (1 << (data+5));
441		else         drvstate->m_sc2_Inputs[strobe-8] &= ~(1 << (data+5));
	444	if ( state ) m_sc2_Inputs[strobe-8] |=  (1 << (data+5));
	445	else         m_sc2_Inputs[strobe-8] &= ~(1 << (data+5));
442	446	}
443	447	}
444	448	}
r21026	r21027
446	450
447	451	///////////////////////////////////////////////////////////////////////////
448	452
449		int Scorpion2_GetSwitchState(running_machine &machine, int strobe, int data)
	453	int bfm_sc2_state::Scorpion2_GetSwitchState(int strobe, int data)
450	454	{
451		bfm_sc2_state *drvstate = machine.driver_data<bfm_sc2_state>();
452	455	int state = 0;
453	456
454	457	if ( strobe < 11 && data < 8 )
455	458	{
456	459	if ( strobe < 8 )
457	460	{
458		state = (drvstate->m_sc2_Inputs[strobe] & (1<<data) ) ? 1 : 0;
	461	state = (m_sc2_Inputs[strobe] & (1<<data) ) ? 1 : 0;
459	462	}
460	463	else
461	464	{
462	465	if ( data > 2 )
463	466	{
464		state = (drvstate->m_sc2_Inputs[strobe-8+4] & (1<<(data+2)) ) ? 1 : 0;
	467	state = (m_sc2_Inputs[strobe-8+4] & (1<<(data+2)) ) ? 1 : 0;
465	468	}
466	469	else
467	470	{
468		state = (drvstate->m_sc2_Inputs[strobe-8] & (1 << (data+5)) ) ? 1 : 0;
	471	state = (m_sc2_Inputs[strobe-8] & (1 << (data+5)) ) ? 1 : 0;
469	472	}
470	473	}
471	474	}
r21026	r21027
915	918	{
916	919	int strobe = m_slide_pay_sensor[slide]>>4, data = m_slide_pay_sensor[slide]&0x0F;
917	920
918		Scorpion2_SetSwitchState(machine(), strobe, data, 0);
	921	Scorpion2_SetSwitchState(strobe, data, 0);
919	922	}
920	923	m_slide_states[slide] = 1;
921	924	}
r21026	r21027
928	931	{
929	932	int strobe = m_slide_pay_sensor[slide]>>4, data = m_slide_pay_sensor[slide]&0x0F;
930	933
931		Scorpion2_SetSwitchState(machine(), strobe, data, 1);
	934	Scorpion2_SetSwitchState(strobe, data, 1);
932	935	}
933	936	m_slide_states[slide] = 0;
934	937	}
r21026	r21027
1063	1066
1064	1067	if ( offset == 7 )
1065	1068	{
1066		result = (result & 0xFE) | read_e2ram(machine());
	1069	result = (result & 0xFE) | read_e2ram();
1067	1070	}
1068	1071
1069	1072	return result;
r21026	r21027
1086	1089	#define SDA 0x02    //SDA pin (data)
1087	1090
1088	1091
1089		static void e2ram_reset(running_machine &machine)
	1092	void bfm_sc2_state::e2ram_reset()
1090	1093	{
1091		bfm_sc2_state *state = machine.driver_data<bfm_sc2_state>();
1092		state->m_e2reg   = 0;
1093		state->m_e2state = 0;
1094		state->m_e2address = 0;
1095		state->m_e2rw    = 0;
1096		state->m_e2data_pin = 0;
1097		state->m_e2data  = (SDA|SCL);
1098		state->m_e2dummywrite = 0;
1099		state->m_e2data_to_read = 0;
	1094	m_e2reg   = 0;
	1095	m_e2state = 0;
	1096	m_e2address = 0;
	1097	m_e2rw    = 0;
	1098	m_e2data_pin = 0;
	1099	m_e2data  = (SDA|SCL);
	1100	m_e2dummywrite = 0;
	1101	m_e2data_to_read = 0;
1100	1102	}
1101	1103
1102	1104	int bfm_sc2_state::recdata(int changed, int data)
r21026	r21027
1131	1133	return res;
1132	1134	}
1133	1135
1134		static int recAck(int changed, int data)
	1136	int bfm_sc2_state::recAck(int changed, int data)
1135	1137	{
1136	1138	int result = 0;
1137	1139
r21026	r21027
1393	1395	}
1394	1396	}
1395	1397
1396		static int read_e2ram(running_machine &machine)
	1398	int bfm_sc2_state::read_e2ram()
1397	1399	{
1398		bfm_sc2_state *state = machine.driver_data<bfm_sc2_state>();
1399		LOG(("e2ram: r %d (%02X) \n", state->m_e2data_pin, state->m_e2data_to_read ));
	1400	LOG(("e2ram: r %d (%02X) \n", m_e2data_pin, m_e2data_to_read ));
1400	1401
1401		return state->m_e2data_pin;
	1402	return m_e2data_pin;
1402	1403	}
1403	1404
1404	1405
r21026	r21027
1409	1410	{
1410	1411	// reset the board //////////////////////////////////////////////////////
1411	1412
1412		on_scorpion2_reset(machine());
	1413	on_scorpion2_reset();
1413	1414	m_vfd0->reset();
1414	1415	m_vfd1->reset();
1415	1416
r21026	r21027
2187	2188
2188	2189
2189	2190
2190		int sc2_find_project_string(running_machine &machine )
	2191	int bfm_sc2_state::sc2_find_project_string( )
2191	2192	{
2192	2193	// search for the project string to find the title (usually just at ff00)
2193	2194	char title_string[4][32] = { "PROJECT NUMBER", "PROJECT PR", "PROJECT ", "CASH ON THE NILE 2" };
2194		UINT8 *src = machine.root_device().memregion( "maincpu" )->base();
2195		int size = machine.root_device().memregion( "maincpu" )->bytes();
	2195	UINT8 *src = machine().root_device().memregion( "maincpu" )->base();
	2196	int size = machine().root_device().memregion( "maincpu" )->bytes();
2196	2197
2197	2198	for (int search=0;search<4;search++)
2198	2199	{
r21026	r21027
2262	2263	}
2263	2264
2264	2265
2265		static void sc2_common_init(running_machine &machine, int decrypt)
	2266	void bfm_sc2_state::sc2_common_init(int decrypt)
2266	2267	{
2267		bfm_sc2_state *state = machine.driver_data<bfm_sc2_state>();
2268	2268
2269		if (decrypt) bfm_decode_mainrom(machine, "maincpu", state->m_codec_data);         // decode main rom
	2269	if (decrypt) bfm_decode_mainrom(machine(), "maincpu", m_codec_data);         // decode main rom
2270	2270
2271		memset(state->m_sc2_Inputs, 0, sizeof(state->m_sc2_Inputs));  // clear all inputs
	2271	memset(m_sc2_Inputs, 0, sizeof(m_sc2_Inputs));  // clear all inputs
2272	2272	}
2273	2273
2274		static void adder2_common_init(running_machine &machine)
	2274	void bfm_sc2_state::adder2_common_init()
2275	2275	{
2276		bfm_sc2_state *state = machine.driver_data<bfm_sc2_state>();
2277	2276	UINT8 *pal;
2278	2277
2279		pal = state->memregion("proms")->base();
	2278	pal = memregion("proms")->base();
2280	2279	if ( pal )
2281	2280	{
2282		memcpy(state->m_key, pal, 8);
	2281	memcpy(m_key, pal, 8);
2283	2282	}
2284	2283	}
2285	2284
r21026	r21027
2287	2286
2288	2287	DRIVER_INIT_MEMBER(bfm_sc2_state,quintoon)
2289	2288	{
2290		sc2_common_init(machine(), 1);
	2289	sc2_common_init( 1);
2291	2290	adder2_decode_char_roms(machine());
2292	2291	MechMtr_config(machine(),8);                    // setup mech meters
2293	2292
2294	2293	m_has_hopper = 0;
2295	2294
2296		Scorpion2_SetSwitchState(machine(),3,0,1);  // tube1 level switch
2297		Scorpion2_SetSwitchState(machine(),3,1,1);  // tube2 level switch
2298		Scorpion2_SetSwitchState(machine(),3,2,1);  // tube3 level switch
	2295	Scorpion2_SetSwitchState(3,0,1);  // tube1 level switch
	2296	Scorpion2_SetSwitchState(3,1,1);  // tube2 level switch
	2297	Scorpion2_SetSwitchState(3,2,1);  // tube3 level switch
2299	2298
2300		Scorpion2_SetSwitchState(machine(),5,2,1);
2301		Scorpion2_SetSwitchState(machine(),6,4,1);
	2299	Scorpion2_SetSwitchState(5,2,1);
	2300	Scorpion2_SetSwitchState(6,4,1);
2302	2301
2303	2302	m_sc2_show_door   = 1;
2304	2303	m_sc2_door_state  = 0x41;
r21026	r21027
2308	2307
2309	2308	DRIVER_INIT_MEMBER(bfm_sc2_state,pyramid)
2310	2309	{
2311		sc2_common_init(machine(), 1);
	2310	sc2_common_init(1);
2312	2311	adder2_decode_char_roms(machine());         // decode GFX roms
2313		adder2_common_init(machine());
	2312	adder2_common_init();
2314	2313
2315	2314	m_has_hopper = 1;
2316	2315
2317		Scorpion2_SetSwitchState(machine(),3,0,1);  // tube1 level switch
2318		Scorpion2_SetSwitchState(machine(),3,1,1);  // tube2 level switch
2319		Scorpion2_SetSwitchState(machine(),3,2,1);  // tube3 level switch
	2316	Scorpion2_SetSwitchState(3,0,1);  // tube1 level switch
	2317	Scorpion2_SetSwitchState(3,1,1);  // tube2 level switch
	2318	Scorpion2_SetSwitchState(3,2,1);  // tube3 level switch
2320	2319
2321	2320	m_sc2_show_door   = 1;
2322	2321	m_sc2_door_state  = 0x41;
r21026	r21027
2325	2324
2326	2325	DRIVER_INIT_MEMBER(bfm_sc2_state,sltsbelg)
2327	2326	{
2328		sc2_common_init(machine(), 1);
	2327	sc2_common_init(1);
2329	2328	adder2_decode_char_roms(machine());         // decode GFX roms
2330		adder2_common_init(machine());
	2329	adder2_common_init();
2331	2330
2332	2331	m_has_hopper = 1;
2333	2332
r21026	r21027
2339	2338
2340	2339	DRIVER_INIT_MEMBER(bfm_sc2_state,adder_dutch)
2341	2340	{
2342		sc2_common_init(machine(), 1);
	2341	sc2_common_init(1);
2343	2342	adder2_decode_char_roms(machine());         // decode GFX roms
2344		adder2_common_init(machine());
	2343	adder2_common_init();
2345	2344
2346	2345	m_has_hopper = 0;
2347	2346
2348		Scorpion2_SetSwitchState(machine(),3,0,1);  // tube1 level switch
2349		Scorpion2_SetSwitchState(machine(),3,1,1);  // tube2 level switch
2350		Scorpion2_SetSwitchState(machine(),3,2,1);  // tube3 level switch
	2347	Scorpion2_SetSwitchState(3,0,1);  // tube1 level switch
	2348	Scorpion2_SetSwitchState(3,1,1);  // tube2 level switch
	2349	Scorpion2_SetSwitchState(3,2,1);  // tube3 level switch
2351	2350
2352	2351	m_sc2_show_door   = 1;
2353	2352	m_sc2_door_state  = 0x41;
r21026	r21027
2357	2356
2358	2357	DRIVER_INIT_MEMBER(bfm_sc2_state,gldncrwn)
2359	2358	{
2360		sc2_common_init(machine(), 1);
	2359	sc2_common_init(1);
2361	2360	adder2_decode_char_roms(machine());         // decode GFX roms
2362		adder2_common_init(machine());
	2361	adder2_common_init();
2363	2362
2364	2363	m_has_hopper = 0;
2365	2364
2366		Scorpion2_SetSwitchState(machine(),3,0,1);  // tube1 level switch
2367		Scorpion2_SetSwitchState(machine(),3,1,1);  // tube2 level switch
2368		Scorpion2_SetSwitchState(machine(),3,2,1);  // tube3 level switch
	2365	Scorpion2_SetSwitchState(3,0,1);  // tube1 level switch
	2366	Scorpion2_SetSwitchState(3,1,1);  // tube2 level switch
	2367	Scorpion2_SetSwitchState(3,2,1);  // tube3 level switch
2369	2368
2370	2369	m_sc2_show_door   = 0;
2371	2370	m_sc2_door_state  = 0x41;
r21026	r21027
2662	2661
2663	2662	static void bfmdm01_busy(running_machine &machine, int state)
2664	2663	{
2665		Scorpion2_SetSwitchState(machine, 4,4, state?0:1);
	2664	bfm_sc2_state *drvstate = machine.driver_data<bfm_sc2_state>();
	2665	drvstate->Scorpion2_SetSwitchState(4,4, state?0:1);
2666	2666	}
2667	2667
2668	2668	static const bfmdm01_interface dm01_interface =
r21026	r21027
2673	2673	/* machine init (called only once) */
2674	2674	MACHINE_RESET_MEMBER(bfm_sc2_state,awp_init)
2675	2675	{
2676		on_scorpion2_reset(machine());
	2676	on_scorpion2_reset();
2677	2677	m_vfd0->reset();
2678	2678	m_vfd1->reset();
2679	2679	}
r21026	r21027
2681	2681
2682	2682	MACHINE_RESET_MEMBER(bfm_sc2_state,dm01_init)
2683	2683	{
2684		on_scorpion2_reset(machine());
	2684	on_scorpion2_reset();
2685	2685	}
2686	2686
2687	2687
r21026	r21027
3831	3831	MCFG_CPU_PERIODIC_INT(bfm_dm01_vbl, 1500 )          /* generate 1500 NMI's per second ?? what is the exact freq?? */
3832	3832	MACHINE_CONFIG_END
3833	3833
3834		static void sc2awp_common_init(running_machine &machine,int reels, int decrypt)
	3834	void bfm_sc2_state::sc2awp_common_init(int reels, int decrypt)
3835	3835	{
3836		bfm_sc2_state *state = machine.driver_data<bfm_sc2_state>();
3837	3836
3838	3837	int n;
3839		sc2_common_init(machine, decrypt);
	3838	sc2_common_init(decrypt);
3840	3839	/* setup n default 96 half step reels */
3841	3840
3842		state->m_reels=reels;
	3841	m_reels=reels;
3843	3842
3844	3843	for ( n = 0; n < reels; n++ )
3845	3844	{
3846		stepper_config(machine, n, &starpoint_interface_48step);
	3845	stepper_config(machine(), n, &starpoint_interface_48step);
3847	3846	}
3848	3847	}
3849	3848
3850		static void sc2awpdmd_common_init(running_machine &machine,int reels, int decrypt)
	3849	void bfm_sc2_state::sc2awpdmd_common_init(int reels, int decrypt)
3851	3850	{
3852		bfm_sc2_state *state = machine.driver_data<bfm_sc2_state>();
3853	3851
3854	3852	int n;
3855		BFM_dm01_config(machine, &dm01_interface);
3856		sc2_common_init(machine, decrypt);
	3853	BFM_dm01_config(machine(), &dm01_interface);
	3854	sc2_common_init(decrypt);
3857	3855	/* setup n default 96 half step reels */
3858	3856
3859		state->m_reels=reels;
	3857	m_reels=reels;
3860	3858
3861	3859	for ( n = 0; n < reels; n++ )
3862	3860	{
3863		stepper_config(machine, n, &starpoint_interface_48step);
	3861	stepper_config(machine(), n, &starpoint_interface_48step);
3864	3862	}
3865	3863	}
3866	3864
r21026	r21027
3868	3866
3869	3867	DRIVER_INIT_MEMBER(bfm_sc2_state,bbrkfst)
3870	3868	{
3871		sc2awp_common_init(machine(),5, 1);
	3869	sc2awp_common_init(5, 1);
3872	3870	MechMtr_config(machine(),8);
3873	3871
3874	3872	m_has_hopper = 0;
3875	3873
3876		Scorpion2_SetSwitchState(machine(),4,0, 1);   /* GBP1 Low Level Switch */
3877		Scorpion2_SetSwitchState(machine(),4,1, 1);   /* 20p Low Level Switch */
3878		Scorpion2_SetSwitchState(machine(),4,2, 1);   /* Token Front Low Level Switch */
3879		Scorpion2_SetSwitchState(machine(),4,3, 1);   /* Token Rear  Low Level Switch */
3880		Scorpion2_SetSwitchState(machine(),4,4, 1);
3881		Scorpion2_SetSwitchState(machine(),6,0, 0);
3882		Scorpion2_SetSwitchState(machine(),6,1, 1);
3883		Scorpion2_SetSwitchState(machine(),6,2, 0);
3884		Scorpion2_SetSwitchState(machine(),6,3, 1);
	3874	Scorpion2_SetSwitchState(4,0, 1);   /* GBP1 Low Level Switch */
	3875	Scorpion2_SetSwitchState(4,1, 1);   /* 20p Low Level Switch */
	3876	Scorpion2_SetSwitchState(4,2, 1);   /* Token Front Low Level Switch */
	3877	Scorpion2_SetSwitchState(4,3, 1);   /* Token Rear  Low Level Switch */
	3878	Scorpion2_SetSwitchState(4,4, 1);
	3879	Scorpion2_SetSwitchState(6,0, 0);
	3880	Scorpion2_SetSwitchState(6,1, 1);
	3881	Scorpion2_SetSwitchState(6,2, 0);
	3882	Scorpion2_SetSwitchState(6,3, 1);
3885	3883
3886		sc2_find_project_string(machine());
	3884	sc2_find_project_string();
3887	3885	}
3888	3886
3889	3887	DRIVER_INIT_MEMBER(bfm_sc2_state,drwho_common)
r21026	r21027
3892	3890
3893	3891	m_has_hopper = 0;
3894	3892
3895		Scorpion2_SetSwitchState(machine(),4,0, 0);   /* GBP1 Low Level Switch */
3896		Scorpion2_SetSwitchState(machine(),4,1, 0);   /* 20p Low Level Switch */
3897		Scorpion2_SetSwitchState(machine(),4,2, 0);   /* Token Front Low Level Switch */
3898		Scorpion2_SetSwitchState(machine(),4,3, 0);   /* Token Rear  Low Level Switch */
3899		Scorpion2_SetSwitchState(machine(),7,0, 0);   /* GBP1 High Level Switch */
3900		Scorpion2_SetSwitchState(machine(),7,1, 0);   /* 20P High Level Switch */
3901		Scorpion2_SetSwitchState(machine(),7,2, 0);   /* Token Front High Level Switch */
3902		Scorpion2_SetSwitchState(machine(),7,3, 0);   /* Token Rear High Level Switch */
	3893	Scorpion2_SetSwitchState(4,0, 0);   /* GBP1 Low Level Switch */
	3894	Scorpion2_SetSwitchState(4,1, 0);   /* 20p Low Level Switch */
	3895	Scorpion2_SetSwitchState(4,2, 0);   /* Token Front Low Level Switch */
	3896	Scorpion2_SetSwitchState(4,3, 0);   /* Token Rear  Low Level Switch */
	3897	Scorpion2_SetSwitchState(7,0, 0);   /* GBP1 High Level Switch */
	3898	Scorpion2_SetSwitchState(7,1, 0);   /* 20P High Level Switch */
	3899	Scorpion2_SetSwitchState(7,2, 0);   /* Token Front High Level Switch */
	3900	Scorpion2_SetSwitchState(7,3, 0);   /* Token Rear High Level Switch */
3903	3901
3904		sc2_find_project_string(machine());
	3902	sc2_find_project_string();
3905	3903	}
3906	3904
3907	3905	DRIVER_INIT_MEMBER(bfm_sc2_state,drwho)
3908	3906	{
3909		sc2awp_common_init(machine(),6, 1);
	3907	sc2awp_common_init(6, 1);
3910	3908	DRIVER_INIT_CALL(drwho_common);
3911	3909	}
3912	3910
3913	3911	DRIVER_INIT_MEMBER(bfm_sc2_state,drwhon)
3914	3912	{
3915		sc2awp_common_init(machine(),4, 0);
	3913	sc2awp_common_init(4, 0);
3916	3914	DRIVER_INIT_CALL(drwho_common);
3917	3915	}
3918	3916
3919	3917
3920	3918	DRIVER_INIT_MEMBER(bfm_sc2_state,focus)
3921	3919	{
3922		sc2awp_common_init(machine(),6, 1);
	3920	sc2awp_common_init(6, 1);
3923	3921	MechMtr_config(machine(),5);
3924		sc2_find_project_string(machine());
	3922	sc2_find_project_string();
3925	3923	}
3926	3924
3927	3925	DRIVER_INIT_MEMBER(bfm_sc2_state,cpeno1)
3928	3926	{
3929		sc2awpdmd_common_init(machine(),6, 1);
	3927	sc2awpdmd_common_init(6, 1);
3930	3928
3931	3929	MechMtr_config(machine(),5);
3932	3930
3933		Scorpion2_SetSwitchState(machine(),3,3,1);  /*  5p play */
3934		Scorpion2_SetSwitchState(machine(),3,4,1);  /* 20p play */
	3931	Scorpion2_SetSwitchState(3,3,1);  /*  5p play */
	3932	Scorpion2_SetSwitchState(3,4,1);  /* 20p play */
3935	3933
3936		Scorpion2_SetSwitchState(machine(),4,0,1);  /* pay tube low (1 pound front) */
3937		Scorpion2_SetSwitchState(machine(),4,1,1);  /* pay tube low (20p) */
3938		Scorpion2_SetSwitchState(machine(),4,2,1);  /* pay tube low (?1 right) */
3939		Scorpion2_SetSwitchState(machine(),4,3,1);  /* pay tube low (?1 left) */
	3934	Scorpion2_SetSwitchState(4,0,1);  /* pay tube low (1 pound front) */
	3935	Scorpion2_SetSwitchState(4,1,1);  /* pay tube low (20p) */
	3936	Scorpion2_SetSwitchState(4,2,1);  /* pay tube low (?1 right) */
	3937	Scorpion2_SetSwitchState(4,3,1);  /* pay tube low (?1 left) */
3940	3938
3941		Scorpion2_SetSwitchState(machine(),5,0,1);  /* pay sensor (GBP1 front) */
3942		Scorpion2_SetSwitchState(machine(),5,1,1);  /* pay sensor (20 p) */
3943		Scorpion2_SetSwitchState(machine(),5,2,1);  /* pay sensor (1 right) */
3944		Scorpion2_SetSwitchState(machine(),5,3,1);  /* pay sensor (?1 left) */
3945		Scorpion2_SetSwitchState(machine(),5,4,1);  /* payout unit present */
	3939	Scorpion2_SetSwitchState(5,0,1);  /* pay sensor (GBP1 front) */
	3940	Scorpion2_SetSwitchState(5,1,1);  /* pay sensor (20 p) */
	3941	Scorpion2_SetSwitchState(5,2,1);  /* pay sensor (1 right) */
	3942	Scorpion2_SetSwitchState(5,3,1);  /* pay sensor (?1 left) */
	3943	Scorpion2_SetSwitchState(5,4,1);  /* payout unit present */
3946	3944
3947	3945	m_slide_pay_sensor[0] = 0x50;
3948	3946	m_slide_pay_sensor[1] = 0x51;
r21026	r21027
3951	3949	m_slide_pay_sensor[4] = 0;
3952	3950	m_slide_pay_sensor[5] = 0;
3953	3951
3954		Scorpion2_SetSwitchState(machine(),6,0,1);  /* ? percentage key */
3955		Scorpion2_SetSwitchState(machine(),6,1,1);
3956		Scorpion2_SetSwitchState(machine(),6,2,1);
3957		Scorpion2_SetSwitchState(machine(),6,3,1);
3958		Scorpion2_SetSwitchState(machine(),6,4,1);
	3952	Scorpion2_SetSwitchState(6,0,1);  /* ? percentage key */
	3953	Scorpion2_SetSwitchState(6,1,1);
	3954	Scorpion2_SetSwitchState(6,2,1);
	3955	Scorpion2_SetSwitchState(6,3,1);
	3956	Scorpion2_SetSwitchState(6,4,1);
3959	3957
3960		Scorpion2_SetSwitchState(machine(),7,0,0);  /* GBP1 High Level Switch  */
3961		Scorpion2_SetSwitchState(machine(),7,1,0);  /* 20P High Level Switch */
3962		Scorpion2_SetSwitchState(machine(),7,2,0);  /* Token Front High Level Switch */
3963		Scorpion2_SetSwitchState(machine(),7,3,0);  /* Token Rear High Level Switch */
	3958	Scorpion2_SetSwitchState(7,0,0);  /* GBP1 High Level Switch  */
	3959	Scorpion2_SetSwitchState(7,1,0);  /* 20P High Level Switch */
	3960	Scorpion2_SetSwitchState(7,2,0);  /* Token Front High Level Switch */
	3961	Scorpion2_SetSwitchState(7,3,0);  /* Token Rear High Level Switch */
3964	3962
3965	3963	m_sc2_show_door   = 1;
3966	3964	m_sc2_door_state  = 0x31;
3967	3965
3968	3966	m_has_hopper = 0;
3969		sc2_find_project_string(machine());
	3967	sc2_find_project_string();
3970	3968	}
3971	3969
3972	3970	DRIVER_INIT_MEMBER(bfm_sc2_state,ofah)
3973	3971	{
3974		sc2awpdmd_common_init(machine(),4, 1);
	3972	sc2awpdmd_common_init(4, 1);
3975	3973
3976		Scorpion2_SetSwitchState(machine(),4,0,1);  /* pay tube low (1 pound front) */
3977		Scorpion2_SetSwitchState(machine(),4,1,1);  /* pay tube low (20p) */
3978		Scorpion2_SetSwitchState(machine(),4,2,1);  /* pay tube low (?1 right) */
3979		Scorpion2_SetSwitchState(machine(),4,3,1);  /* pay tube low (?1 left) */
	3974	Scorpion2_SetSwitchState(4,0,1);  /* pay tube low (1 pound front) */
	3975	Scorpion2_SetSwitchState(4,1,1);  /* pay tube low (20p) */
	3976	Scorpion2_SetSwitchState(4,2,1);  /* pay tube low (?1 right) */
	3977	Scorpion2_SetSwitchState(4,3,1);  /* pay tube low (?1 left) */
3980	3978
3981		Scorpion2_SetSwitchState(machine(),6,0,0);  /* ? percentage key */
3982		Scorpion2_SetSwitchState(machine(),6,1,1);
3983		Scorpion2_SetSwitchState(machine(),6,2,0);
3984		Scorpion2_SetSwitchState(machine(),6,3,1);
	3979	Scorpion2_SetSwitchState(6,0,0);  /* ? percentage key */
	3980	Scorpion2_SetSwitchState(6,1,1);
	3981	Scorpion2_SetSwitchState(6,2,0);
	3982	Scorpion2_SetSwitchState(6,3,1);
3985	3983
3986	3984	MechMtr_config(machine(),3);
3987		sc2_find_project_string(machine());
	3985	sc2_find_project_string();
3988	3986	}
3989	3987
3990	3988	DRIVER_INIT_MEMBER(bfm_sc2_state,prom)
3991	3989	{
3992		sc2awpdmd_common_init(machine(),6, 1);
	3990	sc2awpdmd_common_init(6, 1);
3993	3991
3994		Scorpion2_SetSwitchState(machine(),4,0,1);  /* pay tube low (1 pound front) */
3995		Scorpion2_SetSwitchState(machine(),4,1,1);  /* pay tube low (20p) */
3996		Scorpion2_SetSwitchState(machine(),4,2,1);  /* pay tube low (?1 right) */
3997		Scorpion2_SetSwitchState(machine(),4,3,1);  /* pay tube low (?1 left) */
	3992	Scorpion2_SetSwitchState(4,0,1);  /* pay tube low (1 pound front) */
	3993	Scorpion2_SetSwitchState(4,1,1);  /* pay tube low (20p) */
	3994	Scorpion2_SetSwitchState(4,2,1);  /* pay tube low (?1 right) */
	3995	Scorpion2_SetSwitchState(4,3,1);  /* pay tube low (?1 left) */
3998	3996
3999		Scorpion2_SetSwitchState(machine(),6,0,0);  /* ? percentage key */
4000		Scorpion2_SetSwitchState(machine(),6,1,1);
4001		Scorpion2_SetSwitchState(machine(),6,2,0);
4002		Scorpion2_SetSwitchState(machine(),6,3,1);
	3997	Scorpion2_SetSwitchState(6,0,0);  /* ? percentage key */
	3998	Scorpion2_SetSwitchState(6,1,1);
	3999	Scorpion2_SetSwitchState(6,2,0);
	4000	Scorpion2_SetSwitchState(6,3,1);
4003	4001
4004	4002	MechMtr_config(machine(),3);
4005		sc2_find_project_string(machine());
	4003	sc2_find_project_string();
4006	4004	}
4007	4005
4008	4006	DRIVER_INIT_MEMBER(bfm_sc2_state,bfmcgslm)
4009	4007	{
4010		sc2awp_common_init(machine(),6, 1);
	4008	sc2awp_common_init(6, 1);
4011	4009	MechMtr_config(machine(),8);
4012	4010	m_has_hopper = 0;
4013		sc2_find_project_string(machine());
	4011	sc2_find_project_string();
4014	4012	}
4015	4013
4016	4014	DRIVER_INIT_MEMBER(bfm_sc2_state,luvjub)
4017	4015	{
4018		sc2awpdmd_common_init(machine(),6, 1);
	4016	sc2awpdmd_common_init(6, 1);
4019	4017
4020	4018	MechMtr_config(machine(),8);
4021	4019	m_has_hopper = 0;
4022	4020
4023		Scorpion2_SetSwitchState(machine(),3,0,1);
4024		Scorpion2_SetSwitchState(machine(),3,1,1);
	4021	Scorpion2_SetSwitchState(3,0,1);
	4022	Scorpion2_SetSwitchState(3,1,1);
4025	4023
4026		Scorpion2_SetSwitchState(machine(),4,0,1);
4027		Scorpion2_SetSwitchState(machine(),4,1,1);
4028		Scorpion2_SetSwitchState(machine(),4,2,1);
4029		Scorpion2_SetSwitchState(machine(),4,3,1);
	4024	Scorpion2_SetSwitchState(4,0,1);
	4025	Scorpion2_SetSwitchState(4,1,1);
	4026	Scorpion2_SetSwitchState(4,2,1);
	4027	Scorpion2_SetSwitchState(4,3,1);
4030	4028
4031		Scorpion2_SetSwitchState(machine(),6,0,1);
4032		Scorpion2_SetSwitchState(machine(),6,1,1);
4033		Scorpion2_SetSwitchState(machine(),6,2,1);
4034		Scorpion2_SetSwitchState(machine(),6,3,0);
	4029	Scorpion2_SetSwitchState(6,0,1);
	4030	Scorpion2_SetSwitchState(6,1,1);
	4031	Scorpion2_SetSwitchState(6,2,1);
	4032	Scorpion2_SetSwitchState(6,3,0);
4035	4033
4036		Scorpion2_SetSwitchState(machine(),7,0,0);
4037		Scorpion2_SetSwitchState(machine(),7,1,0);
4038		Scorpion2_SetSwitchState(machine(),7,2,0);
4039		Scorpion2_SetSwitchState(machine(),7,3,0);
4040		sc2_find_project_string(machine());
	4034	Scorpion2_SetSwitchState(7,0,0);
	4035	Scorpion2_SetSwitchState(7,1,0);
	4036	Scorpion2_SetSwitchState(7,2,0);
	4037	Scorpion2_SetSwitchState(7,3,0);
	4038	sc2_find_project_string();
4041	4039	}
4042	4040
4043	4041

trunk/src/mame/drivers/enigma2.c

r21026	r21027
93	93	UINT32 screen_update_enigma2a(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
94	94	TIMER_CALLBACK_MEMBER(interrupt_clear_callback);
95	95	TIMER_CALLBACK_MEMBER(interrupt_assert_callback);
	96	inline UINT16 vpos_to_vysnc_chain_counter( int vpos );
	97	inline int vysnc_chain_counter_to_vpos( UINT16 counter );
	98	void create_interrupt_timers(  );
	99	void start_interrupt_timers(  );
	100	void get_pens(pen_t *pens);
96	101	};
97	102
98	103
r21026	r21027
103	108	*************************************/
104	109
105	110
106		INLINE UINT16 vpos_to_vysnc_chain_counter( int vpos )
	111	UINT16 enigma2_state::vpos_to_vysnc_chain_counter( int vpos )
107	112	{
108	113	return vpos + VCOUNTER_START;
109	114	}
110	115
111	116
112		INLINE int vysnc_chain_counter_to_vpos( UINT16 counter )
	117	int enigma2_state::vysnc_chain_counter_to_vpos( UINT16 counter )
113	118	{
114	119	return counter - VCOUNTER_START;
115	120	}
r21026	r21027
144	149	}
145	150
146	151
147		static void create_interrupt_timers( running_machine &machine )
	152	void enigma2_state::create_interrupt_timers(  )
148	153	{
149		enigma2_state *state = machine.driver_data<enigma2_state>();
150		state->m_interrupt_clear_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(enigma2_state::interrupt_clear_callback),state));
151		state->m_interrupt_assert_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(enigma2_state::interrupt_assert_callback),state));
	154	m_interrupt_clear_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(enigma2_state::interrupt_clear_callback),this));
	155	m_interrupt_assert_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(enigma2_state::interrupt_assert_callback),this));
152	156	}
153	157
154	158
155		static void start_interrupt_timers( running_machine &machine )
	159	void enigma2_state::start_interrupt_timers(  )
156	160	{
157		enigma2_state *state = machine.driver_data<enigma2_state>();
158	161	int vpos = vysnc_chain_counter_to_vpos(INT_TRIGGER_COUNT_1);
159		state->m_interrupt_assert_timer->adjust(machine.primary_screen->time_until_pos(vpos));
	162	m_interrupt_assert_timer->adjust(machine().primary_screen->time_until_pos(vpos));
160	163	}
161	164
162	165
163	166
164	167	void enigma2_state::machine_start()
165	168	{
166		create_interrupt_timers(machine());
	169	create_interrupt_timers();
167	170
168	171	m_maincpu = machine().device<cpu_device>("maincpu");
169	172	m_audiocpu = machine().device<cpu_device>("audiocpu");
r21026	r21027
185	188	m_sound_latch = 0;
186	189	m_blink_count = 0;
187	190
188		start_interrupt_timers(machine());
	191	start_interrupt_timers();
189	192	}
190	193
191	194
r21026	r21027
195	198	*
196	199	*************************************/
197	200
198		static void get_pens(pen_t *pens)
	201	void enigma2_state::get_pens(pen_t *pens)
199	202	{
200	203	offs_t i;
201	204

trunk/src/mame/drivers/mpu3.c

r21026	r21027
188	188	TIMER_CALLBACK_MEMBER(ic21_timeout);
189	189	TIMER_DEVICE_CALLBACK_MEMBER(gen_50hz);
190	190	TIMER_DEVICE_CALLBACK_MEMBER(ic10_callback);
	191	void update_triacs();
	192	void mpu3_stepper_reset();
	193	void ic11_update(mpu3_state *state);
	194	void ic21_output(mpu3_state *state,int data);
	195	void ic21_setup(mpu3_state *state);
	196	void mpu3_config_common();
191	197	};
192	198
193	199	#define DISPLAY_PORT 0
r21026	r21027
195	201	#define BWB_FUNCTIONALITY 2
196	202
197	203
198		static void update_triacs(running_machine &machine)
	204	void mpu3_state::update_triacs()
199	205	{
200		mpu3_state *state = machine.driver_data<mpu3_state>();
201	206	int i,triacdata;
202	207
203		triacdata=state->m_triac_ic3 + (state->m_triac_ic4 << 8) + (state->m_triac_ic5 << 9);
	208	triacdata=m_triac_ic3 + (m_triac_ic4 << 8) + (m_triac_ic5 << 9);
204	209
205	210	for (i = 0; i < 8; i++)
206	211	{
r21026	r21027
209	214	}
210	215
211	216	/* called if board is reset */
212		static void mpu3_stepper_reset(running_machine &machine)
	217	void mpu3_state::mpu3_stepper_reset()
213	218	{
214		mpu3_state *state = machine.driver_data<mpu3_state>();
215	219	int pattern = 0,reel;
216	220	for (reel = 0; reel < 6; reel++)
217	221	{
218	222	stepper_reset_position(reel);
219	223	if (stepper_optic_state(reel)) pattern |= 1<<reel;
220	224	}
221		state->m_optic_pattern = pattern;
	225	m_optic_pattern = pattern;
222	226	}
223	227
224	228	void mpu3_state::machine_reset()
225	229	{
226	230	m_vfd->reset();
227	231
228		mpu3_stepper_reset(machine());
	232	mpu3_stepper_reset();
229	233
230	234	m_lamp_strobe   = 0;
231	235	m_led_strobe    = 0;
r21026	r21027
292	296
293	297	It is used as a multiplexer for the LEDs, lamp selects and inputs.*/
294	298
295		static void ic11_update(mpu3_state *state)
	299	void mpu3_state::ic11_update(mpu3_state *state)
296	300	{
297		if (!state->m_IC11G2A)
	301	if (!m_IC11G2A)
298	302	{
299		if (!state->m_IC11G2B)
	303	if (!m_IC11G2B)
300	304	{
301		if (state->m_IC11G1)
	305	if (m_IC11G1)
302	306	{
303		if ( state->m_IC11GA )  state->m_input_strobe |= 0x01;
304		else                    state->m_input_strobe &= ~0x01;
	307	if ( m_IC11GA )  m_input_strobe |= 0x01;
	308	else                    m_input_strobe &= ~0x01;
305	309
306		if ( state->m_IC11GB )  state->m_input_strobe |= 0x02;
307		else                    state->m_input_strobe &= ~0x02;
	310	if ( m_IC11GB )  m_input_strobe |= 0x02;
	311	else                    m_input_strobe &= ~0x02;
308	312
309		if ( state->m_IC11GC )  state->m_input_strobe |= 0x04;
310		else                    state->m_input_strobe &= ~0x04;
	313	if ( m_IC11GC )  m_input_strobe |= 0x04;
	314	else                    m_input_strobe &= ~0x04;
311	315	}
312	316	}
313	317	}
314	318	else
315		if ((state->m_IC11G2A)||(state->m_IC11G2B)||(!state->m_IC11G1))
	319	if ((m_IC11G2A)||(m_IC11G2B)||(!m_IC11G1))
316	320	{
317		state->m_input_strobe = 0x00;
	321	m_input_strobe = 0x00;
318	322	}
319	323	}
320	324
r21026	r21027
338	342
339	343	This seems less stable than the revised version used in MPU4
340	344	*/
341		static void ic21_output(mpu3_state *state,int data)
	345	void mpu3_state::ic21_output(mpu3_state *state,int data)
342	346	{
343		state->m_IC11G1 = data;
	347	m_IC11G1 = data;
344	348	ic11_update(state);
345	349	}
346	350
347		static void ic21_setup(mpu3_state *state)
	351	void mpu3_state::ic21_setup(mpu3_state *state)
348	352	{
349		if (state->m_IC11GA)
	353	if (m_IC11GA)
350	354	{
351	355	{
352		state->m_ic11_active=1;
	356	m_ic11_active=1;
353	357	ic21_output(state,1);
354		state->m_ic21_timer->adjust(attotime::from_nsec( (0.34 * 47 * 2200000) *(1+(1/47))));
	358	m_ic21_timer->adjust(attotime::from_nsec( (0.34 * 47 * 2200000) *(1+(1/47))));
355	359	}
356	360	}
357	361	}
r21026	r21027
783	787	};
784	788
785	789	/* Common configurations */
786		static void mpu3_config_common(running_machine &machine)
	790	void mpu3_state::mpu3_config_common()
787	791	{
788		mpu3_state *state = machine.driver_data<mpu3_state>();
789		state->m_ic21_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(mpu3_state::ic21_timeout),state));
	792	m_ic21_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(mpu3_state::ic21_timeout),this));
790	793	}
791	794
792	795	void mpu3_state::machine_start()
793	796	{
794		mpu3_config_common(machine());
	797	mpu3_config_common();
795	798
796	799	/* setup 8 mechanical meters */
797	800	MechMtr_config(machine(),8);
r21026	r21027
861	864	m_signal_50hz = m_signal_50hz?0:1;
862	865	machine().device<ptm6840_device>("ptm_ic2")->set_c1(m_signal_50hz);
863	866	machine().device<pia6821_device>("pia_ic3")->cb1_w(~m_signal_50hz);
864		update_triacs(machine());
	867	update_triacs();
865	868	}
866	869
867	870	TIMER_DEVICE_CALLBACK_MEMBER(mpu3_state::ic10_callback)

trunk/src/mame/drivers/diverboy.c

r21026	r21027
71	71	virtual void machine_start();
72	72	virtual void video_start();
73	73	UINT32 screen_update_diverboy(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	74	void draw_sprites(  bitmap_ind16 &bitmap, const rectangle &cliprect );
74	75	};
75	76
76	77
r21026	r21027
78	79	{
79	80	}
80	81
81		static void draw_sprites( running_machine& machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	82	void diverboy_state::draw_sprites(  bitmap_ind16 &bitmap, const rectangle &cliprect )
82	83	{
83		diverboy_state *state = machine.driver_data<diverboy_state>();
84		UINT16 *source = state->m_spriteram;
85		UINT16 *finish = source + (state->m_spriteram.bytes() / 2);
	84	UINT16 *source = m_spriteram;
	85	UINT16 *finish = source + (m_spriteram.bytes() / 2);
86	86
87	87	while (source < finish)
88	88	{
r21026	r21027
100	100
101	101	bank = (source[1] & 0x0002) >> 1;
102	102
103		if (!flash || (machine.primary_screen->frame_number() & 1))
	103	if (!flash || (machine().primary_screen->frame_number() & 1))
104	104	{
105		drawgfx_transpen(bitmap,cliprect,machine.gfx[bank],
	105	drawgfx_transpen(bitmap,cliprect,machine().gfx[bank],
106	106	number,
107	107	colr,
108	108	0,0,
r21026	r21027
117	117	UINT32 diverboy_state::screen_update_diverboy(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
118	118	{
119	119	//  bitmap.fill(get_black_pen(machine()), cliprect);
120		draw_sprites(machine(), bitmap, cliprect);
	120	draw_sprites(bitmap, cliprect);
121	121	return 0;
122	122	}
123	123

trunk/src/mame/drivers/atarisy4.c

r21026	r21027
60	60	DECLARE_MACHINE_RESET(airrace);
61	61	UINT32 screen_update_atarisy4(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
62	62	INTERRUPT_GEN_MEMBER(vblank_int);
	63	void image_mem_to_screen( bool clip);
	64	void draw_polygon(UINT16 color);
	65	void execute_gpu_command();
	66	inline UINT8 hex_to_ascii(UINT8 in);
	67	void load_ldafile(address_space &space, const UINT8 *file);
	68	void load_hexfile(address_space &space, const UINT8 *file);
63	69	};
64	70
65	71
r21026	r21027
207	213	return (y * 4096) + offset + x;
208	214	}
209	215
210		static void image_mem_to_screen(atarisy4_state *state, bool clip)
	216	void atarisy4_state::image_mem_to_screen(bool clip)
211	217	{
212	218	INT16 y = gpu.gr[1] - 0x200;
213	219	UINT16 h = gpu.gr[3];
r21026	r21027
230	236	{
231	237	if (x >= 0 && x <= 511)
232	238	{
233		UINT16 pix = state->m_screen_ram[xy_to_screen_addr(x,y) >> 1];
	239	UINT16 pix = m_screen_ram[xy_to_screen_addr(x,y) >> 1];
234	240
235	241	if (x & 1)
236	242	pix = (pix & (0x00ff)) | gpu.idr << 8;
237	243	else
238	244	pix = (pix & (0xff00)) | gpu.idr;
239	245
240		state->m_screen_ram[xy_to_screen_addr(x,y) >> 1] = pix;
	246	m_screen_ram[xy_to_screen_addr(x,y) >> 1] = pix;
241	247	}
242	248	++x;
243	249	}
r21026	r21027
266	272	}
267	273	}
268	274
269		static void draw_polygon(atarisy4_state *state, UINT16 color)
	275	void atarisy4_state::draw_polygon(UINT16 color)
270	276	{
271	277	int i;
272	278	rectangle clip;
273	279	poly_vertex v1, v2, v3;
274		poly_extra_data *extra = (poly_extra_data *)poly_get_extra_data(state->m_poly);
	280	poly_extra_data *extra = (poly_extra_data *)poly_get_extra_data(m_poly);
275	281
276	282	clip.set(0, 511, 0, 511);
277	283
278	284	extra->color = color;
279		extra->screen_ram = state->m_screen_ram;
	285	extra->screen_ram = m_screen_ram;
280	286
281	287	v1.x = gpu.points[0].x;
282	288	v1.y = gpu.points[0].y;
r21026	r21027
290	296	v3.x = gpu.points[i].x;
291	297	v3.y = gpu.points[i].y;
292	298
293		poly_render_triangle(state->m_poly, 0, clip, draw_scanline, 1, &v1, &v2, &v3);
	299	poly_render_triangle(m_poly, 0, clip, draw_scanline, 1, &v1, &v2, &v3);
294	300	v2 = v3;
295	301	}
296	302	}
r21026	r21027
323	329	PFVR    0x2B    Polygon vector relative
324	330	PFC     0x2C    Polygon close
325	331	*/
326		void execute_gpu_command(running_machine &machine)
	332	void atarisy4_state::execute_gpu_command()
327	333	{
328		atarisy4_state *state = machine.driver_data<atarisy4_state>();
329	334	switch (gpu.ecr)
330	335	{
331	336	case 0x04:
r21026	r21027
378	383
379	384	for (i = 0; i < gpu.gr[3]; ++i)
380	385	{
381		UINT16 val = state->m_screen_ram[offset >> 1];
	386	UINT16 val = m_screen_ram[offset >> 1];
382	387	val >>= (~offset & 1) << 3;
383	388
384	389	if (gpu.gr[4] & 0x10)
385		state->m_r_color_table[table_offs] = val;
	390	m_r_color_table[table_offs] = val;
386	391	if (gpu.gr[4] & 0x20)
387		state->m_g_color_table[table_offs] = val;
	392	m_g_color_table[table_offs] = val;
388	393	if (gpu.gr[4] & 0x40)
389		state->m_b_color_table[table_offs] = val;
	394	m_b_color_table[table_offs] = val;
390	395
391	396	/* Update */
392		palette_set_color(machine, table_offs, MAKE_RGB(state->m_r_color_table[table_offs], state->m_g_color_table[table_offs], state->m_b_color_table[table_offs]));
	397	palette_set_color(machine(), table_offs, MAKE_RGB(m_r_color_table[table_offs], m_g_color_table[table_offs], m_b_color_table[table_offs]));
393	398
394	399	++table_offs;
395	400	++offset;
r21026	r21027
399	404	}
400	405	case 0x20:
401	406	{
402		image_mem_to_screen(state, false);
	407	image_mem_to_screen(false);
403	408	break;
404	409	}
405	410	case 0x21:
406	411	{
407		image_mem_to_screen(state, true);
	412	image_mem_to_screen(true);
408	413	break;
409	414	}
410	415	case 0x28:
r21026	r21027
439	444	}
440	445	case 0x2c:
441	446	{
442		draw_polygon(state, gpu.gr[2]);
443		poly_wait(state->m_poly, "Normal");
	447	draw_polygon(gpu.gr[2]);
	448	poly_wait(m_poly, "Normal");
444	449	break;
445	450	}
446	451	default:
r21026	r21027
476	481	case 0x17:
477	482	{
478	483	gpu.ecr = data;
479		execute_gpu_command(machine());
	484	execute_gpu_command();
480	485	break;
481	486	}
482	487	case 0x1a:  gpu.far = data;     break;
r21026	r21027
795	800	*
796	801	*************************************/
797	802
798		INLINE UINT8 hex_to_ascii(UINT8 in)
	803	UINT8 atarisy4_state::hex_to_ascii(UINT8 in)
799	804	{
800	805	if (in < 0x3a)
801	806	return in - 0x30;
r21026	r21027
805	810	return in;
806	811	}
807	812
808		void load_ldafile(address_space &space, const UINT8 *file)
	813	void atarisy4_state::load_ldafile(address_space &space, const UINT8 *file)
809	814	{
810	815	#define READ_CHAR()     file[i++]
811	816	int i = 0;
r21026	r21027
859	864	}
860	865
861	866	/* Load memory space with data from a Tektronix-Extended HEX file */
862		void load_hexfile(address_space &space, const UINT8 *file)
	867	void atarisy4_state::load_hexfile(address_space &space, const UINT8 *file)
863	868	{
864	869	#define READ_HEX_CHAR()     hex_to_ascii(file[i++])
865	870

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team